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

Comparing:
trunk/configure (file contents), Revision 1188 by chuckv, Thu Nov 22 16:39:45 2007 UTC vs.
branches/development/configure (file contents), Revision 1618 by gezelter, Mon Sep 12 17:09:26 2011 UTC

# Line 1 | Line 1
1   #! /bin/sh
2   # Guess values for system-dependent variables and create Makefiles.
3 < # Generated by GNU Autoconf 2.61 for OOPSE 3.0.
3 > # Generated by GNU Autoconf 2.68 for OpenMD 1.0.
4   #
5   # Report bugs to <gezelter@nd.edu>.
6   #
7 + #
8   # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
9 < # 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
9 > # 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software
10 > # Foundation, Inc.
11 > #
12 > #
13   # This configure script is free software; the Free Software Foundation
14   # gives unlimited permission to copy, distribute and modify it.
15 < ## --------------------- ##
16 < ## M4sh Initialization.  ##
17 < ## --------------------- ##
15 > ## -------------------- ##
16 > ## M4sh Initialization. ##
17 > ## -------------------- ##
18  
19   # Be more Bourne compatible
20   DUALCASE=1; export DUALCASE # for MKS sh
21 < if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
21 > if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
22    emulate sh
23    NULLCMD=:
24 <  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
24 >  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
25    # is contrary to our usage.  Disable this feature.
26    alias -g '${1+"$@"}'='"$@"'
27    setopt NO_GLOB_SUBST
28   else
29 <  case `(set -o) 2>/dev/null` in
30 <  *posix*) set -o posix ;;
29 >  case `(set -o) 2>/dev/null` in #(
30 >  *posix*) :
31 >    set -o posix ;; #(
32 >  *) :
33 >     ;;
34   esac
28 –
35   fi
36  
37  
38 <
39 <
40 < # PATH needs CR
41 < # Avoid depending upon Character Ranges.
42 < as_cr_letters='abcdefghijklmnopqrstuvwxyz'
43 < as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
44 < as_cr_Letters=$as_cr_letters$as_cr_LETTERS
45 < as_cr_digits='0123456789'
46 < as_cr_alnum=$as_cr_Letters$as_cr_digits
47 <
48 < # The user is always right.
49 < if test "${PATH_SEPARATOR+set}" != set; then
50 <  echo "#! /bin/sh" >conf$$.sh
51 <  echo  "exit 0"   >>conf$$.sh
52 <  chmod +x conf$$.sh
53 <  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
54 <    PATH_SEPARATOR=';'
38 > as_nl='
39 > '
40 > export as_nl
41 > # Printing a long string crashes Solaris 7 /usr/bin/printf.
42 > as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
43 > as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
44 > as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
45 > # Prefer a ksh shell builtin over an external printf program on Solaris,
46 > # but without wasting forks for bash or zsh.
47 > if test -z "$BASH_VERSION$ZSH_VERSION" \
48 >    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
49 >  as_echo='print -r --'
50 >  as_echo_n='print -rn --'
51 > elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
52 >  as_echo='printf %s\n'
53 >  as_echo_n='printf %s'
54 > else
55 >  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
56 >    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
57 >    as_echo_n='/usr/ucb/echo -n'
58    else
59 <    PATH_SEPARATOR=:
59 >    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
60 >    as_echo_n_body='eval
61 >      arg=$1;
62 >      case $arg in #(
63 >      *"$as_nl"*)
64 >        expr "X$arg" : "X\\(.*\\)$as_nl";
65 >        arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
66 >      esac;
67 >      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
68 >    '
69 >    export as_echo_n_body
70 >    as_echo_n='sh -c $as_echo_n_body as_echo'
71    fi
72 <  rm -rf conf$$.sh
72 >  export as_echo_body
73 >  as_echo='sh -c $as_echo_body as_echo'
74   fi
75  
76 < # Support unset when possible.
77 < if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
78 <  as_unset=unset
79 < else
80 <  as_unset=false
76 > # The user is always right.
77 > if test "${PATH_SEPARATOR+set}" != set; then
78 >  PATH_SEPARATOR=:
79 >  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
80 >    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
81 >      PATH_SEPARATOR=';'
82 >  }
83   fi
84  
85  
# Line 65 | Line 88 | fi
88   # there to prevent editors from complaining about space-tab.
89   # (If _AS_PATH_WALK were called with IFS unset, it would disable word
90   # splitting by setting IFS to empty value.)
68 – as_nl='
69 – '
91   IFS=" ""        $as_nl"
92  
93   # Find who we are.  Look in the path if we contain no directory separator.
94 < case $0 in
94 > as_myself=
95 > case $0 in #((
96    *[\\/]* ) as_myself=$0 ;;
97    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
98   for as_dir in $PATH
99   do
100    IFS=$as_save_IFS
101    test -z "$as_dir" && as_dir=.
102 <  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
103 < done
102 >    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
103 >  done
104   IFS=$as_save_IFS
105  
106       ;;
# Line 89 | Line 111 | if test ! -f "$as_myself"; then
111    as_myself=$0
112   fi
113   if test ! -f "$as_myself"; then
114 <  echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
115 <  { (exit 1); exit 1; }
114 >  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
115 >  exit 1
116   fi
117  
118 < # Work around bugs in pre-3.0 UWIN ksh.
119 < for as_var in ENV MAIL MAILPATH
120 < do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
118 > # Unset variables that we do not need and which cause bugs (e.g. in
119 > # pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
120 > # suppresses any "Segmentation fault" message there.  '((' could
121 > # trigger a bug in pdksh 5.2.14.
122 > for as_var in BASH_ENV ENV MAIL MAILPATH
123 > do eval test x\${$as_var+set} = xset \
124 >  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
125   done
126   PS1='$ '
127   PS2='> '
128   PS4='+ '
129  
130   # NLS nuisances.
131 < for as_var in \
132 <  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
133 <  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
134 <  LC_TELEPHONE LC_TIME
109 < do
110 <  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
111 <    eval $as_var=C; export $as_var
112 <  else
113 <    ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
114 <  fi
115 < done
131 > LC_ALL=C
132 > export LC_ALL
133 > LANGUAGE=C
134 > export LANGUAGE
135  
117 – # Required to use basename.
118 – if expr a : '\(a\)' >/dev/null 2>&1 &&
119 –   test "X`expr 00001 : '.*\(...\)'`" = X001; then
120 –  as_expr=expr
121 – else
122 –  as_expr=false
123 – fi
124 –
125 – if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
126 –  as_basename=basename
127 – else
128 –  as_basename=false
129 – fi
130 –
131 –
132 – # Name of the executable.
133 – as_me=`$as_basename -- "$0" ||
134 – $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
135 –         X"$0" : 'X\(//\)$' \| \
136 –         X"$0" : 'X\(/\)' \| . 2>/dev/null ||
137 – echo X/"$0" |
138 –    sed '/^.*\/\([^/][^/]*\)\/*$/{
139 –            s//\1/
140 –            q
141 –          }
142 –          /^X\/\(\/\/\)$/{
143 –            s//\1/
144 –            q
145 –          }
146 –          /^X\/\(\/\).*/{
147 –            s//\1/
148 –            q
149 –          }
150 –          s/.*/./; q'`
151 –
136   # CDPATH.
137 < $as_unset CDPATH
137 > (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
138  
155 –
139   if test "x$CONFIG_SHELL" = x; then
140 <  if (eval ":") 2>/dev/null; then
141 <  as_have_required=yes
140 >  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
141 >  emulate sh
142 >  NULLCMD=:
143 >  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
144 >  # is contrary to our usage.  Disable this feature.
145 >  alias -g '\${1+\"\$@\"}'='\"\$@\"'
146 >  setopt NO_GLOB_SUBST
147   else
148 <  as_have_required=no
148 >  case \`(set -o) 2>/dev/null\` in #(
149 >  *posix*) :
150 >    set -o posix ;; #(
151 >  *) :
152 >     ;;
153 > esac
154   fi
155 + "
156 +  as_required="as_fn_return () { (exit \$1); }
157 + as_fn_success () { as_fn_return 0; }
158 + as_fn_failure () { as_fn_return 1; }
159 + as_fn_ret_success () { return 0; }
160 + as_fn_ret_failure () { return 1; }
161  
163 –  if test $as_have_required = yes &&     (eval ":
164 – (as_func_return () {
165 –  (exit \$1)
166 – }
167 – as_func_success () {
168 –  as_func_return 0
169 – }
170 – as_func_failure () {
171 –  as_func_return 1
172 – }
173 – as_func_ret_success () {
174 –  return 0
175 – }
176 – as_func_ret_failure () {
177 –  return 1
178 – }
179 –
162   exitcode=0
163 < if as_func_success; then
164 <  :
165 < else
166 <  exitcode=1
167 <  echo as_func_success failed.
186 < fi
163 > as_fn_success || { exitcode=1; echo as_fn_success failed.; }
164 > as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
165 > as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
166 > as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
167 > if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
168  
188 – if as_func_failure; then
189 –  exitcode=1
190 –  echo as_func_failure succeeded.
191 – fi
192 –
193 – if as_func_ret_success; then
194 –  :
169   else
170 <  exitcode=1
197 <  echo as_func_ret_success failed.
170 >  exitcode=1; echo positional parameters were not saved.
171   fi
172 <
173 < if as_func_ret_failure; then
174 <  exitcode=1
175 <  echo as_func_ret_failure succeeded.
176 < fi
177 <
178 < if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
179 <  :
172 > test x\$exitcode = x0 || exit 1"
173 >  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
174 >  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
175 >  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
176 >  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
177 > test \$(( 1 + 1 )) = 2 || exit 1"
178 >  if (eval "$as_required") 2>/dev/null; then :
179 >  as_have_required=yes
180   else
181 <  exitcode=1
209 <  echo positional parameters were not saved.
181 >  as_have_required=no
182   fi
183 +  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
184  
212 – test \$exitcode = 0) || { (exit 1); exit 1; }
213 –
214 – (
215 –  as_lineno_1=\$LINENO
216 –  as_lineno_2=\$LINENO
217 –  test \"x\$as_lineno_1\" != \"x\$as_lineno_2\" &&
218 –  test \"x\`expr \$as_lineno_1 + 1\`\" = \"x\$as_lineno_2\") || { (exit 1); exit 1; }
219 – ") 2> /dev/null; then
220 –  :
185   else
186 <  as_candidate_shells=
187 <    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
186 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
187 > as_found=false
188   for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
189   do
190    IFS=$as_save_IFS
191    test -z "$as_dir" && as_dir=.
192 <  case $as_dir in
192 >  as_found=:
193 >  case $as_dir in #(
194           /*)
195             for as_base in sh bash ksh sh5; do
196 <             as_candidate_shells="$as_candidate_shells $as_dir/$as_base"
196 >             # Try only shells that exist, to save several forks.
197 >             as_shell=$as_dir/$as_base
198 >             if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
199 >                    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
200 >  CONFIG_SHELL=$as_shell as_have_required=yes
201 >                   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
202 >  break 2
203 > fi
204 > fi
205             done;;
206         esac
207 +  as_found=false
208   done
209 + $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
210 +              { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
211 +  CONFIG_SHELL=$SHELL as_have_required=yes
212 + fi; }
213   IFS=$as_save_IFS
214  
215  
216 <      for as_shell in $as_candidate_shells $SHELL; do
217 <         # Try only shells that exist, to save several forks.
218 <         if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
219 <                { ("$as_shell") 2> /dev/null <<\_ASEOF
220 < if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
221 <  emulate sh
222 <  NULLCMD=:
223 <  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
224 <  # is contrary to our usage.  Disable this feature.
225 <  alias -g '${1+"$@"}'='"$@"'
226 <  setopt NO_GLOB_SUBST
227 < else
228 <  case `(set -o) 2>/dev/null` in
229 <  *posix*) set -o posix ;;
230 < esac
231 <
216 >      if test "x$CONFIG_SHELL" != x; then :
217 >  # We cannot yet assume a decent shell, so we have to provide a
218 >        # neutralization value for shells without unset; and this also
219 >        # works around shells that cannot unset nonexistent variables.
220 >        # Preserve -v and -x to the replacement shell.
221 >        BASH_ENV=/dev/null
222 >        ENV=/dev/null
223 >        (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
224 >        export CONFIG_SHELL
225 >        case $- in # ((((
226 >          *v*x* | *x*v* ) as_opts=-vx ;;
227 >          *v* ) as_opts=-v ;;
228 >          *x* ) as_opts=-x ;;
229 >          * ) as_opts= ;;
230 >        esac
231 >        exec "$CONFIG_SHELL" $as_opts "$as_myself" ${1+"$@"}
232   fi
233  
234 <
235 < :
236 < _ASEOF
237 < }; then
238 <  CONFIG_SHELL=$as_shell
239 <               as_have_required=yes
240 <               if { "$as_shell" 2> /dev/null <<\_ASEOF
241 < if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
242 <  emulate sh
243 <  NULLCMD=:
244 <  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
245 <  # is contrary to our usage.  Disable this feature.
246 <  alias -g '${1+"$@"}'='"$@"'
247 <  setopt NO_GLOB_SUBST
270 < else
271 <  case `(set -o) 2>/dev/null` in
272 <  *posix*) set -o posix ;;
273 < esac
274 <
234 >    if test x$as_have_required = xno; then :
235 >  $as_echo "$0: This script requires a shell more modern than all"
236 >  $as_echo "$0: the shells that I found on your system."
237 >  if test x${ZSH_VERSION+set} = xset ; then
238 >    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
239 >    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
240 >  else
241 >    $as_echo "$0: Please tell bug-autoconf@gnu.org and gezelter@nd.edu
242 > $0: about your system, including any error possibly output
243 > $0: before this message. Then install a modern shell, or
244 > $0: manually run the script under such a shell if you do
245 > $0: have one."
246 >  fi
247 >  exit 1
248   fi
276 –
277 –
278 – :
279 – (as_func_return () {
280 –  (exit $1)
281 – }
282 – as_func_success () {
283 –  as_func_return 0
284 – }
285 – as_func_failure () {
286 –  as_func_return 1
287 – }
288 – as_func_ret_success () {
289 –  return 0
290 – }
291 – as_func_ret_failure () {
292 –  return 1
293 – }
294 –
295 – exitcode=0
296 – if as_func_success; then
297 –  :
298 – else
299 –  exitcode=1
300 –  echo as_func_success failed.
249   fi
302 –
303 – if as_func_failure; then
304 –  exitcode=1
305 –  echo as_func_failure succeeded.
250   fi
251 + SHELL=${CONFIG_SHELL-/bin/sh}
252 + export SHELL
253 + # Unset more variables known to interfere with behavior of common tools.
254 + CLICOLOR_FORCE= GREP_OPTIONS=
255 + unset CLICOLOR_FORCE GREP_OPTIONS
256  
257 < if as_func_ret_success; then
258 <  :
259 < else
260 <  exitcode=1
261 <  echo as_func_ret_success failed.
262 < fi
257 > ## --------------------- ##
258 > ## M4sh Shell Functions. ##
259 > ## --------------------- ##
260 > # as_fn_unset VAR
261 > # ---------------
262 > # Portably unset VAR.
263 > as_fn_unset ()
264 > {
265 >  { eval $1=; unset $1;}
266 > }
267 > as_unset=as_fn_unset
268  
269 < if as_func_ret_failure; then
270 <  exitcode=1
271 <  echo as_func_ret_failure succeeded.
272 < fi
269 > # as_fn_set_status STATUS
270 > # -----------------------
271 > # Set $? to STATUS, without forking.
272 > as_fn_set_status ()
273 > {
274 >  return $1
275 > } # as_fn_set_status
276  
277 < if ( set x; as_func_ret_success y && test x = "$1" ); then
278 <  :
279 < else
280 <  exitcode=1
281 <  echo positional parameters were not saved.
282 < fi
277 > # as_fn_exit STATUS
278 > # -----------------
279 > # Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
280 > as_fn_exit ()
281 > {
282 >  set +e
283 >  as_fn_set_status $1
284 >  exit $1
285 > } # as_fn_exit
286  
287 < test $exitcode = 0) || { (exit 1); exit 1; }
287 > # as_fn_mkdir_p
288 > # -------------
289 > # Create "$as_dir" as a directory, including parents if necessary.
290 > as_fn_mkdir_p ()
291 > {
292  
293 < (
294 <  as_lineno_1=$LINENO
295 <  as_lineno_2=$LINENO
296 <  test "x$as_lineno_1" != "x$as_lineno_2" &&
297 <  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") || { (exit 1); exit 1; }
293 >  case $as_dir in #(
294 >  -*) as_dir=./$as_dir;;
295 >  esac
296 >  test -d "$as_dir" || eval $as_mkdir_p || {
297 >    as_dirs=
298 >    while :; do
299 >      case $as_dir in #(
300 >      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
301 >      *) as_qdir=$as_dir;;
302 >      esac
303 >      as_dirs="'$as_qdir' $as_dirs"
304 >      as_dir=`$as_dirname -- "$as_dir" ||
305 > $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
306 >         X"$as_dir" : 'X\(//\)[^/]' \| \
307 >         X"$as_dir" : 'X\(//\)$' \| \
308 >         X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
309 > $as_echo X"$as_dir" |
310 >    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
311 >            s//\1/
312 >            q
313 >          }
314 >          /^X\(\/\/\)[^/].*/{
315 >            s//\1/
316 >            q
317 >          }
318 >          /^X\(\/\/\)$/{
319 >            s//\1/
320 >            q
321 >          }
322 >          /^X\(\/\).*/{
323 >            s//\1/
324 >            q
325 >          }
326 >          s/.*/./; q'`
327 >      test -d "$as_dir" && break
328 >    done
329 >    test -z "$as_dirs" || eval "mkdir $as_dirs"
330 >  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
331  
335 – _ASEOF
336 – }; then
337 –  break
338 – fi
332  
333 < fi
333 > } # as_fn_mkdir_p
334 > # as_fn_append VAR VALUE
335 > # ----------------------
336 > # Append the text in VALUE to the end of the definition contained in VAR. Take
337 > # advantage of any shell optimizations that allow amortized linear growth over
338 > # repeated appends, instead of the typical quadratic growth present in naive
339 > # implementations.
340 > if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
341 >  eval 'as_fn_append ()
342 >  {
343 >    eval $1+=\$2
344 >  }'
345 > else
346 >  as_fn_append ()
347 >  {
348 >    eval $1=\$$1\$2
349 >  }
350 > fi # as_fn_append
351  
352 <      done
352 > # as_fn_arith ARG...
353 > # ------------------
354 > # Perform arithmetic evaluation on the ARGs, and store the result in the
355 > # global $as_val. Take advantage of shells that can avoid forks. The arguments
356 > # must be portable across $(()) and expr.
357 > if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
358 >  eval 'as_fn_arith ()
359 >  {
360 >    as_val=$(( $* ))
361 >  }'
362 > else
363 >  as_fn_arith ()
364 >  {
365 >    as_val=`expr "$@" || test $? -eq 1`
366 >  }
367 > fi # as_fn_arith
368  
344 –      if test "x$CONFIG_SHELL" != x; then
345 –  for as_var in BASH_ENV ENV
346 –        do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
347 –        done
348 –        export CONFIG_SHELL
349 –        exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
350 – fi
369  
370 + # as_fn_error STATUS ERROR [LINENO LOG_FD]
371 + # ----------------------------------------
372 + # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
373 + # provided, also output the error to LOG_FD, referencing LINENO. Then exit the
374 + # script with STATUS, using 1 if that was 0.
375 + as_fn_error ()
376 + {
377 +  as_status=$1; test $as_status -eq 0 && as_status=1
378 +  if test "$4"; then
379 +    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
380 +    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
381 +  fi
382 +  $as_echo "$as_me: error: $2" >&2
383 +  as_fn_exit $as_status
384 + } # as_fn_error
385  
386 <    if test $as_have_required = no; then
387 <  echo This script requires a shell more modern than all the
388 <      echo shells that I found on your system.  Please install a
356 <      echo modern shell, or manually run the script under such a
357 <      echo shell if you do have one.
358 <      { (exit 1); exit 1; }
359 < fi
360 <
361 <
362 < fi
363 <
364 < fi
365 <
366 <
367 <
368 < (eval "as_func_return () {
369 <  (exit \$1)
370 < }
371 < as_func_success () {
372 <  as_func_return 0
373 < }
374 < as_func_failure () {
375 <  as_func_return 1
376 < }
377 < as_func_ret_success () {
378 <  return 0
379 < }
380 < as_func_ret_failure () {
381 <  return 1
382 < }
383 <
384 < exitcode=0
385 < if as_func_success; then
386 <  :
386 > if expr a : '\(a\)' >/dev/null 2>&1 &&
387 >   test "X`expr 00001 : '.*\(...\)'`" = X001; then
388 >  as_expr=expr
389   else
390 <  exitcode=1
389 <  echo as_func_success failed.
390 >  as_expr=false
391   fi
392  
393 < if as_func_failure; then
394 <  exitcode=1
394 <  echo as_func_failure succeeded.
395 < fi
396 <
397 < if as_func_ret_success; then
398 <  :
393 > if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
394 >  as_basename=basename
395   else
396 <  exitcode=1
401 <  echo as_func_ret_success failed.
396 >  as_basename=false
397   fi
398  
399 < if as_func_ret_failure; then
400 <  exitcode=1
406 <  echo as_func_ret_failure succeeded.
407 < fi
408 <
409 < if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
410 <  :
399 > if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
400 >  as_dirname=dirname
401   else
402 <  exitcode=1
413 <  echo positional parameters were not saved.
402 >  as_dirname=false
403   fi
404  
405 < test \$exitcode = 0") || {
406 <  echo No shell found that supports shell functions.
407 <  echo Please tell autoconf@gnu.org about your system,
408 <  echo including any error possibly output before this
409 <  echo message
410 < }
405 > as_me=`$as_basename -- "$0" ||
406 > $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
407 >         X"$0" : 'X\(//\)$' \| \
408 >         X"$0" : 'X\(/\)' \| . 2>/dev/null ||
409 > $as_echo X/"$0" |
410 >    sed '/^.*\/\([^/][^/]*\)\/*$/{
411 >            s//\1/
412 >            q
413 >          }
414 >          /^X\/\(\/\/\)$/{
415 >            s//\1/
416 >            q
417 >          }
418 >          /^X\/\(\/\).*/{
419 >            s//\1/
420 >            q
421 >          }
422 >          s/.*/./; q'`
423  
424 + # Avoid depending upon Character Ranges.
425 + as_cr_letters='abcdefghijklmnopqrstuvwxyz'
426 + as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
427 + as_cr_Letters=$as_cr_letters$as_cr_LETTERS
428 + as_cr_digits='0123456789'
429 + as_cr_alnum=$as_cr_Letters$as_cr_digits
430  
431  
432 <  as_lineno_1=$LINENO
433 <  as_lineno_2=$LINENO
434 <  test "x$as_lineno_1" != "x$as_lineno_2" &&
435 <  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
436 <
430 <  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
431 <  # uniformly replaced by the line number.  The first 'sed' inserts a
432 <  # line-number line after each line using $LINENO; the second 'sed'
433 <  # does the real work.  The second script uses 'N' to pair each
434 <  # line-number line with the line containing $LINENO, and appends
435 <  # trailing '-' during substitution so that $LINENO is not a special
436 <  # case at line end.
437 <  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
438 <  # scripts with optimization help from Paolo Bonzini.  Blame Lee
439 <  # E. McMahon (1931-1989) for sed's syntax.  :-)
432 >  as_lineno_1=$LINENO as_lineno_1a=$LINENO
433 >  as_lineno_2=$LINENO as_lineno_2a=$LINENO
434 >  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
435 >  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
436 >  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
437    sed -n '
438      p
439      /[$]LINENO/=
# Line 453 | Line 450 | test \$exitcode = 0") || {
450        s/-\n.*//
451      ' >$as_me.lineno &&
452    chmod +x "$as_me.lineno" ||
453 <    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
457 <   { (exit 1); exit 1; }; }
453 >    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
454  
455    # Don't try to exec as it changes $[0], causing all sort of problems
456    # (the dirname of $[0] is not the place where we might find the
# Line 464 | Line 460 | test \$exitcode = 0") || {
460    exit
461   }
462  
467 –
468 – if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
469 –  as_dirname=dirname
470 – else
471 –  as_dirname=false
472 – fi
473 –
463   ECHO_C= ECHO_N= ECHO_T=
464 < case `echo -n x` in
464 > case `echo -n x` in #(((((
465   -n*)
466 <  case `echo 'x\c'` in
466 >  case `echo 'xy\c'` in
467    *c*) ECHO_T=' ';;     # ECHO_T is single tab character.
468 <  *)   ECHO_C='\c';;
468 >  xy)  ECHO_C='\c';;
469 >  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
470 >       ECHO_T=' ';;
471    esac;;
472   *)
473    ECHO_N='-n';;
474   esac
475  
476 < if expr a : '\(a\)' >/dev/null 2>&1 &&
486 <   test "X`expr 00001 : '.*\(...\)'`" = X001; then
487 <  as_expr=expr
488 < else
489 <  as_expr=false
490 < fi
491 <
492 < rm -rf conf$$ conf$$.exe conf$$.file
476 > rm -f conf$$ conf$$.exe conf$$.file
477   if test -d conf$$.dir; then
478 <  rm -rf conf$$.dir/conf$$.file
478 >  rm -f conf$$.dir/conf$$.file
479   else
480 <  rm -rf conf$$.dir
481 <  mkdir conf$$.dir
480 >  rm -f conf$$.dir
481 >  mkdir conf$$.dir 2>/dev/null
482   fi
483 < echo >conf$$.file
484 < if ln -s conf$$.file conf$$ 2>/dev/null; then
485 <  as_ln_s='ln -s'
486 <  # ... but there are two gotchas:
487 <  # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
488 <  # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
489 <  # In both cases, we have to default to `cp -p'.
490 <  ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
483 > if (echo >conf$$.file) 2>/dev/null; then
484 >  if ln -s conf$$.file conf$$ 2>/dev/null; then
485 >    as_ln_s='ln -s'
486 >    # ... but there are two gotchas:
487 >    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
488 >    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
489 >    # In both cases, we have to default to `cp -p'.
490 >    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
491 >      as_ln_s='cp -p'
492 >  elif ln conf$$.file conf$$ 2>/dev/null; then
493 >    as_ln_s=ln
494 >  else
495      as_ln_s='cp -p'
496 < elif ln conf$$.file conf$$ 2>/dev/null; then
509 <  as_ln_s=ln
496 >  fi
497   else
498    as_ln_s='cp -p'
499   fi
500 < rm -rf conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
500 > rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
501   rmdir conf$$.dir 2>/dev/null
502  
503   if mkdir -p . 2>/dev/null; then
504 <  as_mkdir_p=:
504 >  as_mkdir_p='mkdir -p "$as_dir"'
505   else
506    test -d ./-p && rmdir ./-p
507    as_mkdir_p=false
# Line 531 | Line 518 | else
518    as_test_x='
519      eval sh -c '\''
520        if test -d "$1"; then
521 <        test -d "$1/.";
521 >        test -d "$1/.";
522        else
523 <        case $1 in
524 <        -*)set "./$1";;
523 >        case $1 in #(
524 >        -*)set "./$1";;
525          esac;
526 <        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
526 >        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
527          ???[sx]*):;;*)false;;esac;fi
528      '\'' sh
529    '
# Line 550 | Line 537 | as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
537   as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
538  
539  
540 + test -n "$DJDIR" || exec 7<&0 </dev/null
541 + exec 6>&1
542  
554 – exec 7<&0 </dev/null 6>&1
555 –
543   # Name of the host.
544 < # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
544 > # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
545   # so uname gets run too.
546   ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
547  
# Line 569 | Line 556 | MAKEFLAGS=
556   subdirs=
557   MFLAGS=
558   MAKEFLAGS=
572 – SHELL=${CONFIG_SHELL-/bin/sh}
559  
560   # Identity of this package.
561 < PACKAGE_NAME='OOPSE'
562 < PACKAGE_TARNAME='oopse'
563 < PACKAGE_VERSION='3.0'
564 < PACKAGE_STRING='OOPSE 3.0'
561 > PACKAGE_NAME='OpenMD'
562 > PACKAGE_TARNAME='openmd'
563 > PACKAGE_VERSION='1.0'
564 > PACKAGE_STRING='OpenMD 1.0'
565   PACKAGE_BUGREPORT='gezelter@nd.edu'
566 + PACKAGE_URL=''
567  
568 < ac_unique_file="src/applications/oopse/oopse.cpp"
568 > ac_unique_file="src/applications/openmd/openmd.cpp"
569   ac_default_prefix="/usr/local"
570   # Factoring default headers for most tests.
571   ac_includes_default="\
# Line 616 | Line 603 | ac_includes_default="\
603   # include <unistd.h>
604   #endif"
605  
606 < ac_subst_vars='SHELL
607 < PATH_SEPARATOR
608 < PACKAGE_NAME
609 < PACKAGE_TARNAME
610 < PACKAGE_VERSION
611 < PACKAGE_STRING
612 < PACKAGE_BUGREPORT
613 < exec_prefix
614 < prefix
615 < program_transform_name
616 < bindir
617 < sbindir
631 < libexecdir
632 < datarootdir
633 < datadir
634 < sysconfdir
635 < sharedstatedir
636 < localstatedir
637 < includedir
638 < oldincludedir
639 < docdir
640 < infodir
641 < htmldir
642 < dvidir
643 < pdfdir
644 < psdir
645 < libdir
646 < localedir
647 < mandir
648 < DEFS
649 < ECHO_C
650 < ECHO_N
651 < ECHO_T
652 < LIBS
653 < build_alias
654 < host_alias
655 < target_alias
656 < build
657 < build_cpu
658 < build_vendor
659 < build_os
660 < host
661 < host_cpu
662 < host_vendor
663 < host_os
664 < PROGNAME
665 < debug
666 < USE_SINGLE_PRECISION
667 < CXX
668 < CXXFLAGS
669 < LDFLAGS
670 < CPPFLAGS
671 < ac_ct_CXX
672 < EXEEXT
673 < OBJEXT
674 < CC
675 < CFLAGS
676 < ac_ct_CC
677 < FC
678 < FCFLAGS
679 < ac_ct_FC
680 < CPP
681 < GREP
682 < EGREP
683 < LN_S
684 < SET_MAKE
685 < RANLIB
686 < PERLINTERP
687 < PERL_SHEBANG
688 < INSTALL_PROGRAM
689 < INSTALL_SCRIPT
690 < INSTALL_DATA
691 < AR
692 < PS
693 < FCFLAGS_F90
694 < FCFLAGS_SRCEXT
695 < PREPDEFFLAG
696 < FCLIBS
697 < FC_FUNC
698 < FC_FUNC_
699 < MOD
700 < F90_WORK_FILES_ARG
701 < MODDIRFLAG
702 < F90MODINCSPEC
703 < F90_MODULE_NAMES
704 < ZLIB_INC_DIR
705 < ZLIB_LIB_DIR
706 < ZLIB
707 < FFTW_INC_DIR
708 < FFTW_LIB_DIR
709 < FFTW_LIBS
710 < LIBOBJS
606 > ac_subst_vars='LTLIBOBJS
607 > SUBDIRS
608 > OPENMD_HOME
609 > OPENMD
610 > MKINSTALLDIRS
611 > BATEXT
612 > enable_latex_docs
613 > enable_html_docs
614 > enable_dot
615 > DOC
616 > DOT
617 > DOXYGEN
618   POW_LIB
619 + LIBOBJS
620 + USE_OPENBABEL
621 + OPENBABEL_LIB
622 + OPENBABEL_LIB_DIR
623 + OPENBABEL_INC_DIR
624   CXXCPP
625 < __func__
626 < MPI_LIB_DIR
627 < MPI_INC_DIR
628 < MPI_F90_INC
629 < MPI_LIB
630 < MPI_F90_LIB
625 > USE_QHULL
626 > QHULL
627 > QHULL_LIB_DIR
628 > QHULL_INC_DIR
629 > FFTW_LIBS
630 > FFTW_LIB_DIR
631 > FFTW_INC_DIR
632 > ZLIB
633 > ZLIB_LIB_DIR
634 > ZLIB_INC_DIR
635 > PS
636 > AR
637 > INSTALL_DATA
638 > INSTALL_SCRIPT
639 > INSTALL_PROGRAM
640 > PERL_SHEBANG
641 > PERLINTERP
642 > RANLIB
643 > SET_MAKE
644 > LN_S
645 > EGREP
646 > GREP
647 > CPP
648   USE_MPI
649 < DOXYGEN
650 < DOT
651 < DOC
649 > MPICC
650 > MPILIBS
651 > MPICXX
652 > LIBDL
653 > ac_ct_CC
654 > CFLAGS
655 > CC
656 > OBJEXT
657 > EXEEXT
658 > ac_ct_CXX
659 > CPPFLAGS
660 > LDFLAGS
661 > CXXFLAGS
662 > CXX
663 > USE_SINGLE_PRECISION
664 > debug
665 > PROGNAME
666 > host_os
667 > host_vendor
668 > host_cpu
669 > host
670 > build_os
671 > build_vendor
672 > build_cpu
673 > build
674 > target_alias
675 > host_alias
676 > build_alias
677 > LIBS
678 > ECHO_T
679 > ECHO_N
680 > ECHO_C
681 > DEFS
682 > mandir
683 > localedir
684 > libdir
685 > psdir
686 > pdfdir
687 > dvidir
688 > htmldir
689 > infodir
690 > docdir
691 > oldincludedir
692 > includedir
693 > localstatedir
694 > sharedstatedir
695 > sysconfdir
696 > datadir
697 > datarootdir
698 > libexecdir
699 > sbindir
700 > bindir
701 > program_transform_name
702 > prefix
703 > exec_prefix
704 > PACKAGE_URL
705 > PACKAGE_BUGREPORT
706 > PACKAGE_STRING
707 > PACKAGE_VERSION
708 > PACKAGE_TARNAME
709 > PACKAGE_NAME
710 > PATH_SEPARATOR
711 > SHELL'
712 > ac_subst_files=''
713 > ac_user_opts='
714 > enable_option_checking
715 > enable_openmd_home
716 > enable_debug
717 > enable_single
718 > enable_float
719 > with_perl_shebang
720 > with_zlib
721 > with_fftw
722 > with_qhull
723 > with_openbabel
724 > enable_doxygen
725   enable_dot
726   enable_html_docs
727   enable_latex_docs
728 < BATEXT
727 < MKINSTALLDIRS
728 < OOPSE
729 < OOPSE_HOME
730 < SUBDIRS
731 < LTLIBOBJS'
732 < ac_subst_files=''
728 > '
729        ac_precious_vars='build_alias
730   host_alias
731   target_alias
# Line 741 | Line 737 | CFLAGS
737   CCC
738   CC
739   CFLAGS
740 < FC
741 < FCFLAGS
740 > MPICXX
741 > MPICC
742   CPP
743   CXXCPP'
744  
# Line 750 | Line 746 | ac_init_version=false
746   # Initialize some variables set by options.
747   ac_init_help=
748   ac_init_version=false
749 + ac_unrecognized_opts=
750 + ac_unrecognized_sep=
751   # The variables have the same names as the options, with
752   # dashes changed to underlines.
753   cache_file=/dev/null
# Line 805 | Line 803 | do
803    fi
804  
805    case $ac_option in
806 <  *=*)  ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
807 <  *)    ac_optarg=yes ;;
806 >  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
807 >  *=)   ac_optarg= ;;
808 >  *)    ac_optarg=yes ;;
809    esac
810  
811    # Accept the important Cygnus configure options, so we can diagnose typos.
# Line 848 | Line 847 | do
847      datarootdir=$ac_optarg ;;
848  
849    -disable-* | --disable-*)
850 <    ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
850 >    ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
851      # Reject names that are not valid shell variable names.
852 <    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
853 <      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
854 <   { (exit 1); exit 1; }; }
855 <    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
856 <    eval enable_$ac_feature=no ;;
852 >    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
853 >      as_fn_error $? "invalid feature name: $ac_useropt"
854 >    ac_useropt_orig=$ac_useropt
855 >    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
856 >    case $ac_user_opts in
857 >      *"
858 > "enable_$ac_useropt"
859 > "*) ;;
860 >      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
861 >         ac_unrecognized_sep=', ';;
862 >    esac
863 >    eval enable_$ac_useropt=no ;;
864  
865    -docdir | --docdir | --docdi | --doc | --do)
866      ac_prev=docdir ;;
# Line 867 | Line 873 | do
873      dvidir=$ac_optarg ;;
874  
875    -enable-* | --enable-*)
876 <    ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
876 >    ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
877      # Reject names that are not valid shell variable names.
878 <    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
879 <      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
880 <   { (exit 1); exit 1; }; }
881 <    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
882 <    eval enable_$ac_feature=\$ac_optarg ;;
878 >    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
879 >      as_fn_error $? "invalid feature name: $ac_useropt"
880 >    ac_useropt_orig=$ac_useropt
881 >    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
882 >    case $ac_user_opts in
883 >      *"
884 > "enable_$ac_useropt"
885 > "*) ;;
886 >      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
887 >         ac_unrecognized_sep=', ';;
888 >    esac
889 >    eval enable_$ac_useropt=\$ac_optarg ;;
890  
891    -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
892    | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
# Line 1064 | Line 1077 | do
1077      ac_init_version=: ;;
1078  
1079    -with-* | --with-*)
1080 <    ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1080 >    ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1081      # Reject names that are not valid shell variable names.
1082 <    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1083 <      { echo "$as_me: error: invalid package name: $ac_package" >&2
1084 <   { (exit 1); exit 1; }; }
1085 <    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
1086 <    eval with_$ac_package=\$ac_optarg ;;
1082 >    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1083 >      as_fn_error $? "invalid package name: $ac_useropt"
1084 >    ac_useropt_orig=$ac_useropt
1085 >    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1086 >    case $ac_user_opts in
1087 >      *"
1088 > "with_$ac_useropt"
1089 > "*) ;;
1090 >      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
1091 >         ac_unrecognized_sep=', ';;
1092 >    esac
1093 >    eval with_$ac_useropt=\$ac_optarg ;;
1094  
1095    -without-* | --without-*)
1096 <    ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1096 >    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1097      # Reject names that are not valid shell variable names.
1098 <    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1099 <      { echo "$as_me: error: invalid package name: $ac_package" >&2
1100 <   { (exit 1); exit 1; }; }
1101 <    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
1102 <    eval with_$ac_package=no ;;
1098 >    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1099 >      as_fn_error $? "invalid package name: $ac_useropt"
1100 >    ac_useropt_orig=$ac_useropt
1101 >    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1102 >    case $ac_user_opts in
1103 >      *"
1104 > "with_$ac_useropt"
1105 > "*) ;;
1106 >      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
1107 >         ac_unrecognized_sep=', ';;
1108 >    esac
1109 >    eval with_$ac_useropt=no ;;
1110  
1111    --x)
1112      # Obsolete; use --with-x.
# Line 1099 | Line 1126 | do
1126    | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
1127      x_libraries=$ac_optarg ;;
1128  
1129 <  -*) { echo "$as_me: error: unrecognized option: $ac_option
1130 < Try \`$0 --help' for more information." >&2
1104 <   { (exit 1); exit 1; }; }
1129 >  -*) as_fn_error $? "unrecognized option: \`$ac_option'
1130 > Try \`$0 --help' for more information"
1131      ;;
1132  
1133    *=*)
1134      ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
1135      # Reject names that are not valid shell variable names.
1136 <    expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
1137 <      { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
1138 <   { (exit 1); exit 1; }; }
1136 >    case $ac_envvar in #(
1137 >      '' | [0-9]* | *[!_$as_cr_alnum]* )
1138 >      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
1139 >    esac
1140      eval $ac_envvar=\$ac_optarg
1141      export $ac_envvar ;;
1142  
1143    *)
1144      # FIXME: should be removed in autoconf 3.0.
1145 <    echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1145 >    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1146      expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1147 <      echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1148 <    : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
1147 >      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1148 >    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
1149      ;;
1150  
1151    esac
# Line 1126 | Line 1153 | if test -n "$ac_prev"; then
1153  
1154   if test -n "$ac_prev"; then
1155    ac_option=--`echo $ac_prev | sed 's/_/-/g'`
1156 <  { echo "$as_me: error: missing argument to $ac_option" >&2
1130 <   { (exit 1); exit 1; }; }
1156 >  as_fn_error $? "missing argument to $ac_option"
1157   fi
1158  
1159 < # Be sure to have absolute directory names.
1159 > if test -n "$ac_unrecognized_opts"; then
1160 >  case $enable_option_checking in
1161 >    no) ;;
1162 >    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
1163 >    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
1164 >  esac
1165 > fi
1166 >
1167 > # Check all directory arguments for consistency.
1168   for ac_var in   exec_prefix prefix bindir sbindir libexecdir datarootdir \
1169                  datadir sysconfdir sharedstatedir localstatedir includedir \
1170                  oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
1171                  libdir localedir mandir
1172   do
1173    eval ac_val=\$$ac_var
1174 +  # Remove trailing slashes.
1175    case $ac_val in
1176 +    */ )
1177 +      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
1178 +      eval $ac_var=\$ac_val;;
1179 +  esac
1180 +  # Be sure to have absolute directory names.
1181 +  case $ac_val in
1182      [\\/$]* | ?:[\\/]* )  continue;;
1183      NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
1184    esac
1185 <  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
1145 <   { (exit 1); exit 1; }; }
1185 >  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
1186   done
1187  
1188   # There might be people who depend on the old broken behavior: `$host'
# Line 1156 | Line 1196 | if test "x$host_alias" != x; then
1196   if test "x$host_alias" != x; then
1197    if test "x$build_alias" = x; then
1198      cross_compiling=maybe
1199 <    echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
1200 <    If a cross compiler is detected then cross compile mode will be used." >&2
1199 >    $as_echo "$as_me: WARNING: if you wanted to set the --build type, don't use --host.
1200 >    If a cross compiler is detected then cross compile mode will be used" >&2
1201    elif test "x$build_alias" != "x$host_alias"; then
1202      cross_compiling=yes
1203    fi
# Line 1172 | Line 1212 | ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1212   ac_pwd=`pwd` && test -n "$ac_pwd" &&
1213   ac_ls_di=`ls -di .` &&
1214   ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1215 <  { echo "$as_me: error: Working directory cannot be determined" >&2
1176 <   { (exit 1); exit 1; }; }
1215 >  as_fn_error $? "working directory cannot be determined"
1216   test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
1217 <  { echo "$as_me: error: pwd does not report name of working directory" >&2
1179 <   { (exit 1); exit 1; }; }
1217 >  as_fn_error $? "pwd does not report name of working directory"
1218  
1219  
1220   # Find the source files, if location was not specified.
1221   if test -z "$srcdir"; then
1222    ac_srcdir_defaulted=yes
1223    # Try the directory containing this script, then the parent directory.
1224 <  ac_confdir=`$as_dirname -- "$0" ||
1225 < $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
1226 <         X"$0" : 'X\(//\)[^/]' \| \
1227 <         X"$0" : 'X\(//\)$' \| \
1228 <         X"$0" : 'X\(/\)' \| . 2>/dev/null ||
1229 < echo X"$0" |
1224 >  ac_confdir=`$as_dirname -- "$as_myself" ||
1225 > $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
1226 >         X"$as_myself" : 'X\(//\)[^/]' \| \
1227 >         X"$as_myself" : 'X\(//\)$' \| \
1228 >         X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
1229 > $as_echo X"$as_myself" |
1230      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
1231              s//\1/
1232              q
# Line 1215 | Line 1253 | if test ! -r "$srcdir/$ac_unique_file"; then
1253   fi
1254   if test ! -r "$srcdir/$ac_unique_file"; then
1255    test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
1256 <  { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
1219 <   { (exit 1); exit 1; }; }
1256 >  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
1257   fi
1258   ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
1259   ac_abs_confdir=`(
1260 <        cd "$srcdir" && test -r "./$ac_unique_file" || { echo "$as_me: error: $ac_msg" >&2
1224 <   { (exit 1); exit 1; }; }
1260 >        cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
1261          pwd)`
1262   # When building in place, set srcdir=.
1263   if test "$ac_abs_confdir" = "$ac_pwd"; then
# Line 1247 | Line 1283 | if test "$ac_init_help" = "long"; then
1283    # Omit some internal or obsolete options to make the list less imposing.
1284    # This message is too long to be a string in the A/UX 3.1 sh.
1285    cat <<_ACEOF
1286 < \`configure' configures OOPSE 3.0 to adapt to many kinds of systems.
1286 > \`configure' configures OpenMD 1.0 to adapt to many kinds of systems.
1287  
1288   Usage: $0 [OPTION]... [VAR=VALUE]...
1289  
# Line 1261 | Line 1297 | Configuration:
1297        --help=short        display options specific to this package
1298        --help=recursive    display the short help of all the included packages
1299    -V, --version           display version information and exit
1300 <  -q, --quiet, --silent   do not print \`checking...' messages
1300 >  -q, --quiet, --silent   do not print \`checking ...' messages
1301        --cache-file=FILE   cache test results in FILE [disabled]
1302    -C, --config-cache      alias for \`--cache-file=config.cache'
1303    -n, --no-create         do not create output files
# Line 1269 | Line 1305 | Installation directories:
1305  
1306   Installation directories:
1307    --prefix=PREFIX         install architecture-independent files in PREFIX
1308 <                          [$ac_default_prefix]
1308 >                          [$ac_default_prefix]
1309    --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
1310 <                          [PREFIX]
1310 >                          [PREFIX]
1311  
1312   By default, \`make install' will install all the files in
1313   \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
# Line 1281 | Line 1317 | Fine tuning of the installation directories:
1317   For better control, use the options below.
1318  
1319   Fine tuning of the installation directories:
1320 <  --bindir=DIR           user executables [EPREFIX/bin]
1321 <  --sbindir=DIR          system admin executables [EPREFIX/sbin]
1322 <  --libexecdir=DIR       program executables [EPREFIX/libexec]
1323 <  --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
1324 <  --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
1325 <  --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
1326 <  --libdir=DIR           object code libraries [EPREFIX/lib]
1327 <  --includedir=DIR       C header files [PREFIX/include]
1328 <  --oldincludedir=DIR    C header files for non-gcc [/usr/include]
1329 <  --datarootdir=DIR      read-only arch.-independent data root [PREFIX/share]
1330 <  --datadir=DIR          read-only architecture-independent data [DATAROOTDIR]
1331 <  --infodir=DIR          info documentation [DATAROOTDIR/info]
1332 <  --localedir=DIR        locale-dependent data [DATAROOTDIR/locale]
1333 <  --mandir=DIR           man documentation [DATAROOTDIR/man]
1334 <  --docdir=DIR           documentation root [DATAROOTDIR/doc/oopse]
1335 <  --htmldir=DIR          html documentation [DOCDIR]
1336 <  --dvidir=DIR           dvi documentation [DOCDIR]
1337 <  --pdfdir=DIR           pdf documentation [DOCDIR]
1338 <  --psdir=DIR            ps documentation [DOCDIR]
1320 >  --bindir=DIR            user executables [EPREFIX/bin]
1321 >  --sbindir=DIR           system admin executables [EPREFIX/sbin]
1322 >  --libexecdir=DIR        program executables [EPREFIX/libexec]
1323 >  --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
1324 >  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
1325 >  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
1326 >  --libdir=DIR            object code libraries [EPREFIX/lib]
1327 >  --includedir=DIR        C header files [PREFIX/include]
1328 >  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
1329 >  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
1330 >  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
1331 >  --infodir=DIR           info documentation [DATAROOTDIR/info]
1332 >  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
1333 >  --mandir=DIR            man documentation [DATAROOTDIR/man]
1334 >  --docdir=DIR            documentation root [DATAROOTDIR/doc/openmd]
1335 >  --htmldir=DIR           html documentation [DOCDIR]
1336 >  --dvidir=DIR            dvi documentation [DOCDIR]
1337 >  --pdfdir=DIR            pdf documentation [DOCDIR]
1338 >  --psdir=DIR             ps documentation [DOCDIR]
1339   _ACEOF
1340  
1341    cat <<\_ACEOF
# Line 1312 | Line 1348 | if test -n "$ac_init_help"; then
1348  
1349   if test -n "$ac_init_help"; then
1350    case $ac_init_help in
1351 <     short | recursive ) echo "Configuration of OOPSE 3.0:";;
1351 >     short | recursive ) echo "Configuration of OpenMD 1.0:";;
1352     esac
1353    cat <<\_ACEOF
1354  
1355   Optional Features:
1356 +  --disable-option-checking  ignore unrecognized --enable/--with options
1357    --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
1358    --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
1359 <  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
1360 <  --enable-debug          Compile OOPSE in debug mode
1361 <  --enable-single         compile OOPSE in single precision
1359 >  --enable-openmd-home=DIR      define OpenMD home dir PREFIX/openmd
1360 >  --enable-debug          Compile OpenMD in debug mode
1361 >  --enable-single         compile OpenMD in single precision
1362    --enable-float          synonym for --enable-single
1363    --enable-doxygen        enable documentation generation with doxygen (auto)
1364    --enable-dot            use 'dot' to generate graphs in doxygen (auto)
# Line 1337 | Line 1374 | Optional Packages:
1374                            to /usr/local or /usr if not found in /usr/local)
1375    --with-fftw=DIR         root directory path of fftw installation (defaults
1376                            to /usr/local or /usr if not found in /usr/local)
1377 <  --with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
1377 >  --with-qhull=DIR        root directory path of qhull installation (defaults
1378 >                          to /usr/local or /usr if not found in /usr/local)
1379 >  --with-openbabel=DIR    root directory path of openbabel-2.x installation
1380 >                          (defaults to /usr/local or /usr if not found in
1381 >                          /usr/local)
1382  
1383   Some influential environment variables:
1384    CXX         C++ compiler command
# Line 1345 | Line 1386 | Some influential environment variables:
1386    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
1387                nonstandard directory <lib dir>
1388    LIBS        libraries to pass to the linker, e.g. -l<library>
1389 <  CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
1389 >  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
1390                you have headers in a nonstandard directory <include dir>
1391    CC          C compiler command
1392    CFLAGS      C compiler flags
1393 <  FC          Fortran compiler command
1394 <  FCFLAGS     Fortran compiler flags
1393 >  MPICXX      MPI C++ compiler command
1394 >  MPICC       MPI C compiler command
1395    CPP         C preprocessor
1396    CXXCPP      C++ preprocessor
1397  
# Line 1365 | Line 1406 | if test "$ac_init_help" = "recursive"; then
1406   if test "$ac_init_help" = "recursive"; then
1407    # If there are subdirs, report their specific --help.
1408    for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1409 <    test -d "$ac_dir" || continue
1409 >    test -d "$ac_dir" ||
1410 >      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
1411 >      continue
1412      ac_builddir=.
1413  
1414   case "$ac_dir" in
1415   .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
1416   *)
1417 <  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1417 >  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
1418    # A ".." for each directory in $ac_dir_suffix.
1419 <  ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`
1419 >  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
1420    case $ac_top_builddir_sub in
1421    "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
1422    *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
# Line 1409 | Line 1452 | ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
1452        echo &&
1453        $SHELL "$ac_srcdir/configure" --help=recursive
1454      else
1455 <      echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1455 >      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1456      fi || ac_status=$?
1457      cd "$ac_pwd" || { ac_status=$?; break; }
1458    done
# Line 1418 | Line 1461 | if $ac_init_version; then
1461   test -n "$ac_init_help" && exit $ac_status
1462   if $ac_init_version; then
1463    cat <<\_ACEOF
1464 < OOPSE configure 3.0
1465 < generated by GNU Autoconf 2.61
1464 > OpenMD configure 1.0
1465 > generated by GNU Autoconf 2.68
1466  
1467 < Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
1425 < 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
1467 > Copyright (C) 2010 Free Software Foundation, Inc.
1468   This configure script is free software; the Free Software Foundation
1469   gives unlimited permission to copy, distribute and modify it.
1470   _ACEOF
1471    exit
1472 + fi
1473 +
1474 + ## ------------------------ ##
1475 + ## Autoconf initialization. ##
1476 + ## ------------------------ ##
1477 +
1478 + # ac_fn_cxx_try_compile LINENO
1479 + # ----------------------------
1480 + # Try to compile conftest.$ac_ext, and return whether this succeeded.
1481 + ac_fn_cxx_try_compile ()
1482 + {
1483 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1484 +  rm -f conftest.$ac_objext
1485 +  if { { ac_try="$ac_compile"
1486 + case "(($ac_try" in
1487 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1488 +  *) ac_try_echo=$ac_try;;
1489 + esac
1490 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1491 + $as_echo "$ac_try_echo"; } >&5
1492 +  (eval "$ac_compile") 2>conftest.err
1493 +  ac_status=$?
1494 +  if test -s conftest.err; then
1495 +    grep -v '^ *+' conftest.err >conftest.er1
1496 +    cat conftest.er1 >&5
1497 +    mv -f conftest.er1 conftest.err
1498 +  fi
1499 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1500 +  test $ac_status = 0; } && {
1501 +         test -z "$ac_cxx_werror_flag" ||
1502 +         test ! -s conftest.err
1503 +       } && test -s conftest.$ac_objext; then :
1504 +  ac_retval=0
1505 + else
1506 +  $as_echo "$as_me: failed program was:" >&5
1507 + sed 's/^/| /' conftest.$ac_ext >&5
1508 +
1509 +        ac_retval=1
1510 + fi
1511 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1512 +  as_fn_set_status $ac_retval
1513 +
1514 + } # ac_fn_cxx_try_compile
1515 +
1516 + # ac_fn_c_try_compile LINENO
1517 + # --------------------------
1518 + # Try to compile conftest.$ac_ext, and return whether this succeeded.
1519 + ac_fn_c_try_compile ()
1520 + {
1521 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1522 +  rm -f conftest.$ac_objext
1523 +  if { { ac_try="$ac_compile"
1524 + case "(($ac_try" in
1525 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1526 +  *) ac_try_echo=$ac_try;;
1527 + esac
1528 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1529 + $as_echo "$ac_try_echo"; } >&5
1530 +  (eval "$ac_compile") 2>conftest.err
1531 +  ac_status=$?
1532 +  if test -s conftest.err; then
1533 +    grep -v '^ *+' conftest.err >conftest.er1
1534 +    cat conftest.er1 >&5
1535 +    mv -f conftest.er1 conftest.err
1536 +  fi
1537 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1538 +  test $ac_status = 0; } && {
1539 +         test -z "$ac_c_werror_flag" ||
1540 +         test ! -s conftest.err
1541 +       } && test -s conftest.$ac_objext; then :
1542 +  ac_retval=0
1543 + else
1544 +  $as_echo "$as_me: failed program was:" >&5
1545 + sed 's/^/| /' conftest.$ac_ext >&5
1546 +
1547 +        ac_retval=1
1548 + fi
1549 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1550 +  as_fn_set_status $ac_retval
1551 +
1552 + } # ac_fn_c_try_compile
1553 +
1554 + # ac_fn_cxx_try_link LINENO
1555 + # -------------------------
1556 + # Try to link conftest.$ac_ext, and return whether this succeeded.
1557 + ac_fn_cxx_try_link ()
1558 + {
1559 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1560 +  rm -f conftest.$ac_objext conftest$ac_exeext
1561 +  if { { ac_try="$ac_link"
1562 + case "(($ac_try" in
1563 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1564 +  *) ac_try_echo=$ac_try;;
1565 + esac
1566 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1567 + $as_echo "$ac_try_echo"; } >&5
1568 +  (eval "$ac_link") 2>conftest.err
1569 +  ac_status=$?
1570 +  if test -s conftest.err; then
1571 +    grep -v '^ *+' conftest.err >conftest.er1
1572 +    cat conftest.er1 >&5
1573 +    mv -f conftest.er1 conftest.err
1574 +  fi
1575 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1576 +  test $ac_status = 0; } && {
1577 +         test -z "$ac_cxx_werror_flag" ||
1578 +         test ! -s conftest.err
1579 +       } && test -s conftest$ac_exeext && {
1580 +         test "$cross_compiling" = yes ||
1581 +         $as_test_x conftest$ac_exeext
1582 +       }; then :
1583 +  ac_retval=0
1584 + else
1585 +  $as_echo "$as_me: failed program was:" >&5
1586 + sed 's/^/| /' conftest.$ac_ext >&5
1587 +
1588 +        ac_retval=1
1589   fi
1590 +  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
1591 +  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
1592 +  # interfere with the next link command; also delete a directory that is
1593 +  # left behind by Apple's compiler.  We do this before executing the actions.
1594 +  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1595 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1596 +  as_fn_set_status $ac_retval
1597 +
1598 + } # ac_fn_cxx_try_link
1599 +
1600 + # ac_fn_cxx_check_func LINENO FUNC VAR
1601 + # ------------------------------------
1602 + # Tests whether FUNC exists, setting the cache variable VAR accordingly
1603 + ac_fn_cxx_check_func ()
1604 + {
1605 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1606 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1607 + $as_echo_n "checking for $2... " >&6; }
1608 + if eval \${$3+:} false; then :
1609 +  $as_echo_n "(cached) " >&6
1610 + else
1611 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1612 + /* end confdefs.h.  */
1613 + /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
1614 +   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
1615 + #define $2 innocuous_$2
1616 +
1617 + /* System header to define __stub macros and hopefully few prototypes,
1618 +    which can conflict with char $2 (); below.
1619 +    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
1620 +    <limits.h> exists even on freestanding compilers.  */
1621 +
1622 + #ifdef __STDC__
1623 + # include <limits.h>
1624 + #else
1625 + # include <assert.h>
1626 + #endif
1627 +
1628 + #undef $2
1629 +
1630 + /* Override any GCC internal prototype to avoid an error.
1631 +   Use char because int might match the return type of a GCC
1632 +   builtin and then its argument prototype would still apply.  */
1633 + #ifdef __cplusplus
1634 + extern "C"
1635 + #endif
1636 + char $2 ();
1637 + /* The GNU C library defines this for functions which it implements
1638 +    to always fail with ENOSYS.  Some functions are actually named
1639 +    something starting with __ and the normal name is an alias.  */
1640 + #if defined __stub_$2 || defined __stub___$2
1641 + choke me
1642 + #endif
1643 +
1644 + int
1645 + main ()
1646 + {
1647 + return $2 ();
1648 +  ;
1649 +  return 0;
1650 + }
1651 + _ACEOF
1652 + if ac_fn_cxx_try_link "$LINENO"; then :
1653 +  eval "$3=yes"
1654 + else
1655 +  eval "$3=no"
1656 + fi
1657 + rm -f core conftest.err conftest.$ac_objext \
1658 +    conftest$ac_exeext conftest.$ac_ext
1659 + fi
1660 + eval ac_res=\$$3
1661 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1662 + $as_echo "$ac_res" >&6; }
1663 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1664 +
1665 + } # ac_fn_cxx_check_func
1666 +
1667 + # ac_fn_c_try_link LINENO
1668 + # -----------------------
1669 + # Try to link conftest.$ac_ext, and return whether this succeeded.
1670 + ac_fn_c_try_link ()
1671 + {
1672 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1673 +  rm -f conftest.$ac_objext conftest$ac_exeext
1674 +  if { { ac_try="$ac_link"
1675 + case "(($ac_try" in
1676 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1677 +  *) ac_try_echo=$ac_try;;
1678 + esac
1679 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1680 + $as_echo "$ac_try_echo"; } >&5
1681 +  (eval "$ac_link") 2>conftest.err
1682 +  ac_status=$?
1683 +  if test -s conftest.err; then
1684 +    grep -v '^ *+' conftest.err >conftest.er1
1685 +    cat conftest.er1 >&5
1686 +    mv -f conftest.er1 conftest.err
1687 +  fi
1688 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1689 +  test $ac_status = 0; } && {
1690 +         test -z "$ac_c_werror_flag" ||
1691 +         test ! -s conftest.err
1692 +       } && test -s conftest$ac_exeext && {
1693 +         test "$cross_compiling" = yes ||
1694 +         $as_test_x conftest$ac_exeext
1695 +       }; then :
1696 +  ac_retval=0
1697 + else
1698 +  $as_echo "$as_me: failed program was:" >&5
1699 + sed 's/^/| /' conftest.$ac_ext >&5
1700 +
1701 +        ac_retval=1
1702 + fi
1703 +  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
1704 +  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
1705 +  # interfere with the next link command; also delete a directory that is
1706 +  # left behind by Apple's compiler.  We do this before executing the actions.
1707 +  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1708 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1709 +  as_fn_set_status $ac_retval
1710 +
1711 + } # ac_fn_c_try_link
1712 +
1713 + # ac_fn_c_check_func LINENO FUNC VAR
1714 + # ----------------------------------
1715 + # Tests whether FUNC exists, setting the cache variable VAR accordingly
1716 + ac_fn_c_check_func ()
1717 + {
1718 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1719 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1720 + $as_echo_n "checking for $2... " >&6; }
1721 + if eval \${$3+:} false; then :
1722 +  $as_echo_n "(cached) " >&6
1723 + else
1724 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1725 + /* end confdefs.h.  */
1726 + /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
1727 +   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
1728 + #define $2 innocuous_$2
1729 +
1730 + /* System header to define __stub macros and hopefully few prototypes,
1731 +    which can conflict with char $2 (); below.
1732 +    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
1733 +    <limits.h> exists even on freestanding compilers.  */
1734 +
1735 + #ifdef __STDC__
1736 + # include <limits.h>
1737 + #else
1738 + # include <assert.h>
1739 + #endif
1740 +
1741 + #undef $2
1742 +
1743 + /* Override any GCC internal prototype to avoid an error.
1744 +   Use char because int might match the return type of a GCC
1745 +   builtin and then its argument prototype would still apply.  */
1746 + #ifdef __cplusplus
1747 + extern "C"
1748 + #endif
1749 + char $2 ();
1750 + /* The GNU C library defines this for functions which it implements
1751 +    to always fail with ENOSYS.  Some functions are actually named
1752 +    something starting with __ and the normal name is an alias.  */
1753 + #if defined __stub_$2 || defined __stub___$2
1754 + choke me
1755 + #endif
1756 +
1757 + int
1758 + main ()
1759 + {
1760 + return $2 ();
1761 +  ;
1762 +  return 0;
1763 + }
1764 + _ACEOF
1765 + if ac_fn_c_try_link "$LINENO"; then :
1766 +  eval "$3=yes"
1767 + else
1768 +  eval "$3=no"
1769 + fi
1770 + rm -f core conftest.err conftest.$ac_objext \
1771 +    conftest$ac_exeext conftest.$ac_ext
1772 + fi
1773 + eval ac_res=\$$3
1774 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1775 + $as_echo "$ac_res" >&6; }
1776 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1777 +
1778 + } # ac_fn_c_check_func
1779 +
1780 + # ac_fn_c_try_cpp LINENO
1781 + # ----------------------
1782 + # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
1783 + ac_fn_c_try_cpp ()
1784 + {
1785 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1786 +  if { { ac_try="$ac_cpp conftest.$ac_ext"
1787 + case "(($ac_try" in
1788 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1789 +  *) ac_try_echo=$ac_try;;
1790 + esac
1791 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1792 + $as_echo "$ac_try_echo"; } >&5
1793 +  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
1794 +  ac_status=$?
1795 +  if test -s conftest.err; then
1796 +    grep -v '^ *+' conftest.err >conftest.er1
1797 +    cat conftest.er1 >&5
1798 +    mv -f conftest.er1 conftest.err
1799 +  fi
1800 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1801 +  test $ac_status = 0; } > conftest.i && {
1802 +         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
1803 +         test ! -s conftest.err
1804 +       }; then :
1805 +  ac_retval=0
1806 + else
1807 +  $as_echo "$as_me: failed program was:" >&5
1808 + sed 's/^/| /' conftest.$ac_ext >&5
1809 +
1810 +    ac_retval=1
1811 + fi
1812 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1813 +  as_fn_set_status $ac_retval
1814 +
1815 + } # ac_fn_c_try_cpp
1816 +
1817 + # ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
1818 + # -------------------------------------------------------
1819 + # Tests whether HEADER exists, giving a warning if it cannot be compiled using
1820 + # the include files in INCLUDES and setting the cache variable VAR
1821 + # accordingly.
1822 + ac_fn_c_check_header_mongrel ()
1823 + {
1824 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1825 +  if eval \${$3+:} false; then :
1826 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1827 + $as_echo_n "checking for $2... " >&6; }
1828 + if eval \${$3+:} false; then :
1829 +  $as_echo_n "(cached) " >&6
1830 + fi
1831 + eval ac_res=\$$3
1832 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1833 + $as_echo "$ac_res" >&6; }
1834 + else
1835 +  # Is the header compilable?
1836 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
1837 + $as_echo_n "checking $2 usability... " >&6; }
1838 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1839 + /* end confdefs.h.  */
1840 + $4
1841 + #include <$2>
1842 + _ACEOF
1843 + if ac_fn_c_try_compile "$LINENO"; then :
1844 +  ac_header_compiler=yes
1845 + else
1846 +  ac_header_compiler=no
1847 + fi
1848 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1849 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
1850 + $as_echo "$ac_header_compiler" >&6; }
1851 +
1852 + # Is the header present?
1853 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
1854 + $as_echo_n "checking $2 presence... " >&6; }
1855 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1856 + /* end confdefs.h.  */
1857 + #include <$2>
1858 + _ACEOF
1859 + if ac_fn_c_try_cpp "$LINENO"; then :
1860 +  ac_header_preproc=yes
1861 + else
1862 +  ac_header_preproc=no
1863 + fi
1864 + rm -f conftest.err conftest.i conftest.$ac_ext
1865 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
1866 + $as_echo "$ac_header_preproc" >&6; }
1867 +
1868 + # So?  What about this header?
1869 + case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
1870 +  yes:no: )
1871 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
1872 + $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
1873 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
1874 + $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
1875 +    ;;
1876 +  no:yes:* )
1877 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
1878 + $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
1879 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
1880 + $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
1881 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
1882 + $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
1883 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
1884 + $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
1885 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
1886 + $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
1887 + ( $as_echo "## ------------------------------ ##
1888 + ## Report this to gezelter@nd.edu ##
1889 + ## ------------------------------ ##"
1890 +     ) | sed "s/^/$as_me: WARNING:     /" >&2
1891 +    ;;
1892 + esac
1893 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1894 + $as_echo_n "checking for $2... " >&6; }
1895 + if eval \${$3+:} false; then :
1896 +  $as_echo_n "(cached) " >&6
1897 + else
1898 +  eval "$3=\$ac_header_compiler"
1899 + fi
1900 + eval ac_res=\$$3
1901 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1902 + $as_echo "$ac_res" >&6; }
1903 + fi
1904 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1905 +
1906 + } # ac_fn_c_check_header_mongrel
1907 +
1908 + # ac_fn_c_try_run LINENO
1909 + # ----------------------
1910 + # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
1911 + # that executables *can* be run.
1912 + ac_fn_c_try_run ()
1913 + {
1914 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1915 +  if { { ac_try="$ac_link"
1916 + case "(($ac_try" in
1917 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1918 +  *) ac_try_echo=$ac_try;;
1919 + esac
1920 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1921 + $as_echo "$ac_try_echo"; } >&5
1922 +  (eval "$ac_link") 2>&5
1923 +  ac_status=$?
1924 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1925 +  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
1926 +  { { case "(($ac_try" in
1927 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1928 +  *) ac_try_echo=$ac_try;;
1929 + esac
1930 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1931 + $as_echo "$ac_try_echo"; } >&5
1932 +  (eval "$ac_try") 2>&5
1933 +  ac_status=$?
1934 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1935 +  test $ac_status = 0; }; }; then :
1936 +  ac_retval=0
1937 + else
1938 +  $as_echo "$as_me: program exited with status $ac_status" >&5
1939 +       $as_echo "$as_me: failed program was:" >&5
1940 + sed 's/^/| /' conftest.$ac_ext >&5
1941 +
1942 +       ac_retval=$ac_status
1943 + fi
1944 +  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1945 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1946 +  as_fn_set_status $ac_retval
1947 +
1948 + } # ac_fn_c_try_run
1949 +
1950 + # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
1951 + # -------------------------------------------------------
1952 + # Tests whether HEADER exists and can be compiled using the include files in
1953 + # INCLUDES, setting the cache variable VAR accordingly.
1954 + ac_fn_c_check_header_compile ()
1955 + {
1956 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1957 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1958 + $as_echo_n "checking for $2... " >&6; }
1959 + if eval \${$3+:} false; then :
1960 +  $as_echo_n "(cached) " >&6
1961 + else
1962 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1963 + /* end confdefs.h.  */
1964 + $4
1965 + #include <$2>
1966 + _ACEOF
1967 + if ac_fn_c_try_compile "$LINENO"; then :
1968 +  eval "$3=yes"
1969 + else
1970 +  eval "$3=no"
1971 + fi
1972 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1973 + fi
1974 + eval ac_res=\$$3
1975 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1976 + $as_echo "$ac_res" >&6; }
1977 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1978 +
1979 + } # ac_fn_c_check_header_compile
1980 +
1981 + # ac_fn_cxx_try_cpp LINENO
1982 + # ------------------------
1983 + # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
1984 + ac_fn_cxx_try_cpp ()
1985 + {
1986 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1987 +  if { { ac_try="$ac_cpp conftest.$ac_ext"
1988 + case "(($ac_try" in
1989 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1990 +  *) ac_try_echo=$ac_try;;
1991 + esac
1992 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1993 + $as_echo "$ac_try_echo"; } >&5
1994 +  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
1995 +  ac_status=$?
1996 +  if test -s conftest.err; then
1997 +    grep -v '^ *+' conftest.err >conftest.er1
1998 +    cat conftest.er1 >&5
1999 +    mv -f conftest.er1 conftest.err
2000 +  fi
2001 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2002 +  test $ac_status = 0; } > conftest.i && {
2003 +         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2004 +         test ! -s conftest.err
2005 +       }; then :
2006 +  ac_retval=0
2007 + else
2008 +  $as_echo "$as_me: failed program was:" >&5
2009 + sed 's/^/| /' conftest.$ac_ext >&5
2010 +
2011 +    ac_retval=1
2012 + fi
2013 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2014 +  as_fn_set_status $ac_retval
2015 +
2016 + } # ac_fn_cxx_try_cpp
2017 +
2018 + # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2019 + # ---------------------------------------------------------
2020 + # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2021 + # the include files in INCLUDES and setting the cache variable VAR
2022 + # accordingly.
2023 + ac_fn_cxx_check_header_mongrel ()
2024 + {
2025 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2026 +  if eval \${$3+:} false; then :
2027 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2028 + $as_echo_n "checking for $2... " >&6; }
2029 + if eval \${$3+:} false; then :
2030 +  $as_echo_n "(cached) " >&6
2031 + fi
2032 + eval ac_res=\$$3
2033 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2034 + $as_echo "$ac_res" >&6; }
2035 + else
2036 +  # Is the header compilable?
2037 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2038 + $as_echo_n "checking $2 usability... " >&6; }
2039 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2040 + /* end confdefs.h.  */
2041 + $4
2042 + #include <$2>
2043 + _ACEOF
2044 + if ac_fn_cxx_try_compile "$LINENO"; then :
2045 +  ac_header_compiler=yes
2046 + else
2047 +  ac_header_compiler=no
2048 + fi
2049 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2050 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2051 + $as_echo "$ac_header_compiler" >&6; }
2052 +
2053 + # Is the header present?
2054 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2055 + $as_echo_n "checking $2 presence... " >&6; }
2056 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2057 + /* end confdefs.h.  */
2058 + #include <$2>
2059 + _ACEOF
2060 + if ac_fn_cxx_try_cpp "$LINENO"; then :
2061 +  ac_header_preproc=yes
2062 + else
2063 +  ac_header_preproc=no
2064 + fi
2065 + rm -f conftest.err conftest.i conftest.$ac_ext
2066 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2067 + $as_echo "$ac_header_preproc" >&6; }
2068 +
2069 + # So?  What about this header?
2070 + case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2071 +  yes:no: )
2072 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2073 + $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2074 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2075 + $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2076 +    ;;
2077 +  no:yes:* )
2078 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2079 + $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2080 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
2081 + $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
2082 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2083 + $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2084 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
2085 + $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
2086 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2087 + $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2088 + ( $as_echo "## ------------------------------ ##
2089 + ## Report this to gezelter@nd.edu ##
2090 + ## ------------------------------ ##"
2091 +     ) | sed "s/^/$as_me: WARNING:     /" >&2
2092 +    ;;
2093 + esac
2094 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2095 + $as_echo_n "checking for $2... " >&6; }
2096 + if eval \${$3+:} false; then :
2097 +  $as_echo_n "(cached) " >&6
2098 + else
2099 +  eval "$3=\$ac_header_compiler"
2100 + fi
2101 + eval ac_res=\$$3
2102 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2103 + $as_echo "$ac_res" >&6; }
2104 + fi
2105 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2106 +
2107 + } # ac_fn_cxx_check_header_mongrel
2108 +
2109 + # ac_fn_c_check_type LINENO TYPE VAR INCLUDES
2110 + # -------------------------------------------
2111 + # Tests whether TYPE exists after having included INCLUDES, setting cache
2112 + # variable VAR accordingly.
2113 + ac_fn_c_check_type ()
2114 + {
2115 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2116 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2117 + $as_echo_n "checking for $2... " >&6; }
2118 + if eval \${$3+:} false; then :
2119 +  $as_echo_n "(cached) " >&6
2120 + else
2121 +  eval "$3=no"
2122 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2123 + /* end confdefs.h.  */
2124 + $4
2125 + int
2126 + main ()
2127 + {
2128 + if (sizeof ($2))
2129 +         return 0;
2130 +  ;
2131 +  return 0;
2132 + }
2133 + _ACEOF
2134 + if ac_fn_c_try_compile "$LINENO"; then :
2135 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2136 + /* end confdefs.h.  */
2137 + $4
2138 + int
2139 + main ()
2140 + {
2141 + if (sizeof (($2)))
2142 +            return 0;
2143 +  ;
2144 +  return 0;
2145 + }
2146 + _ACEOF
2147 + if ac_fn_c_try_compile "$LINENO"; then :
2148 +
2149 + else
2150 +  eval "$3=yes"
2151 + fi
2152 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2153 + fi
2154 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2155 + fi
2156 + eval ac_res=\$$3
2157 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2158 + $as_echo "$ac_res" >&6; }
2159 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2160 +
2161 + } # ac_fn_c_check_type
2162   cat >config.log <<_ACEOF
2163   This file contains any messages produced by compilers while
2164   running configure, to aid debugging if configure makes a mistake.
2165  
2166 < It was created by OOPSE $as_me 3.0, which was
2167 < generated by GNU Autoconf 2.61.  Invocation command line was
2166 > It was created by OpenMD $as_me 1.0, which was
2167 > generated by GNU Autoconf 2.68.  Invocation command line was
2168  
2169    $ $0 $@
2170  
# Line 1469 | Line 2200 | do
2200   do
2201    IFS=$as_save_IFS
2202    test -z "$as_dir" && as_dir=.
2203 <  echo "PATH: $as_dir"
2204 < done
2203 >    $as_echo "PATH: $as_dir"
2204 >  done
2205   IFS=$as_save_IFS
2206  
2207   } >&5
# Line 1504 | Line 2235 | do
2235      | -silent | --silent | --silen | --sile | --sil)
2236        continue ;;
2237      *\'*)
2238 <      ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
2238 >      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
2239      esac
2240      case $ac_pass in
2241 <    1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
2241 >    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
2242      2)
2243 <      ac_configure_args1="$ac_configure_args1 '$ac_arg'"
2243 >      as_fn_append ac_configure_args1 " '$ac_arg'"
2244        if test $ac_must_keep_next = true; then
2245          ac_must_keep_next=false # Got value, back to normal.
2246        else
# Line 1525 | Line 2256 | do
2256            -* ) ac_must_keep_next=true ;;
2257          esac
2258        fi
2259 <      ac_configure_args="$ac_configure_args '$ac_arg'"
2259 >      as_fn_append ac_configure_args " '$ac_arg'"
2260        ;;
2261      esac
2262    done
2263   done
2264 < $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
2265 < $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
2264 > { ac_configure_args0=; unset ac_configure_args0;}
2265 > { ac_configure_args1=; unset ac_configure_args1;}
2266  
2267   # When interrupted or exit'd, cleanup temporary files, and complete
2268   # config.log.  We remove comments because anyway the quotes in there
# Line 1543 | Line 2274 | trap 'exit_status=$?
2274    {
2275      echo
2276  
2277 <    cat <<\_ASBOX
1547 < ## ---------------- ##
2277 >    $as_echo "## ---------------- ##
2278   ## Cache variables. ##
2279 < ## ---------------- ##
1550 < _ASBOX
2279 > ## ---------------- ##"
2280      echo
2281      # The following way of writing the cache mishandles newlines in values,
2282   (
# Line 1556 | Line 2285 | _ASBOX
2285      case $ac_val in #(
2286      *${as_nl}*)
2287        case $ac_var in #(
2288 <      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
2289 < echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
2288 >      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
2289 > $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
2290        esac
2291        case $ac_var in #(
2292        _ | IFS | as_nl) ;; #(
2293 <      *) $as_unset $ac_var ;;
2293 >      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
2294 >      *) { eval $ac_var=; unset $ac_var;} ;;
2295        esac ;;
2296      esac
2297    done
# Line 1580 | Line 2310 | echo "$as_me: WARNING: Cache variable $ac_var contains
2310   )
2311      echo
2312  
2313 <    cat <<\_ASBOX
1584 < ## ----------------- ##
2313 >    $as_echo "## ----------------- ##
2314   ## Output variables. ##
2315 < ## ----------------- ##
1587 < _ASBOX
2315 > ## ----------------- ##"
2316      echo
2317      for ac_var in $ac_subst_vars
2318      do
2319        eval ac_val=\$$ac_var
2320        case $ac_val in
2321 <      *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
2321 >      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
2322        esac
2323 <      echo "$ac_var='\''$ac_val'\''"
2323 >      $as_echo "$ac_var='\''$ac_val'\''"
2324      done | sort
2325      echo
2326  
2327      if test -n "$ac_subst_files"; then
2328 <      cat <<\_ASBOX
1601 < ## ------------------- ##
2328 >      $as_echo "## ------------------- ##
2329   ## File substitutions. ##
2330 < ## ------------------- ##
1604 < _ASBOX
2330 > ## ------------------- ##"
2331        echo
2332        for ac_var in $ac_subst_files
2333        do
2334          eval ac_val=\$$ac_var
2335          case $ac_val in
2336 <        *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
2336 >        *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
2337          esac
2338 <        echo "$ac_var='\''$ac_val'\''"
2338 >        $as_echo "$ac_var='\''$ac_val'\''"
2339        done | sort
2340        echo
2341      fi
2342  
2343      if test -s confdefs.h; then
2344 <      cat <<\_ASBOX
1619 < ## ----------- ##
2344 >      $as_echo "## ----------- ##
2345   ## confdefs.h. ##
2346 < ## ----------- ##
1622 < _ASBOX
2346 > ## ----------- ##"
2347        echo
2348        cat confdefs.h
2349        echo
2350      fi
2351      test "$ac_signal" != 0 &&
2352 <      echo "$as_me: caught signal $ac_signal"
2353 <    echo "$as_me: exit $exit_status"
2352 >      $as_echo "$as_me: caught signal $ac_signal"
2353 >    $as_echo "$as_me: exit $exit_status"
2354    } >&5
2355 <  rm -rf core *.core core.conftest.* &&
2355 >  rm -f core *.core core.conftest.* &&
2356      rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
2357      exit $exit_status
2358   ' 0
2359   for ac_signal in 1 2 13 15; do
2360 <  trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
2360 >  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
2361   done
2362   ac_signal=0
2363  
2364   # confdefs.h avoids OS command line length limits that DEFS can exceed.
2365   rm -f -r conftest* confdefs.h
2366  
2367 + $as_echo "/* confdefs.h */" > confdefs.h
2368 +
2369   # Predefined preprocessor variables.
2370  
2371   cat >>confdefs.h <<_ACEOF
2372   #define PACKAGE_NAME "$PACKAGE_NAME"
2373   _ACEOF
2374  
1649 –
2375   cat >>confdefs.h <<_ACEOF
2376   #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
2377   _ACEOF
2378  
1654 –
2379   cat >>confdefs.h <<_ACEOF
2380   #define PACKAGE_VERSION "$PACKAGE_VERSION"
2381   _ACEOF
2382  
1659 –
2383   cat >>confdefs.h <<_ACEOF
2384   #define PACKAGE_STRING "$PACKAGE_STRING"
2385   _ACEOF
2386  
1664 –
2387   cat >>confdefs.h <<_ACEOF
2388   #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
2389   _ACEOF
2390  
2391 + cat >>confdefs.h <<_ACEOF
2392 + #define PACKAGE_URL "$PACKAGE_URL"
2393 + _ACEOF
2394  
2395 +
2396   # Let the site file select an alternate cache file if it wants to.
2397 < # Prefer explicitly selected file to automatically selected ones.
2397 > # Prefer an explicitly selected file to automatically selected ones.
2398 > ac_site_file1=NONE
2399 > ac_site_file2=NONE
2400   if test -n "$CONFIG_SITE"; then
2401 <  set x "$CONFIG_SITE"
2401 >  # We do not want a PATH search for config.site.
2402 >  case $CONFIG_SITE in #((
2403 >    -*)  ac_site_file1=./$CONFIG_SITE;;
2404 >    */*) ac_site_file1=$CONFIG_SITE;;
2405 >    *)   ac_site_file1=./$CONFIG_SITE;;
2406 >  esac
2407   elif test "x$prefix" != xNONE; then
2408 <  set x "$prefix/share/config.site" "$prefix/etc/config.site"
2408 >  ac_site_file1=$prefix/share/config.site
2409 >  ac_site_file2=$prefix/etc/config.site
2410   else
2411 <  set x "$ac_default_prefix/share/config.site" \
2412 <        "$ac_default_prefix/etc/config.site"
2411 >  ac_site_file1=$ac_default_prefix/share/config.site
2412 >  ac_site_file2=$ac_default_prefix/etc/config.site
2413   fi
2414 < shift
1681 < for ac_site_file
2414 > for ac_site_file in "$ac_site_file1" "$ac_site_file2"
2415   do
2416 <  if test -r "$ac_site_file"; then
2417 <    { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
2418 < echo "$as_me: loading site script $ac_site_file" >&6;}
2416 >  test "x$ac_site_file" = xNONE && continue
2417 >  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
2418 >    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
2419 > $as_echo "$as_me: loading site script $ac_site_file" >&6;}
2420      sed 's/^/| /' "$ac_site_file" >&5
2421 <    . "$ac_site_file"
2421 >    . "$ac_site_file" \
2422 >      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
2423 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
2424 > as_fn_error $? "failed to load site script $ac_site_file
2425 > See \`config.log' for more details" "$LINENO" 5; }
2426    fi
2427   done
2428  
2429   if test -r "$cache_file"; then
2430 <  # Some versions of bash will fail to source /dev/null (special
2431 <  # files actually), so we avoid doing that.
2432 <  if test -f "$cache_file"; then
2433 <    { echo "$as_me:$LINENO: loading cache $cache_file" >&5
2434 < echo "$as_me: loading cache $cache_file" >&6;}
2430 >  # Some versions of bash will fail to source /dev/null (special files
2431 >  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
2432 >  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
2433 >    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
2434 > $as_echo "$as_me: loading cache $cache_file" >&6;}
2435      case $cache_file in
2436        [\\/]* | ?:[\\/]* ) . "$cache_file";;
2437        *)                      . "./$cache_file";;
2438      esac
2439    fi
2440   else
2441 <  { echo "$as_me:$LINENO: creating cache $cache_file" >&5
2442 < echo "$as_me: creating cache $cache_file" >&6;}
2441 >  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
2442 > $as_echo "$as_me: creating cache $cache_file" >&6;}
2443    >$cache_file
2444   fi
2445  
# Line 1715 | Line 2453 | for ac_var in $ac_precious_vars; do
2453    eval ac_new_val=\$ac_env_${ac_var}_value
2454    case $ac_old_set,$ac_new_set in
2455      set,)
2456 <      { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
2457 < echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
2456 >      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
2457 > $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
2458        ac_cache_corrupted=: ;;
2459      ,set)
2460 <      { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
2461 < echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
2460 >      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
2461 > $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
2462        ac_cache_corrupted=: ;;
2463      ,);;
2464      *)
2465        if test "x$ac_old_val" != "x$ac_new_val"; then
2466 <        { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
2467 < echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
2468 <        { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
2469 < echo "$as_me:   former value:  $ac_old_val" >&2;}
2470 <        { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
2471 < echo "$as_me:   current value: $ac_new_val" >&2;}
2472 <        ac_cache_corrupted=:
2466 >        # differences in whitespace do not lead to failure.
2467 >        ac_old_val_w=`echo x $ac_old_val`
2468 >        ac_new_val_w=`echo x $ac_new_val`
2469 >        if test "$ac_old_val_w" != "$ac_new_val_w"; then
2470 >          { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
2471 > $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
2472 >          ac_cache_corrupted=:
2473 >        else
2474 >          { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
2475 > $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
2476 >          eval $ac_var=\$ac_old_val
2477 >        fi
2478 >        { $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
2479 > $as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
2480 >        { $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
2481 > $as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
2482        fi;;
2483    esac
2484    # Pass precious variables to config.status.
2485    if test "$ac_new_set" = set; then
2486      case $ac_new_val in
2487 <    *\'*) ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
2487 >    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
2488      *) ac_arg=$ac_var=$ac_new_val ;;
2489      esac
2490      case " $ac_configure_args " in
2491        *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
2492 <      *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
2492 >      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
2493      esac
2494    fi
2495   done
2496   if $ac_cache_corrupted; then
2497 <  { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
2498 < echo "$as_me: error: changes in the environment can compromise the build" >&2;}
2499 <  { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
2500 < echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
2501 <   { (exit 1); exit 1; }; }
2497 >  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
2498 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
2499 >  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
2500 > $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
2501 >  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
2502   fi
2503 + ## -------------------- ##
2504 + ## Main body of script. ##
2505 + ## -------------------- ##
2506  
1757 –
1758 –
1759 –
1760 –
1761 –
1762 –
1763 –
1764 –
1765 –
1766 –
1767 –
1768 –
1769 –
1770 –
1771 –
1772 –
1773 –
1774 –
1775 –
1776 –
1777 –
1778 –
1779 –
1780 –
2507   ac_ext=c
2508   ac_cpp='$CPP $CPPFLAGS'
2509   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 1802 | Line 2528 | if test -z "$ac_aux_dir"; then
2528    fi
2529   done
2530   if test -z "$ac_aux_dir"; then
2531 <  { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in ac-tools \"$srcdir\"/ac-tools" >&5
1806 < echo "$as_me: error: cannot find install-sh or install.sh in ac-tools \"$srcdir\"/ac-tools" >&2;}
1807 <   { (exit 1); exit 1; }; }
2531 >  as_fn_error $? "cannot find install-sh, install.sh, or shtool in ac-tools \"$srcdir\"/ac-tools" "$LINENO" 5
2532   fi
2533  
2534   # These three variables are undocumented and unsupported,
# Line 1847 | Line 2571 | ac_config_headers="$ac_config_headers src/config.h"
2571  
2572  
2573  
2574 + #
2575 + #
2576 + #
2577  
2578  
2579  
# Line 1862 | Line 2589 | ac_config_headers="$ac_config_headers src/config.h"
2589  
2590  
2591  
1865 – #
1866 – #
1867 – #
2592  
2593  
2594  
2595  
2596  
2597  
1874 – # AC_F90_MODULE_NAMES
1875 – # -------------------
1876 – #
1877 – # Figure out how the Fortran 90 compiler constructs module file names
1878 – #
1879 – # AC_F90_MODULE_NAMES
2598  
2599  
2600  
# Line 1953 | Line 2671 | ac_config_headers="$ac_config_headers src/config.h"
2671  
2672  
2673  
2674 + # ===========================================================================
2675 + #             http://www.nongnu.org/autoconf-archive/ax_mpi.html
2676 + # ===========================================================================
2677 + #
2678 + # SYNOPSIS
2679 + #
2680 + #   AX_MPI([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
2681 + #
2682 + # DESCRIPTION
2683 + #
2684 + #   This macro tries to find out how to compile programs that use MPI
2685 + #   (Message Passing Interface), a standard API for parallel process
2686 + #   communication (see http://www-unix.mcs.anl.gov/mpi/)
2687 + #
2688 + #   On success, it sets the MPICC, MPICXX, MPIF77, or MPIFC output variable
2689 + #   to the name of the MPI compiler, depending upon the current language.
2690 + #   (This may just be $CC/$CXX/$F77/$FC, but is more often something like
2691 + #   mpicc/mpiCC/mpif77/mpif90.) It also sets MPILIBS to any libraries that
2692 + #   are needed for linking MPI (e.g. -lmpi or -lfmpi, if a special
2693 + #   MPICC/MPICXX/MPIF77/MPIFC was not found).
2694 + #
2695 + #   If you want to compile everything with MPI, you should set:
2696 + #
2697 + #       CC="MPICC" #OR# CXX="MPICXX" #OR# F77="MPIF77" #OR# FC="MPIFC"
2698 + #       LIBS="$MPILIBS $LIBS"
2699 + #
2700 + #   NOTE: The above assumes that you will use $CC (or whatever) for linking
2701 + #   as well as for compiling. (This is the default for automake and most
2702 + #   Makefiles.)
2703 + #
2704 + #   The user can force a particular library/compiler by setting the
2705 + #   MPICC/MPICXX/MPIF77/MPIFC and/or MPILIBS environment variables.
2706 + #
2707 + #   ACTION-IF-FOUND is a list of shell commands to run if an MPI library is
2708 + #   found, and ACTION-IF-NOT-FOUND is a list of commands to run if it is not
2709 + #   found. If ACTION-IF-FOUND is not specified, the default action will
2710 + #   define HAVE_MPI.
2711 + #
2712 + # LICENSE
2713 + #
2714 + #   Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
2715 + #   Copyright (c) 2008 Julian C. Cummings <cummings@cacr.caltech.edu>
2716 + #
2717 + #   This program is free software: you can redistribute it and/or modify it
2718 + #   under the terms of the GNU General Public License as published by the
2719 + #   Free Software Foundation, either version 3 of the License, or (at your
2720 + #   option) any later version.
2721 + #
2722 + #   This program is distributed in the hope that it will be useful, but
2723 + #   WITHOUT ANY WARRANTY; without even the implied warranty of
2724 + #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
2725 + #   Public License for more details.
2726 + #
2727 + #   You should have received a copy of the GNU General Public License along
2728 + #   with this program. If not, see <http://www.gnu.org/licenses/>.
2729 + #
2730 + #   As a special exception, the respective Autoconf Macro's copyright owner
2731 + #   gives unlimited permission to copy, distribute and modify the configure
2732 + #   scripts that are the output of Autoconf when processing the Macro. You
2733 + #   need not follow the terms of the GNU General Public License when using
2734 + #   or distributing such scripts, even though portions of the text of the
2735 + #   Macro appear in them. The GNU General Public License (GPL) does govern
2736 + #   all other use of the material that constitutes the Autoconf Macro.
2737 + #
2738 + #   This special exception to the GPL applies to versions of the Autoconf
2739 + #   Macro released by the Autoconf Archive. When you make and distribute a
2740 + #   modified version of the Autoconf Macro, you may extend this special
2741 + #   exception to the GPL to apply to your modified version as well.
2742  
2743 + # This is what autoupdate's m4 run will expand.  It fires
2744 + # the warning (with _au_warn_XXX), outputs it into the
2745 + # updated configure.ac (with AC_DIAGNOSE), and then outputs
2746 + # the replacement expansion.
2747  
2748  
2749 + # This is an auxiliary macro that is also run when
2750 + # autoupdate runs m4.  It simply calls m4_warning, but
2751 + # we need a wrapper so that each warning is emitted only
2752 + # once.  We break the quoting in m4_warning's argument in
2753 + # order to expand this macro's arguments, not AU_DEFUN's.
2754  
2755  
2756 + # Finally, this is the expansion that is picked up by
2757 + # autoconf.  It tells the user to run autoupdate, and
2758 + # then outputs the replacement expansion.  We do not care
2759 + # about autoupdate's warning because that contains
2760 + # information on what to do *after* running autoupdate.
2761  
2762  
2763  
1964 –
1965 –
1966 –
1967 –
2764   # who am i
2765   # Make sure we can run config.sub.
2766   $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
2767 <  { { echo "$as_me:$LINENO: error: cannot run $SHELL $ac_aux_dir/config.sub" >&5
1972 < echo "$as_me: error: cannot run $SHELL $ac_aux_dir/config.sub" >&2;}
1973 <   { (exit 1); exit 1; }; }
2767 >  as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
2768  
2769 < { echo "$as_me:$LINENO: checking build system type" >&5
2770 < echo $ECHO_N "checking build system type... $ECHO_C" >&6; }
2771 < if test "${ac_cv_build+set}" = set; then
2772 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2769 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
2770 > $as_echo_n "checking build system type... " >&6; }
2771 > if ${ac_cv_build+:} false; then :
2772 >  $as_echo_n "(cached) " >&6
2773   else
2774    ac_build_alias=$build_alias
2775   test "x$ac_build_alias" = x &&
2776    ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
2777   test "x$ac_build_alias" = x &&
2778 <  { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1985 < echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1986 <   { (exit 1); exit 1; }; }
2778 >  as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
2779   ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
2780 <  { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&5
1989 < echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&2;}
1990 <   { (exit 1); exit 1; }; }
2780 >  as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
2781  
2782   fi
2783 < { echo "$as_me:$LINENO: result: $ac_cv_build" >&5
2784 < echo "${ECHO_T}$ac_cv_build" >&6; }
2783 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
2784 > $as_echo "$ac_cv_build" >&6; }
2785   case $ac_cv_build in
2786   *-*-*) ;;
2787 < *) { { echo "$as_me:$LINENO: error: invalid value of canonical build" >&5
1998 < echo "$as_me: error: invalid value of canonical build" >&2;}
1999 <   { (exit 1); exit 1; }; };;
2787 > *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
2788   esac
2789   build=$ac_cv_build
2790   ac_save_IFS=$IFS; IFS='-'
# Line 2012 | Line 2800 | case $build_os in *\ *) build_os=`echo "$build_os" | s
2800   case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
2801  
2802  
2803 < { echo "$as_me:$LINENO: checking host system type" >&5
2804 < echo $ECHO_N "checking host system type... $ECHO_C" >&6; }
2805 < if test "${ac_cv_host+set}" = set; then
2806 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2803 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
2804 > $as_echo_n "checking host system type... " >&6; }
2805 > if ${ac_cv_host+:} false; then :
2806 >  $as_echo_n "(cached) " >&6
2807   else
2808    if test "x$host_alias" = x; then
2809    ac_cv_host=$ac_cv_build
2810   else
2811    ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
2812 <    { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&5
2025 < echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&2;}
2026 <   { (exit 1); exit 1; }; }
2812 >    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
2813   fi
2814  
2815   fi
2816 < { echo "$as_me:$LINENO: result: $ac_cv_host" >&5
2817 < echo "${ECHO_T}$ac_cv_host" >&6; }
2816 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
2817 > $as_echo "$ac_cv_host" >&6; }
2818   case $ac_cv_host in
2819   *-*-*) ;;
2820 < *) { { echo "$as_me:$LINENO: error: invalid value of canonical host" >&5
2035 < echo "$as_me: error: invalid value of canonical host" >&2;}
2036 <   { (exit 1); exit 1; }; };;
2820 > *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
2821   esac
2822   host=$ac_cv_host
2823   ac_save_IFS=$IFS; IFS='-'
# Line 2053 | Line 2837 | case $host_os in *\ *) host_os=`echo "$host_os" | sed
2837  
2838  
2839   # set program name
2840 < PROGNAME="oopse"
2840 > PROGNAME="openmd"
2841  
2842  
2843  
2844  
2845   OBJEXT=".$OBJEXT"
2846  
2847 < OOPSE=oopse
2847 > OPENMD=openmd
2848  
2849   if test "x${prefix}" = "xNONE"
2850   then
2851 <  OOPSE_HOME=${ac_default_prefix}/oopse
2851 >  OPENMD_HOME=${ac_default_prefix}/openmd
2852   else
2853 <  OOPSE_HOME=${prefix}/oopse
2853 >  OPENMD_HOME=${prefix}/openmd
2854   fi
2855 < # Check whether --enable-oopse-home was given.
2856 < if test "${enable_oopse_home+set}" = set; then
2857 <  enableval=$enable_oopse_home; OOPSE_HOME="${enableval}"
2855 > # Check whether --enable-openmd-home was given.
2856 > if test "${enable_openmd_home+set}" = set; then :
2857 >  enableval=$enable_openmd_home; OPENMD_HOME="${enableval}"
2858   fi
2859  
2860  
# Line 2079 | Line 2863 | debug=0
2863  
2864   debug=0
2865   # Check whether --enable-debug was given.
2866 < if test "${enable_debug+set}" = set; then
2866 > if test "${enable_debug+set}" = set; then :
2867    enableval=$enable_debug; debug=1
2868   fi
2869  
2870   if test "${DEBUG}"; then
2871  
2872 < cat >>confdefs.h <<\_ACEOF
2089 < #define debug 1
2090 < _ACEOF
2872 > $as_echo "#define debug 1" >>confdefs.h
2873  
2874    msg="$msg, debug mode"
2875   fi
2876  
2877  
2878   # Check whether --enable-single was given.
2879 < if test "${enable_single+set}" = set; then
2879 > if test "${enable_single+set}" = set; then :
2880    enableval=$enable_single; ok=$enableval
2881   else
2882    ok=no
2883   fi
2884  
2885   # Check whether --enable-float was given.
2886 < if test "${enable_float+set}" = set; then
2886 > if test "${enable_float+set}" = set; then :
2887    enableval=$enable_float; ok=$enableval
2888   fi
2889  
2890   if test "$ok" = "yes"; then
2891  
2892 < cat >>confdefs.h <<\_ACEOF
2111 < #define SINGLE_PRECISION 1
2112 < _ACEOF
2892 > $as_echo "#define SINGLE_PRECISION 1" >>confdefs.h
2893  
2894          USE_SINGLE_PRECISION=yes
2895  
2896   fi
2897  
2118 – # Checks for programs.
2898   ac_ext=cpp
2899   ac_cpp='$CXXCPP $CPPFLAGS'
2900   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 2126 | Line 2905 | if test -z "$CXX"; then
2905      CXX=$CCC
2906    else
2907      if test -n "$ac_tool_prefix"; then
2908 <  for ac_prog in mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
2908 >  for ac_prog in $CXX icpc pathCC pgCC c++ xlc++ xlC g++ CC
2909    do
2910      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2911   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2912 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
2913 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
2914 < if test "${ac_cv_prog_CXX+set}" = set; then
2915 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2912 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2913 > $as_echo_n "checking for $ac_word... " >&6; }
2914 > if ${ac_cv_prog_CXX+:} false; then :
2915 >  $as_echo_n "(cached) " >&6
2916   else
2917    if test -n "$CXX"; then
2918    ac_cv_prog_CXX="$CXX" # Let the user override the test.
# Line 2143 | Line 2922 | do
2922   do
2923    IFS=$as_save_IFS
2924    test -z "$as_dir" && as_dir=.
2925 <  for ac_exec_ext in '' $ac_executable_extensions; do
2925 >    for ac_exec_ext in '' $ac_executable_extensions; do
2926    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2927      ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2928 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2928 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2929      break 2
2930    fi
2931   done
2932 < done
2932 >  done
2933   IFS=$as_save_IFS
2934  
2935   fi
2936   fi
2937   CXX=$ac_cv_prog_CXX
2938   if test -n "$CXX"; then
2939 <  { echo "$as_me:$LINENO: result: $CXX" >&5
2940 < echo "${ECHO_T}$CXX" >&6; }
2939 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
2940 > $as_echo "$CXX" >&6; }
2941   else
2942 <  { echo "$as_me:$LINENO: result: no" >&5
2943 < echo "${ECHO_T}no" >&6; }
2942 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
2943 > $as_echo "no" >&6; }
2944   fi
2945  
2946  
# Line 2170 | Line 2949 | if test -z "$CXX"; then
2949   fi
2950   if test -z "$CXX"; then
2951    ac_ct_CXX=$CXX
2952 <  for ac_prog in mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
2952 >  for ac_prog in $CXX icpc pathCC pgCC c++ xlc++ xlC g++ CC
2953   do
2954    # Extract the first word of "$ac_prog", so it can be a program name with args.
2955   set dummy $ac_prog; ac_word=$2
2956 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
2957 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
2958 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2959 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2956 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2957 > $as_echo_n "checking for $ac_word... " >&6; }
2958 > if ${ac_cv_prog_ac_ct_CXX+:} false; then :
2959 >  $as_echo_n "(cached) " >&6
2960   else
2961    if test -n "$ac_ct_CXX"; then
2962    ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
# Line 2187 | Line 2966 | do
2966   do
2967    IFS=$as_save_IFS
2968    test -z "$as_dir" && as_dir=.
2969 <  for ac_exec_ext in '' $ac_executable_extensions; do
2969 >    for ac_exec_ext in '' $ac_executable_extensions; do
2970    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2971      ac_cv_prog_ac_ct_CXX="$ac_prog"
2972 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2972 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2973      break 2
2974    fi
2975   done
2976 < done
2976 >  done
2977   IFS=$as_save_IFS
2978  
2979   fi
2980   fi
2981   ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2982   if test -n "$ac_ct_CXX"; then
2983 <  { echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2984 < echo "${ECHO_T}$ac_ct_CXX" >&6; }
2983 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
2984 > $as_echo "$ac_ct_CXX" >&6; }
2985   else
2986 <  { echo "$as_me:$LINENO: result: no" >&5
2987 < echo "${ECHO_T}no" >&6; }
2986 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
2987 > $as_echo "no" >&6; }
2988   fi
2989  
2990  
# Line 2217 | Line 2996 | yes:)
2996    else
2997      case $cross_compiling:$ac_tool_warned in
2998   yes:)
2999 < { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
3000 < whose name does not start with the host triplet.  If you think this
2222 < configuration is useful to you, please write to autoconf@gnu.org." >&5
2223 < echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
2224 < whose name does not start with the host triplet.  If you think this
2225 < configuration is useful to you, please write to autoconf@gnu.org." >&2;}
2999 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
3000 > $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
3001   ac_tool_warned=yes ;;
3002   esac
3003      CXX=$ac_ct_CXX
# Line 2232 | Line 3007 | fi
3007    fi
3008   fi
3009   # Provide some information about the compiler.
3010 < echo "$as_me:$LINENO: checking for C++ compiler version" >&5
3011 < ac_compiler=`set X $ac_compile; echo $2`
3012 < { (ac_try="$ac_compiler --version >&5"
3010 > $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
3011 > set X $ac_compile
3012 > ac_compiler=$2
3013 > for ac_option in --version -v -V -qversion; do
3014 >  { { ac_try="$ac_compiler $ac_option >&5"
3015   case "(($ac_try" in
3016    *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3017    *) ac_try_echo=$ac_try;;
3018   esac
3019 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3020 <  (eval "$ac_compiler --version >&5") 2>&5
3019 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3020 > $as_echo "$ac_try_echo"; } >&5
3021 >  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
3022    ac_status=$?
3023 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3024 <  (exit $ac_status); }
3025 < { (ac_try="$ac_compiler -v >&5"
3026 < case "(($ac_try" in
3027 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3028 <  *) ac_try_echo=$ac_try;;
3029 < esac
3030 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3031 <  (eval "$ac_compiler -v >&5") 2>&5
3032 <  ac_status=$?
2255 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2256 <  (exit $ac_status); }
2257 < { (ac_try="$ac_compiler -V >&5"
2258 < case "(($ac_try" in
2259 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2260 <  *) ac_try_echo=$ac_try;;
2261 < esac
2262 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
2263 <  (eval "$ac_compiler -V >&5") 2>&5
2264 <  ac_status=$?
2265 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2266 <  (exit $ac_status); }
3023 >  if test -s conftest.err; then
3024 >    sed '10a\
3025 > ... rest of stderr output deleted ...
3026 >         10q' conftest.err >conftest.er1
3027 >    cat conftest.er1 >&5
3028 >  fi
3029 >  rm -f conftest.er1 conftest.err
3030 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3031 >  test $ac_status = 0; }
3032 > done
3033  
3034 < cat >conftest.$ac_ext <<_ACEOF
2269 < /* confdefs.h.  */
2270 < _ACEOF
2271 < cat confdefs.h >>conftest.$ac_ext
2272 < cat >>conftest.$ac_ext <<_ACEOF
3034 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3035   /* end confdefs.h.  */
3036  
3037   int
# Line 2281 | Line 3043 | ac_clean_files_save=$ac_clean_files
3043   }
3044   _ACEOF
3045   ac_clean_files_save=$ac_clean_files
3046 < ac_clean_files="$ac_clean_files a.out a.exe b.out"
3046 > ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
3047   # Try to create an executable without -o first, disregard a.out.
3048   # It will help us diagnose broken compilers, and finding out an intuition
3049   # of exeext.
3050 < { echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
3051 < echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6; }
3052 < ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3053 < #
3054 < # List of possible output files, starting from the most likely.
3055 < # The algorithm is not robust to junk in `.', hence go to wildcards (a.*)
3056 < # only as a last resort.  b.out is created by i960 compilers.
2295 < ac_files='a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out'
2296 < #
2297 < # The IRIX 6 linker writes into existing files which may not be
2298 < # executable, retaining their permissions.  Remove them first so a
2299 < # subsequent execution test works.
3050 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler works" >&5
3051 > $as_echo_n "checking whether the C++ compiler works... " >&6; }
3052 > ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3053 >
3054 > # The possible output files:
3055 > ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
3056 >
3057   ac_rmfiles=
3058   for ac_file in $ac_files
3059   do
3060    case $ac_file in
3061 <    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;
3061 >    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3062      * ) ac_rmfiles="$ac_rmfiles $ac_file";;
3063    esac
3064   done
3065 < rm -rf $ac_rmfiles
3065 > rm -f $ac_rmfiles
3066  
3067 < if { (ac_try="$ac_link_default"
3067 > if { { ac_try="$ac_link_default"
3068   case "(($ac_try" in
3069    *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3070    *) ac_try_echo=$ac_try;;
3071   esac
3072 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3072 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3073 > $as_echo "$ac_try_echo"; } >&5
3074    (eval "$ac_link_default") 2>&5
3075    ac_status=$?
3076 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3077 <  (exit $ac_status); }; then
3076 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3077 >  test $ac_status = 0; }; then :
3078    # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
3079   # So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
3080   # in a Makefile.  We should not override ac_cv_exeext if it was cached,
# Line 2326 | Line 3084 | do
3084   do
3085    test -f "$ac_file" || continue
3086    case $ac_file in
3087 <    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj )
3087 >    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
3088          ;;
3089      [ab].out )
3090          # We found the default executable, but exeext='' is most
3091          # certainly right.
3092          break;;
3093      *.* )
3094 <        if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
3094 >        if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
3095          then :; else
3096             ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3097          fi
# Line 2352 | Line 3110 | fi
3110   else
3111    ac_file=''
3112   fi
3113 <
3114 < { echo "$as_me:$LINENO: result: $ac_file" >&5
3115 < echo "${ECHO_T}$ac_file" >&6; }
3116 < if test -z "$ac_file"; then
2359 <  echo "$as_me: failed program was:" >&5
3113 > if test -z "$ac_file"; then :
3114 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3115 > $as_echo "no" >&6; }
3116 > $as_echo "$as_me: failed program was:" >&5
3117   sed 's/^/| /' conftest.$ac_ext >&5
3118  
3119 < { { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
3120 < See \`config.log' for more details." >&5
3121 < echo "$as_me: error: C++ compiler cannot create executables
3122 < See \`config.log' for more details." >&2;}
3123 <   { (exit 77); exit 77; }; }
3119 > { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3120 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3121 > as_fn_error 77 "C++ compiler cannot create executables
3122 > See \`config.log' for more details" "$LINENO" 5; }
3123 > else
3124 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
3125 > $as_echo "yes" >&6; }
3126   fi
3127 <
3127 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler default output file name" >&5
3128 > $as_echo_n "checking for C++ compiler default output file name... " >&6; }
3129 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
3130 > $as_echo "$ac_file" >&6; }
3131   ac_exeext=$ac_cv_exeext
3132  
3133 < # Check that the compiler produces executables we can run.  If not, either
2372 < # the compiler is broken, or we cross compile.
2373 < { echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
2374 < echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6; }
2375 < # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
2376 < # If not cross compiling, check that we can run a simple program.
2377 < if test "$cross_compiling" != yes; then
2378 <  if { ac_try='./$ac_file'
2379 <  { (case "(($ac_try" in
2380 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2381 <  *) ac_try_echo=$ac_try;;
2382 < esac
2383 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
2384 <  (eval "$ac_try") 2>&5
2385 <  ac_status=$?
2386 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2387 <  (exit $ac_status); }; }; then
2388 <    cross_compiling=no
2389 <  else
2390 <    if test "$cross_compiling" = maybe; then
2391 <        cross_compiling=yes
2392 <    else
2393 <        { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
2394 < If you meant to cross compile, use \`--host'.
2395 < See \`config.log' for more details." >&5
2396 < echo "$as_me: error: cannot run C++ compiled programs.
2397 < If you meant to cross compile, use \`--host'.
2398 < See \`config.log' for more details." >&2;}
2399 <   { (exit 1); exit 1; }; }
2400 <    fi
2401 <  fi
2402 < fi
2403 < { echo "$as_me:$LINENO: result: yes" >&5
2404 < echo "${ECHO_T}yes" >&6; }
2405 <
2406 < rm -rf a.out a.exe conftest$ac_cv_exeext b.out
3133 > rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
3134   ac_clean_files=$ac_clean_files_save
3135 < # Check that the compiler produces executables we can run.  If not, either
3136 < # the compiler is broken, or we cross compile.
3137 < { echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
2411 < echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6; }
2412 < { echo "$as_me:$LINENO: result: $cross_compiling" >&5
2413 < echo "${ECHO_T}$cross_compiling" >&6; }
2414 <
2415 < { echo "$as_me:$LINENO: checking for suffix of executables" >&5
2416 < echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6; }
2417 < if { (ac_try="$ac_link"
3135 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
3136 > $as_echo_n "checking for suffix of executables... " >&6; }
3137 > if { { ac_try="$ac_link"
3138   case "(($ac_try" in
3139    *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3140    *) ac_try_echo=$ac_try;;
3141   esac
3142 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3142 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3143 > $as_echo "$ac_try_echo"; } >&5
3144    (eval "$ac_link") 2>&5
3145    ac_status=$?
3146 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3147 <  (exit $ac_status); }; then
3146 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3147 >  test $ac_status = 0; }; then :
3148    # If both `conftest.exe' and `conftest' are `present' (well, observable)
3149   # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3150   # work properly (i.e., refer to `conftest.exe'), while it won't with
# Line 2431 | Line 3152 | for ac_file in conftest.exe conftest conftest.*; do
3152   for ac_file in conftest.exe conftest conftest.*; do
3153    test -f "$ac_file" || continue
3154    case $ac_file in
3155 <    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;
3155 >    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3156      *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3157            break;;
3158      * ) break;;
3159    esac
3160   done
3161   else
3162 <  { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3163 < See \`config.log' for more details." >&5
3164 < echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3165 < See \`config.log' for more details." >&2;}
2445 <   { (exit 1); exit 1; }; }
3162 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3163 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3164 > as_fn_error $? "cannot compute suffix of executables: cannot compile and link
3165 > See \`config.log' for more details" "$LINENO" 5; }
3166   fi
3167 + rm -f conftest conftest$ac_cv_exeext
3168 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
3169 + $as_echo "$ac_cv_exeext" >&6; }
3170  
3171 < rm -rf conftest$ac_cv_exeext
2449 < { echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
2450 < echo "${ECHO_T}$ac_cv_exeext" >&6; }
2451 <
2452 < rm -rf conftest.$ac_ext
3171 > rm -f conftest.$ac_ext
3172   EXEEXT=$ac_cv_exeext
3173   ac_exeext=$EXEEXT
3174 < { echo "$as_me:$LINENO: checking for suffix of object files" >&5
3175 < echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6; }
3176 < if test "${ac_cv_objext+set}" = set; then
3177 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3178 < else
3179 <  cat >conftest.$ac_ext <<_ACEOF
3180 < /* confdefs.h.  */
3174 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3175 > /* end confdefs.h.  */
3176 > #include <stdio.h>
3177 > int
3178 > main ()
3179 > {
3180 > FILE *f = fopen ("conftest.out", "w");
3181 > return ferror (f) || fclose (f) != 0;
3182 >
3183 >  ;
3184 >  return 0;
3185 > }
3186   _ACEOF
3187 < cat confdefs.h >>conftest.$ac_ext
3188 < cat >>conftest.$ac_ext <<_ACEOF
3187 > ac_clean_files="$ac_clean_files conftest.out"
3188 > # Check that the compiler produces executables we can run.  If not, either
3189 > # the compiler is broken, or we cross compile.
3190 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
3191 > $as_echo_n "checking whether we are cross compiling... " >&6; }
3192 > if test "$cross_compiling" != yes; then
3193 >  { { ac_try="$ac_link"
3194 > case "(($ac_try" in
3195 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3196 >  *) ac_try_echo=$ac_try;;
3197 > esac
3198 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3199 > $as_echo "$ac_try_echo"; } >&5
3200 >  (eval "$ac_link") 2>&5
3201 >  ac_status=$?
3202 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3203 >  test $ac_status = 0; }
3204 >  if { ac_try='./conftest$ac_cv_exeext'
3205 >  { { case "(($ac_try" in
3206 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3207 >  *) ac_try_echo=$ac_try;;
3208 > esac
3209 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3210 > $as_echo "$ac_try_echo"; } >&5
3211 >  (eval "$ac_try") 2>&5
3212 >  ac_status=$?
3213 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3214 >  test $ac_status = 0; }; }; then
3215 >    cross_compiling=no
3216 >  else
3217 >    if test "$cross_compiling" = maybe; then
3218 >        cross_compiling=yes
3219 >    else
3220 >        { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3221 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3222 > as_fn_error $? "cannot run C++ compiled programs.
3223 > If you meant to cross compile, use \`--host'.
3224 > See \`config.log' for more details" "$LINENO" 5; }
3225 >    fi
3226 >  fi
3227 > fi
3228 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
3229 > $as_echo "$cross_compiling" >&6; }
3230 >
3231 > rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
3232 > ac_clean_files=$ac_clean_files_save
3233 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
3234 > $as_echo_n "checking for suffix of object files... " >&6; }
3235 > if ${ac_cv_objext+:} false; then :
3236 >  $as_echo_n "(cached) " >&6
3237 > else
3238 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3239   /* end confdefs.h.  */
3240  
3241   int
# Line 2472 | Line 3246 | _ACEOF
3246    return 0;
3247   }
3248   _ACEOF
3249 < rm -rf conftest.o conftest.obj
3250 < if { (ac_try="$ac_compile"
3249 > rm -f conftest.o conftest.obj
3250 > if { { ac_try="$ac_compile"
3251   case "(($ac_try" in
3252    *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3253    *) ac_try_echo=$ac_try;;
3254   esac
3255 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3255 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3256 > $as_echo "$ac_try_echo"; } >&5
3257    (eval "$ac_compile") 2>&5
3258    ac_status=$?
3259 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3260 <  (exit $ac_status); }; then
3259 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3260 >  test $ac_status = 0; }; then :
3261    for ac_file in conftest.o conftest.obj conftest.*; do
3262    test -f "$ac_file" || continue;
3263    case $ac_file in
3264 <    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf ) ;;
3264 >    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
3265      *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3266         break;;
3267    esac
3268   done
3269   else
3270 <  echo "$as_me: failed program was:" >&5
3270 >  $as_echo "$as_me: failed program was:" >&5
3271   sed 's/^/| /' conftest.$ac_ext >&5
3272  
3273 < { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3274 < See \`config.log' for more details." >&5
3275 < echo "$as_me: error: cannot compute suffix of object files: cannot compile
3276 < See \`config.log' for more details." >&2;}
2502 <   { (exit 1); exit 1; }; }
3273 > { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3274 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3275 > as_fn_error $? "cannot compute suffix of object files: cannot compile
3276 > See \`config.log' for more details" "$LINENO" 5; }
3277   fi
3278 <
2505 < rm -rf conftest.$ac_cv_objext conftest.$ac_ext
3278 > rm -f conftest.$ac_cv_objext conftest.$ac_ext
3279   fi
3280 < { echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3281 < echo "${ECHO_T}$ac_cv_objext" >&6; }
3280 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
3281 > $as_echo "$ac_cv_objext" >&6; }
3282   OBJEXT=$ac_cv_objext
3283   ac_objext=$OBJEXT
3284 < { echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3285 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6; }
3286 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3287 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3284 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
3285 > $as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
3286 > if ${ac_cv_cxx_compiler_gnu+:} false; then :
3287 >  $as_echo_n "(cached) " >&6
3288   else
3289 <  cat >conftest.$ac_ext <<_ACEOF
2517 < /* confdefs.h.  */
2518 < _ACEOF
2519 < cat confdefs.h >>conftest.$ac_ext
2520 < cat >>conftest.$ac_ext <<_ACEOF
3289 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3290   /* end confdefs.h.  */
3291  
3292   int
# Line 2531 | Line 3300 | _ACEOF
3300    return 0;
3301   }
3302   _ACEOF
3303 < rm -rf conftest.$ac_objext
2535 < if { (ac_try="$ac_compile"
2536 < case "(($ac_try" in
2537 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2538 <  *) ac_try_echo=$ac_try;;
2539 < esac
2540 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
2541 <  (eval "$ac_compile") 2>conftest.er1
2542 <  ac_status=$?
2543 <  grep -v '^ *+' conftest.er1 >conftest.err
2544 <  rm -rf conftest.er1
2545 <  cat conftest.err >&5
2546 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2547 <  (exit $ac_status); } && {
2548 <         test -z "$ac_cxx_werror_flag" ||
2549 <         test ! -s conftest.err
2550 <       } && test -s conftest.$ac_objext; then
3303 > if ac_fn_cxx_try_compile "$LINENO"; then :
3304    ac_compiler_gnu=yes
3305   else
3306 <  echo "$as_me: failed program was:" >&5
2554 < sed 's/^/| /' conftest.$ac_ext >&5
2555 <
2556 <        ac_compiler_gnu=no
3306 >  ac_compiler_gnu=no
3307   fi
3308 <
2559 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
3308 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3309   ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3310  
3311   fi
3312 < { echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3313 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6; }
3314 < GXX=`test $ac_compiler_gnu = yes && echo yes`
3312 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
3313 > $as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
3314 > if test $ac_compiler_gnu = yes; then
3315 >  GXX=yes
3316 > else
3317 >  GXX=
3318 > fi
3319   ac_test_CXXFLAGS=${CXXFLAGS+set}
3320   ac_save_CXXFLAGS=$CXXFLAGS
3321 < { echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3322 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6; }
3323 < if test "${ac_cv_prog_cxx_g+set}" = set; then
3324 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3321 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
3322 > $as_echo_n "checking whether $CXX accepts -g... " >&6; }
3323 > if ${ac_cv_prog_cxx_g+:} false; then :
3324 >  $as_echo_n "(cached) " >&6
3325   else
3326    ac_save_cxx_werror_flag=$ac_cxx_werror_flag
3327     ac_cxx_werror_flag=yes
3328     ac_cv_prog_cxx_g=no
3329     CXXFLAGS="-g"
3330 <   cat >conftest.$ac_ext <<_ACEOF
2578 < /* confdefs.h.  */
2579 < _ACEOF
2580 < cat confdefs.h >>conftest.$ac_ext
2581 < cat >>conftest.$ac_ext <<_ACEOF
3330 >   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3331   /* end confdefs.h.  */
3332  
3333   int
# Line 2589 | Line 3338 | _ACEOF
3338    return 0;
3339   }
3340   _ACEOF
3341 < rm -rf conftest.$ac_objext
2593 < if { (ac_try="$ac_compile"
2594 < case "(($ac_try" in
2595 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2596 <  *) ac_try_echo=$ac_try;;
2597 < esac
2598 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
2599 <  (eval "$ac_compile") 2>conftest.er1
2600 <  ac_status=$?
2601 <  grep -v '^ *+' conftest.er1 >conftest.err
2602 <  rm -rf conftest.er1
2603 <  cat conftest.err >&5
2604 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2605 <  (exit $ac_status); } && {
2606 <         test -z "$ac_cxx_werror_flag" ||
2607 <         test ! -s conftest.err
2608 <       } && test -s conftest.$ac_objext; then
3341 > if ac_fn_cxx_try_compile "$LINENO"; then :
3342    ac_cv_prog_cxx_g=yes
3343   else
3344 <  echo "$as_me: failed program was:" >&5
3345 < sed 's/^/| /' conftest.$ac_ext >&5
2613 <
2614 <        CXXFLAGS=""
2615 <      cat >conftest.$ac_ext <<_ACEOF
2616 < /* confdefs.h.  */
2617 < _ACEOF
2618 < cat confdefs.h >>conftest.$ac_ext
2619 < cat >>conftest.$ac_ext <<_ACEOF
3344 >  CXXFLAGS=""
3345 >      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3346   /* end confdefs.h.  */
3347  
3348   int
# Line 2627 | Line 3353 | _ACEOF
3353    return 0;
3354   }
3355   _ACEOF
3356 < rm -rf conftest.$ac_objext
2631 < if { (ac_try="$ac_compile"
2632 < case "(($ac_try" in
2633 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2634 <  *) ac_try_echo=$ac_try;;
2635 < esac
2636 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
2637 <  (eval "$ac_compile") 2>conftest.er1
2638 <  ac_status=$?
2639 <  grep -v '^ *+' conftest.er1 >conftest.err
2640 <  rm -rf conftest.er1
2641 <  cat conftest.err >&5
2642 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2643 <  (exit $ac_status); } && {
2644 <         test -z "$ac_cxx_werror_flag" ||
2645 <         test ! -s conftest.err
2646 <       } && test -s conftest.$ac_objext; then
2647 <  :
2648 < else
2649 <  echo "$as_me: failed program was:" >&5
2650 < sed 's/^/| /' conftest.$ac_ext >&5
3356 > if ac_fn_cxx_try_compile "$LINENO"; then :
3357  
3358 <        ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3358 > else
3359 >  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3360           CXXFLAGS="-g"
3361 <         cat >conftest.$ac_ext <<_ACEOF
2655 < /* confdefs.h.  */
2656 < _ACEOF
2657 < cat confdefs.h >>conftest.$ac_ext
2658 < cat >>conftest.$ac_ext <<_ACEOF
3361 >         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3362   /* end confdefs.h.  */
3363  
3364   int
# Line 2666 | Line 3369 | _ACEOF
3369    return 0;
3370   }
3371   _ACEOF
3372 < rm -rf conftest.$ac_objext
2670 < if { (ac_try="$ac_compile"
2671 < case "(($ac_try" in
2672 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2673 <  *) ac_try_echo=$ac_try;;
2674 < esac
2675 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
2676 <  (eval "$ac_compile") 2>conftest.er1
2677 <  ac_status=$?
2678 <  grep -v '^ *+' conftest.er1 >conftest.err
2679 <  rm -rf conftest.er1
2680 <  cat conftest.err >&5
2681 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2682 <  (exit $ac_status); } && {
2683 <         test -z "$ac_cxx_werror_flag" ||
2684 <         test ! -s conftest.err
2685 <       } && test -s conftest.$ac_objext; then
3372 > if ac_fn_cxx_try_compile "$LINENO"; then :
3373    ac_cv_prog_cxx_g=yes
2687 – else
2688 –  echo "$as_me: failed program was:" >&5
2689 – sed 's/^/| /' conftest.$ac_ext >&5
2690 –
2691 –
3374   fi
3375 <
2694 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
3375 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3376   fi
3377 <
2697 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
3377 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3378   fi
3379 <
2700 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
3379 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3380     ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3381   fi
3382 < { echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3383 < echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6; }
3382 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
3383 > $as_echo "$ac_cv_prog_cxx_g" >&6; }
3384   if test "$ac_test_CXXFLAGS" = set; then
3385    CXXFLAGS=$ac_save_CXXFLAGS
3386   elif test $ac_cv_prog_cxx_g = yes; then
# Line 2729 | Line 3408 | if test -n "$ac_tool_prefix"; then
3408   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3409   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3410   if test -n "$ac_tool_prefix"; then
3411 <  for ac_prog in mpicc icc pathcc pgcc cc xlc gcc
3411 >  for ac_prog in $CC icc pathcc pgcc cc xlc gcc
3412    do
3413      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3414   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3415 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
3416 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
3417 < if test "${ac_cv_prog_CC+set}" = set; then
3418 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3415 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3416 > $as_echo_n "checking for $ac_word... " >&6; }
3417 > if ${ac_cv_prog_CC+:} false; then :
3418 >  $as_echo_n "(cached) " >&6
3419   else
3420    if test -n "$CC"; then
3421    ac_cv_prog_CC="$CC" # Let the user override the test.
# Line 2746 | Line 3425 | do
3425   do
3426    IFS=$as_save_IFS
3427    test -z "$as_dir" && as_dir=.
3428 <  for ac_exec_ext in '' $ac_executable_extensions; do
3428 >    for ac_exec_ext in '' $ac_executable_extensions; do
3429    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3430      ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3431 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3431 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3432      break 2
3433    fi
3434   done
3435 < done
3435 >  done
3436   IFS=$as_save_IFS
3437  
3438   fi
3439   fi
3440   CC=$ac_cv_prog_CC
3441   if test -n "$CC"; then
3442 <  { echo "$as_me:$LINENO: result: $CC" >&5
3443 < echo "${ECHO_T}$CC" >&6; }
3442 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
3443 > $as_echo "$CC" >&6; }
3444   else
3445 <  { echo "$as_me:$LINENO: result: no" >&5
3446 < echo "${ECHO_T}no" >&6; }
3445 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3446 > $as_echo "no" >&6; }
3447   fi
3448  
3449  
# Line 2773 | Line 3452 | if test -z "$CC"; then
3452   fi
3453   if test -z "$CC"; then
3454    ac_ct_CC=$CC
3455 <  for ac_prog in mpicc icc pathcc pgcc cc xlc gcc
3455 >  for ac_prog in $CC icc pathcc pgcc cc xlc gcc
3456   do
3457    # Extract the first word of "$ac_prog", so it can be a program name with args.
3458   set dummy $ac_prog; ac_word=$2
3459 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
3460 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
3461 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3462 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3459 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3460 > $as_echo_n "checking for $ac_word... " >&6; }
3461 > if ${ac_cv_prog_ac_ct_CC+:} false; then :
3462 >  $as_echo_n "(cached) " >&6
3463   else
3464    if test -n "$ac_ct_CC"; then
3465    ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
# Line 2790 | Line 3469 | do
3469   do
3470    IFS=$as_save_IFS
3471    test -z "$as_dir" && as_dir=.
3472 <  for ac_exec_ext in '' $ac_executable_extensions; do
3472 >    for ac_exec_ext in '' $ac_executable_extensions; do
3473    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3474      ac_cv_prog_ac_ct_CC="$ac_prog"
3475 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3475 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3476      break 2
3477    fi
3478   done
3479 < done
3479 >  done
3480   IFS=$as_save_IFS
3481  
3482   fi
3483   fi
3484   ac_ct_CC=$ac_cv_prog_ac_ct_CC
3485   if test -n "$ac_ct_CC"; then
3486 <  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3487 < echo "${ECHO_T}$ac_ct_CC" >&6; }
3486 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
3487 > $as_echo "$ac_ct_CC" >&6; }
3488   else
3489 <  { echo "$as_me:$LINENO: result: no" >&5
3490 < echo "${ECHO_T}no" >&6; }
3489 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3490 > $as_echo "no" >&6; }
3491   fi
3492  
3493  
# Line 2820 | Line 3499 | yes:)
3499    else
3500      case $cross_compiling:$ac_tool_warned in
3501   yes:)
3502 < { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
3503 < whose name does not start with the host triplet.  If you think this
2825 < configuration is useful to you, please write to autoconf@gnu.org." >&5
2826 < echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
2827 < whose name does not start with the host triplet.  If you think this
2828 < configuration is useful to you, please write to autoconf@gnu.org." >&2;}
3502 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
3503 > $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
3504   ac_tool_warned=yes ;;
3505   esac
3506      CC=$ac_ct_CC
# Line 2833 | Line 3508 | fi
3508   fi
3509  
3510  
3511 < test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3512 < See \`config.log' for more details." >&5
3513 < echo "$as_me: error: no acceptable C compiler found in \$PATH
3514 < See \`config.log' for more details." >&2;}
2840 <   { (exit 1); exit 1; }; }
3511 > test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3512 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3513 > as_fn_error $? "no acceptable C compiler found in \$PATH
3514 > See \`config.log' for more details" "$LINENO" 5; }
3515  
3516   # Provide some information about the compiler.
3517 < echo "$as_me:$LINENO: checking for C compiler version" >&5
3518 < ac_compiler=`set X $ac_compile; echo $2`
3519 < { (ac_try="$ac_compiler --version >&5"
3520 < case "(($ac_try" in
3521 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2848 <  *) ac_try_echo=$ac_try;;
2849 < esac
2850 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
2851 <  (eval "$ac_compiler --version >&5") 2>&5
2852 <  ac_status=$?
2853 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2854 <  (exit $ac_status); }
2855 < { (ac_try="$ac_compiler -v >&5"
3517 > $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
3518 > set X $ac_compile
3519 > ac_compiler=$2
3520 > for ac_option in --version -v -V -qversion; do
3521 >  { { ac_try="$ac_compiler $ac_option >&5"
3522   case "(($ac_try" in
3523    *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3524    *) ac_try_echo=$ac_try;;
3525   esac
3526 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3527 <  (eval "$ac_compiler -v >&5") 2>&5
3526 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3527 > $as_echo "$ac_try_echo"; } >&5
3528 >  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
3529    ac_status=$?
3530 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3531 <  (exit $ac_status); }
3532 < { (ac_try="$ac_compiler -V >&5"
3533 < case "(($ac_try" in
3534 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3535 <  *) ac_try_echo=$ac_try;;
3536 < esac
3537 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3538 <  (eval "$ac_compiler -V >&5") 2>&5
3539 <  ac_status=$?
2873 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2874 <  (exit $ac_status); }
3530 >  if test -s conftest.err; then
3531 >    sed '10a\
3532 > ... rest of stderr output deleted ...
3533 >         10q' conftest.err >conftest.er1
3534 >    cat conftest.er1 >&5
3535 >  fi
3536 >  rm -f conftest.er1 conftest.err
3537 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3538 >  test $ac_status = 0; }
3539 > done
3540  
3541 < { echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3542 < echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6; }
3543 < if test "${ac_cv_c_compiler_gnu+set}" = set; then
3544 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3541 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
3542 > $as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
3543 > if ${ac_cv_c_compiler_gnu+:} false; then :
3544 >  $as_echo_n "(cached) " >&6
3545   else
3546 <  cat >conftest.$ac_ext <<_ACEOF
2882 < /* confdefs.h.  */
2883 < _ACEOF
2884 < cat confdefs.h >>conftest.$ac_ext
2885 < cat >>conftest.$ac_ext <<_ACEOF
3546 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3547   /* end confdefs.h.  */
3548  
3549   int
# Line 2896 | Line 3557 | _ACEOF
3557    return 0;
3558   }
3559   _ACEOF
3560 < rm -rf conftest.$ac_objext
2900 < if { (ac_try="$ac_compile"
2901 < case "(($ac_try" in
2902 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2903 <  *) ac_try_echo=$ac_try;;
2904 < esac
2905 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
2906 <  (eval "$ac_compile") 2>conftest.er1
2907 <  ac_status=$?
2908 <  grep -v '^ *+' conftest.er1 >conftest.err
2909 <  rm -f conftest.er1
2910 <  cat conftest.err >&5
2911 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2912 <  (exit $ac_status); } && {
2913 <         test -z "$ac_c_werror_flag" ||
2914 <         test ! -s conftest.err
2915 <       } && test -s conftest.$ac_objext; then
3560 > if ac_fn_c_try_compile "$LINENO"; then :
3561    ac_compiler_gnu=yes
3562   else
3563 <  echo "$as_me: failed program was:" >&5
2919 < sed 's/^/| /' conftest.$ac_ext >&5
2920 <
2921 <        ac_compiler_gnu=no
3563 >  ac_compiler_gnu=no
3564   fi
3565 <
2924 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
3565 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3566   ac_cv_c_compiler_gnu=$ac_compiler_gnu
3567  
3568   fi
3569 < { echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3570 < echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6; }
3571 < GCC=`test $ac_compiler_gnu = yes && echo yes`
3569 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
3570 > $as_echo "$ac_cv_c_compiler_gnu" >&6; }
3571 > if test $ac_compiler_gnu = yes; then
3572 >  GCC=yes
3573 > else
3574 >  GCC=
3575 > fi
3576   ac_test_CFLAGS=${CFLAGS+set}
3577   ac_save_CFLAGS=$CFLAGS
3578 < { echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3579 < echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6; }
3580 < if test "${ac_cv_prog_cc_g+set}" = set; then
3581 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3578 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
3579 > $as_echo_n "checking whether $CC accepts -g... " >&6; }
3580 > if ${ac_cv_prog_cc_g+:} false; then :
3581 >  $as_echo_n "(cached) " >&6
3582   else
3583    ac_save_c_werror_flag=$ac_c_werror_flag
3584     ac_c_werror_flag=yes
3585     ac_cv_prog_cc_g=no
3586     CFLAGS="-g"
3587 <   cat >conftest.$ac_ext <<_ACEOF
2943 < /* confdefs.h.  */
2944 < _ACEOF
2945 < cat confdefs.h >>conftest.$ac_ext
2946 < cat >>conftest.$ac_ext <<_ACEOF
3587 >   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3588   /* end confdefs.h.  */
3589  
3590   int
# Line 2954 | Line 3595 | _ACEOF
3595    return 0;
3596   }
3597   _ACEOF
3598 < rm -rf conftest.$ac_objext
2958 < if { (ac_try="$ac_compile"
2959 < case "(($ac_try" in
2960 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2961 <  *) ac_try_echo=$ac_try;;
2962 < esac
2963 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
2964 <  (eval "$ac_compile") 2>conftest.er1
2965 <  ac_status=$?
2966 <  grep -v '^ *+' conftest.er1 >conftest.err
2967 <  rm -f conftest.er1
2968 <  cat conftest.err >&5
2969 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2970 <  (exit $ac_status); } && {
2971 <         test -z "$ac_c_werror_flag" ||
2972 <         test ! -s conftest.err
2973 <       } && test -s conftest.$ac_objext; then
3598 > if ac_fn_c_try_compile "$LINENO"; then :
3599    ac_cv_prog_cc_g=yes
3600   else
3601 <  echo "$as_me: failed program was:" >&5
3602 < sed 's/^/| /' conftest.$ac_ext >&5
2978 <
2979 <        CFLAGS=""
2980 <      cat >conftest.$ac_ext <<_ACEOF
2981 < /* confdefs.h.  */
2982 < _ACEOF
2983 < cat confdefs.h >>conftest.$ac_ext
2984 < cat >>conftest.$ac_ext <<_ACEOF
3601 >  CFLAGS=""
3602 >      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3603   /* end confdefs.h.  */
3604  
3605   int
# Line 2992 | Line 3610 | _ACEOF
3610    return 0;
3611   }
3612   _ACEOF
3613 < rm -rf conftest.$ac_objext
2996 < if { (ac_try="$ac_compile"
2997 < case "(($ac_try" in
2998 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2999 <  *) ac_try_echo=$ac_try;;
3000 < esac
3001 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3002 <  (eval "$ac_compile") 2>conftest.er1
3003 <  ac_status=$?
3004 <  grep -v '^ *+' conftest.er1 >conftest.err
3005 <  rm -rf conftest.er1
3006 <  cat conftest.err >&5
3007 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3008 <  (exit $ac_status); } && {
3009 <         test -z "$ac_c_werror_flag" ||
3010 <         test ! -s conftest.err
3011 <       } && test -s conftest.$ac_objext; then
3012 <  :
3013 < else
3014 <  echo "$as_me: failed program was:" >&5
3015 < sed 's/^/| /' conftest.$ac_ext >&5
3613 > if ac_fn_c_try_compile "$LINENO"; then :
3614  
3615 <        ac_c_werror_flag=$ac_save_c_werror_flag
3615 > else
3616 >  ac_c_werror_flag=$ac_save_c_werror_flag
3617           CFLAGS="-g"
3618 <         cat >conftest.$ac_ext <<_ACEOF
3020 < /* confdefs.h.  */
3021 < _ACEOF
3022 < cat confdefs.h >>conftest.$ac_ext
3023 < cat >>conftest.$ac_ext <<_ACEOF
3618 >         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3619   /* end confdefs.h.  */
3620  
3621   int
# Line 3031 | Line 3626 | _ACEOF
3626    return 0;
3627   }
3628   _ACEOF
3629 < rm -rf conftest.$ac_objext
3035 < if { (ac_try="$ac_compile"
3036 < case "(($ac_try" in
3037 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3038 <  *) ac_try_echo=$ac_try;;
3039 < esac
3040 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3041 <  (eval "$ac_compile") 2>conftest.er1
3042 <  ac_status=$?
3043 <  grep -v '^ *+' conftest.er1 >conftest.err
3044 <  rm -f conftest.er1
3045 <  cat conftest.err >&5
3046 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3047 <  (exit $ac_status); } && {
3048 <         test -z "$ac_c_werror_flag" ||
3049 <         test ! -s conftest.err
3050 <       } && test -s conftest.$ac_objext; then
3629 > if ac_fn_c_try_compile "$LINENO"; then :
3630    ac_cv_prog_cc_g=yes
3052 – else
3053 –  echo "$as_me: failed program was:" >&5
3054 – sed 's/^/| /' conftest.$ac_ext >&5
3055 –
3056 –
3631   fi
3632 <
3059 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
3632 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3633   fi
3634 <
3062 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
3634 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3635   fi
3636 <
3065 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
3636 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3637     ac_c_werror_flag=$ac_save_c_werror_flag
3638   fi
3639 < { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3640 < echo "${ECHO_T}$ac_cv_prog_cc_g" >&6; }
3639 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
3640 > $as_echo "$ac_cv_prog_cc_g" >&6; }
3641   if test "$ac_test_CFLAGS" = set; then
3642    CFLAGS=$ac_save_CFLAGS
3643   elif test $ac_cv_prog_cc_g = yes; then
# Line 3082 | Line 3653 | fi
3653      CFLAGS=
3654    fi
3655   fi
3656 < { echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
3657 < echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; }
3658 < if test "${ac_cv_prog_cc_c89+set}" = set; then
3659 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3656 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
3657 > $as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
3658 > if ${ac_cv_prog_cc_c89+:} false; then :
3659 >  $as_echo_n "(cached) " >&6
3660   else
3661    ac_cv_prog_cc_c89=no
3662   ac_save_CC=$CC
3663 < cat >conftest.$ac_ext <<_ACEOF
3093 < /* confdefs.h.  */
3094 < _ACEOF
3095 < cat confdefs.h >>conftest.$ac_ext
3096 < cat >>conftest.$ac_ext <<_ACEOF
3663 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3664   /* end confdefs.h.  */
3665   #include <stdarg.h>
3666   #include <stdio.h>
# Line 3150 | Line 3717 | do
3717          -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3718   do
3719    CC="$ac_save_CC $ac_arg"
3720 <  rm -rf conftest.$ac_objext
3154 < if { (ac_try="$ac_compile"
3155 < case "(($ac_try" in
3156 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3157 <  *) ac_try_echo=$ac_try;;
3158 < esac
3159 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3160 <  (eval "$ac_compile") 2>conftest.er1
3161 <  ac_status=$?
3162 <  grep -v '^ *+' conftest.er1 >conftest.err
3163 <  rm -f conftest.er1
3164 <  cat conftest.err >&5
3165 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3166 <  (exit $ac_status); } && {
3167 <         test -z "$ac_c_werror_flag" ||
3168 <         test ! -s conftest.err
3169 <       } && test -s conftest.$ac_objext; then
3720 >  if ac_fn_c_try_compile "$LINENO"; then :
3721    ac_cv_prog_cc_c89=$ac_arg
3171 – else
3172 –  echo "$as_me: failed program was:" >&5
3173 – sed 's/^/| /' conftest.$ac_ext >&5
3174 –
3175 –
3722   fi
3723 <
3178 < rm -rf core conftest.err conftest.$ac_objext
3723 > rm -f core conftest.err conftest.$ac_objext
3724    test "x$ac_cv_prog_cc_c89" != "xno" && break
3725   done
3726 < rm -rf conftest.$ac_ext
3726 > rm -f conftest.$ac_ext
3727   CC=$ac_save_CC
3728  
3729   fi
3730   # AC_CACHE_VAL
3731   case "x$ac_cv_prog_cc_c89" in
3732    x)
3733 <    { echo "$as_me:$LINENO: result: none needed" >&5
3734 < echo "${ECHO_T}none needed" >&6; } ;;
3733 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
3734 > $as_echo "none needed" >&6; } ;;
3735    xno)
3736 <    { echo "$as_me:$LINENO: result: unsupported" >&5
3737 < echo "${ECHO_T}unsupported" >&6; } ;;
3736 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
3737 > $as_echo "unsupported" >&6; } ;;
3738    *)
3739      CC="$CC $ac_cv_prog_cc_c89"
3740 <    { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
3741 < echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;;
3740 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
3741 > $as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
3742   esac
3743 + if test "x$ac_cv_prog_cc_c89" != xno; then :
3744  
3745 + fi
3746  
3747   ac_ext=c
3748   ac_cpp='$CPP $CPPFLAGS'
# Line 3203 | Line 3750 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
3750   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3751   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3752  
3753 < ac_ext=${ac_fc_srcext-f}
3754 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
3755 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
3756 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3757 < if test -n "$ac_tool_prefix"; then
3758 <  for ac_prog in mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
3759 <  do
3760 <    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3761 < set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3762 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
3763 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
3764 < if test "${ac_cv_prog_FC+set}" = set; then
3765 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3753 >
3754 > save_CXX=$CXX
3755 > save_CC=$CC
3756 > save_LIBS=$LIBS
3757 >
3758 > ac_ext=cpp
3759 > ac_cpp='$CXXCPP $CPPFLAGS'
3760 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3761 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3762 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3763 >
3764 >
3765 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lc" >&5
3766 > $as_echo_n "checking for dlopen in -lc... " >&6; }
3767 > if ${ac_cv_lib_c_dlopen+:} false; then :
3768 >  $as_echo_n "(cached) " >&6
3769   else
3770 <  if test -n "$FC"; then
3771 <  ac_cv_prog_FC="$FC" # Let the user override the test.
3770 >  ac_check_lib_save_LIBS=$LIBS
3771 > LIBS="-lc  $LIBS"
3772 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3773 > /* end confdefs.h.  */
3774 >
3775 > /* Override any GCC internal prototype to avoid an error.
3776 >   Use char because int might match the return type of a GCC
3777 >   builtin and then its argument prototype would still apply.  */
3778 > #ifdef __cplusplus
3779 > extern "C"
3780 > #endif
3781 > char dlopen ();
3782 > int
3783 > main ()
3784 > {
3785 > return dlopen ();
3786 >  ;
3787 >  return 0;
3788 > }
3789 > _ACEOF
3790 > if ac_fn_cxx_try_link "$LINENO"; then :
3791 >  ac_cv_lib_c_dlopen=yes
3792   else
3793 +  ac_cv_lib_c_dlopen=no
3794 + fi
3795 + rm -f core conftest.err conftest.$ac_objext \
3796 +    conftest$ac_exeext conftest.$ac_ext
3797 + LIBS=$ac_check_lib_save_LIBS
3798 + fi
3799 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_c_dlopen" >&5
3800 + $as_echo "$ac_cv_lib_c_dlopen" >&6; }
3801 + if test "x$ac_cv_lib_c_dlopen" = xyes; then :
3802 +  LIBDL=""
3803 + else
3804 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
3805 + $as_echo_n "checking for dlopen in -ldl... " >&6; }
3806 + if ${ac_cv_lib_dl_dlopen+:} false; then :
3807 +  $as_echo_n "(cached) " >&6
3808 + else
3809 +  ac_check_lib_save_LIBS=$LIBS
3810 + LIBS="-ldl  $LIBS"
3811 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3812 + /* end confdefs.h.  */
3813 +
3814 + /* Override any GCC internal prototype to avoid an error.
3815 +   Use char because int might match the return type of a GCC
3816 +   builtin and then its argument prototype would still apply.  */
3817 + #ifdef __cplusplus
3818 + extern "C"
3819 + #endif
3820 + char dlopen ();
3821 + int
3822 + main ()
3823 + {
3824 + return dlopen ();
3825 +  ;
3826 +  return 0;
3827 + }
3828 + _ACEOF
3829 + if ac_fn_cxx_try_link "$LINENO"; then :
3830 +  ac_cv_lib_dl_dlopen=yes
3831 + else
3832 +  ac_cv_lib_dl_dlopen=no
3833 + fi
3834 + rm -f core conftest.err conftest.$ac_objext \
3835 +    conftest$ac_exeext conftest.$ac_ext
3836 + LIBS=$ac_check_lib_save_LIBS
3837 + fi
3838 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
3839 + $as_echo "$ac_cv_lib_dl_dlopen" >&6; }
3840 + if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
3841 +  LIBDL="-ldl"
3842 + fi
3843 +
3844 + fi
3845 +
3846 +
3847 +
3848 +
3849 +
3850 +
3851 +
3852 +        for ac_prog in openmpicxx openmpiCC openmpic++ mpic++ mpicxx mpiCC hcp mpxlC_r mpxlC mpCC cmpic++
3853 + do
3854 +  # Extract the first word of "$ac_prog", so it can be a program name with args.
3855 + set dummy $ac_prog; ac_word=$2
3856 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3857 + $as_echo_n "checking for $ac_word... " >&6; }
3858 + if ${ac_cv_prog_MPICXX+:} false; then :
3859 +  $as_echo_n "(cached) " >&6
3860 + else
3861 +  if test -n "$MPICXX"; then
3862 +  ac_cv_prog_MPICXX="$MPICXX" # Let the user override the test.
3863 + else
3864   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3865   for as_dir in $PATH
3866   do
3867    IFS=$as_save_IFS
3868    test -z "$as_dir" && as_dir=.
3869 <  for ac_exec_ext in '' $ac_executable_extensions; do
3869 >    for ac_exec_ext in '' $ac_executable_extensions; do
3870    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3871 <    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
3872 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3871 >    ac_cv_prog_MPICXX="$ac_prog"
3872 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3873      break 2
3874    fi
3875   done
3876 < done
3876 >  done
3877   IFS=$as_save_IFS
3878  
3879   fi
3880   fi
3881 < FC=$ac_cv_prog_FC
3882 < if test -n "$FC"; then
3883 <  { echo "$as_me:$LINENO: result: $FC" >&5
3884 < echo "${ECHO_T}$FC" >&6; }
3881 > MPICXX=$ac_cv_prog_MPICXX
3882 > if test -n "$MPICXX"; then
3883 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICXX" >&5
3884 > $as_echo "$MPICXX" >&6; }
3885   else
3886 <  { echo "$as_me:$LINENO: result: no" >&5
3887 < echo "${ECHO_T}no" >&6; }
3886 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3887 > $as_echo "no" >&6; }
3888   fi
3889  
3890  
3891 <    test -n "$FC" && break
3892 <  done
3891 >  test -n "$MPICXX" && break
3892 > done
3893 > test -n "$MPICXX" || MPICXX="$CXX"
3894 >
3895 >        ax_mpi_save_CXX="$CXX"
3896 >        CXX="$MPICXX"
3897 >
3898 >
3899 >
3900 > if test x = x"$MPILIBS"; then
3901 >        ac_fn_cxx_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
3902 > if test "x$ac_cv_func_MPI_Init" = xyes; then :
3903 >  MPILIBS=" "
3904   fi
3905 < if test -z "$FC"; then
3906 <  ac_ct_FC=$FC
3907 <  for ac_prog in mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
3905 >
3906 > fi
3907 >
3908 > if test x = x"$MPILIBS"; then
3909 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
3910 > $as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
3911 > if ${ac_cv_lib_mpi_MPI_Init+:} false; then :
3912 >  $as_echo_n "(cached) " >&6
3913 > else
3914 >  ac_check_lib_save_LIBS=$LIBS
3915 > LIBS="-lmpi  $LIBS"
3916 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3917 > /* end confdefs.h.  */
3918 >
3919 > /* Override any GCC internal prototype to avoid an error.
3920 >   Use char because int might match the return type of a GCC
3921 >   builtin and then its argument prototype would still apply.  */
3922 > #ifdef __cplusplus
3923 > extern "C"
3924 > #endif
3925 > char MPI_Init ();
3926 > int
3927 > main ()
3928 > {
3929 > return MPI_Init ();
3930 >  ;
3931 >  return 0;
3932 > }
3933 > _ACEOF
3934 > if ac_fn_cxx_try_link "$LINENO"; then :
3935 >  ac_cv_lib_mpi_MPI_Init=yes
3936 > else
3937 >  ac_cv_lib_mpi_MPI_Init=no
3938 > fi
3939 > rm -f core conftest.err conftest.$ac_objext \
3940 >    conftest$ac_exeext conftest.$ac_ext
3941 > LIBS=$ac_check_lib_save_LIBS
3942 > fi
3943 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
3944 > $as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
3945 > if test "x$ac_cv_lib_mpi_MPI_Init" = xyes; then :
3946 >  MPILIBS="-lmpi"
3947 > fi
3948 >
3949 > fi
3950 > if test x = x"$MPILIBS"; then
3951 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
3952 > $as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
3953 > if ${ac_cv_lib_mpich_MPI_Init+:} false; then :
3954 >  $as_echo_n "(cached) " >&6
3955 > else
3956 >  ac_check_lib_save_LIBS=$LIBS
3957 > LIBS="-lmpich  $LIBS"
3958 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3959 > /* end confdefs.h.  */
3960 >
3961 > /* Override any GCC internal prototype to avoid an error.
3962 >   Use char because int might match the return type of a GCC
3963 >   builtin and then its argument prototype would still apply.  */
3964 > #ifdef __cplusplus
3965 > extern "C"
3966 > #endif
3967 > char MPI_Init ();
3968 > int
3969 > main ()
3970 > {
3971 > return MPI_Init ();
3972 >  ;
3973 >  return 0;
3974 > }
3975 > _ACEOF
3976 > if ac_fn_cxx_try_link "$LINENO"; then :
3977 >  ac_cv_lib_mpich_MPI_Init=yes
3978 > else
3979 >  ac_cv_lib_mpich_MPI_Init=no
3980 > fi
3981 > rm -f core conftest.err conftest.$ac_objext \
3982 >    conftest$ac_exeext conftest.$ac_ext
3983 > LIBS=$ac_check_lib_save_LIBS
3984 > fi
3985 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
3986 > $as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
3987 > if test "x$ac_cv_lib_mpich_MPI_Init" = xyes; then :
3988 >  MPILIBS="-lmpich"
3989 > fi
3990 >
3991 > fi
3992 >
3993 > if test x != x"$MPILIBS"; then
3994 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
3995 > $as_echo_n "checking for mpi.h... " >&6; }
3996 >        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3997 > /* end confdefs.h.  */
3998 > #include <mpi.h>
3999 > int
4000 > main ()
4001 > {
4002 >
4003 >  ;
4004 >  return 0;
4005 > }
4006 > _ACEOF
4007 > if ac_fn_cxx_try_compile "$LINENO"; then :
4008 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4009 > $as_echo "yes" >&6; }
4010 > else
4011 >  MPILIBS=""
4012 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4013 > $as_echo "no" >&6; }
4014 > fi
4015 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4016 > fi
4017 >
4018 > CXX="$ax_mpi_save_CXX"
4019 >
4020 >
4021 >
4022 > # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4023 > if test x = x"$MPILIBS"; then
4024 >        USE_MPI="no"
4025 >       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C++ MPI implementation found. openmd_MPI will not be built." >&5
4026 > $as_echo "$as_me: WARNING: No suitable C++ MPI implementation found. openmd_MPI will not be built." >&2;}
4027 >        :
4028 > else
4029 >        USE_MPI="yes"
4030 >        :
4031 > fi
4032 >
4033 >
4034 > if test $USE_MPI != no; then :
4035 >
4036 > ac_ext=c
4037 > ac_cpp='$CPP $CPPFLAGS'
4038 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4039 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4040 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4041 >
4042 >
4043 >
4044 >
4045 >
4046 >
4047 >        for ac_prog in openmpicc mpicc hcc mpxlc_r mpxlc mpcc cmpicc
4048   do
4049    # Extract the first word of "$ac_prog", so it can be a program name with args.
4050   set dummy $ac_prog; ac_word=$2
4051 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
4052 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
4053 < if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
4054 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4051 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4052 > $as_echo_n "checking for $ac_word... " >&6; }
4053 > if ${ac_cv_prog_MPICC+:} false; then :
4054 >  $as_echo_n "(cached) " >&6
4055   else
4056 <  if test -n "$ac_ct_FC"; then
4057 <  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
4056 >  if test -n "$MPICC"; then
4057 >  ac_cv_prog_MPICC="$MPICC" # Let the user override the test.
4058   else
4059   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4060   for as_dir in $PATH
4061   do
4062    IFS=$as_save_IFS
4063    test -z "$as_dir" && as_dir=.
4064 <  for ac_exec_ext in '' $ac_executable_extensions; do
4064 >    for ac_exec_ext in '' $ac_executable_extensions; do
4065    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4066 <    ac_cv_prog_ac_ct_FC="$ac_prog"
4067 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4066 >    ac_cv_prog_MPICC="$ac_prog"
4067 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4068      break 2
4069    fi
4070   done
4071 < done
4071 >  done
4072   IFS=$as_save_IFS
4073  
4074   fi
4075   fi
4076 < ac_ct_FC=$ac_cv_prog_ac_ct_FC
4077 < if test -n "$ac_ct_FC"; then
4078 <  { echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
4079 < echo "${ECHO_T}$ac_ct_FC" >&6; }
4076 > MPICC=$ac_cv_prog_MPICC
4077 > if test -n "$MPICC"; then
4078 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICC" >&5
4079 > $as_echo "$MPICC" >&6; }
4080   else
4081 <  { echo "$as_me:$LINENO: result: no" >&5
4082 < echo "${ECHO_T}no" >&6; }
4081 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4082 > $as_echo "no" >&6; }
4083   fi
4084  
4085  
4086 <  test -n "$ac_ct_FC" && break
4086 >  test -n "$MPICC" && break
4087   done
4088 + test -n "$MPICC" || MPICC="$CC"
4089  
4090 <  if test "x$ac_ct_FC" = x; then
4091 <    FC=""
3299 <  else
3300 <    case $cross_compiling:$ac_tool_warned in
3301 < yes:)
3302 < { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
3303 < whose name does not start with the host triplet.  If you think this
3304 < configuration is useful to you, please write to autoconf@gnu.org." >&5
3305 < echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
3306 < whose name does not start with the host triplet.  If you think this
3307 < configuration is useful to you, please write to autoconf@gnu.org." >&2;}
3308 < ac_tool_warned=yes ;;
3309 < esac
3310 <    FC=$ac_ct_FC
3311 <  fi
3312 < fi
4090 >        ax_mpi_save_CC="$CC"
4091 >        CC="$MPICC"
4092  
4093  
3315 – # Provide some information about the compiler.
3316 – echo "$as_me:$LINENO: checking for Fortran compiler version" >&5
3317 – ac_compiler=`set X $ac_compile; echo $2`
3318 – { (ac_try="$ac_compiler --version >&5"
3319 – case "(($ac_try" in
3320 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3321 –  *) ac_try_echo=$ac_try;;
3322 – esac
3323 – eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3324 –  (eval "$ac_compiler --version >&5") 2>&5
3325 –  ac_status=$?
3326 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3327 –  (exit $ac_status); }
3328 – { (ac_try="$ac_compiler -v >&5"
3329 – case "(($ac_try" in
3330 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3331 –  *) ac_try_echo=$ac_try;;
3332 – esac
3333 – eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3334 –  (eval "$ac_compiler -v >&5") 2>&5
3335 –  ac_status=$?
3336 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3337 –  (exit $ac_status); }
3338 – { (ac_try="$ac_compiler -V >&5"
3339 – case "(($ac_try" in
3340 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3341 –  *) ac_try_echo=$ac_try;;
3342 – esac
3343 – eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3344 –  (eval "$ac_compiler -V >&5") 2>&5
3345 –  ac_status=$?
3346 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3347 –  (exit $ac_status); }
3348 – rm -rf a.out
4094  
4095 < # If we don't use `.F' as extension, the preprocessor is not run on the
4096 < # input file.  (Note that this only needs to work for GNU compilers.)
4097 < ac_save_ext=$ac_ext
4098 < ac_ext=F
4099 < { echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
4100 < echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6; }
4101 < if test "${ac_cv_fc_compiler_gnu+set}" = set; then
4102 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4095 > if test x = x"$MPILIBS"; then
4096 >        ac_fn_c_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
4097 > if test "x$ac_cv_func_MPI_Init" = xyes; then :
4098 >  MPILIBS=" "
4099 > fi
4100 >
4101 > fi
4102 >
4103 > if test x = x"$MPILIBS"; then
4104 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
4105 > $as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
4106 > if ${ac_cv_lib_mpi_MPI_Init+:} false; then :
4107 >  $as_echo_n "(cached) " >&6
4108   else
4109 <  cat >conftest.$ac_ext <<_ACEOF
4110 <      program main
4111 < #ifndef __GNUC__
4112 <       choke me
3363 < #endif
4109 >  ac_check_lib_save_LIBS=$LIBS
4110 > LIBS="-lmpi  $LIBS"
4111 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4112 > /* end confdefs.h.  */
4113  
4114 <      end
4114 > /* Override any GCC internal prototype to avoid an error.
4115 >   Use char because int might match the return type of a GCC
4116 >   builtin and then its argument prototype would still apply.  */
4117 > #ifdef __cplusplus
4118 > extern "C"
4119 > #endif
4120 > char MPI_Init ();
4121 > int
4122 > main ()
4123 > {
4124 > return MPI_Init ();
4125 >  ;
4126 >  return 0;
4127 > }
4128   _ACEOF
4129 < rm -rf conftest.$ac_objext
4130 < if { (ac_try="$ac_compile"
3369 < case "(($ac_try" in
3370 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3371 <  *) ac_try_echo=$ac_try;;
3372 < esac
3373 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3374 <  (eval "$ac_compile") 2>conftest.er1
3375 <  ac_status=$?
3376 <  grep -v '^ *+' conftest.er1 >conftest.err
3377 <  rm -f conftest.er1
3378 <  cat conftest.err >&5
3379 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3380 <  (exit $ac_status); } && {
3381 <         test -z "$ac_fc_werror_flag" ||
3382 <         test ! -s conftest.err
3383 <       } && test -s conftest.$ac_objext; then
3384 <  ac_compiler_gnu=yes
4129 > if ac_fn_c_try_link "$LINENO"; then :
4130 >  ac_cv_lib_mpi_MPI_Init=yes
4131   else
4132 <  echo "$as_me: failed program was:" >&5
3387 < sed 's/^/| /' conftest.$ac_ext >&5
3388 <
3389 <        ac_compiler_gnu=no
4132 >  ac_cv_lib_mpi_MPI_Init=no
4133   fi
4134 + rm -f core conftest.err conftest.$ac_objext \
4135 +    conftest$ac_exeext conftest.$ac_ext
4136 + LIBS=$ac_check_lib_save_LIBS
4137 + fi
4138 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
4139 + $as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
4140 + if test "x$ac_cv_lib_mpi_MPI_Init" = xyes; then :
4141 +  MPILIBS="-lmpi"
4142 + fi
4143  
3392 – rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
3393 – ac_cv_fc_compiler_gnu=$ac_compiler_gnu
3394 –
4144   fi
4145 < { echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
4146 < echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6; }
4147 < ac_ext=$ac_save_ext
4148 < ac_test_FFLAGS=${FCFLAGS+set}
4149 < ac_save_FFLAGS=$FCFLAGS
3401 < FCFLAGS=
3402 < { echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
3403 < echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6; }
3404 < if test "${ac_cv_prog_fc_g+set}" = set; then
3405 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4145 > if test x = x"$MPILIBS"; then
4146 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4147 > $as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4148 > if ${ac_cv_lib_mpich_MPI_Init+:} false; then :
4149 >  $as_echo_n "(cached) " >&6
4150   else
4151 <  FCFLAGS=-g
4152 < cat >conftest.$ac_ext <<_ACEOF
4153 <      program main
4151 >  ac_check_lib_save_LIBS=$LIBS
4152 > LIBS="-lmpich  $LIBS"
4153 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4154 > /* end confdefs.h.  */
4155  
4156 <      end
4156 > /* Override any GCC internal prototype to avoid an error.
4157 >   Use char because int might match the return type of a GCC
4158 >   builtin and then its argument prototype would still apply.  */
4159 > #ifdef __cplusplus
4160 > extern "C"
4161 > #endif
4162 > char MPI_Init ();
4163 > int
4164 > main ()
4165 > {
4166 > return MPI_Init ();
4167 >  ;
4168 >  return 0;
4169 > }
4170   _ACEOF
4171 < rm -rf conftest.$ac_objext
4172 < if { (ac_try="$ac_compile"
3415 < case "(($ac_try" in
3416 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3417 <  *) ac_try_echo=$ac_try;;
3418 < esac
3419 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3420 <  (eval "$ac_compile") 2>conftest.er1
3421 <  ac_status=$?
3422 <  grep -v '^ *+' conftest.er1 >conftest.err
3423 <  rm -f conftest.er1
3424 <  cat conftest.err >&5
3425 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3426 <  (exit $ac_status); } && {
3427 <         test -z "$ac_fc_werror_flag" ||
3428 <         test ! -s conftest.err
3429 <       } && test -s conftest.$ac_objext; then
3430 <  ac_cv_prog_fc_g=yes
4171 > if ac_fn_c_try_link "$LINENO"; then :
4172 >  ac_cv_lib_mpich_MPI_Init=yes
4173   else
4174 <  echo "$as_me: failed program was:" >&5
4175 < sed 's/^/| /' conftest.$ac_ext >&5
4174 >  ac_cv_lib_mpich_MPI_Init=no
4175 > fi
4176 > rm -f core conftest.err conftest.$ac_objext \
4177 >    conftest$ac_exeext conftest.$ac_ext
4178 > LIBS=$ac_check_lib_save_LIBS
4179 > fi
4180 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4181 > $as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4182 > if test "x$ac_cv_lib_mpich_MPI_Init" = xyes; then :
4183 >  MPILIBS="-lmpich"
4184 > fi
4185  
3435 –        ac_cv_prog_fc_g=no
4186   fi
4187  
4188 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
4188 > if test x != x"$MPILIBS"; then
4189 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4190 > $as_echo_n "checking for mpi.h... " >&6; }
4191 >        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4192 > /* end confdefs.h.  */
4193 > #include <mpi.h>
4194 > int
4195 > main ()
4196 > {
4197  
4198 +  ;
4199 +  return 0;
4200 + }
4201 + _ACEOF
4202 + if ac_fn_c_try_compile "$LINENO"; then :
4203 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4204 + $as_echo "yes" >&6; }
4205 + else
4206 +  MPILIBS=""
4207 +                { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4208 + $as_echo "no" >&6; }
4209   fi
4210 < { echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
4211 < echo "${ECHO_T}$ac_cv_prog_fc_g" >&6; }
4212 < if test "$ac_test_FFLAGS" = set; then
4213 <  FCFLAGS=$ac_save_FFLAGS
4214 < elif test $ac_cv_prog_fc_g = yes; then
4215 <  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4216 <    FCFLAGS="-g -O2"
4217 <  else
4218 <    FCFLAGS="-g"
4219 <  fi
4210 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4211 > fi
4212 >
4213 > CC="$ax_mpi_save_CC"
4214 >
4215 >
4216 >
4217 > # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4218 > if test x = x"$MPILIBS"; then
4219 >        USE_MPI="no"
4220 >       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C MPI implementation found. openmd_MPI will not be built." >&5
4221 > $as_echo "$as_me: WARNING: No suitable C MPI implementation found. openmd_MPI will not be built." >&2;}
4222 >        :
4223   else
4224 <  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4225 <    FCFLAGS="-O2"
3454 <  else
3455 <    FCFLAGS=
3456 <  fi
4224 >        USE_MPI="yes"
4225 >        :
4226   fi
4227  
3459 – ac_ext=c
3460 – ac_cpp='$CPP $CPPFLAGS'
3461 – ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3462 – ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3463 – ac_compiler_gnu=$ac_cv_c_compiler_gnu
4228  
4229 + fi
4230 + if test $USE_MPI != no; then :
4231 +
4232 +        CXX=$MPICXX
4233 +        CC=$MPICC
4234 +        LIBS="$MPILIBS $LIBS"
4235 +
4236 + else
4237 +
4238 +        CXX=$save_CXX
4239 +        CC=$save_CC
4240 +        LIBS=$save_LIBS
4241 +
4242 +
4243 + fi
4244 +
4245 +
4246 + # Checks for programs.
4247   ac_ext=c
4248   ac_cpp='$CPP $CPPFLAGS'
4249   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4250   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4251   ac_compiler_gnu=$ac_cv_c_compiler_gnu
4252 < { echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4253 < echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6; }
4252 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
4253 > $as_echo_n "checking how to run the C preprocessor... " >&6; }
4254   # On Suns, sometimes $CPP names a directory.
4255   if test -n "$CPP" && test -d "$CPP"; then
4256    CPP=
4257   fi
4258   if test -z "$CPP"; then
4259 <  if test "${ac_cv_prog_CPP+set}" = set; then
4260 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4259 >  if ${ac_cv_prog_CPP+:} false; then :
4260 >  $as_echo_n "(cached) " >&6
4261   else
4262        # Double quotes because CPP needs to be expanded
4263      for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
# Line 3489 | Line 4271 | do
4271    # <limits.h> exists even on freestanding compilers.
4272    # On the NeXT, cc -E runs the code through the compiler's parser,
4273    # not just through cpp. "Syntax error" is here to catch this case.
4274 <  cat >conftest.$ac_ext <<_ACEOF
3493 < /* confdefs.h.  */
3494 < _ACEOF
3495 < cat confdefs.h >>conftest.$ac_ext
3496 < cat >>conftest.$ac_ext <<_ACEOF
4274 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4275   /* end confdefs.h.  */
4276   #ifdef __STDC__
4277   # include <limits.h>
# Line 3502 | Line 4280 | _ACEOF
4280   #endif
4281                       Syntax error
4282   _ACEOF
4283 < if { (ac_try="$ac_cpp conftest.$ac_ext"
3506 < case "(($ac_try" in
3507 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3508 <  *) ac_try_echo=$ac_try;;
3509 < esac
3510 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3511 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
3512 <  ac_status=$?
3513 <  grep -v '^ *+' conftest.er1 >conftest.err
3514 <  rm -rf conftest.er1
3515 <  cat conftest.err >&5
3516 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3517 <  (exit $ac_status); } >/dev/null && {
3518 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
3519 <         test ! -s conftest.err
3520 <       }; then
3521 <  :
3522 < else
3523 <  echo "$as_me: failed program was:" >&5
3524 < sed 's/^/| /' conftest.$ac_ext >&5
4283 > if ac_fn_c_try_cpp "$LINENO"; then :
4284  
4285 + else
4286    # Broken: fails on valid input.
4287   continue
4288   fi
4289 + rm -f conftest.err conftest.i conftest.$ac_ext
4290  
3530 – rm -rf conftest.err conftest.$ac_ext
3531 –
4291    # OK, works on sane cases.  Now check whether nonexistent headers
4292    # can be detected and how.
4293 <  cat >conftest.$ac_ext <<_ACEOF
3535 < /* confdefs.h.  */
3536 < _ACEOF
3537 < cat confdefs.h >>conftest.$ac_ext
3538 < cat >>conftest.$ac_ext <<_ACEOF
4293 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4294   /* end confdefs.h.  */
4295   #include <ac_nonexistent.h>
4296   _ACEOF
4297 < if { (ac_try="$ac_cpp conftest.$ac_ext"
3543 < case "(($ac_try" in
3544 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3545 <  *) ac_try_echo=$ac_try;;
3546 < esac
3547 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3548 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
3549 <  ac_status=$?
3550 <  grep -v '^ *+' conftest.er1 >conftest.err
3551 <  rm -f conftest.er1
3552 <  cat conftest.err >&5
3553 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3554 <  (exit $ac_status); } >/dev/null && {
3555 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
3556 <         test ! -s conftest.err
3557 <       }; then
4297 > if ac_fn_c_try_cpp "$LINENO"; then :
4298    # Broken: success on invalid input.
4299   continue
4300   else
3561 –  echo "$as_me: failed program was:" >&5
3562 – sed 's/^/| /' conftest.$ac_ext >&5
3563 –
4301    # Passes both tests.
4302   ac_preproc_ok=:
4303   break
4304   fi
4305 + rm -f conftest.err conftest.i conftest.$ac_ext
4306  
3569 – rm -rf conftest.err conftest.$ac_ext
3570 –
4307   done
4308   # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4309 < rm -rf conftest.err conftest.$ac_ext
4310 < if $ac_preproc_ok; then
4309 > rm -f conftest.i conftest.err conftest.$ac_ext
4310 > if $ac_preproc_ok; then :
4311    break
4312   fi
4313  
# Line 3583 | Line 4319 | fi
4319   else
4320    ac_cv_prog_CPP=$CPP
4321   fi
4322 < { echo "$as_me:$LINENO: result: $CPP" >&5
4323 < echo "${ECHO_T}$CPP" >&6; }
4322 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
4323 > $as_echo "$CPP" >&6; }
4324   ac_preproc_ok=false
4325   for ac_c_preproc_warn_flag in '' yes
4326   do
# Line 3594 | Line 4330 | do
4330    # <limits.h> exists even on freestanding compilers.
4331    # On the NeXT, cc -E runs the code through the compiler's parser,
4332    # not just through cpp. "Syntax error" is here to catch this case.
4333 <  cat >conftest.$ac_ext <<_ACEOF
3598 < /* confdefs.h.  */
3599 < _ACEOF
3600 < cat confdefs.h >>conftest.$ac_ext
3601 < cat >>conftest.$ac_ext <<_ACEOF
4333 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4334   /* end confdefs.h.  */
4335   #ifdef __STDC__
4336   # include <limits.h>
# Line 3607 | Line 4339 | _ACEOF
4339   #endif
4340                       Syntax error
4341   _ACEOF
4342 < if { (ac_try="$ac_cpp conftest.$ac_ext"
3611 < case "(($ac_try" in
3612 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3613 <  *) ac_try_echo=$ac_try;;
3614 < esac
3615 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3616 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
3617 <  ac_status=$?
3618 <  grep -v '^ *+' conftest.er1 >conftest.err
3619 <  rm -f conftest.er1
3620 <  cat conftest.err >&5
3621 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3622 <  (exit $ac_status); } >/dev/null && {
3623 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
3624 <         test ! -s conftest.err
3625 <       }; then
3626 <  :
3627 < else
3628 <  echo "$as_me: failed program was:" >&5
3629 < sed 's/^/| /' conftest.$ac_ext >&5
4342 > if ac_fn_c_try_cpp "$LINENO"; then :
4343  
4344 + else
4345    # Broken: fails on valid input.
4346   continue
4347   fi
4348 + rm -f conftest.err conftest.i conftest.$ac_ext
4349  
3635 – rm -rf conftest.err conftest.$ac_ext
3636 –
4350    # OK, works on sane cases.  Now check whether nonexistent headers
4351    # can be detected and how.
4352 <  cat >conftest.$ac_ext <<_ACEOF
3640 < /* confdefs.h.  */
3641 < _ACEOF
3642 < cat confdefs.h >>conftest.$ac_ext
3643 < cat >>conftest.$ac_ext <<_ACEOF
4352 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4353   /* end confdefs.h.  */
4354   #include <ac_nonexistent.h>
4355   _ACEOF
4356 < if { (ac_try="$ac_cpp conftest.$ac_ext"
3648 < case "(($ac_try" in
3649 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3650 <  *) ac_try_echo=$ac_try;;
3651 < esac
3652 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3653 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
3654 <  ac_status=$?
3655 <  grep -v '^ *+' conftest.er1 >conftest.err
3656 <  rm -f conftest.er1
3657 <  cat conftest.err >&5
3658 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3659 <  (exit $ac_status); } >/dev/null && {
3660 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
3661 <         test ! -s conftest.err
3662 <       }; then
4356 > if ac_fn_c_try_cpp "$LINENO"; then :
4357    # Broken: success on invalid input.
4358   continue
4359   else
3666 –  echo "$as_me: failed program was:" >&5
3667 – sed 's/^/| /' conftest.$ac_ext >&5
3668 –
4360    # Passes both tests.
4361   ac_preproc_ok=:
4362   break
4363   fi
4364 + rm -f conftest.err conftest.i conftest.$ac_ext
4365  
3674 – rm -rf conftest.err conftest.$ac_ext
3675 –
4366   done
4367   # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4368 < rm -rf conftest.err conftest.$ac_ext
4369 < if $ac_preproc_ok; then
4370 <  :
4368 > rm -f conftest.i conftest.err conftest.$ac_ext
4369 > if $ac_preproc_ok; then :
4370 >
4371   else
4372 <  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
4373 < See \`config.log' for more details." >&5
4374 < echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
4375 < See \`config.log' for more details." >&2;}
3686 <   { (exit 1); exit 1; }; }
4372 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
4373 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
4374 > as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
4375 > See \`config.log' for more details" "$LINENO" 5; }
4376   fi
4377  
4378   ac_ext=c
# Line 3692 | Line 4381 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
4381   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4382   ac_compiler_gnu=$ac_cv_c_compiler_gnu
4383  
4384 < { echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5
4385 < echo $ECHO_N "checking for grep that handles long lines and -e... $ECHO_C" >&6; }
4386 < if test "${ac_cv_path_GREP+set}" = set; then
4387 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4384 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
4385 > $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
4386 > if ${ac_cv_path_GREP+:} false; then :
4387 >  $as_echo_n "(cached) " >&6
4388   else
4389 <  # Extract the first word of "grep ggrep" to use in msg output
3701 < if test -z "$GREP"; then
3702 < set dummy grep ggrep; ac_prog_name=$2
3703 < if test "${ac_cv_path_GREP+set}" = set; then
3704 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3705 < else
4389 >  if test -z "$GREP"; then
4390    ac_path_GREP_found=false
4391 < # Loop through the user's path and test for each of PROGNAME-LIST
4392 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4391 >  # Loop through the user's path and test for each of PROGNAME-LIST
4392 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4393   for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
4394   do
4395    IFS=$as_save_IFS
4396    test -z "$as_dir" && as_dir=.
4397 <  for ac_prog in grep ggrep; do
4398 <  for ac_exec_ext in '' $ac_executable_extensions; do
4399 <    ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
4400 <    { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
4401 <    # Check for GNU ac_path_GREP and select it if it is found.
4397 >    for ac_prog in grep ggrep; do
4398 >    for ac_exec_ext in '' $ac_executable_extensions; do
4399 >      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
4400 >      { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
4401 > # Check for GNU ac_path_GREP and select it if it is found.
4402    # Check for GNU $ac_path_GREP
4403   case `"$ac_path_GREP" --version 2>&1` in
4404   *GNU*)
4405    ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
4406   *)
4407    ac_count=0
4408 <  echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"
4408 >  $as_echo_n 0123456789 >"conftest.in"
4409    while :
4410    do
4411      cat "conftest.in" "conftest.in" >"conftest.tmp"
4412      mv "conftest.tmp" "conftest.in"
4413      cp "conftest.in" "conftest.nl"
4414 <    echo 'GREP' >> "conftest.nl"
4414 >    $as_echo 'GREP' >> "conftest.nl"
4415      "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
4416      diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
4417 <    ac_count=`expr $ac_count + 1`
4417 >    as_fn_arith $ac_count + 1 && ac_count=$as_val
4418      if test $ac_count -gt ${ac_path_GREP_max-0}; then
4419        # Best one so far, save it but keep looking for a better one
4420        ac_cv_path_GREP="$ac_path_GREP"
# Line 3739 | Line 4423 | case `"$ac_path_GREP" --version 2>&1` in
4423      # 10*(2^10) chars as input seems more than enough
4424      test $ac_count -gt 10 && break
4425    done
4426 <  rm -rf conftest.in conftest.tmp conftest.nl conftest.out;;
4426 >  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
4427   esac
4428  
4429 <
4430 <    $ac_path_GREP_found && break 3
4429 >      $ac_path_GREP_found && break 3
4430 >    done
4431    done
4432 < done
3749 <
3750 < done
4432 >  done
4433   IFS=$as_save_IFS
4434 <
4435 <
4436 < fi
3755 <
3756 < GREP="$ac_cv_path_GREP"
3757 < if test -z "$GREP"; then
3758 <  { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
3759 < echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
3760 <   { (exit 1); exit 1; }; }
3761 < fi
3762 <
4434 >  if test -z "$ac_cv_path_GREP"; then
4435 >    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
4436 >  fi
4437   else
4438    ac_cv_path_GREP=$GREP
4439   fi
4440  
3767 –
4441   fi
4442 < { echo "$as_me:$LINENO: result: $ac_cv_path_GREP" >&5
4443 < echo "${ECHO_T}$ac_cv_path_GREP" >&6; }
4442 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
4443 > $as_echo "$ac_cv_path_GREP" >&6; }
4444   GREP="$ac_cv_path_GREP"
4445  
4446  
4447 < { echo "$as_me:$LINENO: checking for egrep" >&5
4448 < echo $ECHO_N "checking for egrep... $ECHO_C" >&6; }
4449 < if test "${ac_cv_path_EGREP+set}" = set; then
4450 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4447 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
4448 > $as_echo_n "checking for egrep... " >&6; }
4449 > if ${ac_cv_path_EGREP+:} false; then :
4450 >  $as_echo_n "(cached) " >&6
4451   else
4452    if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
4453     then ac_cv_path_EGREP="$GREP -E"
4454     else
4455 <     # Extract the first word of "egrep" to use in msg output
3783 < if test -z "$EGREP"; then
3784 < set dummy egrep; ac_prog_name=$2
3785 < if test "${ac_cv_path_EGREP+set}" = set; then
3786 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3787 < else
4455 >     if test -z "$EGREP"; then
4456    ac_path_EGREP_found=false
4457 < # Loop through the user's path and test for each of PROGNAME-LIST
4458 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4457 >  # Loop through the user's path and test for each of PROGNAME-LIST
4458 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4459   for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
4460   do
4461    IFS=$as_save_IFS
4462    test -z "$as_dir" && as_dir=.
4463 <  for ac_prog in egrep; do
4464 <  for ac_exec_ext in '' $ac_executable_extensions; do
4465 <    ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
4466 <    { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
4467 <    # Check for GNU ac_path_EGREP and select it if it is found.
4463 >    for ac_prog in egrep; do
4464 >    for ac_exec_ext in '' $ac_executable_extensions; do
4465 >      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
4466 >      { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
4467 > # Check for GNU ac_path_EGREP and select it if it is found.
4468    # Check for GNU $ac_path_EGREP
4469   case `"$ac_path_EGREP" --version 2>&1` in
4470   *GNU*)
4471    ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
4472   *)
4473    ac_count=0
4474 <  echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"
4474 >  $as_echo_n 0123456789 >"conftest.in"
4475    while :
4476    do
4477      cat "conftest.in" "conftest.in" >"conftest.tmp"
4478      mv "conftest.tmp" "conftest.in"
4479      cp "conftest.in" "conftest.nl"
4480 <    echo 'EGREP' >> "conftest.nl"
4480 >    $as_echo 'EGREP' >> "conftest.nl"
4481      "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
4482      diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
4483 <    ac_count=`expr $ac_count + 1`
4483 >    as_fn_arith $ac_count + 1 && ac_count=$as_val
4484      if test $ac_count -gt ${ac_path_EGREP_max-0}; then
4485        # Best one so far, save it but keep looking for a better one
4486        ac_cv_path_EGREP="$ac_path_EGREP"
# Line 3821 | Line 4489 | case `"$ac_path_EGREP" --version 2>&1` in
4489      # 10*(2^10) chars as input seems more than enough
4490      test $ac_count -gt 10 && break
4491    done
4492 <  rm -rf conftest.in conftest.tmp conftest.nl conftest.out;;
4492 >  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
4493   esac
4494  
4495 <
4496 <    $ac_path_EGREP_found && break 3
4495 >      $ac_path_EGREP_found && break 3
4496 >    done
4497    done
4498 < done
3831 <
3832 < done
4498 >  done
4499   IFS=$as_save_IFS
4500 <
4501 <
4502 < fi
3837 <
3838 < EGREP="$ac_cv_path_EGREP"
3839 < if test -z "$EGREP"; then
3840 <  { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
3841 < echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
3842 <   { (exit 1); exit 1; }; }
3843 < fi
3844 <
4500 >  if test -z "$ac_cv_path_EGREP"; then
4501 >    as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
4502 >  fi
4503   else
4504    ac_cv_path_EGREP=$EGREP
4505   fi
4506  
3849 –
4507     fi
4508   fi
4509 < { echo "$as_me:$LINENO: result: $ac_cv_path_EGREP" >&5
4510 < echo "${ECHO_T}$ac_cv_path_EGREP" >&6; }
4509 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
4510 > $as_echo "$ac_cv_path_EGREP" >&6; }
4511   EGREP="$ac_cv_path_EGREP"
4512  
4513  
4514 < { echo "$as_me:$LINENO: checking whether ln -s works" >&5
4515 < echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6; }
4514 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5
4515 > $as_echo_n "checking whether ln -s works... " >&6; }
4516   LN_S=$as_ln_s
4517   if test "$LN_S" = "ln -s"; then
4518 <  { echo "$as_me:$LINENO: result: yes" >&5
4519 < echo "${ECHO_T}yes" >&6; }
4518 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4519 > $as_echo "yes" >&6; }
4520   else
4521 <  { echo "$as_me:$LINENO: result: no, using $LN_S" >&5
4522 < echo "${ECHO_T}no, using $LN_S" >&6; }
4521 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5
4522 > $as_echo "no, using $LN_S" >&6; }
4523   fi
4524  
4525 < { echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
4526 < echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6; }
4527 < set x ${MAKE-make}; ac_make=`echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
4528 < if { as_var=ac_cv_prog_make_${ac_make}_set; eval "test \"\${$as_var+set}\" = set"; }; then
4529 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4525 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
4526 > $as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
4527 > set x ${MAKE-make}
4528 > ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
4529 > if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then :
4530 >  $as_echo_n "(cached) " >&6
4531   else
4532    cat >conftest.make <<\_ACEOF
4533   SHELL = /bin/sh
4534   all:
4535          @echo '@@@%%%=$(MAKE)=@@@%%%'
4536   _ACEOF
4537 < # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
4537 > # GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
4538   case `${MAKE-make} -f conftest.make 2>/dev/null` in
4539    *@@@%%%=?*=@@@%%%*)
4540      eval ac_cv_prog_make_${ac_make}_set=yes;;
4541    *)
4542      eval ac_cv_prog_make_${ac_make}_set=no;;
4543   esac
4544 < rm -rf conftest.make
4544 > rm -f conftest.make
4545   fi
4546   if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
4547 <  { echo "$as_me:$LINENO: result: yes" >&5
4548 < echo "${ECHO_T}yes" >&6; }
4547 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4548 > $as_echo "yes" >&6; }
4549    SET_MAKE=
4550   else
4551 <  { echo "$as_me:$LINENO: result: no" >&5
4552 < echo "${ECHO_T}no" >&6; }
4551 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4552 > $as_echo "no" >&6; }
4553    SET_MAKE="MAKE=${MAKE-make}"
4554   fi
4555  
4556   if test -n "$ac_tool_prefix"; then
4557    # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
4558   set dummy ${ac_tool_prefix}ranlib; ac_word=$2
4559 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
4560 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
4561 < if test "${ac_cv_prog_RANLIB+set}" = set; then
4562 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4559 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4560 > $as_echo_n "checking for $ac_word... " >&6; }
4561 > if ${ac_cv_prog_RANLIB+:} false; then :
4562 >  $as_echo_n "(cached) " >&6
4563   else
4564    if test -n "$RANLIB"; then
4565    ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
# Line 3911 | Line 4569 | do
4569   do
4570    IFS=$as_save_IFS
4571    test -z "$as_dir" && as_dir=.
4572 <  for ac_exec_ext in '' $ac_executable_extensions; do
4572 >    for ac_exec_ext in '' $ac_executable_extensions; do
4573    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4574      ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
4575 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4575 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4576      break 2
4577    fi
4578   done
4579 < done
4579 >  done
4580   IFS=$as_save_IFS
4581  
4582   fi
4583   fi
4584   RANLIB=$ac_cv_prog_RANLIB
4585   if test -n "$RANLIB"; then
4586 <  { echo "$as_me:$LINENO: result: $RANLIB" >&5
4587 < echo "${ECHO_T}$RANLIB" >&6; }
4586 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
4587 > $as_echo "$RANLIB" >&6; }
4588   else
4589 <  { echo "$as_me:$LINENO: result: no" >&5
4590 < echo "${ECHO_T}no" >&6; }
4589 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4590 > $as_echo "no" >&6; }
4591   fi
4592  
4593  
# Line 3938 | Line 4596 | set dummy ranlib; ac_word=$2
4596    ac_ct_RANLIB=$RANLIB
4597    # Extract the first word of "ranlib", so it can be a program name with args.
4598   set dummy ranlib; ac_word=$2
4599 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
4600 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
4601 < if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
4602 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4599 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4600 > $as_echo_n "checking for $ac_word... " >&6; }
4601 > if ${ac_cv_prog_ac_ct_RANLIB+:} false; then :
4602 >  $as_echo_n "(cached) " >&6
4603   else
4604    if test -n "$ac_ct_RANLIB"; then
4605    ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
# Line 3951 | Line 4609 | do
4609   do
4610    IFS=$as_save_IFS
4611    test -z "$as_dir" && as_dir=.
4612 <  for ac_exec_ext in '' $ac_executable_extensions; do
4612 >    for ac_exec_ext in '' $ac_executable_extensions; do
4613    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4614      ac_cv_prog_ac_ct_RANLIB="ranlib"
4615 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4615 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4616      break 2
4617    fi
4618   done
4619 < done
4619 >  done
4620   IFS=$as_save_IFS
4621  
4622   fi
4623   fi
4624   ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
4625   if test -n "$ac_ct_RANLIB"; then
4626 <  { echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
4627 < echo "${ECHO_T}$ac_ct_RANLIB" >&6; }
4626 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
4627 > $as_echo "$ac_ct_RANLIB" >&6; }
4628   else
4629 <  { echo "$as_me:$LINENO: result: no" >&5
4630 < echo "${ECHO_T}no" >&6; }
4629 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4630 > $as_echo "no" >&6; }
4631   fi
4632  
4633    if test "x$ac_ct_RANLIB" = x; then
# Line 3977 | Line 4635 | yes:)
4635    else
4636      case $cross_compiling:$ac_tool_warned in
4637   yes:)
4638 < { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
4639 < whose name does not start with the host triplet.  If you think this
3982 < configuration is useful to you, please write to autoconf@gnu.org." >&5
3983 < echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
3984 < whose name does not start with the host triplet.  If you think this
3985 < configuration is useful to you, please write to autoconf@gnu.org." >&2;}
4638 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4639 > $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4640   ac_tool_warned=yes ;;
4641   esac
4642      RANLIB=$ac_ct_RANLIB
# Line 3994 | Line 4648 | set dummy perl; ac_word=$2
4648  
4649     # Extract the first word of "perl", so it can be a program name with args.
4650   set dummy perl; ac_word=$2
4651 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
4652 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
4653 < if test "${ac_cv_path_PERLINTERP+set}" = set; then
4654 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4651 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4652 > $as_echo_n "checking for $ac_word... " >&6; }
4653 > if ${ac_cv_path_PERLINTERP+:} false; then :
4654 >  $as_echo_n "(cached) " >&6
4655   else
4656    case $PERLINTERP in
4657    [\\/]* | ?:[\\/]*)
# Line 4009 | Line 4663 | do
4663   do
4664    IFS=$as_save_IFS
4665    test -z "$as_dir" && as_dir=.
4666 <  for ac_exec_ext in '' $ac_executable_extensions; do
4666 >    for ac_exec_ext in '' $ac_executable_extensions; do
4667    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4668      ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
4669 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4669 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4670      break 2
4671    fi
4672   done
4673 < done
4673 >  done
4674   IFS=$as_save_IFS
4675  
4676    test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
# Line 4025 | Line 4679 | if test -n "$PERLINTERP"; then
4679   fi
4680   PERLINTERP=$ac_cv_path_PERLINTERP
4681   if test -n "$PERLINTERP"; then
4682 <  { echo "$as_me:$LINENO: result: $PERLINTERP" >&5
4683 < echo "${ECHO_T}$PERLINTERP" >&6; }
4682 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PERLINTERP" >&5
4683 > $as_echo "$PERLINTERP" >&6; }
4684   else
4685 <  { echo "$as_me:$LINENO: result: no" >&5
4686 < echo "${ECHO_T}no" >&6; }
4685 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4686 > $as_echo "no" >&6; }
4687   fi
4688  
4689  
# Line 4038 | Line 4692 | fi
4692  
4693  
4694   # Check whether --with-perl-shebang was given.
4695 < if test "${with_perl_shebang+set}" = set; then
4695 > if test "${with_perl_shebang+set}" = set; then :
4696    withval=$with_perl_shebang; opt_perl_shebang="$withval"
4697   else
4698                  opt_perl_shebang="not_set"
4699   fi
4700  
4701 <   { echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
4702 < echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6; }
4703 < if test "${ax_cv_opt_perl_shebang+set}" = set; then
4704 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4701 >   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether explicit instead of detected sharpbang is to be used" >&5
4702 > $as_echo_n "checking whether explicit instead of detected sharpbang is to be used... " >&6; }
4703 > if ${ax_cv_opt_perl_shebang+:} false; then :
4704 >  $as_echo_n "(cached) " >&6
4705   else
4706     case "$opt_perl_shebang" in
4707                        not_set  ) ax_cv_opt_perl_shebang=''
# Line 4057 | Line 4711 | fi
4711                      esac
4712  
4713   fi
4714 < { echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
4715 < echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6; }
4714 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_opt_perl_shebang" >&5
4715 > $as_echo "$ax_cv_opt_perl_shebang" >&6; }
4716     if test "A$ax_cv_opt_perl_shebang" != "A"
4717       then
4718         ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
4719         PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
4720 <              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
4721 < echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
4720 >              { $as_echo "$as_me:${as_lineno-$LINENO}: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
4721 > $as_echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
4722  
4723   # Automatic detection of sharpbang formula starts here
4724       else
4725     _somian_shbangperl=`$PERLINTERP -V:startperl`
4726     negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
4727 <   { echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
4728 < echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6; }
4729 < if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
4730 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4727 >   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for kernel sharpbang invocation to start perl" >&5
4728 > $as_echo_n "checking for kernel sharpbang invocation to start perl... " >&6; }
4729 > if ${ac_cv_sys_kernshrpbang_perl+:} false; then :
4730 >  $as_echo_n "(cached) " >&6
4731   else
4732    _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
4733          if test "x$_somian_kspb_perl" == x
# Line 4089 | Line 4743 | fi
4743          fi
4744  
4745   fi
4746 < { echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
4747 < echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6; }
4746 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_kernshrpbang_perl" >&5
4747 > $as_echo "$ac_cv_sys_kernshrpbang_perl" >&6; }
4748   # The above prints Checking ... result message to user.
4749     PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
4750  
4751      if test A${_somian_ksbp_warn_empty+set} == Aset
4752 <      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
4753 < echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
4752 >      then   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
4753 > $as_echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
4754      fi
4755   # Inform user after printing result value
4756      if test A${_somian_ksbp_warn_defau+set} == Aset
4757 <      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
4758 < echo "$as_me: Maybe Not good -" >&6;}
4759 <           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
4760 < echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
4761 <      else { echo "$as_me:$LINENO: OK Good result - " >&5
4762 < echo "$as_me: OK Good result - " >&6;}
4763 <           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
4764 < echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
4757 >      then { $as_echo "$as_me:${as_lineno-$LINENO}: Maybe Not good -" >&5
4758 > $as_echo "$as_me: Maybe Not good -" >&6;}
4759 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
4760 > $as_echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
4761 >      else { $as_echo "$as_me:${as_lineno-$LINENO}: OK Good result - " >&5
4762 > $as_echo "$as_me: OK Good result - " >&6;}
4763 >           { $as_echo "$as_me:${as_lineno-$LINENO}: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
4764 > $as_echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
4765      fi
4766    fi
4767  
# Line 4124 | Line 4778 | echo "$as_me: In last check we got a proper-looking an
4778   # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
4779   # OS/2's system install, which has a completely different semantic
4780   # ./install, which can be erroneously created by make from ./install.sh.
4781 < { echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
4782 < echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6; }
4781 > # Reject install programs that cannot install multiple files.
4782 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
4783 > $as_echo_n "checking for a BSD-compatible install... " >&6; }
4784   if test -z "$INSTALL"; then
4785 < if test "${ac_cv_path_install+set}" = set; then
4786 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4785 > if ${ac_cv_path_install+:} false; then :
4786 >  $as_echo_n "(cached) " >&6
4787   else
4788    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4789   for as_dir in $PATH
4790   do
4791    IFS=$as_save_IFS
4792    test -z "$as_dir" && as_dir=.
4793 <  # Account for people who put trailing slashes in PATH elements.
4794 < case $as_dir/ in
4795 <  ./ | .// | /cC/* | \
4793 >    # Account for people who put trailing slashes in PATH elements.
4794 > case $as_dir/ in #((
4795 >  ./ | .// | /[cC]/* | \
4796    /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
4797 <  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
4797 >  ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
4798    /usr/ucb/* ) ;;
4799    *)
4800      # OSF1 and SCO ODT 3.0 have their own names for install.
# Line 4157 | Line 4812 | case $as_dir/ in
4812              # program-specific install script used by HP pwplus--don't use.
4813              :
4814            else
4815 <            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
4816 <            break 3
4815 >            rm -rf conftest.one conftest.two conftest.dir
4816 >            echo one > conftest.one
4817 >            echo two > conftest.two
4818 >            mkdir conftest.dir
4819 >            if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
4820 >              test -s conftest.one && test -s conftest.two &&
4821 >              test -s conftest.dir/conftest.one &&
4822 >              test -s conftest.dir/conftest.two
4823 >            then
4824 >              ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
4825 >              break 3
4826 >            fi
4827            fi
4828          fi
4829        done
4830      done
4831      ;;
4832   esac
4833 < done
4833 >
4834 >  done
4835   IFS=$as_save_IFS
4836  
4837 + rm -rf conftest.one conftest.two conftest.dir
4838  
4839   fi
4840    if test "${ac_cv_path_install+set}" = set; then
# Line 4180 | Line 4847 | fi
4847      INSTALL=$ac_install_sh
4848    fi
4849   fi
4850 < { echo "$as_me:$LINENO: result: $INSTALL" >&5
4851 < echo "${ECHO_T}$INSTALL" >&6; }
4850 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
4851 > $as_echo "$INSTALL" >&6; }
4852  
4853   # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
4854   # It thinks the first close brace ends the variable substitution.
# Line 4195 | Line 4862 | esac
4862     x/*) ;;
4863     *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
4864   esac
4865 < MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
4865 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f -m 755"
4866   # Extract the first word of "ar", so it can be a program name with args.
4867   set dummy ar; ac_word=$2
4868 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
4869 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
4870 < if test "${ac_cv_prog_AR+set}" = set; then
4871 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4868 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4869 > $as_echo_n "checking for $ac_word... " >&6; }
4870 > if ${ac_cv_prog_AR+:} false; then :
4871 >  $as_echo_n "(cached) " >&6
4872   else
4873    if test -n "$AR"; then
4874    ac_cv_prog_AR="$AR" # Let the user override the test.
# Line 4211 | Line 4878 | do
4878   do
4879    IFS=$as_save_IFS
4880    test -z "$as_dir" && as_dir=.
4881 <  for ac_exec_ext in '' $ac_executable_extensions; do
4881 >    for ac_exec_ext in '' $ac_executable_extensions; do
4882    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4883      ac_cv_prog_AR="ar"
4884 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4884 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4885      break 2
4886    fi
4887   done
4888 < done
4888 >  done
4889   IFS=$as_save_IFS
4890  
4891    test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
# Line 4226 | Line 4893 | if test -n "$AR"; then
4893   fi
4894   AR=$ac_cv_prog_AR
4895   if test -n "$AR"; then
4896 <  { echo "$as_me:$LINENO: result: $AR" >&5
4897 < echo "${ECHO_T}$AR" >&6; }
4896 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
4897 > $as_echo "$AR" >&6; }
4898   else
4899 <  { echo "$as_me:$LINENO: result: no" >&5
4900 < echo "${ECHO_T}no" >&6; }
4899 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4900 > $as_echo "no" >&6; }
4901   fi
4902  
4903  
# Line 4262 | Line 4929 | _ACEOF
4929      case $ac_val in #(
4930      *${as_nl}*)
4931        case $ac_var in #(
4932 <      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
4933 < echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
4932 >      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
4933 > $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
4934        esac
4935        case $ac_var in #(
4936        _ | IFS | as_nl) ;; #(
4937 <      *) $as_unset $ac_var ;;
4937 >      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
4938 >      *) { eval $ac_var=; unset $ac_var;} ;;
4939        esac ;;
4940      esac
4941    done
# Line 4275 | Line 4943 | echo "$as_me: WARNING: Cache variable $ac_var contains
4943    (set) 2>&1 |
4944      case $as_nl`(ac_space=' '; set) 2>&1` in #(
4945      *${as_nl}ac_space=\ *)
4946 <      # `set' does not quote correctly, so add quotes (double-quote
4947 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
4946 >      # `set' does not quote correctly, so add quotes: double-quote
4947 >      # substitution turns \\\\ into \\, and sed turns \\ into \.
4948        sed -n \
4949          "s/'/'\\\\''/g;
4950            s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
# Line 4298 | Line 4966 | if diff "$cache_file" confcache >/dev/null 2>&1; then
4966       :end' >>confcache
4967   if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
4968    if test -w "$cache_file"; then
4969 <    test "x$cache_file" != "x/dev/null" &&
4970 <      { echo "$as_me:$LINENO: updating cache $cache_file" >&5
4971 < echo "$as_me: updating cache $cache_file" >&6;}
4972 <    cat confcache >$cache_file
4969 >    if test "x$cache_file" != "x/dev/null"; then
4970 >      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
4971 > $as_echo "$as_me: updating cache $cache_file" >&6;}
4972 >      if test ! -f "$cache_file" || test -h "$cache_file"; then
4973 >        cat confcache >"$cache_file"
4974 >      else
4975 >        case $cache_file in #(
4976 >        */* | ?:*)
4977 >          mv -f confcache "$cache_file"$$ &&
4978 >          mv -f "$cache_file"$$ "$cache_file" ;; #(
4979 >        *)
4980 >          mv -f confcache "$cache_file" ;;
4981 >        esac
4982 >      fi
4983 >    fi
4984    else
4985 <    { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
4986 < echo "$as_me: not updating unwritable cache $cache_file" >&6;}
4985 >    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
4986 > $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
4987    fi
4988   fi
4989 < rm -rf confcache
4989 > rm -f confcache
4990    exit 1
4991   fi
4992   # Extract the first word of "ps", so it can be a program name with args.
4993   set dummy ps; ac_word=$2
4994 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
4995 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
4996 < if test "${ac_cv_path_PS+set}" = set; then
4997 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4994 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4995 > $as_echo_n "checking for $ac_word... " >&6; }
4996 > if ${ac_cv_path_PS+:} false; then :
4997 >  $as_echo_n "(cached) " >&6
4998   else
4999    case $PS in
5000    [\\/]* | ?:[\\/]*)
# Line 4327 | Line 5006 | do
5006   do
5007    IFS=$as_save_IFS
5008    test -z "$as_dir" && as_dir=.
5009 <  for ac_exec_ext in '' $ac_executable_extensions; do
5009 >    for ac_exec_ext in '' $ac_executable_extensions; do
5010    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5011      ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
5012 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5012 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5013      break 2
5014    fi
5015   done
5016 < done
5016 >  done
5017   IFS=$as_save_IFS
5018  
5019    ;;
# Line 4342 | Line 5021 | if test -n "$PS"; then
5021   fi
5022   PS=$ac_cv_path_PS
5023   if test -n "$PS"; then
5024 <  { echo "$as_me:$LINENO: result: $PS" >&5
5025 < echo "${ECHO_T}$PS" >&6; }
5024 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PS" >&5
5025 > $as_echo "$PS" >&6; }
5026   else
5027 <  { echo "$as_me:$LINENO: result: no" >&5
5028 < echo "${ECHO_T}no" >&6; }
5027 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5028 > $as_echo "no" >&6; }
5029   fi
5030  
5031  
5032 < { echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
5033 < echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6; }
5034 < if test "${ac_cv_prog_ps_syntax+set}" = set; then
5035 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5032 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for POSIX or BSD ps syntax" >&5
5033 > $as_echo_n "checking for POSIX or BSD ps syntax... " >&6; }
5034 > if ${ac_cv_prog_ps_syntax+:} false; then :
5035 >  $as_echo_n "(cached) " >&6
5036   else
5037  
5038          if $PS ax -o rss > /dev/null 2>&1; then
# Line 4372 | Line 5051 | else
5051                  if test "$ac_cv_prog_ps_ef" = yes; then
5052                          ac_cv_prog_ps_syntax=POSIX
5053                  else
5054 <                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
4376 < echo "$as_me: error: Could not determine ps syntax" >&2;}
4377 <   { (exit 1); exit 1; }; }
5054 >                        as_fn_error $? "Could not determine ps syntax" "$LINENO" 5
5055                  fi
5056          fi
5057  
5058   fi
5059 < { echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
5060 < echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6; }
5059 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_ps_syntax" >&5
5060 > $as_echo "$ac_cv_prog_ps_syntax" >&6; }
5061  
5062   cat >>confdefs.h <<_ACEOF
5063   #define PSCOMMAND $PS
# Line 4388 | Line 5065 | if test "$ac_cv_prog_ps_syntax" = BSD; then
5065  
5066   if test "$ac_cv_prog_ps_syntax" = BSD; then
5067  
5068 < cat >>confdefs.h <<\_ACEOF
4392 < #define PSTYPE_IS_BSD 1
4393 < _ACEOF
5068 > $as_echo "#define PSTYPE_IS_BSD 1" >>confdefs.h
5069  
5070   else
5071     if test "$ac_cv_prog_ps_syntax" = POSIX; then
5072  
5073 < cat >>confdefs.h <<\_ACEOF
4399 < #define PSTYPE_IS_POSIX 1
4400 < _ACEOF
5073 > $as_echo "#define PSTYPE_IS_POSIX 1" >>confdefs.h
5074  
5075     else
5076 <       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
4404 < echo "$as_me: error: Unknown ps syntax type!" >&2;}
4405 <   { (exit 1); exit 1; }; }
5076 >       as_fn_error $? "Unknown ps syntax type!" "$LINENO" 5
5077     fi
5078   fi
5079  
5080 < ac_ext=${ac_fc_srcext-f}
5081 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5082 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5083 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5080 > ac_ext=c
5081 > ac_cpp='$CPP $CPPFLAGS'
5082 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5083 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5084 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5085  
5086  
5087 < ac_ext=${ac_fc_srcext-f}
5088 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5089 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5090 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4419 < { echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
4420 < echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6; }
4421 < if test "${ac_cv_fc_srcext_F90+set}" = set; then
4422 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5087 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for asin in -lm" >&5
5088 > $as_echo_n "checking for asin in -lm... " >&6; }
5089 > if ${ac_cv_lib_m_asin+:} false; then :
5090 >  $as_echo_n "(cached) " >&6
5091   else
5092 <  ac_ext=F90
5093 < ac_fcflags_srcext_save=$ac_fcflags_srcext
5094 < ac_fcflags_srcext=
5095 < ac_cv_fc_srcext_F90=unknown
4428 < for ac_flag in none -qsuffix=f=F90 -Tf; do
4429 <  test "x$ac_flag" != xnone && ac_fcflags_srcext="$ac_flag"
4430 <  cat >conftest.$ac_ext <<_ACEOF
4431 <      program main
5092 >  ac_check_lib_save_LIBS=$LIBS
5093 > LIBS="-lm  $LIBS"
5094 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5095 > /* end confdefs.h.  */
5096  
5097 <      end
5097 > /* Override any GCC internal prototype to avoid an error.
5098 >   Use char because int might match the return type of a GCC
5099 >   builtin and then its argument prototype would still apply.  */
5100 > #ifdef __cplusplus
5101 > extern "C"
5102 > #endif
5103 > char asin ();
5104 > int
5105 > main ()
5106 > {
5107 > return asin ();
5108 >  ;
5109 >  return 0;
5110 > }
5111   _ACEOF
5112 < rm -rf conftest.$ac_objext
5113 < if { (ac_try="$ac_compile"
4437 < case "(($ac_try" in
4438 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4439 <  *) ac_try_echo=$ac_try;;
4440 < esac
4441 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4442 <  (eval "$ac_compile") 2>conftest.er1
4443 <  ac_status=$?
4444 <  grep -v '^ *+' conftest.er1 >conftest.err
4445 <  rm -f conftest.er1
4446 <  cat conftest.err >&5
4447 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4448 <  (exit $ac_status); } && {
4449 <         test -z "$ac_fc_werror_flag" ||
4450 <         test ! -s conftest.err
4451 <       } && test -s conftest.$ac_objext; then
4452 <  ac_cv_fc_srcext_F90=$ac_flag; break
5112 > if ac_fn_c_try_link "$LINENO"; then :
5113 >  ac_cv_lib_m_asin=yes
5114   else
5115 <  echo "$as_me: failed program was:" >&5
5116 < sed 's/^/| /' conftest.$ac_ext >&5
5115 >  ac_cv_lib_m_asin=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_m_asin" >&5
5122 > $as_echo "$ac_cv_lib_m_asin" >&6; }
5123 > if test "x$ac_cv_lib_m_asin" = xyes; then :
5124 >  cat >>confdefs.h <<_ACEOF
5125 > #define HAVE_LIBM 1
5126 > _ACEOF
5127  
5128 +  LIBS="-lm $LIBS"
5129  
5130 + else
5131 +  exit
5132   fi
5133  
5134 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
5135 < done
5136 < rm -rf conftest.$ac_objext conftest.F90
5137 < ac_fcflags_srcext=$ac_fcflags_srcext_save
5138 <
4465 < fi
4466 < { echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
4467 < echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6; }
4468 < if test "x$ac_cv_fc_srcext_F90" = xunknown; then
4469 <  { { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
4470 < echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
4471 <   { (exit 1); exit 1; }; }
5134 >
5135 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
5136 > $as_echo_n "checking for ANSI C header files... " >&6; }
5137 > if ${ac_cv_header_stdc+:} false; then :
5138 >  $as_echo_n "(cached) " >&6
5139   else
5140 <  ac_fc_srcext=F90
5141 <  if test "x$ac_cv_fc_srcext_F90" = xnone; then
5142 <    ac_fcflags_srcext=""
5143 <    FCFLAGS_F90=""
5144 <  else
5145 <    ac_fcflags_srcext=$ac_cv_fc_srcext_F90
4479 <    FCFLAGS_F90=$ac_cv_fc_srcext_F90
4480 <  fi
5140 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5141 > /* end confdefs.h.  */
5142 > #include <stdlib.h>
5143 > #include <stdarg.h>
5144 > #include <string.h>
5145 > #include <float.h>
5146  
5147 + int
5148 + main ()
5149 + {
5150  
5151 +  ;
5152 +  return 0;
5153 + }
5154 + _ACEOF
5155 + if ac_fn_c_try_compile "$LINENO"; then :
5156 +  ac_cv_header_stdc=yes
5157 + else
5158 +  ac_cv_header_stdc=no
5159   fi
5160 < ac_ext=${ac_fc_srcext-f}
4485 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4486 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4487 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5160 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5161  
5162 + if test $ac_cv_header_stdc = yes; then
5163 +  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5164 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5165 + /* end confdefs.h.  */
5166 + #include <string.h>
5167  
5168 + _ACEOF
5169 + if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5170 +  $EGREP "memchr" >/dev/null 2>&1; then :
5171  
5172 + else
5173 +  ac_cv_header_stdc=no
5174 + fi
5175 + rm -f conftest*
5176  
5177 + fi
5178  
5179 < # Try to determine native compiler flags that allow us to use F90 suffix
5180 < # for preprocessed f90 source.
5179 > if test $ac_cv_header_stdc = yes; then
5180 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5181 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5182 > /* end confdefs.h.  */
5183 > #include <stdlib.h>
5184  
5185 < if test "$ac_test_PREPFLAG" != "set"; then
5186 <  PREPFLAG=""
5187 <  case "${host_cpu}-${host_os}" in
5185 > _ACEOF
5186 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5187 >  $EGREP "free" >/dev/null 2>&1; then :
5188  
5189 <  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
5190 <                    PREPFLAG="-fpp1 "
5191 <                fi;;
5192 <  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
4504 <                    PREPFLAG="-qsuffix=cpp=F90 "
4505 <                fi;;
4506 <  *darwin*)
4507 <        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
4508 <                PREPFLAG="-qsuffix=cpp=F90 "
4509 <        fi;;
4510 <  esac
5189 > else
5190 >  ac_cv_header_stdc=no
5191 > fi
5192 > rm -f conftest*
5193  
5194 <  if test -z "$PREPFLAG"; then
4513 <        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
4514 < echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
4515 <        PREPFLAG=""
4516 <  fi
5194 > fi
5195  
5196 <  { echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
5197 < echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6; }
5196 > if test $ac_cv_header_stdc = yes; then
5197 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5198 >  if test "$cross_compiling" = yes; then :
5199 >  :
5200 > else
5201 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5202 > /* end confdefs.h.  */
5203 > #include <ctype.h>
5204 > #include <stdlib.h>
5205 > #if ((' ' & 0x0FF) == 0x020)
5206 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5207 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5208 > #else
5209 > # define ISLOWER(c) \
5210 >                   (('a' <= (c) && (c) <= 'i') \
5211 >                     || ('j' <= (c) && (c) <= 'r') \
5212 >                     || ('s' <= (c) && (c) <= 'z'))
5213 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5214 > #endif
5215  
5216 <  ac_ext=${ac_fc_srcext-f}
5217 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5218 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5219 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5216 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5217 > int
5218 > main ()
5219 > {
5220 >  int i;
5221 >  for (i = 0; i < 256; i++)
5222 >    if (XOR (islower (i), ISLOWER (i))
5223 >        || toupper (i) != TOUPPER (i))
5224 >      return 2;
5225 >  return 0;
5226 > }
5227 > _ACEOF
5228 > if ac_fn_c_try_run "$LINENO"; then :
5229  
5230 <  ac_save_ext=$ac_ext
5231 <  ac_ext=F90
5232 <  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
5230 > else
5231 >  ac_cv_header_stdc=no
5232 > fi
5233 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
5234 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
5235 > fi
5236  
4530 –  if test "$PREPFLAG"; then
4531 –  FCFLAGS_SRCEXT="${PREPFLAG}"
5237   fi
5238 + fi
5239 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
5240 + $as_echo "$ac_cv_header_stdc" >&6; }
5241 + if test $ac_cv_header_stdc = yes; then
5242  
5243 <    cat >conftest.$ac_ext <<_ACEOF
5243 > $as_echo "#define STDC_HEADERS 1" >>confdefs.h
5244  
5245 + fi
5246  
5247 < program conftest
5248 <  integer :: i
5249 <  i = 1
5250 < end program conftest
5251 <
5247 > # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5248 > for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5249 >                  inttypes.h stdint.h unistd.h
5250 > do :
5251 >  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
5252 > ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
5253 > "
5254 > if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
5255 >  cat >>confdefs.h <<_ACEOF
5256 > #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
5257   _ACEOF
4543 – rm -rf conftest.$ac_objext
4544 – if { (ac_try="$ac_compile"
4545 – case "(($ac_try" in
4546 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4547 –  *) ac_try_echo=$ac_try;;
4548 – esac
4549 – eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4550 –  (eval "$ac_compile") 2>conftest.er1
4551 –  ac_status=$?
4552 –  grep -v '^ *+' conftest.er1 >conftest.err
4553 –  rm -f conftest.er1
4554 –  cat conftest.err >&5
4555 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4556 –  (exit $ac_status); } && {
4557 –         test -z "$ac_fc_werror_flag" ||
4558 –         test ! -s conftest.err
4559 –       } && test -s conftest.$ac_objext; then
4560 –  prepflagworks=1
4561 – else
4562 –  echo "$as_me: failed program was:" >&5
4563 – sed 's/^/| /' conftest.$ac_ext >&5
5258  
4565 –        prepflagworks=0
5259   fi
5260  
5261 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
5261 > done
5262  
4570 –  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
4571 –  ac_ext=$ac_save_ext
4572 –  ac_ext=${ac_fc_srcext-f}
4573 – ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4574 – ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4575 – ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5263  
5264 + #
5265 + # Handle user hints
5266 + #
5267  
5268 <  if test "$prepflagworks" = 1; then
5269 <    { echo "$as_me:$LINENO: result: yes" >&5
5270 < echo "${ECHO_T}yes" >&6; }
5271 <    FCFLAGS_SRCEXT="${PREPFLAG}"
5268 > # Check whether --with-zlib was given.
5269 > if test "${with_zlib+set}" = set; then :
5270 >  withval=$with_zlib; zlib_dir="$withval"
5271 > else
5272 >                zlib_dir="not_set"
5273 > fi
5274  
5275 + if test "$zlib_dir" != "no"; then
5276 +
5277 + if test "$zlib_dir" != "not_set" ; then
5278 +  if test -d "$zlib_dir"
5279 +  then
5280 +    ZLIB_HOME="$zlib_dir"
5281    else
5282 <    { echo "$as_me:$LINENO: result: no" >&5
5283 < echo "${ECHO_T}no" >&6; }
5284 <    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
5285 < echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
5286 <   { (exit 1); exit 1; }; }
5282 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
5283 > $as_echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
5284 >        ZLIB_HOME=/usr/local
5285 >        if test ! -f "${ZLIB_HOME}/include/zlib.h"
5286 >        then
5287 >                ZLIB_HOME=/usr
5288 >        fi
5289    fi
5290   fi
5291 + #
5292 + # Locate zlib, if wanted
5293 + #
5294 + if test -n "${ZLIB_HOME}"
5295 + then
5296 +        ZLIB_OLD_LDFLAGS=$LDFLAGS
5297 +        ZLIB_OLD_CFLAGS=$CFLAGS
5298 +        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5299 +        CFLAGS="$CFLAGS -I${ZLIB_HOME}/include"
5300  
5301 +        ac_ext=c
5302 + ac_cpp='$CPP $CPPFLAGS'
5303 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5304 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5305 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
5306  
5307 +        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for inflateEnd in -lz" >&5
5308 + $as_echo_n "checking for inflateEnd in -lz... " >&6; }
5309 + if ${ac_cv_lib_z_inflateEnd+:} false; then :
5310 +  $as_echo_n "(cached) " >&6
5311 + else
5312 +  ac_check_lib_save_LIBS=$LIBS
5313 + LIBS="-lz  $LIBS"
5314 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5315 + /* end confdefs.h.  */
5316  
5317 + /* Override any GCC internal prototype to avoid an error.
5318 +   Use char because int might match the return type of a GCC
5319 +   builtin and then its argument prototype would still apply.  */
5320 + #ifdef __cplusplus
5321 + extern "C"
5322 + #endif
5323 + char inflateEnd ();
5324 + int
5325 + main ()
5326 + {
5327 + return inflateEnd ();
5328 +  ;
5329 +  return 0;
5330 + }
5331 + _ACEOF
5332 + if ac_fn_c_try_link "$LINENO"; then :
5333 +  ac_cv_lib_z_inflateEnd=yes
5334 + else
5335 +  ac_cv_lib_z_inflateEnd=no
5336 + fi
5337 + rm -f core conftest.err conftest.$ac_objext \
5338 +    conftest$ac_exeext conftest.$ac_ext
5339 + LIBS=$ac_check_lib_save_LIBS
5340 + fi
5341 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_z_inflateEnd" >&5
5342 + $as_echo "$ac_cv_lib_z_inflateEnd" >&6; }
5343 + if test "x$ac_cv_lib_z_inflateEnd" = xyes; then :
5344 +  zlib_cv_libz=yes
5345 + else
5346 +  zlib_cv_libz=no
5347 + fi
5348  
5349 +        ac_fn_c_check_header_mongrel "$LINENO" "zlib.h" "ac_cv_header_zlib_h" "$ac_includes_default"
5350 + if test "x$ac_cv_header_zlib_h" = xyes; then :
5351 +  zlib_cv_zlib_h=yes
5352 + else
5353 +  zlib_cv_zlib_h=no
5354 + fi
5355  
4596 – # Try to determine native compiler flags that allow us to use F90 suffix
4597 – # for preprocessed f90 source with -D type defines
5356  
5357 < if test "$ac_test_PREPDEFFLAG" != "set"; then
5358 <  PREPDEFFLAG=""
5359 <  case "${host_cpu}-${host_os}" in
5357 >        ac_ext=c
5358 > ac_cpp='$CPP $CPPFLAGS'
5359 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5360 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5361 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5362  
4603 –  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
4604 –                    PREPDEFFLAG=" "
4605 –                fi;;
4606 –  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
4607 –                    PREPDEFFLAG="-WF,"
4608 –                fi;;
4609 –  *darwin*)
4610 –        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
4611 –                PREPDEFFLAG="-WF,"
4612 –        fi;;
4613 –  esac
5363  
5364 <  if test -z "$PREPDEFFLAG"; then
4616 <        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
4617 < echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
4618 <        PREPDEFFLAG=" "
4619 <  fi
5364 >        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
5365  
5366 <  { echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
4622 < echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6; }
5366 > $as_echo "#define HAVE_ZLIB_H 1" >>confdefs.h
5367  
4624 –  ac_ext=${ac_fc_srcext-f}
4625 – ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4626 – ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4627 – ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5368  
5369 <  ac_save_ext=$ac_ext
4630 <  ac_ext=F90
4631 <  ac_save_FCFLAGS=$FCFLAGS
5369 > $as_echo "#define HAVE_LIBZ 1" >>confdefs.h
5370  
5371 <  if test "$PREPDEFFLAG"; then
5372 <  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
5373 < fi
5371 >                ZLIB_INC_DIR="${ZLIB_HOME}/include"
5372 >                ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
5373 >                ZLIB="-lz"
5374 >        else
5375 >                { $as_echo "$as_me:${as_lineno-$LINENO}: checking zlib in ${ZLIB_HOME}" >&5
5376 > $as_echo_n "checking zlib in ${ZLIB_HOME}... " >&6; }
5377 >                ZLIB_INC_DIR=
5378 >                ZLIB_LIB_DIR=
5379 >                ZLIB=
5380 >                LDFLAGS="$ZLIB_OLD_LDFLAGS"
5381 >                CFLAGS="$ZLIB_OLD_CFLAGS"
5382 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
5383 > $as_echo "failed" >&6; }
5384 >                echo ""
5385 >                echo "*********************************************************"
5386 >                echo "* WARNING: Could not find a working zlib installation   *"
5387 >                echo "* If you need OpenMD to be able to deal with compressed *"
5388 >                echo "* trajectory dump files be sure to specify a valid zlib *"
5389 >                echo "* installation with --with-zlib=DIR                     *"
5390 >                echo "*                                                       *"
5391 >                echo "* OpenMD will still work without zlib installed.        *"
5392 >                echo "*********************************************************"
5393 >                echo ""
5394 >        fi
5395  
4637 –    cat >conftest.$ac_ext <<_ACEOF
5396  
5397  
5398 < program conftest
5399 <  integer :: i
4642 < #ifdef TEST
4643 <  i = 1
4644 < #else
4645 <  choke me
4646 < #endif
4647 < end program conftest
5398 > fi
5399 > fi
5400  
5401 < _ACEOF
5402 < rm -rf conftest.$ac_objext
5403 < if { (ac_try="$ac_compile"
4652 < case "(($ac_try" in
4653 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4654 <  *) ac_try_echo=$ac_try;;
4655 < esac
4656 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4657 <  (eval "$ac_compile") 2>conftest.er1
4658 <  ac_status=$?
4659 <  grep -v '^ *+' conftest.er1 >conftest.err
4660 <  rm -f conftest.er1
4661 <  cat conftest.err >&5
4662 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4663 <  (exit $ac_status); } && {
4664 <         test -z "$ac_fc_werror_flag" ||
4665 <         test ! -s conftest.err
4666 <       } && test -s conftest.$ac_objext; then
4667 <  prepdefflagworks=1
4668 < else
4669 <  echo "$as_me: failed program was:" >&5
4670 < sed 's/^/| /' conftest.$ac_ext >&5
5401 > #
5402 > # Handle user hints
5403 > #
5404  
5405 <        prepdefflagworks=0
5405 > # Check whether --with-fftw was given.
5406 > if test "${with_fftw+set}" = set; then :
5407 >  withval=$with_fftw; fftw_dir="$withval"
5408 > else
5409 >             fftw_dir="not_set"
5410   fi
5411  
5412 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
5412 > if test "$fftw_dir" != "no"; then
5413 >  if test "$fftw_dir" != "not_set" ; then
5414 >    if test -d "$fftw_dir"; then
5415 >      FFTW_HOME="$fftw_dir"
5416 >    else
5417 >      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
5418 > $as_echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
5419 >      FFTW_HOME=/usr/local
5420 >      if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"; then
5421 >        FFTW_HOME=/usr
5422 >      fi
5423 >    fi
5424 >    #
5425 >    # Locate fftw, if wanted
5426 >    #
5427 >    if test -n "${FFTW_HOME}"; then
5428 >      FFTW_OLD_LDFLAGS=$LDFLAGS
5429 >      FFTW_OLD_CFLAGS=$CFLAGS
5430 >      LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
5431 >      CFLAGS="$CFLAGS -I${FFTW_HOME}/include"
5432  
5433 <  FCFLAGS=$ac_save_FCFLAGS
5434 <  ac_ext=$ac_save_ext
5435 <  ac_ext=${ac_fc_srcext-f}
5436 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5437 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4682 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5433 >      ac_ext=c
5434 > ac_cpp='$CPP $CPPFLAGS'
5435 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5436 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5437 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5438  
5439 +      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftw_execute in -lfftw3" >&5
5440 + $as_echo_n "checking for fftw_execute in -lfftw3... " >&6; }
5441 + if ${ac_cv_lib_fftw3_fftw_execute+:} false; then :
5442 +  $as_echo_n "(cached) " >&6
5443 + else
5444 +  ac_check_lib_save_LIBS=$LIBS
5445 + LIBS="-lfftw3  $LIBS"
5446 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5447 + /* end confdefs.h.  */
5448  
5449 <  if test "$prepdefflagworks" = 1; then
5450 <    { echo "$as_me:$LINENO: result: yes" >&5
5451 < echo "${ECHO_T}yes" >&6; }
5452 <
5453 <  else
5454 <    { echo "$as_me:$LINENO: result: no" >&5
5455 < echo "${ECHO_T}no" >&6; }
5456 <    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
5457 < echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
5458 <   { (exit 1); exit 1; }; }
5459 <  fi
5449 > /* Override any GCC internal prototype to avoid an error.
5450 >   Use char because int might match the return type of a GCC
5451 >   builtin and then its argument prototype would still apply.  */
5452 > #ifdef __cplusplus
5453 > extern "C"
5454 > #endif
5455 > char fftw_execute ();
5456 > int
5457 > main ()
5458 > {
5459 > return fftw_execute ();
5460 >  ;
5461 >  return 0;
5462 > }
5463 > _ACEOF
5464 > if ac_fn_c_try_link "$LINENO"; then :
5465 >  ac_cv_lib_fftw3_fftw_execute=yes
5466 > else
5467 >  ac_cv_lib_fftw3_fftw_execute=no
5468   fi
5469 <
5470 < ac_ext=${ac_fc_srcext-f}
5471 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5472 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5473 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5474 < { echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
5475 < echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6; }
5476 < if test "${ac_cv_prog_fc_v+set}" = set; then
4705 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5469 > rm -f core conftest.err conftest.$ac_objext \
5470 >    conftest$ac_exeext conftest.$ac_ext
5471 > LIBS=$ac_check_lib_save_LIBS
5472 > fi
5473 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fftw3_fftw_execute" >&5
5474 > $as_echo "$ac_cv_lib_fftw3_fftw_execute" >&6; }
5475 > if test "x$ac_cv_lib_fftw3_fftw_execute" = xyes; then :
5476 >  fftw_cv_libfftw3=yes
5477   else
5478 <  cat >conftest.$ac_ext <<_ACEOF
5479 <      program main
5478 >  fftw_cv_libfftw3=no
5479 > fi
5480  
5481 <      end
5482 < _ACEOF
5483 < rm -rf conftest.$ac_objext
5484 < if { (ac_try="$ac_compile"
5485 < case "(($ac_try" in
5486 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4716 <  *) ac_try_echo=$ac_try;;
4717 < esac
4718 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4719 <  (eval "$ac_compile") 2>conftest.er1
4720 <  ac_status=$?
4721 <  grep -v '^ *+' conftest.er1 >conftest.err
4722 <  rm -rf conftest.er1
4723 <  cat conftest.err >&5
4724 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4725 <  (exit $ac_status); } && {
4726 <         test -z "$ac_fc_werror_flag" ||
4727 <         test ! -s conftest.err
4728 <       } && test -s conftest.$ac_objext; then
4729 <  ac_cv_prog_fc_v=
4730 < # Try some options frequently used verbose output
4731 < for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4732 <  cat >conftest.$ac_ext <<_ACEOF
4733 <      program main
5481 >      ac_fn_c_check_header_mongrel "$LINENO" "fftw3.h" "ac_cv_header_fftw3_h" "$ac_includes_default"
5482 > if test "x$ac_cv_header_fftw3_h" = xyes; then :
5483 >  fftw_cv_fftw3_h=yes
5484 > else
5485 >  fftw_cv_fftw3_h=no
5486 > fi
5487  
5488 <      end
5488 >
5489 >      if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"; then
5490 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftwnd_one in -lfftw" >&5
5491 > $as_echo_n "checking for fftwnd_one in -lfftw... " >&6; }
5492 > if ${ac_cv_lib_fftw_fftwnd_one+:} false; then :
5493 >  $as_echo_n "(cached) " >&6
5494 > else
5495 >  ac_check_lib_save_LIBS=$LIBS
5496 > LIBS="-lfftw  $LIBS"
5497 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5498 > /* end confdefs.h.  */
5499 >
5500 > /* Override any GCC internal prototype to avoid an error.
5501 >   Use char because int might match the return type of a GCC
5502 >   builtin and then its argument prototype would still apply.  */
5503 > #ifdef __cplusplus
5504 > extern "C"
5505 > #endif
5506 > char fftwnd_one ();
5507 > int
5508 > main ()
5509 > {
5510 > return fftwnd_one ();
5511 >  ;
5512 >  return 0;
5513 > }
5514   _ACEOF
5515 + if ac_fn_c_try_link "$LINENO"; then :
5516 +  ac_cv_lib_fftw_fftwnd_one=yes
5517 + else
5518 +  ac_cv_lib_fftw_fftwnd_one=no
5519 + fi
5520 + rm -f core conftest.err conftest.$ac_objext \
5521 +    conftest$ac_exeext conftest.$ac_ext
5522 + LIBS=$ac_check_lib_save_LIBS
5523 + fi
5524 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fftw_fftwnd_one" >&5
5525 + $as_echo "$ac_cv_lib_fftw_fftwnd_one" >&6; }
5526 + if test "x$ac_cv_lib_fftw_fftwnd_one" = xyes; then :
5527 +  fftw_cv_libfftw=yes
5528 + else
5529 +  fftw_cv_libfftw=no
5530 + fi
5531  
5532 < # Compile and link our simple test program by passing a flag (argument
5533 < # 1 to this macro) to the Fortran compiler in order to get
5534 < # "verbose" output that we can then parse for the Fortran linker
5535 < # flags.
5536 < ac_save_FFLAGS=$FCFLAGS
5537 < FCFLAGS="$FCFLAGS $ac_verb"
4744 < eval "set x $ac_link"
4745 < shift
4746 < echo "$as_me:$LINENO: $*" >&5
4747 < ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4748 < echo "$ac_fc_v_output" >&5
4749 < FCFLAGS=$ac_save_FFLAGS
5532 >        ac_fn_c_check_header_mongrel "$LINENO" "fftw.h" "ac_cv_header_fftw_h" "$ac_includes_default"
5533 > if test "x$ac_cv_header_fftw_h" = xyes; then :
5534 >  fftw_cv_fftw_h=yes
5535 > else
5536 >  fftw_cv_fftw_h=no
5537 > fi
5538  
4751 – rm -rf conftest*
5539  
5540 < # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
5541 < # /foo, /bar, and /baz are search directories for the Fortran linker.
5542 < # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
5543 < ac_fc_v_output="`echo $ac_fc_v_output |
5544 <        grep 'LPATH is:' |
5545 <        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
5540 >        if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"; then
5541 >          { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftwnd_one in -ldfftw" >&5
5542 > $as_echo_n "checking for fftwnd_one in -ldfftw... " >&6; }
5543 > if ${ac_cv_lib_dfftw_fftwnd_one+:} false; then :
5544 >  $as_echo_n "(cached) " >&6
5545 > else
5546 >  ac_check_lib_save_LIBS=$LIBS
5547 > LIBS="-ldfftw  $LIBS"
5548 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5549 > /* end confdefs.h.  */
5550  
5551 < # FIXME: we keep getting bitten by quoted arguments; a more general fix
5552 < #        that detects unbalanced quotes in FLIBS should be implemented
5553 < #        and (ugh) tested at some point.
5554 < case $ac_fc_v_output in
5555 <  # If we are using xlf then replace all the commas with spaces.
5556 <  *xlfentry*)
5557 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
5551 > /* Override any GCC internal prototype to avoid an error.
5552 >   Use char because int might match the return type of a GCC
5553 >   builtin and then its argument prototype would still apply.  */
5554 > #ifdef __cplusplus
5555 > extern "C"
5556 > #endif
5557 > char fftwnd_one ();
5558 > int
5559 > main ()
5560 > {
5561 > return fftwnd_one ();
5562 >  ;
5563 >  return 0;
5564 > }
5565 > _ACEOF
5566 > if ac_fn_c_try_link "$LINENO"; then :
5567 >  ac_cv_lib_dfftw_fftwnd_one=yes
5568 > else
5569 >  ac_cv_lib_dfftw_fftwnd_one=no
5570 > fi
5571 > rm -f core conftest.err conftest.$ac_objext \
5572 >    conftest$ac_exeext conftest.$ac_ext
5573 > LIBS=$ac_check_lib_save_LIBS
5574 > fi
5575 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
5576 > $as_echo "$ac_cv_lib_dfftw_fftwnd_one" >&6; }
5577 > if test "x$ac_cv_lib_dfftw_fftwnd_one" = xyes; then :
5578 >  fftw_cv_libdfftw=yes
5579 > else
5580 >  fftw_cv_libdfftw=no
5581 > fi
5582  
5583 <  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
5584 <  # $LIBS confuse us, and the libraries appear later in the output anyway).
5585 <  *mGLOB_options_string*)
5586 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"-mGLOB[^"]*"/ /g'` ;;
5583 >          ac_fn_c_check_header_mongrel "$LINENO" "dfftw.h" "ac_cv_header_dfftw_h" "$ac_includes_default"
5584 > if test "x$ac_cv_header_dfftw_h" = xyes; then :
5585 >  fftw_cv_dfftw_h=yes
5586 > else
5587 >  fftw_cv_dfftw_h=no
5588 > fi
5589  
4773 –  # Portland Group compiler has singly- or doubly-quoted -cmdline argument
4774 –  # Singly-quoted arguments were reported for versions 5.2-4 and 6.0-4.
4775 –  # Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
4776 –  *-cmdline\ * | *-ignore\ * | *-def\ *)
4777 –    ac_fc_v_output=`echo $ac_fc_v_output | sed "\
4778 –        s/-cmdline  *'[^']*'/ /g; s/-cmdline  *\"[^\"]*\"/ /g
4779 –        s/-ignore  *'[^']*'/ /g; s/-ignore  *\"[^\"]*\"/ /g
4780 –        s/-def  *'[^']*'/ /g; s/-def  *\"[^\"]*\"/ /g"` ;;
5590  
5591 <  # If we are using Cray Fortran then delete quotes.
5592 <  *cft90*)
5593 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"//g'` ;;
5594 < esac
5591 >        fi
5592 >      fi
5593 >      ac_ext=c
5594 > ac_cpp='$CPP $CPPFLAGS'
5595 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5596 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5597 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5598  
5599 +      if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"; then
5600  
5601 <  # look for -l* and *.a constructs in the output
4789 <  for ac_arg in $ac_fc_v_output; do
4790 <     case $ac_arg in
4791 <        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4792 <          ac_cv_prog_fc_v=$ac_verb
4793 <          break 2 ;;
4794 <     esac
4795 <  done
4796 < done
4797 < if test -z "$ac_cv_prog_fc_v"; then
4798 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4799 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4800 < fi
4801 < else
4802 <  echo "$as_me: failed program was:" >&5
4803 < sed 's/^/| /' conftest.$ac_ext >&5
5601 > $as_echo "#define HAVE_FFTW3_H 1" >>confdefs.h
5602  
5603 <        { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
5604 < echo "$as_me: WARNING: compilation failed" >&2;}
5605 < fi
5603 >        FFTW_INC_DIR="${FFTW_HOME}/include"
5604 >        FFTW_LIB_DIR="${FFTW_HOME}/lib"
5605 >        FFTW_LIBS="-lfftw3"
5606 >      else
5607 >        if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"; then
5608  
5609 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
5609 > $as_echo "#define HAVE_FFTW_H 1" >>confdefs.h
5610  
5611 < fi
5612 < { echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
5613 < echo "${ECHO_T}$ac_cv_prog_fc_v" >&6; }
5614 < { echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
5615 < echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6; }
4816 < if test "${ac_cv_fc_libs+set}" = set; then
4817 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4818 < else
4819 <  if test "x$FCLIBS" != "x"; then
4820 <  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4821 < else
5611 >          FFTW_INC_DIR="${FFTW_HOME}/include"
5612 >          FFTW_LIB_DIR="${FFTW_HOME}/lib"
5613 >          FFTW_LIBS="-lfftw"
5614 >        else
5615 >          if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"; then
5616  
5617 < cat >conftest.$ac_ext <<_ACEOF
4824 <      program main
5617 > $as_echo "#define HAVE_DFFTW_H 1" >>confdefs.h
5618  
5619 <      end
5620 < _ACEOF
5619 >            FFTW_INC_DIR="${FFTW_HOME}/include"
5620 >            FFTW_LIB_DIR="${FFTW_HOME}/lib"
5621 >            FFTW_LIBS="-ldfftw"
5622 >          else
5623 >            { $as_echo "$as_me:${as_lineno-$LINENO}: checking fftw in ${FFTW_HOME}" >&5
5624 > $as_echo_n "checking fftw in ${FFTW_HOME}... " >&6; }
5625 >            FFTW_INC_DIR=
5626 >            FFTW_LIB_DIR=
5627 >            FFTW_LIBS=
5628 >            LDFLAGS="$FFTW_OLD_LDFLAGS"
5629 >            CFLAGS="$FFTW_OLD_CFLAGS"
5630 >            { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
5631 > $as_echo "failed" >&6; }
5632 >            echo ""
5633 >            echo "*********************************************************"
5634 >            echo "* WARNING: Could not find a working FFTW installation   *"
5635 >            echo "* If you need the staticProps program to be able to     *"
5636 >            echo "* compute undulation spectra, be sure to specify a      *"
5637 >            echo "* valid fftw installation with --with-fftw=DIR          *"
5638 >            echo "*                                                       *"
5639 >            echo "* OpenMD will still work without fftw installed.        *"
5640 >            echo "*********************************************************"
5641 >            echo ""
5642 >          fi
5643 >        fi
5644 >      fi
5645  
5646 < # Compile and link our simple test program by passing a flag (argument
5647 < # 1 to this macro) to the Fortran compiler in order to get
5648 < # "verbose" output that we can then parse for the Fortran linker
5649 < # flags.
5650 < ac_save_FFLAGS=$FCFLAGS
5651 < FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
5652 < eval "set x $ac_link"
5653 < shift
5654 < echo "$as_me:$LINENO: $*" >&5
5655 < ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
5656 < echo "$ac_fc_v_output" >&5
5657 < FCFLAGS=$ac_save_FFLAGS
5646 >
5647 >
5648 >    fi
5649 >  fi
5650 > fi
5651 >
5652 > #
5653 > # Handle user hints
5654 > #
5655 >
5656 > # Check whether --with-qhull was given.
5657 > if test "${with_qhull+set}" = set; then :
5658 >  withval=$with_qhull; qhull_dir="$withval"
5659 > else
5660 >  qhull_dir="not_set"
5661 > fi
5662  
5663 < rm -rf conftest*
5663 > QHULL_INC_DIR=
5664 > QHULL_LIB_DIR=
5665 > QHULL=
5666 > USE_QHULL=no
5667  
5668 < # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
5669 < # /foo, /bar, and /baz are search directories for the Fortran linker.
5670 < # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
5671 < ac_fc_v_output="`echo $ac_fc_v_output |
5672 <        grep 'LPATH is:' |
5673 <        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
5668 > if test "$qhull_dir" != "no"; then
5669 >   if test "$qhull_dir" != "not_set" ; then
5670 >     if test -d "$qhull_dir"; then
5671 >       QHULL_HOME="$qhull_dir"
5672 >     else
5673 >       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&5
5674 > $as_echo "$as_me: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&2;}
5675 >       QHULL_HOME=/usr/local
5676 >       if test ! -f "${QHULL_HOME}/include/qhull/libqhull.h"; then
5677 >          QHULL_HOME=/usr
5678 >       fi
5679 >     fi
5680 >   fi
5681 >   #
5682 >   # Locate qhull, if wanted
5683 >   #
5684 >   if test -n "${QHULL_HOME}"; then
5685 >        { $as_echo "$as_me:${as_lineno-$LINENO}: Checking for qhull in ${QHULL_HOME}" >&5
5686 > $as_echo "$as_me: Checking for qhull in ${QHULL_HOME}" >&6;}
5687  
5688 < # FIXME: we keep getting bitten by quoted arguments; a more general fix
5689 < #        that detects unbalanced quotes in FLIBS should be implemented
5690 < #        and (ugh) tested at some point.
5691 < case $ac_fc_v_output in
5692 <  # If we are using xlf then replace all the commas with spaces.
4856 <  *xlfentry*)
4857 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
5688 >        ac_ext=c
5689 > ac_cpp='$CPP $CPPFLAGS'
5690 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5691 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5692 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5693  
5694 <  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
5695 <  # $LIBS confuse us, and the libraries appear later in the output anyway).
5696 <  *mGLOB_options_string*)
5697 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"-mGLOB[^"]*"/ /g'` ;;
5698 <
5699 <  # Portland Group compiler has singly- or doubly-quoted -cmdline argument
5700 <  # Singly-quoted arguments were reported for versions 5.2-4 and 6.0-4.
5701 <  # Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
5702 <  *-cmdline\ * | *-ignore\ * | *-def\ *)
4868 <    ac_fc_v_output=`echo $ac_fc_v_output | sed "\
4869 <        s/-cmdline  *'[^']*'/ /g; s/-cmdline  *\"[^\"]*\"/ /g
4870 <        s/-ignore  *'[^']*'/ /g; s/-ignore  *\"[^\"]*\"/ /g
4871 <        s/-def  *'[^']*'/ /g; s/-def  *\"[^\"]*\"/ /g"` ;;
4872 <
4873 <  # If we are using Cray Fortran then delete quotes.
4874 <  *cft90*)
4875 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"//g'` ;;
4876 < esac
4877 <
4878 <
4879 <
4880 < ac_cv_fc_libs=
4881 <
4882 < # Save positional arguments (if any)
4883 < ac_save_positional="$@"
4884 <
4885 < set X $ac_fc_v_output
4886 < while test $# != 1; do
4887 <  shift
4888 <  ac_arg=$1
4889 <  case $ac_arg in
4890 <        [\\/]*.a | ?:[\\/]*.a)
4891 <            ac_exists=false
4892 <  for ac_i in $ac_cv_fc_libs; do
4893 <    if test x"$ac_arg" = x"$ac_i"; then
4894 <      ac_exists=true
4895 <      break
4896 <    fi
4897 <  done
4898 <
4899 <  if test x"$ac_exists" = xtrue; then
4900 <  :
5694 >        QHULL_OLD_LDFLAGS=$LDFLAGS
5695 >        QHULL_OLD_CFLAGS=$CFLAGS
5696 >        QHULL_OLD_CPPFLAGS=$CPPFLAGS
5697 >        LDFLAGS="$LDFLAGS -L${QHULL_HOME}/lib"
5698 >        CFLAGS="$CFLAGS -I${QHULL_HOME}/include"
5699 >        CPPFLAGS="$CPPFLAGS -I${QHULL_HOME}/include"
5700 >        ac_fn_c_check_header_mongrel "$LINENO" "qhull/libqhull.h" "ac_cv_header_qhull_libqhull_h" "$ac_includes_default"
5701 > if test "x$ac_cv_header_qhull_libqhull_h" = xyes; then :
5702 >  qhull_cv_libqhull_h=yes
5703   else
5704 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5704 >  qhull_cv_libqhull_h=no
5705   fi
5706  
4905 –          ;;
4906 –        -bI:*)
4907 –            ac_exists=false
4908 –  for ac_i in $ac_cv_fc_libs; do
4909 –    if test x"$ac_arg" = x"$ac_i"; then
4910 –      ac_exists=true
4911 –      break
4912 –    fi
4913 –  done
5707  
5708 <  if test x"$ac_exists" = xtrue; then
5709 <  :
5708 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for qh_qhull in -lqhull" >&5
5709 > $as_echo_n "checking for qh_qhull in -lqhull... " >&6; }
5710 > if ${ac_cv_lib_qhull_qh_qhull+:} false; then :
5711 >  $as_echo_n "(cached) " >&6
5712   else
5713 <  if test "$ac_compiler_gnu" = yes; then
5714 <  for ac_link_opt in $ac_arg; do
5715 <    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5716 <  done
5713 >  ac_check_lib_save_LIBS=$LIBS
5714 > LIBS="-lqhull  $LIBS"
5715 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5716 > /* end confdefs.h.  */
5717 >
5718 > /* Override any GCC internal prototype to avoid an error.
5719 >   Use char because int might match the return type of a GCC
5720 >   builtin and then its argument prototype would still apply.  */
5721 > #ifdef __cplusplus
5722 > extern "C"
5723 > #endif
5724 > char qh_qhull ();
5725 > int
5726 > main ()
5727 > {
5728 > return qh_qhull ();
5729 >  ;
5730 >  return 0;
5731 > }
5732 > _ACEOF
5733 > if ac_fn_c_try_link "$LINENO"; then :
5734 >  ac_cv_lib_qhull_qh_qhull=yes
5735   else
5736 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5736 >  ac_cv_lib_qhull_qh_qhull=no
5737   fi
5738 + rm -f core conftest.err conftest.$ac_objext \
5739 +    conftest$ac_exeext conftest.$ac_ext
5740 + LIBS=$ac_check_lib_save_LIBS
5741   fi
5742 <
5743 <          ;;
5744 <          # Ignore these flags.
5745 <        -lang* | -lcrt*.o | -lc | -lgcc* | -lSystem | -libmil | -LANG:=* | -LIST:* | -LNO:*)
4930 <          ;;
4931 <        -lkernel32)
4932 <          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4933 <          ;;
4934 <        -[LRuYz])
4935 <          # These flags, when seen by themselves, take an argument.
4936 <          # We remove the space between option and argument and re-iterate
4937 <          # unless we find an empty arg or a new option (starting with -)
4938 <          case $2 in
4939 <             "" | -*);;
4940 <             *)
4941 <                ac_arg="$ac_arg$2"
4942 <                shift; shift
4943 <                set X $ac_arg "$@"
4944 <                ;;
4945 <          esac
4946 <          ;;
4947 <        -YP,*)
4948 <          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4949 <              ac_exists=false
4950 <  for ac_i in $ac_cv_fc_libs; do
4951 <    if test x"$ac_j" = x"$ac_i"; then
4952 <      ac_exists=true
4953 <      break
4954 <    fi
4955 <  done
4956 <
4957 <  if test x"$ac_exists" = xtrue; then
4958 <  :
5742 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_qhull_qh_qhull" >&5
5743 > $as_echo "$ac_cv_lib_qhull_qh_qhull" >&6; }
5744 > if test "x$ac_cv_lib_qhull_qh_qhull" = xyes; then :
5745 >  qhull_cv_libqhull=yes
5746   else
5747 <  ac_arg="$ac_arg $ac_j"
4961 <                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5747 >  qhull_cv_libqhull=no
5748   fi
5749  
5750 <          done
5751 <          ;;
5752 <        -[lLR]*)
5753 <            ac_exists=false
4968 <  for ac_i in $ac_cv_fc_libs; do
4969 <    if test x"$ac_arg" = x"$ac_i"; then
4970 <      ac_exists=true
4971 <      break
4972 <    fi
4973 <  done
4974 <
4975 <  if test x"$ac_exists" = xtrue; then
4976 <  :
5750 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for qh_qhull in -lqhull6" >&5
5751 > $as_echo_n "checking for qh_qhull in -lqhull6... " >&6; }
5752 > if ${ac_cv_lib_qhull6_qh_qhull+:} false; then :
5753 >  $as_echo_n "(cached) " >&6
5754   else
5755 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5756 < fi
5755 >  ac_check_lib_save_LIBS=$LIBS
5756 > LIBS="-lqhull6  $LIBS"
5757 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5758 > /* end confdefs.h.  */
5759  
5760 <          ;;
5761 <        -zallextract*| -zdefaultextract)
5762 <          ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5763 <          ;;
5764 <          # Ignore everything else.
5765 <  esac
5766 < done
5767 < # restore positional arguments
5768 < set X $ac_save_positional; shift
5769 <
5770 < # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5771 < # then we insist that the "run path" must be an absolute path (i.e. it
5772 < # must begin with a "/").
5773 < case `(uname -sr) 2>/dev/null` in
5774 <   "SunOS 5"*)
5775 <      ac_ld_run_path=`echo $ac_fc_v_output |
5776 <                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4998 <      test "x$ac_ld_run_path" != x &&
4999 <        if test "$ac_compiler_gnu" = yes; then
5000 <  for ac_link_opt in $ac_ld_run_path; do
5001 <    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5002 <  done
5760 > /* Override any GCC internal prototype to avoid an error.
5761 >   Use char because int might match the return type of a GCC
5762 >   builtin and then its argument prototype would still apply.  */
5763 > #ifdef __cplusplus
5764 > extern "C"
5765 > #endif
5766 > char qh_qhull ();
5767 > int
5768 > main ()
5769 > {
5770 > return qh_qhull ();
5771 >  ;
5772 >  return 0;
5773 > }
5774 > _ACEOF
5775 > if ac_fn_c_try_link "$LINENO"; then :
5776 >  ac_cv_lib_qhull6_qh_qhull=yes
5777   else
5778 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5778 >  ac_cv_lib_qhull6_qh_qhull=no
5779   fi
5780 <      ;;
5781 < esac
5782 < fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5009 <
5780 > rm -f core conftest.err conftest.$ac_objext \
5781 >    conftest$ac_exeext conftest.$ac_ext
5782 > LIBS=$ac_check_lib_save_LIBS
5783   fi
5784 < { echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5785 < echo "${ECHO_T}$ac_cv_fc_libs" >&6; }
5786 < FCLIBS="$ac_cv_fc_libs"
5787 <
5015 <
5016 < ac_ext=${ac_fc_srcext-f}
5017 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5018 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5019 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5020 <
5021 <
5022 < ac_ext=${ac_fc_srcext-f}
5023 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5024 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5025 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5026 <
5027 < { echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
5028 < echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6; }
5029 < if test "${ac_cv_fc_dummy_main+set}" = set; then
5030 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5784 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_qhull6_qh_qhull" >&5
5785 > $as_echo "$ac_cv_lib_qhull6_qh_qhull" >&6; }
5786 > if test "x$ac_cv_lib_qhull6_qh_qhull" = xyes; then :
5787 >  qhull_cv_libqhull6=yes
5788   else
5789 <  ac_fc_dm_save_LIBS=$LIBS
5790 < LIBS="$LIBS $FCLIBS"
5791 < ac_fortran_dm_var=FC_DUMMY_MAIN
5792 < ac_ext=c
5789 >  qhull_cv_libqhull6=no
5790 > fi
5791 >
5792 >        LDFLAGS="$QHULL_OLD_LDFLAGS"
5793 >        CFLAGS="$QHULL_OLD_CFLAGS"
5794 >        CPPFLAGS="$QHULL_OLD_CPPFLAGS"
5795 >        ac_ext=c
5796   ac_cpp='$CPP $CPPFLAGS'
5797   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5798   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5799   ac_compiler_gnu=$ac_cv_c_compiler_gnu
5800  
5801 < # First, try linking without a dummy main:
5802 < cat >conftest.$ac_ext <<_ACEOF
5803 < /* confdefs.h.  */
5801 >
5802 >        if test "$qhull_cv_libqhull_h" = "yes" -a "$qhull_cv_libqhull" = "yes" -o "$qhull_cv_libqhull6" = "yes"; then
5803 >
5804 > $as_echo "#define HAVE_LIBQHULL_H 1" >>confdefs.h
5805 >
5806 >           if test "$qhull_cv_libqhull" = "yes"; then
5807 >
5808 > $as_echo "#define HAVE_QHULL 1" >>confdefs.h
5809 >
5810 >                QHULL="-lqhull"
5811 >           fi
5812 >           if test "$qhull_cv_libqhull6" = "yes"; then
5813 >
5814 > $as_echo "#define HAVE_QHULL 1" >>confdefs.h
5815 >
5816 >                QHULL="-lqhull6"
5817 >           fi
5818 >           USE_QHULL=yes
5819 >           QHULL_INC_DIR="${QHULL_HOME}/include"
5820 >           QHULL_LIB_DIR="${QHULL_HOME}/lib"
5821 >           { $as_echo "$as_me:${as_lineno-$LINENO}: result: Working qhull found, will proceed." >&5
5822 > $as_echo "Working qhull found, will proceed." >&6; }
5823 >        else
5824 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: " >&5
5825 > $as_echo "$as_me: WARNING: " >&2;}
5826 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Could not find a working qhull installation" >&5
5827 > $as_echo "$as_me: WARNING: Could not find a working qhull installation" >&2;}
5828 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: If you need OpenMD to be able to deal with convex    " >&5
5829 > $as_echo "$as_me: WARNING: If you need OpenMD to be able to deal with convex    " >&2;}
5830 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: hulls be sure to specify a valid qhull installation " >&5
5831 > $as_echo "$as_me: WARNING: hulls be sure to specify a valid qhull installation " >&2;}
5832 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: with --with-qhull=DIR                               " >&5
5833 > $as_echo "$as_me: WARNING: with --with-qhull=DIR                               " >&2;}
5834 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: " >&5
5835 > $as_echo "$as_me: WARNING: " >&2;}
5836 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: OpenMD will still work without qhull installed.      " >&5
5837 > $as_echo "$as_me: WARNING: OpenMD will still work without qhull installed.      " >&2;}
5838 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: " >&5
5839 > $as_echo "$as_me: WARNING: " >&2;}
5840 >        fi
5841 >    fi
5842 > fi
5843 >
5844 >
5845 >
5846 >
5847 >
5848 > ac_ext=cpp
5849 > ac_cpp='$CXXCPP $CPPFLAGS'
5850 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5851 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5852 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5853 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
5854 > $as_echo_n "checking how to run the C++ preprocessor... " >&6; }
5855 > if test -z "$CXXCPP"; then
5856 >  if ${ac_cv_prog_CXXCPP+:} false; then :
5857 >  $as_echo_n "(cached) " >&6
5858 > else
5859 >      # Double quotes because CXXCPP needs to be expanded
5860 >    for CXXCPP in "$CXX -E" "/lib/cpp"
5861 >    do
5862 >      ac_preproc_ok=false
5863 > for ac_cxx_preproc_warn_flag in '' yes
5864 > do
5865 >  # Use a header file that comes with gcc, so configuring glibc
5866 >  # with a fresh cross-compiler works.
5867 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5868 >  # <limits.h> exists even on freestanding compilers.
5869 >  # On the NeXT, cc -E runs the code through the compiler's parser,
5870 >  # not just through cpp. "Syntax error" is here to catch this case.
5871 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5872 > /* end confdefs.h.  */
5873 > #ifdef __STDC__
5874 > # include <limits.h>
5875 > #else
5876 > # include <assert.h>
5877 > #endif
5878 >                     Syntax error
5879   _ACEOF
5880 < cat confdefs.h >>conftest.$ac_ext
5881 < cat >>conftest.$ac_ext <<_ACEOF
5880 > if ac_fn_cxx_try_cpp "$LINENO"; then :
5881 >
5882 > else
5883 >  # Broken: fails on valid input.
5884 > continue
5885 > fi
5886 > rm -f conftest.err conftest.i conftest.$ac_ext
5887 >
5888 >  # OK, works on sane cases.  Now check whether nonexistent headers
5889 >  # can be detected and how.
5890 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5891   /* end confdefs.h.  */
5892 + #include <ac_nonexistent.h>
5893 + _ACEOF
5894 + if ac_fn_cxx_try_cpp "$LINENO"; then :
5895 +  # Broken: success on invalid input.
5896 + continue
5897 + else
5898 +  # Passes both tests.
5899 + ac_preproc_ok=:
5900 + break
5901 + fi
5902 + rm -f conftest.err conftest.i conftest.$ac_ext
5903  
5904 < #ifdef FC_DUMMY_MAIN
5905 < #ifndef FC_DUMMY_MAIN_EQ_F77
5906 < #  ifdef __cplusplus
5907 <     extern "C"
5908 < #  endif
5909 <   int FC_DUMMY_MAIN() { return 1; }
5904 > done
5905 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5906 > rm -f conftest.i conftest.err conftest.$ac_ext
5907 > if $ac_preproc_ok; then :
5908 >  break
5909 > fi
5910 >
5911 >    done
5912 >    ac_cv_prog_CXXCPP=$CXXCPP
5913 >
5914 > fi
5915 >  CXXCPP=$ac_cv_prog_CXXCPP
5916 > else
5917 >  ac_cv_prog_CXXCPP=$CXXCPP
5918 > fi
5919 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
5920 > $as_echo "$CXXCPP" >&6; }
5921 > ac_preproc_ok=false
5922 > for ac_cxx_preproc_warn_flag in '' yes
5923 > do
5924 >  # Use a header file that comes with gcc, so configuring glibc
5925 >  # with a fresh cross-compiler works.
5926 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5927 >  # <limits.h> exists even on freestanding compilers.
5928 >  # On the NeXT, cc -E runs the code through the compiler's parser,
5929 >  # not just through cpp. "Syntax error" is here to catch this case.
5930 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5931 > /* end confdefs.h.  */
5932 > #ifdef __STDC__
5933 > # include <limits.h>
5934 > #else
5935 > # include <assert.h>
5936   #endif
5937 < #endif
5937 >                     Syntax error
5938 > _ACEOF
5939 > if ac_fn_cxx_try_cpp "$LINENO"; then :
5940 >
5941 > else
5942 >  # Broken: fails on valid input.
5943 > continue
5944 > fi
5945 > rm -f conftest.err conftest.i conftest.$ac_ext
5946 >
5947 >  # OK, works on sane cases.  Now check whether nonexistent headers
5948 >  # can be detected and how.
5949 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5950 > /* end confdefs.h.  */
5951 > #include <ac_nonexistent.h>
5952 > _ACEOF
5953 > if ac_fn_cxx_try_cpp "$LINENO"; then :
5954 >  # Broken: success on invalid input.
5955 > continue
5956 > else
5957 >  # Passes both tests.
5958 > ac_preproc_ok=:
5959 > break
5960 > fi
5961 > rm -f conftest.err conftest.i conftest.$ac_ext
5962 >
5963 > done
5964 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5965 > rm -f conftest.i conftest.err conftest.$ac_ext
5966 > if $ac_preproc_ok; then :
5967 >
5968 > else
5969 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
5970 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
5971 > as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check
5972 > See \`config.log' for more details" "$LINENO" 5; }
5973 > fi
5974 >
5975 > ac_ext=cpp
5976 > ac_cpp='$CXXCPP $CPPFLAGS'
5977 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5978 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5979 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5980 >
5981 >
5982 > #
5983 > # Handle user hints
5984 > #
5985 >
5986 > # Check whether --with-openbabel was given.
5987 > if test "${with_openbabel+set}" = set; then :
5988 >  withval=$with_openbabel; openbabel_dir="$withval"
5989 > else
5990 >                openbabel_dir="not_set"
5991 > fi
5992 >
5993 > if test "$openbabel_dir" != "no"; then
5994 >
5995 > if test "$openbabel_dir" != "not_set" ; then
5996 >  if test -d "$openbabel_dir"
5997 >  then
5998 >    OPENBABEL_HOME="$openbabel_dir"
5999 >  else
6000 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $openbabel_dir does not exist, checking usual places" >&5
6001 > $as_echo "$as_me: WARNING: Sorry, $openbabel_dir does not exist, checking usual places" >&2;}
6002 >        OPENBABEL_HOME=/usr/local
6003 >        if test ! -f "${OPENBABEL_HOME}/include/openbabel-2.0/openbabel/babelconfig.h" -a -f "${OPENBABEL_HOME}/include/openbabel-2.0/openbabel/obconversion.h"
6004 >        then
6005 >                OPENBABEL_HOME=/usr
6006 >        fi
6007 >  fi
6008 > fi
6009 > #
6010 > # Locate openbabel, if wanted
6011 > #
6012 > if test -n "${OPENBABEL_HOME}"
6013 > then
6014 >
6015 >        ac_ext=cpp
6016 > ac_cpp='$CXXCPP $CPPFLAGS'
6017 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6018 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6019 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6020 >
6021 >        OPENBABEL_OLD_LDFLAGS=$LDFLAGS
6022 >        OPENBABEL_OLD_CPPFLAGS=$CPPFLAGS
6023 >        LDFLAGS="$LDFLAGS -L${OPENBABEL_HOME}/lib -lopenbabel"
6024 >        CPPFLAGS="$CPPFLAGS -I${OPENBABEL_HOME}/include/openbabel-2.0"
6025 >        ac_fn_cxx_check_header_mongrel "$LINENO" "openbabel/babelconfig.h" "ac_cv_header_openbabel_babelconfig_h" "$ac_includes_default"
6026 > if test "x$ac_cv_header_openbabel_babelconfig_h" = xyes; then :
6027 >  openbabel_cv_openbabel_h=yes
6028 > else
6029 >  openbabel_cv_openbabel_h=no
6030 > fi
6031 >
6032 >
6033 >        ac_fn_cxx_check_header_mongrel "$LINENO" "openbabel/obconversion.h" "ac_cv_header_openbabel_obconversion_h" "$ac_includes_default"
6034 > if test "x$ac_cv_header_openbabel_obconversion_h" = xyes; then :
6035 >  openbabel_cv_obconversion_h=yes
6036 > else
6037 >  openbabel_cv_obconversion_h=no
6038 > fi
6039 >
6040 >
6041 >        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6042 > /* end confdefs.h.  */
6043 >
6044 >
6045 > #include <openbabel/babelconfig.h>
6046 > #include <openbabel/obconversion.h>
6047 > using namespace std;
6048 > using namespace OpenBabel;
6049 >
6050   int
6051   main ()
6052   {
6053  
6054 + OBConversion Conv(&cin, &cout);
6055 +
6056 +
6057    ;
6058    return 0;
6059   }
6060   _ACEOF
6061 < rm -rf conftest.$ac_objext conftest$ac_exeext
6062 < if { (ac_try="$ac_link"
6063 < case "(($ac_try" in
6064 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6065 <  *) ac_try_echo=$ac_try;;
6066 < esac
5071 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5072 <  (eval "$ac_link") 2>conftest.er1
5073 <  ac_status=$?
5074 <  grep -v '^ *+' conftest.er1 >conftest.err
5075 <  rm -f conftest.er1
5076 <  cat conftest.err >&5
5077 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5078 <  (exit $ac_status); } && {
5079 <         test -z "$ac_c_werror_flag" ||
5080 <         test ! -s conftest.err
5081 <       } && test -s conftest$ac_exeext &&
5082 <       $as_test_x conftest$ac_exeext; then
5083 <  ac_cv_fortran_dummy_main=none
6061 > if ac_fn_cxx_try_link "$LINENO"; then :
6062 >
6063 >                openbabel_lib_found="yes"
6064 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
6065 > $as_echo "found" >&6; }
6066 >
6067   else
5085 –  echo "$as_me: failed program was:" >&5
5086 – sed 's/^/| /' conftest.$ac_ext >&5
6068  
6069 <        ac_cv_fortran_dummy_main=unknown
6069 >                openbabel_lib_found="no"
6070 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6071 > $as_echo "not found" >&6; }
6072 >
6073 >
6074   fi
6075 + rm -f core conftest.err conftest.$ac_objext \
6076 +    conftest$ac_exeext conftest.$ac_ext
6077 +        ac_ext=c
6078 + ac_cpp='$CPP $CPPFLAGS'
6079 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6080 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6081 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
6082  
6083 < rm -rf core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6084 <      conftest$ac_exeext conftest.$ac_ext
6083 >        LDFLAGS="$OPENBABEL_OLD_LDFLAGS"
6084 >        CPPFLAGS="$OPENBABEL_OLD_CPPFLAGS"
6085  
6086 < if test $ac_cv_fortran_dummy_main = unknown; then
6087 <   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
6088 <     cat >conftest.$ac_ext <<_ACEOF
6089 < /* confdefs.h.  */
6090 < _ACEOF
6091 < cat confdefs.h >>conftest.$ac_ext
6092 < cat >>conftest.$ac_ext <<_ACEOF
6086 >        if test "$openbabel_lib_found" = "yes" -a "$openbabel_cv_openbabel_h" = "yes" -a "$openbabel_cv_obconversion_h" = "yes"; then
6087 >                USE_OPENBABEL=yes
6088 >                OPENBABEL_INC_DIR="${OPENBABEL_HOME}/include/openbabel-2.0"
6089 >                OPENBABEL_LIB_DIR="${OPENBABEL_HOME}/lib"
6090 >                OPENBABEL_LIB="-lopenbabel"
6091 >        else
6092 >                { $as_echo "$as_me:${as_lineno-$LINENO}: checking openbabel in ${OPENBABEL_HOME}" >&5
6093 > $as_echo_n "checking openbabel in ${OPENBABEL_HOME}... " >&6; }
6094 >                OPENBABEL_INC_DIR=
6095 >                OPENBABEL_LIB_DIR=
6096 >                OPENBABEL_LIB=
6097 >                USE_OPENBABEL=no
6098 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
6099 > $as_echo "failed" >&6; }
6100 >                echo ""
6101 >                echo "*********************************************************"
6102 >                echo "* WARNING: Could not find a working openbabel-2.x       *"
6103 >                echo "* installation If you need OpenMD to be able to convert *"
6104 >                echo "* xyz or pdb files you need to specify a valid          *"
6105 >                echo "* openbabel-2.x installation with --with-openbabel=DIR  *"
6106 >                echo "*                                                       *"
6107 >                echo "* OpenMD will still work without openbabel installed.   *"
6108 >                echo "*********************************************************"
6109 >                echo ""
6110 >        fi
6111 >
6112 >
6113 >
6114 >
6115 > fi
6116 > fi
6117 >
6118 >
6119 > # Checks for header files.
6120 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
6121 > $as_echo_n "checking for ANSI C header files... " >&6; }
6122 > if ${ac_cv_header_stdc+:} false; then :
6123 >  $as_echo_n "(cached) " >&6
6124 > else
6125 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6126   /* end confdefs.h.  */
6127 < #define $ac_fortran_dm_var $ac_func
6128 < #ifdef FC_DUMMY_MAIN
6129 < #ifndef FC_DUMMY_MAIN_EQ_F77
6130 < #  ifdef __cplusplus
6131 <     extern "C"
5107 < #  endif
5108 <   int FC_DUMMY_MAIN() { return 1; }
5109 < #endif
5110 < #endif
6127 > #include <stdlib.h>
6128 > #include <stdarg.h>
6129 > #include <string.h>
6130 > #include <float.h>
6131 >
6132   int
6133   main ()
6134   {
# Line 5116 | Line 6137 | _ACEOF
6137    return 0;
6138   }
6139   _ACEOF
6140 < rm -rf conftest.$ac_objext conftest$ac_exeext
6141 < if { (ac_try="$ac_link"
5121 < case "(($ac_try" in
5122 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5123 <  *) ac_try_echo=$ac_try;;
5124 < esac
5125 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5126 <  (eval "$ac_link") 2>conftest.er1
5127 <  ac_status=$?
5128 <  grep -v '^ *+' conftest.er1 >conftest.err
5129 <  rm -f conftest.er1
5130 <  cat conftest.err >&5
5131 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5132 <  (exit $ac_status); } && {
5133 <         test -z "$ac_c_werror_flag" ||
5134 <         test ! -s conftest.err
5135 <       } && test -s conftest$ac_exeext &&
5136 <       $as_test_x conftest$ac_exeext; then
5137 <  ac_cv_fortran_dummy_main=$ac_func; break
6140 > if ac_fn_c_try_compile "$LINENO"; then :
6141 >  ac_cv_header_stdc=yes
6142   else
6143 <  echo "$as_me: failed program was:" >&5
6144 < sed 's/^/| /' conftest.$ac_ext >&5
6143 >  ac_cv_header_stdc=no
6144 > fi
6145 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6146  
6147 + if test $ac_cv_header_stdc = yes; then
6148 +  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
6149 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6150 + /* end confdefs.h.  */
6151 + #include <string.h>
6152  
6153 + _ACEOF
6154 + if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6155 +  $EGREP "memchr" >/dev/null 2>&1; then :
6156 +
6157 + else
6158 +  ac_cv_header_stdc=no
6159   fi
6160 + rm -f conftest*
6161  
5145 – rm -rf core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
5146 –      conftest$ac_exeext conftest.$ac_ext
5147 –   done
5148 – fi
5149 – ac_ext=${ac_fc_srcext-f}
5150 – ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5151 – ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5152 – ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5153 – ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
5154 – rm -rf conftest*
5155 – LIBS=$ac_fc_dm_save_LIBS
5156 –
6162   fi
5158 – { echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
5159 – echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6; }
5160 – FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
5161 – if test "$FC_DUMMY_MAIN" != unknown; then
5162 –  if test $FC_DUMMY_MAIN != none; then
6163  
6164 < cat >>confdefs.h <<_ACEOF
6165 < #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
6166 < _ACEOF
6164 > if test $ac_cv_header_stdc = yes; then
6165 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
6166 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6167 > /* end confdefs.h.  */
6168 > #include <stdlib.h>
6169  
5168 –  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
5169 –
5170 – cat >>confdefs.h <<\_ACEOF
5171 – #define FC_DUMMY_MAIN_EQ_F77 1
6170   _ACEOF
6171 + if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6172 +  $EGREP "free" >/dev/null 2>&1; then :
6173  
5174 –  fi
5175 – fi
6174   else
6175 <  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
5178 < See \`config.log' for more details." >&5
5179 < echo "$as_me: error: linking to Fortran libraries from C fails
5180 < See \`config.log' for more details." >&2;}
5181 <   { (exit 1); exit 1; }; }
6175 >  ac_cv_header_stdc=no
6176   fi
6177 + rm -f conftest*
6178  
6179 + fi
6180  
6181 < ac_ext=${ac_fc_srcext-f}
6182 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6183 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6184 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5189 <
5190 < ac_ext=${ac_fc_srcext-f}
5191 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5192 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5193 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5194 < { echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
5195 < echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6; }
5196 < if test "${ac_cv_fc_mangling+set}" = set; then
5197 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6181 > if test $ac_cv_header_stdc = yes; then
6182 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
6183 >  if test "$cross_compiling" = yes; then :
6184 >  :
6185   else
6186 <  cat >conftest.$ac_ext <<_ACEOF
5200 <      subroutine foobar()
5201 <      return
5202 <      end
5203 <      subroutine foo_bar()
5204 <      return
5205 <      end
5206 < _ACEOF
5207 < rm -rf conftest.$ac_objext
5208 < if { (ac_try="$ac_compile"
5209 < case "(($ac_try" in
5210 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5211 <  *) ac_try_echo=$ac_try;;
5212 < esac
5213 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5214 <  (eval "$ac_compile") 2>conftest.er1
5215 <  ac_status=$?
5216 <  grep -v '^ *+' conftest.er1 >conftest.err
5217 <  rm -f conftest.er1
5218 <  cat conftest.err >&5
5219 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5220 <  (exit $ac_status); } && {
5221 <         test -z "$ac_fc_werror_flag" ||
5222 <         test ! -s conftest.err
5223 <       } && test -s conftest.$ac_objext; then
5224 <  mv conftest.$ac_objext cfortran_test.$ac_objext
5225 <
5226 <  ac_save_LIBS=$LIBS
5227 <  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
5228 <
5229 <  ac_ext=c
5230 < ac_cpp='$CPP $CPPFLAGS'
5231 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5232 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5233 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
5234 <  ac_success=no
5235 <  for ac_foobar in foobar FOOBAR; do
5236 <    for ac_underscore in "" "_"; do
5237 <      ac_func="$ac_foobar$ac_underscore"
5238 <      cat >conftest.$ac_ext <<_ACEOF
5239 < /* confdefs.h.  */
5240 < _ACEOF
5241 < cat confdefs.h >>conftest.$ac_ext
5242 < cat >>conftest.$ac_ext <<_ACEOF
6186 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6187   /* end confdefs.h.  */
6188 <
6189 < /* Override any GCC internal prototype to avoid an error.
6190 <   Use char because int might match the return type of a GCC
6191 <   builtin and then its argument prototype would still apply.  */
6192 < #ifdef __cplusplus
6193 < extern "C"
6188 > #include <ctype.h>
6189 > #include <stdlib.h>
6190 > #if ((' ' & 0x0FF) == 0x020)
6191 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
6192 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
6193 > #else
6194 > # define ISLOWER(c) \
6195 >                   (('a' <= (c) && (c) <= 'i') \
6196 >                     || ('j' <= (c) && (c) <= 'r') \
6197 >                     || ('s' <= (c) && (c) <= 'z'))
6198 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
6199   #endif
6200 < char $ac_func ();
6201 < #ifdef FC_DUMMY_MAIN
5253 < #ifndef FC_DUMMY_MAIN_EQ_F77
5254 < #  ifdef __cplusplus
5255 <     extern "C"
5256 < #  endif
5257 <   int FC_DUMMY_MAIN() { return 1; }
5258 < #endif
5259 < #endif
6200 >
6201 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
6202   int
6203   main ()
6204   {
6205 < return $ac_func ();
6206 <  ;
6205 >  int i;
6206 >  for (i = 0; i < 256; i++)
6207 >    if (XOR (islower (i), ISLOWER (i))
6208 >        || toupper (i) != TOUPPER (i))
6209 >      return 2;
6210    return 0;
6211   }
6212   _ACEOF
6213 < rm -rf conftest.$ac_objext conftest$ac_exeext
6214 < if { (ac_try="$ac_link"
5270 < case "(($ac_try" in
5271 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5272 <  *) ac_try_echo=$ac_try;;
5273 < esac
5274 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5275 <  (eval "$ac_link") 2>conftest.er1
5276 <  ac_status=$?
5277 <  grep -v '^ *+' conftest.er1 >conftest.err
5278 <  rm -f conftest.er1
5279 <  cat conftest.err >&5
5280 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5281 <  (exit $ac_status); } && {
5282 <         test -z "$ac_c_werror_flag" ||
5283 <         test ! -s conftest.err
5284 <       } && test -s conftest$ac_exeext &&
5285 <       $as_test_x conftest$ac_exeext; then
5286 <  ac_success=yes; break 2
6213 > if ac_fn_c_try_run "$LINENO"; then :
6214 >
6215   else
6216 <  echo "$as_me: failed program was:" >&5
6217 < sed 's/^/| /' conftest.$ac_ext >&5
6216 >  ac_cv_header_stdc=no
6217 > fi
6218 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
6219 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
6220 > fi
6221  
5291 –
6222   fi
6223 + fi
6224 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
6225 + $as_echo "$ac_cv_header_stdc" >&6; }
6226 + if test $ac_cv_header_stdc = yes; then
6227  
6228 < rm -rf core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
5295 <      conftest$ac_exeext conftest.$ac_ext
5296 <    done
5297 <  done
5298 <  ac_ext=${ac_fc_srcext-f}
5299 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5300 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5301 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6228 > $as_echo "#define STDC_HEADERS 1" >>confdefs.h
6229  
6230 <  if test "$ac_success" = "yes"; then
5304 <     case $ac_foobar in
5305 <        foobar)
5306 <           ac_case=lower
5307 <           ac_foo_bar=foo_bar
5308 <           ;;
5309 <        FOOBAR)
5310 <           ac_case=upper
5311 <           ac_foo_bar=FOO_BAR
5312 <           ;;
5313 <     esac
6230 > fi
6231  
6232 <     ac_ext=c
6233 < ac_cpp='$CPP $CPPFLAGS'
6234 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6235 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6236 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6237 <     ac_success_extra=no
6238 <     for ac_extra in "" "_"; do
5322 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
5323 <        cat >conftest.$ac_ext <<_ACEOF
5324 < /* confdefs.h.  */
6232 > for ac_header in libintl.h limits.h machine/hal_sysinfo.h stdlib.h string.h strings.h sys/param.h sys/pstat.h sys/sysctl.h sys/sysinfo.h sys/sysmp.h sys/systemcfg.h sys/table.h sys/time.h unistd.h
6233 > do :
6234 >  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
6235 > ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
6236 > if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
6237 >  cat >>confdefs.h <<_ACEOF
6238 > #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
6239   _ACEOF
6240 < cat confdefs.h >>conftest.$ac_ext
6241 < cat >>conftest.$ac_ext <<_ACEOF
6240 >
6241 > fi
6242 >
6243 > done
6244 >
6245 >
6246 > # Checks for typedefs, structures, and compiler characteristics.
6247 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for stdbool.h that conforms to C99" >&5
6248 > $as_echo_n "checking for stdbool.h that conforms to C99... " >&6; }
6249 > if ${ac_cv_header_stdbool_h+:} false; then :
6250 >  $as_echo_n "(cached) " >&6
6251 > else
6252 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6253   /* end confdefs.h.  */
6254  
6255 < /* Override any GCC internal prototype to avoid an error.
6256 <   Use char because int might match the return type of a GCC
6257 <   builtin and then its argument prototype would still apply.  */
5333 < #ifdef __cplusplus
5334 < extern "C"
6255 > #include <stdbool.h>
6256 > #ifndef bool
6257 > "error: bool is not defined"
6258   #endif
6259 < char $ac_func ();
6260 < #ifdef FC_DUMMY_MAIN
5338 < #ifndef FC_DUMMY_MAIN_EQ_F77
5339 < #  ifdef __cplusplus
5340 <     extern "C"
5341 < #  endif
5342 <   int FC_DUMMY_MAIN() { return 1; }
6259 > #ifndef false
6260 > "error: false is not defined"
6261   #endif
6262 + #if false
6263 + "error: false is not 0"
6264   #endif
6265 + #ifndef true
6266 + "error: true is not defined"
6267 + #endif
6268 + #if true != 1
6269 + "error: true is not 1"
6270 + #endif
6271 + #ifndef __bool_true_false_are_defined
6272 + "error: __bool_true_false_are_defined is not defined"
6273 + #endif
6274 +
6275 +        struct s { _Bool s: 1; _Bool t; } s;
6276 +
6277 +        char a[true == 1 ? 1 : -1];
6278 +        char b[false == 0 ? 1 : -1];
6279 +        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
6280 +        char d[(bool) 0.5 == true ? 1 : -1];
6281 +        /* See body of main program for 'e'.  */
6282 +        char f[(_Bool) 0.0 == false ? 1 : -1];
6283 +        char g[true];
6284 +        char h[sizeof (_Bool)];
6285 +        char i[sizeof s.t];
6286 +        enum { j = false, k = true, l = false * true, m = true * 256 };
6287 +        /* The following fails for
6288 +           HP aC++/ANSI C B3910B A.05.55 [Dec 04 2003]. */
6289 +        _Bool n[m];
6290 +        char o[sizeof n == m * sizeof n[0] ? 1 : -1];
6291 +        char p[-1 - (_Bool) 0 < 0 && -1 - (bool) 0 < 0 ? 1 : -1];
6292 +        /* Catch a bug in an HP-UX C compiler.  See
6293 +           http://gcc.gnu.org/ml/gcc-patches/2003-12/msg02303.html
6294 +           http://lists.gnu.org/archive/html/bug-coreutils/2005-11/msg00161.html
6295 +         */
6296 +        _Bool q = true;
6297 +        _Bool *pq = &q;
6298 +
6299   int
6300   main ()
6301   {
6302 < return $ac_func ();
6302 >
6303 >        bool e = &s;
6304 >        *pq |= q;
6305 >        *pq |= ! q;
6306 >        /* Refer to every declared value, to avoid compiler optimizations.  */
6307 >        return (!a + !b + !c + !d + !e + !f + !g + !h + !i + !!j + !k + !!l
6308 >                + !m + !n + !o + !p + !q + !pq);
6309 >
6310    ;
6311    return 0;
6312   }
6313   _ACEOF
6314 < rm -rf conftest.$ac_objext conftest$ac_exeext
6315 < if { (ac_try="$ac_link"
5355 < case "(($ac_try" in
5356 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5357 <  *) ac_try_echo=$ac_try;;
5358 < esac
5359 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5360 <  (eval "$ac_link") 2>conftest.er1
5361 <  ac_status=$?
5362 <  grep -v '^ *+' conftest.er1 >conftest.err
5363 <  rm -f conftest.er1
5364 <  cat conftest.err >&5
5365 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5366 <  (exit $ac_status); } && {
5367 <         test -z "$ac_c_werror_flag" ||
5368 <         test ! -s conftest.err
5369 <       } && test -s conftest$ac_exeext &&
5370 <       $as_test_x conftest$ac_exeext; then
5371 <  ac_success_extra=yes; break
6314 > if ac_fn_c_try_compile "$LINENO"; then :
6315 >  ac_cv_header_stdbool_h=yes
6316   else
6317 <  echo "$as_me: failed program was:" >&5
6318 < sed 's/^/| /' conftest.$ac_ext >&5
6317 >  ac_cv_header_stdbool_h=no
6318 > fi
6319 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6320 > fi
6321 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdbool_h" >&5
6322 > $as_echo "$ac_cv_header_stdbool_h" >&6; }
6323 > ac_fn_c_check_type "$LINENO" "_Bool" "ac_cv_type__Bool" "$ac_includes_default"
6324 > if test "x$ac_cv_type__Bool" = xyes; then :
6325  
6326 + cat >>confdefs.h <<_ACEOF
6327 + #define HAVE__BOOL 1
6328 + _ACEOF
6329  
6330 +
6331   fi
6332  
6333 < rm -rf core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
5380 <      conftest$ac_exeext conftest.$ac_ext
5381 <     done
5382 <     ac_ext=${ac_fc_srcext-f}
5383 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5384 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5385 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6333 > if test $ac_cv_header_stdbool_h = yes; then
6334  
6335 <     if test "$ac_success_extra" = "yes"; then
6336 <        ac_cv_fc_mangling="$ac_case case"
6337 <        if test -z "$ac_underscore"; then
6338 <           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
6339 <        else
6340 <           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
6341 <        fi
6342 <        if test -z "$ac_extra"; then
6343 <           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
6344 <        else
6345 <           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
6346 <        fi
6347 <      else
6348 <        ac_cv_fc_mangling="unknown"
6349 <      fi
6350 <  else
6351 <     ac_cv_fc_mangling="unknown"
6352 <  fi
6353 <
6354 <  LIBS=$ac_save_LIBS
6355 <  rm -rf cfortran_test* conftest*
6356 < else
6357 <  echo "$as_me: failed program was:" >&5
6358 < sed 's/^/| /' conftest.$ac_ext >&5
6359 <
6360 <        { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
6361 < See \`config.log' for more details." >&5
6362 < echo "$as_me: error: cannot compile a simple Fortran program
6363 < See \`config.log' for more details." >&2;}
6364 <   { (exit 1); exit 1; }; }
6365 < fi
6366 <
6367 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
6368 <
6369 < fi
6370 < { echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
6371 < echo "${ECHO_T}$ac_cv_fc_mangling" >&6; }
6372 <
6373 < ac_ext=${ac_fc_srcext-f}
6374 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6375 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6376 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6377 <
6378 < ac_ext=${ac_fc_srcext-f}
6379 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6380 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6381 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6382 <
6383 <
6384 < case $ac_cv_fc_mangling in
6385 <  "lower case, no underscore, no extra underscore")
6386 <          cat >>confdefs.h <<\_ACEOF
6387 < #define FC_FUNC(name,NAME) name
6388 < _ACEOF
6389 <
6390 <          cat >>confdefs.h <<\_ACEOF
6391 < #define FC_FUNC_(name,NAME) name
6392 < _ACEOF
6393 < ;;
6394 <  "lower case, no underscore, extra underscore")
6395 <          cat >>confdefs.h <<\_ACEOF
6396 < #define FC_FUNC(name,NAME) name
6397 < _ACEOF
6398 <
6399 <          cat >>confdefs.h <<\_ACEOF
6400 < #define FC_FUNC_(name,NAME) name ## _
6401 < _ACEOF
6402 < ;;
6403 <  "lower case, underscore, no extra underscore")
6404 <          cat >>confdefs.h <<\_ACEOF
6405 < #define FC_FUNC(name,NAME) name ## _
6406 < _ACEOF
6407 <
6408 <          cat >>confdefs.h <<\_ACEOF
6409 < #define FC_FUNC_(name,NAME) name ## _
6410 < _ACEOF
6411 < ;;
6412 <  "lower case, underscore, extra underscore")
6413 <          cat >>confdefs.h <<\_ACEOF
6414 < #define FC_FUNC(name,NAME) name ## _
6415 < _ACEOF
6416 <
6417 <          cat >>confdefs.h <<\_ACEOF
6418 < #define FC_FUNC_(name,NAME) name ## __
6419 < _ACEOF
6420 < ;;
6421 <  "upper case, no underscore, no extra underscore")
6422 <          cat >>confdefs.h <<\_ACEOF
6423 < #define FC_FUNC(name,NAME) NAME
6424 < _ACEOF
6425 <
6426 <          cat >>confdefs.h <<\_ACEOF
6427 < #define FC_FUNC_(name,NAME) NAME
6428 < _ACEOF
6429 < ;;
6430 <  "upper case, no underscore, extra underscore")
6431 <          cat >>confdefs.h <<\_ACEOF
6432 < #define FC_FUNC(name,NAME) NAME
6433 < _ACEOF
6434 <
6435 <          cat >>confdefs.h <<\_ACEOF
6436 < #define FC_FUNC_(name,NAME) NAME ## _
6437 < _ACEOF
6438 < ;;
6439 <  "upper case, underscore, no extra underscore")
6440 <          cat >>confdefs.h <<\_ACEOF
6441 < #define FC_FUNC(name,NAME) NAME ## _
6442 < _ACEOF
6443 <
6444 <          cat >>confdefs.h <<\_ACEOF
6445 < #define FC_FUNC_(name,NAME) NAME ## _
6446 < _ACEOF
6447 < ;;
6448 <  "upper case, underscore, extra underscore")
6449 <          cat >>confdefs.h <<\_ACEOF
6450 < #define FC_FUNC(name,NAME) NAME ## _
6451 < _ACEOF
6452 <
6453 <          cat >>confdefs.h <<\_ACEOF
6454 < #define FC_FUNC_(name,NAME) NAME ## __
6455 < _ACEOF
6456 < ;;
6457 <  *)
6458 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
6459 < echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
6460 <          ;;
6461 < esac
6462 <
6463 < ac_ext=${ac_fc_srcext-f}
6464 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6465 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6466 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6467 <
6468 <
6469 <
6470 < ac_ext=${ac_fc_srcext-f}
6471 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6472 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6473 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6474 < { echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
6475 < echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6; }
6476 < if test "${ac_cv_prog_fc_v+set}" = set; then
6477 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6478 < else
6479 <  cat >conftest.$ac_ext <<_ACEOF
6480 <      program main
6481 <
6482 <      end
6483 < _ACEOF
6484 < rm -rf conftest.$ac_objext
6485 < if { (ac_try="$ac_compile"
6486 < case "(($ac_try" in
6487 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6488 <  *) ac_try_echo=$ac_try;;
6489 < esac
6490 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6491 <  (eval "$ac_compile") 2>conftest.er1
6492 <  ac_status=$?
6493 <  grep -v '^ *+' conftest.er1 >conftest.err
6494 <  rm -f conftest.er1
6495 <  cat conftest.err >&5
6496 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6497 <  (exit $ac_status); } && {
6498 <         test -z "$ac_fc_werror_flag" ||
6499 <         test ! -s conftest.err
6500 <       } && test -s conftest.$ac_objext; then
6501 <  ac_cv_prog_fc_v=
6502 < # Try some options frequently used verbose output
6503 < for ac_verb in -v -verbose --verbose -V -\#\#\#; do
6504 <  cat >conftest.$ac_ext <<_ACEOF
6505 <      program main
6506 <
6507 <      end
6508 < _ACEOF
6509 <
6510 < # Compile and link our simple test program by passing a flag (argument
6511 < # 1 to this macro) to the Fortran compiler in order to get
6512 < # "verbose" output that we can then parse for the Fortran linker
6513 < # flags.
6514 < ac_save_FFLAGS=$FCFLAGS
6515 < FCFLAGS="$FCFLAGS $ac_verb"
6516 < eval "set x $ac_link"
6517 < shift
6518 < echo "$as_me:$LINENO: $*" >&5
6519 < ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
6520 < echo "$ac_fc_v_output" >&5
6521 < FCFLAGS=$ac_save_FFLAGS
6522 <
6523 < rm -rf conftest*
6524 <
6525 < # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
6526 < # /foo, /bar, and /baz are search directories for the Fortran linker.
6527 < # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
6528 < ac_fc_v_output="`echo $ac_fc_v_output |
6529 <        grep 'LPATH is:' |
6530 <        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
6531 <
6532 < # FIXME: we keep getting bitten by quoted arguments; a more general fix
6533 < #        that detects unbalanced quotes in FLIBS should be implemented
6534 < #        and (ugh) tested at some point.
6535 < case $ac_fc_v_output in
6536 <  # If we are using xlf then replace all the commas with spaces.
6537 <  *xlfentry*)
6538 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
6539 <
6540 <  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
6541 <  # $LIBS confuse us, and the libraries appear later in the output anyway).
6542 <  *mGLOB_options_string*)
6543 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"-mGLOB[^"]*"/ /g'` ;;
6544 <
6545 <  # Portland Group compiler has singly- or doubly-quoted -cmdline argument
6546 <  # Singly-quoted arguments were reported for versions 5.2-4 and 6.0-4.
6547 <  # Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
6548 <  *-cmdline\ * | *-ignore\ * | *-def\ *)
6549 <    ac_fc_v_output=`echo $ac_fc_v_output | sed "\
6550 <        s/-cmdline  *'[^']*'/ /g; s/-cmdline  *\"[^\"]*\"/ /g
6551 <        s/-ignore  *'[^']*'/ /g; s/-ignore  *\"[^\"]*\"/ /g
6552 <        s/-def  *'[^']*'/ /g; s/-def  *\"[^\"]*\"/ /g"` ;;
6553 <
6554 <  # If we are using Cray Fortran then delete quotes.
6555 <  *cft90*)
6556 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"//g'` ;;
6557 < esac
6558 <
6559 <
6560 <  # look for -l* and *.a constructs in the output
6561 <  for ac_arg in $ac_fc_v_output; do
6562 <     case $ac_arg in
6563 <        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
6564 <          ac_cv_prog_fc_v=$ac_verb
6565 <          break 2 ;;
6566 <     esac
6567 <  done
6568 < done
6569 < if test -z "$ac_cv_prog_fc_v"; then
6570 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
6571 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
6572 < fi
6573 < else
6574 <  echo "$as_me: failed program was:" >&5
6575 < sed 's/^/| /' conftest.$ac_ext >&5
6576 <
6577 <        { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
6578 < echo "$as_me: WARNING: compilation failed" >&2;}
6579 < fi
6580 <
6581 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6582 <
6583 < fi
6584 < { echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
6585 < echo "${ECHO_T}$ac_cv_prog_fc_v" >&6; }
6586 < { echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
6587 < echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6; }
6588 < if test "${ac_cv_fc_libs+set}" = set; then
6589 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6590 < else
6591 <  if test "x$FCLIBS" != "x"; then
6592 <  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
6593 < else
6594 <
6595 < cat >conftest.$ac_ext <<_ACEOF
6596 <      program main
6597 <
6598 <      end
6599 < _ACEOF
6600 <
6601 < # Compile and link our simple test program by passing a flag (argument
6602 < # 1 to this macro) to the Fortran compiler in order to get
6603 < # "verbose" output that we can then parse for the Fortran linker
6604 < # flags.
6605 < ac_save_FFLAGS=$FCFLAGS
6606 < FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
6607 < eval "set x $ac_link"
6608 < shift
6609 < echo "$as_me:$LINENO: $*" >&5
6610 < ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
6611 < echo "$ac_fc_v_output" >&5
6612 < FCFLAGS=$ac_save_FFLAGS
6613 <
6614 < rm -rf conftest*
6615 <
6616 < # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
6617 < # /foo, /bar, and /baz are search directories for the Fortran linker.
6618 < # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
6619 < ac_fc_v_output="`echo $ac_fc_v_output |
6620 <        grep 'LPATH is:' |
6621 <        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
6622 <
6623 < # FIXME: we keep getting bitten by quoted arguments; a more general fix
6624 < #        that detects unbalanced quotes in FLIBS should be implemented
6625 < #        and (ugh) tested at some point.
6626 < case $ac_fc_v_output in
6627 <  # If we are using xlf then replace all the commas with spaces.
6628 <  *xlfentry*)
6629 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
6630 <
6631 <  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
6632 <  # $LIBS confuse us, and the libraries appear later in the output anyway).
6633 <  *mGLOB_options_string*)
6634 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"-mGLOB[^"]*"/ /g'` ;;
6635 <
6636 <  # Portland Group compiler has singly- or doubly-quoted -cmdline argument
6637 <  # Singly-quoted arguments were reported for versions 5.2-4 and 6.0-4.
6638 <  # Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
6639 <  *-cmdline\ * | *-ignore\ * | *-def\ *)
6640 <    ac_fc_v_output=`echo $ac_fc_v_output | sed "\
6641 <        s/-cmdline  *'[^']*'/ /g; s/-cmdline  *\"[^\"]*\"/ /g
6642 <        s/-ignore  *'[^']*'/ /g; s/-ignore  *\"[^\"]*\"/ /g
6643 <        s/-def  *'[^']*'/ /g; s/-def  *\"[^\"]*\"/ /g"` ;;
6644 <
6645 <  # If we are using Cray Fortran then delete quotes.
6646 <  *cft90*)
6647 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"//g'` ;;
6648 < esac
6649 <
6650 <
6651 <
6652 < ac_cv_fc_libs=
6653 <
6654 < # Save positional arguments (if any)
6655 < ac_save_positional="$@"
6656 <
6657 < set X $ac_fc_v_output
6658 < while test $# != 1; do
6659 <  shift
6660 <  ac_arg=$1
6661 <  case $ac_arg in
6662 <        [\\/]*.a | ?:[\\/]*.a)
6663 <            ac_exists=false
6664 <  for ac_i in $ac_cv_fc_libs; do
6665 <    if test x"$ac_arg" = x"$ac_i"; then
6666 <      ac_exists=true
6667 <      break
6668 <    fi
6669 <  done
6670 <
6671 <  if test x"$ac_exists" = xtrue; then
6672 <  :
6673 < else
6674 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6675 < fi
6676 <
6677 <          ;;
6678 <        -bI:*)
6679 <            ac_exists=false
6680 <  for ac_i in $ac_cv_fc_libs; do
6681 <    if test x"$ac_arg" = x"$ac_i"; then
6682 <      ac_exists=true
6683 <      break
6684 <    fi
6685 <  done
6686 <
6687 <  if test x"$ac_exists" = xtrue; then
6688 <  :
6689 < else
6690 <  if test "$ac_compiler_gnu" = yes; then
6691 <  for ac_link_opt in $ac_arg; do
6692 <    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
6693 <  done
6694 < else
6695 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6696 < fi
6697 < fi
6698 <
6699 <          ;;
6700 <          # Ignore these flags.
6701 <        -lang* | -lcrt*.o | -lc | -lgcc* | -lSystem | -libmil | -LANG:=* | -LIST:* | -LNO:*)
6702 <          ;;
6703 <        -lkernel32)
6704 <          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6705 <          ;;
6706 <        -[LRuYz])
6707 <          # These flags, when seen by themselves, take an argument.
6708 <          # We remove the space between option and argument and re-iterate
6709 <          # unless we find an empty arg or a new option (starting with -)
6710 <          case $2 in
6711 <             "" | -*);;
6712 <             *)
6713 <                ac_arg="$ac_arg$2"
6714 <                shift; shift
5767 <                set X $ac_arg "$@"
5768 <                ;;
5769 <          esac
5770 <          ;;
5771 <        -YP,*)
5772 <          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
5773 <              ac_exists=false
5774 <  for ac_i in $ac_cv_fc_libs; do
5775 <    if test x"$ac_j" = x"$ac_i"; then
5776 <      ac_exists=true
5777 <      break
5778 <    fi
5779 <  done
5780 <
5781 <  if test x"$ac_exists" = xtrue; then
5782 <  :
5783 < else
5784 <  ac_arg="$ac_arg $ac_j"
5785 <                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5786 < fi
5787 <
5788 <          done
5789 <          ;;
5790 <        -[lLR]*)
5791 <            ac_exists=false
5792 <  for ac_i in $ac_cv_fc_libs; do
5793 <    if test x"$ac_arg" = x"$ac_i"; then
5794 <      ac_exists=true
5795 <      break
5796 <    fi
5797 <  done
5798 <
5799 <  if test x"$ac_exists" = xtrue; then
5800 <  :
5801 < else
5802 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5803 < fi
5804 <
5805 <          ;;
5806 <        -zallextract*| -zdefaultextract)
5807 <          ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5808 <          ;;
5809 <          # Ignore everything else.
5810 <  esac
5811 < done
5812 < # restore positional arguments
5813 < set X $ac_save_positional; shift
5814 <
5815 < # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5816 < # then we insist that the "run path" must be an absolute path (i.e. it
5817 < # must begin with a "/").
5818 < case `(uname -sr) 2>/dev/null` in
5819 <   "SunOS 5"*)
5820 <      ac_ld_run_path=`echo $ac_fc_v_output |
5821 <                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5822 <      test "x$ac_ld_run_path" != x &&
5823 <        if test "$ac_compiler_gnu" = yes; then
5824 <  for ac_link_opt in $ac_ld_run_path; do
5825 <    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5826 <  done
5827 < else
5828 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5829 < fi
5830 <      ;;
5831 < esac
5832 < fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5833 <
5834 < fi
5835 < { echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5836 < echo "${ECHO_T}$ac_cv_fc_libs" >&6; }
5837 < FCLIBS="$ac_cv_fc_libs"
5838 <
5839 <
5840 < ac_ext=${ac_fc_srcext-f}
5841 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5842 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5843 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5844 <
5845 <
5846 <
5847 < { echo "$as_me:$LINENO: checking for module suffix" >&5
5848 < echo $ECHO_N "checking for module suffix... $ECHO_C" >&6; }
5849 < rm -rf conftest*
5850 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5851 < rm -f work*
5852 < cat >conftest.$ac_ext <<EOF
5853 <        module conftest
5854 <        integer n
5855 <        parameter (n=1)
5856 <        end module conftest
5857 < EOF
5858 < # SGI and absoft compilers generates module name in upper case!
5859 < testname="conftest"
5860 < modcase="lower"
5861 < if (eval $ac_compile) 2>/dev/null ; then
5862 <    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5863 <    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5864 <    if test -z "$MOD" ; then
5865 <        MOD=`ls CONFTEST* 2>/dev/null \
5866 <                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5867 <        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5868 <        if test -n "$MOD" ; then
5869 <            testname="CONFTEST"
5870 <            modcase="upper"
5871 <        fi
5872 <    fi
5873 <    if test -z "$MOD" ; then
5874 <        { echo "$as_me:$LINENO: result: unknown" >&5
5875 < echo "${ECHO_T}unknown" >&6; }
5876 <        # Use mod if we can't figure it out
5877 <        MOD="mod"
5878 <    else
5879 <        { echo "$as_me:$LINENO: result: $MOD" >&5
5880 < echo "${ECHO_T}$MOD" >&6; }
5881 <    fi
5882 <    if test -s work.pcl ; then
5883 <        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
5884 < echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
5885 <    fi
5886 < else
5887 <    { echo "$as_me:$LINENO: result: unknown" >&5
5888 < echo "${ECHO_T}unknown" >&6; }
5889 < fi
5890 <
5891 <
5892 <
5893 <
5894 <
5895 < # Check for module include path (some use -I, some (Solaris) use -M, some
5896 < # (absoft) use -p).
5897 < # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
5898 < # specified, work.pcl and work.pc are created.  However, if you specify
5899 < # a file, it must contain a the name of a file ending in .pc .  Ugh!
5900 < # Use the module made above
5901 < { echo "$as_me:$LINENO: checking for module directory path flag" >&5
5902 < echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6; }
5903 < rm -rf conftest*
5904 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5905 < rm -f work*
5906 < cat >conftest.$ac_ext <<EOF
5907 <        module conftest
5908 <        integer n
5909 <        parameter (n=1)
5910 <        end module conftest
5911 < EOF
5912 < # SGI and absoft compilers generates module name in upper case!
5913 < testname="conftest"
5914 < if (eval $ac_compile) 2>/dev/null ; then
5915 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5916 <   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5917 <   if test -n "$mod" ; then
5918 <      testname="CONFTEST"
5919 <   fi
5920 <   madedir=0
5921 <   if test ! -d conf ; then mkdir conf ; madedir=1; fi
5922 <   cp $testname.$MOD conf
5923 <   rm -f conftest* CONFTEST*
5924 <   cat >conftest1.$ac_ext <<EOF
5925 <        program main
5926 <        use conftest
5927 <        print *, n
5928 <        end
5929 < EOF
5930 <   F90_WORK_FILES_ARG=""
5931 <   F90MODINCSPEC=""
5932 <   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5933 <       MODDIRFLAG="-I"
5934 <       F90MODINCSPEC="-I<dir>"
5935 <       { echo "$as_me:$LINENO: result: -I" >&5
5936 < echo "${ECHO_T}-I" >&6; }
5937 <   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5938 <       MODDIRFLAG="-M"
5939 <       F90MODINCSPEC="-M<dir>"
5940 <       { echo "$as_me:$LINENO: result: -M" >&5
5941 < echo "${ECHO_T}-M" >&6; }
5942 <   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5943 <       MODDIRFLAG="-p"
5944 <       F90MODINCSPEC="-p<dir>"
5945 <       { echo "$as_me:$LINENO: result: -p" >&5
5946 < echo "${ECHO_T}-p" >&6; }
5947 <   elif test -s work.pc ; then
5948 <        cp work.pc conf/mpimod.pc
5949 <        echo "mpimod.pc" > conf/mpimod.pcl
5950 <        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5951 <        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5952 <            MODDIRFLAG='-cl,mpimod.pcl'
5953 <            { echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5954 < echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6; }
5955 <            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
5956 <            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
5957 <
5958 <        else
5959 <            # The version of the Intel compiler that I have refuses to let
5960 <            # you put the "work catalog" list anywhere but the current
5961 <            # directory. For example, you cannot in
5962 <         :
5963 <        fi
5964 <   fi
5965 <   if test -z "MODDIRFLAG" ; then
5966 <       { echo "$as_me:$LINENO: result: unknown" >&5
5967 < echo "${ECHO_T}unknown" >&6; }
5968 <   fi
5969 <
5970 <
5971 <   rm -rf conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
5972 <   if test $madedir = 1 ; then rmdir conf ; fi
5973 < fi
5974 <
5975 <
5976 < { echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
5977 < echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6; }
5978 < if test "${ac_cv_f90_module_names+set}" = set; then
5979 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5980 < else
5981 <  ac_ext=${ac_fc_srcext-f}
5982 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5983 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5984 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5985 <
5986 < # carry out the test in a new directory, so that we don't miss anything
5987 < mkdir conftest
5988 < cd conftest
5989 < cat >conftest.$ac_ext <<_ACEOF
5990 < MODULE Bar
5991 < END MODULE Bar
5992 < _ACEOF
5993 < rm -rf conftest.$ac_objext
5994 < if { (ac_try="$ac_compile"
5995 < case "(($ac_try" in
5996 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5997 <  *) ac_try_echo=$ac_try;;
5998 < esac
5999 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6000 <  (eval "$ac_compile") 2>conftest.er1
6001 <  ac_status=$?
6002 <  grep -v '^ *+' conftest.er1 >conftest.err
6003 <  rm -f conftest.er1
6004 <  cat conftest.err >&5
6005 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6006 <  (exit $ac_status); } && {
6007 <         test -z "$ac_fc_werror_flag" ||
6008 <         test ! -s conftest.err
6009 <       } && test -s conftest.$ac_objext; then
6010 <  ac_cv_f90_module_names=
6011 < ac_file_list=*
6012 < for ac_file in $ac_file_list; do
6013 <   case $ac_file in
6014 <      # don't care for original source and object files
6015 <      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
6016 <          :
6017 <          ;;
6018 <      # look for new files derived from the file name
6019 <      *conftest*)
6020 <          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
6021 <            ac_exists=false
6022 <  for ac_i in $ac_cv_f90_module_names; do
6023 <    if test x"$ac_pat" = x"$ac_i"; then
6024 <      ac_exists=true
6025 <      break
6026 <    fi
6027 <  done
6028 <
6029 <  if test x"$ac_exists" = xtrue; then
6030 <  :
6031 < else
6032 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
6033 < fi
6034 <
6035 <          ;;
6036 <      # look for new files derived from the module name,
6037 <      # with different case translation schemes
6038 <      *Bar*)
6039 <          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
6040 <            ac_exists=false
6041 <  for ac_i in $ac_cv_f90_module_names; do
6042 <    if test x"$ac_pat" = x"$ac_i"; then
6043 <      ac_exists=true
6044 <      break
6045 <    fi
6046 <  done
6047 <
6048 <  if test x"$ac_exists" = xtrue; then
6049 <  :
6050 < else
6051 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
6052 < fi
6053 <
6054 <          ;;
6055 <      *bar*)
6056 <          ac_pat=`echo $ac_file | sed s/bar/%module%/`
6057 <            ac_exists=false
6058 <  for ac_i in $ac_cv_f90_module_names; do
6059 <    if test x"$ac_pat" = x"$ac_i"; then
6060 <      ac_exists=true
6061 <      break
6062 <    fi
6063 <  done
6064 <
6065 <  if test x"$ac_exists" = xtrue; then
6066 <  :
6067 < else
6068 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
6069 < fi
6070 <
6071 <          ;;
6072 <      *BAR*)
6073 <          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
6074 <            ac_exists=false
6075 <  for ac_i in $ac_cv_f90_module_names; do
6076 <    if test x"$ac_pat" = x"$ac_i"; then
6077 <      ac_exists=true
6078 <      break
6079 <    fi
6080 <  done
6081 <
6082 <  if test x"$ac_exists" = xtrue; then
6083 <  :
6084 < else
6085 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
6086 < fi
6087 <
6088 <          ;;
6089 <       # Other files - we have no idea how they are generated
6090 <       *)
6091 <          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
6092 < echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
6093 <          ;;
6094 <   esac
6095 < done
6096 < if test "x$ac_cv_f90_module_names" = "x"; then
6097 <  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
6098 < echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
6099 < fi
6100 <
6101 < else
6102 <  echo "$as_me: failed program was:" >&5
6103 < sed 's/^/| /' conftest.$ac_ext >&5
6104 <
6105 <        ac_cv_f90_module_names=
6106 < { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
6107 < echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
6108 < fi
6109 <
6110 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
6111 < cd ..
6112 < # cleanup
6113 < rm -rf conftest
6114 < ac_ext=${ac_fc_srcext-f}
6115 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6116 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6117 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6118 <
6119 < fi
6120 < { echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
6121 < echo "${ECHO_T}$ac_cv_f90_module_names" >&6; } # AC_CACHE_CHECK
6122 <
6123 < # We now generate a shell script that will help us to figure out the correct
6124 < # module file names, using the value of ac_cv_f90_module_names
6125 <
6126 < echo "Generating shell script modnam"
6127 <
6128 < cat > scripts/modnam << EOF
6129 < #! /bin/sh
6130 < # This script is auto-generated by configure
6131 < #
6132 < usage="\\
6133 < Usage: \$0 [FILES]
6134 <
6135 < [FILES] are Fortran 90 source files.
6136 < The output is a list of module file names that the Fortran 90 compiler
6137 < generates when compiling [FILES]."
6138 <
6139 < list=
6140 < empty=
6141 <
6142 < if test \$# -eq 0; then
6143 <   echo "\$usage"; exit 0
6144 < fi
6145 <
6146 < while test \$# != 0; do
6147 <
6148 <  file=\$1
6149 <  shift
6150 <
6151 < # strip suffix
6152 <  base=\`echo \$file | sed 's/[.][^.]*$//'\`
6153 <
6154 <  test ! -f \$file && continue
6155 <
6156 < # Look for module definitions and transform them to upper / lower case
6157 <  mods=\`cat \$file | sed '/^ *[mM][oO][dD][uU][lL][eE]/!d;s/^ *[mM][oO][dD][uU][lL][eE] *\([A-Za-z_][A-Za-z0-9_]*\).*\$/\1/'\`
6158 <  upper=\`echo \$mods | tr a-z A-Z\`
6159 <  lower=\`echo \$mods | tr A-Z a-z\`
6160 <
6161 < # Here, the patterns for generating module file names were inserted by configure
6162 <  for trans in $ac_cv_f90_module_names; do
6163 <
6164 <    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
6165 <    var=empty
6166 <    case \$pat in
6167 <       %MODULE%)
6168 <          var=upper ;;
6169 <       %Module%)
6170 <          var=mods ;;
6171 <       %module%)
6172 <          var=lower ;;
6173 <       %FILE%)
6174 <          test -n "\$mods" && var=base ;;
6175 <    esac
6176 <    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
6177 <    list="\$list \$new"
6178 <  done
6179 < done
6180 <
6181 < echo \$list
6182 < # end of configure-generated script
6183 < EOF
6184 < chmod 755 scripts/modnam
6185 <
6186 < pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
6187 < F90_MODULE_NAMES=empty
6188 < case $pat in
6189 <       %MODULE%)
6190 <          F90_MODULE_NAMES=UPPER ;;
6191 <       %Module%)
6192 <          F90_MODULE_NAMES=Mixed ;;
6193 <       %module%)
6194 <          F90_MODULE_NAMES=lower ;;
6195 <       *)
6196 <          F90_MODULE_NAMES=unknown ;;
6197 < esac
6198 <
6199 < ac_ext=c
6200 < ac_cpp='$CPP $CPPFLAGS'
6201 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6202 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6203 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6204 <
6205 <
6206 < ac_ext=c
6207 < ac_cpp='$CPP $CPPFLAGS'
6208 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6209 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6210 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6211 <
6212 <
6213 <
6214 < { echo "$as_me:$LINENO: checking for asin in -lm" >&5
6215 < echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6; }
6216 < if test "${ac_cv_lib_m_asin+set}" = set; then
6217 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6218 < else
6219 <  ac_check_lib_save_LIBS=$LIBS
6220 < LIBS="-lm  $LIBS"
6221 < cat >conftest.$ac_ext <<_ACEOF
6222 < /* confdefs.h.  */
6223 < _ACEOF
6224 < cat confdefs.h >>conftest.$ac_ext
6225 < cat >>conftest.$ac_ext <<_ACEOF
6226 < /* end confdefs.h.  */
6227 <
6228 < /* Override any GCC internal prototype to avoid an error.
6229 <   Use char because int might match the return type of a GCC
6230 <   builtin and then its argument prototype would still apply.  */
6231 < #ifdef __cplusplus
6232 < extern "C"
6233 < #endif
6234 < char asin ();
6235 < #ifdef FC_DUMMY_MAIN
6236 < #ifndef FC_DUMMY_MAIN_EQ_F77
6237 < #  ifdef __cplusplus
6238 <     extern "C"
6239 < #  endif
6240 <   int FC_DUMMY_MAIN() { return 1; }
6241 < #endif
6242 < #endif
6243 < int
6244 < main ()
6245 < {
6246 < return asin ();
6247 <  ;
6248 <  return 0;
6249 < }
6250 < _ACEOF
6251 < rm -rf conftest.$ac_objext conftest$ac_exeext
6252 < if { (ac_try="$ac_link"
6253 < case "(($ac_try" in
6254 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6255 <  *) ac_try_echo=$ac_try;;
6256 < esac
6257 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6258 <  (eval "$ac_link") 2>conftest.er1
6259 <  ac_status=$?
6260 <  grep -v '^ *+' conftest.er1 >conftest.err
6261 <  rm -f conftest.er1
6262 <  cat conftest.err >&5
6263 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6264 <  (exit $ac_status); } && {
6265 <         test -z "$ac_c_werror_flag" ||
6266 <         test ! -s conftest.err
6267 <       } && test -s conftest$ac_exeext &&
6268 <       $as_test_x conftest$ac_exeext; then
6269 <  ac_cv_lib_m_asin=yes
6270 < else
6271 <  echo "$as_me: failed program was:" >&5
6272 < sed 's/^/| /' conftest.$ac_ext >&5
6273 <
6274 <        ac_cv_lib_m_asin=no
6275 < fi
6276 <
6277 < rm -rf core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6278 <      conftest$ac_exeext conftest.$ac_ext
6279 < LIBS=$ac_check_lib_save_LIBS
6280 < fi
6281 < { echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
6282 < echo "${ECHO_T}$ac_cv_lib_m_asin" >&6; }
6283 < if test $ac_cv_lib_m_asin = yes; then
6284 <  cat >>confdefs.h <<_ACEOF
6285 < #define HAVE_LIBM 1
6286 < _ACEOF
6287 <
6288 <  LIBS="-lm $LIBS"
6289 <
6290 < else
6291 <  exit
6292 < fi
6293 <
6294 <
6295 < { echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6296 < echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6; }
6297 < if test "${ac_cv_header_stdc+set}" = set; then
6298 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6299 < else
6300 <  cat >conftest.$ac_ext <<_ACEOF
6301 < /* confdefs.h.  */
6302 < _ACEOF
6303 < cat confdefs.h >>conftest.$ac_ext
6304 < cat >>conftest.$ac_ext <<_ACEOF
6305 < /* end confdefs.h.  */
6306 < #include <stdlib.h>
6307 < #include <stdarg.h>
6308 < #include <string.h>
6309 < #include <float.h>
6310 <
6311 < #ifdef FC_DUMMY_MAIN
6312 < #ifndef FC_DUMMY_MAIN_EQ_F77
6313 < #  ifdef __cplusplus
6314 <     extern "C"
6315 < #  endif
6316 <   int FC_DUMMY_MAIN() { return 1; }
6317 < #endif
6318 < #endif
6319 < int
6320 < main ()
6321 < {
6322 <
6323 <  ;
6324 <  return 0;
6325 < }
6326 < _ACEOF
6327 < rm -rf conftest.$ac_objext
6328 < if { (ac_try="$ac_compile"
6329 < case "(($ac_try" in
6330 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6331 <  *) ac_try_echo=$ac_try;;
6332 < esac
6333 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6334 <  (eval "$ac_compile") 2>conftest.er1
6335 <  ac_status=$?
6336 <  grep -v '^ *+' conftest.er1 >conftest.err
6337 <  rm -f conftest.er1
6338 <  cat conftest.err >&5
6339 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6340 <  (exit $ac_status); } && {
6341 <         test -z "$ac_c_werror_flag" ||
6342 <         test ! -s conftest.err
6343 <       } && test -s conftest.$ac_objext; then
6344 <  ac_cv_header_stdc=yes
6345 < else
6346 <  echo "$as_me: failed program was:" >&5
6347 < sed 's/^/| /' conftest.$ac_ext >&5
6348 <
6349 <        ac_cv_header_stdc=no
6350 < fi
6351 <
6352 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
6353 <
6354 < if test $ac_cv_header_stdc = yes; then
6355 <  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
6356 <  cat >conftest.$ac_ext <<_ACEOF
6357 < /* confdefs.h.  */
6358 < _ACEOF
6359 < cat confdefs.h >>conftest.$ac_ext
6360 < cat >>conftest.$ac_ext <<_ACEOF
6361 < /* end confdefs.h.  */
6362 < #include <string.h>
6363 <
6364 < _ACEOF
6365 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6366 <  $EGREP "memchr" >/dev/null 2>&1; then
6367 <  :
6368 < else
6369 <  ac_cv_header_stdc=no
6370 < fi
6371 < rm -rf conftest*
6372 <
6373 < fi
6374 <
6375 < if test $ac_cv_header_stdc = yes; then
6376 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
6377 <  cat >conftest.$ac_ext <<_ACEOF
6378 < /* confdefs.h.  */
6379 < _ACEOF
6380 < cat confdefs.h >>conftest.$ac_ext
6381 < cat >>conftest.$ac_ext <<_ACEOF
6382 < /* end confdefs.h.  */
6383 < #include <stdlib.h>
6384 <
6385 < _ACEOF
6386 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6387 <  $EGREP "free" >/dev/null 2>&1; then
6388 <  :
6389 < else
6390 <  ac_cv_header_stdc=no
6391 < fi
6392 < rm -rf conftest*
6393 <
6394 < fi
6395 <
6396 < if test $ac_cv_header_stdc = yes; then
6397 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
6398 <  if test "$cross_compiling" = yes; then
6399 <  :
6400 < else
6401 <  cat >conftest.$ac_ext <<_ACEOF
6402 < /* confdefs.h.  */
6403 < _ACEOF
6404 < cat confdefs.h >>conftest.$ac_ext
6405 < cat >>conftest.$ac_ext <<_ACEOF
6406 < /* end confdefs.h.  */
6407 < #include <ctype.h>
6408 < #include <stdlib.h>
6409 < #if ((' ' & 0x0FF) == 0x020)
6410 < # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
6411 < # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
6412 < #else
6413 < # define ISLOWER(c) \
6414 <                   (('a' <= (c) && (c) <= 'i') \
6415 <                     || ('j' <= (c) && (c) <= 'r') \
6416 <                     || ('s' <= (c) && (c) <= 'z'))
6417 < # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
6418 < #endif
6419 <
6420 < #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
6421 < int
6422 < main ()
6423 < {
6424 <  int i;
6425 <  for (i = 0; i < 256; i++)
6426 <    if (XOR (islower (i), ISLOWER (i))
6427 <        || toupper (i) != TOUPPER (i))
6428 <      return 2;
6429 <  return 0;
6430 < }
6431 < _ACEOF
6432 < rm -rf conftest$ac_exeext
6433 < if { (ac_try="$ac_link"
6434 < case "(($ac_try" in
6435 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6436 <  *) ac_try_echo=$ac_try;;
6437 < esac
6438 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6439 <  (eval "$ac_link") 2>&5
6440 <  ac_status=$?
6441 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6442 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
6443 <  { (case "(($ac_try" in
6444 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6445 <  *) ac_try_echo=$ac_try;;
6446 < esac
6447 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6448 <  (eval "$ac_try") 2>&5
6449 <  ac_status=$?
6450 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6451 <  (exit $ac_status); }; }; then
6452 <  :
6453 < else
6454 <  echo "$as_me: program exited with status $ac_status" >&5
6455 < echo "$as_me: failed program was:" >&5
6456 < sed 's/^/| /' conftest.$ac_ext >&5
6457 <
6458 < ( exit $ac_status )
6459 < ac_cv_header_stdc=no
6460 < fi
6461 < rm -rf core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
6462 < fi
6463 <
6464 <
6465 < fi
6466 < fi
6467 < { echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
6468 < echo "${ECHO_T}$ac_cv_header_stdc" >&6; }
6469 < if test $ac_cv_header_stdc = yes; then
6470 <
6471 < cat >>confdefs.h <<\_ACEOF
6472 < #define STDC_HEADERS 1
6473 < _ACEOF
6474 <
6475 < fi
6476 <
6477 < # On IRIX 5.3, sys/types and inttypes.h are conflicting.
6478 <
6479 <
6480 <
6481 <
6482 <
6483 <
6484 <
6485 <
6486 <
6487 < for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
6488 <                  inttypes.h stdint.h unistd.h
6489 < do
6490 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6491 < { echo "$as_me:$LINENO: checking for $ac_header" >&5
6492 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
6493 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
6494 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6495 < else
6496 <  cat >conftest.$ac_ext <<_ACEOF
6497 < /* confdefs.h.  */
6498 < _ACEOF
6499 < cat confdefs.h >>conftest.$ac_ext
6500 < cat >>conftest.$ac_ext <<_ACEOF
6501 < /* end confdefs.h.  */
6502 < $ac_includes_default
6503 <
6504 < #include <$ac_header>
6505 < _ACEOF
6506 < rm -rf conftest.$ac_objext
6507 < if { (ac_try="$ac_compile"
6508 < case "(($ac_try" in
6509 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6510 <  *) ac_try_echo=$ac_try;;
6511 < esac
6512 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6513 <  (eval "$ac_compile") 2>conftest.er1
6514 <  ac_status=$?
6515 <  grep -v '^ *+' conftest.er1 >conftest.err
6516 <  rm -f conftest.er1
6517 <  cat conftest.err >&5
6518 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6519 <  (exit $ac_status); } && {
6520 <         test -z "$ac_c_werror_flag" ||
6521 <         test ! -s conftest.err
6522 <       } && test -s conftest.$ac_objext; then
6523 <  eval "$as_ac_Header=yes"
6524 < else
6525 <  echo "$as_me: failed program was:" >&5
6526 < sed 's/^/| /' conftest.$ac_ext >&5
6527 <
6528 <        eval "$as_ac_Header=no"
6529 < fi
6530 <
6531 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
6532 < fi
6533 < ac_res=`eval echo '${'$as_ac_Header'}'`
6534 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
6535 < echo "${ECHO_T}$ac_res" >&6; }
6536 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6537 <  cat >>confdefs.h <<_ACEOF
6538 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6539 < _ACEOF
6540 <
6541 < fi
6542 <
6543 < done
6544 <
6545 <
6546 < #
6547 < # Handle user hints
6548 < #
6549 <
6550 < # Check whether --with-zlib was given.
6551 < if test "${with_zlib+set}" = set; then
6552 <  withval=$with_zlib; zlib_dir="$withval"
6553 < else
6554 <                zlib_dir="not_set"
6555 < fi
6556 <
6557 < if test "$zlib_dir" != "no"; then
6558 <
6559 < if test "$zlib_dir" != "not_set" ; then
6560 <  if test -d "$zlib_dir"
6561 <  then
6562 <    ZLIB_HOME="$zlib_dir"
6563 <  else
6564 <    { echo "$as_me:$LINENO: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
6565 < echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
6566 <  fi
6567 < fi
6568 <
6569 < ZLIB_HOME=/usr/local
6570 < if test ! -f "${ZLIB_HOME}/include/zlib.h"
6571 < then
6572 <        ZLIB_HOME=/usr
6573 < fi
6574 <
6575 < #
6576 < # Locate zlib, if wanted
6577 < #
6578 < if test -n "${ZLIB_HOME}"
6579 < then
6580 <        ZLIB_OLD_LDFLAGS=$LDFLAGS
6581 <        ZLIB_OLD_CPPFLAGS=$LDFLAGS
6582 <        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
6583 <        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
6584 <
6585 <        ac_ext=c
6586 < ac_cpp='$CPP $CPPFLAGS'
6587 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6588 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6589 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6590 <
6591 <        { echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6592 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6; }
6593 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
6594 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6595 < else
6596 <  ac_check_lib_save_LIBS=$LIBS
6597 < LIBS="-lz  $LIBS"
6598 < cat >conftest.$ac_ext <<_ACEOF
6599 < /* confdefs.h.  */
6600 < _ACEOF
6601 < cat confdefs.h >>conftest.$ac_ext
6602 < cat >>conftest.$ac_ext <<_ACEOF
6603 < /* end confdefs.h.  */
6604 <
6605 < /* Override any GCC internal prototype to avoid an error.
6606 <   Use char because int might match the return type of a GCC
6607 <   builtin and then its argument prototype would still apply.  */
6608 < #ifdef __cplusplus
6609 < extern "C"
6610 < #endif
6611 < char inflateEnd ();
6612 < #ifdef FC_DUMMY_MAIN
6613 < #ifndef FC_DUMMY_MAIN_EQ_F77
6614 < #  ifdef __cplusplus
6615 <     extern "C"
6616 < #  endif
6617 <   int FC_DUMMY_MAIN() { return 1; }
6618 < #endif
6619 < #endif
6620 < int
6621 < main ()
6622 < {
6623 < return inflateEnd ();
6624 <  ;
6625 <  return 0;
6626 < }
6627 < _ACEOF
6628 < rm -rf conftest.$ac_objext conftest$ac_exeext
6629 < if { (ac_try="$ac_link"
6630 < case "(($ac_try" in
6631 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6632 <  *) ac_try_echo=$ac_try;;
6633 < esac
6634 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6635 <  (eval "$ac_link") 2>conftest.er1
6636 <  ac_status=$?
6637 <  grep -v '^ *+' conftest.er1 >conftest.err
6638 <  rm -f conftest.er1
6639 <  cat conftest.err >&5
6640 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6641 <  (exit $ac_status); } && {
6642 <         test -z "$ac_c_werror_flag" ||
6643 <         test ! -s conftest.err
6644 <       } && test -s conftest$ac_exeext &&
6645 <       $as_test_x conftest$ac_exeext; then
6646 <  ac_cv_lib_z_inflateEnd=yes
6647 < else
6648 <  echo "$as_me: failed program was:" >&5
6649 < sed 's/^/| /' conftest.$ac_ext >&5
6650 <
6651 <        ac_cv_lib_z_inflateEnd=no
6652 < fi
6653 <
6654 < rm -rf core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6655 <      conftest$ac_exeext conftest.$ac_ext
6656 < LIBS=$ac_check_lib_save_LIBS
6657 < fi
6658 < { echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
6659 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6; }
6660 < if test $ac_cv_lib_z_inflateEnd = yes; then
6661 <  zlib_cv_libz=yes
6662 < else
6663 <  zlib_cv_libz=no
6664 < fi
6665 <
6666 <        if test "${ac_cv_header_zlib_h+set}" = set; then
6667 <  { echo "$as_me:$LINENO: checking for zlib.h" >&5
6668 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6; }
6669 < if test "${ac_cv_header_zlib_h+set}" = set; then
6670 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6671 < fi
6672 < { echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6673 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6; }
6674 < else
6675 <  # Is the header compilable?
6676 < { echo "$as_me:$LINENO: checking zlib.h usability" >&5
6677 < echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6; }
6678 < cat >conftest.$ac_ext <<_ACEOF
6679 < /* confdefs.h.  */
6680 < _ACEOF
6681 < cat confdefs.h >>conftest.$ac_ext
6682 < cat >>conftest.$ac_ext <<_ACEOF
6683 < /* end confdefs.h.  */
6684 < $ac_includes_default
6685 < #include <zlib.h>
6686 < _ACEOF
6687 < rm -rf conftest.$ac_objext
6688 < if { (ac_try="$ac_compile"
6689 < case "(($ac_try" in
6690 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6691 <  *) ac_try_echo=$ac_try;;
6692 < esac
6693 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6694 <  (eval "$ac_compile") 2>conftest.er1
6695 <  ac_status=$?
6696 <  grep -v '^ *+' conftest.er1 >conftest.err
6697 <  rm -f conftest.er1
6698 <  cat conftest.err >&5
6699 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6700 <  (exit $ac_status); } && {
6701 <         test -z "$ac_c_werror_flag" ||
6702 <         test ! -s conftest.err
6703 <       } && test -s conftest.$ac_objext; then
6704 <  ac_header_compiler=yes
6705 < else
6706 <  echo "$as_me: failed program was:" >&5
6707 < sed 's/^/| /' conftest.$ac_ext >&5
6708 <
6709 <        ac_header_compiler=no
6710 < fi
6711 <
6712 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
6713 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6714 < echo "${ECHO_T}$ac_header_compiler" >&6; }
6715 <
6716 < # Is the header present?
6717 < { echo "$as_me:$LINENO: checking zlib.h presence" >&5
6718 < echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6; }
6719 < cat >conftest.$ac_ext <<_ACEOF
6720 < /* confdefs.h.  */
6721 < _ACEOF
6722 < cat confdefs.h >>conftest.$ac_ext
6723 < cat >>conftest.$ac_ext <<_ACEOF
6724 < /* end confdefs.h.  */
6725 < #include <zlib.h>
6726 < _ACEOF
6727 < if { (ac_try="$ac_cpp conftest.$ac_ext"
6728 < case "(($ac_try" in
6729 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6730 <  *) ac_try_echo=$ac_try;;
6731 < esac
6732 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6733 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
6734 <  ac_status=$?
6735 <  grep -v '^ *+' conftest.er1 >conftest.err
6736 <  rm -f conftest.er1
6737 <  cat conftest.err >&5
6738 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6739 <  (exit $ac_status); } >/dev/null && {
6740 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
6741 <         test ! -s conftest.err
6742 <       }; then
6743 <  ac_header_preproc=yes
6744 < else
6745 <  echo "$as_me: failed program was:" >&5
6746 < sed 's/^/| /' conftest.$ac_ext >&5
6747 <
6748 <  ac_header_preproc=no
6749 < fi
6750 <
6751 < rm -rf conftest.err conftest.$ac_ext
6752 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6753 < echo "${ECHO_T}$ac_header_preproc" >&6; }
6754 <
6755 < # So?  What about this header?
6756 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6757 <  yes:no: )
6758 <    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
6759 < echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6760 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
6761 < echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
6762 <    ac_header_preproc=yes
6763 <    ;;
6764 <  no:yes:* )
6765 <    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
6766 < echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
6767 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
6768 < echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
6769 <    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
6770 < echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
6771 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
6772 < echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6773 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
6774 < echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
6775 <    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
6776 < echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
6777 <    ( cat <<\_ASBOX
6778 < ## ------------------------------ ##
6779 < ## Report this to gezelter@nd.edu ##
6780 < ## ------------------------------ ##
6781 < _ASBOX
6782 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
6783 <    ;;
6784 < esac
6785 < { echo "$as_me:$LINENO: checking for zlib.h" >&5
6786 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6; }
6787 < if test "${ac_cv_header_zlib_h+set}" = set; then
6788 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6789 < else
6790 <  ac_cv_header_zlib_h=$ac_header_preproc
6791 < fi
6792 < { echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6793 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6; }
6794 <
6795 < fi
6796 < if test $ac_cv_header_zlib_h = yes; then
6797 <  zlib_cv_zlib_h=yes
6798 < else
6799 <  zlib_cv_zlib_h=no
6800 < fi
6801 <
6802 <
6803 <        ac_ext=c
6804 < ac_cpp='$CPP $CPPFLAGS'
6805 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6806 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6807 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6808 <
6809 <
6810 <        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
6811 <
6812 < cat >>confdefs.h <<\_ACEOF
6813 < #define HAVE_ZLIB_H 1
6814 < _ACEOF
6815 <
6816 <
6817 < cat >>confdefs.h <<\_ACEOF
6818 < #define HAVE_LIBZ 1
6819 < _ACEOF
6820 <
6821 <                ZLIB_INC_DIR="${ZLIB_HOME}/include"
6822 <                ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
6823 <                ZLIB="-lz"
6824 <        else
6825 <                { echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6826 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6; }
6827 <                ZLIB_INC_DIR=
6828 <                ZLIB_LIB_DIR=
6829 <                ZLIB=
6830 <                LDFLAGS="$ZLIB_OLD_LDFLAGS"
6831 <                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6832 <                { echo "$as_me:$LINENO: result: failed" >&5
6833 < echo "${ECHO_T}failed" >&6; }
6834 <                echo ""
6835 <                echo "*********************************************************"
6836 <                echo "* WARNING: Could not find a working zlib installation   *"
6837 <                echo "* If you need OOPSE to be able to deal with compressed  *"
6838 <                echo "* trajectory dump files be sure to specify a valid zlib *"
6839 <                echo "* installation with --with-zlib=DIR                     *"
6840 <                echo "*                                                       *"
6841 <                echo "* OOPSE will still work without zlib installed.         *"
6842 <                echo "*********************************************************"
6843 <                echo ""
6844 <        fi
6845 <
6846 <
6847 <
6848 < fi
6849 < fi
6850 <
6851 < #
6852 < # Handle user hints
6853 < #
6854 <
6855 < # Check whether --with-fftw was given.
6856 < if test "${with_fftw+set}" = set; then
6857 <  withval=$with_fftw; fftw_dir="$withval"
6858 < else
6859 <             fftw_dir="not_set"
6860 < fi
6861 <
6862 < if test "$fftw_dir" != "no"; then
6863 <  if test "$fftw_dir" != "not_set" ; then
6864 <    if test -d "$fftw_dir"; then
6865 <      FFTW_HOME="$fftw_dir"
6866 <    else
6867 <      { echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
6868 < echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
6869 <      FFTW_HOME=/usr/local
6870 <      if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"; then
6871 <        FFTW_HOME=/usr
6872 <      fi
6873 <    fi
6874 <    #
6875 <    # Locate fftw, if wanted
6876 <    #
6877 <    if test -n "${FFTW_HOME}"; then
6878 <      FFTW_OLD_LDFLAGS=$LDFLAGS
6879 <      FFTW_OLD_CPPFLAGS=$LDFLAGS
6880 <      LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
6881 <      CPPFLAGS="$CPPFLAGS -I${FFTW_HOME}/include"
6882 <
6883 <      ac_ext=c
6884 < ac_cpp='$CPP $CPPFLAGS'
6885 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6886 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6887 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6888 <
6889 <      { echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
6890 < echo $ECHO_N "checking for fftw_execute in -lfftw3... $ECHO_C" >&6; }
6891 < if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
6892 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6893 < else
6894 <  ac_check_lib_save_LIBS=$LIBS
6895 < LIBS="-lfftw3  $LIBS"
6896 < cat >conftest.$ac_ext <<_ACEOF
6897 < /* confdefs.h.  */
6898 < _ACEOF
6899 < cat confdefs.h >>conftest.$ac_ext
6900 < cat >>conftest.$ac_ext <<_ACEOF
6901 < /* end confdefs.h.  */
6902 <
6903 < /* Override any GCC internal prototype to avoid an error.
6904 <   Use char because int might match the return type of a GCC
6905 <   builtin and then its argument prototype would still apply.  */
6906 < #ifdef __cplusplus
6907 < extern "C"
6908 < #endif
6909 < char fftw_execute ();
6910 < #ifdef FC_DUMMY_MAIN
6911 < #ifndef FC_DUMMY_MAIN_EQ_F77
6912 < #  ifdef __cplusplus
6913 <     extern "C"
6914 < #  endif
6915 <   int FC_DUMMY_MAIN() { return 1; }
6916 < #endif
6917 < #endif
6918 < int
6919 < main ()
6920 < {
6921 < return fftw_execute ();
6922 <  ;
6923 <  return 0;
6924 < }
6925 < _ACEOF
6926 < rm -rf conftest.$ac_objext conftest$ac_exeext
6927 < if { (ac_try="$ac_link"
6928 < case "(($ac_try" in
6929 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6930 <  *) ac_try_echo=$ac_try;;
6931 < esac
6932 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6933 <  (eval "$ac_link") 2>conftest.er1
6934 <  ac_status=$?
6935 <  grep -v '^ *+' conftest.er1 >conftest.err
6936 <  rm -f conftest.er1
6937 <  cat conftest.err >&5
6938 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6939 <  (exit $ac_status); } && {
6940 <         test -z "$ac_c_werror_flag" ||
6941 <         test ! -s conftest.err
6942 <       } && test -s conftest$ac_exeext &&
6943 <       $as_test_x conftest$ac_exeext; then
6944 <  ac_cv_lib_fftw3_fftw_execute=yes
6945 < else
6946 <  echo "$as_me: failed program was:" >&5
6947 < sed 's/^/| /' conftest.$ac_ext >&5
6948 <
6949 <        ac_cv_lib_fftw3_fftw_execute=no
6950 < fi
6951 <
6952 < rm -rf core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6953 <      conftest$ac_exeext conftest.$ac_ext
6954 < LIBS=$ac_check_lib_save_LIBS
6955 < fi
6956 < { echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
6957 < echo "${ECHO_T}$ac_cv_lib_fftw3_fftw_execute" >&6; }
6958 < if test $ac_cv_lib_fftw3_fftw_execute = yes; then
6959 <  fftw_cv_libfftw3=yes
6960 < else
6961 <  fftw_cv_libfftw3=no
6962 < fi
6963 <
6964 <      if test "${ac_cv_header_fftw3_h+set}" = set; then
6965 <  { echo "$as_me:$LINENO: checking for fftw3.h" >&5
6966 < echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6; }
6967 < if test "${ac_cv_header_fftw3_h+set}" = set; then
6968 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6969 < fi
6970 < { echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6971 < echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6; }
6972 < else
6973 <  # Is the header compilable?
6974 < { echo "$as_me:$LINENO: checking fftw3.h usability" >&5
6975 < echo $ECHO_N "checking fftw3.h usability... $ECHO_C" >&6; }
6976 < cat >conftest.$ac_ext <<_ACEOF
6977 < /* confdefs.h.  */
6978 < _ACEOF
6979 < cat confdefs.h >>conftest.$ac_ext
6980 < cat >>conftest.$ac_ext <<_ACEOF
6981 < /* end confdefs.h.  */
6982 < $ac_includes_default
6983 < #include <fftw3.h>
6984 < _ACEOF
6985 < rm -rf conftest.$ac_objext
6986 < if { (ac_try="$ac_compile"
6987 < case "(($ac_try" in
6988 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6989 <  *) ac_try_echo=$ac_try;;
6990 < esac
6991 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6992 <  (eval "$ac_compile") 2>conftest.er1
6993 <  ac_status=$?
6994 <  grep -v '^ *+' conftest.er1 >conftest.err
6995 <  rm -f conftest.er1
6996 <  cat conftest.err >&5
6997 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6998 <  (exit $ac_status); } && {
6999 <         test -z "$ac_c_werror_flag" ||
7000 <         test ! -s conftest.err
7001 <       } && test -s conftest.$ac_objext; then
7002 <  ac_header_compiler=yes
7003 < else
7004 <  echo "$as_me: failed program was:" >&5
7005 < sed 's/^/| /' conftest.$ac_ext >&5
7006 <
7007 <        ac_header_compiler=no
7008 < fi
7009 <
7010 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
7011 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7012 < echo "${ECHO_T}$ac_header_compiler" >&6; }
7013 <
7014 < # Is the header present?
7015 < { echo "$as_me:$LINENO: checking fftw3.h presence" >&5
7016 < echo $ECHO_N "checking fftw3.h presence... $ECHO_C" >&6; }
7017 < cat >conftest.$ac_ext <<_ACEOF
7018 < /* confdefs.h.  */
7019 < _ACEOF
7020 < cat confdefs.h >>conftest.$ac_ext
7021 < cat >>conftest.$ac_ext <<_ACEOF
7022 < /* end confdefs.h.  */
7023 < #include <fftw3.h>
7024 < _ACEOF
7025 < if { (ac_try="$ac_cpp conftest.$ac_ext"
7026 < case "(($ac_try" in
7027 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7028 <  *) ac_try_echo=$ac_try;;
7029 < esac
7030 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7031 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
7032 <  ac_status=$?
7033 <  grep -v '^ *+' conftest.er1 >conftest.err
7034 <  rm -f conftest.er1
7035 <  cat conftest.err >&5
7036 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7037 <  (exit $ac_status); } >/dev/null && {
7038 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
7039 <         test ! -s conftest.err
7040 <       }; then
7041 <  ac_header_preproc=yes
7042 < else
7043 <  echo "$as_me: failed program was:" >&5
7044 < sed 's/^/| /' conftest.$ac_ext >&5
7045 <
7046 <  ac_header_preproc=no
7047 < fi
7048 <
7049 < rm -rf conftest.err conftest.$ac_ext
7050 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7051 < echo "${ECHO_T}$ac_header_preproc" >&6; }
7052 <
7053 < # So?  What about this header?
7054 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7055 <  yes:no: )
7056 <    { echo "$as_me:$LINENO: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&5
7057 < echo "$as_me: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
7058 <    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the compiler's result" >&5
7059 < echo "$as_me: WARNING: fftw3.h: proceeding with the compiler's result" >&2;}
7060 <    ac_header_preproc=yes
7061 <    ;;
7062 <  no:yes:* )
7063 <    { echo "$as_me:$LINENO: WARNING: fftw3.h: present but cannot be compiled" >&5
7064 < echo "$as_me: WARNING: fftw3.h: present but cannot be compiled" >&2;}
7065 <    { echo "$as_me:$LINENO: WARNING: fftw3.h:     check for missing prerequisite headers?" >&5
7066 < echo "$as_me: WARNING: fftw3.h:     check for missing prerequisite headers?" >&2;}
7067 <    { echo "$as_me:$LINENO: WARNING: fftw3.h: see the Autoconf documentation" >&5
7068 < echo "$as_me: WARNING: fftw3.h: see the Autoconf documentation" >&2;}
7069 <    { echo "$as_me:$LINENO: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&5
7070 < echo "$as_me: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&2;}
7071 <    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the preprocessor's result" >&5
7072 < echo "$as_me: WARNING: fftw3.h: proceeding with the preprocessor's result" >&2;}
7073 <    { echo "$as_me:$LINENO: WARNING: fftw3.h: in the future, the compiler will take precedence" >&5
7074 < echo "$as_me: WARNING: fftw3.h: in the future, the compiler will take precedence" >&2;}
7075 <    ( cat <<\_ASBOX
7076 < ## ------------------------------ ##
7077 < ## Report this to gezelter@nd.edu ##
7078 < ## ------------------------------ ##
7079 < _ASBOX
7080 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
7081 <    ;;
7082 < esac
7083 < { echo "$as_me:$LINENO: checking for fftw3.h" >&5
7084 < echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6; }
7085 < if test "${ac_cv_header_fftw3_h+set}" = set; then
7086 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7087 < else
7088 <  ac_cv_header_fftw3_h=$ac_header_preproc
7089 < fi
7090 < { echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
7091 < echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6; }
7092 <
7093 < fi
7094 < if test $ac_cv_header_fftw3_h = yes; then
7095 <  fftw_cv_fftw3_h=yes
7096 < else
7097 <  fftw_cv_fftw3_h=no
7098 < fi
7099 <
7100 <
7101 <      if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"; then
7102 <        { echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
7103 < echo $ECHO_N "checking for fftwnd_one in -lfftw... $ECHO_C" >&6; }
7104 < if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
7105 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7106 < else
7107 <  ac_check_lib_save_LIBS=$LIBS
7108 < LIBS="-lfftw  $LIBS"
7109 < cat >conftest.$ac_ext <<_ACEOF
7110 < /* confdefs.h.  */
7111 < _ACEOF
7112 < cat confdefs.h >>conftest.$ac_ext
7113 < cat >>conftest.$ac_ext <<_ACEOF
7114 < /* end confdefs.h.  */
7115 <
7116 < /* Override any GCC internal prototype to avoid an error.
7117 <   Use char because int might match the return type of a GCC
7118 <   builtin and then its argument prototype would still apply.  */
7119 < #ifdef __cplusplus
7120 < extern "C"
7121 < #endif
7122 < char fftwnd_one ();
7123 < #ifdef FC_DUMMY_MAIN
7124 < #ifndef FC_DUMMY_MAIN_EQ_F77
7125 < #  ifdef __cplusplus
7126 <     extern "C"
7127 < #  endif
7128 <   int FC_DUMMY_MAIN() { return 1; }
7129 < #endif
7130 < #endif
7131 < int
7132 < main ()
7133 < {
7134 < return fftwnd_one ();
7135 <  ;
7136 <  return 0;
7137 < }
7138 < _ACEOF
7139 < rm -rf conftest.$ac_objext conftest$ac_exeext
7140 < if { (ac_try="$ac_link"
7141 < case "(($ac_try" in
7142 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7143 <  *) ac_try_echo=$ac_try;;
7144 < esac
7145 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7146 <  (eval "$ac_link") 2>conftest.er1
7147 <  ac_status=$?
7148 <  grep -v '^ *+' conftest.er1 >conftest.err
7149 <  rm -f conftest.er1
7150 <  cat conftest.err >&5
7151 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7152 <  (exit $ac_status); } && {
7153 <         test -z "$ac_c_werror_flag" ||
7154 <         test ! -s conftest.err
7155 <       } && test -s conftest$ac_exeext &&
7156 <       $as_test_x conftest$ac_exeext; then
7157 <  ac_cv_lib_fftw_fftwnd_one=yes
7158 < else
7159 <  echo "$as_me: failed program was:" >&5
7160 < sed 's/^/| /' conftest.$ac_ext >&5
7161 <
7162 <        ac_cv_lib_fftw_fftwnd_one=no
7163 < fi
7164 <
7165 < rm -rf core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
7166 <      conftest$ac_exeext conftest.$ac_ext
7167 < LIBS=$ac_check_lib_save_LIBS
7168 < fi
7169 < { echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
7170 < echo "${ECHO_T}$ac_cv_lib_fftw_fftwnd_one" >&6; }
7171 < if test $ac_cv_lib_fftw_fftwnd_one = yes; then
7172 <  fftw_cv_libfftw=yes
7173 < else
7174 <  fftw_cv_libfftw=no
7175 < fi
7176 <
7177 <        if test "${ac_cv_header_fftw_h+set}" = set; then
7178 <  { echo "$as_me:$LINENO: checking for fftw.h" >&5
7179 < echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6; }
7180 < if test "${ac_cv_header_fftw_h+set}" = set; then
7181 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7182 < fi
7183 < { echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
7184 < echo "${ECHO_T}$ac_cv_header_fftw_h" >&6; }
7185 < else
7186 <  # Is the header compilable?
7187 < { echo "$as_me:$LINENO: checking fftw.h usability" >&5
7188 < echo $ECHO_N "checking fftw.h usability... $ECHO_C" >&6; }
7189 < cat >conftest.$ac_ext <<_ACEOF
7190 < /* confdefs.h.  */
7191 < _ACEOF
7192 < cat confdefs.h >>conftest.$ac_ext
7193 < cat >>conftest.$ac_ext <<_ACEOF
7194 < /* end confdefs.h.  */
7195 < $ac_includes_default
7196 < #include <fftw.h>
7197 < _ACEOF
7198 < rm -rf conftest.$ac_objext
7199 < if { (ac_try="$ac_compile"
7200 < case "(($ac_try" in
7201 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7202 <  *) ac_try_echo=$ac_try;;
7203 < esac
7204 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7205 <  (eval "$ac_compile") 2>conftest.er1
7206 <  ac_status=$?
7207 <  grep -v '^ *+' conftest.er1 >conftest.err
7208 <  rm -f conftest.er1
7209 <  cat conftest.err >&5
7210 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7211 <  (exit $ac_status); } && {
7212 <         test -z "$ac_c_werror_flag" ||
7213 <         test ! -s conftest.err
7214 <       } && test -s conftest.$ac_objext; then
7215 <  ac_header_compiler=yes
7216 < else
7217 <  echo "$as_me: failed program was:" >&5
7218 < sed 's/^/| /' conftest.$ac_ext >&5
7219 <
7220 <        ac_header_compiler=no
7221 < fi
7222 <
7223 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
7224 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7225 < echo "${ECHO_T}$ac_header_compiler" >&6; }
7226 <
7227 < # Is the header present?
7228 < { echo "$as_me:$LINENO: checking fftw.h presence" >&5
7229 < echo $ECHO_N "checking fftw.h presence... $ECHO_C" >&6; }
7230 < cat >conftest.$ac_ext <<_ACEOF
7231 < /* confdefs.h.  */
7232 < _ACEOF
7233 < cat confdefs.h >>conftest.$ac_ext
7234 < cat >>conftest.$ac_ext <<_ACEOF
7235 < /* end confdefs.h.  */
7236 < #include <fftw.h>
7237 < _ACEOF
7238 < if { (ac_try="$ac_cpp conftest.$ac_ext"
7239 < case "(($ac_try" in
7240 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7241 <  *) ac_try_echo=$ac_try;;
7242 < esac
7243 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7244 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
7245 <  ac_status=$?
7246 <  grep -v '^ *+' conftest.er1 >conftest.err
7247 <  rm -f conftest.er1
7248 <  cat conftest.err >&5
7249 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7250 <  (exit $ac_status); } >/dev/null && {
7251 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
7252 <         test ! -s conftest.err
7253 <       }; then
7254 <  ac_header_preproc=yes
7255 < else
7256 <  echo "$as_me: failed program was:" >&5
7257 < sed 's/^/| /' conftest.$ac_ext >&5
7258 <
7259 <  ac_header_preproc=no
7260 < fi
7261 <
7262 < rm -rf conftest.err conftest.$ac_ext
7263 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7264 < echo "${ECHO_T}$ac_header_preproc" >&6; }
7265 <
7266 < # So?  What about this header?
7267 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7268 <  yes:no: )
7269 <    { echo "$as_me:$LINENO: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
7270 < echo "$as_me: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
7271 <    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the compiler's result" >&5
7272 < echo "$as_me: WARNING: fftw.h: proceeding with the compiler's result" >&2;}
7273 <    ac_header_preproc=yes
7274 <    ;;
7275 <  no:yes:* )
7276 <    { echo "$as_me:$LINENO: WARNING: fftw.h: present but cannot be compiled" >&5
7277 < echo "$as_me: WARNING: fftw.h: present but cannot be compiled" >&2;}
7278 <    { echo "$as_me:$LINENO: WARNING: fftw.h:     check for missing prerequisite headers?" >&5
7279 < echo "$as_me: WARNING: fftw.h:     check for missing prerequisite headers?" >&2;}
7280 <    { echo "$as_me:$LINENO: WARNING: fftw.h: see the Autoconf documentation" >&5
7281 < echo "$as_me: WARNING: fftw.h: see the Autoconf documentation" >&2;}
7282 <    { echo "$as_me:$LINENO: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&5
7283 < echo "$as_me: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
7284 <    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the preprocessor's result" >&5
7285 < echo "$as_me: WARNING: fftw.h: proceeding with the preprocessor's result" >&2;}
7286 <    { echo "$as_me:$LINENO: WARNING: fftw.h: in the future, the compiler will take precedence" >&5
7287 < echo "$as_me: WARNING: fftw.h: in the future, the compiler will take precedence" >&2;}
7288 <    ( cat <<\_ASBOX
7289 < ## ------------------------------ ##
7290 < ## Report this to gezelter@nd.edu ##
7291 < ## ------------------------------ ##
7292 < _ASBOX
7293 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
7294 <    ;;
7295 < esac
7296 < { echo "$as_me:$LINENO: checking for fftw.h" >&5
7297 < echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6; }
7298 < if test "${ac_cv_header_fftw_h+set}" = set; then
7299 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7300 < else
7301 <  ac_cv_header_fftw_h=$ac_header_preproc
7302 < fi
7303 < { echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
7304 < echo "${ECHO_T}$ac_cv_header_fftw_h" >&6; }
7305 <
7306 < fi
7307 < if test $ac_cv_header_fftw_h = yes; then
7308 <  fftw_cv_fftw_h=yes
7309 < else
7310 <  fftw_cv_fftw_h=no
7311 < fi
7312 <
7313 <
7314 <        if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"; then
7315 <          { echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
7316 < echo $ECHO_N "checking for fftwnd_one in -ldfftw... $ECHO_C" >&6; }
7317 < if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
7318 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7319 < else
7320 <  ac_check_lib_save_LIBS=$LIBS
7321 < LIBS="-ldfftw  $LIBS"
7322 < cat >conftest.$ac_ext <<_ACEOF
7323 < /* confdefs.h.  */
7324 < _ACEOF
7325 < cat confdefs.h >>conftest.$ac_ext
7326 < cat >>conftest.$ac_ext <<_ACEOF
7327 < /* end confdefs.h.  */
7328 <
7329 < /* Override any GCC internal prototype to avoid an error.
7330 <   Use char because int might match the return type of a GCC
7331 <   builtin and then its argument prototype would still apply.  */
7332 < #ifdef __cplusplus
7333 < extern "C"
7334 < #endif
7335 < char fftwnd_one ();
7336 < #ifdef FC_DUMMY_MAIN
7337 < #ifndef FC_DUMMY_MAIN_EQ_F77
7338 < #  ifdef __cplusplus
7339 <     extern "C"
7340 < #  endif
7341 <   int FC_DUMMY_MAIN() { return 1; }
7342 < #endif
7343 < #endif
7344 < int
7345 < main ()
7346 < {
7347 < return fftwnd_one ();
7348 <  ;
7349 <  return 0;
7350 < }
7351 < _ACEOF
7352 < rm -rf conftest.$ac_objext conftest$ac_exeext
7353 < if { (ac_try="$ac_link"
7354 < case "(($ac_try" in
7355 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7356 <  *) ac_try_echo=$ac_try;;
7357 < esac
7358 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7359 <  (eval "$ac_link") 2>conftest.er1
7360 <  ac_status=$?
7361 <  grep -v '^ *+' conftest.er1 >conftest.err
7362 <  rm -f conftest.er1
7363 <  cat conftest.err >&5
7364 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7365 <  (exit $ac_status); } && {
7366 <         test -z "$ac_c_werror_flag" ||
7367 <         test ! -s conftest.err
7368 <       } && test -s conftest$ac_exeext &&
7369 <       $as_test_x conftest$ac_exeext; then
7370 <  ac_cv_lib_dfftw_fftwnd_one=yes
7371 < else
7372 <  echo "$as_me: failed program was:" >&5
7373 < sed 's/^/| /' conftest.$ac_ext >&5
7374 <
7375 <        ac_cv_lib_dfftw_fftwnd_one=no
7376 < fi
7377 <
7378 < rm -rf core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
7379 <      conftest$ac_exeext conftest.$ac_ext
7380 < LIBS=$ac_check_lib_save_LIBS
7381 < fi
7382 < { echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
7383 < echo "${ECHO_T}$ac_cv_lib_dfftw_fftwnd_one" >&6; }
7384 < if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
7385 <  fftw_cv_libdfftw=yes
7386 < else
7387 <  fftw_cv_libdfftw=no
7388 < fi
7389 <
7390 <          if test "${ac_cv_header_dfftw_h+set}" = set; then
7391 <  { echo "$as_me:$LINENO: checking for dfftw.h" >&5
7392 < echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6; }
7393 < if test "${ac_cv_header_dfftw_h+set}" = set; then
7394 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7395 < fi
7396 < { echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
7397 < echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6; }
7398 < else
7399 <  # Is the header compilable?
7400 < { echo "$as_me:$LINENO: checking dfftw.h usability" >&5
7401 < echo $ECHO_N "checking dfftw.h usability... $ECHO_C" >&6; }
7402 < cat >conftest.$ac_ext <<_ACEOF
7403 < /* confdefs.h.  */
7404 < _ACEOF
7405 < cat confdefs.h >>conftest.$ac_ext
7406 < cat >>conftest.$ac_ext <<_ACEOF
7407 < /* end confdefs.h.  */
7408 < $ac_includes_default
7409 < #include <dfftw.h>
7410 < _ACEOF
7411 < rm -rf conftest.$ac_objext
7412 < if { (ac_try="$ac_compile"
7413 < case "(($ac_try" in
7414 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7415 <  *) ac_try_echo=$ac_try;;
7416 < esac
7417 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7418 <  (eval "$ac_compile") 2>conftest.er1
7419 <  ac_status=$?
7420 <  grep -v '^ *+' conftest.er1 >conftest.err
7421 <  rm -f conftest.er1
7422 <  cat conftest.err >&5
7423 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7424 <  (exit $ac_status); } && {
7425 <         test -z "$ac_c_werror_flag" ||
7426 <         test ! -s conftest.err
7427 <       } && test -s conftest.$ac_objext; then
7428 <  ac_header_compiler=yes
7429 < else
7430 <  echo "$as_me: failed program was:" >&5
7431 < sed 's/^/| /' conftest.$ac_ext >&5
7432 <
7433 <        ac_header_compiler=no
7434 < fi
7435 <
7436 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
7437 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7438 < echo "${ECHO_T}$ac_header_compiler" >&6; }
7439 <
7440 < # Is the header present?
7441 < { echo "$as_me:$LINENO: checking dfftw.h presence" >&5
7442 < echo $ECHO_N "checking dfftw.h presence... $ECHO_C" >&6; }
7443 < cat >conftest.$ac_ext <<_ACEOF
7444 < /* confdefs.h.  */
7445 < _ACEOF
7446 < cat confdefs.h >>conftest.$ac_ext
7447 < cat >>conftest.$ac_ext <<_ACEOF
7448 < /* end confdefs.h.  */
7449 < #include <dfftw.h>
7450 < _ACEOF
7451 < if { (ac_try="$ac_cpp conftest.$ac_ext"
7452 < case "(($ac_try" in
7453 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7454 <  *) ac_try_echo=$ac_try;;
7455 < esac
7456 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7457 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
7458 <  ac_status=$?
7459 <  grep -v '^ *+' conftest.er1 >conftest.err
7460 <  rm -f conftest.er1
7461 <  cat conftest.err >&5
7462 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7463 <  (exit $ac_status); } >/dev/null && {
7464 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
7465 <         test ! -s conftest.err
7466 <       }; then
7467 <  ac_header_preproc=yes
7468 < else
7469 <  echo "$as_me: failed program was:" >&5
7470 < sed 's/^/| /' conftest.$ac_ext >&5
7471 <
7472 <  ac_header_preproc=no
7473 < fi
7474 <
7475 < rm -rf conftest.err conftest.$ac_ext
7476 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7477 < echo "${ECHO_T}$ac_header_preproc" >&6; }
7478 <
7479 < # So?  What about this header?
7480 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7481 <  yes:no: )
7482 <    { echo "$as_me:$LINENO: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
7483 < echo "$as_me: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
7484 <    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the compiler's result" >&5
7485 < echo "$as_me: WARNING: dfftw.h: proceeding with the compiler's result" >&2;}
7486 <    ac_header_preproc=yes
7487 <    ;;
7488 <  no:yes:* )
7489 <    { echo "$as_me:$LINENO: WARNING: dfftw.h: present but cannot be compiled" >&5
7490 < echo "$as_me: WARNING: dfftw.h: present but cannot be compiled" >&2;}
7491 <    { echo "$as_me:$LINENO: WARNING: dfftw.h:     check for missing prerequisite headers?" >&5
7492 < echo "$as_me: WARNING: dfftw.h:     check for missing prerequisite headers?" >&2;}
7493 <    { echo "$as_me:$LINENO: WARNING: dfftw.h: see the Autoconf documentation" >&5
7494 < echo "$as_me: WARNING: dfftw.h: see the Autoconf documentation" >&2;}
7495 <    { echo "$as_me:$LINENO: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&5
7496 < echo "$as_me: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
7497 <    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the preprocessor's result" >&5
7498 < echo "$as_me: WARNING: dfftw.h: proceeding with the preprocessor's result" >&2;}
7499 <    { echo "$as_me:$LINENO: WARNING: dfftw.h: in the future, the compiler will take precedence" >&5
7500 < echo "$as_me: WARNING: dfftw.h: in the future, the compiler will take precedence" >&2;}
7501 <    ( cat <<\_ASBOX
7502 < ## ------------------------------ ##
7503 < ## Report this to gezelter@nd.edu ##
7504 < ## ------------------------------ ##
7505 < _ASBOX
7506 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
7507 <    ;;
7508 < esac
7509 < { echo "$as_me:$LINENO: checking for dfftw.h" >&5
7510 < echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6; }
7511 < if test "${ac_cv_header_dfftw_h+set}" = set; then
7512 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7513 < else
7514 <  ac_cv_header_dfftw_h=$ac_header_preproc
7515 < fi
7516 < { echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
7517 < echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6; }
7518 <
7519 < fi
7520 < if test $ac_cv_header_dfftw_h = yes; then
7521 <  fftw_cv_dfftw_h=yes
7522 < else
7523 <  fftw_cv_dfftw_h=no
7524 < fi
7525 <
7526 <
7527 <        fi
7528 <      fi
7529 <      ac_ext=c
7530 < ac_cpp='$CPP $CPPFLAGS'
7531 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7532 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7533 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
7534 <
7535 <      if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"; then
7536 <
7537 < cat >>confdefs.h <<\_ACEOF
7538 < #define HAVE_FFTW3_H 1
7539 < _ACEOF
7540 <
7541 <        FFTW_INC_DIR="${FFTW_HOME}/include"
7542 <        FFTW_LIB_DIR="${FFTW_HOME}/lib"
7543 <        FFTW_LIBS="-lfftw3"
7544 <      else
7545 <        if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"; then
7546 <
7547 < cat >>confdefs.h <<\_ACEOF
7548 < #define HAVE_FFTW_H 1
7549 < _ACEOF
7550 <
7551 <          FFTW_INC_DIR="${FFTW_HOME}/include"
7552 <          FFTW_LIB_DIR="${FFTW_HOME}/lib"
7553 <          FFTW_LIBS="-lfftw"
7554 <        else
7555 <          if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"; then
7556 <
7557 < cat >>confdefs.h <<\_ACEOF
7558 < #define HAVE_DFFTW_H 1
7559 < _ACEOF
7560 <
7561 <            FFTW_INC_DIR="${FFTW_HOME}/include"
7562 <            FFTW_LIB_DIR="${FFTW_HOME}/lib"
7563 <            FFTW_LIBS="-ldfftw"
7564 <          else
7565 <            { echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
7566 < echo $ECHO_N "checking fftw in ${FFTW_HOME}... $ECHO_C" >&6; }
7567 <            FFTW_INC_DIR=
7568 <            FFTW_LIB_DIR=
7569 <            FFTW_LIBS=
7570 <            LDFLAGS="$FFTW_OLD_LDFLAGS"
7571 <            CPPFLAGS="$FFTW_OLD_CPPFLAGS"
7572 <            { echo "$as_me:$LINENO: result: failed" >&5
7573 < echo "${ECHO_T}failed" >&6; }
7574 <            echo ""
7575 <            echo "*********************************************************"
7576 <            echo "* WARNING: Could not find a working FFTW installation   *"
7577 <            echo "* If you need the staticProps program to be able to     *"
7578 <            echo "* compute undulation spectra, be sure to specify a      *"
7579 <            echo "* valid fftw installation with --with-fftw=DIR          *"
7580 <            echo "*                                                       *"
7581 <            echo "* OOPSE will still work without fftw installed.         *"
7582 <            echo "*********************************************************"
7583 <            echo ""
7584 <          fi
7585 <        fi
7586 <      fi
7587 <
7588 <
7589 <
7590 <    fi
7591 <  fi
7592 < fi
7593 <
7594 <
7595 <
7596 < # Checks for header files.
7597 < { echo "$as_me:$LINENO: checking for ANSI C header files" >&5
7598 < echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6; }
7599 < if test "${ac_cv_header_stdc+set}" = set; then
7600 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7601 < else
7602 <  cat >conftest.$ac_ext <<_ACEOF
7603 < /* confdefs.h.  */
7604 < _ACEOF
7605 < cat confdefs.h >>conftest.$ac_ext
7606 < cat >>conftest.$ac_ext <<_ACEOF
7607 < /* end confdefs.h.  */
7608 < #include <stdlib.h>
7609 < #include <stdarg.h>
7610 < #include <string.h>
7611 < #include <float.h>
7612 <
7613 < #ifdef FC_DUMMY_MAIN
7614 < #ifndef FC_DUMMY_MAIN_EQ_F77
7615 < #  ifdef __cplusplus
7616 <     extern "C"
7617 < #  endif
7618 <   int FC_DUMMY_MAIN() { return 1; }
7619 < #endif
7620 < #endif
7621 < int
7622 < main ()
7623 < {
7624 <
7625 <  ;
7626 <  return 0;
7627 < }
7628 < _ACEOF
7629 < rm -rf conftest.$ac_objext
7630 < if { (ac_try="$ac_compile"
7631 < case "(($ac_try" in
7632 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7633 <  *) ac_try_echo=$ac_try;;
7634 < esac
7635 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7636 <  (eval "$ac_compile") 2>conftest.er1
7637 <  ac_status=$?
7638 <  grep -v '^ *+' conftest.er1 >conftest.err
7639 <  rm -f conftest.er1
7640 <  cat conftest.err >&5
7641 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7642 <  (exit $ac_status); } && {
7643 <         test -z "$ac_c_werror_flag" ||
7644 <         test ! -s conftest.err
7645 <       } && test -s conftest.$ac_objext; then
7646 <  ac_cv_header_stdc=yes
7647 < else
7648 <  echo "$as_me: failed program was:" >&5
7649 < sed 's/^/| /' conftest.$ac_ext >&5
7650 <
7651 <        ac_cv_header_stdc=no
7652 < fi
7653 <
7654 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
7655 <
7656 < if test $ac_cv_header_stdc = yes; then
7657 <  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
7658 <  cat >conftest.$ac_ext <<_ACEOF
7659 < /* confdefs.h.  */
7660 < _ACEOF
7661 < cat confdefs.h >>conftest.$ac_ext
7662 < cat >>conftest.$ac_ext <<_ACEOF
7663 < /* end confdefs.h.  */
7664 < #include <string.h>
7665 <
7666 < _ACEOF
7667 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7668 <  $EGREP "memchr" >/dev/null 2>&1; then
7669 <  :
7670 < else
7671 <  ac_cv_header_stdc=no
7672 < fi
7673 < rm -rf conftest*
7674 <
7675 < fi
7676 <
7677 < if test $ac_cv_header_stdc = yes; then
7678 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7679 <  cat >conftest.$ac_ext <<_ACEOF
7680 < /* confdefs.h.  */
7681 < _ACEOF
7682 < cat confdefs.h >>conftest.$ac_ext
7683 < cat >>conftest.$ac_ext <<_ACEOF
7684 < /* end confdefs.h.  */
7685 < #include <stdlib.h>
7686 <
7687 < _ACEOF
7688 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7689 <  $EGREP "free" >/dev/null 2>&1; then
7690 <  :
7691 < else
7692 <  ac_cv_header_stdc=no
7693 < fi
7694 < rm -rf conftest*
7695 <
7696 < fi
7697 <
7698 < if test $ac_cv_header_stdc = yes; then
7699 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7700 <  if test "$cross_compiling" = yes; then
7701 <  :
7702 < else
7703 <  cat >conftest.$ac_ext <<_ACEOF
7704 < /* confdefs.h.  */
7705 < _ACEOF
7706 < cat confdefs.h >>conftest.$ac_ext
7707 < cat >>conftest.$ac_ext <<_ACEOF
7708 < /* end confdefs.h.  */
7709 < #include <ctype.h>
7710 < #include <stdlib.h>
7711 < #if ((' ' & 0x0FF) == 0x020)
7712 < # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7713 < # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7714 < #else
7715 < # define ISLOWER(c) \
7716 <                   (('a' <= (c) && (c) <= 'i') \
7717 <                     || ('j' <= (c) && (c) <= 'r') \
7718 <                     || ('s' <= (c) && (c) <= 'z'))
7719 < # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7720 < #endif
7721 <
7722 < #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7723 < int
7724 < main ()
7725 < {
7726 <  int i;
7727 <  for (i = 0; i < 256; i++)
7728 <    if (XOR (islower (i), ISLOWER (i))
7729 <        || toupper (i) != TOUPPER (i))
7730 <      return 2;
7731 <  return 0;
7732 < }
7733 < _ACEOF
7734 < rm -rf conftest$ac_exeext
7735 < if { (ac_try="$ac_link"
7736 < case "(($ac_try" in
7737 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7738 <  *) ac_try_echo=$ac_try;;
7739 < esac
7740 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7741 <  (eval "$ac_link") 2>&5
7742 <  ac_status=$?
7743 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7744 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7745 <  { (case "(($ac_try" in
7746 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7747 <  *) ac_try_echo=$ac_try;;
7748 < esac
7749 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7750 <  (eval "$ac_try") 2>&5
7751 <  ac_status=$?
7752 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7753 <  (exit $ac_status); }; }; then
7754 <  :
7755 < else
7756 <  echo "$as_me: program exited with status $ac_status" >&5
7757 < echo "$as_me: failed program was:" >&5
7758 < sed 's/^/| /' conftest.$ac_ext >&5
7759 <
7760 < ( exit $ac_status )
7761 < ac_cv_header_stdc=no
7762 < fi
7763 < rm -rf core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7764 < fi
7765 <
7766 <
7767 < fi
7768 < fi
7769 < { echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7770 < echo "${ECHO_T}$ac_cv_header_stdc" >&6; }
7771 < if test $ac_cv_header_stdc = yes; then
7772 <
7773 < cat >>confdefs.h <<\_ACEOF
7774 < #define STDC_HEADERS 1
7775 < _ACEOF
7776 <
7777 < fi
7778 <
7779 <
7780 <
7781 <
7782 <
7783 <
7784 <
7785 <
7786 <
7787 <
7788 <
7789 <
7790 <
7791 <
7792 <
7793 <
7794 <
7795 <
7796 <
7797 <
7798 <
7799 <
7800 <
7801 <
7802 <
7803 <
7804 < for ac_header in conio.h dlfcn.h fstream.h iostream.h libintl.h limits.h machine/hal_sysinfo.h math.h stddef.h stdio.h stdlib.h string.h strings.h strstream.h sys/param.h sys/pstat.h sys/sysmp.h sys/sysctl.h sys/sysinfo.h sys/systemcfg.h sys/table.h sys/time.h time.h unistd.h zlib.h
7805 < do
7806 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7807 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
7808 <  { echo "$as_me:$LINENO: checking for $ac_header" >&5
7809 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
7810 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
7811 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7812 < fi
7813 < ac_res=`eval echo '${'$as_ac_Header'}'`
7814 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
7815 < echo "${ECHO_T}$ac_res" >&6; }
7816 < else
7817 <  # Is the header compilable?
7818 < { echo "$as_me:$LINENO: checking $ac_header usability" >&5
7819 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
7820 < cat >conftest.$ac_ext <<_ACEOF
7821 < /* confdefs.h.  */
7822 < _ACEOF
7823 < cat confdefs.h >>conftest.$ac_ext
7824 < cat >>conftest.$ac_ext <<_ACEOF
7825 < /* end confdefs.h.  */
7826 < $ac_includes_default
7827 < #include <$ac_header>
7828 < _ACEOF
7829 < rm -rf conftest.$ac_objext
7830 < if { (ac_try="$ac_compile"
7831 < case "(($ac_try" in
7832 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7833 <  *) ac_try_echo=$ac_try;;
7834 < esac
7835 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7836 <  (eval "$ac_compile") 2>conftest.er1
7837 <  ac_status=$?
7838 <  grep -v '^ *+' conftest.er1 >conftest.err
7839 <  rm -f conftest.er1
7840 <  cat conftest.err >&5
7841 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7842 <  (exit $ac_status); } && {
7843 <         test -z "$ac_c_werror_flag" ||
7844 <         test ! -s conftest.err
7845 <       } && test -s conftest.$ac_objext; then
7846 <  ac_header_compiler=yes
7847 < else
7848 <  echo "$as_me: failed program was:" >&5
7849 < sed 's/^/| /' conftest.$ac_ext >&5
7850 <
7851 <        ac_header_compiler=no
7852 < fi
7853 <
7854 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
7855 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7856 < echo "${ECHO_T}$ac_header_compiler" >&6; }
7857 <
7858 < # Is the header present?
7859 < { echo "$as_me:$LINENO: checking $ac_header presence" >&5
7860 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
7861 < cat >conftest.$ac_ext <<_ACEOF
7862 < /* confdefs.h.  */
7863 < _ACEOF
7864 < cat confdefs.h >>conftest.$ac_ext
7865 < cat >>conftest.$ac_ext <<_ACEOF
7866 < /* end confdefs.h.  */
7867 < #include <$ac_header>
7868 < _ACEOF
7869 < if { (ac_try="$ac_cpp conftest.$ac_ext"
7870 < case "(($ac_try" in
7871 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7872 <  *) ac_try_echo=$ac_try;;
7873 < esac
7874 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7875 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
7876 <  ac_status=$?
7877 <  grep -v '^ *+' conftest.er1 >conftest.err
7878 <  rm -f conftest.er1
7879 <  cat conftest.err >&5
7880 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7881 <  (exit $ac_status); } >/dev/null && {
7882 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
7883 <         test ! -s conftest.err
7884 <       }; then
7885 <  ac_header_preproc=yes
7886 < else
7887 <  echo "$as_me: failed program was:" >&5
7888 < sed 's/^/| /' conftest.$ac_ext >&5
7889 <
7890 <  ac_header_preproc=no
7891 < fi
7892 <
7893 < rm -rf conftest.err conftest.$ac_ext
7894 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7895 < echo "${ECHO_T}$ac_header_preproc" >&6; }
7896 <
7897 < # So?  What about this header?
7898 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7899 <  yes:no: )
7900 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7901 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7902 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7903 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7904 <    ac_header_preproc=yes
7905 <    ;;
7906 <  no:yes:* )
7907 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7908 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7909 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7910 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7911 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7912 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7913 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7914 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7915 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7916 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7917 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7918 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7919 <    ( cat <<\_ASBOX
7920 < ## ------------------------------ ##
7921 < ## Report this to gezelter@nd.edu ##
7922 < ## ------------------------------ ##
7923 < _ASBOX
7924 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
7925 <    ;;
7926 < esac
7927 < { echo "$as_me:$LINENO: checking for $ac_header" >&5
7928 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
7929 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
7930 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7931 < else
7932 <  eval "$as_ac_Header=\$ac_header_preproc"
7933 < fi
7934 < ac_res=`eval echo '${'$as_ac_Header'}'`
7935 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
7936 < echo "${ECHO_T}$ac_res" >&6; }
7937 <
7938 < fi
7939 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
7940 <  cat >>confdefs.h <<_ACEOF
7941 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7942 < _ACEOF
7943 <
7944 < fi
7945 <
7946 < done
7947 <
7948 <
7949 < # Checks for typedefs, structures, and compiler characteristics.
7950 < { echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7951 < echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6; }
7952 < if test "${ac_cv_header_stdbool_h+set}" = set; then
7953 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7954 < else
7955 <  cat >conftest.$ac_ext <<_ACEOF
7956 < /* confdefs.h.  */
7957 < _ACEOF
7958 < cat confdefs.h >>conftest.$ac_ext
7959 < cat >>conftest.$ac_ext <<_ACEOF
7960 < /* end confdefs.h.  */
7961 <
7962 < #include <stdbool.h>
7963 < #ifndef bool
7964 < "error: bool is not defined"
7965 < #endif
7966 < #ifndef false
7967 < "error: false is not defined"
7968 < #endif
7969 < #if false
7970 < "error: false is not 0"
7971 < #endif
7972 < #ifndef true
7973 < "error: true is not defined"
7974 < #endif
7975 < #if true != 1
7976 < "error: true is not 1"
7977 < #endif
7978 < #ifndef __bool_true_false_are_defined
7979 < "error: __bool_true_false_are_defined is not defined"
7980 < #endif
7981 <
7982 <        struct s { _Bool s: 1; _Bool t; } s;
7983 <
7984 <        char a[true == 1 ? 1 : -1];
7985 <        char b[false == 0 ? 1 : -1];
7986 <        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7987 <        char d[(bool) 0.5 == true ? 1 : -1];
7988 <        bool e = &s;
7989 <        char f[(_Bool) 0.0 == false ? 1 : -1];
7990 <        char g[true];
7991 <        char h[sizeof (_Bool)];
7992 <        char i[sizeof s.t];
7993 <        enum { j = false, k = true, l = false * true, m = true * 256 };
7994 <        _Bool n[m];
7995 <        char o[sizeof n == m * sizeof n[0] ? 1 : -1];
7996 <        char p[-1 - (_Bool) 0 < 0 && -1 - (bool) 0 < 0 ? 1 : -1];
7997 < #       if defined __xlc__ || defined __GNUC__
7998 <         /* Catch a bug in IBM AIX xlc compiler version 6.0.0.0
7999 <            reported by James Lemley on 2005-10-05; see
8000 <            http://lists.gnu.org/archive/html/bug-coreutils/2005-10/msg00086.html
8001 <            This test is not quite right, since xlc is allowed to
8002 <            reject this program, as the initializer for xlcbug is
8003 <            not one of the forms that C requires support for.
8004 <            However, doing the test right would require a runtime
8005 <            test, and that would make cross-compilation harder.
8006 <            Let us hope that IBM fixes the xlc bug, and also adds
8007 <            support for this kind of constant expression.  In the
8008 <            meantime, this test will reject xlc, which is OK, since
8009 <            our stdbool.h substitute should suffice.  We also test
8010 <            this with GCC, where it should work, to detect more
8011 <            quickly whether someone messes up the test in the
8012 <            future.  */
8013 <         char digs[] = "0123456789";
8014 <         int xlcbug = 1 / (&(digs + 5)[-2 + (bool) 1] == &digs[4] ? 1 : -1);
8015 < #       endif
8016 <        /* Catch a bug in an HP-UX C compiler.  See
8017 <           http://gcc.gnu.org/ml/gcc-patches/2003-12/msg02303.html
8018 <           http://lists.gnu.org/archive/html/bug-coreutils/2005-11/msg00161.html
8019 <         */
8020 <        _Bool q = true;
8021 <        _Bool *pq = &q;
8022 <
8023 < #ifdef FC_DUMMY_MAIN
8024 < #ifndef FC_DUMMY_MAIN_EQ_F77
8025 < #  ifdef __cplusplus
8026 <     extern "C"
8027 < #  endif
8028 <   int FC_DUMMY_MAIN() { return 1; }
8029 < #endif
8030 < #endif
8031 < int
8032 < main ()
8033 < {
8034 <
8035 <        *pq |= q;
8036 <        *pq |= ! q;
8037 <        /* Refer to every declared value, to avoid compiler optimizations.  */
8038 <        return (!a + !b + !c + !d + !e + !f + !g + !h + !i + !!j + !k + !!l
8039 <                + !m + !n + !o + !p + !q + !pq);
8040 <
8041 <  ;
8042 <  return 0;
8043 < }
8044 < _ACEOF
8045 < rm -rf conftest.$ac_objext
8046 < if { (ac_try="$ac_compile"
8047 < case "(($ac_try" in
8048 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8049 <  *) ac_try_echo=$ac_try;;
8050 < esac
8051 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8052 <  (eval "$ac_compile") 2>conftest.er1
8053 <  ac_status=$?
8054 <  grep -v '^ *+' conftest.er1 >conftest.err
8055 <  rm -f conftest.er1
8056 <  cat conftest.err >&5
8057 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8058 <  (exit $ac_status); } && {
8059 <         test -z "$ac_c_werror_flag" ||
8060 <         test ! -s conftest.err
8061 <       } && test -s conftest.$ac_objext; then
8062 <  ac_cv_header_stdbool_h=yes
8063 < else
8064 <  echo "$as_me: failed program was:" >&5
8065 < sed 's/^/| /' conftest.$ac_ext >&5
8066 <
8067 <        ac_cv_header_stdbool_h=no
8068 < fi
8069 <
8070 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
8071 < fi
8072 < { echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
8073 < echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6; }
8074 < { echo "$as_me:$LINENO: checking for _Bool" >&5
8075 < echo $ECHO_N "checking for _Bool... $ECHO_C" >&6; }
8076 < if test "${ac_cv_type__Bool+set}" = set; then
8077 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8078 < else
8079 <  cat >conftest.$ac_ext <<_ACEOF
8080 < /* confdefs.h.  */
8081 < _ACEOF
8082 < cat confdefs.h >>conftest.$ac_ext
8083 < cat >>conftest.$ac_ext <<_ACEOF
8084 < /* end confdefs.h.  */
8085 < $ac_includes_default
8086 < typedef _Bool ac__type_new_;
8087 < #ifdef FC_DUMMY_MAIN
8088 < #ifndef FC_DUMMY_MAIN_EQ_F77
8089 < #  ifdef __cplusplus
8090 <     extern "C"
8091 < #  endif
8092 <   int FC_DUMMY_MAIN() { return 1; }
8093 < #endif
8094 < #endif
8095 < int
8096 < main ()
8097 < {
8098 < if ((ac__type_new_ *) 0)
8099 <  return 0;
8100 < if (sizeof (ac__type_new_))
8101 <  return 0;
8102 <  ;
8103 <  return 0;
8104 < }
8105 < _ACEOF
8106 < rm -rf conftest.$ac_objext
8107 < if { (ac_try="$ac_compile"
8108 < case "(($ac_try" in
8109 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8110 <  *) ac_try_echo=$ac_try;;
8111 < esac
8112 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8113 <  (eval "$ac_compile") 2>conftest.er1
8114 <  ac_status=$?
8115 <  grep -v '^ *+' conftest.er1 >conftest.err
8116 <  rm -f conftest.er1
8117 <  cat conftest.err >&5
8118 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8119 <  (exit $ac_status); } && {
8120 <         test -z "$ac_c_werror_flag" ||
8121 <         test ! -s conftest.err
8122 <       } && test -s conftest.$ac_objext; then
8123 <  ac_cv_type__Bool=yes
8124 < else
8125 <  echo "$as_me: failed program was:" >&5
8126 < sed 's/^/| /' conftest.$ac_ext >&5
8127 <
8128 <        ac_cv_type__Bool=no
8129 < fi
8130 <
8131 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
8132 < fi
8133 < { echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
8134 < echo "${ECHO_T}$ac_cv_type__Bool" >&6; }
8135 < if test $ac_cv_type__Bool = yes; then
8136 <
8137 < cat >>confdefs.h <<_ACEOF
8138 < #define HAVE__BOOL 1
8139 < _ACEOF
8140 <
8141 <
8142 < fi
8143 <
8144 < if test $ac_cv_header_stdbool_h = yes; then
8145 <
8146 < cat >>confdefs.h <<\_ACEOF
8147 < #define HAVE_STDBOOL_H 1
8148 < _ACEOF
8149 <
8150 < fi
8151 <
8152 < { echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
8153 < echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6; }
8154 < if test "${ac_cv_c_const+set}" = set; then
8155 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8156 < else
8157 <  cat >conftest.$ac_ext <<_ACEOF
8158 < /* confdefs.h.  */
8159 < _ACEOF
8160 < cat confdefs.h >>conftest.$ac_ext
8161 < cat >>conftest.$ac_ext <<_ACEOF
8162 < /* end confdefs.h.  */
8163 <
8164 < #ifdef FC_DUMMY_MAIN
8165 < #ifndef FC_DUMMY_MAIN_EQ_F77
8166 < #  ifdef __cplusplus
8167 <     extern "C"
8168 < #  endif
8169 <   int FC_DUMMY_MAIN() { return 1; }
8170 < #endif
8171 < #endif
8172 < int
8173 < main ()
8174 < {
8175 < /* FIXME: Include the comments suggested by Paul. */
8176 < #ifndef __cplusplus
8177 <  /* Ultrix mips cc rejects this.  */
8178 <  typedef int charset[2];
8179 <  const charset cs;
8180 <  /* SunOS 4.1.1 cc rejects this.  */
8181 <  char const *const *pcpcc;
8182 <  char **ppc;
8183 <  /* NEC SVR4.0.2 mips cc rejects this.  */
8184 <  struct point {int x, y;};
8185 <  static struct point const zero = {0,0};
8186 <  /* AIX XL C 1.02.0.0 rejects this.
8187 <     It does not let you subtract one const X* pointer from another in
8188 <     an arm of an if-expression whose if-part is not a constant
8189 <     expression */
8190 <  const char *g = "string";
8191 <  pcpcc = &g + (g ? g-g : 0);
8192 <  /* HPUX 7.0 cc rejects these. */
8193 <  ++pcpcc;
8194 <  ppc = (char**) pcpcc;
8195 <  pcpcc = (char const *const *) ppc;
8196 <  { /* SCO 3.2v4 cc rejects this.  */
8197 <    char *t;
8198 <    char const *s = 0 ? (char *) 0 : (char const *) 0;
8199 <
8200 <    *t++ = 0;
8201 <    if (s) return 0;
8202 <  }
8203 <  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
8204 <    int x[] = {25, 17};
8205 <    const int *foo = &x[0];
8206 <    ++foo;
8207 <  }
8208 <  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
8209 <    typedef const int *iptr;
8210 <    iptr p = 0;
8211 <    ++p;
8212 <  }
8213 <  { /* AIX XL C 1.02.0.0 rejects this saying
8214 <       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
8215 <    struct s { int j; const int *ap[3]; };
8216 <    struct s *b; b->j = 5;
8217 <  }
8218 <  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
8219 <    const int foo = 10;
8220 <    if (!foo) return 0;
8221 <  }
8222 <  return !cs[0] && !zero.x;
8223 < #endif
8224 <
8225 <  ;
8226 <  return 0;
8227 < }
8228 < _ACEOF
8229 < rm -rf conftest.$ac_objext
8230 < if { (ac_try="$ac_compile"
8231 < case "(($ac_try" in
8232 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8233 <  *) ac_try_echo=$ac_try;;
8234 < esac
8235 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8236 <  (eval "$ac_compile") 2>conftest.er1
8237 <  ac_status=$?
8238 <  grep -v '^ *+' conftest.er1 >conftest.err
8239 <  rm -f conftest.er1
8240 <  cat conftest.err >&5
8241 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8242 <  (exit $ac_status); } && {
8243 <         test -z "$ac_c_werror_flag" ||
8244 <         test ! -s conftest.err
8245 <       } && test -s conftest.$ac_objext; then
8246 <  ac_cv_c_const=yes
8247 < else
8248 <  echo "$as_me: failed program was:" >&5
8249 < sed 's/^/| /' conftest.$ac_ext >&5
8250 <
8251 <        ac_cv_c_const=no
8252 < fi
8253 <
8254 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
8255 < fi
8256 < { echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8257 < echo "${ECHO_T}$ac_cv_c_const" >&6; }
8258 < if test $ac_cv_c_const = no; then
8259 <
8260 < cat >>confdefs.h <<\_ACEOF
8261 < #define const
8262 < _ACEOF
8263 <
8264 < fi
8265 <
8266 < { echo "$as_me:$LINENO: checking for inline" >&5
8267 < echo $ECHO_N "checking for inline... $ECHO_C" >&6; }
8268 < if test "${ac_cv_c_inline+set}" = set; then
8269 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8270 < else
8271 <  ac_cv_c_inline=no
8272 < for ac_kw in inline __inline__ __inline; do
8273 <  cat >conftest.$ac_ext <<_ACEOF
8274 < /* confdefs.h.  */
8275 < _ACEOF
8276 < cat confdefs.h >>conftest.$ac_ext
8277 < cat >>conftest.$ac_ext <<_ACEOF
8278 < /* end confdefs.h.  */
8279 < #ifndef __cplusplus
8280 < typedef int foo_t;
8281 < static $ac_kw foo_t static_foo () {return 0; }
8282 < $ac_kw foo_t foo () {return 0; }
8283 < #endif
8284 <
8285 < _ACEOF
8286 < rm -rf conftest.$ac_objext
8287 < if { (ac_try="$ac_compile"
8288 < case "(($ac_try" in
8289 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8290 <  *) ac_try_echo=$ac_try;;
8291 < esac
8292 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8293 <  (eval "$ac_compile") 2>conftest.er1
8294 <  ac_status=$?
8295 <  grep -v '^ *+' conftest.er1 >conftest.err
8296 <  rm -f conftest.er1
8297 <  cat conftest.err >&5
8298 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8299 <  (exit $ac_status); } && {
8300 <         test -z "$ac_c_werror_flag" ||
8301 <         test ! -s conftest.err
8302 <       } && test -s conftest.$ac_objext; then
8303 <  ac_cv_c_inline=$ac_kw
8304 < else
8305 <  echo "$as_me: failed program was:" >&5
8306 < sed 's/^/| /' conftest.$ac_ext >&5
8307 <
8308 <
8309 < fi
8310 <
8311 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
8312 <  test "$ac_cv_c_inline" != no && break
8313 < done
8314 <
8315 < fi
8316 < { echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8317 < echo "${ECHO_T}$ac_cv_c_inline" >&6; }
8318 <
8319 <
8320 < case $ac_cv_c_inline in
8321 <  inline | yes) ;;
8322 <  *)
8323 <    case $ac_cv_c_inline in
8324 <      no) ac_val=;;
8325 <      *) ac_val=$ac_cv_c_inline;;
8326 <    esac
8327 <    cat >>confdefs.h <<_ACEOF
8328 < #ifndef __cplusplus
8329 < #define inline $ac_val
8330 < #endif
8331 < _ACEOF
8332 <    ;;
8333 < esac
8334 <
8335 < { echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
8336 < echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6; }
8337 < if test "${ac_cv_c_restrict+set}" = set; then
8338 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8339 < else
8340 <  ac_cv_c_restrict=no
8341 <   # Try the official restrict keyword, then gcc's __restrict, and
8342 <   # the less common variants.
8343 <   for ac_kw in restrict __restrict __restrict__ _Restrict; do
8344 <     cat >conftest.$ac_ext <<_ACEOF
8345 < /* confdefs.h.  */
8346 < _ACEOF
8347 < cat confdefs.h >>conftest.$ac_ext
8348 < cat >>conftest.$ac_ext <<_ACEOF
8349 < /* end confdefs.h.  */
8350 < typedef int * int_ptr;
8351 <        int foo (int_ptr $ac_kw ip) {
8352 <        return ip[0];
8353 <       }
8354 < #ifdef FC_DUMMY_MAIN
8355 < #ifndef FC_DUMMY_MAIN_EQ_F77
8356 < #  ifdef __cplusplus
8357 <     extern "C"
8358 < #  endif
8359 <   int FC_DUMMY_MAIN() { return 1; }
8360 < #endif
8361 < #endif
8362 < int
8363 < main ()
8364 < {
8365 < int s[1];
8366 <        int * $ac_kw t = s;
8367 <        t[0] = 0;
8368 <        return foo(t)
8369 <  ;
8370 <  return 0;
8371 < }
8372 < _ACEOF
8373 < rm -rf conftest.$ac_objext
8374 < if { (ac_try="$ac_compile"
8375 < case "(($ac_try" in
8376 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8377 <  *) ac_try_echo=$ac_try;;
8378 < esac
8379 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8380 <  (eval "$ac_compile") 2>conftest.er1
8381 <  ac_status=$?
8382 <  grep -v '^ *+' conftest.er1 >conftest.err
8383 <  rm -f conftest.er1
8384 <  cat conftest.err >&5
8385 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8386 <  (exit $ac_status); } && {
8387 <         test -z "$ac_c_werror_flag" ||
8388 <         test ! -s conftest.err
8389 <       } && test -s conftest.$ac_objext; then
8390 <  ac_cv_c_restrict=$ac_kw
8391 < else
8392 <  echo "$as_me: failed program was:" >&5
8393 < sed 's/^/| /' conftest.$ac_ext >&5
8394 <
8395 <
8396 < fi
8397 <
8398 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
8399 <     test "$ac_cv_c_restrict" != no && break
8400 <   done
8401 <
8402 < fi
8403 < { echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
8404 < echo "${ECHO_T}$ac_cv_c_restrict" >&6; }
8405 < case $ac_cv_c_restrict in
8406 <   restrict) ;;
8407 <   no)
8408 < cat >>confdefs.h <<\_ACEOF
8409 < #define restrict
8410 < _ACEOF
8411 < ;;
8412 <   *)  cat >>confdefs.h <<_ACEOF
8413 < #define restrict $ac_cv_c_restrict
8414 < _ACEOF
8415 < ;;
8416 < esac
8417 <
8418 < { echo "$as_me:$LINENO: checking for size_t" >&5
8419 < echo $ECHO_N "checking for size_t... $ECHO_C" >&6; }
8420 < if test "${ac_cv_type_size_t+set}" = set; then
8421 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8422 < else
8423 <  cat >conftest.$ac_ext <<_ACEOF
8424 < /* confdefs.h.  */
8425 < _ACEOF
8426 < cat confdefs.h >>conftest.$ac_ext
8427 < cat >>conftest.$ac_ext <<_ACEOF
8428 < /* end confdefs.h.  */
8429 < $ac_includes_default
8430 < typedef size_t ac__type_new_;
8431 < #ifdef FC_DUMMY_MAIN
8432 < #ifndef FC_DUMMY_MAIN_EQ_F77
8433 < #  ifdef __cplusplus
8434 <     extern "C"
8435 < #  endif
8436 <   int FC_DUMMY_MAIN() { return 1; }
8437 < #endif
8438 < #endif
8439 < int
8440 < main ()
8441 < {
8442 < if ((ac__type_new_ *) 0)
8443 <  return 0;
8444 < if (sizeof (ac__type_new_))
8445 <  return 0;
8446 <  ;
8447 <  return 0;
8448 < }
8449 < _ACEOF
8450 < rm -rf conftest.$ac_objext
8451 < if { (ac_try="$ac_compile"
8452 < case "(($ac_try" in
8453 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8454 <  *) ac_try_echo=$ac_try;;
8455 < esac
8456 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8457 <  (eval "$ac_compile") 2>conftest.er1
8458 <  ac_status=$?
8459 <  grep -v '^ *+' conftest.er1 >conftest.err
8460 <  rm -f conftest.er1
8461 <  cat conftest.err >&5
8462 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8463 <  (exit $ac_status); } && {
8464 <         test -z "$ac_c_werror_flag" ||
8465 <         test ! -s conftest.err
8466 <       } && test -s conftest.$ac_objext; then
8467 <  ac_cv_type_size_t=yes
8468 < else
8469 <  echo "$as_me: failed program was:" >&5
8470 < sed 's/^/| /' conftest.$ac_ext >&5
8471 <
8472 <        ac_cv_type_size_t=no
8473 < fi
8474 <
8475 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
8476 < fi
8477 < { echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
8478 < echo "${ECHO_T}$ac_cv_type_size_t" >&6; }
8479 < if test $ac_cv_type_size_t = yes; then
8480 <  :
8481 < else
8482 <
8483 < cat >>confdefs.h <<_ACEOF
8484 < #define size_t unsigned int
8485 < _ACEOF
8486 <
8487 < fi
8488 <
8489 < { echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
8490 < echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6; }
8491 < if test "${ac_cv_header_time+set}" = set; then
8492 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8493 < else
8494 <  cat >conftest.$ac_ext <<_ACEOF
8495 < /* confdefs.h.  */
8496 < _ACEOF
8497 < cat confdefs.h >>conftest.$ac_ext
8498 < cat >>conftest.$ac_ext <<_ACEOF
8499 < /* end confdefs.h.  */
8500 < #include <sys/types.h>
8501 < #include <sys/time.h>
8502 < #include <time.h>
8503 <
8504 < #ifdef FC_DUMMY_MAIN
8505 < #ifndef FC_DUMMY_MAIN_EQ_F77
8506 < #  ifdef __cplusplus
8507 <     extern "C"
8508 < #  endif
8509 <   int FC_DUMMY_MAIN() { return 1; }
8510 < #endif
8511 < #endif
8512 < int
8513 < main ()
8514 < {
8515 < if ((struct tm *) 0)
8516 < return 0;
8517 <  ;
8518 <  return 0;
8519 < }
8520 < _ACEOF
8521 < rm -rf conftest.$ac_objext
8522 < if { (ac_try="$ac_compile"
8523 < case "(($ac_try" in
8524 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8525 <  *) ac_try_echo=$ac_try;;
8526 < esac
8527 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8528 <  (eval "$ac_compile") 2>conftest.er1
8529 <  ac_status=$?
8530 <  grep -v '^ *+' conftest.er1 >conftest.err
8531 <  rm -f conftest.er1
8532 <  cat conftest.err >&5
8533 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8534 <  (exit $ac_status); } && {
8535 <         test -z "$ac_c_werror_flag" ||
8536 <         test ! -s conftest.err
8537 <       } && test -s conftest.$ac_objext; then
8538 <  ac_cv_header_time=yes
8539 < else
8540 <  echo "$as_me: failed program was:" >&5
8541 < sed 's/^/| /' conftest.$ac_ext >&5
8542 <
8543 <        ac_cv_header_time=no
8544 < fi
8545 <
8546 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
8547 < fi
8548 < { echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
8549 < echo "${ECHO_T}$ac_cv_header_time" >&6; }
8550 < if test $ac_cv_header_time = yes; then
8551 <
8552 < cat >>confdefs.h <<\_ACEOF
8553 < #define TIME_WITH_SYS_TIME 1
8554 < _ACEOF
8555 <
8556 < fi
8557 <
8558 < { echo "$as_me:$LINENO: checking for clock_t" >&5
8559 < echo $ECHO_N "checking for clock_t... $ECHO_C" >&6; }
8560 < if test "${ac_cv_type_clock_t+set}" = set; then
8561 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8562 < else
8563 <  cat >conftest.$ac_ext <<_ACEOF
8564 < /* confdefs.h.  */
8565 < _ACEOF
8566 < cat confdefs.h >>conftest.$ac_ext
8567 < cat >>conftest.$ac_ext <<_ACEOF
8568 < /* end confdefs.h.  */
8569 < $ac_includes_default
8570 < typedef clock_t ac__type_new_;
8571 < #ifdef FC_DUMMY_MAIN
8572 < #ifndef FC_DUMMY_MAIN_EQ_F77
8573 < #  ifdef __cplusplus
8574 <     extern "C"
8575 < #  endif
8576 <   int FC_DUMMY_MAIN() { return 1; }
8577 < #endif
8578 < #endif
8579 < int
8580 < main ()
8581 < {
8582 < if ((ac__type_new_ *) 0)
8583 <  return 0;
8584 < if (sizeof (ac__type_new_))
8585 <  return 0;
8586 <  ;
8587 <  return 0;
8588 < }
8589 < _ACEOF
8590 < rm -rf conftest.$ac_objext
8591 < if { (ac_try="$ac_compile"
8592 < case "(($ac_try" in
8593 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8594 <  *) ac_try_echo=$ac_try;;
8595 < esac
8596 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8597 <  (eval "$ac_compile") 2>conftest.er1
8598 <  ac_status=$?
8599 <  grep -v '^ *+' conftest.er1 >conftest.err
8600 <  rm -f conftest.er1
8601 <  cat conftest.err >&5
8602 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8603 <  (exit $ac_status); } && {
8604 <         test -z "$ac_c_werror_flag" ||
8605 <         test ! -s conftest.err
8606 <       } && test -s conftest.$ac_objext; then
8607 <  ac_cv_type_clock_t=yes
8608 < else
8609 <  echo "$as_me: failed program was:" >&5
8610 < sed 's/^/| /' conftest.$ac_ext >&5
8611 <
8612 <        ac_cv_type_clock_t=no
8613 < fi
8614 <
8615 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
8616 < fi
8617 < { echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
8618 < echo "${ECHO_T}$ac_cv_type_clock_t" >&6; }
8619 < if test $ac_cv_type_clock_t = yes; then
8620 <
8621 < cat >>confdefs.h <<_ACEOF
8622 < #define HAVE_CLOCK_T 1
8623 < _ACEOF
8624 <
8625 <
8626 < fi
8627 <
8628 < { echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
8629 < echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6; }
8630 < if test "${ac_cv_c_const+set}" = set; then
8631 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8632 < else
8633 <  cat >conftest.$ac_ext <<_ACEOF
8634 < /* confdefs.h.  */
8635 < _ACEOF
8636 < cat confdefs.h >>conftest.$ac_ext
8637 < cat >>conftest.$ac_ext <<_ACEOF
8638 < /* end confdefs.h.  */
8639 <
8640 < #ifdef FC_DUMMY_MAIN
8641 < #ifndef FC_DUMMY_MAIN_EQ_F77
8642 < #  ifdef __cplusplus
8643 <     extern "C"
8644 < #  endif
8645 <   int FC_DUMMY_MAIN() { return 1; }
8646 < #endif
8647 < #endif
8648 < int
8649 < main ()
8650 < {
8651 < /* FIXME: Include the comments suggested by Paul. */
8652 < #ifndef __cplusplus
8653 <  /* Ultrix mips cc rejects this.  */
8654 <  typedef int charset[2];
8655 <  const charset cs;
8656 <  /* SunOS 4.1.1 cc rejects this.  */
8657 <  char const *const *pcpcc;
8658 <  char **ppc;
8659 <  /* NEC SVR4.0.2 mips cc rejects this.  */
8660 <  struct point {int x, y;};
8661 <  static struct point const zero = {0,0};
8662 <  /* AIX XL C 1.02.0.0 rejects this.
8663 <     It does not let you subtract one const X* pointer from another in
8664 <     an arm of an if-expression whose if-part is not a constant
8665 <     expression */
8666 <  const char *g = "string";
8667 <  pcpcc = &g + (g ? g-g : 0);
8668 <  /* HPUX 7.0 cc rejects these. */
8669 <  ++pcpcc;
8670 <  ppc = (char**) pcpcc;
8671 <  pcpcc = (char const *const *) ppc;
8672 <  { /* SCO 3.2v4 cc rejects this.  */
8673 <    char *t;
8674 <    char const *s = 0 ? (char *) 0 : (char const *) 0;
8675 <
8676 <    *t++ = 0;
8677 <    if (s) return 0;
8678 <  }
8679 <  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
8680 <    int x[] = {25, 17};
8681 <    const int *foo = &x[0];
8682 <    ++foo;
8683 <  }
8684 <  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
8685 <    typedef const int *iptr;
8686 <    iptr p = 0;
8687 <    ++p;
8688 <  }
8689 <  { /* AIX XL C 1.02.0.0 rejects this saying
8690 <       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
8691 <    struct s { int j; const int *ap[3]; };
8692 <    struct s *b; b->j = 5;
8693 <  }
8694 <  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
8695 <    const int foo = 10;
8696 <    if (!foo) return 0;
8697 <  }
8698 <  return !cs[0] && !zero.x;
8699 < #endif
8700 <
8701 <  ;
8702 <  return 0;
8703 < }
8704 < _ACEOF
8705 < rm -rf conftest.$ac_objext
8706 < if { (ac_try="$ac_compile"
8707 < case "(($ac_try" in
8708 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8709 <  *) ac_try_echo=$ac_try;;
8710 < esac
8711 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8712 <  (eval "$ac_compile") 2>conftest.er1
8713 <  ac_status=$?
8714 <  grep -v '^ *+' conftest.er1 >conftest.err
8715 <  rm -f conftest.er1
8716 <  cat conftest.err >&5
8717 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8718 <  (exit $ac_status); } && {
8719 <         test -z "$ac_c_werror_flag" ||
8720 <         test ! -s conftest.err
8721 <       } && test -s conftest.$ac_objext; then
8722 <  ac_cv_c_const=yes
8723 < else
8724 <  echo "$as_me: failed program was:" >&5
8725 < sed 's/^/| /' conftest.$ac_ext >&5
8726 <
8727 <        ac_cv_c_const=no
8728 < fi
8729 <
8730 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
8731 < fi
8732 < { echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8733 < echo "${ECHO_T}$ac_cv_c_const" >&6; }
8734 < if test $ac_cv_c_const = no; then
8735 <
8736 < cat >>confdefs.h <<\_ACEOF
8737 < #define const
8738 < _ACEOF
8739 <
8740 < fi
8741 <
8742 < { echo "$as_me:$LINENO: checking for inline" >&5
8743 < echo $ECHO_N "checking for inline... $ECHO_C" >&6; }
8744 < if test "${ac_cv_c_inline+set}" = set; then
8745 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8746 < else
8747 <  ac_cv_c_inline=no
8748 < for ac_kw in inline __inline__ __inline; do
8749 <  cat >conftest.$ac_ext <<_ACEOF
8750 < /* confdefs.h.  */
8751 < _ACEOF
8752 < cat confdefs.h >>conftest.$ac_ext
8753 < cat >>conftest.$ac_ext <<_ACEOF
8754 < /* end confdefs.h.  */
8755 < #ifndef __cplusplus
8756 < typedef int foo_t;
8757 < static $ac_kw foo_t static_foo () {return 0; }
8758 < $ac_kw foo_t foo () {return 0; }
8759 < #endif
8760 <
8761 < _ACEOF
8762 < rm -rf conftest.$ac_objext
8763 < if { (ac_try="$ac_compile"
8764 < case "(($ac_try" in
8765 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8766 <  *) ac_try_echo=$ac_try;;
8767 < esac
8768 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8769 <  (eval "$ac_compile") 2>conftest.er1
8770 <  ac_status=$?
8771 <  grep -v '^ *+' conftest.er1 >conftest.err
8772 <  rm -f conftest.er1
8773 <  cat conftest.err >&5
8774 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8775 <  (exit $ac_status); } && {
8776 <         test -z "$ac_c_werror_flag" ||
8777 <         test ! -s conftest.err
8778 <       } && test -s conftest.$ac_objext; then
8779 <  ac_cv_c_inline=$ac_kw
8780 < else
8781 <  echo "$as_me: failed program was:" >&5
8782 < sed 's/^/| /' conftest.$ac_ext >&5
8783 <
8784 <
8785 < fi
8786 <
8787 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
8788 <  test "$ac_cv_c_inline" != no && break
8789 < done
8790 <
8791 < fi
8792 < { echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8793 < echo "${ECHO_T}$ac_cv_c_inline" >&6; }
8794 <
8795 <
8796 < case $ac_cv_c_inline in
8797 <  inline | yes) ;;
8798 <  *)
8799 <    case $ac_cv_c_inline in
8800 <      no) ac_val=;;
8801 <      *) ac_val=$ac_cv_c_inline;;
8802 <    esac
8803 <    cat >>confdefs.h <<_ACEOF
8804 < #ifndef __cplusplus
8805 < #define inline $ac_val
8806 < #endif
8807 < _ACEOF
8808 <    ;;
8809 < esac
8810 <
8811 <
8812 < # Checks for library functions.
8813 <
8814 < for ac_header in stdlib.h
8815 < do
8816 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8817 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
8818 <  { echo "$as_me:$LINENO: checking for $ac_header" >&5
8819 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
8820 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
8821 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8822 < fi
8823 < ac_res=`eval echo '${'$as_ac_Header'}'`
8824 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
8825 < echo "${ECHO_T}$ac_res" >&6; }
8826 < else
8827 <  # Is the header compilable?
8828 < { echo "$as_me:$LINENO: checking $ac_header usability" >&5
8829 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
8830 < cat >conftest.$ac_ext <<_ACEOF
8831 < /* confdefs.h.  */
8832 < _ACEOF
8833 < cat confdefs.h >>conftest.$ac_ext
8834 < cat >>conftest.$ac_ext <<_ACEOF
8835 < /* end confdefs.h.  */
8836 < $ac_includes_default
8837 < #include <$ac_header>
8838 < _ACEOF
8839 < rm -rf conftest.$ac_objext
8840 < if { (ac_try="$ac_compile"
8841 < case "(($ac_try" in
8842 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8843 <  *) ac_try_echo=$ac_try;;
8844 < esac
8845 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8846 <  (eval "$ac_compile") 2>conftest.er1
8847 <  ac_status=$?
8848 <  grep -v '^ *+' conftest.er1 >conftest.err
8849 <  rm -f conftest.er1
8850 <  cat conftest.err >&5
8851 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8852 <  (exit $ac_status); } && {
8853 <         test -z "$ac_c_werror_flag" ||
8854 <         test ! -s conftest.err
8855 <       } && test -s conftest.$ac_objext; then
8856 <  ac_header_compiler=yes
8857 < else
8858 <  echo "$as_me: failed program was:" >&5
8859 < sed 's/^/| /' conftest.$ac_ext >&5
8860 <
8861 <        ac_header_compiler=no
8862 < fi
8863 <
8864 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
8865 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8866 < echo "${ECHO_T}$ac_header_compiler" >&6; }
8867 <
8868 < # Is the header present?
8869 < { echo "$as_me:$LINENO: checking $ac_header presence" >&5
8870 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
8871 < cat >conftest.$ac_ext <<_ACEOF
8872 < /* confdefs.h.  */
8873 < _ACEOF
8874 < cat confdefs.h >>conftest.$ac_ext
8875 < cat >>conftest.$ac_ext <<_ACEOF
8876 < /* end confdefs.h.  */
8877 < #include <$ac_header>
8878 < _ACEOF
8879 < if { (ac_try="$ac_cpp conftest.$ac_ext"
8880 < case "(($ac_try" in
8881 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8882 <  *) ac_try_echo=$ac_try;;
8883 < esac
8884 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8885 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
8886 <  ac_status=$?
8887 <  grep -v '^ *+' conftest.er1 >conftest.err
8888 <  rm -rf conftest.er1
8889 <  cat conftest.err >&5
8890 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8891 <  (exit $ac_status); } >/dev/null && {
8892 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
8893 <         test ! -s conftest.err
8894 <       }; then
8895 <  ac_header_preproc=yes
8896 < else
8897 <  echo "$as_me: failed program was:" >&5
8898 < sed 's/^/| /' conftest.$ac_ext >&5
8899 <
8900 <  ac_header_preproc=no
8901 < fi
8902 <
8903 < rm -rf conftest.err conftest.$ac_ext
8904 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8905 < echo "${ECHO_T}$ac_header_preproc" >&6; }
8906 <
8907 < # So?  What about this header?
8908 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8909 <  yes:no: )
8910 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8911 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8912 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8913 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8914 <    ac_header_preproc=yes
8915 <    ;;
8916 <  no:yes:* )
8917 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8918 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8919 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8920 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8921 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8922 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8923 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8924 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8925 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8926 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8927 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8928 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8929 <    ( cat <<\_ASBOX
8930 < ## ------------------------------ ##
8931 < ## Report this to gezelter@nd.edu ##
8932 < ## ------------------------------ ##
8933 < _ASBOX
8934 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
8935 <    ;;
8936 < esac
8937 < { echo "$as_me:$LINENO: checking for $ac_header" >&5
8938 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
8939 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
8940 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8941 < else
8942 <  eval "$as_ac_Header=\$ac_header_preproc"
8943 < fi
8944 < ac_res=`eval echo '${'$as_ac_Header'}'`
8945 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
8946 < echo "${ECHO_T}$ac_res" >&6; }
8947 <
8948 < fi
8949 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
8950 <  cat >>confdefs.h <<_ACEOF
8951 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8952 < _ACEOF
8953 <
8954 < fi
8955 <
8956 < done
8957 <
8958 < { echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8959 < echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6; }
8960 < if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8961 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8962 < else
8963 <  if test "$cross_compiling" = yes; then
8964 <  ac_cv_func_malloc_0_nonnull=no
8965 < else
8966 <  cat >conftest.$ac_ext <<_ACEOF
8967 < /* confdefs.h.  */
8968 < _ACEOF
8969 < cat confdefs.h >>conftest.$ac_ext
8970 < cat >>conftest.$ac_ext <<_ACEOF
8971 < /* end confdefs.h.  */
8972 < #if defined STDC_HEADERS || defined HAVE_STDLIB_H
8973 < # include <stdlib.h>
8974 < #else
8975 < char *malloc ();
8976 < #endif
8977 <
8978 < #ifdef FC_DUMMY_MAIN
8979 < #ifndef FC_DUMMY_MAIN_EQ_F77
8980 < #  ifdef __cplusplus
8981 <     extern "C"
8982 < #  endif
8983 <   int FC_DUMMY_MAIN() { return 1; }
8984 < #endif
8985 < #endif
8986 < int
8987 < main ()
8988 < {
8989 < return ! malloc (0);
8990 <  ;
8991 <  return 0;
8992 < }
8993 < _ACEOF
8994 < rm -rf conftest$ac_exeext
8995 < if { (ac_try="$ac_link"
8996 < case "(($ac_try" in
8997 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8998 <  *) ac_try_echo=$ac_try;;
8999 < esac
9000 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9001 <  (eval "$ac_link") 2>&5
9002 <  ac_status=$?
9003 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9004 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9005 <  { (case "(($ac_try" in
9006 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9007 <  *) ac_try_echo=$ac_try;;
9008 < esac
9009 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9010 <  (eval "$ac_try") 2>&5
9011 <  ac_status=$?
9012 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9013 <  (exit $ac_status); }; }; then
9014 <  ac_cv_func_malloc_0_nonnull=yes
9015 < else
9016 <  echo "$as_me: program exited with status $ac_status" >&5
9017 < echo "$as_me: failed program was:" >&5
9018 < sed 's/^/| /' conftest.$ac_ext >&5
9019 <
9020 < ( exit $ac_status )
9021 < ac_cv_func_malloc_0_nonnull=no
9022 < fi
9023 < rm -rf core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9024 < fi
9025 <
9026 <
9027 < fi
9028 < { echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
9029 < echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6; }
9030 < if test $ac_cv_func_malloc_0_nonnull = yes; then
9031 <
9032 < cat >>confdefs.h <<\_ACEOF
9033 < #define HAVE_MALLOC 1
9034 < _ACEOF
9035 <
9036 < else
9037 <  cat >>confdefs.h <<\_ACEOF
9038 < #define HAVE_MALLOC 0
9039 < _ACEOF
9040 <
9041 <   case " $LIBOBJS " in
9042 <  *" malloc.$ac_objext "* ) ;;
9043 <  *) LIBOBJS="$LIBOBJS malloc.$ac_objext"
9044 < ;;
9045 < esac
9046 <
9047 <
9048 < cat >>confdefs.h <<\_ACEOF
9049 < #define malloc rpl_malloc
9050 < _ACEOF
9051 <
9052 < fi
9053 <
9054 <
9055 <
9056 < { echo "$as_me:$LINENO: checking for working memcmp" >&5
9057 < echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6; }
9058 < if test "${ac_cv_func_memcmp_working+set}" = set; then
9059 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9060 < else
9061 <  if test "$cross_compiling" = yes; then
9062 <  ac_cv_func_memcmp_working=no
9063 < else
9064 <  cat >conftest.$ac_ext <<_ACEOF
9065 < /* confdefs.h.  */
9066 < _ACEOF
9067 < cat confdefs.h >>conftest.$ac_ext
9068 < cat >>conftest.$ac_ext <<_ACEOF
9069 < /* end confdefs.h.  */
9070 < $ac_includes_default
9071 < #ifdef FC_DUMMY_MAIN
9072 < #ifndef FC_DUMMY_MAIN_EQ_F77
9073 < #  ifdef __cplusplus
9074 <     extern "C"
9075 < #  endif
9076 <   int FC_DUMMY_MAIN() { return 1; }
9077 < #endif
9078 < #endif
9079 < int
9080 < main ()
9081 < {
9082 <
9083 <  /* Some versions of memcmp are not 8-bit clean.  */
9084 <  char c0 = '\100', c1 = '\200', c2 = '\201';
9085 <  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
9086 <    return 1;
9087 <
9088 <  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
9089 <     or more and with at least one buffer not starting on a 4-byte boundary.
9090 <     William Lewis provided this test program.   */
9091 <  {
9092 <    char foo[21];
9093 <    char bar[21];
9094 <    int i;
9095 <    for (i = 0; i < 4; i++)
9096 <      {
9097 <        char *a = foo + i;
9098 <        char *b = bar + i;
9099 <        strcpy (a, "--------01111111");
9100 <        strcpy (b, "--------10000000");
9101 <        if (memcmp (a, b, 16) >= 0)
9102 <          return 1;
9103 <      }
9104 <    return 0;
9105 <  }
9106 <
9107 <  ;
9108 <  return 0;
9109 < }
9110 < _ACEOF
9111 < rm -rf conftest$ac_exeext
9112 < if { (ac_try="$ac_link"
9113 < case "(($ac_try" in
9114 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9115 <  *) ac_try_echo=$ac_try;;
9116 < esac
9117 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9118 <  (eval "$ac_link") 2>&5
9119 <  ac_status=$?
9120 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9121 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9122 <  { (case "(($ac_try" in
9123 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9124 <  *) ac_try_echo=$ac_try;;
9125 < esac
9126 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9127 <  (eval "$ac_try") 2>&5
9128 <  ac_status=$?
9129 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9130 <  (exit $ac_status); }; }; then
9131 <  ac_cv_func_memcmp_working=yes
9132 < else
9133 <  echo "$as_me: program exited with status $ac_status" >&5
9134 < echo "$as_me: failed program was:" >&5
9135 < sed 's/^/| /' conftest.$ac_ext >&5
9136 <
9137 < ( exit $ac_status )
9138 < ac_cv_func_memcmp_working=no
9139 < fi
9140 < rm -rf core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9141 < fi
9142 <
9143 <
9144 < fi
9145 < { echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
9146 < echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6; }
9147 < test $ac_cv_func_memcmp_working = no && case " $LIBOBJS " in
9148 <  *" memcmp.$ac_objext "* ) ;;
9149 <  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext"
9150 < ;;
9151 < esac
9152 <
9153 <
9154 <
9155 < for ac_header in stdlib.h
9156 < do
9157 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9158 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
9159 <  { echo "$as_me:$LINENO: checking for $ac_header" >&5
9160 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
9161 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
9162 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9163 < fi
9164 < ac_res=`eval echo '${'$as_ac_Header'}'`
9165 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
9166 < echo "${ECHO_T}$ac_res" >&6; }
9167 < else
9168 <  # Is the header compilable?
9169 < { echo "$as_me:$LINENO: checking $ac_header usability" >&5
9170 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
9171 < cat >conftest.$ac_ext <<_ACEOF
9172 < /* confdefs.h.  */
9173 < _ACEOF
9174 < cat confdefs.h >>conftest.$ac_ext
9175 < cat >>conftest.$ac_ext <<_ACEOF
9176 < /* end confdefs.h.  */
9177 < $ac_includes_default
9178 < #include <$ac_header>
9179 < _ACEOF
9180 < rm -rf conftest.$ac_objext
9181 < if { (ac_try="$ac_compile"
9182 < case "(($ac_try" in
9183 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9184 <  *) ac_try_echo=$ac_try;;
9185 < esac
9186 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9187 <  (eval "$ac_compile") 2>conftest.er1
9188 <  ac_status=$?
9189 <  grep -v '^ *+' conftest.er1 >conftest.err
9190 <  rm -f conftest.er1
9191 <  cat conftest.err >&5
9192 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9193 <  (exit $ac_status); } && {
9194 <         test -z "$ac_c_werror_flag" ||
9195 <         test ! -s conftest.err
9196 <       } && test -s conftest.$ac_objext; then
9197 <  ac_header_compiler=yes
9198 < else
9199 <  echo "$as_me: failed program was:" >&5
9200 < sed 's/^/| /' conftest.$ac_ext >&5
9201 <
9202 <        ac_header_compiler=no
9203 < fi
9204 <
9205 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
9206 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9207 < echo "${ECHO_T}$ac_header_compiler" >&6; }
9208 <
9209 < # Is the header present?
9210 < { echo "$as_me:$LINENO: checking $ac_header presence" >&5
9211 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
9212 < cat >conftest.$ac_ext <<_ACEOF
9213 < /* confdefs.h.  */
9214 < _ACEOF
9215 < cat confdefs.h >>conftest.$ac_ext
9216 < cat >>conftest.$ac_ext <<_ACEOF
9217 < /* end confdefs.h.  */
9218 < #include <$ac_header>
9219 < _ACEOF
9220 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9221 < case "(($ac_try" in
9222 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9223 <  *) ac_try_echo=$ac_try;;
9224 < esac
9225 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9226 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9227 <  ac_status=$?
9228 <  grep -v '^ *+' conftest.er1 >conftest.err
9229 <  rm -f conftest.er1
9230 <  cat conftest.err >&5
9231 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9232 <  (exit $ac_status); } >/dev/null && {
9233 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
9234 <         test ! -s conftest.err
9235 <       }; then
9236 <  ac_header_preproc=yes
9237 < else
9238 <  echo "$as_me: failed program was:" >&5
9239 < sed 's/^/| /' conftest.$ac_ext >&5
9240 <
9241 <  ac_header_preproc=no
9242 < fi
9243 <
9244 < rm -rf conftest.err conftest.$ac_ext
9245 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9246 < echo "${ECHO_T}$ac_header_preproc" >&6; }
9247 <
9248 < # So?  What about this header?
9249 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9250 <  yes:no: )
9251 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9252 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9253 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9254 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9255 <    ac_header_preproc=yes
9256 <    ;;
9257 <  no:yes:* )
9258 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9259 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9260 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9261 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9262 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9263 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9264 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9265 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9266 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9267 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9268 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9269 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9270 <    ( cat <<\_ASBOX
9271 < ## ------------------------------ ##
9272 < ## Report this to gezelter@nd.edu ##
9273 < ## ------------------------------ ##
9274 < _ASBOX
9275 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
9276 <    ;;
9277 < esac
9278 < { echo "$as_me:$LINENO: checking for $ac_header" >&5
9279 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
9280 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
9281 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9282 < else
9283 <  eval "$as_ac_Header=\$ac_header_preproc"
9284 < fi
9285 < ac_res=`eval echo '${'$as_ac_Header'}'`
9286 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
9287 < echo "${ECHO_T}$ac_res" >&6; }
9288 <
9289 < fi
9290 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
9291 <  cat >>confdefs.h <<_ACEOF
9292 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9293 < _ACEOF
9294 <
9295 < fi
9296 <
9297 < done
9298 <
9299 < { echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
9300 < echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6; }
9301 < if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
9302 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9303 < else
9304 <  if test "$cross_compiling" = yes; then
9305 <  ac_cv_func_realloc_0_nonnull=no
9306 < else
9307 <  cat >conftest.$ac_ext <<_ACEOF
9308 < /* confdefs.h.  */
9309 < _ACEOF
9310 < cat confdefs.h >>conftest.$ac_ext
9311 < cat >>conftest.$ac_ext <<_ACEOF
9312 < /* end confdefs.h.  */
9313 < #if defined STDC_HEADERS || defined HAVE_STDLIB_H
9314 < # include <stdlib.h>
9315 < #else
9316 < char *realloc ();
9317 < #endif
9318 <
9319 < #ifdef FC_DUMMY_MAIN
9320 < #ifndef FC_DUMMY_MAIN_EQ_F77
9321 < #  ifdef __cplusplus
9322 <     extern "C"
9323 < #  endif
9324 <   int FC_DUMMY_MAIN() { return 1; }
9325 < #endif
9326 < #endif
9327 < int
9328 < main ()
9329 < {
9330 < return ! realloc (0, 0);
9331 <  ;
9332 <  return 0;
9333 < }
9334 < _ACEOF
9335 < rm -rf conftest$ac_exeext
9336 < if { (ac_try="$ac_link"
9337 < case "(($ac_try" in
9338 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9339 <  *) ac_try_echo=$ac_try;;
9340 < esac
9341 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9342 <  (eval "$ac_link") 2>&5
9343 <  ac_status=$?
9344 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9345 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9346 <  { (case "(($ac_try" in
9347 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9348 <  *) ac_try_echo=$ac_try;;
9349 < esac
9350 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9351 <  (eval "$ac_try") 2>&5
9352 <  ac_status=$?
9353 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9354 <  (exit $ac_status); }; }; then
9355 <  ac_cv_func_realloc_0_nonnull=yes
9356 < else
9357 <  echo "$as_me: program exited with status $ac_status" >&5
9358 < echo "$as_me: failed program was:" >&5
9359 < sed 's/^/| /' conftest.$ac_ext >&5
9360 <
9361 < ( exit $ac_status )
9362 < ac_cv_func_realloc_0_nonnull=no
9363 < fi
9364 < rm -rf core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9365 < fi
9366 <
9367 <
9368 < fi
9369 < { echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
9370 < echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6; }
9371 < if test $ac_cv_func_realloc_0_nonnull = yes; then
9372 <
9373 < cat >>confdefs.h <<\_ACEOF
9374 < #define HAVE_REALLOC 1
9375 < _ACEOF
9376 <
9377 < else
9378 <  cat >>confdefs.h <<\_ACEOF
9379 < #define HAVE_REALLOC 0
9380 < _ACEOF
9381 <
9382 <   case " $LIBOBJS " in
9383 <  *" realloc.$ac_objext "* ) ;;
9384 <  *) LIBOBJS="$LIBOBJS realloc.$ac_objext"
9385 < ;;
9386 < esac
9387 <
9388 <
9389 < cat >>confdefs.h <<\_ACEOF
9390 < #define realloc rpl_realloc
9391 < _ACEOF
9392 <
9393 < fi
9394 <
9395 <
9396 <
9397 <
9398 <
9399 < for ac_header in sys/select.h sys/socket.h
9400 < do
9401 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9402 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
9403 <  { echo "$as_me:$LINENO: checking for $ac_header" >&5
9404 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
9405 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
9406 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9407 < fi
9408 < ac_res=`eval echo '${'$as_ac_Header'}'`
9409 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
9410 < echo "${ECHO_T}$ac_res" >&6; }
9411 < else
9412 <  # Is the header compilable?
9413 < { echo "$as_me:$LINENO: checking $ac_header usability" >&5
9414 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
9415 < cat >conftest.$ac_ext <<_ACEOF
9416 < /* confdefs.h.  */
9417 < _ACEOF
9418 < cat confdefs.h >>conftest.$ac_ext
9419 < cat >>conftest.$ac_ext <<_ACEOF
9420 < /* end confdefs.h.  */
9421 < $ac_includes_default
9422 < #include <$ac_header>
9423 < _ACEOF
9424 < rm -rf conftest.$ac_objext
9425 < if { (ac_try="$ac_compile"
9426 < case "(($ac_try" in
9427 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9428 <  *) ac_try_echo=$ac_try;;
9429 < esac
9430 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9431 <  (eval "$ac_compile") 2>conftest.er1
9432 <  ac_status=$?
9433 <  grep -v '^ *+' conftest.er1 >conftest.err
9434 <  rm -f conftest.er1
9435 <  cat conftest.err >&5
9436 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9437 <  (exit $ac_status); } && {
9438 <         test -z "$ac_c_werror_flag" ||
9439 <         test ! -s conftest.err
9440 <       } && test -s conftest.$ac_objext; then
9441 <  ac_header_compiler=yes
9442 < else
9443 <  echo "$as_me: failed program was:" >&5
9444 < sed 's/^/| /' conftest.$ac_ext >&5
9445 <
9446 <        ac_header_compiler=no
9447 < fi
9448 <
9449 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
9450 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9451 < echo "${ECHO_T}$ac_header_compiler" >&6; }
9452 <
9453 < # Is the header present?
9454 < { echo "$as_me:$LINENO: checking $ac_header presence" >&5
9455 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
9456 < cat >conftest.$ac_ext <<_ACEOF
9457 < /* confdefs.h.  */
9458 < _ACEOF
9459 < cat confdefs.h >>conftest.$ac_ext
9460 < cat >>conftest.$ac_ext <<_ACEOF
9461 < /* end confdefs.h.  */
9462 < #include <$ac_header>
9463 < _ACEOF
9464 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9465 < case "(($ac_try" in
9466 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9467 <  *) ac_try_echo=$ac_try;;
9468 < esac
9469 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9470 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9471 <  ac_status=$?
9472 <  grep -v '^ *+' conftest.er1 >conftest.err
9473 <  rm -f conftest.er1
9474 <  cat conftest.err >&5
9475 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9476 <  (exit $ac_status); } >/dev/null && {
9477 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
9478 <         test ! -s conftest.err
9479 <       }; then
9480 <  ac_header_preproc=yes
9481 < else
9482 <  echo "$as_me: failed program was:" >&5
9483 < sed 's/^/| /' conftest.$ac_ext >&5
9484 <
9485 <  ac_header_preproc=no
9486 < fi
9487 <
9488 < rm -rf conftest.err conftest.$ac_ext
9489 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9490 < echo "${ECHO_T}$ac_header_preproc" >&6; }
9491 <
9492 < # So?  What about this header?
9493 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9494 <  yes:no: )
9495 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9496 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9497 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9498 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9499 <    ac_header_preproc=yes
9500 <    ;;
9501 <  no:yes:* )
9502 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9503 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9504 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9505 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9506 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9507 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9508 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9509 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9510 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9511 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9512 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9513 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9514 <    ( cat <<\_ASBOX
9515 < ## ------------------------------ ##
9516 < ## Report this to gezelter@nd.edu ##
9517 < ## ------------------------------ ##
9518 < _ASBOX
9519 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
9520 <    ;;
9521 < esac
9522 < { echo "$as_me:$LINENO: checking for $ac_header" >&5
9523 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
9524 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
9525 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9526 < else
9527 <  eval "$as_ac_Header=\$ac_header_preproc"
9528 < fi
9529 < ac_res=`eval echo '${'$as_ac_Header'}'`
9530 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
9531 < echo "${ECHO_T}$ac_res" >&6; }
9532 <
9533 < fi
9534 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
9535 <  cat >>confdefs.h <<_ACEOF
9536 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9537 < _ACEOF
9538 <
9539 < fi
9540 <
9541 < done
9542 <
9543 < { echo "$as_me:$LINENO: checking types of arguments for select" >&5
9544 < echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6; }
9545 < if test "${ac_cv_func_select_args+set}" = set; then
9546 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9547 < else
9548 <  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
9549 < for ac_arg1 in 'int' 'size_t' 'unsigned long int' 'unsigned int'; do
9550 <  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
9551 <   cat >conftest.$ac_ext <<_ACEOF
9552 < /* confdefs.h.  */
9553 < _ACEOF
9554 < cat confdefs.h >>conftest.$ac_ext
9555 < cat >>conftest.$ac_ext <<_ACEOF
9556 < /* end confdefs.h.  */
9557 < $ac_includes_default
9558 < #ifdef HAVE_SYS_SELECT_H
9559 < # include <sys/select.h>
9560 < #endif
9561 < #ifdef HAVE_SYS_SOCKET_H
9562 < # include <sys/socket.h>
9563 < #endif
9564 <
9565 < #ifdef FC_DUMMY_MAIN
9566 < #ifndef FC_DUMMY_MAIN_EQ_F77
9567 < #  ifdef __cplusplus
9568 <     extern "C"
9569 < #  endif
9570 <   int FC_DUMMY_MAIN() { return 1; }
9571 < #endif
9572 < #endif
9573 < int
9574 < main ()
9575 < {
9576 < extern int select ($ac_arg1,
9577 <                                            $ac_arg234, $ac_arg234, $ac_arg234,
9578 <                                            $ac_arg5);
9579 <  ;
9580 <  return 0;
9581 < }
9582 < _ACEOF
9583 < rm -rf conftest.$ac_objext
9584 < if { (ac_try="$ac_compile"
9585 < case "(($ac_try" in
9586 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9587 <  *) ac_try_echo=$ac_try;;
9588 < esac
9589 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9590 <  (eval "$ac_compile") 2>conftest.er1
9591 <  ac_status=$?
9592 <  grep -v '^ *+' conftest.er1 >conftest.err
9593 <  rm -f conftest.er1
9594 <  cat conftest.err >&5
9595 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9596 <  (exit $ac_status); } && {
9597 <         test -z "$ac_c_werror_flag" ||
9598 <         test ! -s conftest.err
9599 <       } && test -s conftest.$ac_objext; then
9600 <  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
9601 < else
9602 <  echo "$as_me: failed program was:" >&5
9603 < sed 's/^/| /' conftest.$ac_ext >&5
9604 <
9605 <
9606 < fi
9607 <
9608 < rm -rf core conftest.err conftest.$ac_objext conftest.$ac_ext
9609 <  done
9610 < done
9611 < done
9612 < # Provide a safe default value.
9613 < : ${ac_cv_func_select_args='int,int *,struct timeval *'}
9614 <
9615 < fi
9616 < { echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
9617 < echo "${ECHO_T}$ac_cv_func_select_args" >&6; }
9618 < ac_save_IFS=$IFS; IFS=','
9619 < set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
9620 < IFS=$ac_save_IFS
9621 < shift
9622 <
9623 < cat >>confdefs.h <<_ACEOF
9624 < #define SELECT_TYPE_ARG1 $1
9625 < _ACEOF
9626 <
9627 <
9628 < cat >>confdefs.h <<_ACEOF
9629 < #define SELECT_TYPE_ARG234 ($2)
9630 < _ACEOF
9631 <
9632 <
9633 < cat >>confdefs.h <<_ACEOF
9634 < #define SELECT_TYPE_ARG5 ($3)
9635 < _ACEOF
9636 <
9637 < rm -rf conftest*
9638 <
9639 <
9640 < for ac_func in strftime
9641 < do
9642 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9643 < { echo "$as_me:$LINENO: checking for $ac_func" >&5
9644 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
9645 < if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
9646 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9647 < else
9648 <  cat >conftest.$ac_ext <<_ACEOF
9649 < /* confdefs.h.  */
9650 < _ACEOF
9651 < cat confdefs.h >>conftest.$ac_ext
9652 < cat >>conftest.$ac_ext <<_ACEOF
9653 < /* end confdefs.h.  */
9654 < /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9655 <   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9656 < #define $ac_func innocuous_$ac_func
9657 <
9658 < /* System header to define __stub macros and hopefully few prototypes,
9659 <    which can conflict with char $ac_func (); below.
9660 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9661 <    <limits.h> exists even on freestanding compilers.  */
9662 <
9663 < #ifdef __STDC__
9664 < # include <limits.h>
9665 < #else
9666 < # include <assert.h>
9667 < #endif
9668 <
9669 < #undef $ac_func
9670 <
9671 < /* Override any GCC internal prototype to avoid an error.
9672 <   Use char because int might match the return type of a GCC
9673 <   builtin and then its argument prototype would still apply.  */
9674 < #ifdef __cplusplus
9675 < extern "C"
9676 < #endif
9677 < char $ac_func ();
9678 < /* The GNU C library defines this for functions which it implements
9679 <    to always fail with ENOSYS.  Some functions are actually named
9680 <    something starting with __ and the normal name is an alias.  */
9681 < #if defined __stub_$ac_func || defined __stub___$ac_func
9682 < choke me
9683 < #endif
9684 <
9685 < #ifdef FC_DUMMY_MAIN
9686 < #ifndef FC_DUMMY_MAIN_EQ_F77
9687 < #  ifdef __cplusplus
9688 <     extern "C"
9689 < #  endif
9690 <   int FC_DUMMY_MAIN() { return 1; }
9691 < #endif
9692 < #endif
9693 < int
9694 < main ()
9695 < {
9696 < return $ac_func ();
9697 <  ;
9698 <  return 0;
9699 < }
9700 < _ACEOF
9701 < rm -rf conftest.$ac_objext conftest$ac_exeext
9702 < if { (ac_try="$ac_link"
9703 < case "(($ac_try" in
9704 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9705 <  *) ac_try_echo=$ac_try;;
9706 < esac
9707 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9708 <  (eval "$ac_link") 2>conftest.er1
9709 <  ac_status=$?
9710 <  grep -v '^ *+' conftest.er1 >conftest.err
9711 <  rm -f conftest.er1
9712 <  cat conftest.err >&5
9713 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9714 <  (exit $ac_status); } && {
9715 <         test -z "$ac_c_werror_flag" ||
9716 <         test ! -s conftest.err
9717 <       } && test -s conftest$ac_exeext &&
9718 <       $as_test_x conftest$ac_exeext; then
9719 <  eval "$as_ac_var=yes"
9720 < else
9721 <  echo "$as_me: failed program was:" >&5
9722 < sed 's/^/| /' conftest.$ac_ext >&5
9723 <
9724 <        eval "$as_ac_var=no"
9725 < fi
9726 <
9727 < rm -rf core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
9728 <      conftest$ac_exeext conftest.$ac_ext
9729 < fi
9730 < ac_res=`eval echo '${'$as_ac_var'}'`
9731 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
9732 < echo "${ECHO_T}$ac_res" >&6; }
9733 < if test `eval echo '${'$as_ac_var'}'` = yes; then
9734 <  cat >>confdefs.h <<_ACEOF
9735 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9736 < _ACEOF
9737 <
9738 < else
9739 <  # strftime is in -lintl on SCO UNIX.
9740 < { echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9741 < echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6; }
9742 < if test "${ac_cv_lib_intl_strftime+set}" = set; then
9743 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9744 < else
9745 <  ac_check_lib_save_LIBS=$LIBS
9746 < LIBS="-lintl  $LIBS"
9747 < cat >conftest.$ac_ext <<_ACEOF
9748 < /* confdefs.h.  */
9749 < _ACEOF
9750 < cat confdefs.h >>conftest.$ac_ext
9751 < cat >>conftest.$ac_ext <<_ACEOF
9752 < /* end confdefs.h.  */
9753 <
9754 < /* Override any GCC internal prototype to avoid an error.
9755 <   Use char because int might match the return type of a GCC
9756 <   builtin and then its argument prototype would still apply.  */
9757 < #ifdef __cplusplus
9758 < extern "C"
9759 < #endif
9760 < char strftime ();
9761 < #ifdef FC_DUMMY_MAIN
9762 < #ifndef FC_DUMMY_MAIN_EQ_F77
9763 < #  ifdef __cplusplus
9764 <     extern "C"
9765 < #  endif
9766 <   int FC_DUMMY_MAIN() { return 1; }
9767 < #endif
9768 < #endif
9769 < int
9770 < main ()
9771 < {
9772 < return strftime ();
9773 <  ;
9774 <  return 0;
9775 < }
9776 < _ACEOF
9777 < rm -rf conftest.$ac_objext conftest$ac_exeext
9778 < if { (ac_try="$ac_link"
9779 < case "(($ac_try" in
9780 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9781 <  *) ac_try_echo=$ac_try;;
9782 < esac
9783 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9784 <  (eval "$ac_link") 2>conftest.er1
9785 <  ac_status=$?
9786 <  grep -v '^ *+' conftest.er1 >conftest.err
9787 <  rm -f conftest.er1
9788 <  cat conftest.err >&5
9789 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9790 <  (exit $ac_status); } && {
9791 <         test -z "$ac_c_werror_flag" ||
9792 <         test ! -s conftest.err
9793 <       } && test -s conftest$ac_exeext &&
9794 <       $as_test_x conftest$ac_exeext; then
9795 <  ac_cv_lib_intl_strftime=yes
9796 < else
9797 <  echo "$as_me: failed program was:" >&5
9798 < sed 's/^/| /' conftest.$ac_ext >&5
9799 <
9800 <        ac_cv_lib_intl_strftime=no
9801 < fi
9802 <
9803 < rm -rf core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
9804 <      conftest$ac_exeext conftest.$ac_ext
9805 < LIBS=$ac_check_lib_save_LIBS
9806 < fi
9807 < { echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9808 < echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6; }
9809 < if test $ac_cv_lib_intl_strftime = yes; then
9810 <  cat >>confdefs.h <<\_ACEOF
9811 < #define HAVE_STRFTIME 1
9812 < _ACEOF
9813 <
9814 < LIBS="-lintl $LIBS"
9815 < fi
9816 <
9817 < fi
9818 < done
9819 <
9820 < { echo "$as_me:$LINENO: checking for working strtod" >&5
9821 < echo $ECHO_N "checking for working strtod... $ECHO_C" >&6; }
9822 < if test "${ac_cv_func_strtod+set}" = set; then
9823 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9824 < else
9825 <  if test "$cross_compiling" = yes; then
9826 <  ac_cv_func_strtod=no
9827 < else
9828 <  cat >conftest.$ac_ext <<_ACEOF
9829 < /* confdefs.h.  */
9830 < _ACEOF
9831 < cat confdefs.h >>conftest.$ac_ext
9832 < cat >>conftest.$ac_ext <<_ACEOF
9833 < /* end confdefs.h.  */
9834 <
9835 < $ac_includes_default
9836 < #ifndef strtod
9837 < double strtod ();
9838 < #endif
9839 < int
9840 < main()
9841 < {
9842 <  {
9843 <    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9844 <    char *string = " +69";
9845 <    char *term;
9846 <    double value;
9847 <    value = strtod (string, &term);
9848 <    if (value != 69 || term != (string + 4))
9849 <      return 1;
9850 <  }
9851 <
9852 <  {
9853 <    /* Under Solaris 2.4, strtod returns the wrong value for the
9854 <       terminating character under some conditions.  */
9855 <    char *string = "NaN";
9856 <    char *term;
9857 <    strtod (string, &term);
9858 <    if (term != string && *(term - 1) == 0)
9859 <      return 1;
9860 <  }
9861 <  return 0;
9862 < }
9863 <
9864 < _ACEOF
9865 < rm -f conftest$ac_exeext
9866 < if { (ac_try="$ac_link"
9867 < case "(($ac_try" in
9868 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9869 <  *) ac_try_echo=$ac_try;;
9870 < esac
9871 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9872 <  (eval "$ac_link") 2>&5
9873 <  ac_status=$?
9874 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9875 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9876 <  { (case "(($ac_try" in
9877 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9878 <  *) ac_try_echo=$ac_try;;
9879 < esac
9880 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9881 <  (eval "$ac_try") 2>&5
9882 <  ac_status=$?
9883 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9884 <  (exit $ac_status); }; }; then
9885 <  ac_cv_func_strtod=yes
9886 < else
9887 <  echo "$as_me: program exited with status $ac_status" >&5
9888 < echo "$as_me: failed program was:" >&5
9889 < sed 's/^/| /' conftest.$ac_ext >&5
9890 <
9891 < ( exit $ac_status )
9892 < ac_cv_func_strtod=no
9893 < fi
9894 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9895 < fi
9896 <
9897 <
9898 < fi
9899 < { echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9900 < echo "${ECHO_T}$ac_cv_func_strtod" >&6; }
9901 < if test $ac_cv_func_strtod = no; then
9902 <  case " $LIBOBJS " in
9903 <  *" strtod.$ac_objext "* ) ;;
9904 <  *) LIBOBJS="$LIBOBJS strtod.$ac_objext"
9905 < ;;
9906 < esac
9907 <
9908 < { echo "$as_me:$LINENO: checking for pow" >&5
9909 < echo $ECHO_N "checking for pow... $ECHO_C" >&6; }
9910 < if test "${ac_cv_func_pow+set}" = set; then
9911 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9912 < else
9913 <  cat >conftest.$ac_ext <<_ACEOF
9914 < /* confdefs.h.  */
9915 < _ACEOF
9916 < cat confdefs.h >>conftest.$ac_ext
9917 < cat >>conftest.$ac_ext <<_ACEOF
9918 < /* end confdefs.h.  */
9919 < /* Define pow to an innocuous variant, in case <limits.h> declares pow.
9920 <   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9921 < #define pow innocuous_pow
9922 <
9923 < /* System header to define __stub macros and hopefully few prototypes,
9924 <    which can conflict with char pow (); below.
9925 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9926 <    <limits.h> exists even on freestanding compilers.  */
9927 <
9928 < #ifdef __STDC__
9929 < # include <limits.h>
9930 < #else
9931 < # include <assert.h>
9932 < #endif
9933 <
9934 < #undef pow
9935 <
9936 < /* Override any GCC internal prototype to avoid an error.
9937 <   Use char because int might match the return type of a GCC
9938 <   builtin and then its argument prototype would still apply.  */
9939 < #ifdef __cplusplus
9940 < extern "C"
9941 < #endif
9942 < char pow ();
9943 < /* The GNU C library defines this for functions which it implements
9944 <    to always fail with ENOSYS.  Some functions are actually named
9945 <    something starting with __ and the normal name is an alias.  */
9946 < #if defined __stub_pow || defined __stub___pow
9947 < choke me
9948 < #endif
9949 <
9950 < #ifdef FC_DUMMY_MAIN
9951 < #ifndef FC_DUMMY_MAIN_EQ_F77
9952 < #  ifdef __cplusplus
9953 <     extern "C"
9954 < #  endif
9955 <   int FC_DUMMY_MAIN() { return 1; }
9956 < #endif
9957 < #endif
9958 < int
9959 < main ()
9960 < {
9961 < return pow ();
9962 <  ;
9963 <  return 0;
9964 < }
9965 < _ACEOF
9966 < rm -f conftest.$ac_objext conftest$ac_exeext
9967 < if { (ac_try="$ac_link"
9968 < case "(($ac_try" in
9969 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9970 <  *) ac_try_echo=$ac_try;;
9971 < esac
9972 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9973 <  (eval "$ac_link") 2>conftest.er1
9974 <  ac_status=$?
9975 <  grep -v '^ *+' conftest.er1 >conftest.err
9976 <  rm -f conftest.er1
9977 <  cat conftest.err >&5
9978 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9979 <  (exit $ac_status); } && {
9980 <         test -z "$ac_c_werror_flag" ||
9981 <         test ! -s conftest.err
9982 <       } && test -s conftest$ac_exeext &&
9983 <       $as_test_x conftest$ac_exeext; then
9984 <  ac_cv_func_pow=yes
9985 < else
9986 <  echo "$as_me: failed program was:" >&5
9987 < sed 's/^/| /' conftest.$ac_ext >&5
9988 <
9989 <        ac_cv_func_pow=no
9990 < fi
9991 <
9992 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
9993 <      conftest$ac_exeext conftest.$ac_ext
9994 < fi
9995 < { echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9996 < echo "${ECHO_T}$ac_cv_func_pow" >&6; }
9997 <
9998 < if test $ac_cv_func_pow = no; then
9999 <  { echo "$as_me:$LINENO: checking for pow in -lm" >&5
10000 < echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6; }
10001 < if test "${ac_cv_lib_m_pow+set}" = set; then
10002 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10003 < else
10004 <  ac_check_lib_save_LIBS=$LIBS
10005 < LIBS="-lm  $LIBS"
10006 < cat >conftest.$ac_ext <<_ACEOF
10007 < /* confdefs.h.  */
10008 < _ACEOF
10009 < cat confdefs.h >>conftest.$ac_ext
10010 < cat >>conftest.$ac_ext <<_ACEOF
10011 < /* end confdefs.h.  */
10012 <
10013 < /* Override any GCC internal prototype to avoid an error.
10014 <   Use char because int might match the return type of a GCC
10015 <   builtin and then its argument prototype would still apply.  */
10016 < #ifdef __cplusplus
10017 < extern "C"
10018 < #endif
10019 < char pow ();
10020 < #ifdef FC_DUMMY_MAIN
10021 < #ifndef FC_DUMMY_MAIN_EQ_F77
10022 < #  ifdef __cplusplus
10023 <     extern "C"
10024 < #  endif
10025 <   int FC_DUMMY_MAIN() { return 1; }
10026 < #endif
10027 < #endif
10028 < int
10029 < main ()
10030 < {
10031 < return pow ();
10032 <  ;
10033 <  return 0;
10034 < }
10035 < _ACEOF
10036 < rm -f conftest.$ac_objext conftest$ac_exeext
10037 < if { (ac_try="$ac_link"
10038 < case "(($ac_try" in
10039 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10040 <  *) ac_try_echo=$ac_try;;
10041 < esac
10042 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10043 <  (eval "$ac_link") 2>conftest.er1
10044 <  ac_status=$?
10045 <  grep -v '^ *+' conftest.er1 >conftest.err
10046 <  rm -f conftest.er1
10047 <  cat conftest.err >&5
10048 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10049 <  (exit $ac_status); } && {
10050 <         test -z "$ac_c_werror_flag" ||
10051 <         test ! -s conftest.err
10052 <       } && test -s conftest$ac_exeext &&
10053 <       $as_test_x conftest$ac_exeext; then
10054 <  ac_cv_lib_m_pow=yes
10055 < else
10056 <  echo "$as_me: failed program was:" >&5
10057 < sed 's/^/| /' conftest.$ac_ext >&5
10058 <
10059 <        ac_cv_lib_m_pow=no
10060 < fi
10061 <
10062 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
10063 <      conftest$ac_exeext conftest.$ac_ext
10064 < LIBS=$ac_check_lib_save_LIBS
10065 < fi
10066 < { echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
10067 < echo "${ECHO_T}$ac_cv_lib_m_pow" >&6; }
10068 < if test $ac_cv_lib_m_pow = yes; then
10069 <  POW_LIB=-lm
10070 < else
10071 <  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
10072 < echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
10073 < fi
10074 <
10075 < fi
10076 <
10077 < fi
10078 <
10079 <
10080 <
10081 <
10082 <
10083 <
10084 <
10085 <
10086 <
10087 <
10088 <
10089 <
10090 <
10091 <
10092 <
10093 <
10094 <
10095 <
10096 <
10097 <
10098 <
10099 <
10100 <
10101 <
10102 <
10103 <
10104 <
10105 <
10106 < for ac_func in floor getpagesize gettimeofday memchr memmove memset pow pstat_getdynamic pstat_getstatic rint select snprintf sranddev sqrt strcasecmp strchr strdup stricmp strncasecmp strnicmp strrchr strstr strtol sysmp getsysinfo sysctl table
10107 < do
10108 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10109 < { echo "$as_me:$LINENO: checking for $ac_func" >&5
10110 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
10111 < if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
10112 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10113 < else
10114 <  cat >conftest.$ac_ext <<_ACEOF
10115 < /* confdefs.h.  */
10116 < _ACEOF
10117 < cat confdefs.h >>conftest.$ac_ext
10118 < cat >>conftest.$ac_ext <<_ACEOF
10119 < /* end confdefs.h.  */
10120 < /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10121 <   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10122 < #define $ac_func innocuous_$ac_func
10123 <
10124 < /* System header to define __stub macros and hopefully few prototypes,
10125 <    which can conflict with char $ac_func (); below.
10126 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10127 <    <limits.h> exists even on freestanding compilers.  */
10128 <
10129 < #ifdef __STDC__
10130 < # include <limits.h>
10131 < #else
10132 < # include <assert.h>
10133 < #endif
10134 <
10135 < #undef $ac_func
10136 <
10137 < /* Override any GCC internal prototype to avoid an error.
10138 <   Use char because int might match the return type of a GCC
10139 <   builtin and then its argument prototype would still apply.  */
10140 < #ifdef __cplusplus
10141 < extern "C"
10142 < #endif
10143 < char $ac_func ();
10144 < /* The GNU C library defines this for functions which it implements
10145 <    to always fail with ENOSYS.  Some functions are actually named
10146 <    something starting with __ and the normal name is an alias.  */
10147 < #if defined __stub_$ac_func || defined __stub___$ac_func
10148 < choke me
10149 < #endif
10150 <
10151 < #ifdef FC_DUMMY_MAIN
10152 < #ifndef FC_DUMMY_MAIN_EQ_F77
10153 < #  ifdef __cplusplus
10154 <     extern "C"
10155 < #  endif
10156 <   int FC_DUMMY_MAIN() { return 1; }
10157 < #endif
10158 < #endif
10159 < int
10160 < main ()
10161 < {
10162 < return $ac_func ();
10163 <  ;
10164 <  return 0;
10165 < }
10166 < _ACEOF
10167 < rm -f conftest.$ac_objext conftest$ac_exeext
10168 < if { (ac_try="$ac_link"
10169 < case "(($ac_try" in
10170 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10171 <  *) ac_try_echo=$ac_try;;
10172 < esac
10173 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10174 <  (eval "$ac_link") 2>conftest.er1
10175 <  ac_status=$?
10176 <  grep -v '^ *+' conftest.er1 >conftest.err
10177 <  rm -f conftest.er1
10178 <  cat conftest.err >&5
10179 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10180 <  (exit $ac_status); } && {
10181 <         test -z "$ac_c_werror_flag" ||
10182 <         test ! -s conftest.err
10183 <       } && test -s conftest$ac_exeext &&
10184 <       $as_test_x conftest$ac_exeext; then
10185 <  eval "$as_ac_var=yes"
10186 < else
10187 <  echo "$as_me: failed program was:" >&5
10188 < sed 's/^/| /' conftest.$ac_ext >&5
10189 <
10190 <        eval "$as_ac_var=no"
10191 < fi
10192 <
10193 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
10194 <      conftest$ac_exeext conftest.$ac_ext
10195 < fi
10196 < ac_res=`eval echo '${'$as_ac_var'}'`
10197 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
10198 < echo "${ECHO_T}$ac_res" >&6; }
10199 < if test `eval echo '${'$as_ac_var'}'` = yes; then
10200 <  cat >>confdefs.h <<_ACEOF
10201 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10202 < _ACEOF
10203 <
10204 < fi
10205 < done
10206 <
10207 <
10208 < # special check for _system_configuration because AIX <4.3.2 do not
10209 < # contain the `physmem' member.
10210 < { echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
10211 < echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6; }
10212 < cat >conftest.$ac_ext <<_ACEOF
10213 < /* confdefs.h.  */
10214 < _ACEOF
10215 < cat confdefs.h >>conftest.$ac_ext
10216 < cat >>conftest.$ac_ext <<_ACEOF
10217 < /* end confdefs.h.  */
10218 < #include <sys/systemcfg.h>
10219 < #ifdef FC_DUMMY_MAIN
10220 < #ifndef FC_DUMMY_MAIN_EQ_F77
10221 < #  ifdef __cplusplus
10222 <     extern "C"
10223 < #  endif
10224 <   int FC_DUMMY_MAIN() { return 1; }
10225 < #endif
10226 < #endif
10227 < int
10228 < main ()
10229 < {
10230 < double x = _system_configuration.physmem;
10231 <  ;
10232 <  return 0;
10233 < }
10234 < _ACEOF
10235 < rm -f conftest.$ac_objext
10236 < if { (ac_try="$ac_compile"
10237 < case "(($ac_try" in
10238 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10239 <  *) ac_try_echo=$ac_try;;
10240 < esac
10241 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10242 <  (eval "$ac_compile") 2>conftest.er1
10243 <  ac_status=$?
10244 <  grep -v '^ *+' conftest.er1 >conftest.err
10245 <  rm -f conftest.er1
10246 <  cat conftest.err >&5
10247 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10248 <  (exit $ac_status); } && {
10249 <         test -z "$ac_c_werror_flag" ||
10250 <         test ! -s conftest.err
10251 <       } && test -s conftest.$ac_objext; then
10252 <  { echo "$as_me:$LINENO: result: yes" >&5
10253 < echo "${ECHO_T}yes" >&6; }
10254 <
10255 < cat >>confdefs.h <<\_ACEOF
10256 < #define HAVE__SYSTEM_CONFIGURATION 1
10257 < _ACEOF
10258 <
10259 < else
10260 <  echo "$as_me: failed program was:" >&5
10261 < sed 's/^/| /' conftest.$ac_ext >&5
10262 <
10263 <        { echo "$as_me:$LINENO: result: no" >&5
10264 < echo "${ECHO_T}no" >&6; }
10265 < fi
10266 <
10267 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10268 <
10269 <  # clean out junk possibly left behind by a previous configuration
10270 <  rm -f src/getopt.h
10271 <  # Check for getopt_long support
10272 <
10273 < for ac_header in getopt.h
10274 < do
10275 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10276 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10277 <  { echo "$as_me:$LINENO: checking for $ac_header" >&5
10278 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
10279 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10280 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10281 < fi
10282 < ac_res=`eval echo '${'$as_ac_Header'}'`
10283 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
10284 < echo "${ECHO_T}$ac_res" >&6; }
10285 < else
10286 <  # Is the header compilable?
10287 < { echo "$as_me:$LINENO: checking $ac_header usability" >&5
10288 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
10289 < cat >conftest.$ac_ext <<_ACEOF
10290 < /* confdefs.h.  */
10291 < _ACEOF
10292 < cat confdefs.h >>conftest.$ac_ext
10293 < cat >>conftest.$ac_ext <<_ACEOF
10294 < /* end confdefs.h.  */
10295 < $ac_includes_default
10296 < #include <$ac_header>
10297 < _ACEOF
10298 < rm -f conftest.$ac_objext
10299 < if { (ac_try="$ac_compile"
10300 < case "(($ac_try" in
10301 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10302 <  *) ac_try_echo=$ac_try;;
10303 < esac
10304 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10305 <  (eval "$ac_compile") 2>conftest.er1
10306 <  ac_status=$?
10307 <  grep -v '^ *+' conftest.er1 >conftest.err
10308 <  rm -f conftest.er1
10309 <  cat conftest.err >&5
10310 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10311 <  (exit $ac_status); } && {
10312 <         test -z "$ac_c_werror_flag" ||
10313 <         test ! -s conftest.err
10314 <       } && test -s conftest.$ac_objext; then
10315 <  ac_header_compiler=yes
10316 < else
10317 <  echo "$as_me: failed program was:" >&5
10318 < sed 's/^/| /' conftest.$ac_ext >&5
10319 <
10320 <        ac_header_compiler=no
10321 < fi
10322 <
10323 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10324 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10325 < echo "${ECHO_T}$ac_header_compiler" >&6; }
10326 <
10327 < # Is the header present?
10328 < { echo "$as_me:$LINENO: checking $ac_header presence" >&5
10329 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
10330 < cat >conftest.$ac_ext <<_ACEOF
10331 < /* confdefs.h.  */
10332 < _ACEOF
10333 < cat confdefs.h >>conftest.$ac_ext
10334 < cat >>conftest.$ac_ext <<_ACEOF
10335 < /* end confdefs.h.  */
10336 < #include <$ac_header>
10337 < _ACEOF
10338 < if { (ac_try="$ac_cpp conftest.$ac_ext"
10339 < case "(($ac_try" in
10340 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10341 <  *) ac_try_echo=$ac_try;;
10342 < esac
10343 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10344 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
10345 <  ac_status=$?
10346 <  grep -v '^ *+' conftest.er1 >conftest.err
10347 <  rm -f conftest.er1
10348 <  cat conftest.err >&5
10349 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10350 <  (exit $ac_status); } >/dev/null && {
10351 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
10352 <         test ! -s conftest.err
10353 <       }; then
10354 <  ac_header_preproc=yes
10355 < else
10356 <  echo "$as_me: failed program was:" >&5
10357 < sed 's/^/| /' conftest.$ac_ext >&5
10358 <
10359 <  ac_header_preproc=no
10360 < fi
10361 <
10362 < rm -f conftest.err conftest.$ac_ext
10363 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10364 < echo "${ECHO_T}$ac_header_preproc" >&6; }
10365 <
10366 < # So?  What about this header?
10367 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10368 <  yes:no: )
10369 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10370 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10371 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10372 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10373 <    ac_header_preproc=yes
10374 <    ;;
10375 <  no:yes:* )
10376 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10377 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10378 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10379 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10380 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10381 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10382 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10383 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10384 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10385 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10386 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10387 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10388 <    ( cat <<\_ASBOX
10389 < ## ------------------------------ ##
10390 < ## Report this to gezelter@nd.edu ##
10391 < ## ------------------------------ ##
10392 < _ASBOX
10393 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
10394 <    ;;
10395 < esac
10396 < { echo "$as_me:$LINENO: checking for $ac_header" >&5
10397 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
10398 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10399 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10400 < else
10401 <  eval "$as_ac_Header=\$ac_header_preproc"
10402 < fi
10403 < ac_res=`eval echo '${'$as_ac_Header'}'`
10404 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
10405 < echo "${ECHO_T}$ac_res" >&6; }
10406 <
10407 < fi
10408 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
10409 <  cat >>confdefs.h <<_ACEOF
10410 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10411 < _ACEOF
10412 <
10413 < fi
10414 <
10415 < done
10416 <
10417 <
10418 < for ac_func in getopt_long
10419 < do
10420 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10421 < { echo "$as_me:$LINENO: checking for $ac_func" >&5
10422 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
10423 < if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
10424 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10425 < else
10426 <  cat >conftest.$ac_ext <<_ACEOF
10427 < /* confdefs.h.  */
10428 < _ACEOF
10429 < cat confdefs.h >>conftest.$ac_ext
10430 < cat >>conftest.$ac_ext <<_ACEOF
10431 < /* end confdefs.h.  */
10432 < /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10433 <   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10434 < #define $ac_func innocuous_$ac_func
10435 <
10436 < /* System header to define __stub macros and hopefully few prototypes,
10437 <    which can conflict with char $ac_func (); below.
10438 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10439 <    <limits.h> exists even on freestanding compilers.  */
10440 <
10441 < #ifdef __STDC__
10442 < # include <limits.h>
10443 < #else
10444 < # include <assert.h>
10445 < #endif
10446 <
10447 < #undef $ac_func
10448 <
10449 < /* Override any GCC internal prototype to avoid an error.
10450 <   Use char because int might match the return type of a GCC
10451 <   builtin and then its argument prototype would still apply.  */
10452 < #ifdef __cplusplus
10453 < extern "C"
10454 < #endif
10455 < char $ac_func ();
10456 < /* The GNU C library defines this for functions which it implements
10457 <    to always fail with ENOSYS.  Some functions are actually named
10458 <    something starting with __ and the normal name is an alias.  */
10459 < #if defined __stub_$ac_func || defined __stub___$ac_func
10460 < choke me
10461 < #endif
10462 <
10463 < #ifdef FC_DUMMY_MAIN
10464 < #ifndef FC_DUMMY_MAIN_EQ_F77
10465 < #  ifdef __cplusplus
10466 <     extern "C"
10467 < #  endif
10468 <   int FC_DUMMY_MAIN() { return 1; }
10469 < #endif
10470 < #endif
10471 < int
10472 < main ()
10473 < {
10474 < return $ac_func ();
10475 <  ;
10476 <  return 0;
10477 < }
10478 < _ACEOF
10479 < rm -f conftest.$ac_objext conftest$ac_exeext
10480 < if { (ac_try="$ac_link"
10481 < case "(($ac_try" in
10482 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10483 <  *) ac_try_echo=$ac_try;;
10484 < esac
10485 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10486 <  (eval "$ac_link") 2>conftest.er1
10487 <  ac_status=$?
10488 <  grep -v '^ *+' conftest.er1 >conftest.err
10489 <  rm -f conftest.er1
10490 <  cat conftest.err >&5
10491 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10492 <  (exit $ac_status); } && {
10493 <         test -z "$ac_c_werror_flag" ||
10494 <         test ! -s conftest.err
10495 <       } && test -s conftest$ac_exeext &&
10496 <       $as_test_x conftest$ac_exeext; then
10497 <  eval "$as_ac_var=yes"
10498 < else
10499 <  echo "$as_me: failed program was:" >&5
10500 < sed 's/^/| /' conftest.$ac_ext >&5
10501 <
10502 <        eval "$as_ac_var=no"
10503 < fi
10504 <
10505 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
10506 <      conftest$ac_exeext conftest.$ac_ext
10507 < fi
10508 < ac_res=`eval echo '${'$as_ac_var'}'`
10509 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
10510 < echo "${ECHO_T}$ac_res" >&6; }
10511 < if test `eval echo '${'$as_ac_var'}'` = yes; then
10512 <  cat >>confdefs.h <<_ACEOF
10513 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10514 < _ACEOF
10515 <
10516 < else
10517 <  # FreeBSD has a gnugetopt library for this
10518 <    { echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
10519 < echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6; }
10520 < if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
10521 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10522 < else
10523 <  ac_check_lib_save_LIBS=$LIBS
10524 < LIBS="-lgnugetopt  $LIBS"
10525 < cat >conftest.$ac_ext <<_ACEOF
10526 < /* confdefs.h.  */
10527 < _ACEOF
10528 < cat confdefs.h >>conftest.$ac_ext
10529 < cat >>conftest.$ac_ext <<_ACEOF
10530 < /* end confdefs.h.  */
10531 <
10532 < /* Override any GCC internal prototype to avoid an error.
10533 <   Use char because int might match the return type of a GCC
10534 <   builtin and then its argument prototype would still apply.  */
10535 < #ifdef __cplusplus
10536 < extern "C"
10537 < #endif
10538 < char getopt_long ();
10539 < #ifdef FC_DUMMY_MAIN
10540 < #ifndef FC_DUMMY_MAIN_EQ_F77
10541 < #  ifdef __cplusplus
10542 <     extern "C"
10543 < #  endif
10544 <   int FC_DUMMY_MAIN() { return 1; }
10545 < #endif
10546 < #endif
10547 < int
10548 < main ()
10549 < {
10550 < return getopt_long ();
10551 <  ;
10552 <  return 0;
10553 < }
10554 < _ACEOF
10555 < rm -f conftest.$ac_objext conftest$ac_exeext
10556 < if { (ac_try="$ac_link"
10557 < case "(($ac_try" in
10558 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10559 <  *) ac_try_echo=$ac_try;;
10560 < esac
10561 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10562 <  (eval "$ac_link") 2>conftest.er1
10563 <  ac_status=$?
10564 <  grep -v '^ *+' conftest.er1 >conftest.err
10565 <  rm -f conftest.er1
10566 <  cat conftest.err >&5
10567 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10568 <  (exit $ac_status); } && {
10569 <         test -z "$ac_c_werror_flag" ||
10570 <         test ! -s conftest.err
10571 <       } && test -s conftest$ac_exeext &&
10572 <       $as_test_x conftest$ac_exeext; then
10573 <  ac_cv_lib_gnugetopt_getopt_long=yes
10574 < else
10575 <  echo "$as_me: failed program was:" >&5
10576 < sed 's/^/| /' conftest.$ac_ext >&5
10577 <
10578 <        ac_cv_lib_gnugetopt_getopt_long=no
10579 < fi
10580 <
10581 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
10582 <      conftest$ac_exeext conftest.$ac_ext
10583 < LIBS=$ac_check_lib_save_LIBS
10584 < fi
10585 < { echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
10586 < echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6; }
10587 < if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
10588 <  cat >>confdefs.h <<\_ACEOF
10589 < #define HAVE_GETOPT_LONG 1
10590 < _ACEOF
10591 <
10592 < else
10593 <  # use the GNU replacement
10594 <      case " $LIBOBJS " in
10595 <  *" getopt.$ac_objext "* ) ;;
10596 <  *) LIBOBJS="$LIBOBJS getopt.$ac_objext"
10597 < ;;
10598 < esac
10599 <
10600 <      case " $LIBOBJS " in
10601 <  *" getopt1.$ac_objext "* ) ;;
10602 <  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext"
10603 < ;;
10604 < esac
10605 <
10606 <      ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
10607 <
10608 < fi
10609 <
10610 < fi
10611 < done
10612 <
10613 <
10614 < ac_ext=cpp
10615 < ac_cpp='$CXXCPP $CPPFLAGS'
10616 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10617 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10618 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10619 <
10620 <
10621 < { echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
10622 < echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6; }
10623 < if test "${ac_cv_cxx_namespaces+set}" = set; then
10624 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10625 < else
10626 <
10627 < ac_ext=cpp
10628 < ac_cpp='$CXXCPP $CPPFLAGS'
10629 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10630 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10631 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10632 <
10633 < cat >conftest.$ac_ext <<_ACEOF
10634 < /* confdefs.h.  */
10635 < _ACEOF
10636 < cat confdefs.h >>conftest.$ac_ext
10637 < cat >>conftest.$ac_ext <<_ACEOF
10638 < /* end confdefs.h.  */
10639 < namespace Outer { namespace Inner { int i = 0; }}
10640 < #ifdef FC_DUMMY_MAIN
10641 < #ifndef FC_DUMMY_MAIN_EQ_F77
10642 < #  ifdef __cplusplus
10643 <     extern "C"
10644 < #  endif
10645 <   int FC_DUMMY_MAIN() { return 1; }
10646 < #endif
10647 < #endif
10648 < int
10649 < main ()
10650 < {
10651 < using namespace Outer::Inner; return i;
10652 <  ;
10653 <  return 0;
10654 < }
10655 < _ACEOF
10656 < rm -f conftest.$ac_objext
10657 < if { (ac_try="$ac_compile"
10658 < case "(($ac_try" in
10659 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10660 <  *) ac_try_echo=$ac_try;;
10661 < esac
10662 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10663 <  (eval "$ac_compile") 2>conftest.er1
10664 <  ac_status=$?
10665 <  grep -v '^ *+' conftest.er1 >conftest.err
10666 <  rm -f conftest.er1
10667 <  cat conftest.err >&5
10668 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10669 <  (exit $ac_status); } && {
10670 <         test -z "$ac_cxx_werror_flag" ||
10671 <         test ! -s conftest.err
10672 <       } && test -s conftest.$ac_objext; then
10673 <  ac_cv_cxx_namespaces=yes
10674 < else
10675 <  echo "$as_me: failed program was:" >&5
10676 < sed 's/^/| /' conftest.$ac_ext >&5
10677 <
10678 <        ac_cv_cxx_namespaces=no
10679 < fi
10680 <
10681 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10682 < ac_ext=cpp
10683 < ac_cpp='$CXXCPP $CPPFLAGS'
10684 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10685 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10686 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10687 <
10688 <
10689 < fi
10690 < { echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10691 < echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6; }
10692 < if test "$ac_cv_cxx_namespaces" = yes; then
10693 <
10694 < cat >>confdefs.h <<\_ACEOF
10695 < #define HAVE_NAMESPACES
10696 < _ACEOF
10697 <
10698 < fi
10699 <
10700 < ac_ext=cpp
10701 < ac_cpp='$CXXCPP $CPPFLAGS'
10702 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10703 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10704 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10705 < { echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10706 < echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6; }
10707 < if test -z "$CXXCPP"; then
10708 <  if test "${ac_cv_prog_CXXCPP+set}" = set; then
10709 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10710 < else
10711 <      # Double quotes because CXXCPP needs to be expanded
10712 <    for CXXCPP in "$CXX -E" "/lib/cpp"
10713 <    do
10714 <      ac_preproc_ok=false
10715 < for ac_cxx_preproc_warn_flag in '' yes
10716 < do
10717 <  # Use a header file that comes with gcc, so configuring glibc
10718 <  # with a fresh cross-compiler works.
10719 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10720 <  # <limits.h> exists even on freestanding compilers.
10721 <  # On the NeXT, cc -E runs the code through the compiler's parser,
10722 <  # not just through cpp. "Syntax error" is here to catch this case.
10723 <  cat >conftest.$ac_ext <<_ACEOF
10724 < /* confdefs.h.  */
10725 < _ACEOF
10726 < cat confdefs.h >>conftest.$ac_ext
10727 < cat >>conftest.$ac_ext <<_ACEOF
10728 < /* end confdefs.h.  */
10729 < #ifdef __STDC__
10730 < # include <limits.h>
10731 < #else
10732 < # include <assert.h>
10733 < #endif
10734 <                     Syntax error
10735 < _ACEOF
10736 < if { (ac_try="$ac_cpp conftest.$ac_ext"
10737 < case "(($ac_try" in
10738 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10739 <  *) ac_try_echo=$ac_try;;
10740 < esac
10741 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10742 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
10743 <  ac_status=$?
10744 <  grep -v '^ *+' conftest.er1 >conftest.err
10745 <  rm -f conftest.er1
10746 <  cat conftest.err >&5
10747 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10748 <  (exit $ac_status); } >/dev/null && {
10749 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
10750 <         test ! -s conftest.err
10751 <       }; then
10752 <  :
10753 < else
10754 <  echo "$as_me: failed program was:" >&5
10755 < sed 's/^/| /' conftest.$ac_ext >&5
10756 <
10757 <  # Broken: fails on valid input.
10758 < continue
10759 < fi
10760 <
10761 < rm -f conftest.err conftest.$ac_ext
10762 <
10763 <  # OK, works on sane cases.  Now check whether nonexistent headers
10764 <  # can be detected and how.
10765 <  cat >conftest.$ac_ext <<_ACEOF
10766 < /* confdefs.h.  */
10767 < _ACEOF
10768 < cat confdefs.h >>conftest.$ac_ext
10769 < cat >>conftest.$ac_ext <<_ACEOF
10770 < /* end confdefs.h.  */
10771 < #include <ac_nonexistent.h>
10772 < _ACEOF
10773 < if { (ac_try="$ac_cpp conftest.$ac_ext"
10774 < case "(($ac_try" in
10775 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10776 <  *) ac_try_echo=$ac_try;;
10777 < esac
10778 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10779 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
10780 <  ac_status=$?
10781 <  grep -v '^ *+' conftest.er1 >conftest.err
10782 <  rm -f conftest.er1
10783 <  cat conftest.err >&5
10784 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10785 <  (exit $ac_status); } >/dev/null && {
10786 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
10787 <         test ! -s conftest.err
10788 <       }; then
10789 <  # Broken: success on invalid input.
10790 < continue
10791 < else
10792 <  echo "$as_me: failed program was:" >&5
10793 < sed 's/^/| /' conftest.$ac_ext >&5
10794 <
10795 <  # Passes both tests.
10796 < ac_preproc_ok=:
10797 < break
10798 < fi
10799 <
10800 < rm -f conftest.err conftest.$ac_ext
10801 <
10802 < done
10803 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10804 < rm -f conftest.err conftest.$ac_ext
10805 < if $ac_preproc_ok; then
10806 <  break
10807 < fi
10808 <
10809 <    done
10810 <    ac_cv_prog_CXXCPP=$CXXCPP
10811 <
10812 < fi
10813 <  CXXCPP=$ac_cv_prog_CXXCPP
10814 < else
10815 <  ac_cv_prog_CXXCPP=$CXXCPP
10816 < fi
10817 < { echo "$as_me:$LINENO: result: $CXXCPP" >&5
10818 < echo "${ECHO_T}$CXXCPP" >&6; }
10819 < ac_preproc_ok=false
10820 < for ac_cxx_preproc_warn_flag in '' yes
10821 < do
10822 <  # Use a header file that comes with gcc, so configuring glibc
10823 <  # with a fresh cross-compiler works.
10824 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10825 <  # <limits.h> exists even on freestanding compilers.
10826 <  # On the NeXT, cc -E runs the code through the compiler's parser,
10827 <  # not just through cpp. "Syntax error" is here to catch this case.
10828 <  cat >conftest.$ac_ext <<_ACEOF
10829 < /* confdefs.h.  */
10830 < _ACEOF
10831 < cat confdefs.h >>conftest.$ac_ext
10832 < cat >>conftest.$ac_ext <<_ACEOF
10833 < /* end confdefs.h.  */
10834 < #ifdef __STDC__
10835 < # include <limits.h>
10836 < #else
10837 < # include <assert.h>
10838 < #endif
10839 <                     Syntax error
10840 < _ACEOF
10841 < if { (ac_try="$ac_cpp conftest.$ac_ext"
10842 < case "(($ac_try" in
10843 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10844 <  *) ac_try_echo=$ac_try;;
10845 < esac
10846 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10847 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
10848 <  ac_status=$?
10849 <  grep -v '^ *+' conftest.er1 >conftest.err
10850 <  rm -f conftest.er1
10851 <  cat conftest.err >&5
10852 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10853 <  (exit $ac_status); } >/dev/null && {
10854 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
10855 <         test ! -s conftest.err
10856 <       }; then
10857 <  :
10858 < else
10859 <  echo "$as_me: failed program was:" >&5
10860 < sed 's/^/| /' conftest.$ac_ext >&5
10861 <
10862 <  # Broken: fails on valid input.
10863 < continue
10864 < fi
10865 <
10866 < rm -f conftest.err conftest.$ac_ext
10867 <
10868 <  # OK, works on sane cases.  Now check whether nonexistent headers
10869 <  # can be detected and how.
10870 <  cat >conftest.$ac_ext <<_ACEOF
10871 < /* confdefs.h.  */
10872 < _ACEOF
10873 < cat confdefs.h >>conftest.$ac_ext
10874 < cat >>conftest.$ac_ext <<_ACEOF
10875 < /* end confdefs.h.  */
10876 < #include <ac_nonexistent.h>
10877 < _ACEOF
10878 < if { (ac_try="$ac_cpp conftest.$ac_ext"
10879 < case "(($ac_try" in
10880 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10881 <  *) ac_try_echo=$ac_try;;
10882 < esac
10883 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10884 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
10885 <  ac_status=$?
10886 <  grep -v '^ *+' conftest.er1 >conftest.err
10887 <  rm -f conftest.er1
10888 <  cat conftest.err >&5
10889 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10890 <  (exit $ac_status); } >/dev/null && {
10891 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
10892 <         test ! -s conftest.err
10893 <       }; then
10894 <  # Broken: success on invalid input.
10895 < continue
10896 < else
10897 <  echo "$as_me: failed program was:" >&5
10898 < sed 's/^/| /' conftest.$ac_ext >&5
10899 <
10900 <  # Passes both tests.
10901 < ac_preproc_ok=:
10902 < break
10903 < fi
10904 <
10905 < rm -f conftest.err conftest.$ac_ext
10906 <
10907 < done
10908 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10909 < rm -f conftest.err conftest.$ac_ext
10910 < if $ac_preproc_ok; then
10911 <  :
10912 < else
10913 <  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10914 < See \`config.log' for more details." >&5
10915 < echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10916 < See \`config.log' for more details." >&2;}
10917 <   { (exit 1); exit 1; }; }
10918 < fi
10919 <
10920 < ac_ext=cpp
10921 < ac_cpp='$CXXCPP $CPPFLAGS'
10922 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10923 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10924 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10925 <
10926 <
10927 < { echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10928 < echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6; }
10929 < if test "${ac_cv_cxx_have_stl+set}" = set; then
10930 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10931 < else
10932 <
10933 <
10934 < ac_ext=cpp
10935 < ac_cpp='$CXXCPP $CPPFLAGS'
10936 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10937 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10938 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10939 <
10940 < cat >conftest.$ac_ext <<_ACEOF
10941 < /* confdefs.h.  */
10942 < _ACEOF
10943 < cat confdefs.h >>conftest.$ac_ext
10944 < cat >>conftest.$ac_ext <<_ACEOF
10945 < /* end confdefs.h.  */
10946 < #include <list>
10947 < #include <deque>
10948 < #ifdef HAVE_NAMESPACES
10949 < using namespace std;
10950 < #endif
10951 < #ifdef FC_DUMMY_MAIN
10952 < #ifndef FC_DUMMY_MAIN_EQ_F77
10953 < #  ifdef __cplusplus
10954 <     extern "C"
10955 < #  endif
10956 <   int FC_DUMMY_MAIN() { return 1; }
10957 < #endif
10958 < #endif
10959 < int
10960 < main ()
10961 < {
10962 < list<int> x; x.push_back(5);
10963 < list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10964 <  ;
10965 <  return 0;
10966 < }
10967 < _ACEOF
10968 < rm -f conftest.$ac_objext
10969 < if { (ac_try="$ac_compile"
10970 < case "(($ac_try" in
10971 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10972 <  *) ac_try_echo=$ac_try;;
10973 < esac
10974 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10975 <  (eval "$ac_compile") 2>conftest.er1
10976 <  ac_status=$?
10977 <  grep -v '^ *+' conftest.er1 >conftest.err
10978 <  rm -f conftest.er1
10979 <  cat conftest.err >&5
10980 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10981 <  (exit $ac_status); } && {
10982 <         test -z "$ac_cxx_werror_flag" ||
10983 <         test ! -s conftest.err
10984 <       } && test -s conftest.$ac_objext; then
10985 <  ac_cv_cxx_have_stl=yes
10986 < else
10987 <  echo "$as_me: failed program was:" >&5
10988 < sed 's/^/| /' conftest.$ac_ext >&5
10989 <
10990 <        ac_cv_cxx_have_stl=no
10991 < fi
10992 <
10993 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10994 < ac_ext=cpp
10995 < ac_cpp='$CXXCPP $CPPFLAGS'
10996 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10997 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10998 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10999 <
11000 <
11001 < fi
11002 < { echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
11003 < echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6; }
11004 < if test "$ac_cv_cxx_have_stl" = yes; then
11005 <
11006 < cat >>confdefs.h <<\_ACEOF
11007 < #define HAVE_STL
11008 < _ACEOF
11009 <
11010 < fi
11011 <
11012 <
11013 <
11014 <  if test "${ac_cv_header_iostream+set}" = set; then
11015 <  { echo "$as_me:$LINENO: checking for iostream" >&5
11016 < echo $ECHO_N "checking for iostream... $ECHO_C" >&6; }
11017 < if test "${ac_cv_header_iostream+set}" = set; then
11018 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11019 < fi
11020 < { echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
11021 < echo "${ECHO_T}$ac_cv_header_iostream" >&6; }
11022 < else
11023 <  # Is the header compilable?
11024 < { echo "$as_me:$LINENO: checking iostream usability" >&5
11025 < echo $ECHO_N "checking iostream usability... $ECHO_C" >&6; }
11026 < cat >conftest.$ac_ext <<_ACEOF
11027 < /* confdefs.h.  */
11028 < _ACEOF
11029 < cat confdefs.h >>conftest.$ac_ext
11030 < cat >>conftest.$ac_ext <<_ACEOF
11031 < /* end confdefs.h.  */
11032 < $ac_includes_default
11033 < #include <iostream>
11034 < _ACEOF
11035 < rm -f conftest.$ac_objext
11036 < if { (ac_try="$ac_compile"
11037 < case "(($ac_try" in
11038 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11039 <  *) ac_try_echo=$ac_try;;
11040 < esac
11041 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11042 <  (eval "$ac_compile") 2>conftest.er1
11043 <  ac_status=$?
11044 <  grep -v '^ *+' conftest.er1 >conftest.err
11045 <  rm -f conftest.er1
11046 <  cat conftest.err >&5
11047 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11048 <  (exit $ac_status); } && {
11049 <         test -z "$ac_cxx_werror_flag" ||
11050 <         test ! -s conftest.err
11051 <       } && test -s conftest.$ac_objext; then
11052 <  ac_header_compiler=yes
11053 < else
11054 <  echo "$as_me: failed program was:" >&5
11055 < sed 's/^/| /' conftest.$ac_ext >&5
11056 <
11057 <        ac_header_compiler=no
11058 < fi
11059 <
11060 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11061 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11062 < echo "${ECHO_T}$ac_header_compiler" >&6; }
11063 <
11064 < # Is the header present?
11065 < { echo "$as_me:$LINENO: checking iostream presence" >&5
11066 < echo $ECHO_N "checking iostream presence... $ECHO_C" >&6; }
11067 < cat >conftest.$ac_ext <<_ACEOF
11068 < /* confdefs.h.  */
11069 < _ACEOF
11070 < cat confdefs.h >>conftest.$ac_ext
11071 < cat >>conftest.$ac_ext <<_ACEOF
11072 < /* end confdefs.h.  */
11073 < #include <iostream>
11074 < _ACEOF
11075 < if { (ac_try="$ac_cpp conftest.$ac_ext"
11076 < case "(($ac_try" in
11077 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11078 <  *) ac_try_echo=$ac_try;;
11079 < esac
11080 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11081 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
11082 <  ac_status=$?
11083 <  grep -v '^ *+' conftest.er1 >conftest.err
11084 <  rm -f conftest.er1
11085 <  cat conftest.err >&5
11086 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11087 <  (exit $ac_status); } >/dev/null && {
11088 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
11089 <         test ! -s conftest.err
11090 <       }; then
11091 <  ac_header_preproc=yes
11092 < else
11093 <  echo "$as_me: failed program was:" >&5
11094 < sed 's/^/| /' conftest.$ac_ext >&5
11095 <
11096 <  ac_header_preproc=no
11097 < fi
11098 <
11099 < rm -f conftest.err conftest.$ac_ext
11100 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11101 < echo "${ECHO_T}$ac_header_preproc" >&6; }
11102 <
11103 < # So?  What about this header?
11104 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11105 <  yes:no: )
11106 <    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
11107 < echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
11108 <    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
11109 < echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
11110 <    ac_header_preproc=yes
11111 <    ;;
11112 <  no:yes:* )
11113 <    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
11114 < echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
11115 <    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
11116 < echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
11117 <    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
11118 < echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
11119 <    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
11120 < echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
11121 <    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
11122 < echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
11123 <    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
11124 < echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
11125 <    ( cat <<\_ASBOX
11126 < ## ------------------------------ ##
11127 < ## Report this to gezelter@nd.edu ##
11128 < ## ------------------------------ ##
11129 < _ASBOX
11130 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
11131 <    ;;
11132 < esac
11133 < { echo "$as_me:$LINENO: checking for iostream" >&5
11134 < echo $ECHO_N "checking for iostream... $ECHO_C" >&6; }
11135 < if test "${ac_cv_header_iostream+set}" = set; then
11136 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11137 < else
11138 <  ac_cv_header_iostream=$ac_header_preproc
11139 < fi
11140 < { echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
11141 < echo "${ECHO_T}$ac_cv_header_iostream" >&6; }
11142 <
11143 < fi
11144 < if test $ac_cv_header_iostream = yes; then
11145 <
11146 <
11147 < cat >>confdefs.h <<\_ACEOF
11148 < #define HAVE_IOSTREAM 1
11149 < _ACEOF
11150 <
11151 <
11152 < else
11153 <
11154 <
11155 < for ac_header in iostream.h
11156 < do
11157 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11158 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11159 <  { echo "$as_me:$LINENO: checking for $ac_header" >&5
11160 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
11161 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11162 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11163 < fi
11164 < ac_res=`eval echo '${'$as_ac_Header'}'`
11165 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
11166 < echo "${ECHO_T}$ac_res" >&6; }
11167 < else
11168 <  # Is the header compilable?
11169 < { echo "$as_me:$LINENO: checking $ac_header usability" >&5
11170 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
11171 < cat >conftest.$ac_ext <<_ACEOF
11172 < /* confdefs.h.  */
11173 < _ACEOF
11174 < cat confdefs.h >>conftest.$ac_ext
11175 < cat >>conftest.$ac_ext <<_ACEOF
11176 < /* end confdefs.h.  */
11177 < $ac_includes_default
11178 < #include <$ac_header>
11179 < _ACEOF
11180 < rm -f conftest.$ac_objext
11181 < if { (ac_try="$ac_compile"
11182 < case "(($ac_try" in
11183 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11184 <  *) ac_try_echo=$ac_try;;
11185 < esac
11186 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11187 <  (eval "$ac_compile") 2>conftest.er1
11188 <  ac_status=$?
11189 <  grep -v '^ *+' conftest.er1 >conftest.err
11190 <  rm -f conftest.er1
11191 <  cat conftest.err >&5
11192 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11193 <  (exit $ac_status); } && {
11194 <         test -z "$ac_cxx_werror_flag" ||
11195 <         test ! -s conftest.err
11196 <       } && test -s conftest.$ac_objext; then
11197 <  ac_header_compiler=yes
11198 < else
11199 <  echo "$as_me: failed program was:" >&5
11200 < sed 's/^/| /' conftest.$ac_ext >&5
11201 <
11202 <        ac_header_compiler=no
11203 < fi
11204 <
11205 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11206 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11207 < echo "${ECHO_T}$ac_header_compiler" >&6; }
11208 <
11209 < # Is the header present?
11210 < { echo "$as_me:$LINENO: checking $ac_header presence" >&5
11211 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
11212 < cat >conftest.$ac_ext <<_ACEOF
11213 < /* confdefs.h.  */
11214 < _ACEOF
11215 < cat confdefs.h >>conftest.$ac_ext
11216 < cat >>conftest.$ac_ext <<_ACEOF
11217 < /* end confdefs.h.  */
11218 < #include <$ac_header>
11219 < _ACEOF
11220 < if { (ac_try="$ac_cpp conftest.$ac_ext"
11221 < case "(($ac_try" in
11222 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11223 <  *) ac_try_echo=$ac_try;;
11224 < esac
11225 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11226 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
11227 <  ac_status=$?
11228 <  grep -v '^ *+' conftest.er1 >conftest.err
11229 <  rm -f conftest.er1
11230 <  cat conftest.err >&5
11231 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11232 <  (exit $ac_status); } >/dev/null && {
11233 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
11234 <         test ! -s conftest.err
11235 <       }; then
11236 <  ac_header_preproc=yes
11237 < else
11238 <  echo "$as_me: failed program was:" >&5
11239 < sed 's/^/| /' conftest.$ac_ext >&5
11240 <
11241 <  ac_header_preproc=no
11242 < fi
11243 <
11244 < rm -f conftest.err conftest.$ac_ext
11245 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11246 < echo "${ECHO_T}$ac_header_preproc" >&6; }
11247 <
11248 < # So?  What about this header?
11249 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11250 <  yes:no: )
11251 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11252 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11253 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11254 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11255 <    ac_header_preproc=yes
11256 <    ;;
11257 <  no:yes:* )
11258 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11259 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11260 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11261 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11262 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11263 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11264 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11265 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11266 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11267 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11268 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11269 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11270 <    ( cat <<\_ASBOX
11271 < ## ------------------------------ ##
11272 < ## Report this to gezelter@nd.edu ##
11273 < ## ------------------------------ ##
11274 < _ASBOX
11275 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
11276 <    ;;
11277 < esac
11278 < { echo "$as_me:$LINENO: checking for $ac_header" >&5
11279 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
11280 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11281 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11282 < else
11283 <  eval "$as_ac_Header=\$ac_header_preproc"
11284 < fi
11285 < ac_res=`eval echo '${'$as_ac_Header'}'`
11286 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
11287 < echo "${ECHO_T}$ac_res" >&6; }
11288 <
11289 < fi
11290 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
11291 <  cat >>confdefs.h <<_ACEOF
11292 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11293 < _ACEOF
11294 <
11295 < fi
11296 <
11297 < done
11298 <
11299 <
11300 < fi
11301 <
11302 <
11303 <
11304 <
11305 <  if test "${ac_cv_header_iomanip+set}" = set; then
11306 <  { echo "$as_me:$LINENO: checking for iomanip" >&5
11307 < echo $ECHO_N "checking for iomanip... $ECHO_C" >&6; }
11308 < if test "${ac_cv_header_iomanip+set}" = set; then
11309 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11310 < fi
11311 < { echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
11312 < echo "${ECHO_T}$ac_cv_header_iomanip" >&6; }
11313 < else
11314 <  # Is the header compilable?
11315 < { echo "$as_me:$LINENO: checking iomanip usability" >&5
11316 < echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6; }
11317 < cat >conftest.$ac_ext <<_ACEOF
11318 < /* confdefs.h.  */
11319 < _ACEOF
11320 < cat confdefs.h >>conftest.$ac_ext
11321 < cat >>conftest.$ac_ext <<_ACEOF
11322 < /* end confdefs.h.  */
11323 < $ac_includes_default
11324 < #include <iomanip>
11325 < _ACEOF
11326 < rm -f conftest.$ac_objext
11327 < if { (ac_try="$ac_compile"
11328 < case "(($ac_try" in
11329 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11330 <  *) ac_try_echo=$ac_try;;
11331 < esac
11332 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11333 <  (eval "$ac_compile") 2>conftest.er1
11334 <  ac_status=$?
11335 <  grep -v '^ *+' conftest.er1 >conftest.err
11336 <  rm -f conftest.er1
11337 <  cat conftest.err >&5
11338 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11339 <  (exit $ac_status); } && {
11340 <         test -z "$ac_cxx_werror_flag" ||
11341 <         test ! -s conftest.err
11342 <       } && test -s conftest.$ac_objext; then
11343 <  ac_header_compiler=yes
11344 < else
11345 <  echo "$as_me: failed program was:" >&5
11346 < sed 's/^/| /' conftest.$ac_ext >&5
11347 <
11348 <        ac_header_compiler=no
11349 < fi
11350 <
11351 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11352 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11353 < echo "${ECHO_T}$ac_header_compiler" >&6; }
11354 <
11355 < # Is the header present?
11356 < { echo "$as_me:$LINENO: checking iomanip presence" >&5
11357 < echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6; }
11358 < cat >conftest.$ac_ext <<_ACEOF
11359 < /* confdefs.h.  */
11360 < _ACEOF
11361 < cat confdefs.h >>conftest.$ac_ext
11362 < cat >>conftest.$ac_ext <<_ACEOF
11363 < /* end confdefs.h.  */
11364 < #include <iomanip>
11365 < _ACEOF
11366 < if { (ac_try="$ac_cpp conftest.$ac_ext"
11367 < case "(($ac_try" in
11368 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11369 <  *) ac_try_echo=$ac_try;;
11370 < esac
11371 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11372 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
11373 <  ac_status=$?
11374 <  grep -v '^ *+' conftest.er1 >conftest.err
11375 <  rm -f conftest.er1
11376 <  cat conftest.err >&5
11377 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11378 <  (exit $ac_status); } >/dev/null && {
11379 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
11380 <         test ! -s conftest.err
11381 <       }; then
11382 <  ac_header_preproc=yes
11383 < else
11384 <  echo "$as_me: failed program was:" >&5
11385 < sed 's/^/| /' conftest.$ac_ext >&5
11386 <
11387 <  ac_header_preproc=no
11388 < fi
11389 <
11390 < rm -f conftest.err conftest.$ac_ext
11391 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11392 < echo "${ECHO_T}$ac_header_preproc" >&6; }
11393 <
11394 < # So?  What about this header?
11395 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11396 <  yes:no: )
11397 <    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
11398 < echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
11399 <    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
11400 < echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
11401 <    ac_header_preproc=yes
11402 <    ;;
11403 <  no:yes:* )
11404 <    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
11405 < echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
11406 <    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
11407 < echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
11408 <    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
11409 < echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
11410 <    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
11411 < echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
11412 <    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
11413 < echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
11414 <    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
11415 < echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
11416 <    ( cat <<\_ASBOX
11417 < ## ------------------------------ ##
11418 < ## Report this to gezelter@nd.edu ##
11419 < ## ------------------------------ ##
11420 < _ASBOX
11421 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
11422 <    ;;
11423 < esac
11424 < { echo "$as_me:$LINENO: checking for iomanip" >&5
11425 < echo $ECHO_N "checking for iomanip... $ECHO_C" >&6; }
11426 < if test "${ac_cv_header_iomanip+set}" = set; then
11427 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11428 < else
11429 <  ac_cv_header_iomanip=$ac_header_preproc
11430 < fi
11431 < { echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
11432 < echo "${ECHO_T}$ac_cv_header_iomanip" >&6; }
11433 <
11434 < fi
11435 < if test $ac_cv_header_iomanip = yes; then
11436 <
11437 <
11438 < cat >>confdefs.h <<\_ACEOF
11439 < #define HAVE_IOMANIP 1
11440 < _ACEOF
11441 <
11442 <
11443 < else
11444 <
11445 <
11446 < for ac_header in iomanip.h
11447 < do
11448 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11449 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11450 <  { echo "$as_me:$LINENO: checking for $ac_header" >&5
11451 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
11452 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11453 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11454 < fi
11455 < ac_res=`eval echo '${'$as_ac_Header'}'`
11456 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
11457 < echo "${ECHO_T}$ac_res" >&6; }
11458 < else
11459 <  # Is the header compilable?
11460 < { echo "$as_me:$LINENO: checking $ac_header usability" >&5
11461 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
11462 < cat >conftest.$ac_ext <<_ACEOF
11463 < /* confdefs.h.  */
11464 < _ACEOF
11465 < cat confdefs.h >>conftest.$ac_ext
11466 < cat >>conftest.$ac_ext <<_ACEOF
11467 < /* end confdefs.h.  */
11468 < $ac_includes_default
11469 < #include <$ac_header>
11470 < _ACEOF
11471 < rm -f conftest.$ac_objext
11472 < if { (ac_try="$ac_compile"
11473 < case "(($ac_try" in
11474 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11475 <  *) ac_try_echo=$ac_try;;
11476 < esac
11477 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11478 <  (eval "$ac_compile") 2>conftest.er1
11479 <  ac_status=$?
11480 <  grep -v '^ *+' conftest.er1 >conftest.err
11481 <  rm -f conftest.er1
11482 <  cat conftest.err >&5
11483 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11484 <  (exit $ac_status); } && {
11485 <         test -z "$ac_cxx_werror_flag" ||
11486 <         test ! -s conftest.err
11487 <       } && test -s conftest.$ac_objext; then
11488 <  ac_header_compiler=yes
11489 < else
11490 <  echo "$as_me: failed program was:" >&5
11491 < sed 's/^/| /' conftest.$ac_ext >&5
11492 <
11493 <        ac_header_compiler=no
11494 < fi
11495 <
11496 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11497 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11498 < echo "${ECHO_T}$ac_header_compiler" >&6; }
11499 <
11500 < # Is the header present?
11501 < { echo "$as_me:$LINENO: checking $ac_header presence" >&5
11502 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
11503 < cat >conftest.$ac_ext <<_ACEOF
11504 < /* confdefs.h.  */
11505 < _ACEOF
11506 < cat confdefs.h >>conftest.$ac_ext
11507 < cat >>conftest.$ac_ext <<_ACEOF
11508 < /* end confdefs.h.  */
11509 < #include <$ac_header>
11510 < _ACEOF
11511 < if { (ac_try="$ac_cpp conftest.$ac_ext"
11512 < case "(($ac_try" in
11513 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11514 <  *) ac_try_echo=$ac_try;;
11515 < esac
11516 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11517 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
11518 <  ac_status=$?
11519 <  grep -v '^ *+' conftest.er1 >conftest.err
11520 <  rm -f conftest.er1
11521 <  cat conftest.err >&5
11522 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11523 <  (exit $ac_status); } >/dev/null && {
11524 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
11525 <         test ! -s conftest.err
11526 <       }; then
11527 <  ac_header_preproc=yes
11528 < else
11529 <  echo "$as_me: failed program was:" >&5
11530 < sed 's/^/| /' conftest.$ac_ext >&5
11531 <
11532 <  ac_header_preproc=no
11533 < fi
11534 <
11535 < rm -f conftest.err conftest.$ac_ext
11536 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11537 < echo "${ECHO_T}$ac_header_preproc" >&6; }
11538 <
11539 < # So?  What about this header?
11540 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11541 <  yes:no: )
11542 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11543 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11544 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11545 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11546 <    ac_header_preproc=yes
11547 <    ;;
11548 <  no:yes:* )
11549 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11550 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11551 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11552 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11553 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11554 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11555 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11556 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11557 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11558 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11559 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11560 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11561 <    ( cat <<\_ASBOX
11562 < ## ------------------------------ ##
11563 < ## Report this to gezelter@nd.edu ##
11564 < ## ------------------------------ ##
11565 < _ASBOX
11566 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
11567 <    ;;
11568 < esac
11569 < { echo "$as_me:$LINENO: checking for $ac_header" >&5
11570 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
11571 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11572 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11573 < else
11574 <  eval "$as_ac_Header=\$ac_header_preproc"
11575 < fi
11576 < ac_res=`eval echo '${'$as_ac_Header'}'`
11577 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
11578 < echo "${ECHO_T}$ac_res" >&6; }
11579 <
11580 < fi
11581 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
11582 <  cat >>confdefs.h <<_ACEOF
11583 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11584 < _ACEOF
11585 <
11586 < fi
11587 <
11588 < done
11589 <
11590 <
11591 < fi
11592 <
11593 <
11594 <
11595 <
11596 < for ac_header in cmath
11597 < do
11598 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11599 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11600 <  { echo "$as_me:$LINENO: checking for $ac_header" >&5
11601 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
11602 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11603 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11604 < fi
11605 < ac_res=`eval echo '${'$as_ac_Header'}'`
11606 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
11607 < echo "${ECHO_T}$ac_res" >&6; }
11608 < else
11609 <  # Is the header compilable?
11610 < { echo "$as_me:$LINENO: checking $ac_header usability" >&5
11611 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
11612 < cat >conftest.$ac_ext <<_ACEOF
11613 < /* confdefs.h.  */
11614 < _ACEOF
11615 < cat confdefs.h >>conftest.$ac_ext
11616 < cat >>conftest.$ac_ext <<_ACEOF
11617 < /* end confdefs.h.  */
11618 < $ac_includes_default
11619 < #include <$ac_header>
11620 < _ACEOF
11621 < rm -f conftest.$ac_objext
11622 < if { (ac_try="$ac_compile"
11623 < case "(($ac_try" in
11624 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11625 <  *) ac_try_echo=$ac_try;;
11626 < esac
11627 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11628 <  (eval "$ac_compile") 2>conftest.er1
11629 <  ac_status=$?
11630 <  grep -v '^ *+' conftest.er1 >conftest.err
11631 <  rm -f conftest.er1
11632 <  cat conftest.err >&5
11633 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11634 <  (exit $ac_status); } && {
11635 <         test -z "$ac_cxx_werror_flag" ||
11636 <         test ! -s conftest.err
11637 <       } && test -s conftest.$ac_objext; then
11638 <  ac_header_compiler=yes
11639 < else
11640 <  echo "$as_me: failed program was:" >&5
11641 < sed 's/^/| /' conftest.$ac_ext >&5
11642 <
11643 <        ac_header_compiler=no
11644 < fi
11645 <
11646 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11647 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11648 < echo "${ECHO_T}$ac_header_compiler" >&6; }
11649 <
11650 < # Is the header present?
11651 < { echo "$as_me:$LINENO: checking $ac_header presence" >&5
11652 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
11653 < cat >conftest.$ac_ext <<_ACEOF
11654 < /* confdefs.h.  */
11655 < _ACEOF
11656 < cat confdefs.h >>conftest.$ac_ext
11657 < cat >>conftest.$ac_ext <<_ACEOF
11658 < /* end confdefs.h.  */
11659 < #include <$ac_header>
11660 < _ACEOF
11661 < if { (ac_try="$ac_cpp conftest.$ac_ext"
11662 < case "(($ac_try" in
11663 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11664 <  *) ac_try_echo=$ac_try;;
11665 < esac
11666 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11667 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
11668 <  ac_status=$?
11669 <  grep -v '^ *+' conftest.er1 >conftest.err
11670 <  rm -f conftest.er1
11671 <  cat conftest.err >&5
11672 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11673 <  (exit $ac_status); } >/dev/null && {
11674 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
11675 <         test ! -s conftest.err
11676 <       }; then
11677 <  ac_header_preproc=yes
11678 < else
11679 <  echo "$as_me: failed program was:" >&5
11680 < sed 's/^/| /' conftest.$ac_ext >&5
11681 <
11682 <  ac_header_preproc=no
11683 < fi
11684 <
11685 < rm -f conftest.err conftest.$ac_ext
11686 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11687 < echo "${ECHO_T}$ac_header_preproc" >&6; }
11688 <
11689 < # So?  What about this header?
11690 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11691 <  yes:no: )
11692 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11693 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11694 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11695 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11696 <    ac_header_preproc=yes
11697 <    ;;
11698 <  no:yes:* )
11699 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11700 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11701 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11702 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11703 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11704 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11705 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11706 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11707 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11708 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11709 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11710 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11711 <    ( cat <<\_ASBOX
11712 < ## ------------------------------ ##
11713 < ## Report this to gezelter@nd.edu ##
11714 < ## ------------------------------ ##
11715 < _ASBOX
11716 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
11717 <    ;;
11718 < esac
11719 < { echo "$as_me:$LINENO: checking for $ac_header" >&5
11720 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
11721 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11722 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11723 < else
11724 <  eval "$as_ac_Header=\$ac_header_preproc"
11725 < fi
11726 < ac_res=`eval echo '${'$as_ac_Header'}'`
11727 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
11728 < echo "${ECHO_T}$ac_res" >&6; }
11729 <
11730 < fi
11731 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
11732 <  cat >>confdefs.h <<_ACEOF
11733 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11734 < _ACEOF
11735 <
11736 < fi
11737 <
11738 < done
11739 <
11740 <
11741 <
11742 <
11743 <  { echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11744 < echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6; }
11745 < if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11746 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11747 < else
11748 <
11749 <      ac_cv_cxx_have_std_iostream=no
11750 <      ac_cv_cxx_need_use_std_iostream=no
11751 <      if test "x$ac_cv_cxx_namespaces" = xyes; then
11752 <
11753 <        ac_ext=cpp
11754 < ac_cpp='$CXXCPP $CPPFLAGS'
11755 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11756 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11757 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11758 <
11759 <        cat >conftest.$ac_ext <<_ACEOF
11760 < /* confdefs.h.  */
11761 < _ACEOF
11762 < cat confdefs.h >>conftest.$ac_ext
11763 < cat >>conftest.$ac_ext <<_ACEOF
11764 < /* end confdefs.h.  */
11765 <
11766 < #ifdef HAVE_IOSTREAM
11767 < #include <iostream>
11768 < #else
11769 < #include <iostream.h>
11770 < #endif
11771 <
11772 < #ifdef FC_DUMMY_MAIN
11773 < #ifndef FC_DUMMY_MAIN_EQ_F77
11774 < #  ifdef __cplusplus
11775 <     extern "C"
11776 < #  endif
11777 <   int FC_DUMMY_MAIN() { return 1; }
11778 < #endif
11779 < #endif
11780 < int
11781 < main ()
11782 < {
11783 < std::cout<<"Hello World"<<std::endl;return 0;
11784 <  ;
11785 <  return 0;
11786 < }
11787 < _ACEOF
11788 < rm -f conftest.$ac_objext
11789 < if { (ac_try="$ac_compile"
11790 < case "(($ac_try" in
11791 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11792 <  *) ac_try_echo=$ac_try;;
11793 < esac
11794 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11795 <  (eval "$ac_compile") 2>conftest.er1
11796 <  ac_status=$?
11797 <  grep -v '^ *+' conftest.er1 >conftest.err
11798 <  rm -f conftest.er1
11799 <  cat conftest.err >&5
11800 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11801 <  (exit $ac_status); } && {
11802 <         test -z "$ac_cxx_werror_flag" ||
11803 <         test ! -s conftest.err
11804 <       } && test -s conftest.$ac_objext; then
11805 <  ac_cv_cxx_have_std_iostream=yes
11806 < else
11807 <  echo "$as_me: failed program was:" >&5
11808 < sed 's/^/| /' conftest.$ac_ext >&5
11809 <
11810 <
11811 < fi
11812 <
11813 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11814 <        cat >conftest.$ac_ext <<_ACEOF
11815 < /* confdefs.h.  */
11816 < _ACEOF
11817 < cat confdefs.h >>conftest.$ac_ext
11818 < cat >>conftest.$ac_ext <<_ACEOF
11819 < /* end confdefs.h.  */
11820 <
11821 < #define __USE_STD_IOSTREAM 1
11822 < #ifdef HAVE_IOSTREAM
11823 < #include <iostream>
11824 < #else
11825 < #include <iostream.h>
11826 < #endif
11827 <
11828 < #ifdef FC_DUMMY_MAIN
11829 < #ifndef FC_DUMMY_MAIN_EQ_F77
11830 < #  ifdef __cplusplus
11831 <     extern "C"
11832 < #  endif
11833 <   int FC_DUMMY_MAIN() { return 1; }
11834 < #endif
11835 < #endif
11836 < int
11837 < main ()
11838 < {
11839 < std::cout<<"Hello World"<<std::endl;return 0;
11840 <  ;
11841 <  return 0;
11842 < }
11843 < _ACEOF
11844 < rm -f conftest.$ac_objext
11845 < if { (ac_try="$ac_compile"
11846 < case "(($ac_try" in
11847 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11848 <  *) ac_try_echo=$ac_try;;
11849 < esac
11850 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11851 <  (eval "$ac_compile") 2>conftest.er1
11852 <  ac_status=$?
11853 <  grep -v '^ *+' conftest.er1 >conftest.err
11854 <  rm -f conftest.er1
11855 <  cat conftest.err >&5
11856 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11857 <  (exit $ac_status); } && {
11858 <         test -z "$ac_cxx_werror_flag" ||
11859 <         test ! -s conftest.err
11860 <       } && test -s conftest.$ac_objext; then
11861 <  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11862 < else
11863 <  echo "$as_me: failed program was:" >&5
11864 < sed 's/^/| /' conftest.$ac_ext >&5
11865 <
11866 <
11867 < fi
11868 <
11869 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11870 <        ac_ext=cpp
11871 < ac_cpp='$CXXCPP $CPPFLAGS'
11872 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11873 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11874 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11875 <
11876 <      fi
11877 <
11878 < fi
11879 < { echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11880 < echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6; }
11881 <  if test "$ac_cv_cxx_have_std_iostream" = yes; then
11882 <
11883 < cat >>confdefs.h <<\_ACEOF
11884 < #define HAVE_STD_IOSTREAM 1
11885 < _ACEOF
11886 <
11887 <  fi
11888 <  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11889 <
11890 < cat >>confdefs.h <<\_ACEOF
11891 < #define __USE_STD_IOSTREAM 1
11892 < _ACEOF
11893 <
11894 <  fi
11895 <
11896 <
11897 <
11898 <
11899 <  { echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11900 < echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6; }
11901 < if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11902 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11903 < else
11904 <
11905 <      ac_cv_cxx_have_std_stl=no
11906 <      if test "x$ac_cv_cxx_namespaces" = xyes; then
11907 <
11908 <        ac_ext=cpp
11909 < ac_cpp='$CXXCPP $CPPFLAGS'
11910 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11911 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11912 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11913 <
11914 <        cat >conftest.$ac_ext <<_ACEOF
11915 < /* confdefs.h.  */
11916 < _ACEOF
11917 < cat confdefs.h >>conftest.$ac_ext
11918 < cat >>conftest.$ac_ext <<_ACEOF
11919 < /* end confdefs.h.  */
11920 < #include <list>
11921 <
11922 < #ifdef FC_DUMMY_MAIN
11923 < #ifndef FC_DUMMY_MAIN_EQ_F77
11924 < #  ifdef __cplusplus
11925 <     extern "C"
11926 < #  endif
11927 <   int FC_DUMMY_MAIN() { return 1; }
11928 < #endif
11929 < #endif
11930 < int
11931 < main ()
11932 < {
11933 < std::list<int> foo;return 0;
11934 <  ;
11935 <  return 0;
11936 < }
11937 < _ACEOF
11938 < rm -f conftest.$ac_objext
11939 < if { (ac_try="$ac_compile"
11940 < case "(($ac_try" in
11941 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11942 <  *) ac_try_echo=$ac_try;;
11943 < esac
11944 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11945 <  (eval "$ac_compile") 2>conftest.er1
11946 <  ac_status=$?
11947 <  grep -v '^ *+' conftest.er1 >conftest.err
11948 <  rm -f conftest.er1
11949 <  cat conftest.err >&5
11950 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11951 <  (exit $ac_status); } && {
11952 <         test -z "$ac_cxx_werror_flag" ||
11953 <         test ! -s conftest.err
11954 <       } && test -s conftest.$ac_objext; then
11955 <  ac_cv_cxx_have_std_stl=yes
11956 < else
11957 <  echo "$as_me: failed program was:" >&5
11958 < sed 's/^/| /' conftest.$ac_ext >&5
11959 <
11960 <
11961 < fi
11962 <
11963 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11964 <        ac_ext=cpp
11965 < ac_cpp='$CXXCPP $CPPFLAGS'
11966 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11967 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11968 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11969 <
11970 <      fi
11971 <
11972 < fi
11973 < { echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11974 < echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6; }
11975 <  if test "$ac_cv_cxx_have_std_stl" = yes; then
11976 <
11977 < cat >>confdefs.h <<\_ACEOF
11978 < #define HAVE_STD_STL 1
11979 < _ACEOF
11980 <
11981 <  fi
11982 <
11983 <
11984 <
11985 <  { echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11986 < echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6; }
11987 < if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11988 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11989 < else
11990 <
11991 <    ac_cv_cxx_have_fstream_attach=no
11992 <
11993 <    ac_ext=cpp
11994 < ac_cpp='$CXXCPP $CPPFLAGS'
11995 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11996 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11997 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11998 <
11999 <    cat >conftest.$ac_ext <<_ACEOF
12000 < /* confdefs.h.  */
12001 < _ACEOF
12002 < cat confdefs.h >>conftest.$ac_ext
12003 < cat >>conftest.$ac_ext <<_ACEOF
12004 < /* end confdefs.h.  */
12005 <
12006 < #ifdef HAVE_IOSTREAM
12007 < #include <fstream>
12008 < #else
12009 < #include <fstream.h>
12010 < #endif
12011 < #ifdef HAVE_STD_IOSTREAM
12012 < using namespace std;
12013 < #endif
12014 <
12015 < #ifdef FC_DUMMY_MAIN
12016 < #ifndef FC_DUMMY_MAIN_EQ_F77
12017 < #  ifdef __cplusplus
12018 <     extern "C"
12019 < #  endif
12020 <   int FC_DUMMY_MAIN() { return 1; }
12021 < #endif
12022 < #endif
12023 < int
12024 < main ()
12025 < {
12026 < int fd=0;ofstream s;s.attach(fd);
12027 <  ;
12028 <  return 0;
12029 < }
12030 < _ACEOF
12031 < rm -f conftest.$ac_objext
12032 < if { (ac_try="$ac_compile"
12033 < case "(($ac_try" in
12034 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12035 <  *) ac_try_echo=$ac_try;;
12036 < esac
12037 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12038 <  (eval "$ac_compile") 2>conftest.er1
12039 <  ac_status=$?
12040 <  grep -v '^ *+' conftest.er1 >conftest.err
12041 <  rm -f conftest.er1
12042 <  cat conftest.err >&5
12043 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12044 <  (exit $ac_status); } && {
12045 <         test -z "$ac_cxx_werror_flag" ||
12046 <         test ! -s conftest.err
12047 <       } && test -s conftest.$ac_objext; then
12048 <  ac_cv_cxx_have_fstream_attach=yes
12049 < else
12050 <  echo "$as_me: failed program was:" >&5
12051 < sed 's/^/| /' conftest.$ac_ext >&5
12052 <
12053 <
12054 < fi
12055 <
12056 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12057 <    ac_ext=cpp
12058 < ac_cpp='$CXXCPP $CPPFLAGS'
12059 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12060 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12061 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12062 <
12063 <
12064 < fi
12065 < { echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
12066 < echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6; }
12067 <  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
12068 <
12069 < cat >>confdefs.h <<\_ACEOF
12070 < #define HAVE_FSTREAM_ATTACH 1
12071 < _ACEOF
12072 <
12073 <  fi
12074 <
12075 <
12076 <
12077 <  { echo "$as_me:$LINENO: checking for fstream::open()" >&5
12078 < echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6; }
12079 < if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
12080 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12081 < else
12082 <
12083 <    ac_cv_cxx_have_fstream_open=no
12084 <    ac_cv_cxx_fstream_open_prot=no
12085 <
12086 <    ac_ext=cpp
12087 < ac_cpp='$CXXCPP $CPPFLAGS'
12088 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12089 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12090 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12091 <
12092 <    # Try with 2 parameters
12093 <    cat >conftest.$ac_ext <<_ACEOF
12094 < /* confdefs.h.  */
12095 < _ACEOF
12096 < cat confdefs.h >>conftest.$ac_ext
12097 < cat >>conftest.$ac_ext <<_ACEOF
12098 < /* end confdefs.h.  */
12099 <
12100 < #ifdef HAVE_IOSTREAM
12101 < #include <fstream>
12102 < #else
12103 < #include <fstream.h>
12104 < #endif
12105 < #ifdef HAVE_STD_IOSTREAM
12106 < using namespace std;
12107 < #endif
12108 <
12109 < #ifdef FC_DUMMY_MAIN
12110 < #ifndef FC_DUMMY_MAIN_EQ_F77
12111 < #  ifdef __cplusplus
12112 <     extern "C"
12113 < #  endif
12114 <   int FC_DUMMY_MAIN() { return 1; }
12115 < #endif
12116 < #endif
12117 < int
12118 < main ()
12119 < {
12120 < ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
12121 <  ;
12122 <  return 0;
12123 < }
12124 < _ACEOF
12125 < rm -f conftest.$ac_objext
12126 < if { (ac_try="$ac_compile"
12127 < case "(($ac_try" in
12128 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12129 <  *) ac_try_echo=$ac_try;;
12130 < esac
12131 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12132 <  (eval "$ac_compile") 2>conftest.er1
12133 <  ac_status=$?
12134 <  grep -v '^ *+' conftest.er1 >conftest.err
12135 <  rm -f conftest.er1
12136 <  cat conftest.err >&5
12137 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12138 <  (exit $ac_status); } && {
12139 <         test -z "$ac_cxx_werror_flag" ||
12140 <         test ! -s conftest.err
12141 <       } && test -s conftest.$ac_objext; then
12142 <  ac_cv_cxx_have_fstream_open=yes
12143 < else
12144 <  echo "$as_me: failed program was:" >&5
12145 < sed 's/^/| /' conftest.$ac_ext >&5
12146 <
12147 <
12148 < fi
12149 <
12150 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12151 <    # Try with mode parameter
12152 <    cat >conftest.$ac_ext <<_ACEOF
12153 < /* confdefs.h.  */
12154 < _ACEOF
12155 < cat confdefs.h >>conftest.$ac_ext
12156 < cat >>conftest.$ac_ext <<_ACEOF
12157 < /* end confdefs.h.  */
12158 <
12159 < #ifdef HAVE_IOSTREAM
12160 < #include <fstream>
12161 < #else
12162 < #include <fstream.h>
12163 < #endif
12164 < #ifdef HAVE_STD_IOSTREAM
12165 < using namespace std;
12166 < #endif
12167 <
12168 < #ifdef FC_DUMMY_MAIN
12169 < #ifndef FC_DUMMY_MAIN_EQ_F77
12170 < #  ifdef __cplusplus
12171 <     extern "C"
12172 < #  endif
12173 <   int FC_DUMMY_MAIN() { return 1; }
12174 < #endif
12175 < #endif
12176 < int
12177 < main ()
12178 < {
12179 < ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
12180 <  ;
12181 <  return 0;
12182 < }
12183 < _ACEOF
12184 < rm -f conftest.$ac_objext
12185 < if { (ac_try="$ac_compile"
12186 < case "(($ac_try" in
12187 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12188 <  *) ac_try_echo=$ac_try;;
12189 < esac
12190 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12191 <  (eval "$ac_compile") 2>conftest.er1
12192 <  ac_status=$?
12193 <  grep -v '^ *+' conftest.er1 >conftest.err
12194 <  rm -f conftest.er1
12195 <  cat conftest.err >&5
12196 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12197 <  (exit $ac_status); } && {
12198 <         test -z "$ac_cxx_werror_flag" ||
12199 <         test ! -s conftest.err
12200 <       } && test -s conftest.$ac_objext; then
12201 <  ac_cv_cxx_fstream_open_prot=yes
12202 < else
12203 <  echo "$as_me: failed program was:" >&5
12204 < sed 's/^/| /' conftest.$ac_ext >&5
12205 <
12206 <
12207 < fi
12208 <
12209 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12210 <    ac_ext=cpp
12211 < ac_cpp='$CXXCPP $CPPFLAGS'
12212 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12213 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12214 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12215 <
12216 <
12217 < fi
12218 < { echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
12219 < echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6; }
12220 <  if test "$ac_cv_cxx_have_fstream_open" = yes; then
12221 <
12222 < cat >>confdefs.h <<\_ACEOF
12223 < #define HAVE_FSTREAM_OPEN 1
12224 < _ACEOF
12225 <
12226 <  fi
12227 <  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
12228 <
12229 < cat >>confdefs.h <<\_ACEOF
12230 < #define FSTREAM_OPEN_PROT 1
12231 < _ACEOF
12232 <
12233 <  fi
12234 <
12235 <
12236 <
12237 <
12238 <
12239 <
12240 <
12241 < for ac_header in ctype.h iostream fstream sstream strstream
12242 < do
12243 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
12244 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
12245 <  { echo "$as_me:$LINENO: checking for $ac_header" >&5
12246 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
12247 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
12248 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12249 < fi
12250 < ac_res=`eval echo '${'$as_ac_Header'}'`
12251 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
12252 < echo "${ECHO_T}$ac_res" >&6; }
12253 < else
12254 <  # Is the header compilable?
12255 < { echo "$as_me:$LINENO: checking $ac_header usability" >&5
12256 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
12257 < cat >conftest.$ac_ext <<_ACEOF
12258 < /* confdefs.h.  */
12259 < _ACEOF
12260 < cat confdefs.h >>conftest.$ac_ext
12261 < cat >>conftest.$ac_ext <<_ACEOF
12262 < /* end confdefs.h.  */
12263 < $ac_includes_default
12264 < #include <$ac_header>
12265 < _ACEOF
12266 < rm -f conftest.$ac_objext
12267 < if { (ac_try="$ac_compile"
12268 < case "(($ac_try" in
12269 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12270 <  *) ac_try_echo=$ac_try;;
12271 < esac
12272 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12273 <  (eval "$ac_compile") 2>conftest.er1
12274 <  ac_status=$?
12275 <  grep -v '^ *+' conftest.er1 >conftest.err
12276 <  rm -f conftest.er1
12277 <  cat conftest.err >&5
12278 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12279 <  (exit $ac_status); } && {
12280 <         test -z "$ac_cxx_werror_flag" ||
12281 <         test ! -s conftest.err
12282 <       } && test -s conftest.$ac_objext; then
12283 <  ac_header_compiler=yes
12284 < else
12285 <  echo "$as_me: failed program was:" >&5
12286 < sed 's/^/| /' conftest.$ac_ext >&5
12287 <
12288 <        ac_header_compiler=no
12289 < fi
12290 <
12291 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12292 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
12293 < echo "${ECHO_T}$ac_header_compiler" >&6; }
12294 <
12295 < # Is the header present?
12296 < { echo "$as_me:$LINENO: checking $ac_header presence" >&5
12297 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
12298 < cat >conftest.$ac_ext <<_ACEOF
12299 < /* confdefs.h.  */
12300 < _ACEOF
12301 < cat confdefs.h >>conftest.$ac_ext
12302 < cat >>conftest.$ac_ext <<_ACEOF
12303 < /* end confdefs.h.  */
12304 < #include <$ac_header>
12305 < _ACEOF
12306 < if { (ac_try="$ac_cpp conftest.$ac_ext"
12307 < case "(($ac_try" in
12308 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12309 <  *) ac_try_echo=$ac_try;;
12310 < esac
12311 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12312 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
12313 <  ac_status=$?
12314 <  grep -v '^ *+' conftest.er1 >conftest.err
12315 <  rm -f conftest.er1
12316 <  cat conftest.err >&5
12317 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12318 <  (exit $ac_status); } >/dev/null && {
12319 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
12320 <         test ! -s conftest.err
12321 <       }; then
12322 <  ac_header_preproc=yes
12323 < else
12324 <  echo "$as_me: failed program was:" >&5
12325 < sed 's/^/| /' conftest.$ac_ext >&5
12326 <
12327 <  ac_header_preproc=no
12328 < fi
12329 <
12330 < rm -f conftest.err conftest.$ac_ext
12331 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
12332 < echo "${ECHO_T}$ac_header_preproc" >&6; }
12333 <
12334 < # So?  What about this header?
12335 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
12336 <  yes:no: )
12337 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
12338 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
12339 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
12340 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
12341 <    ac_header_preproc=yes
12342 <    ;;
12343 <  no:yes:* )
12344 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
12345 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
12346 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
12347 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
12348 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
12349 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
12350 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
12351 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
12352 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
12353 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
12354 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
12355 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
12356 <    ( cat <<\_ASBOX
12357 < ## ------------------------------ ##
12358 < ## Report this to gezelter@nd.edu ##
12359 < ## ------------------------------ ##
12360 < _ASBOX
12361 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
12362 <    ;;
12363 < esac
12364 < { echo "$as_me:$LINENO: checking for $ac_header" >&5
12365 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
12366 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
12367 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12368 < else
12369 <  eval "$as_ac_Header=\$ac_header_preproc"
12370 < fi
12371 < ac_res=`eval echo '${'$as_ac_Header'}'`
12372 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
12373 < echo "${ECHO_T}$ac_res" >&6; }
12374 <
12375 < fi
12376 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
12377 <  cat >>confdefs.h <<_ACEOF
12378 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
12379 < _ACEOF
12380 <
12381 < fi
12382 <
12383 < done
12384 <
12385 < # AC_CPP_FUNC
12386 < # ------------------ #
12387 < # Checks to see if ANSI C99 CPP variable __func__ works.
12388 < # If not, perhaps __FUNCTION__ works instead.
12389 < # If not, we'll just define __func__ to "".
12390 < # AC_CPP_FUNC
12391 <
12392 <   case $ac_cv_prog_cc_stdc in
12393 <  no) ac_cv_prog_cc_c99=no; ac_cv_prog_cc_c89=no ;;
12394 <  *) { echo "$as_me:$LINENO: checking for $CC option to accept ISO C99" >&5
12395 < echo $ECHO_N "checking for $CC option to accept ISO C99... $ECHO_C" >&6; }
12396 < if test "${ac_cv_prog_cc_c99+set}" = set; then
12397 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12398 < else
12399 <  ac_cv_prog_cc_c99=no
12400 < ac_save_CC=$CC
12401 < cat >conftest.$ac_ext <<_ACEOF
12402 < /* confdefs.h.  */
12403 < _ACEOF
12404 < cat confdefs.h >>conftest.$ac_ext
12405 < cat >>conftest.$ac_ext <<_ACEOF
12406 < /* end confdefs.h.  */
12407 < #include <stdarg.h>
12408 < #include <stdbool.h>
12409 < #include <stdlib.h>
12410 < #include <wchar.h>
12411 < #include <stdio.h>
12412 <
12413 < // Check varargs macros.  These examples are taken from C99 6.10.3.5.
12414 < #define debug(...) fprintf (stderr, __VA_ARGS__)
12415 < #define showlist(...) puts (#__VA_ARGS__)
12416 < #define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
12417 < static void
12418 < test_varargs_macros (void)
12419 < {
12420 <  int x = 1234;
12421 <  int y = 5678;
12422 <  debug ("Flag");
12423 <  debug ("X = %d\n", x);
12424 <  showlist (The first, second, and third items.);
12425 <  report (x>y, "x is %d but y is %d", x, y);
12426 < }
12427 <
12428 < // Check long long types.
12429 < #define BIG64 18446744073709551615ull
12430 < #define BIG32 4294967295ul
12431 < #define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
12432 < #if !BIG_OK
12433 <  your preprocessor is broken;
12434 < #endif
12435 < #if BIG_OK
12436 < #else
12437 <  your preprocessor is broken;
12438 < #endif
12439 < static long long int bignum = -9223372036854775807LL;
12440 < static unsigned long long int ubignum = BIG64;
12441 <
12442 < struct incomplete_array
12443 < {
12444 <  int datasize;
12445 <  double data[];
12446 < };
12447 <
12448 < struct named_init {
12449 <  int number;
12450 <  const wchar_t *name;
12451 <  double average;
12452 < };
12453 <
12454 < typedef const char *ccp;
12455 <
12456 < static inline int
12457 < test_restrict (ccp restrict text)
12458 < {
12459 <  // See if C++-style comments work.
12460 <  // Iterate through items via the restricted pointer.
12461 <  // Also check for declarations in for loops.
12462 <  for (unsigned int i = 0; *(text+i) != '\0'; ++i)
12463 <    continue;
12464 <  return 0;
12465 < }
12466 <
12467 < // Check varargs and va_copy.
12468 < static void
12469 < test_varargs (const char *format, ...)
12470 < {
12471 <  va_list args;
12472 <  va_start (args, format);
12473 <  va_list args_copy;
12474 <  va_copy (args_copy, args);
12475 <
12476 <  const char *str;
12477 <  int number;
12478 <  float fnumber;
12479 <
12480 <  while (*format)
12481 <    {
12482 <      switch (*format++)
12483 <        {
12484 <        case 's': // string
12485 <          str = va_arg (args_copy, const char *);
12486 <          break;
12487 <        case 'd': // int
12488 <          number = va_arg (args_copy, int);
12489 <          break;
12490 <        case 'f': // float
12491 <          fnumber = va_arg (args_copy, double);
12492 <          break;
12493 <        default:
12494 <          break;
12495 <        }
12496 <    }
12497 <  va_end (args_copy);
12498 <  va_end (args);
12499 < }
12500 <
12501 < #ifdef FC_DUMMY_MAIN
12502 < #ifndef FC_DUMMY_MAIN_EQ_F77
12503 < #  ifdef __cplusplus
12504 <     extern "C"
12505 < #  endif
12506 <   int FC_DUMMY_MAIN() { return 1; }
12507 < #endif
12508 < #endif
12509 < int
12510 < main ()
12511 < {
12512 <
12513 <  // Check bool.
12514 <  _Bool success = false;
12515 <
12516 <  // Check restrict.
12517 <  if (test_restrict ("String literal") == 0)
12518 <    success = true;
12519 <  char *restrict newvar = "Another string";
12520 <
12521 <  // Check varargs.
12522 <  test_varargs ("s, d' f .", "string", 65, 34.234);
12523 <  test_varargs_macros ();
12524 <
12525 <  // Check flexible array members.
12526 <  struct incomplete_array *ia =
12527 <    malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
12528 <  ia->datasize = 10;
12529 <  for (int i = 0; i < ia->datasize; ++i)
12530 <    ia->data[i] = i * 1.234;
12531 <
12532 <  // Check named initializers.
12533 <  struct named_init ni = {
12534 <    .number = 34,
12535 <    .name = L"Test wide string",
12536 <    .average = 543.34343,
12537 <  };
12538 <
12539 <  ni.number = 58;
12540 <
12541 <  int dynamic_array[ni.number];
12542 <  dynamic_array[ni.number - 1] = 543;
12543 <
12544 <  // work around unused variable warnings
12545 <  return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x'
12546 <          || dynamic_array[ni.number - 1] != 543);
12547 <
12548 <  ;
12549 <  return 0;
12550 < }
12551 < _ACEOF
12552 < for ac_arg in '' -std=gnu99 -c99 -qlanglvl=extc99
12553 < do
12554 <  CC="$ac_save_CC $ac_arg"
12555 <  rm -f conftest.$ac_objext
12556 < if { (ac_try="$ac_compile"
12557 < case "(($ac_try" in
12558 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12559 <  *) ac_try_echo=$ac_try;;
12560 < esac
12561 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12562 <  (eval "$ac_compile") 2>conftest.er1
12563 <  ac_status=$?
12564 <  grep -v '^ *+' conftest.er1 >conftest.err
12565 <  rm -f conftest.er1
12566 <  cat conftest.err >&5
12567 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12568 <  (exit $ac_status); } && {
12569 <         test -z "$ac_cxx_werror_flag" ||
12570 <         test ! -s conftest.err
12571 <       } && test -s conftest.$ac_objext; then
12572 <  ac_cv_prog_cc_c99=$ac_arg
12573 < else
12574 <  echo "$as_me: failed program was:" >&5
12575 < sed 's/^/| /' conftest.$ac_ext >&5
12576 <
12577 <
12578 < fi
12579 <
12580 < rm -f core conftest.err conftest.$ac_objext
12581 <  test "x$ac_cv_prog_cc_c99" != "xno" && break
12582 < done
12583 < rm -f conftest.$ac_ext
12584 < CC=$ac_save_CC
12585 <
12586 < fi
12587 < # AC_CACHE_VAL
12588 < case "x$ac_cv_prog_cc_c99" in
12589 <  x)
12590 <    { echo "$as_me:$LINENO: result: none needed" >&5
12591 < echo "${ECHO_T}none needed" >&6; } ;;
12592 <  xno)
12593 <    { echo "$as_me:$LINENO: result: unsupported" >&5
12594 < echo "${ECHO_T}unsupported" >&6; } ;;
12595 <  *)
12596 <    CC="$CC $ac_cv_prog_cc_c99"
12597 <    { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c99" >&5
12598 < echo "${ECHO_T}$ac_cv_prog_cc_c99" >&6; } ;;
12599 < esac
12600 < if test "x$ac_cv_prog_cc_c99" != xno; then
12601 <  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99
12602 < else
12603 <  { echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
12604 < echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; }
12605 < if test "${ac_cv_prog_cc_c89+set}" = set; then
12606 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12607 < else
12608 <  ac_cv_prog_cc_c89=no
12609 < ac_save_CC=$CC
12610 < cat >conftest.$ac_ext <<_ACEOF
12611 < /* confdefs.h.  */
12612 < _ACEOF
12613 < cat confdefs.h >>conftest.$ac_ext
12614 < cat >>conftest.$ac_ext <<_ACEOF
12615 < /* end confdefs.h.  */
12616 < #include <stdarg.h>
12617 < #include <stdio.h>
12618 < #include <sys/types.h>
12619 < #include <sys/stat.h>
12620 < /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
12621 < struct buf { int x; };
12622 < FILE * (*rcsopen) (struct buf *, struct stat *, int);
12623 < static char *e (p, i)
12624 <     char **p;
12625 <     int i;
12626 < {
12627 <  return p[i];
12628 < }
12629 < static char *f (char * (*g) (char **, int), char **p, ...)
12630 < {
12631 <  char *s;
12632 <  va_list v;
12633 <  va_start (v,p);
12634 <  s = g (p, va_arg (v,int));
12635 <  va_end (v);
12636 <  return s;
12637 < }
12638 <
12639 < /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
12640 <   function prototypes and stuff, but not '\xHH' hex character constants.
12641 <   These don't provoke an error unfortunately, instead are silently treated
12642 <   as 'x'.  The following induces an error, until -std is added to get
12643 <   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
12644 <   array size at least.  It's necessary to write '\x00'==0 to get something
12645 <   that's true only with -std.  */
12646 < int osf4_cc_array ['\x00' == 0 ? 1 : -1];
12647 <
12648 < /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
12649 <   inside strings and character constants.  */
12650 < #define FOO(x) 'x'
12651 < int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
12652 <
12653 < int test (int i, double x);
12654 < struct s1 {int (*f) (int a);};
12655 < struct s2 {int (*f) (double a);};
12656 < int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
12657 < int argc;
12658 < char **argv;
12659 < #ifdef FC_DUMMY_MAIN
12660 < #ifndef FC_DUMMY_MAIN_EQ_F77
12661 < #  ifdef __cplusplus
12662 <     extern "C"
12663 < #  endif
12664 <   int FC_DUMMY_MAIN() { return 1; }
12665 < #endif
12666 < #endif
12667 < int
12668 < main ()
12669 < {
12670 < return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
12671 <  ;
12672 <  return 0;
12673 < }
12674 < _ACEOF
12675 < for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
12676 <        -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
12677 < do
12678 <  CC="$ac_save_CC $ac_arg"
12679 <  rm -f conftest.$ac_objext
12680 < if { (ac_try="$ac_compile"
12681 < case "(($ac_try" in
12682 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12683 <  *) ac_try_echo=$ac_try;;
12684 < esac
12685 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12686 <  (eval "$ac_compile") 2>conftest.er1
12687 <  ac_status=$?
12688 <  grep -v '^ *+' conftest.er1 >conftest.err
12689 <  rm -f conftest.er1
12690 <  cat conftest.err >&5
12691 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12692 <  (exit $ac_status); } && {
12693 <         test -z "$ac_cxx_werror_flag" ||
12694 <         test ! -s conftest.err
12695 <       } && test -s conftest.$ac_objext; then
12696 <  ac_cv_prog_cc_c89=$ac_arg
12697 < else
12698 <  echo "$as_me: failed program was:" >&5
12699 < sed 's/^/| /' conftest.$ac_ext >&5
12700 <
12701 <
12702 < fi
12703 <
12704 < rm -f core conftest.err conftest.$ac_objext
12705 <  test "x$ac_cv_prog_cc_c89" != "xno" && break
12706 < done
12707 < rm -f conftest.$ac_ext
12708 < CC=$ac_save_CC
12709 <
12710 < fi
12711 < # AC_CACHE_VAL
12712 < case "x$ac_cv_prog_cc_c89" in
12713 <  x)
12714 <    { echo "$as_me:$LINENO: result: none needed" >&5
12715 < echo "${ECHO_T}none needed" >&6; } ;;
12716 <  xno)
12717 <    { echo "$as_me:$LINENO: result: unsupported" >&5
12718 < echo "${ECHO_T}unsupported" >&6; } ;;
12719 <  *)
12720 <    CC="$CC $ac_cv_prog_cc_c89"
12721 <    { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
12722 < echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;;
12723 < esac
12724 < if test "x$ac_cv_prog_cc_c89" != xno; then
12725 <  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89
12726 < else
12727 <  ac_cv_prog_cc_stdc=no
12728 < fi
12729 <
12730 <
12731 < fi
12732 <
12733 < ;;
12734 < esac
12735 <  { echo "$as_me:$LINENO: checking for $CC option to accept ISO Standard C" >&5
12736 < echo $ECHO_N "checking for $CC option to accept ISO Standard C... $ECHO_C" >&6; }
12737 <  if test "${ac_cv_prog_cc_stdc+set}" = set; then
12738 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12739 < fi
12740 <
12741 <  case $ac_cv_prog_cc_stdc in
12742 <  no) { echo "$as_me:$LINENO: result: unsupported" >&5
12743 < echo "${ECHO_T}unsupported" >&6; } ;;
12744 <  '') { echo "$as_me:$LINENO: result: none needed" >&5
12745 < echo "${ECHO_T}none needed" >&6; } ;;
12746 <  *) { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
12747 < echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6; } ;;
12748 < esac
12749 <
12750 <
12751 < { echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
12752 < echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6; }
12753 < if test "${ac_cv_cpp_func+set}" = set; then
12754 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12755 < else
12756 <  cat >conftest.$ac_ext <<_ACEOF
12757 < /* confdefs.h.  */
12758 < _ACEOF
12759 < cat confdefs.h >>conftest.$ac_ext
12760 < cat >>conftest.$ac_ext <<_ACEOF
12761 < /* end confdefs.h.  */
12762 <
12763 < #ifdef FC_DUMMY_MAIN
12764 < #ifndef FC_DUMMY_MAIN_EQ_F77
12765 < #  ifdef __cplusplus
12766 <     extern "C"
12767 < #  endif
12768 <   int FC_DUMMY_MAIN() { return 1; }
12769 < #endif
12770 < #endif
12771 < int
12772 < main ()
12773 < {
12774 < const char *foo = __func__;
12775 <  ;
12776 <  return 0;
12777 < }
12778 < _ACEOF
12779 < rm -f conftest.$ac_objext
12780 < if { (ac_try="$ac_compile"
12781 < case "(($ac_try" in
12782 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12783 <  *) ac_try_echo=$ac_try;;
12784 < esac
12785 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12786 <  (eval "$ac_compile") 2>conftest.er1
12787 <  ac_status=$?
12788 <  grep -v '^ *+' conftest.er1 >conftest.err
12789 <  rm -f conftest.er1
12790 <  cat conftest.err >&5
12791 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12792 <  (exit $ac_status); } && {
12793 <         test -z "$ac_cxx_werror_flag" ||
12794 <         test ! -s conftest.err
12795 <       } && test -s conftest.$ac_objext; then
12796 <  ac_cv_cpp_func=yes
12797 < else
12798 <  echo "$as_me: failed program was:" >&5
12799 < sed 's/^/| /' conftest.$ac_ext >&5
12800 <
12801 <        cat >conftest.$ac_ext <<_ACEOF
12802 < /* confdefs.h.  */
12803 < _ACEOF
12804 < cat confdefs.h >>conftest.$ac_ext
12805 < cat >>conftest.$ac_ext <<_ACEOF
12806 < /* end confdefs.h.  */
12807 <
12808 < #ifdef FC_DUMMY_MAIN
12809 < #ifndef FC_DUMMY_MAIN_EQ_F77
12810 < #  ifdef __cplusplus
12811 <     extern "C"
12812 < #  endif
12813 <   int FC_DUMMY_MAIN() { return 1; }
12814 < #endif
12815 < #endif
12816 < int
12817 < main ()
12818 < {
12819 < const char *foo = __FUNCTION__;
12820 <  ;
12821 <  return 0;
12822 < }
12823 < _ACEOF
12824 < rm -f conftest.$ac_objext
12825 < if { (ac_try="$ac_compile"
12826 < case "(($ac_try" in
12827 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12828 <  *) ac_try_echo=$ac_try;;
12829 < esac
12830 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12831 <  (eval "$ac_compile") 2>conftest.er1
12832 <  ac_status=$?
12833 <  grep -v '^ *+' conftest.er1 >conftest.err
12834 <  rm -f conftest.er1
12835 <  cat conftest.err >&5
12836 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12837 <  (exit $ac_status); } && {
12838 <         test -z "$ac_cxx_werror_flag" ||
12839 <         test ! -s conftest.err
12840 <       } && test -s conftest.$ac_objext; then
12841 <  ac_cv_cpp_func=__FUNCTION__
12842 < else
12843 <  echo "$as_me: failed program was:" >&5
12844 < sed 's/^/| /' conftest.$ac_ext >&5
12845 <
12846 <        ac_cv_cpp_func=no
12847 < fi
12848 <
12849 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12850 < fi
12851 <
12852 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12853 < fi
12854 < { echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
12855 < echo "${ECHO_T}$ac_cv_cpp_func" >&6; }
12856 < if test $ac_cv_cpp_func = __FUNCTION__; then
12857 <
12858 < cat >>confdefs.h <<\_ACEOF
12859 < #define __func__ __FUNCTION__
12860 < _ACEOF
12861 <
12862 < elif test $ac_cv_cpp_func = no; then
12863 <
12864 < cat >>confdefs.h <<\_ACEOF
12865 < #define __func__ ""
12866 < _ACEOF
12867 <
12868 < fi
12869 <
12870 <
12871 <
12872 <
12873 <
12874 < case $debug in
12875 <  1)
12876 <     ;;
12877 <  *)
12878 <
12879 <
12880 <
12881 <
12882 < # Try to determine "good" native compiler flags if none specified on command
12883 < # line
12884 <
12885 < if test "$ac_test_FFLAGS" != "set"; then
12886 <  FCFLAGS=""
12887 <  case "${host_cpu}-${host_os}" in
12888 <
12889 <  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
12890 <                    FCFLAGS="-O3 -ip -no-prec-div"
12891 <                fi;;
12892 <   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
12893 <                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
12894 <                fi;;
12895 <   powerpc*-aix*)
12896 <        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12897 <                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
12898 <                echo "*******************************************************"
12899 <                echo "*  You have AIX on an unknown powerpc system.  It is  *"
12900 <                echo "*  recommended that you use                           *"
12901 <                echo "*                                                     *"
12902 <                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12903 <                echo "*                                 ^^^                 *"
12904 <                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12905 <                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
12906 <                echo "*******************************************************"
12907 <        fi;;
12908 <   *darwin*)
12909 <        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12910 <                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
12911 <        fi
12912 <        if test "$FC" = ifort; then
12913 <                FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
12914 <        fi;;
12915 <  esac
12916 <
12917 <  if test -n "$CPU_FLAGS"; then
12918 <        FCFLAGS="$FCFLAGS $CPU_FLAGS"
12919 <  fi
12920 <
12921 <  if test -z "$FCFLAGS"; then
12922 <        echo ""
12923 <        echo "*********************************************************"
12924 <        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
12925 <        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12926 <        echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
12927 <        echo "*********************************************************"
12928 <        echo ""
12929 <        FCFLAGS="-O3"
12930 <  fi
12931 <
12932 <
12933 < { echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
12934 < echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6; }
12935 < if test "${ac_guessed_f90flags+set}" = set; then
12936 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12937 < else
12938 <
12939 <
12940 < ac_ext=${ac_fc_srcext-f}
12941 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
12942 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
12943 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
12944 <
12945 < echo 'program main' > conftest.$ac_ext
12946 < echo 'end program main' >> conftest.$ac_ext
12947 < ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
12948 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12949 <  (eval $ac_compile) 2>&5
12950 <  ac_status=$?
12951 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12952 <  (exit $ac_status); }; then
12953 <        ac_guessed_f90flags=yes
12954 < else
12955 <        ac_guessed_f90flags=no
12956 < fi
12957 < rm -rf conftest*
12958 < ac_ext=cpp
12959 < ac_cpp='$CXXCPP $CPPFLAGS'
12960 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12961 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12962 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12963 <
12964 <
12965 < fi
12966 < { echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12967 < echo "${ECHO_T}$ac_guessed_f90flags" >&6; }
12968 < if test "$ac_guessed_f90flags" = yes; then
12969 <        :
12970 <
12971 < else
12972 <        :
12973 <
12974 <        echo ""
12975 <        echo "**********************************************************"
12976 <        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12977 <        echo "* your compiler.                                        *"
12978 <        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12979 <        echo "*********************************************************"
12980 <        echo ""
12981 <        FCFLAGS=""
12982 <
12983 < fi
12984 <
12985 <
12986 < fi
12987 <
12988 <
12989 <
12990 <
12991 <
12992 <
12993 <
12994 < { echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12995 < echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6; }
12996 < if test "${ac_cv_prog_really_gcc+set}" = set; then
12997 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12998 < else
12999 <
13000 < cat > conftest.c <<EOF
13001 < #ifdef __GNUC__
13002 <  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
13003 <     no;
13004 <  #else
13005 <     yes;
13006 <  #endif
13007 < #endif
13008 < EOF
13009 < if { ac_try='${CC-cc} -E conftest.c'
13010 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13011 <  (eval $ac_try) 2>&5
13012 <  ac_status=$?
13013 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13014 <  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
13015 <  ac_cv_prog_really_gcc=yes
13016 < else
13017 <  ac_cv_prog_really_gcc=no
13018 < fi
13019 <
13020 < fi
13021 < { echo "$as_me:$LINENO: result: $ac_cv_prog_really_gcc" >&5
13022 < echo "${ECHO_T}$ac_cv_prog_really_gcc" >&6; }
13023 < if test "$ac_cv_prog_really_gcc" = yes; then
13024 <        :
13025 <
13026 < else
13027 <        :
13028 <
13029 < fi
13030 <
13031 <
13032 < # Try to determine "good" native compiler flags if none specified on command
13033 < # line
13034 < if test "$ac_test_CFLAGS" != "set"; then
13035 <  CFLAGS=""
13036 <  case "${host_cpu}-${host_os}" in
13037 <
13038 <  *linux*) if test "$CC" = icc; then
13039 <                    CFLAGS="-O"
13040 <                fi;;
13041 <  sparc-solaris2*) if test "$CC" = cc; then
13042 <                    CFLAGS="-O -dalign"
13043 <                 fi;;
13044 <
13045 <  alpha*-osf*)  if test "$CC" = cc; then
13046 <                    CFLAGS="-newc -w0 -O5 -ansi_alias -ansi_args -fp_reorder -tune host -arch host -std1"
13047 <                fi;;
13048 <
13049 <  hppa*-hpux*)  if test "$CC" = cc; then
13050 <                    CFLAGS="-Ae +O3 +Oall"
13051 <                fi;;
13052 <
13053 <   rs6000*-aix*)  if test "$CC" = cc -o "$CC" = xlc; then
13054 <                    CFLAGS="-O3 -qtune=auto -qansialias -w"
13055 <                fi;;
13056 <   powerpc*-aix*)
13057 <        if test "$CC" = cc -o "$CC" = xlc; then
13058 <                CFLAGS="-O3 -qtune=auto -qansialias -w"
13059 <                echo "*******************************************************"
13060 <                echo "*  You have AIX on an unknown powerpc system.  It is  *"
13061 <                echo "*  recommended that you use                           *"
13062 <                echo "*                                                     *"
13063 <                echo "*    CFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
13064 <                echo "*                                 ^^^                 *"
13065 <                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
13066 <                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
13067 <                echo "*******************************************************"
13068 <        fi;;
13069 <   *darwin*)
13070 <        if test "$CC" = xlc -o "$CC" = cc; then
13071 <                CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
13072 <        fi
13073 <        if test "$CC" = icc; then
13074 <                CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
13075 <        fi;;
13076 <  esac
13077 <
13078 <  # use default flags for gcc on all systems
13079 <  if test $ac_cv_prog_really_gcc = yes; then
13080 <     CFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align -pedantic"
13081 <  fi
13082 <
13083 <  # test for gcc-specific flags:
13084 <  if test $ac_cv_prog_really_gcc = yes; then
13085 <    # -malign-double for x86 systems
13086 <
13087 <
13088 < { echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
13089 < echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6; }
13090 < if test "${ac_align_double+set}" = set; then
13091 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13092 < else
13093 <  echo 'void f(){}' > conftest.c
13094 < if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
13095 <        ac_align_double=yes
13096 < else
13097 <        ac_align_double=no
13098 < fi
13099 < rm -f conftest*
13100 <
13101 < fi
13102 < { echo "$as_me:$LINENO: result: $ac_align_double" >&5
13103 < echo "${ECHO_T}$ac_align_double" >&6; }
13104 < if test "$ac_align_double" = yes; then
13105 <        :
13106 <        CFLAGS="$CFLAGS -malign-double"
13107 < else
13108 <        :
13109 <
13110 < fi
13111 <
13112 <    # -fstrict-aliasing for gcc-2.95+
13113 <
13114 <
13115 < { echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
13116 < echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6; }
13117 < if test "${ac_fstrict_aliasing+set}" = set; then
13118 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13119 < else
13120 <  echo 'void f(){}' > conftest.c
13121 < if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
13122 <        ac_fstrict_aliasing=yes
13123 < else
13124 <        ac_fstrict_aliasing=no
13125 < fi
13126 < rm -f conftest*
13127 <
13128 < fi
13129 < { echo "$as_me:$LINENO: result: $ac_fstrict_aliasing" >&5
13130 < echo "${ECHO_T}$ac_fstrict_aliasing" >&6; }
13131 < if test "$ac_fstrict_aliasing" = yes; then
13132 <        :
13133 <        CFLAGS="$CFLAGS -fstrict-aliasing"
13134 < else
13135 <        :
13136 <
13137 < fi
13138 <
13139 <  fi
13140 <
13141 <  CPU_FLAGS=""
13142 <  if test $ac_cv_prog_really_gcc = yes; then
13143 <                  case "${host_cpu}" in
13144 <          i586*)
13145 <
13146 < { echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
13147 < echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6; }
13148 < if test "${ac_cpu_pentium+set}" = set; then
13149 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13150 < else
13151 <  echo 'void f(){}' > conftest.c
13152 < if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
13153 <        ac_cpu_pentium=yes
13154 < else
13155 <        ac_cpu_pentium=no
13156 < fi
13157 < rm -f conftest*
13158 <
13159 < fi
13160 < { echo "$as_me:$LINENO: result: $ac_cpu_pentium" >&5
13161 < echo "${ECHO_T}$ac_cpu_pentium" >&6; }
13162 < if test "$ac_cpu_pentium" = yes; then
13163 <        :
13164 <        CPU_FLAGS=-mcpu=pentium
13165 < else
13166 <        :
13167 <
13168 <
13169 < { echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
13170 < echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6; }
13171 < if test "${ac_pentium+set}" = set; then
13172 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13173 < else
13174 <  echo 'void f(){}' > conftest.c
13175 < if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
13176 <        ac_pentium=yes
13177 < else
13178 <        ac_pentium=no
13179 < fi
13180 < rm -f conftest*
13181 <
13182 < fi
13183 < { echo "$as_me:$LINENO: result: $ac_pentium" >&5
13184 < echo "${ECHO_T}$ac_pentium" >&6; }
13185 < if test "$ac_pentium" = yes; then
13186 <        :
13187 <        CPU_FLAGS=-mpentium
13188 < else
13189 <        :
13190 <
13191 < fi
13192 <
13193 < fi
13194 <
13195 <                  ;;
13196 <          i686*)
13197 <
13198 < { echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
13199 < echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6; }
13200 < if test "${ac_cpu_pentiumpro+set}" = set; then
13201 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13202 < else
13203 <  echo 'void f(){}' > conftest.c
13204 < if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
13205 <        ac_cpu_pentiumpro=yes
13206 < else
13207 <        ac_cpu_pentiumpro=no
13208 < fi
13209 < rm -f conftest*
13210 <
13211 < fi
13212 < { echo "$as_me:$LINENO: result: $ac_cpu_pentiumpro" >&5
13213 < echo "${ECHO_T}$ac_cpu_pentiumpro" >&6; }
13214 < if test "$ac_cpu_pentiumpro" = yes; then
13215 <        :
13216 <        CPU_FLAGS=-mcpu=pentiumpro
13217 < else
13218 <        :
13219 <
13220 <
13221 < { echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
13222 < echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6; }
13223 < if test "${ac_pentiumpro+set}" = set; then
13224 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13225 < else
13226 <  echo 'void f(){}' > conftest.c
13227 < if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
13228 <        ac_pentiumpro=yes
13229 < else
13230 <        ac_pentiumpro=no
13231 < fi
13232 < rm -f conftest*
13233 <
13234 < fi
13235 < { echo "$as_me:$LINENO: result: $ac_pentiumpro" >&5
13236 < echo "${ECHO_T}$ac_pentiumpro" >&6; }
13237 < if test "$ac_pentiumpro" = yes; then
13238 <        :
13239 <        CPU_FLAGS=-mpentiumpro
13240 < else
13241 <        :
13242 <
13243 < fi
13244 <
13245 < fi
13246 <
13247 <                  ;;
13248 <          powerpc*)
13249 <                cputype=`(grep cpu /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/ //g') 2> /dev/null`
13250 <                is60x=`echo $cputype | egrep "^600-9e?$"`
13251 <                if test -n "$is60x"; then
13252 <
13253 <
13254 < { echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
13255 < echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6; }
13256 < if test "${ac_m_cpu_60x+set}" = set; then
13257 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13258 < else
13259 <  echo 'void f(){}' > conftest.c
13260 < if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
13261 <        ac_m_cpu_60x=yes
13262 < else
13263 <        ac_m_cpu_60x=no
13264 < fi
13265 < rm -f conftest*
13266 <
13267 < fi
13268 < { echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
13269 < echo "${ECHO_T}$ac_m_cpu_60x" >&6; }
13270 < if test "$ac_m_cpu_60x" = yes; then
13271 <        :
13272 <        CPU_FLAGS=-mcpu=$cputype
13273 < else
13274 <        :
13275 <
13276 < fi
13277 <
13278 <                elif test "$cputype" = 750; then
13279 <
13280 <
13281 < { echo "$as_me:$LINENO: checking whether we are using gcc 2.95 or later" >&5
13282 < echo $ECHO_N "checking whether we are using gcc 2.95 or later... $ECHO_C" >&6; }
13283 < if test "${ac_cv_prog_gcc_2_95+set}" = set; then
13284 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13285 < else
13286 <
13287 < cat > conftest.c <<EOF
13288 < #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
13289 < #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
13290 <     yes;
13291 < #  endif
13292 < #endif
13293 < EOF
13294 < if { ac_try='${CC-cc} -E conftest.c'
13295 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13296 <  (eval $ac_try) 2>&5
13297 <  ac_status=$?
13298 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13299 <  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
13300 <  ac_cv_prog_gcc_2_95=yes
13301 < else
13302 <  ac_cv_prog_gcc_2_95=no
13303 < fi
13304 <
13305 < fi
13306 < { echo "$as_me:$LINENO: result: $ac_cv_prog_gcc_2_95" >&5
13307 < echo "${ECHO_T}$ac_cv_prog_gcc_2_95" >&6; }
13308 < if test "$ac_cv_prog_gcc_2_95" = yes; then
13309 <        :
13310 <
13311 <
13312 < { echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
13313 < echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6; }
13314 < if test "${ac_m_cpu_750+set}" = set; then
13315 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13316 < else
13317 <  echo 'void f(){}' > conftest.c
13318 < if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
13319 <        ac_m_cpu_750=yes
13320 < else
13321 <        ac_m_cpu_750=no
13322 < fi
13323 < rm -f conftest*
13324 <
13325 < fi
13326 < { echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
13327 < echo "${ECHO_T}$ac_m_cpu_750" >&6; }
13328 < if test "$ac_m_cpu_750" = yes; then
13329 <        :
13330 <        CPU_FLAGS=-mcpu=750
13331 < else
13332 <        :
13333 <
13334 < fi
13335 <
13336 < else
13337 <        :
13338 <
13339 < fi
13340 <
13341 <                fi
13342 <                if test -z "$CPU_FLAGS"; then
13343 <
13344 <
13345 < { echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
13346 < echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6; }
13347 < if test "${ac_m_cpu_powerpc+set}" = set; then
13348 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13349 < else
13350 <  echo 'void f(){}' > conftest.c
13351 < if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
13352 <        ac_m_cpu_powerpc=yes
13353 < else
13354 <        ac_m_cpu_powerpc=no
13355 < fi
13356 < rm -f conftest*
13357 <
13358 < fi
13359 < { echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
13360 < echo "${ECHO_T}$ac_m_cpu_powerpc" >&6; }
13361 < if test "$ac_m_cpu_powerpc" = yes; then
13362 <        :
13363 <        CPU_FLAGS=-mcpu=powerpc
13364 < else
13365 <        :
13366 <
13367 < fi
13368 <
13369 <                fi
13370 <                if test -z "$CPU_FLAGS"; then
13371 <
13372 <
13373 < { echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
13374 < echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6; }
13375 < if test "${ac_m_powerpc+set}" = set; then
13376 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13377 < else
13378 <  echo 'void f(){}' > conftest.c
13379 < if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
13380 <        ac_m_powerpc=yes
13381 < else
13382 <        ac_m_powerpc=no
13383 < fi
13384 < rm -f conftest*
13385 <
13386 < fi
13387 < { echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
13388 < echo "${ECHO_T}$ac_m_powerpc" >&6; }
13389 < if test "$ac_m_powerpc" = yes; then
13390 <        :
13391 <        CPU_FLAGS=-mpowerpc
13392 < else
13393 <        :
13394 <
13395 < fi
13396 <
13397 <                fi
13398 <          esac
13399 <  fi
13400 <
13401 <  if test -n "$CPU_FLAGS"; then
13402 <        CFLAGS="$CFLAGS $CPU_FLAGS"
13403 <  fi
13404 <
13405 <  if test -z "$CFLAGS"; then
13406 <        echo ""
13407 <        echo "********************************************************"
13408 <        echo "* WARNING: Don't know the best CFLAGS for this system  *"
13409 <        echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
13410 <        echo "* (otherwise, a default of CFLAGS=-O3 will be used)    *"
13411 <        echo "********************************************************"
13412 <        echo ""
13413 <        CFLAGS="-O3"
13414 <  fi
13415 <
13416 <
13417 <
13418 < { echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
13419 < echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6; }
13420 < if test "${ac_guessed_cflags+set}" = set; then
13421 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13422 < else
13423 <  echo 'void f(){}' > conftest.c
13424 < if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
13425 <        ac_guessed_cflags=yes
13426 < else
13427 <        ac_guessed_cflags=no
13428 < fi
13429 < rm -f conftest*
13430 <
13431 < fi
13432 < { echo "$as_me:$LINENO: result: $ac_guessed_cflags" >&5
13433 < echo "${ECHO_T}$ac_guessed_cflags" >&6; }
13434 < if test "$ac_guessed_cflags" = yes; then
13435 <        :
13436 <
13437 < else
13438 <        :
13439 <
13440 <        echo ""
13441 <        echo "********************************************************"
13442 <        echo "* WARNING: The guessed CFLAGS don't seem to work with  *"
13443 <        echo "* your compiler.                                       *"
13444 <        echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
13445 <        echo "********************************************************"
13446 <        echo ""
13447 <        CFLAGS=""
13448 <
13449 < fi
13450 <
13451 <
13452 < fi
13453 <
13454 <
13455 <
13456 <
13457 <
13458 <
13459 <
13460 < { echo "$as_me:$LINENO: checking whether we are *really* using GNU c++" >&5
13461 < echo $ECHO_N "checking whether we are *really* using GNU c++... $ECHO_C" >&6; }
13462 < if test "${ac_cv_prog_really_gxx+set}" = set; then
13463 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13464 < else
13465 <
13466 < cat > conftest.cpp <<EOF
13467 < #ifdef __GNUC__
13468 <  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
13469 <     no;
13470 <  #else
13471 <     yes;
13472 <  #endif
13473 < #endif
13474 < EOF
13475 < if { ac_try='${CXX-c++} -E conftest.cpp'
13476 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13477 <  (eval $ac_try) 2>&5
13478 <  ac_status=$?
13479 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13480 <  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
13481 <  ac_cv_prog_really_gxx=yes
13482 < else
13483 <  ac_cv_prog_really_gxx=no
13484 < fi
13485 <
13486 < fi
13487 < { echo "$as_me:$LINENO: result: $ac_cv_prog_really_gxx" >&5
13488 < echo "${ECHO_T}$ac_cv_prog_really_gxx" >&6; }
13489 < if test "$ac_cv_prog_really_gxx" = yes; then
13490 <        :
13491 <
13492 < else
13493 <        :
13494 <
13495 < fi
13496 <
13497 <
13498 < # Try to determine "good" native compiler flags if none specified on command
13499 < # line
13500 < if test "$ac_test_CXXFLAGS" != "set"; then
13501 <  CXXFLAGS=""
13502 <  case "${host_cpu}-${host_os}" in
13503 <
13504 <  *linux*) if test "$CXX" = icc -o "$CXX" = icpc; then
13505 <                    CXXFLAGS="-O"
13506 <                fi;;
13507 <  sparc-solaris2*) if test "$CXX" = CC; then
13508 <                    CXXFLAGS="-features=extensions -O -dalign"
13509 <                 fi;;
13510 <   rs6000*-aix*)  if test "$CXX" = xlC; then
13511 <                    CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
13512 <                fi;;
13513 <   powerpc*-aix*)
13514 <        if test "$CXX" = xlC; then
13515 <                CXXFLAGS="-O3 -qarch=ppc -qansialias -w"
13516 <                echo "*******************************************************"
13517 <                echo "*  You have AIX on an unknown powerpc system.  It is  *"
13518 <                echo "*  recommended that you use                           *"
13519 <                echo "*                                                     *"
13520 <                echo "*  CXXFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
13521 <                echo "*                                 ^^^                 *"
13522 <                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
13523 <                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
13524 <                echo "*******************************************************"
13525 <        fi;;
13526 <   *darwin*)
13527 <        if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
13528 <                CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
13529 <        fi
13530 <        if test "$CXX" = icpc; then
13531 <                CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
13532 <        fi;;
13533 <  esac
13534 <
13535 <  # use default flags for gcc on all systems
13536 <  if test $ac_cv_prog_really_gxx = yes; then
13537 <     CXXFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align -pedantic"
13538 <  fi
13539 <
13540 <  # test for gcc-specific flags:
13541 <  if test $ac_cv_prog_really_gxx = yes; then
13542 <    # -malign-double for x86 systems
13543 <
13544 <
13545 < { echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
13546 < echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6; }
13547 < if test "${ac_align_double+set}" = set; then
13548 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13549 < else
13550 <  echo 'void f(){}' > conftest.cpp
13551 < if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
13552 <        ac_align_double=yes
13553 < else
13554 <        ac_align_double=no
13555 < fi
13556 < rm -f conftest*
13557 <
13558 < fi
13559 < { echo "$as_me:$LINENO: result: $ac_align_double" >&5
13560 < echo "${ECHO_T}$ac_align_double" >&6; }
13561 < if test "$ac_align_double" = yes; then
13562 <        :
13563 <        CXXFLAGS="$CXXFLAGS -malign-double"
13564 < else
13565 <        :
13566 <
13567 < fi
13568 <
13569 <    # -fstrict-aliasing for gcc-2.95+
13570 <
13571 <
13572 < { echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
13573 < echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6; }
13574 < if test "${ac_fstrict_aliasing+set}" = set; then
13575 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13576 < else
13577 <  echo 'void f(){}' > conftest.cpp
13578 < if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
13579 <        ac_fstrict_aliasing=yes
13580 < else
13581 <        ac_fstrict_aliasing=no
13582 < fi
13583 < rm -f conftest*
13584 <
13585 < fi
13586 < { echo "$as_me:$LINENO: result: $ac_fstrict_aliasing" >&5
13587 < echo "${ECHO_T}$ac_fstrict_aliasing" >&6; }
13588 < if test "$ac_fstrict_aliasing" = yes; then
13589 <        :
13590 <        CXXFLAGS="$CXXFLAGS -fstrict-aliasing"
13591 < else
13592 <        :
13593 <
13594 < fi
13595 <
13596 <  fi
13597 <
13598 <  CPU_FLAGS=""
13599 <  if test $ac_cv_prog_really_gxx = yes; then
13600 <                  case "${host_cpu}" in
13601 <          i586*)
13602 <
13603 < { echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
13604 < echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6; }
13605 < if test "${ac_cpu_pentium+set}" = set; then
13606 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13607 < else
13608 <  echo 'void f(){}' > conftest.cpp
13609 < if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
13610 <        ac_cpu_pentium=yes
13611 < else
13612 <        ac_cpu_pentium=no
13613 < fi
13614 < rm -f conftest*
13615 <
13616 < fi
13617 < { echo "$as_me:$LINENO: result: $ac_cpu_pentium" >&5
13618 < echo "${ECHO_T}$ac_cpu_pentium" >&6; }
13619 < if test "$ac_cpu_pentium" = yes; then
13620 <        :
13621 <        CPU_FLAGS=-mcpu=pentium
13622 < else
13623 <        :
13624 <
13625 <
13626 < { echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
13627 < echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6; }
13628 < if test "${ac_pentium+set}" = set; then
13629 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13630 < else
13631 <  echo 'void f(){}' > conftest.cpp
13632 < if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
13633 <        ac_pentium=yes
13634 < else
13635 <        ac_pentium=no
13636 < fi
13637 < rm -f conftest*
13638 <
13639 < fi
13640 < { echo "$as_me:$LINENO: result: $ac_pentium" >&5
13641 < echo "${ECHO_T}$ac_pentium" >&6; }
13642 < if test "$ac_pentium" = yes; then
13643 <        :
13644 <        CPU_FLAGS=-mpentium
13645 < else
13646 <        :
13647 <
13648 < fi
13649 <
13650 < fi
13651 <
13652 <                  ;;
13653 <          i686*)
13654 <
13655 < { echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
13656 < echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6; }
13657 < if test "${ac_cpu_pentiumpro+set}" = set; then
13658 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13659 < else
13660 <  echo 'void f(){}' > conftest.cpp
13661 < if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
13662 <        ac_cpu_pentiumpro=yes
13663 < else
13664 <        ac_cpu_pentiumpro=no
13665 < fi
13666 < rm -f conftest*
13667 <
13668 < fi
13669 < { echo "$as_me:$LINENO: result: $ac_cpu_pentiumpro" >&5
13670 < echo "${ECHO_T}$ac_cpu_pentiumpro" >&6; }
13671 < if test "$ac_cpu_pentiumpro" = yes; then
13672 <        :
13673 <        CPU_FLAGS=-mcpu=pentiumpro
13674 < else
13675 <        :
13676 <
13677 <
13678 < { echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
13679 < echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6; }
13680 < if test "${ac_pentiumpro+set}" = set; then
13681 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13682 < else
13683 <  echo 'void f(){}' > conftest.cpp
13684 < if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
13685 <        ac_pentiumpro=yes
13686 < else
13687 <        ac_pentiumpro=no
13688 < fi
13689 < rm -f conftest*
13690 <
13691 < fi
13692 < { echo "$as_me:$LINENO: result: $ac_pentiumpro" >&5
13693 < echo "${ECHO_T}$ac_pentiumpro" >&6; }
13694 < if test "$ac_pentiumpro" = yes; then
13695 <        :
13696 <        CPU_FLAGS=-mpentiumpro
13697 < else
13698 <        :
13699 <
13700 < fi
13701 <
13702 < fi
13703 <
13704 <                  ;;
13705 <          powerpc*)
13706 <                cputype=`(grep cpu /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/ //g') 2> /dev/null`
13707 <                is60x=`echo $cputype | egrep "^600-9e?$"`
13708 <                if test -n "$is60x"; then
13709 <
13710 <
13711 < { echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
13712 < echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6; }
13713 < if test "${ac_m_cpu_60x+set}" = set; then
13714 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13715 < else
13716 <  echo 'void f(){}' > conftest.cpp
13717 < if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
13718 <        ac_m_cpu_60x=yes
13719 < else
13720 <        ac_m_cpu_60x=no
13721 < fi
13722 < rm -f conftest*
13723 <
13724 < fi
13725 < { echo "$as_me:$LINENO: result: $ac_m_cpu_60x" >&5
13726 < echo "${ECHO_T}$ac_m_cpu_60x" >&6; }
13727 < if test "$ac_m_cpu_60x" = yes; then
13728 <        :
13729 <        CPU_FLAGS=-mcpu=$cputype
13730 < else
13731 <        :
13732 <
13733 < fi
13734 <
13735 <                elif test "$cputype" = 750; then
13736 <
13737 <
13738 < { echo "$as_me:$LINENO: checking whether we are using g++ 2.95 or later" >&5
13739 < echo $ECHO_N "checking whether we are using g++ 2.95 or later... $ECHO_C" >&6; }
13740 < if test "${ac_cv_prog_gxx_2_95+set}" = set; then
13741 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13742 < else
13743 <
13744 < cat > conftest.cpp <<EOF
13745 < #ifdef __GNUC__ && !defined (__INTEL_COMPILER)
13746 < #  if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
13747 <     yes;
13748 < #  endif
13749 < #endif
13750 < EOF
13751 < if { ac_try='${CXX-c++} -E conftest.cpp'
13752 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13753 <  (eval $ac_try) 2>&5
13754 <  ac_status=$?
13755 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13756 <  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
13757 <  ac_cv_prog_gxx_2_95=yes
13758 < else
13759 <  ac_cv_prog_gxx_2_95=no
13760 < fi
13761 <
13762 < fi
13763 < { echo "$as_me:$LINENO: result: $ac_cv_prog_gxx_2_95" >&5
13764 < echo "${ECHO_T}$ac_cv_prog_gxx_2_95" >&6; }
13765 < if test "$ac_cv_prog_gxx_2_95" = yes; then
13766 <        :
13767 <
13768 <
13769 < { echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
13770 < echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6; }
13771 < if test "${ac_m_cpu_750+set}" = set; then
13772 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13773 < else
13774 <  echo 'void f(){}' > conftest.cpp
13775 < if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
13776 <        ac_m_cpu_750=yes
13777 < else
13778 <        ac_m_cpu_750=no
13779 < fi
13780 < rm -f conftest*
13781 <
13782 < fi
13783 < { echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
13784 < echo "${ECHO_T}$ac_m_cpu_750" >&6; }
13785 < if test "$ac_m_cpu_750" = yes; then
13786 <        :
13787 <        CPU_FLAGS=-mcpu=750
13788 < else
13789 <        :
13790 <
13791 < fi
13792 <
13793 < else
13794 <        :
13795 <
13796 < fi
13797 <
13798 <                fi
13799 <                if test -z "$CPU_FLAGS"; then
13800 <
13801 <
13802 < { echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
13803 < echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6; }
13804 < if test "${ac_m_cpu_powerpc+set}" = set; then
13805 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13806 < else
13807 <  echo 'void f(){}' > conftest.cpp
13808 < if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
13809 <        ac_m_cpu_powerpc=yes
13810 < else
13811 <        ac_m_cpu_powerpc=no
13812 < fi
13813 < rm -f conftest*
13814 <
13815 < fi
13816 < { echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
13817 < echo "${ECHO_T}$ac_m_cpu_powerpc" >&6; }
13818 < if test "$ac_m_cpu_powerpc" = yes; then
13819 <        :
13820 <        CPU_FLAGS=-mcpu=powerpc
13821 < else
13822 <        :
13823 <
13824 < fi
13825 <
13826 <                fi
13827 <                if test -z "$CPU_FLAGS"; then
13828 <
13829 <
13830 < { echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
13831 < echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6; }
13832 < if test "${ac_m_powerpc+set}" = set; then
13833 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13834 < else
13835 <  echo 'void f(){}' > conftest.cpp
13836 < if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
13837 <        ac_m_powerpc=yes
13838 < else
13839 <        ac_m_powerpc=no
13840 < fi
13841 < rm -f conftest*
13842 <
13843 < fi
13844 < { echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
13845 < echo "${ECHO_T}$ac_m_powerpc" >&6; }
13846 < if test "$ac_m_powerpc" = yes; then
13847 <        :
13848 <        CPU_FLAGS=-mpowerpc
13849 < else
13850 <        :
13851 <
13852 < fi
13853 <
13854 <                fi
13855 <          esac
13856 <  fi
13857 <
13858 <  if test -n "$CPU_FLAGS"; then
13859 <        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
13860 <  fi
13861 <
13862 <  if test -z "$CXXFLAGS"; then
13863 <        echo ""
13864 <        echo "**********************************************************"
13865 <        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
13866 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
13867 <        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
13868 <        echo "**********************************************************"
13869 <        echo ""
13870 <        CXXFLAGS="-O3"
13871 <  fi
13872 <
13873 <
13874 <
13875 < { echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
13876 < echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6; }
13877 < if test "${ac_guessed_cxxflags+set}" = set; then
13878 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13879 < else
13880 <  echo 'void f(){}' > conftest.cpp
13881 < if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
13882 <        ac_guessed_cxxflags=yes
13883 < else
13884 <        ac_guessed_cxxflags=no
13885 < fi
13886 < rm -f conftest*
13887 <
13888 < fi
13889 < { echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
13890 < echo "${ECHO_T}$ac_guessed_cxxflags" >&6; }
13891 < if test "$ac_guessed_cxxflags" = yes; then
13892 <        :
13893 <
13894 < else
13895 <        :
13896 <
13897 <        echo ""
13898 <        echo "**********************************************************"
13899 <        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
13900 <        echo "* your compiler.                                         *"
13901 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
13902 <        echo "**********************************************************"
13903 <        echo ""
13904 <        CXXFLAGS=""
13905 <
13906 < fi
13907 <
13908 <
13909 < fi
13910 <
13911 <     ;;
13912 < esac
13913 <
13914 <
13915 < cat >>confdefs.h <<\_ACEOF
13916 < #define OBAPI
13917 < _ACEOF
13918 <
13919 <
13920 <
13921 <
13922 < # Check whether --with-mpi was given.
13923 < if test "${with_mpi+set}" = set; then
13924 <  withval=$with_mpi; with_mpi=$withval
13925 < else
13926 <  with_mpi="no"
13927 < fi
13928 <
13929 <
13930 < case "x$with_mpi" in
13931 <        xyes | "x")  USE_MPI=yes;;
13932 <        xno) USE_MPI=no ;;
13933 <        *) MPI="$with_mpi"; USE_MPI=yes ;;
13934 < esac
13935 < if test "$USE_MPI" = "yes" -a -z "$with_mpi"; then
13936 <        MPI="/usr/local"
13937 < fi
13938 < if test "$USE_MPI" = "yes"; then
13939 <
13940 <
13941 < # Set variables...
13942 < MPI_LIB_DIR="$MPI/lib"
13943 < MPI_INC_DIR="$MPI/include"
13944 <
13945 <
13946 <
13947 < ac_ext=c
13948 < ac_cpp='$CPP $CPPFLAGS'
13949 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13950 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13951 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
13952 <
13953 < { echo "$as_me:$LINENO: checking for mpi.h" >&5
13954 < echo $ECHO_N "checking for mpi.h... $ECHO_C" >&6; }
13955 < have_mpi_h=0
13956 < rm -f conftest*
13957 < echo '#include <mpi.h>' > conftest.c
13958 < if ${CC} -I${MPI_INC_DIR} -c conftest.c 2>&1 ; then
13959 <        { echo "$as_me:$LINENO: result: yes" >&5
13960 < echo "${ECHO_T}yes" >&6; }
13961 <        have_mpi_h=1
13962 < else
13963 <        if test -s conftest.out ; then
13964 <                cat conftest.out >> config.log
13965 <        fi
13966 <        { echo "$as_me:$LINENO: result: no! Check MPI include paths" >&5
13967 < echo "${ECHO_T}no! Check MPI include paths" >&6; }
13968 <        USE_MPI="no"
13969 < fi
13970 < rm -f conftest*
13971 < if test "$have_mpi_h" = 1; then
13972 <
13973 < cat >>confdefs.h <<\_ACEOF
13974 < #define HAVE_MPI_H 1
13975 < _ACEOF
13976 <
13977 < fi
13978 <
13979 < { echo "$as_me:$LINENO: checking whether mpif.h is usable" >&5
13980 < echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6; }
13981 <
13982 < ac_ext=${ac_fc_srcext-f}
13983 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
13984 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
13985 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
13986 <
13987 < ac_save_ext=$ac_ext
13988 < ac_ext=F90
13989 < ac_save_FCFLAGS=$FCFLAGS
13990 < have_mpif_h=0
13991 < rm -f conftest*
13992 < cat >conftest.$ac_ext <<EOF
13993 < program main
13994 <   include 'mpif.h'
13995 < end
13996 < EOF
13997 < if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13998 <        { echo "$as_me:$LINENO: result: yes" >&5
13999 < echo "${ECHO_T}yes" >&6; }
14000 <        MPI_F90_INC="$MPI_INC_DIR"
14001 <        have_mpif_h=1
14002 < else
14003 <        if test -s conftest.out ; then
14004 <                cat conftest.out >> config.log
14005 <        fi
14006 <        { echo "$as_me:$LINENO: result: no! Check MPI include paths" >&5
14007 < echo "${ECHO_T}no! Check MPI include paths" >&6; }
14008 <        USE_MPI="no"
14009 < fi
14010 < rm -f conftest*
14011 <
14012 < if test "$have_mpif_h" = 1; then
14013 <
14014 < cat >>confdefs.h <<\_ACEOF
14015 < #define HAVE_MPIF_H 1
14016 < _ACEOF
14017 <
14018 < fi
14019 < FCFLAGS=$ac_save_FCFLAGS
14020 < ac_ext=$ac_save_ext
14021 < ac_ext=c
14022 < ac_cpp='$CPP $CPPFLAGS'
14023 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
14024 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
14025 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
14026 <
14027 <
14028 < ac_ext=c
14029 < ac_cpp='$CPP $CPPFLAGS'
14030 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
14031 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
14032 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
14033 <
14034 < ac_save_LDFLAGS=$LDFLAGS
14035 < LDFLAGS="-L${MPI_LIB_DIR} ${LDFLAGS} "
14036 <
14037 < if test x = x"$MPI_LIB"; then
14038 <        { echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
14039 < echo $ECHO_N "checking for MPI_Init in -lmpich... $ECHO_C" >&6; }
14040 < if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then
14041 <  echo $ECHO_N "(cached) $ECHO_C" >&6
14042 < else
14043 <  ac_check_lib_save_LIBS=$LIBS
14044 < LIBS="-lmpich  $LIBS"
14045 < cat >conftest.$ac_ext <<_ACEOF
14046 < /* confdefs.h.  */
14047 < _ACEOF
14048 < cat confdefs.h >>conftest.$ac_ext
14049 < cat >>conftest.$ac_ext <<_ACEOF
14050 < /* end confdefs.h.  */
14051 <
14052 < /* Override any GCC internal prototype to avoid an error.
14053 <   Use char because int might match the return type of a GCC
14054 <   builtin and then its argument prototype would still apply.  */
14055 < #ifdef __cplusplus
14056 < extern "C"
14057 < #endif
14058 < char MPI_Init ();
14059 < #ifdef FC_DUMMY_MAIN
14060 < #ifndef FC_DUMMY_MAIN_EQ_F77
14061 < #  ifdef __cplusplus
14062 <     extern "C"
14063 < #  endif
14064 <   int FC_DUMMY_MAIN() { return 1; }
14065 < #endif
14066 < #endif
14067 < int
14068 < main ()
14069 < {
14070 < return MPI_Init ();
14071 <  ;
14072 <  return 0;
14073 < }
14074 < _ACEOF
14075 < rm -f conftest.$ac_objext conftest$ac_exeext
14076 < if { (ac_try="$ac_link"
14077 < case "(($ac_try" in
14078 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
14079 <  *) ac_try_echo=$ac_try;;
14080 < esac
14081 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
14082 <  (eval "$ac_link") 2>conftest.er1
14083 <  ac_status=$?
14084 <  grep -v '^ *+' conftest.er1 >conftest.err
14085 <  rm -f conftest.er1
14086 <  cat conftest.err >&5
14087 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14088 <  (exit $ac_status); } && {
14089 <         test -z "$ac_c_werror_flag" ||
14090 <         test ! -s conftest.err
14091 <       } && test -s conftest$ac_exeext &&
14092 <       $as_test_x conftest$ac_exeext; then
14093 <  ac_cv_lib_mpich_MPI_Init=yes
14094 < else
14095 <  echo "$as_me: failed program was:" >&5
14096 < sed 's/^/| /' conftest.$ac_ext >&5
14097 <
14098 <        ac_cv_lib_mpich_MPI_Init=no
14099 < fi
14100 <
14101 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
14102 <      conftest$ac_exeext conftest.$ac_ext
14103 < LIBS=$ac_check_lib_save_LIBS
14104 < fi
14105 < { echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
14106 < echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6; }
14107 < if test $ac_cv_lib_mpich_MPI_Init = yes; then
14108 <  MPI_LIB="-lmpich"
14109 < fi
14110 <
14111 < fi
14112 < $as_unset ac_cv_lib_mpich_MPI_Init
14113 < if test x = x"$MPI_LIB"; then
14114 <        { echo "$as_me:$LINENO: checking for MPI_Init in -lpmpich" >&5
14115 < echo $ECHO_N "checking for MPI_Init in -lpmpich... $ECHO_C" >&6; }
14116 < if test "${ac_cv_lib_pmpich_MPI_Init+set}" = set; then
14117 <  echo $ECHO_N "(cached) $ECHO_C" >&6
14118 < else
14119 <  ac_check_lib_save_LIBS=$LIBS
14120 < LIBS="-lpmpich -lmpich -lpmpich -lmpich $LIBS"
14121 < cat >conftest.$ac_ext <<_ACEOF
14122 < /* confdefs.h.  */
14123 < _ACEOF
14124 < cat confdefs.h >>conftest.$ac_ext
14125 < cat >>conftest.$ac_ext <<_ACEOF
14126 < /* end confdefs.h.  */
14127 <
14128 < /* Override any GCC internal prototype to avoid an error.
14129 <   Use char because int might match the return type of a GCC
14130 <   builtin and then its argument prototype would still apply.  */
14131 < #ifdef __cplusplus
14132 < extern "C"
14133 < #endif
14134 < char MPI_Init ();
14135 < #ifdef FC_DUMMY_MAIN
14136 < #ifndef FC_DUMMY_MAIN_EQ_F77
14137 < #  ifdef __cplusplus
14138 <     extern "C"
14139 < #  endif
14140 <   int FC_DUMMY_MAIN() { return 1; }
14141 < #endif
14142 < #endif
14143 < int
14144 < main ()
14145 < {
14146 < return MPI_Init ();
14147 <  ;
14148 <  return 0;
14149 < }
14150 < _ACEOF
14151 < rm -f conftest.$ac_objext conftest$ac_exeext
14152 < if { (ac_try="$ac_link"
14153 < case "(($ac_try" in
14154 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
14155 <  *) ac_try_echo=$ac_try;;
14156 < esac
14157 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
14158 <  (eval "$ac_link") 2>conftest.er1
14159 <  ac_status=$?
14160 <  grep -v '^ *+' conftest.er1 >conftest.err
14161 <  rm -f conftest.er1
14162 <  cat conftest.err >&5
14163 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14164 <  (exit $ac_status); } && {
14165 <         test -z "$ac_c_werror_flag" ||
14166 <         test ! -s conftest.err
14167 <       } && test -s conftest$ac_exeext &&
14168 <       $as_test_x conftest$ac_exeext; then
14169 <  ac_cv_lib_pmpich_MPI_Init=yes
14170 < else
14171 <  echo "$as_me: failed program was:" >&5
14172 < sed 's/^/| /' conftest.$ac_ext >&5
6335 > $as_echo "#define HAVE_STDBOOL_H 1" >>confdefs.h
6336 >
6337 > fi
6338 >
6339 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5
6340 > $as_echo_n "checking for an ANSI C-conforming const... " >&6; }
6341 > if ${ac_cv_c_const+:} false; then :
6342 >  $as_echo_n "(cached) " >&6
6343 > else
6344 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6345 > /* end confdefs.h.  */
6346 >
6347 > int
6348 > main ()
6349 > {
6350 > /* FIXME: Include the comments suggested by Paul. */
6351 > #ifndef __cplusplus
6352 >  /* Ultrix mips cc rejects this.  */
6353 >  typedef int charset[2];
6354 >  const charset cs;
6355 >  /* SunOS 4.1.1 cc rejects this.  */
6356 >  char const *const *pcpcc;
6357 >  char **ppc;
6358 >  /* NEC SVR4.0.2 mips cc rejects this.  */
6359 >  struct point {int x, y;};
6360 >  static struct point const zero = {0,0};
6361 >  /* AIX XL C 1.02.0.0 rejects this.
6362 >     It does not let you subtract one const X* pointer from another in
6363 >     an arm of an if-expression whose if-part is not a constant
6364 >     expression */
6365 >  const char *g = "string";
6366 >  pcpcc = &g + (g ? g-g : 0);
6367 >  /* HPUX 7.0 cc rejects these. */
6368 >  ++pcpcc;
6369 >  ppc = (char**) pcpcc;
6370 >  pcpcc = (char const *const *) ppc;
6371 >  { /* SCO 3.2v4 cc rejects this.  */
6372 >    char *t;
6373 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
6374 >
6375 >    *t++ = 0;
6376 >    if (s) return 0;
6377 >  }
6378 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
6379 >    int x[] = {25, 17};
6380 >    const int *foo = &x[0];
6381 >    ++foo;
6382 >  }
6383 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
6384 >    typedef const int *iptr;
6385 >    iptr p = 0;
6386 >    ++p;
6387 >  }
6388 >  { /* AIX XL C 1.02.0.0 rejects this saying
6389 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
6390 >    struct s { int j; const int *ap[3]; };
6391 >    struct s *b; b->j = 5;
6392 >  }
6393 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
6394 >    const int foo = 10;
6395 >    if (!foo) return 0;
6396 >  }
6397 >  return !cs[0] && !zero.x;
6398 > #endif
6399 >
6400 >  ;
6401 >  return 0;
6402 > }
6403 > _ACEOF
6404 > if ac_fn_c_try_compile "$LINENO"; then :
6405 >  ac_cv_c_const=yes
6406 > else
6407 >  ac_cv_c_const=no
6408 > fi
6409 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6410 > fi
6411 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5
6412 > $as_echo "$ac_cv_c_const" >&6; }
6413 > if test $ac_cv_c_const = no; then
6414 >
6415 > $as_echo "#define const /**/" >>confdefs.h
6416 >
6417 > fi
6418 >
6419 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for inline" >&5
6420 > $as_echo_n "checking for inline... " >&6; }
6421 > if ${ac_cv_c_inline+:} false; then :
6422 >  $as_echo_n "(cached) " >&6
6423 > else
6424 >  ac_cv_c_inline=no
6425 > for ac_kw in inline __inline__ __inline; do
6426 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6427 > /* end confdefs.h.  */
6428 > #ifndef __cplusplus
6429 > typedef int foo_t;
6430 > static $ac_kw foo_t static_foo () {return 0; }
6431 > $ac_kw foo_t foo () {return 0; }
6432 > #endif
6433 >
6434 > _ACEOF
6435 > if ac_fn_c_try_compile "$LINENO"; then :
6436 >  ac_cv_c_inline=$ac_kw
6437 > fi
6438 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6439 >  test "$ac_cv_c_inline" != no && break
6440 > done
6441 >
6442 > fi
6443 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline" >&5
6444 > $as_echo "$ac_cv_c_inline" >&6; }
6445 >
6446 > case $ac_cv_c_inline in
6447 >  inline | yes) ;;
6448 >  *)
6449 >    case $ac_cv_c_inline in
6450 >      no) ac_val=;;
6451 >      *) ac_val=$ac_cv_c_inline;;
6452 >    esac
6453 >    cat >>confdefs.h <<_ACEOF
6454 > #ifndef __cplusplus
6455 > #define inline $ac_val
6456 > #endif
6457 > _ACEOF
6458 >    ;;
6459 > esac
6460 >
6461 > ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
6462 > if test "x$ac_cv_type_size_t" = xyes; then :
6463 >
6464 > else
6465 >
6466 > cat >>confdefs.h <<_ACEOF
6467 > #define size_t unsigned int
6468 > _ACEOF
6469 >
6470 > fi
6471 >
6472 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether time.h and sys/time.h may both be included" >&5
6473 > $as_echo_n "checking whether time.h and sys/time.h may both be included... " >&6; }
6474 > if ${ac_cv_header_time+:} false; then :
6475 >  $as_echo_n "(cached) " >&6
6476 > else
6477 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6478 > /* end confdefs.h.  */
6479 > #include <sys/types.h>
6480 > #include <sys/time.h>
6481 > #include <time.h>
6482 >
6483 > int
6484 > main ()
6485 > {
6486 > if ((struct tm *) 0)
6487 > return 0;
6488 >  ;
6489 >  return 0;
6490 > }
6491 > _ACEOF
6492 > if ac_fn_c_try_compile "$LINENO"; then :
6493 >  ac_cv_header_time=yes
6494 > else
6495 >  ac_cv_header_time=no
6496 > fi
6497 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6498 > fi
6499 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_time" >&5
6500 > $as_echo "$ac_cv_header_time" >&6; }
6501 > if test $ac_cv_header_time = yes; then
6502 >
6503 > $as_echo "#define TIME_WITH_SYS_TIME 1" >>confdefs.h
6504 >
6505 > fi
6506 >
6507 >
6508 > # Checks for library functions.
6509 > for ac_header in stdlib.h
6510 > do :
6511 >  ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
6512 > if test "x$ac_cv_header_stdlib_h" = xyes; then :
6513 >  cat >>confdefs.h <<_ACEOF
6514 > #define HAVE_STDLIB_H 1
6515 > _ACEOF
6516 >
6517 > fi
6518 >
6519 > done
6520 >
6521 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible malloc" >&5
6522 > $as_echo_n "checking for GNU libc compatible malloc... " >&6; }
6523 > if ${ac_cv_func_malloc_0_nonnull+:} false; then :
6524 >  $as_echo_n "(cached) " >&6
6525 > else
6526 >  if test "$cross_compiling" = yes; then :
6527 >  ac_cv_func_malloc_0_nonnull=no
6528 > else
6529 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6530 > /* end confdefs.h.  */
6531 > #if defined STDC_HEADERS || defined HAVE_STDLIB_H
6532 > # include <stdlib.h>
6533 > #else
6534 > char *malloc ();
6535 > #endif
6536 >
6537 > int
6538 > main ()
6539 > {
6540 > return ! malloc (0);
6541 >  ;
6542 >  return 0;
6543 > }
6544 > _ACEOF
6545 > if ac_fn_c_try_run "$LINENO"; then :
6546 >  ac_cv_func_malloc_0_nonnull=yes
6547 > else
6548 >  ac_cv_func_malloc_0_nonnull=no
6549 > fi
6550 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
6551 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
6552 > fi
6553 >
6554 > fi
6555 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_malloc_0_nonnull" >&5
6556 > $as_echo "$ac_cv_func_malloc_0_nonnull" >&6; }
6557 > if test $ac_cv_func_malloc_0_nonnull = yes; then :
6558 >
6559 > $as_echo "#define HAVE_MALLOC 1" >>confdefs.h
6560 >
6561 > else
6562 >  $as_echo "#define HAVE_MALLOC 0" >>confdefs.h
6563 >
6564 >   case " $LIBOBJS " in
6565 >  *" malloc.$ac_objext "* ) ;;
6566 >  *) LIBOBJS="$LIBOBJS malloc.$ac_objext"
6567 > ;;
6568 > esac
6569 >
6570 >
6571 > $as_echo "#define malloc rpl_malloc" >>confdefs.h
6572 >
6573 > fi
6574 >
6575 >
6576 > for ac_header in stdlib.h
6577 > do :
6578 >  ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
6579 > if test "x$ac_cv_header_stdlib_h" = xyes; then :
6580 >  cat >>confdefs.h <<_ACEOF
6581 > #define HAVE_STDLIB_H 1
6582 > _ACEOF
6583 >
6584 > fi
6585 >
6586 > done
6587 >
6588 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible realloc" >&5
6589 > $as_echo_n "checking for GNU libc compatible realloc... " >&6; }
6590 > if ${ac_cv_func_realloc_0_nonnull+:} false; then :
6591 >  $as_echo_n "(cached) " >&6
6592 > else
6593 >  if test "$cross_compiling" = yes; then :
6594 >  ac_cv_func_realloc_0_nonnull=no
6595 > else
6596 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6597 > /* end confdefs.h.  */
6598 > #if defined STDC_HEADERS || defined HAVE_STDLIB_H
6599 > # include <stdlib.h>
6600 > #else
6601 > char *realloc ();
6602 > #endif
6603 >
6604 > int
6605 > main ()
6606 > {
6607 > return ! realloc (0, 0);
6608 >  ;
6609 >  return 0;
6610 > }
6611 > _ACEOF
6612 > if ac_fn_c_try_run "$LINENO"; then :
6613 >  ac_cv_func_realloc_0_nonnull=yes
6614 > else
6615 >  ac_cv_func_realloc_0_nonnull=no
6616 > fi
6617 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
6618 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
6619 > fi
6620 >
6621 > fi
6622 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_realloc_0_nonnull" >&5
6623 > $as_echo "$ac_cv_func_realloc_0_nonnull" >&6; }
6624 > if test $ac_cv_func_realloc_0_nonnull = yes; then :
6625 >
6626 > $as_echo "#define HAVE_REALLOC 1" >>confdefs.h
6627 >
6628 > else
6629 >  $as_echo "#define HAVE_REALLOC 0" >>confdefs.h
6630 >
6631 >   case " $LIBOBJS " in
6632 >  *" realloc.$ac_objext "* ) ;;
6633 >  *) LIBOBJS="$LIBOBJS realloc.$ac_objext"
6634 > ;;
6635 > esac
6636 >
6637 >
6638 > $as_echo "#define realloc rpl_realloc" >>confdefs.h
6639 >
6640 > fi
6641 >
6642 >
6643 > for ac_header in sys/select.h sys/socket.h
6644 > do :
6645 >  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
6646 > ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
6647 > if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
6648 >  cat >>confdefs.h <<_ACEOF
6649 > #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
6650 > _ACEOF
6651 >
6652 > fi
6653 >
6654 > done
6655 >
6656 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking types of arguments for select" >&5
6657 > $as_echo_n "checking types of arguments for select... " >&6; }
6658 > if ${ac_cv_func_select_args+:} false; then :
6659 >  $as_echo_n "(cached) " >&6
6660 > else
6661 >  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
6662 > for ac_arg1 in 'int' 'size_t' 'unsigned long int' 'unsigned int'; do
6663 >  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
6664 >   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6665 > /* end confdefs.h.  */
6666 > $ac_includes_default
6667 > #ifdef HAVE_SYS_SELECT_H
6668 > # include <sys/select.h>
6669 > #endif
6670 > #ifdef HAVE_SYS_SOCKET_H
6671 > # include <sys/socket.h>
6672 > #endif
6673 >
6674 > int
6675 > main ()
6676 > {
6677 > extern int select ($ac_arg1,
6678 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
6679 >                                            $ac_arg5);
6680 >  ;
6681 >  return 0;
6682 > }
6683 > _ACEOF
6684 > if ac_fn_c_try_compile "$LINENO"; then :
6685 >  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
6686 > fi
6687 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6688 >  done
6689 > done
6690 > done
6691 > # Provide a safe default value.
6692 > : "${ac_cv_func_select_args=int,int *,struct timeval *}"
6693 >
6694 > fi
6695 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_select_args" >&5
6696 > $as_echo "$ac_cv_func_select_args" >&6; }
6697 > ac_save_IFS=$IFS; IFS=','
6698 > set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
6699 > IFS=$ac_save_IFS
6700 > shift
6701 >
6702 > cat >>confdefs.h <<_ACEOF
6703 > #define SELECT_TYPE_ARG1 $1
6704 > _ACEOF
6705 >
6706 >
6707 > cat >>confdefs.h <<_ACEOF
6708 > #define SELECT_TYPE_ARG234 ($2)
6709 > _ACEOF
6710 >
6711 >
6712 > cat >>confdefs.h <<_ACEOF
6713 > #define SELECT_TYPE_ARG5 ($3)
6714 > _ACEOF
6715  
6716 <        ac_cv_lib_pmpich_MPI_Init=no
14175 < fi
6716 > rm -f conftest*
6717  
6718 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6719 <      conftest$ac_exeext conftest.$ac_ext
6720 < LIBS=$ac_check_lib_save_LIBS
6721 < fi
14181 < { echo "$as_me:$LINENO: result: $ac_cv_lib_pmpich_MPI_Init" >&5
14182 < echo "${ECHO_T}$ac_cv_lib_pmpich_MPI_Init" >&6; }
14183 < if test $ac_cv_lib_pmpich_MPI_Init = yes; then
14184 <  MPI_LIB="-lpmpich -lmpich -lpmpich -lmpich"
14185 < fi
14186 <
14187 < fi
14188 < if test x = x"$MPI_LIB"; then
14189 <        { echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
14190 < echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6; }
14191 < if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
14192 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6718 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working strtod" >&5
6719 > $as_echo_n "checking for working strtod... " >&6; }
6720 > if ${ac_cv_func_strtod+:} false; then :
6721 >  $as_echo_n "(cached) " >&6
6722   else
6723 <  ac_check_lib_save_LIBS=$LIBS
6724 < LIBS="-lmpi  $LIBS"
6725 < cat >conftest.$ac_ext <<_ACEOF
6726 < /* confdefs.h.  */
14198 < _ACEOF
14199 < cat confdefs.h >>conftest.$ac_ext
14200 < cat >>conftest.$ac_ext <<_ACEOF
6723 >  if test "$cross_compiling" = yes; then :
6724 >  ac_cv_func_strtod=no
6725 > else
6726 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6727   /* end confdefs.h.  */
6728  
6729 < /* Override any GCC internal prototype to avoid an error.
6730 <   Use char because int might match the return type of a GCC
6731 <   builtin and then its argument prototype would still apply.  */
14206 < #ifdef __cplusplus
14207 < extern "C"
6729 > $ac_includes_default
6730 > #ifndef strtod
6731 > double strtod ();
6732   #endif
14209 – char MPI_Init ();
14210 – #ifdef FC_DUMMY_MAIN
14211 – #ifndef FC_DUMMY_MAIN_EQ_F77
14212 – #  ifdef __cplusplus
14213 –     extern "C"
14214 – #  endif
14215 –   int FC_DUMMY_MAIN() { return 1; }
14216 – #endif
14217 – #endif
6733   int
6734 < main ()
6734 > main()
6735   {
6736 < return MPI_Init ();
6737 <  ;
6736 >  {
6737 >    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
6738 >    char *string = " +69";
6739 >    char *term;
6740 >    double value;
6741 >    value = strtod (string, &term);
6742 >    if (value != 69 || term != (string + 4))
6743 >      return 1;
6744 >  }
6745 >
6746 >  {
6747 >    /* Under Solaris 2.4, strtod returns the wrong value for the
6748 >       terminating character under some conditions.  */
6749 >    char *string = "NaN";
6750 >    char *term;
6751 >    strtod (string, &term);
6752 >    if (term != string && *(term - 1) == 0)
6753 >      return 1;
6754 >  }
6755    return 0;
6756   }
6757 +
6758   _ACEOF
6759 < rm -f conftest.$ac_objext conftest$ac_exeext
6760 < if { (ac_try="$ac_link"
14228 < case "(($ac_try" in
14229 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
14230 <  *) ac_try_echo=$ac_try;;
14231 < esac
14232 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
14233 <  (eval "$ac_link") 2>conftest.er1
14234 <  ac_status=$?
14235 <  grep -v '^ *+' conftest.er1 >conftest.err
14236 <  rm -f conftest.er1
14237 <  cat conftest.err >&5
14238 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14239 <  (exit $ac_status); } && {
14240 <         test -z "$ac_c_werror_flag" ||
14241 <         test ! -s conftest.err
14242 <       } && test -s conftest$ac_exeext &&
14243 <       $as_test_x conftest$ac_exeext; then
14244 <  ac_cv_lib_mpi_MPI_Init=yes
6759 > if ac_fn_c_try_run "$LINENO"; then :
6760 >  ac_cv_func_strtod=yes
6761   else
6762 <  echo "$as_me: failed program was:" >&5
14247 < sed 's/^/| /' conftest.$ac_ext >&5
14248 <
14249 <        ac_cv_lib_mpi_MPI_Init=no
6762 >  ac_cv_func_strtod=no
6763   fi
6764 + rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
6765 +  conftest.$ac_objext conftest.beam conftest.$ac_ext
6766 + fi
6767  
14252 – rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
14253 –      conftest$ac_exeext conftest.$ac_ext
14254 – LIBS=$ac_check_lib_save_LIBS
6768   fi
6769 < { echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
6770 < echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6; }
6771 < if test $ac_cv_lib_mpi_MPI_Init = yes; then
6772 <  MPI_LIB="-lmpi"
6773 < fi
6769 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_strtod" >&5
6770 > $as_echo "$ac_cv_func_strtod" >&6; }
6771 > if test $ac_cv_func_strtod = no; then
6772 >  case " $LIBOBJS " in
6773 >  *" strtod.$ac_objext "* ) ;;
6774 >  *) LIBOBJS="$LIBOBJS strtod.$ac_objext"
6775 > ;;
6776 > esac
6777  
6778 + ac_fn_c_check_func "$LINENO" "pow" "ac_cv_func_pow"
6779 + if test "x$ac_cv_func_pow" = xyes; then :
6780 +
6781   fi
6782 < $as_unset ac_cv_lib_mpi_MPI_Init
6783 < if test x = x"$MPI_LIB"; then
6784 <        { echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
6785 < echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6; }
6786 < if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
6787 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6782 >
6783 > if test $ac_cv_func_pow = no; then
6784 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pow in -lm" >&5
6785 > $as_echo_n "checking for pow in -lm... " >&6; }
6786 > if ${ac_cv_lib_m_pow+:} false; then :
6787 >  $as_echo_n "(cached) " >&6
6788   else
6789    ac_check_lib_save_LIBS=$LIBS
6790 < LIBS="-lmpi -llam $LIBS"
6791 < cat >conftest.$ac_ext <<_ACEOF
14273 < /* confdefs.h.  */
14274 < _ACEOF
14275 < cat confdefs.h >>conftest.$ac_ext
14276 < cat >>conftest.$ac_ext <<_ACEOF
6790 > LIBS="-lm  $LIBS"
6791 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6792   /* end confdefs.h.  */
6793  
6794   /* Override any GCC internal prototype to avoid an error.
# Line 14282 | Line 6797 | extern "C"
6797   #ifdef __cplusplus
6798   extern "C"
6799   #endif
6800 < char MPI_Init ();
14286 < #ifdef FC_DUMMY_MAIN
14287 < #ifndef FC_DUMMY_MAIN_EQ_F77
14288 < #  ifdef __cplusplus
14289 <     extern "C"
14290 < #  endif
14291 <   int FC_DUMMY_MAIN() { return 1; }
14292 < #endif
14293 < #endif
6800 > char pow ();
6801   int
6802   main ()
6803   {
6804 < return MPI_Init ();
6804 > return pow ();
6805    ;
6806    return 0;
6807   }
6808   _ACEOF
6809 < rm -f conftest.$ac_objext conftest$ac_exeext
6810 < if { (ac_try="$ac_link"
14304 < case "(($ac_try" in
14305 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
14306 <  *) ac_try_echo=$ac_try;;
14307 < esac
14308 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
14309 <  (eval "$ac_link") 2>conftest.er1
14310 <  ac_status=$?
14311 <  grep -v '^ *+' conftest.er1 >conftest.err
14312 <  rm -f conftest.er1
14313 <  cat conftest.err >&5
14314 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14315 <  (exit $ac_status); } && {
14316 <         test -z "$ac_c_werror_flag" ||
14317 <         test ! -s conftest.err
14318 <       } && test -s conftest$ac_exeext &&
14319 <       $as_test_x conftest$ac_exeext; then
14320 <  ac_cv_lib_mpi_MPI_Init=yes
6809 > if ac_fn_c_try_link "$LINENO"; then :
6810 >  ac_cv_lib_m_pow=yes
6811   else
6812 <  echo "$as_me: failed program was:" >&5
14323 < sed 's/^/| /' conftest.$ac_ext >&5
14324 <
14325 <        ac_cv_lib_mpi_MPI_Init=no
6812 >  ac_cv_lib_m_pow=no
6813   fi
6814 <
6815 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
14329 <      conftest$ac_exeext conftest.$ac_ext
6814 > rm -f core conftest.err conftest.$ac_objext \
6815 >    conftest$ac_exeext conftest.$ac_ext
6816   LIBS=$ac_check_lib_save_LIBS
6817   fi
6818 < { echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
6819 < echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6; }
6820 < if test $ac_cv_lib_mpi_MPI_Init = yes; then
6821 <  MPI_LIB="-lmpi -llam"
6818 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_pow" >&5
6819 > $as_echo "$ac_cv_lib_m_pow" >&6; }
6820 > if test "x$ac_cv_lib_m_pow" = xyes; then :
6821 >  POW_LIB=-lm
6822 > else
6823 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cannot find library containing definition of pow" >&5
6824 > $as_echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
6825   fi
6826  
6827   fi
6828 < $as_unset ac_cv_lib_mpi_MPI_Init
6829 < if test x = x"$MPI_LIB"; then
6830 < { echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
6831 < echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6; }
6832 < if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
6833 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6834 < else
6835 <  ac_check_lib_save_LIBS=$LIBS
6836 < LIBS="-lmpi -llam -lpthread $LIBS"
6837 < cat >conftest.$ac_ext <<_ACEOF
14349 < /* confdefs.h.  */
6828 >
6829 > fi
6830 >
6831 > for ac_func in floor getpagesize gettimeofday memset pow pstat_getdynamic pstat_getstatic select sqrt strcasecmp strchr strdup stricmp strncasecmp strnicmp strstr strtol sysmp getsysinfo sysctl table
6832 > do :
6833 >  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
6834 > ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
6835 > if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
6836 >  cat >>confdefs.h <<_ACEOF
6837 > #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
6838   _ACEOF
14351 – cat confdefs.h >>conftest.$ac_ext
14352 – cat >>conftest.$ac_ext <<_ACEOF
14353 – /* end confdefs.h.  */
6839  
6840 < /* Override any GCC internal prototype to avoid an error.
6841 <   Use char because int might match the return type of a GCC
6842 <   builtin and then its argument prototype would still apply.  */
6843 < #ifdef __cplusplus
6844 < extern "C"
6845 < #endif
6846 < char MPI_Init ();
6847 < #ifdef FC_DUMMY_MAIN
6848 < #ifndef FC_DUMMY_MAIN_EQ_F77
6849 < #  ifdef __cplusplus
6850 <     extern "C"
14366 < #  endif
14367 <   int FC_DUMMY_MAIN() { return 1; }
14368 < #endif
14369 < #endif
6840 > fi
6841 > done
6842 >
6843 >
6844 > # special check for _system_configuration because AIX <4.3.2 do not
6845 > # contain the `physmem' member.
6846 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for external symbol _system_configuration" >&5
6847 > $as_echo_n "checking for external symbol _system_configuration... " >&6; }
6848 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6849 > /* end confdefs.h.  */
6850 > #include <sys/systemcfg.h>
6851   int
6852   main ()
6853   {
6854 < return MPI_Init ();
6854 > double x = _system_configuration.physmem;
6855    ;
6856    return 0;
6857   }
6858   _ACEOF
6859 < rm -f conftest.$ac_objext conftest$ac_exeext
6860 < if { (ac_try="$ac_link"
6861 < case "(($ac_try" in
6862 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6863 <  *) ac_try_echo=$ac_try;;
6864 < esac
6865 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6866 <  (eval "$ac_link") 2>conftest.er1
6859 > if ac_fn_c_try_compile "$LINENO"; then :
6860 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
6861 > $as_echo "yes" >&6; }
6862 >
6863 > $as_echo "#define HAVE__SYSTEM_CONFIGURATION 1" >>confdefs.h
6864 >
6865 > else
6866 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6867 > $as_echo "no" >&6; }
6868 > fi
6869 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6870 >
6871 >
6872 > case $debug in
6873 >  1)
6874 >     ;;
6875 >  *)
6876 >
6877 >
6878 >
6879 >
6880 >
6881 >
6882 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are *really* using GNU cc" >&5
6883 > $as_echo_n "checking whether we are *really* using GNU cc... " >&6; }
6884 > if ${ac_cv_prog_really_gcc+:} false; then :
6885 >  $as_echo_n "(cached) " >&6
6886 > else
6887 >
6888 > cat > conftest.c <<EOF
6889 > #ifdef __GNUC__
6890 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
6891 >     no;
6892 >  #else
6893 >     yes;
6894 >  #endif
6895 > #endif
6896 > EOF
6897 > if { ac_try='${CC-cc} -E conftest.c'
6898 >  { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5
6899 >  (eval $ac_try) 2>&5
6900    ac_status=$?
6901 <  grep -v '^ *+' conftest.er1 >conftest.err
6902 <  rm -f conftest.er1
6903 <  cat conftest.err >&5
14390 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14391 <  (exit $ac_status); } && {
14392 <         test -z "$ac_c_werror_flag" ||
14393 <         test ! -s conftest.err
14394 <       } && test -s conftest$ac_exeext &&
14395 <       $as_test_x conftest$ac_exeext; then
14396 <  ac_cv_lib_mpi_MPI_Init=yes
6901 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
6902 >  test $ac_status = 0; }; } | egrep yes >/dev/null 2>&1; then
6903 >  ac_cv_prog_really_gcc=yes
6904   else
6905 <  echo "$as_me: failed program was:" >&5
6906 < sed 's/^/| /' conftest.$ac_ext >&5
6905 >  ac_cv_prog_really_gcc=no
6906 > fi
6907  
14401 –        ac_cv_lib_mpi_MPI_Init=no
6908   fi
6909 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_really_gcc" >&5
6910 + $as_echo "$ac_cv_prog_really_gcc" >&6; }
6911 + if test "$ac_cv_prog_really_gcc" = yes; then
6912 +        :
6913  
6914 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6915 <      conftest$ac_exeext conftest.$ac_ext
6916 < LIBS=$ac_check_lib_save_LIBS
6914 > else
6915 >        :
6916 >
6917   fi
6918 < { echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
6919 < echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6; }
6920 < if test $ac_cv_lib_mpi_MPI_Init = yes; then
6921 <  MPI_LIB="-lmpi -llam -lpthread"
6918 >
6919 >
6920 > # Try to determine "good" native compiler flags if none specified on command
6921 > # line
6922 > if test "$ac_test_CFLAGS" != "set"; then
6923 >  CFLAGS=""
6924 >  case "${host_cpu}-${host_os}" in
6925 >
6926 >  *linux*) if test "$CC" = icc; then
6927 >                    CFLAGS="-O2"
6928 >                fi;;
6929 >  sparc-solaris2*) if test "$CC" = cc; then
6930 >                    CFLAGS="-O -dalign"
6931 >                 fi;;
6932 >
6933 >  alpha*-osf*)  if test "$CC" = cc; then
6934 >                    CFLAGS="-newc -w0 -O5 -ansi_alias -ansi_args -fp_reorder -tune host -arch host -std1"
6935 >                fi;;
6936 >
6937 >  hppa*-hpux*)  if test "$CC" = cc; then
6938 >                    CFLAGS="-Ae +O3 +Oall"
6939 >                fi;;
6940 >
6941 >   rs6000*-aix*)  if test "$CC" = cc -o "$CC" = xlc; then
6942 >                    CFLAGS="-O3 -qtune=auto -qansialias -w"
6943 >                fi;;
6944 >   powerpc*-aix*)
6945 >        if test "$CC" = cc -o "$CC" = xlc; then
6946 >                CFLAGS="-O3 -qtune=auto -qansialias -w"
6947 >                echo "*******************************************************"
6948 >                echo "*  You have AIX on an unknown powerpc system.  It is  *"
6949 >                echo "*  recommended that you use                           *"
6950 >                echo "*                                                     *"
6951 >                echo "*    CFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
6952 >                echo "*                                 ^^^                 *"
6953 >                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
6954 >                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
6955 >                echo "*******************************************************"
6956 >        fi;;
6957 >   *darwin*)
6958 >        if test "$CC" = xlc; then
6959 >                CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
6960 >        fi
6961 >        if test "$CC" = icc; then
6962 >                CFLAGS="-O2"
6963 >        fi
6964 >        if test $ac_cv_prog_really_gcc = yes; then
6965 >                CFLAGS="-Os"
6966 >        fi;;
6967 >  esac
6968 >
6969 >  # use default flags for gcc on all systems
6970 >  if test $ac_cv_prog_really_gcc = yes -a -z "$CFLAGS"; then
6971 >     CFLAGS="-O2"
6972 >  fi
6973 >
6974 >  if test -z "$CFLAGS"; then
6975 >        echo ""
6976 >        echo "********************************************************"
6977 >        echo "* WARNING: Don't know the best CFLAGS for this system  *"
6978 >        echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
6979 >        echo "* (otherwise, a default of CFLAGS=-O will be used)     *"
6980 >        echo "********************************************************"
6981 >        echo ""
6982 >        CFLAGS="-O"
6983 >  fi
6984 >
6985 >
6986 >
6987 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts ${CFLAGS}" >&5
6988 > $as_echo_n "checking whether ${CC} accepts ${CFLAGS}... " >&6; }
6989 > if ${ac_cv_ac_cv_guessed_cflags+:} false; then :
6990 >  $as_echo_n "(cached) " >&6
6991   else
6992 +  echo 'void f(){}' > conftest.c
6993 + if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
6994 +        ac_cv_ac_cv_guessed_cflags=yes
6995 + else
6996 +        ac_cv_ac_cv_guessed_cflags=no
6997 + fi
6998 + rm -f conftest*
6999  
7000 <             { { echo "$as_me:$LINENO: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&5
7001 < echo "$as_me: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&2;}
7002 <   { (exit 1); exit 1; }; }
7003 <             USE_MPI="no"
7000 > fi
7001 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_ac_cv_guessed_cflags" >&5
7002 > $as_echo "$ac_cv_ac_cv_guessed_cflags" >&6; }
7003 > if test "$ac_cv_ac_cv_guessed_cflags" = yes; then
7004 >        :
7005  
7006 + else
7007 +        :
7008 +
7009 +        echo ""
7010 +        echo "********************************************************"
7011 +        echo "* WARNING: The guessed CFLAGS don't seem to work with  *"
7012 +        echo "* your compiler.                                       *"
7013 +        echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
7014 +        echo "********************************************************"
7015 +        echo ""
7016 +        CFLAGS=""
7017 +
7018   fi
7019  
7020 +
7021   fi
7022  
7023  
7024  
7025 < { echo "$as_me:$LINENO: checking for MPI Fortran library" >&5
7026 < echo $ECHO_N "checking for MPI Fortran library... $ECHO_C" >&6; }
7027 < MPI_F90_LIB=""
7028 < if test -f "$MPI_LIB_DIR/libfmpich.a" ; then
7029 <        MPI_F90_LIB="-lfmpich"
7030 < elif test -f "$MPI_LIB_DIR/liblamf77mpi.a" ; then
7031 <        MPI_F90_LIB="-llamf77mpi"
7025 >
7026 >
7027 >
7028 >
7029 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are *really* using GNU c++" >&5
7030 > $as_echo_n "checking whether we are *really* using GNU c++... " >&6; }
7031 > if ${ac_cv_prog_really_gxx+:} false; then :
7032 >  $as_echo_n "(cached) " >&6
7033   else
7034 <                        MPI_F90_LIB="  "
7034 >
7035 > cat > conftest.cpp <<EOF
7036 > #ifdef __GNUC__
7037 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
7038 >     no;
7039 >  #else
7040 >     yes;
7041 >  #endif
7042 > #endif
7043 > EOF
7044 > if { ac_try='${CXX-c++} -E conftest.cpp'
7045 >  { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5
7046 >  (eval $ac_try) 2>&5
7047 >  ac_status=$?
7048 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
7049 >  test $ac_status = 0; }; } | egrep yes >/dev/null 2>&1; then
7050 >  ac_cv_prog_really_gxx=yes
7051 > else
7052 >  ac_cv_prog_really_gxx=no
7053   fi
14435 – { echo "$as_me:$LINENO: result: found $MPI_F90_LIB" >&5
14436 – echo "${ECHO_T}found $MPI_F90_LIB" >&6; }
7054  
7055 + fi
7056 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_really_gxx" >&5
7057 + $as_echo "$ac_cv_prog_really_gxx" >&6; }
7058 + if test "$ac_cv_prog_really_gxx" = yes; then
7059 +        :
7060  
7061 + else
7062 +        :
7063 +
7064   fi
7065  
7066  
7067 + # Try to determine "good" native compiler flags if none specified on command
7068 + # line
7069 + if test "$ac_test_CXXFLAGS" != "set"; then
7070 +  CXXFLAGS=""
7071 +  case "${host_cpu}-${host_os}" in
7072  
7073 +  *linux*) if test "$CXX" = icc -o "$CXX" = icpc; then
7074 +                    CXXFLAGS="-O2"
7075 +                fi;;
7076 +  sparc-solaris2*) if test "$CXX" = CC; then
7077 +                    CXXFLAGS="-features=extensions -O -dalign"
7078 +                 fi;;
7079 +   rs6000*-aix*)  if test "$CXX" = xlC; then
7080 +                    CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
7081 +                fi;;
7082 +   powerpc*-aix*)
7083 +        if test "$CXX" = xlC; then
7084 +                CXXFLAGS="-O3 -qarch=ppc -qansialias -w"
7085 +                echo "*******************************************************"
7086 +                echo "*  You have AIX on an unknown powerpc system.  It is  *"
7087 +                echo "*  recommended that you use                           *"
7088 +                echo "*                                                     *"
7089 +                echo "*  CXXFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
7090 +                echo "*                                 ^^^                 *"
7091 +                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
7092 +                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
7093 +                echo "*******************************************************"
7094 +        fi;;
7095 +   *darwin*)
7096 +        if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
7097 +                CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
7098 +        fi
7099 +        if test "$CXX" = icpc; then
7100 +                CXXFLAGS="-O2"
7101 +        fi
7102 +        if test $ac_cv_prog_really_gxx = yes; then
7103 +                CXXFLAGS="-Os"
7104 +        fi;;
7105 +  esac
7106  
7107 +  # use default flags for gcc on all systems
7108 +  if test $ac_cv_prog_really_gxx = yes -a -z "$CXXFLAGS"; then
7109 +     CXXFLAGS="-O2"
7110 +  fi
7111 +
7112 +  if test -z "$CXXFLAGS"; then
7113 +        echo ""
7114 +        echo "**********************************************************"
7115 +        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
7116 +        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
7117 +        echo "* (otherwise, a default of CXXFLAGS=-O will be used)     *"
7118 +        echo "**********************************************************"
7119 +        echo ""
7120 +        CXXFLAGS="-O"
7121 +  fi
7122 +
7123 +
7124 +
7125 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
7126 + $as_echo_n "checking whether ${CXX} accepts ${CXXFLAGS}... " >&6; }
7127 + if ${ac_cv_ac_cv_guessed_cxxflags+:} false; then :
7128 +  $as_echo_n "(cached) " >&6
7129 + else
7130 +  echo 'void f(){}' > conftest.cpp
7131 + if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
7132 +        ac_cv_ac_cv_guessed_cxxflags=yes
7133 + else
7134 +        ac_cv_ac_cv_guessed_cxxflags=no
7135 + fi
7136 + rm -f conftest*
7137 +
7138 + fi
7139 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_ac_cv_guessed_cxxflags" >&5
7140 + $as_echo "$ac_cv_ac_cv_guessed_cxxflags" >&6; }
7141 + if test "$ac_cv_ac_cv_guessed_cxxflags" = yes; then
7142 +        :
7143 +
7144 + else
7145 +        :
7146 +
7147 +        echo ""
7148 +        echo "**********************************************************"
7149 +        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
7150 +        echo "* your compiler.                                         *"
7151 +        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
7152 +        echo "**********************************************************"
7153 +        echo ""
7154 +        CXXFLAGS=""
7155 +
7156 + fi
7157 +
7158 +
7159 + fi
7160 +
7161 +     ;;
7162 + esac
7163 +
7164 +
7165   # Check whether --enable-doxygen was given.
7166 < if test "${enable_doxygen+set}" = set; then
7166 > if test "${enable_doxygen+set}" = set; then :
7167    enableval=$enable_doxygen;
7168   fi
7169  
7170   # Check whether --enable-dot was given.
7171 < if test "${enable_dot+set}" = set; then
7171 > if test "${enable_dot+set}" = set; then :
7172    enableval=$enable_dot;
7173   fi
7174  
7175   # Check whether --enable-html-docs was given.
7176 < if test "${enable_html_docs+set}" = set; then
7176 > if test "${enable_html_docs+set}" = set; then :
7177    enableval=$enable_html_docs;
7178   else
7179     enable_html_docs=yes
7180   fi
7181  
7182   # Check whether --enable-latex-docs was given.
7183 < if test "${enable_latex_docs+set}" = set; then
7183 > if test "${enable_latex_docs+set}" = set; then :
7184    enableval=$enable_latex_docs;
7185   else
7186     enable_latex_docs=no
# Line 14470 | Line 7191 | set dummy doxygen; ac_word=$2
7191   else
7192          # Extract the first word of "doxygen", so it can be a program name with args.
7193   set dummy doxygen; ac_word=$2
7194 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
7195 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
7196 < if test "${ac_cv_path_DOXYGEN+set}" = set; then
7197 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7194 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7195 > $as_echo_n "checking for $ac_word... " >&6; }
7196 > if ${ac_cv_path_DOXYGEN+:} false; then :
7197 >  $as_echo_n "(cached) " >&6
7198   else
7199    case $DOXYGEN in
7200    [\\/]* | ?:[\\/]*)
# Line 14485 | Line 7206 | do
7206   do
7207    IFS=$as_save_IFS
7208    test -z "$as_dir" && as_dir=.
7209 <  for ac_exec_ext in '' $ac_executable_extensions; do
7209 >    for ac_exec_ext in '' $ac_executable_extensions; do
7210    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
7211      ac_cv_path_DOXYGEN="$as_dir/$ac_word$ac_exec_ext"
7212 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7212 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7213      break 2
7214    fi
7215   done
7216 < done
7216 >  done
7217   IFS=$as_save_IFS
7218  
7219    ;;
# Line 14500 | Line 7221 | if test -n "$DOXYGEN"; then
7221   fi
7222   DOXYGEN=$ac_cv_path_DOXYGEN
7223   if test -n "$DOXYGEN"; then
7224 <  { echo "$as_me:$LINENO: result: $DOXYGEN" >&5
7225 < echo "${ECHO_T}$DOXYGEN" >&6; }
7224 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DOXYGEN" >&5
7225 > $as_echo "$DOXYGEN" >&6; }
7226   else
7227 <  { echo "$as_me:$LINENO: result: no" >&5
7228 < echo "${ECHO_T}no" >&6; }
7227 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7228 > $as_echo "no" >&6; }
7229   fi
7230  
7231  
7232          if test "x$DOXYGEN" = x; then
7233                  if test "x$enable_doxygen" = xyes; then
7234 <                        { { echo "$as_me:$LINENO: error: could not find doxygen" >&5
14514 < echo "$as_me: error: could not find doxygen" >&2;}
14515 <   { (exit 1); exit 1; }; }
7234 >                        as_fn_error $? "could not find doxygen" "$LINENO" 5
7235                  fi
7236                  enable_doc=no
7237          else
7238                  enable_doc=yes
7239                  # Extract the first word of "dot", so it can be a program name with args.
7240   set dummy dot; ac_word=$2
7241 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
7242 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
7243 < if test "${ac_cv_path_DOT+set}" = set; then
7244 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7241 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7242 > $as_echo_n "checking for $ac_word... " >&6; }
7243 > if ${ac_cv_path_DOT+:} false; then :
7244 >  $as_echo_n "(cached) " >&6
7245   else
7246    case $DOT in
7247    [\\/]* | ?:[\\/]*)
# Line 14534 | Line 7253 | do
7253   do
7254    IFS=$as_save_IFS
7255    test -z "$as_dir" && as_dir=.
7256 <  for ac_exec_ext in '' $ac_executable_extensions; do
7256 >    for ac_exec_ext in '' $ac_executable_extensions; do
7257    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
7258      ac_cv_path_DOT="$as_dir/$ac_word$ac_exec_ext"
7259 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7259 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7260      break 2
7261    fi
7262   done
7263 < done
7263 >  done
7264   IFS=$as_save_IFS
7265  
7266    ;;
# Line 14549 | Line 7268 | if test -n "$DOT"; then
7268   fi
7269   DOT=$ac_cv_path_DOT
7270   if test -n "$DOT"; then
7271 <  { echo "$as_me:$LINENO: result: $DOT" >&5
7272 < echo "${ECHO_T}$DOT" >&6; }
7271 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DOT" >&5
7272 > $as_echo "$DOT" >&6; }
7273   else
7274 <  { echo "$as_me:$LINENO: result: no" >&5
7275 < echo "${ECHO_T}no" >&6; }
7274 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7275 > $as_echo "no" >&6; }
7276   fi
7277  
7278  
# Line 14569 | Line 7288 | if test x$DOT = x; then
7288  
7289   if test x$DOT = x; then
7290          if test "x$enable_dot" = xyes; then
7291 <                { { echo "$as_me:$LINENO: error: could not find dot" >&5
14573 < echo "$as_me: error: could not find dot" >&2;}
14574 <   { (exit 1); exit 1; }; }
7291 >                as_fn_error $? "could not find dot" "$LINENO" 5
7292          fi
7293          enable_dot=no
7294   else
# Line 14593 | Line 7310 | fi
7310  
7311  
7312  
7313 + ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/math/Makefile src/integrators/Makefile src/applications/atom2md/Makefile scripts/filepp"
7314  
7315  
14598 –
14599 – ac_config_files="$ac_config_files make/Makefile src/utils/Makefile scripts/filepp"
14600 –
14601 –
7316   cat >confcache <<\_ACEOF
7317   # This file is a shell script that caches the results of configure
7318   # tests run on this system so they can be shared between configure
# Line 14626 | Line 7340 | _ACEOF
7340      case $ac_val in #(
7341      *${as_nl}*)
7342        case $ac_var in #(
7343 <      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
7344 < echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
7343 >      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
7344 > $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
7345        esac
7346        case $ac_var in #(
7347        _ | IFS | as_nl) ;; #(
7348 <      *) $as_unset $ac_var ;;
7348 >      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
7349 >      *) { eval $ac_var=; unset $ac_var;} ;;
7350        esac ;;
7351      esac
7352    done
# Line 14639 | Line 7354 | echo "$as_me: WARNING: Cache variable $ac_var contains
7354    (set) 2>&1 |
7355      case $as_nl`(ac_space=' '; set) 2>&1` in #(
7356      *${as_nl}ac_space=\ *)
7357 <      # `set' does not quote correctly, so add quotes (double-quote
7358 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
7357 >      # `set' does not quote correctly, so add quotes: double-quote
7358 >      # substitution turns \\\\ into \\, and sed turns \\ into \.
7359        sed -n \
7360          "s/'/'\\\\''/g;
7361            s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
# Line 14662 | Line 7377 | if diff "$cache_file" confcache >/dev/null 2>&1; then
7377       :end' >>confcache
7378   if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
7379    if test -w "$cache_file"; then
7380 <    test "x$cache_file" != "x/dev/null" &&
7381 <      { echo "$as_me:$LINENO: updating cache $cache_file" >&5
7382 < echo "$as_me: updating cache $cache_file" >&6;}
7383 <    cat confcache >$cache_file
7380 >    if test "x$cache_file" != "x/dev/null"; then
7381 >      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
7382 > $as_echo "$as_me: updating cache $cache_file" >&6;}
7383 >      if test ! -f "$cache_file" || test -h "$cache_file"; then
7384 >        cat confcache >"$cache_file"
7385 >      else
7386 >        case $cache_file in #(
7387 >        */* | ?:*)
7388 >          mv -f confcache "$cache_file"$$ &&
7389 >          mv -f "$cache_file"$$ "$cache_file" ;; #(
7390 >        *)
7391 >          mv -f confcache "$cache_file" ;;
7392 >        esac
7393 >      fi
7394 >    fi
7395    else
7396 <    { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
7397 < echo "$as_me: not updating unwritable cache $cache_file" >&6;}
7396 >    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
7397 > $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
7398    fi
7399   fi
7400   rm -f confcache
# Line 14681 | Line 7407 | ac_ltlibobjs=
7407  
7408   ac_libobjs=
7409   ac_ltlibobjs=
7410 + U=
7411   for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
7412    # 1. Remove the extension, and $U if already installed.
7413    ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
7414 <  ac_i=`echo "$ac_i" | sed "$ac_script"`
7414 >  ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
7415    # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
7416    #    will be set to the directory where LIBOBJS objects are built.
7417 <  ac_libobjs="$ac_libobjs \${LIBOBJDIR}$ac_i\$U.$ac_objext"
7418 <  ac_ltlibobjs="$ac_ltlibobjs \${LIBOBJDIR}$ac_i"'$U.lo'
7417 >  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
7418 >  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
7419   done
7420   LIBOBJS=$ac_libobjs
7421  
# Line 14696 | Line 7423 | LTLIBOBJS=$ac_ltlibobjs
7423  
7424  
7425  
7426 < : ${CONFIG_STATUS=./config.status}
7426 > : "${CONFIG_STATUS=./config.status}"
7427 > ac_write_fail=0
7428   ac_clean_files_save=$ac_clean_files
7429   ac_clean_files="$ac_clean_files $CONFIG_STATUS"
7430 < { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
7431 < echo "$as_me: creating $CONFIG_STATUS" >&6;}
7432 < cat >$CONFIG_STATUS <<_ACEOF
7430 > { $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
7431 > $as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
7432 > as_write_fail=0
7433 > cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
7434   #! $SHELL
7435   # Generated by $as_me.
7436   # Run this file to recreate the current configuration.
# Line 14711 | Line 7440 | ac_cs_silent=false
7440   debug=false
7441   ac_cs_recheck=false
7442   ac_cs_silent=false
7443 +
7444   SHELL=\${CONFIG_SHELL-$SHELL}
7445 < _ACEOF
7445 > export SHELL
7446 > _ASEOF
7447 > cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
7448 > ## -------------------- ##
7449 > ## M4sh Initialization. ##
7450 > ## -------------------- ##
7451  
14717 – cat >>$CONFIG_STATUS <<\_ACEOF
14718 – ## --------------------- ##
14719 – ## M4sh Initialization.  ##
14720 – ## --------------------- ##
14721 –
7452   # Be more Bourne compatible
7453   DUALCASE=1; export DUALCASE # for MKS sh
7454 < if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
7454 > if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
7455    emulate sh
7456    NULLCMD=:
7457 <  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
7457 >  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
7458    # is contrary to our usage.  Disable this feature.
7459    alias -g '${1+"$@"}'='"$@"'
7460    setopt NO_GLOB_SUBST
7461   else
7462 <  case `(set -o) 2>/dev/null` in
7463 <  *posix*) set -o posix ;;
7462 >  case `(set -o) 2>/dev/null` in #(
7463 >  *posix*) :
7464 >    set -o posix ;; #(
7465 >  *) :
7466 >     ;;
7467   esac
14735 –
7468   fi
7469  
7470  
7471 <
7472 <
7473 < # PATH needs CR
7474 < # Avoid depending upon Character Ranges.
7475 < as_cr_letters='abcdefghijklmnopqrstuvwxyz'
7476 < as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
7477 < as_cr_Letters=$as_cr_letters$as_cr_LETTERS
7478 < as_cr_digits='0123456789'
7479 < as_cr_alnum=$as_cr_Letters$as_cr_digits
7480 <
7481 < # The user is always right.
7482 < if test "${PATH_SEPARATOR+set}" != set; then
7483 <  echo "#! /bin/sh" >conf$$.sh
7484 <  echo  "exit 0"   >>conf$$.sh
7485 <  chmod +x conf$$.sh
7486 <  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
7487 <    PATH_SEPARATOR=';'
7488 <  else
7489 <    PATH_SEPARATOR=:
7471 > as_nl='
7472 > '
7473 > export as_nl
7474 > # Printing a long string crashes Solaris 7 /usr/bin/printf.
7475 > as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
7476 > as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
7477 > as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
7478 > # Prefer a ksh shell builtin over an external printf program on Solaris,
7479 > # but without wasting forks for bash or zsh.
7480 > if test -z "$BASH_VERSION$ZSH_VERSION" \
7481 >    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
7482 >  as_echo='print -r --'
7483 >  as_echo_n='print -rn --'
7484 > elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
7485 >  as_echo='printf %s\n'
7486 >  as_echo_n='printf %s'
7487 > else
7488 >  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
7489 >    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
7490 >    as_echo_n='/usr/ucb/echo -n'
7491 >  else
7492 >    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
7493 >    as_echo_n_body='eval
7494 >      arg=$1;
7495 >      case $arg in #(
7496 >      *"$as_nl"*)
7497 >        expr "X$arg" : "X\\(.*\\)$as_nl";
7498 >        arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
7499 >      esac;
7500 >      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
7501 >    '
7502 >    export as_echo_n_body
7503 >    as_echo_n='sh -c $as_echo_n_body as_echo'
7504    fi
7505 <  rm -f conf$$.sh
7505 >  export as_echo_body
7506 >  as_echo='sh -c $as_echo_body as_echo'
7507   fi
7508  
7509 < # Support unset when possible.
7510 < if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
7511 <  as_unset=unset
7512 < else
7513 <  as_unset=false
7509 > # The user is always right.
7510 > if test "${PATH_SEPARATOR+set}" != set; then
7511 >  PATH_SEPARATOR=:
7512 >  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
7513 >    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
7514 >      PATH_SEPARATOR=';'
7515 >  }
7516   fi
7517  
7518  
# Line 14772 | Line 7521 | fi
7521   # there to prevent editors from complaining about space-tab.
7522   # (If _AS_PATH_WALK were called with IFS unset, it would disable word
7523   # splitting by setting IFS to empty value.)
14775 – as_nl='
14776 – '
7524   IFS=" ""        $as_nl"
7525  
7526   # Find who we are.  Look in the path if we contain no directory separator.
7527 < case $0 in
7527 > as_myself=
7528 > case $0 in #((
7529    *[\\/]* ) as_myself=$0 ;;
7530    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7531   for as_dir in $PATH
7532   do
7533    IFS=$as_save_IFS
7534    test -z "$as_dir" && as_dir=.
7535 <  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
7536 < done
7535 >    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
7536 >  done
7537   IFS=$as_save_IFS
7538  
7539       ;;
# Line 14796 | Line 7544 | if test ! -f "$as_myself"; then
7544    as_myself=$0
7545   fi
7546   if test ! -f "$as_myself"; then
7547 <  echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
7548 <  { (exit 1); exit 1; }
7547 >  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
7548 >  exit 1
7549   fi
7550  
7551 < # Work around bugs in pre-3.0 UWIN ksh.
7552 < for as_var in ENV MAIL MAILPATH
7553 < do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
7551 > # Unset variables that we do not need and which cause bugs (e.g. in
7552 > # pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
7553 > # suppresses any "Segmentation fault" message there.  '((' could
7554 > # trigger a bug in pdksh 5.2.14.
7555 > for as_var in BASH_ENV ENV MAIL MAILPATH
7556 > do eval test x\${$as_var+set} = xset \
7557 >  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
7558   done
7559   PS1='$ '
7560   PS2='> '
7561   PS4='+ '
7562  
7563   # NLS nuisances.
7564 < for as_var in \
7565 <  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
7566 <  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
7567 <  LC_TELEPHONE LC_TIME
7568 < do
7569 <  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
7570 <    eval $as_var=C; export $as_var
7571 <  else
7572 <    ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
7564 > LC_ALL=C
7565 > export LC_ALL
7566 > LANGUAGE=C
7567 > export LANGUAGE
7568 >
7569 > # CDPATH.
7570 > (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
7571 >
7572 >
7573 > # as_fn_error STATUS ERROR [LINENO LOG_FD]
7574 > # ----------------------------------------
7575 > # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
7576 > # provided, also output the error to LOG_FD, referencing LINENO. Then exit the
7577 > # script with STATUS, using 1 if that was 0.
7578 > as_fn_error ()
7579 > {
7580 >  as_status=$1; test $as_status -eq 0 && as_status=1
7581 >  if test "$4"; then
7582 >    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
7583 >    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
7584    fi
7585 < done
7585 >  $as_echo "$as_me: error: $2" >&2
7586 >  as_fn_exit $as_status
7587 > } # as_fn_error
7588  
7589 < # Required to use basename.
7589 >
7590 > # as_fn_set_status STATUS
7591 > # -----------------------
7592 > # Set $? to STATUS, without forking.
7593 > as_fn_set_status ()
7594 > {
7595 >  return $1
7596 > } # as_fn_set_status
7597 >
7598 > # as_fn_exit STATUS
7599 > # -----------------
7600 > # Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
7601 > as_fn_exit ()
7602 > {
7603 >  set +e
7604 >  as_fn_set_status $1
7605 >  exit $1
7606 > } # as_fn_exit
7607 >
7608 > # as_fn_unset VAR
7609 > # ---------------
7610 > # Portably unset VAR.
7611 > as_fn_unset ()
7612 > {
7613 >  { eval $1=; unset $1;}
7614 > }
7615 > as_unset=as_fn_unset
7616 > # as_fn_append VAR VALUE
7617 > # ----------------------
7618 > # Append the text in VALUE to the end of the definition contained in VAR. Take
7619 > # advantage of any shell optimizations that allow amortized linear growth over
7620 > # repeated appends, instead of the typical quadratic growth present in naive
7621 > # implementations.
7622 > if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
7623 >  eval 'as_fn_append ()
7624 >  {
7625 >    eval $1+=\$2
7626 >  }'
7627 > else
7628 >  as_fn_append ()
7629 >  {
7630 >    eval $1=\$$1\$2
7631 >  }
7632 > fi # as_fn_append
7633 >
7634 > # as_fn_arith ARG...
7635 > # ------------------
7636 > # Perform arithmetic evaluation on the ARGs, and store the result in the
7637 > # global $as_val. Take advantage of shells that can avoid forks. The arguments
7638 > # must be portable across $(()) and expr.
7639 > if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
7640 >  eval 'as_fn_arith ()
7641 >  {
7642 >    as_val=$(( $* ))
7643 >  }'
7644 > else
7645 >  as_fn_arith ()
7646 >  {
7647 >    as_val=`expr "$@" || test $? -eq 1`
7648 >  }
7649 > fi # as_fn_arith
7650 >
7651 >
7652   if expr a : '\(a\)' >/dev/null 2>&1 &&
7653     test "X`expr 00001 : '.*\(...\)'`" = X001; then
7654    as_expr=expr
# Line 14835 | Line 7662 | fi
7662    as_basename=false
7663   fi
7664  
7665 + if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
7666 +  as_dirname=dirname
7667 + else
7668 +  as_dirname=false
7669 + fi
7670  
14839 – # Name of the executable.
7671   as_me=`$as_basename -- "$0" ||
7672   $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
7673           X"$0" : 'X\(//\)$' \| \
7674           X"$0" : 'X\(/\)' \| . 2>/dev/null ||
7675 < echo X/"$0" |
7675 > $as_echo X/"$0" |
7676      sed '/^.*\/\([^/][^/]*\)\/*$/{
7677              s//\1/
7678              q
# Line 14856 | Line 7687 | echo X/"$0" |
7687            }
7688            s/.*/./; q'`
7689  
7690 < # CDPATH.
7691 < $as_unset CDPATH
7690 > # Avoid depending upon Character Ranges.
7691 > as_cr_letters='abcdefghijklmnopqrstuvwxyz'
7692 > as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
7693 > as_cr_Letters=$as_cr_letters$as_cr_LETTERS
7694 > as_cr_digits='0123456789'
7695 > as_cr_alnum=$as_cr_Letters$as_cr_digits
7696  
14862 –
14863 –
14864 –  as_lineno_1=$LINENO
14865 –  as_lineno_2=$LINENO
14866 –  test "x$as_lineno_1" != "x$as_lineno_2" &&
14867 –  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
14868 –
14869 –  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
14870 –  # uniformly replaced by the line number.  The first 'sed' inserts a
14871 –  # line-number line after each line using $LINENO; the second 'sed'
14872 –  # does the real work.  The second script uses 'N' to pair each
14873 –  # line-number line with the line containing $LINENO, and appends
14874 –  # trailing '-' during substitution so that $LINENO is not a special
14875 –  # case at line end.
14876 –  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
14877 –  # scripts with optimization help from Paolo Bonzini.  Blame Lee
14878 –  # E. McMahon (1931-1989) for sed's syntax.  :-)
14879 –  sed -n '
14880 –    p
14881 –    /[$]LINENO/=
14882 –  ' <$as_myself |
14883 –    sed '
14884 –      s/[$]LINENO.*/&-/
14885 –      t lineno
14886 –      b
14887 –      :lineno
14888 –      N
14889 –      :loop
14890 –      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
14891 –      t loop
14892 –      s/-\n.*//
14893 –    ' >$as_me.lineno &&
14894 –  chmod +x "$as_me.lineno" ||
14895 –    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
14896 –   { (exit 1); exit 1; }; }
14897 –
14898 –  # Don't try to exec as it changes $[0], causing all sort of problems
14899 –  # (the dirname of $[0] is not the place where we might find the
14900 –  # original and so on.  Autoconf is especially sensitive to this).
14901 –  . "./$as_me.lineno"
14902 –  # Exit status is that of the last command.
14903 –  exit
14904 – }
14905 –
14906 –
14907 – if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
14908 –  as_dirname=dirname
14909 – else
14910 –  as_dirname=false
14911 – fi
14912 –
7697   ECHO_C= ECHO_N= ECHO_T=
7698 < case `echo -n x` in
7698 > case `echo -n x` in #(((((
7699   -n*)
7700 <  case `echo 'x\c'` in
7700 >  case `echo 'xy\c'` in
7701    *c*) ECHO_T=' ';;     # ECHO_T is single tab character.
7702 <  *)   ECHO_C='\c';;
7702 >  xy)  ECHO_C='\c';;
7703 >  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
7704 >       ECHO_T=' ';;
7705    esac;;
7706   *)
7707    ECHO_N='-n';;
7708   esac
7709  
14924 – if expr a : '\(a\)' >/dev/null 2>&1 &&
14925 –   test "X`expr 00001 : '.*\(...\)'`" = X001; then
14926 –  as_expr=expr
14927 – else
14928 –  as_expr=false
14929 – fi
14930 –
7710   rm -f conf$$ conf$$.exe conf$$.file
7711   if test -d conf$$.dir; then
7712    rm -f conf$$.dir/conf$$.file
7713   else
7714    rm -f conf$$.dir
7715 <  mkdir conf$$.dir
7715 >  mkdir conf$$.dir 2>/dev/null
7716   fi
7717 < echo >conf$$.file
7718 < if ln -s conf$$.file conf$$ 2>/dev/null; then
7719 <  as_ln_s='ln -s'
7720 <  # ... but there are two gotchas:
7721 <  # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
7722 <  # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
7723 <  # In both cases, we have to default to `cp -p'.
7724 <  ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
7717 > if (echo >conf$$.file) 2>/dev/null; then
7718 >  if ln -s conf$$.file conf$$ 2>/dev/null; then
7719 >    as_ln_s='ln -s'
7720 >    # ... but there are two gotchas:
7721 >    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
7722 >    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
7723 >    # In both cases, we have to default to `cp -p'.
7724 >    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
7725 >      as_ln_s='cp -p'
7726 >  elif ln conf$$.file conf$$ 2>/dev/null; then
7727 >    as_ln_s=ln
7728 >  else
7729      as_ln_s='cp -p'
7730 < elif ln conf$$.file conf$$ 2>/dev/null; then
14948 <  as_ln_s=ln
7730 >  fi
7731   else
7732    as_ln_s='cp -p'
7733   fi
7734   rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
7735   rmdir conf$$.dir 2>/dev/null
7736  
7737 +
7738 + # as_fn_mkdir_p
7739 + # -------------
7740 + # Create "$as_dir" as a directory, including parents if necessary.
7741 + as_fn_mkdir_p ()
7742 + {
7743 +
7744 +  case $as_dir in #(
7745 +  -*) as_dir=./$as_dir;;
7746 +  esac
7747 +  test -d "$as_dir" || eval $as_mkdir_p || {
7748 +    as_dirs=
7749 +    while :; do
7750 +      case $as_dir in #(
7751 +      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
7752 +      *) as_qdir=$as_dir;;
7753 +      esac
7754 +      as_dirs="'$as_qdir' $as_dirs"
7755 +      as_dir=`$as_dirname -- "$as_dir" ||
7756 + $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
7757 +         X"$as_dir" : 'X\(//\)[^/]' \| \
7758 +         X"$as_dir" : 'X\(//\)$' \| \
7759 +         X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
7760 + $as_echo X"$as_dir" |
7761 +    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
7762 +            s//\1/
7763 +            q
7764 +          }
7765 +          /^X\(\/\/\)[^/].*/{
7766 +            s//\1/
7767 +            q
7768 +          }
7769 +          /^X\(\/\/\)$/{
7770 +            s//\1/
7771 +            q
7772 +          }
7773 +          /^X\(\/\).*/{
7774 +            s//\1/
7775 +            q
7776 +          }
7777 +          s/.*/./; q'`
7778 +      test -d "$as_dir" && break
7779 +    done
7780 +    test -z "$as_dirs" || eval "mkdir $as_dirs"
7781 +  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
7782 +
7783 +
7784 + } # as_fn_mkdir_p
7785   if mkdir -p . 2>/dev/null; then
7786 <  as_mkdir_p=:
7786 >  as_mkdir_p='mkdir -p "$as_dir"'
7787   else
7788    test -d ./-p && rmdir ./-p
7789    as_mkdir_p=false
# Line 14970 | Line 7800 | else
7800    as_test_x='
7801      eval sh -c '\''
7802        if test -d "$1"; then
7803 <        test -d "$1/.";
7803 >        test -d "$1/.";
7804        else
7805 <        case $1 in
7806 <        -*)set "./$1";;
7805 >        case $1 in #(
7806 >        -*)set "./$1";;
7807          esac;
7808 <        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
7808 >        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
7809          ???[sx]*):;;*)false;;esac;fi
7810      '\'' sh
7811    '
# Line 14990 | Line 7820 | exec 6>&1
7820  
7821  
7822   exec 6>&1
7823 + ## ----------------------------------- ##
7824 + ## Main body of $CONFIG_STATUS script. ##
7825 + ## ----------------------------------- ##
7826 + _ASEOF
7827 + test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
7828  
7829 < # Save the log message, to keep $[0] and so on meaningful, and to
7829 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
7830 > # Save the log message, to keep $0 and so on meaningful, and to
7831   # report actual input values of CONFIG_FILES etc. instead of their
7832   # values after options handling.
7833   ac_log="
7834 < This file was extended by OOPSE $as_me 3.0, which was
7835 < generated by GNU Autoconf 2.61.  Invocation command line was
7834 > This file was extended by OpenMD $as_me 1.0, which was
7835 > generated by GNU Autoconf 2.68.  Invocation command line was
7836  
7837    CONFIG_FILES    = $CONFIG_FILES
7838    CONFIG_HEADERS  = $CONFIG_HEADERS
# Line 15009 | Line 7845 | _ACEOF
7845  
7846   _ACEOF
7847  
7848 < cat >>$CONFIG_STATUS <<_ACEOF
7848 > case $ac_config_files in *"
7849 > "*) set x $ac_config_files; shift; ac_config_files=$*;;
7850 > esac
7851 >
7852 > case $ac_config_headers in *"
7853 > "*) set x $ac_config_headers; shift; ac_config_headers=$*;;
7854 > esac
7855 >
7856 >
7857 > cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
7858   # Files that config.status was made for.
7859   config_files="$ac_config_files"
7860   config_headers="$ac_config_headers"
15016 – config_links="$ac_config_links"
7861  
7862   _ACEOF
7863  
7864 < cat >>$CONFIG_STATUS <<\_ACEOF
7864 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
7865   ac_cs_usage="\
7866 < \`$as_me' instantiates files from templates according to the
7867 < current configuration.
7866 > \`$as_me' instantiates files and other configuration actions
7867 > from templates according to the current configuration.  Unless the files
7868 > and actions are specified as TAGs, all are instantiated by default.
7869  
7870 < Usage: $0 [OPTIONS] [FILE]...
7870 > Usage: $0 [OPTION]... [TAG]...
7871  
7872    -h, --help       print this help, then exit
7873    -V, --version    print version number and configuration settings, then exit
7874 <  -q, --quiet      do not print progress messages
7874 >      --config     print configuration, then exit
7875 >  -q, --quiet, --silent
7876 >                   do not print progress messages
7877    -d, --debug      don't remove temporary files
7878        --recheck    update $as_me by reconfiguring in the same conditions
7879 <  --file=FILE[:TEMPLATE]
7880 <                   instantiate the configuration file FILE
7881 <  --header=FILE[:TEMPLATE]
7882 <                   instantiate the configuration header FILE
7879 >      --file=FILE[:TEMPLATE]
7880 >                   instantiate the configuration file FILE
7881 >      --header=FILE[:TEMPLATE]
7882 >                   instantiate the configuration header FILE
7883  
7884   Configuration files:
7885   $config_files
# Line 15040 | Line 7887 | $config_headers
7887   Configuration headers:
7888   $config_headers
7889  
7890 < Configuration links:
15044 < $config_links
7890 > Report bugs to <gezelter@nd.edu>."
7891  
15046 – Report bugs to <bug-autoconf@gnu.org>."
15047 –
7892   _ACEOF
7893 < cat >>$CONFIG_STATUS <<_ACEOF
7893 > cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
7894 > ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
7895   ac_cs_version="\\
7896 < OOPSE config.status 3.0
7897 < configured by $0, generated by GNU Autoconf 2.61,
7898 <  with options \\"`echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
7896 > OpenMD config.status 1.0
7897 > configured by $0, generated by GNU Autoconf 2.68,
7898 >  with options \\"\$ac_cs_config\\"
7899  
7900 < Copyright (C) 2006 Free Software Foundation, Inc.
7900 > Copyright (C) 2010 Free Software Foundation, Inc.
7901   This config.status script is free software; the Free Software Foundation
7902   gives unlimited permission to copy, distribute and modify it."
7903  
7904   ac_pwd='$ac_pwd'
7905   srcdir='$srcdir'
7906   INSTALL='$INSTALL'
7907 + test -n "\$AWK" || AWK=awk
7908   _ACEOF
7909  
7910 < cat >>$CONFIG_STATUS <<\_ACEOF
7911 < # If no file are specified by the user, then we need to provide default
15066 < # value.  By we need to know if files were specified by the user.
7910 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
7911 > # The default lists apply if the user does not specify any file.
7912   ac_need_defaults=:
7913   while test $# != 0
7914   do
7915    case $1 in
7916 <  --*=*)
7916 >  --*=?*)
7917      ac_option=`expr "X$1" : 'X\([^=]*\)='`
7918      ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
7919      ac_shift=:
7920      ;;
7921 +  --*=)
7922 +    ac_option=`expr "X$1" : 'X\([^=]*\)='`
7923 +    ac_optarg=
7924 +    ac_shift=:
7925 +    ;;
7926    *)
7927      ac_option=$1
7928      ac_optarg=$2
# Line 15085 | Line 7935 | do
7935    -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
7936      ac_cs_recheck=: ;;
7937    --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
7938 <    echo "$ac_cs_version"; exit ;;
7938 >    $as_echo "$ac_cs_version"; exit ;;
7939 >  --config | --confi | --conf | --con | --co | --c )
7940 >    $as_echo "$ac_cs_config"; exit ;;
7941    --debug | --debu | --deb | --de | --d | -d )
7942      debug=: ;;
7943    --file | --fil | --fi | --f )
7944      $ac_shift
7945 <    CONFIG_FILES="$CONFIG_FILES $ac_optarg"
7945 >    case $ac_optarg in
7946 >    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
7947 >    '') as_fn_error $? "missing file argument" ;;
7948 >    esac
7949 >    as_fn_append CONFIG_FILES " '$ac_optarg'"
7950      ac_need_defaults=false;;
7951    --header | --heade | --head | --hea )
7952      $ac_shift
7953 <    CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
7953 >    case $ac_optarg in
7954 >    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
7955 >    esac
7956 >    as_fn_append CONFIG_HEADERS " '$ac_optarg'"
7957      ac_need_defaults=false;;
7958    --he | --h)
7959      # Conflict between --help and --header
7960 <    { echo "$as_me: error: ambiguous option: $1
7961 < Try \`$0 --help' for more information." >&2
15103 <   { (exit 1); exit 1; }; };;
7960 >    as_fn_error $? "ambiguous option: \`$1'
7961 > Try \`$0 --help' for more information.";;
7962    --help | --hel | -h )
7963 <    echo "$ac_cs_usage"; exit ;;
7963 >    $as_echo "$ac_cs_usage"; exit ;;
7964    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
7965    | -silent | --silent | --silen | --sile | --sil | --si | --s)
7966      ac_cs_silent=: ;;
7967  
7968    # This is an error.
7969 <  -*) { echo "$as_me: error: unrecognized option: $1
7970 < Try \`$0 --help' for more information." >&2
15113 <   { (exit 1); exit 1; }; } ;;
7969 >  -*) as_fn_error $? "unrecognized option: \`$1'
7970 > Try \`$0 --help' for more information." ;;
7971  
7972 <  *) ac_config_targets="$ac_config_targets $1"
7972 >  *) as_fn_append ac_config_targets " $1"
7973       ac_need_defaults=false ;;
7974  
7975    esac
# Line 15127 | Line 7984 | _ACEOF
7984   fi
7985  
7986   _ACEOF
7987 < cat >>$CONFIG_STATUS <<_ACEOF
7987 > cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
7988   if \$ac_cs_recheck; then
7989 <  echo "running CONFIG_SHELL=$SHELL $SHELL $0 "$ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
7990 <  CONFIG_SHELL=$SHELL
7989 >  set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
7990 >  shift
7991 >  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
7992 >  CONFIG_SHELL='$SHELL'
7993    export CONFIG_SHELL
7994 <  exec $SHELL "$0"$ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
7994 >  exec "\$@"
7995   fi
7996  
7997   _ACEOF
7998 < cat >>$CONFIG_STATUS <<\_ACEOF
7998 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
7999   exec 5>>config.log
8000   {
8001    echo
8002    sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
8003   ## Running $as_me. ##
8004   _ASBOX
8005 <  echo "$ac_log"
8005 >  $as_echo "$ac_log"
8006   } >&5
8007  
8008   _ACEOF
8009 < cat >>$CONFIG_STATUS <<_ACEOF
8009 > cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
8010   _ACEOF
8011  
8012 < cat >>$CONFIG_STATUS <<\_ACEOF
8012 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
8013  
8014   # Handling of arguments.
8015   for ac_config_target in $ac_config_targets
8016   do
8017    case $ac_config_target in
8018      "src/config.h") CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;
15160 –    "src/getopt.h") CONFIG_LINKS="$CONFIG_LINKS src/getopt.h:src/utils/gnugetopt.h" ;;
8019      "make/Makefile") CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
8020      "src/utils/Makefile") CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
8021 +    "src/math/Makefile") CONFIG_FILES="$CONFIG_FILES src/math/Makefile" ;;
8022 +    "src/integrators/Makefile") CONFIG_FILES="$CONFIG_FILES src/integrators/Makefile" ;;
8023 +    "src/applications/atom2md/Makefile") CONFIG_FILES="$CONFIG_FILES src/applications/atom2md/Makefile" ;;
8024      "scripts/filepp") CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
8025  
8026 <  *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
15166 < echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
15167 <   { (exit 1); exit 1; }; };;
8026 >  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
8027    esac
8028   done
8029  
# Line 15176 | Line 8035 | if $ac_need_defaults; then
8035   if $ac_need_defaults; then
8036    test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
8037    test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
15179 –  test "${CONFIG_LINKS+set}" = set || CONFIG_LINKS=$config_links
8038   fi
8039  
8040   # Have a temporary directory for convenience.  Make it in the build tree
# Line 15187 | Line 8045 | $debug ||
8045   # after its creation but before its name has been assigned to `$tmp'.
8046   $debug ||
8047   {
8048 <  tmp=
8048 >  tmp= ac_tmp=
8049    trap 'exit_status=$?
8050 <  { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status
8050 >  : "${ac_tmp:=$tmp}"
8051 >  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
8052   ' 0
8053 <  trap '{ (exit 1); exit 1; }' 1 2 13 15
8053 >  trap 'as_fn_exit 1' 1 2 13 15
8054   }
8055   # Create a (secure) tmp directory for tmp files.
8056  
8057   {
8058    tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
8059 <  test -n "$tmp" && test -d "$tmp"
8059 >  test -d "$tmp"
8060   }  ||
8061   {
8062    tmp=./conf$$-$RANDOM
8063    (umask 077 && mkdir "$tmp")
8064 < } ||
8065 < {
15207 <   echo "$me: cannot create a temporary directory in ." >&2
15208 <   { (exit 1); exit 1; }
15209 < }
8064 > } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
8065 > ac_tmp=$tmp
8066  
8067 < #
8068 < # Set up the sed scripts for CONFIG_FILES section.
8069 < #
15214 <
15215 < # No need to generate the scripts if there are no CONFIG_FILES.
15216 < # This happens for instance when ./config.status config.h
8067 > # Set up the scripts for CONFIG_FILES section.
8068 > # No need to generate them if there are no CONFIG_FILES.
8069 > # This happens for instance with `./config.status config.h'.
8070   if test -n "$CONFIG_FILES"; then
8071  
15219 – _ACEOF
8072  
8073 + ac_cr=`echo X | tr X '\015'`
8074 + # On cygwin, bash can eat \r inside `` if the user requested igncr.
8075 + # But we know of no other shell where ac_cr would be empty at this
8076 + # point, so we can use a bashism as a fallback.
8077 + if test "x$ac_cr" = x; then
8078 +  eval ac_cr=\$\'\\r\'
8079 + fi
8080 + ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
8081 + if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
8082 +  ac_cs_awk_cr='\\r'
8083 + else
8084 +  ac_cs_awk_cr=$ac_cr
8085 + fi
8086  
8087 + echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
8088 + _ACEOF
8089  
8090 +
8091 + {
8092 +  echo "cat >conf$$subs.awk <<_ACEOF" &&
8093 +  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
8094 +  echo "_ACEOF"
8095 + } >conf$$subs.sh ||
8096 +  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
8097 + ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
8098   ac_delim='%!_!# '
8099   for ac_last_try in false false false false false :; do
8100 <  cat >conf$$subs.sed <<_ACEOF
8101 < SHELL!$SHELL$ac_delim
15227 < PATH_SEPARATOR!$PATH_SEPARATOR$ac_delim
15228 < PACKAGE_NAME!$PACKAGE_NAME$ac_delim
15229 < PACKAGE_TARNAME!$PACKAGE_TARNAME$ac_delim
15230 < PACKAGE_VERSION!$PACKAGE_VERSION$ac_delim
15231 < PACKAGE_STRING!$PACKAGE_STRING$ac_delim
15232 < PACKAGE_BUGREPORT!$PACKAGE_BUGREPORT$ac_delim
15233 < exec_prefix!$exec_prefix$ac_delim
15234 < prefix!$prefix$ac_delim
15235 < program_transform_name!$program_transform_name$ac_delim
15236 < bindir!$bindir$ac_delim
15237 < sbindir!$sbindir$ac_delim
15238 < libexecdir!$libexecdir$ac_delim
15239 < datarootdir!$datarootdir$ac_delim
15240 < datadir!$datadir$ac_delim
15241 < sysconfdir!$sysconfdir$ac_delim
15242 < sharedstatedir!$sharedstatedir$ac_delim
15243 < localstatedir!$localstatedir$ac_delim
15244 < includedir!$includedir$ac_delim
15245 < oldincludedir!$oldincludedir$ac_delim
15246 < docdir!$docdir$ac_delim
15247 < infodir!$infodir$ac_delim
15248 < htmldir!$htmldir$ac_delim
15249 < dvidir!$dvidir$ac_delim
15250 < pdfdir!$pdfdir$ac_delim
15251 < psdir!$psdir$ac_delim
15252 < libdir!$libdir$ac_delim
15253 < localedir!$localedir$ac_delim
15254 < mandir!$mandir$ac_delim
15255 < DEFS!$DEFS$ac_delim
15256 < ECHO_C!$ECHO_C$ac_delim
15257 < ECHO_N!$ECHO_N$ac_delim
15258 < ECHO_T!$ECHO_T$ac_delim
15259 < LIBS!$LIBS$ac_delim
15260 < build_alias!$build_alias$ac_delim
15261 < host_alias!$host_alias$ac_delim
15262 < target_alias!$target_alias$ac_delim
15263 < build!$build$ac_delim
15264 < build_cpu!$build_cpu$ac_delim
15265 < build_vendor!$build_vendor$ac_delim
15266 < build_os!$build_os$ac_delim
15267 < host!$host$ac_delim
15268 < host_cpu!$host_cpu$ac_delim
15269 < host_vendor!$host_vendor$ac_delim
15270 < host_os!$host_os$ac_delim
15271 < PROGNAME!$PROGNAME$ac_delim
15272 < debug!$debug$ac_delim
15273 < USE_SINGLE_PRECISION!$USE_SINGLE_PRECISION$ac_delim
15274 < CXX!$CXX$ac_delim
15275 < CXXFLAGS!$CXXFLAGS$ac_delim
15276 < LDFLAGS!$LDFLAGS$ac_delim
15277 < CPPFLAGS!$CPPFLAGS$ac_delim
15278 < ac_ct_CXX!$ac_ct_CXX$ac_delim
15279 < EXEEXT!$EXEEXT$ac_delim
15280 < OBJEXT!$OBJEXT$ac_delim
15281 < CC!$CC$ac_delim
15282 < CFLAGS!$CFLAGS$ac_delim
15283 < ac_ct_CC!$ac_ct_CC$ac_delim
15284 < FC!$FC$ac_delim
15285 < FCFLAGS!$FCFLAGS$ac_delim
15286 < ac_ct_FC!$ac_ct_FC$ac_delim
15287 < CPP!$CPP$ac_delim
15288 < GREP!$GREP$ac_delim
15289 < EGREP!$EGREP$ac_delim
15290 < LN_S!$LN_S$ac_delim
15291 < SET_MAKE!$SET_MAKE$ac_delim
15292 < RANLIB!$RANLIB$ac_delim
15293 < PERLINTERP!$PERLINTERP$ac_delim
15294 < PERL_SHEBANG!$PERL_SHEBANG$ac_delim
15295 < INSTALL_PROGRAM!$INSTALL_PROGRAM$ac_delim
15296 < INSTALL_SCRIPT!$INSTALL_SCRIPT$ac_delim
15297 < INSTALL_DATA!$INSTALL_DATA$ac_delim
15298 < AR!$AR$ac_delim
15299 < PS!$PS$ac_delim
15300 < FCFLAGS_F90!$FCFLAGS_F90$ac_delim
15301 < FCFLAGS_SRCEXT!$FCFLAGS_SRCEXT$ac_delim
15302 < PREPDEFFLAG!$PREPDEFFLAG$ac_delim
15303 < FCLIBS!$FCLIBS$ac_delim
15304 < FC_FUNC!$FC_FUNC$ac_delim
15305 < FC_FUNC_!$FC_FUNC_$ac_delim
15306 < MOD!$MOD$ac_delim
15307 < F90_WORK_FILES_ARG!$F90_WORK_FILES_ARG$ac_delim
15308 < MODDIRFLAG!$MODDIRFLAG$ac_delim
15309 < F90MODINCSPEC!$F90MODINCSPEC$ac_delim
15310 < F90_MODULE_NAMES!$F90_MODULE_NAMES$ac_delim
15311 < ZLIB_INC_DIR!$ZLIB_INC_DIR$ac_delim
15312 < ZLIB_LIB_DIR!$ZLIB_LIB_DIR$ac_delim
15313 < ZLIB!$ZLIB$ac_delim
15314 < FFTW_INC_DIR!$FFTW_INC_DIR$ac_delim
15315 < FFTW_LIB_DIR!$FFTW_LIB_DIR$ac_delim
15316 < FFTW_LIBS!$FFTW_LIBS$ac_delim
15317 < LIBOBJS!$LIBOBJS$ac_delim
15318 < POW_LIB!$POW_LIB$ac_delim
15319 < CXXCPP!$CXXCPP$ac_delim
15320 < __func__!$__func__$ac_delim
15321 < MPI_LIB_DIR!$MPI_LIB_DIR$ac_delim
15322 < MPI_INC_DIR!$MPI_INC_DIR$ac_delim
15323 < _ACEOF
8100 >  . ./conf$$subs.sh ||
8101 >    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
8102  
8103 <  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 97; then
8103 >  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
8104 >  if test $ac_delim_n = $ac_delim_num; then
8105      break
8106    elif $ac_last_try; then
8107 <    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
15329 < echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
15330 <   { (exit 1); exit 1; }; }
8107 >    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
8108    else
8109      ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
8110    fi
8111   done
8112 + rm -f conf$$subs.sh
8113  
8114 < ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`
8115 < if test -n "$ac_eof"; then
8116 <  ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`
8117 <  ac_eof=`expr $ac_eof + 1`
8118 < fi
8114 > cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
8115 > cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
8116 > _ACEOF
8117 > sed -n '
8118 > h
8119 > s/^/S["/; s/!.*/"]=/
8120 > p
8121 > g
8122 > s/^[^!]*!//
8123 > :repl
8124 > t repl
8125 > s/'"$ac_delim"'$//
8126 > t delim
8127 > :nl
8128 > h
8129 > s/\(.\{148\}\)..*/\1/
8130 > t more1
8131 > s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
8132 > p
8133 > n
8134 > b repl
8135 > :more1
8136 > s/["\\]/\\&/g; s/^/"/; s/$/"\\/
8137 > p
8138 > g
8139 > s/.\{148\}//
8140 > t nl
8141 > :delim
8142 > h
8143 > s/\(.\{148\}\)..*/\1/
8144 > t more2
8145 > s/["\\]/\\&/g; s/^/"/; s/$/"/
8146 > p
8147 > b
8148 > :more2
8149 > s/["\\]/\\&/g; s/^/"/; s/$/"\\/
8150 > p
8151 > g
8152 > s/.\{148\}//
8153 > t delim
8154 > ' <conf$$subs.awk | sed '
8155 > /^[^""]/{
8156 >  N
8157 >  s/\n//
8158 > }
8159 > ' >>$CONFIG_STATUS || ac_write_fail=1
8160 > rm -f conf$$subs.awk
8161 > cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
8162 > _ACAWK
8163 > cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
8164 >  for (key in S) S_is_set[key] = 1
8165 >  FS = ""
8166  
8167 < cat >>$CONFIG_STATUS <<_ACEOF
8168 < cat >"\$tmp/subs-1.sed" <<\CEOF$ac_eof
8169 < /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
8167 > }
8168 > {
8169 >  line = $ 0
8170 >  nfields = split(line, field, "@")
8171 >  substed = 0
8172 >  len = length(field[1])
8173 >  for (i = 2; i < nfields; i++) {
8174 >    key = field[i]
8175 >    keylen = length(key)
8176 >    if (S_is_set[key]) {
8177 >      value = S[key]
8178 >      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
8179 >      len += length(value) + length(field[++i])
8180 >      substed = 1
8181 >    } else
8182 >      len += 1 + keylen
8183 >  }
8184 >
8185 >  print line
8186 > }
8187 >
8188 > _ACAWK
8189   _ACEOF
8190 < sed '
8191 < s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g
8192 < s/^/s,@/; s/!/@,|#_!!_#|/
8193 < :n
8194 < t n
8195 < s/'"$ac_delim"'$/,g/; t
8196 < s/$/\\/; p
15353 < N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n
15354 < ' >>$CONFIG_STATUS <conf$$subs.sed
15355 < rm -f conf$$subs.sed
15356 < cat >>$CONFIG_STATUS <<_ACEOF
15357 < CEOF$ac_eof
8190 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
8191 > if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
8192 >  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
8193 > else
8194 >  cat
8195 > fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
8196 >  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
8197   _ACEOF
8198  
8199 + # VPATH may cause trouble with some makes, so we remove sole $(srcdir),
8200 + # ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
8201 + # trailing colons and then remove the whole line if VPATH becomes empty
8202 + # (actually we leave an empty line to preserve line numbers).
8203 + if test "x$srcdir" = x.; then
8204 +  ac_vpsub='/^[  ]*VPATH[        ]*=[    ]*/{
8205 + h
8206 + s///
8207 + s/^/:/
8208 + s/[      ]*$/:/
8209 + s/:\$(srcdir):/:/g
8210 + s/:\${srcdir}:/:/g
8211 + s/:@srcdir@:/:/g
8212 + s/^:*//
8213 + s/:*$//
8214 + x
8215 + s/\(=[   ]*\).*/\1/
8216 + G
8217 + s/\n//
8218 + s/^[^=]*=[       ]*$//
8219 + }'
8220 + fi
8221  
8222 < ac_delim='%!_!# '
8223 < for ac_last_try in false false false false false :; do
8224 <  cat >conf$$subs.sed <<_ACEOF
8225 < MPI_F90_INC!$MPI_F90_INC$ac_delim
8226 < MPI_LIB!$MPI_LIB$ac_delim
8227 < MPI_F90_LIB!$MPI_F90_LIB$ac_delim
8228 < USE_MPI!$USE_MPI$ac_delim
8229 < DOXYGEN!$DOXYGEN$ac_delim
8230 < DOT!$DOT$ac_delim
15370 < DOC!$DOC$ac_delim
15371 < enable_dot!$enable_dot$ac_delim
15372 < enable_html_docs!$enable_html_docs$ac_delim
15373 < enable_latex_docs!$enable_latex_docs$ac_delim
15374 < BATEXT!$BATEXT$ac_delim
15375 < MKINSTALLDIRS!$MKINSTALLDIRS$ac_delim
15376 < OOPSE!$OOPSE$ac_delim
15377 < OOPSE_HOME!$OOPSE_HOME$ac_delim
15378 < SUBDIRS!$SUBDIRS$ac_delim
15379 < LTLIBOBJS!$LTLIBOBJS$ac_delim
8222 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
8223 > fi # test -n "$CONFIG_FILES"
8224 >
8225 > # Set up the scripts for CONFIG_HEADERS section.
8226 > # No need to generate them if there are no CONFIG_HEADERS.
8227 > # This happens for instance with `./config.status Makefile'.
8228 > if test -n "$CONFIG_HEADERS"; then
8229 > cat >"$ac_tmp/defines.awk" <<\_ACAWK ||
8230 > BEGIN {
8231   _ACEOF
8232  
8233 <  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 16; then
8233 > # Transform confdefs.h into an awk script `defines.awk', embedded as
8234 > # here-document in config.status, that substitutes the proper values into
8235 > # config.h.in to produce config.h.
8236 >
8237 > # Create a delimiter string that does not exist in confdefs.h, to ease
8238 > # handling of long lines.
8239 > ac_delim='%!_!# '
8240 > for ac_last_try in false false :; do
8241 >  ac_tt=`sed -n "/$ac_delim/p" confdefs.h`
8242 >  if test -z "$ac_tt"; then
8243      break
8244    elif $ac_last_try; then
8245 <    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
15386 < echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
15387 <   { (exit 1); exit 1; }; }
8245 >    as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5
8246    else
8247      ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
8248    fi
8249   done
8250  
8251 < ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`
8252 < if test -n "$ac_eof"; then
8253 <  ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`
15396 <  ac_eof=`expr $ac_eof + 1`
15397 < fi
8251 > # For the awk script, D is an array of macro values keyed by name,
8252 > # likewise P contains macro parameters if any.  Preserve backslash
8253 > # newline sequences.
8254  
8255 < cat >>$CONFIG_STATUS <<_ACEOF
8256 < cat >"\$tmp/subs-2.sed" <<\CEOF$ac_eof
8257 < /@[a-zA-Z_][a-zA-Z_0-9]*@/!b end
8255 > ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
8256 > sed -n '
8257 > s/.\{148\}/&'"$ac_delim"'/g
8258 > t rset
8259 > :rset
8260 > s/^[     ]*#[    ]*define[       ][      ]*/ /
8261 > t def
8262 > d
8263 > :def
8264 > s/\\$//
8265 > t bsnl
8266 > s/["\\]/\\&/g
8267 > s/^ \('"$ac_word_re"'\)\(([^()]*)\)[     ]*\(.*\)/P["\1"]="\2"\
8268 > D["\1"]=" \3"/p
8269 > s/^ \('"$ac_word_re"'\)[         ]*\(.*\)/D["\1"]=" \2"/p
8270 > d
8271 > :bsnl
8272 > s/["\\]/\\&/g
8273 > s/^ \('"$ac_word_re"'\)\(([^()]*)\)[     ]*\(.*\)/P["\1"]="\2"\
8274 > D["\1"]=" \3\\\\\\n"\\/p
8275 > t cont
8276 > s/^ \('"$ac_word_re"'\)[         ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p
8277 > t cont
8278 > d
8279 > :cont
8280 > n
8281 > s/.\{148\}/&'"$ac_delim"'/g
8282 > t clear
8283 > :clear
8284 > s/\\$//
8285 > t bsnlc
8286 > s/["\\]/\\&/g; s/^/"/; s/$/"/p
8287 > d
8288 > :bsnlc
8289 > s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p
8290 > b cont
8291 > ' <confdefs.h | sed '
8292 > s/'"$ac_delim"'/"\\\
8293 > "/g' >>$CONFIG_STATUS || ac_write_fail=1
8294 >
8295 > cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
8296 >  for (key in D) D_is_set[key] = 1
8297 >  FS = ""
8298 > }
8299 > /^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ {
8300 >  line = \$ 0
8301 >  split(line, arg, " ")
8302 >  if (arg[1] == "#") {
8303 >    defundef = arg[2]
8304 >    mac1 = arg[3]
8305 >  } else {
8306 >    defundef = substr(arg[1], 2)
8307 >    mac1 = arg[2]
8308 >  }
8309 >  split(mac1, mac2, "(") #)
8310 >  macro = mac2[1]
8311 >  prefix = substr(line, 1, index(line, defundef) - 1)
8312 >  if (D_is_set[macro]) {
8313 >    # Preserve the white space surrounding the "#".
8314 >    print prefix "define", macro P[macro] D[macro]
8315 >    next
8316 >  } else {
8317 >    # Replace #undef with comments.  This is necessary, for example,
8318 >    # in the case of _POSIX_SOURCE, which is predefined and required
8319 >    # on some systems where configure will not decide to define it.
8320 >    if (defundef == "undef") {
8321 >      print "/*", prefix defundef, macro, "*/"
8322 >      next
8323 >    }
8324 >  }
8325 > }
8326 > { print }
8327 > _ACAWK
8328   _ACEOF
8329 < sed '
8330 < s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g
8331 < s/^/s,@/; s/!/@,|#_!!_#|/
15406 < :n
15407 < t n
15408 < s/'"$ac_delim"'$/,g/; t
15409 < s/$/\\/; p
15410 < N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n
15411 < ' >>$CONFIG_STATUS <conf$$subs.sed
15412 < rm -f conf$$subs.sed
15413 < cat >>$CONFIG_STATUS <<_ACEOF
15414 < :end
15415 < s/|#_!!_#|//g
15416 < CEOF$ac_eof
15417 < _ACEOF
8329 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
8330 >  as_fn_error $? "could not setup config headers machinery" "$LINENO" 5
8331 > fi # test -n "$CONFIG_HEADERS"
8332  
8333  
8334 < # VPATH may cause trouble with some makes, so we remove $(srcdir),
8335 < # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
8336 < # trailing colons and then remove the whole line if VPATH becomes empty
15423 < # (actually we leave an empty line to preserve line numbers).
15424 < if test "x$srcdir" = x.; then
15425 <  ac_vpsub='/^[  ]*VPATH[        ]*=/{
15426 < s/:*\$(srcdir):*/:/
15427 < s/:*\${srcdir}:*/:/
15428 < s/:*@srcdir@:*/:/
15429 < s/^\([^=]*=[     ]*\):*/\1/
15430 < s/:*$//
15431 < s/^[^=]*=[       ]*$//
15432 < }'
15433 < fi
15434 <
15435 < cat >>$CONFIG_STATUS <<\_ACEOF
15436 < fi # test -n "$CONFIG_FILES"
15437 <
15438 <
15439 < for ac_tag in  :F $CONFIG_FILES  :H $CONFIG_HEADERS  :L $CONFIG_LINKS
8334 > eval set X "  :F $CONFIG_FILES  :H $CONFIG_HEADERS    "
8335 > shift
8336 > for ac_tag
8337   do
8338    case $ac_tag in
8339    :[FHLC]) ac_mode=$ac_tag; continue;;
8340    esac
8341    case $ac_mode$ac_tag in
8342    :[FHL]*:*);;
8343 <  :L* | :C*:*) { { echo "$as_me:$LINENO: error: Invalid tag $ac_tag." >&5
15447 < echo "$as_me: error: Invalid tag $ac_tag." >&2;}
15448 <   { (exit 1); exit 1; }; };;
8343 >  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
8344    :[FH]-) ac_tag=-:-;;
8345    :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
8346    esac
# Line 15464 | Line 8359 | echo "$as_me: error: Invalid tag $ac_tag." >&2;}
8359      for ac_f
8360      do
8361        case $ac_f in
8362 <      -) ac_f="$tmp/stdin";;
8362 >      -) ac_f="$ac_tmp/stdin";;
8363        *) # Look for the file first in the build tree, then in the source tree
8364           # (if the path is not absolute).  The absolute path cannot be DOS-style,
8365           # because $ac_f cannot contain `:'.
# Line 15473 | Line 8368 | echo "$as_me: error: Invalid tag $ac_tag." >&2;}
8368             [\\/$]*) false;;
8369             *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
8370             esac ||
8371 <           { { echo "$as_me:$LINENO: error: cannot find input file: $ac_f" >&5
15477 < echo "$as_me: error: cannot find input file: $ac_f" >&2;}
15478 <   { (exit 1); exit 1; }; };;
8371 >           as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
8372        esac
8373 <      ac_file_inputs="$ac_file_inputs $ac_f"
8373 >      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
8374 >      as_fn_append ac_file_inputs " '$ac_f'"
8375      done
8376  
8377      # Let's still pretend it is `configure' which instantiates (i.e., don't
8378      # use $as_me), people would be surprised to read:
8379      #    /* config.h.  Generated by config.status.  */
8380 <    configure_input="Generated from "`IFS=:
8381 <          echo $* | sed 's|^[^:]*/||;s|:[^:]*/|, |g'`" by configure."
8380 >    configure_input='Generated from '`
8381 >          $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
8382 >        `' by configure.'
8383      if test x"$ac_file" != x-; then
8384        configure_input="$ac_file.  $configure_input"
8385 <      { echo "$as_me:$LINENO: creating $ac_file" >&5
8386 < echo "$as_me: creating $ac_file" >&6;}
8385 >      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
8386 > $as_echo "$as_me: creating $ac_file" >&6;}
8387      fi
8388 +    # Neutralize special characters interpreted by sed in replacement strings.
8389 +    case $configure_input in #(
8390 +    *\&* | *\|* | *\\* )
8391 +       ac_sed_conf_input=`$as_echo "$configure_input" |
8392 +       sed 's/[\\\\&|]/\\\\&/g'`;; #(
8393 +    *) ac_sed_conf_input=$configure_input;;
8394 +    esac
8395  
8396      case $ac_tag in
8397 <    *:-:* | *:-) cat >"$tmp/stdin";;
8397 >    *:-:* | *:-) cat >"$ac_tmp/stdin" \
8398 >      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
8399      esac
8400      ;;
8401    esac
# Line 15502 | Line 8405 | $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \|
8405           X"$ac_file" : 'X\(//\)[^/]' \| \
8406           X"$ac_file" : 'X\(//\)$' \| \
8407           X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
8408 < echo X"$ac_file" |
15506 <    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
15507 <            s//\1/
15508 <            q
15509 <          }
15510 <          /^X\(\/\/\)[^/].*/{
15511 <            s//\1/
15512 <            q
15513 <          }
15514 <          /^X\(\/\/\)$/{
15515 <            s//\1/
15516 <            q
15517 <          }
15518 <          /^X\(\/\).*/{
15519 <            s//\1/
15520 <            q
15521 <          }
15522 <          s/.*/./; q'`
15523 <  { as_dir="$ac_dir"
15524 <  case $as_dir in #(
15525 <  -*) as_dir=./$as_dir;;
15526 <  esac
15527 <  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {
15528 <    as_dirs=
15529 <    while :; do
15530 <      case $as_dir in #(
15531 <      *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #(
15532 <      *) as_qdir=$as_dir;;
15533 <      esac
15534 <      as_dirs="'$as_qdir' $as_dirs"
15535 <      as_dir=`$as_dirname -- "$as_dir" ||
15536 < $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
15537 <         X"$as_dir" : 'X\(//\)[^/]' \| \
15538 <         X"$as_dir" : 'X\(//\)$' \| \
15539 <         X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
15540 < echo X"$as_dir" |
8408 > $as_echo X"$ac_file" |
8409      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
8410              s//\1/
8411              q
# Line 15555 | Line 8423 | echo X"$as_dir" |
8423              q
8424            }
8425            s/.*/./; q'`
8426 <      test -d "$as_dir" && break
15559 <    done
15560 <    test -z "$as_dirs" || eval "mkdir $as_dirs"
15561 <  } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
15562 < echo "$as_me: error: cannot create directory $as_dir" >&2;}
15563 <   { (exit 1); exit 1; }; }; }
8426 >  as_dir="$ac_dir"; as_fn_mkdir_p
8427    ac_builddir=.
8428  
8429   case "$ac_dir" in
8430   .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
8431   *)
8432 <  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
8432 >  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
8433    # A ".." for each directory in $ac_dir_suffix.
8434 <  ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`
8434 >  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
8435    case $ac_top_builddir_sub in
8436    "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
8437    *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
# Line 15608 | Line 8471 | _ACEOF
8471    esac
8472   _ACEOF
8473  
8474 < cat >>$CONFIG_STATUS <<\_ACEOF
8474 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
8475   # If the template does not know about datarootdir, expand it.
8476   # FIXME: This hack should be removed a few years after 2.60.
8477   ac_datarootdir_hack=; ac_datarootdir_seen=
8478 <
8479 < case `sed -n '/datarootdir/ {
8478 > ac_sed_dataroot='
8479 > /datarootdir/ {
8480    p
8481    q
8482   }
# Line 15621 | Line 8484 | case `sed -n '/datarootdir/ {
8484   /@docdir@/p
8485   /@infodir@/p
8486   /@localedir@/p
8487 < /@mandir@/p
8488 < ' $ac_file_inputs` in
8487 > /@mandir@/p'
8488 > case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
8489   *datarootdir*) ac_datarootdir_seen=yes;;
8490   *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
8491 <  { echo "$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
8492 < echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
8491 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
8492 > $as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
8493   _ACEOF
8494 < cat >>$CONFIG_STATUS <<_ACEOF
8494 > cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
8495    ac_datarootdir_hack='
8496    s&@datadir@&$datadir&g
8497    s&@docdir@&$docdir&g
8498    s&@infodir@&$infodir&g
8499    s&@localedir@&$localedir&g
8500    s&@mandir@&$mandir&g
8501 <    s&\\\${datarootdir}&$datarootdir&g' ;;
8501 >  s&\\\${datarootdir}&$datarootdir&g' ;;
8502   esac
8503   _ACEOF
8504  
8505   # Neutralize VPATH when `$srcdir' = `.'.
8506   # Shell code in configure.ac might set extrasub.
8507   # FIXME: do we really want to maintain this feature?
8508 < cat >>$CONFIG_STATUS <<_ACEOF
8509 <  sed "$ac_vpsub
8508 > cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
8509 > ac_sed_extra="$ac_vpsub
8510   $extrasub
8511   _ACEOF
8512 < cat >>$CONFIG_STATUS <<\_ACEOF
8512 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
8513   :t
8514   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
8515 < s&@configure_input@&$configure_input&;t t
8515 > s|@configure_input@|$ac_sed_conf_input|;t t
8516   s&@top_builddir@&$ac_top_builddir_sub&;t t
8517 + s&@top_build_prefix@&$ac_top_build_prefix&;t t
8518   s&@srcdir@&$ac_srcdir&;t t
8519   s&@abs_srcdir@&$ac_abs_srcdir&;t t
8520   s&@top_srcdir@&$ac_top_srcdir&;t t
# Line 15660 | Line 8524 | $ac_datarootdir_hack
8524   s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
8525   s&@INSTALL@&$ac_INSTALL&;t t
8526   $ac_datarootdir_hack
8527 < " $ac_file_inputs | sed -f "$tmp/subs-1.sed" | sed -f "$tmp/subs-2.sed" >$tmp/out
8527 > "
8528 > eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
8529 >  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
8530  
8531   test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
8532 <  { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } &&
8533 <  { ac_out=`sed -n '/^[  ]*datarootdir[  ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } &&
8534 <  { echo "$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable \`datarootdir'
8535 < which seems to be undefined.  Please make sure it is defined." >&5
8536 < echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
8537 < which seems to be undefined.  Please make sure it is defined." >&2;}
8532 >  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
8533 >  { ac_out=`sed -n '/^[  ]*datarootdir[  ]*:*=/p' \
8534 >      "$ac_tmp/out"`; test -z "$ac_out"; } &&
8535 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
8536 > which seems to be undefined.  Please make sure it is defined" >&5
8537 > $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
8538 > which seems to be undefined.  Please make sure it is defined" >&2;}
8539  
8540 <  rm -f "$tmp/stdin"
8540 >  rm -f "$ac_tmp/stdin"
8541    case $ac_file in
8542 <  -) cat "$tmp/out"; rm -f "$tmp/out";;
8543 <  *) rm -f "$ac_file"; mv "$tmp/out" $ac_file;;
8544 <  esac
8542 >  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
8543 >  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
8544 >  esac \
8545 >  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
8546   ;;
8547    :H)
8548    #
8549    # CONFIG_HEADER
8550    #
8551 < _ACEOF
8552 <
8553 < # Transform confdefs.h into a sed script `conftest.defines', that
8554 < # substitutes the proper values into config.h.in to produce config.h.
8555 < rm -f conftest.defines conftest.tail
8556 < # First, append a space to every undef/define line, to ease matching.
8557 < echo 's/$/ /' >conftest.defines
8558 < # Then, protect against being on the right side of a sed subst, or in
8559 < # an unquoted here document, in config.status.  If some macros were
15692 < # called several times there might be several #defines for the same
15693 < # symbol, which is useless.  But do not sort them, since the last
15694 < # AC_DEFINE must be honored.
15695 < ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
15696 < # These sed commands are passed to sed as "A NAME B PARAMS C VALUE D", where
15697 < # NAME is the cpp macro being defined, VALUE is the value it is being given.
15698 < # PARAMS is the parameter list in the macro definition--in most cases, it's
15699 < # just an empty string.
15700 < ac_dA='s,^\\([   #]*\\)[^        ]*\\([  ]*'
15701 < ac_dB='\\)[      (].*,\\1define\\2'
15702 < ac_dC=' '
15703 < ac_dD=' ,'
15704 <
15705 < uniq confdefs.h |
15706 <  sed -n '
15707 <        t rset
15708 <        :rset
15709 <        s/^[     ]*#[    ]*define[       ][      ]*//
15710 <        t ok
15711 <        d
15712 <        :ok
15713 <        s/[\\&,]/\\&/g
15714 <        s/^\('"$ac_word_re"'\)\(([^()]*)\)[      ]*\(.*\)/ '"$ac_dA"'\1'"$ac_dB"'\2'"${ac_dC}"'\3'"$ac_dD"'/p
15715 <        s/^\('"$ac_word_re"'\)[  ]*\(.*\)/'"$ac_dA"'\1'"$ac_dB$ac_dC"'\2'"$ac_dD"'/p
15716 <  ' >>conftest.defines
15717 <
15718 < # Remove the space that was appended to ease matching.
15719 < # Then replace #undef with comments.  This is necessary, for
15720 < # example, in the case of _POSIX_SOURCE, which is predefined and required
15721 < # on some systems where configure will not decide to define it.
15722 < # (The regexp can be short, since the line contains either #define or #undef.)
15723 < echo 's/ $//
15724 < s,^[     #]*u.*,/* & */,' >>conftest.defines
15725 <
15726 < # Break up conftest.defines:
15727 < ac_max_sed_lines=50
15728 <
15729 < # First sed command is:  sed -f defines.sed $ac_file_inputs >"$tmp/out1"
15730 < # Second one is:         sed -f defines.sed "$tmp/out1" >"$tmp/out2"
15731 < # Third one will be:     sed -f defines.sed "$tmp/out2" >"$tmp/out1"
15732 < # et cetera.
15733 < ac_in='$ac_file_inputs'
15734 < ac_out='"$tmp/out1"'
15735 < ac_nxt='"$tmp/out2"'
15736 <
15737 < while :
15738 < do
15739 <  # Write a here document:
15740 <    cat >>$CONFIG_STATUS <<_ACEOF
15741 <    # First, check the format of the line:
15742 <    cat >"\$tmp/defines.sed" <<\\CEOF
15743 < /^[      ]*#[    ]*undef[        ][      ]*$ac_word_re[  ]*\$/b def
15744 < /^[      ]*#[    ]*define[       ][      ]*$ac_word_re[(         ]/b def
15745 < b
15746 < :def
15747 < _ACEOF
15748 <  sed ${ac_max_sed_lines}q conftest.defines >>$CONFIG_STATUS
15749 <  echo 'CEOF
15750 <    sed -f "$tmp/defines.sed"' "$ac_in >$ac_out" >>$CONFIG_STATUS
15751 <  ac_in=$ac_out; ac_out=$ac_nxt; ac_nxt=$ac_in
15752 <  sed 1,${ac_max_sed_lines}d conftest.defines >conftest.tail
15753 <  grep . conftest.tail >/dev/null || break
15754 <  rm -f conftest.defines
15755 <  mv conftest.tail conftest.defines
15756 < done
15757 < rm -f conftest.defines conftest.tail
15758 <
15759 < echo "ac_result=$ac_in" >>$CONFIG_STATUS
15760 < cat >>$CONFIG_STATUS <<\_ACEOF
15761 <  if test x"$ac_file" != x-; then
15762 <    echo "/* $configure_input  */" >"$tmp/config.h"
15763 <    cat "$ac_result" >>"$tmp/config.h"
15764 <    if diff $ac_file "$tmp/config.h" >/dev/null 2>&1; then
15765 <      { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
15766 < echo "$as_me: $ac_file is unchanged" >&6;}
8551 >  if test x"$ac_file" != x-; then
8552 >    {
8553 >      $as_echo "/* $configure_input  */" \
8554 >      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
8555 >    } >"$ac_tmp/config.h" \
8556 >      || as_fn_error $? "could not create $ac_file" "$LINENO" 5
8557 >    if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
8558 >      { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
8559 > $as_echo "$as_me: $ac_file is unchanged" >&6;}
8560      else
8561 <      rm -f $ac_file
8562 <      mv "$tmp/config.h" $ac_file
8561 >      rm -f "$ac_file"
8562 >      mv "$ac_tmp/config.h" "$ac_file" \
8563 >        || as_fn_error $? "could not create $ac_file" "$LINENO" 5
8564      fi
8565    else
8566 <    echo "/* $configure_input  */"
8567 <    cat "$ac_result"
8566 >    $as_echo "/* $configure_input  */" \
8567 >      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
8568 >      || as_fn_error $? "could not create -" "$LINENO" 5
8569    fi
15775 –  rm -f "$tmp/out12"
8570   ;;
15777 –  :L)
15778 –  #
15779 –  # CONFIG_LINK
15780 –  #
8571  
15782 –  { echo "$as_me:$LINENO: linking $srcdir/$ac_source to $ac_file" >&5
15783 – echo "$as_me: linking $srcdir/$ac_source to $ac_file" >&6;}
8572  
15785 –  if test ! -r "$srcdir/$ac_source"; then
15786 –    { { echo "$as_me:$LINENO: error: $srcdir/$ac_source: file not found" >&5
15787 – echo "$as_me: error: $srcdir/$ac_source: file not found" >&2;}
15788 –   { (exit 1); exit 1; }; }
15789 –  fi
15790 –  rm -f "$ac_file"
15791 –
15792 –  # Try a relative symlink, then a hard link, then a copy.
15793 –  case $srcdir in
15794 –  [\\/$]* | ?:[\\/]* ) ac_rel_source=$srcdir/$ac_source ;;
15795 –      *) ac_rel_source=$ac_top_build_prefix$srcdir/$ac_source ;;
8573    esac
15797 –  ln -s "$ac_rel_source" "$ac_file" 2>/dev/null ||
15798 –    ln "$srcdir/$ac_source" "$ac_file" 2>/dev/null ||
15799 –    cp -p "$srcdir/$ac_source" "$ac_file" ||
15800 –    { { echo "$as_me:$LINENO: error: cannot link or copy $srcdir/$ac_source to $ac_file" >&5
15801 – echo "$as_me: error: cannot link or copy $srcdir/$ac_source to $ac_file" >&2;}
15802 –   { (exit 1); exit 1; }; }
15803 – ;;
8574  
15805 –  esac
8575  
15807 –
8576    case $ac_file$ac_mode in
8577      "make/Makefile":F) chmod 0755 scripts/* ;;
8578      "src/utils/Makefile":F) chmod 0755 scripts/* ;;
8579 +    "src/math/Makefile":F) chmod 0755 scripts/* ;;
8580 +    "src/integrators/Makefile":F) chmod 0755 scripts/* ;;
8581 +    "src/applications/atom2md/Makefile":F) chmod 0755 scripts/* ;;
8582      "scripts/filepp":F) chmod 0755 scripts/* ;;
8583  
8584    esac
8585   done # for ac_tag
8586  
8587  
8588 < { (exit 0); exit 0; }
8588 > as_fn_exit 0
8589   _ACEOF
15819 – chmod +x $CONFIG_STATUS
8590   ac_clean_files=$ac_clean_files_save
8591  
8592 + test $ac_write_fail = 0 ||
8593 +  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
8594  
8595 +
8596   # configure is writing to config.log, and then calls config.status.
8597   # config.status does its own redirection, appending to config.log.
8598   # Unfortunately, on DOS this fails, as config.log is still kept open
# Line 15838 | Line 8611 | if test "$no_create" != yes; then
8611    exec 5>>config.log
8612    # Use ||, not &&, to avoid exiting from the if with $? = 1, which
8613    # would make configure fail if this is the last instruction.
8614 <  $ac_cs_success || { (exit 1); exit 1; }
8614 >  $ac_cs_success || as_fn_exit 1
8615   fi
8616 + if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
8617 +  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
8618 + $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
8619 + fi
8620  

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines