OpenCores
URL https://opencores.org/ocsvn/scarts/scarts/trunk

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gcc/] [gcc-4.1.1/] [libgfortran/] [configure] - Blame information for rev 14

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 14 jlechner
#! /bin/sh
2
# Guess values for system-dependent variables and create Makefiles.
3
# Generated by GNU Autoconf 2.59 for GNU Fortran Runtime Library 0.2.
4
#
5
# Copyright (C) 2003 Free Software Foundation, Inc.
6
# This configure script is free software; the Free Software Foundation
7
# gives unlimited permission to copy, distribute and modify it.
8
## --------------------- ##
9
## M4sh Initialization.  ##
10
## --------------------- ##
11
 
12
# Be Bourne compatible
13
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
14
  emulate sh
15
  NULLCMD=:
16
  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
17
  # is contrary to our usage.  Disable this feature.
18
  alias -g '${1+"$@"}'='"$@"'
19
elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
20
  set -o posix
21
fi
22
DUALCASE=1; export DUALCASE # for MKS sh
23
 
24
# Support unset when possible.
25
if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
26
  as_unset=unset
27
else
28
  as_unset=false
29
fi
30
 
31
 
32
# Work around bugs in pre-3.0 UWIN ksh.
33
$as_unset ENV MAIL MAILPATH
34
PS1='$ '
35
PS2='> '
36
PS4='+ '
37
 
38
# NLS nuisances.
39
for as_var in \
40
  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
41
  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
42
  LC_TELEPHONE LC_TIME
43
do
44
  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
45
    eval $as_var=C; export $as_var
46
  else
47
    $as_unset $as_var
48
  fi
49
done
50
 
51
# Required to use basename.
52
if expr a : '\(a\)' >/dev/null 2>&1; then
53
  as_expr=expr
54
else
55
  as_expr=false
56
fi
57
 
58
if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
59
  as_basename=basename
60
else
61
  as_basename=false
62
fi
63
 
64
 
65
# Name of the executable.
66
as_me=`$as_basename "$0" ||
67
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
68
         X"$0" : 'X\(//\)$' \| \
69
         X"$0" : 'X\(/\)$' \| \
70
         .     : '\(.\)' 2>/dev/null ||
71
echo X/"$0" |
72
    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
73
          /^X\/\(\/\/\)$/{ s//\1/; q; }
74
          /^X\/\(\/\).*/{ s//\1/; q; }
75
          s/.*/./; q'`
76
 
77
 
78
# PATH needs CR, and LINENO needs CR and PATH.
79
# Avoid depending upon Character Ranges.
80
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
81
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
82
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
83
as_cr_digits='0123456789'
84
as_cr_alnum=$as_cr_Letters$as_cr_digits
85
 
86
# The user is always right.
87
if test "${PATH_SEPARATOR+set}" != set; then
88
  echo "#! /bin/sh" >conf$$.sh
89
  echo  "exit 0"   >>conf$$.sh
90
  chmod +x conf$$.sh
91
  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
92
    PATH_SEPARATOR=';'
93
  else
94
    PATH_SEPARATOR=:
95
  fi
96
  rm -f conf$$.sh
97
fi
98
 
99
 
100
  as_lineno_1=$LINENO
101
  as_lineno_2=$LINENO
102
  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
103
  test "x$as_lineno_1" != "x$as_lineno_2" &&
104
  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
105
  # Find who we are.  Look in the path if we contain no path at all
106
  # relative or not.
107
  case $0 in
108
    *[\\/]* ) as_myself=$0 ;;
109
    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
110
for as_dir in $PATH
111
do
112
  IFS=$as_save_IFS
113
  test -z "$as_dir" && as_dir=.
114
  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
115
done
116
 
117
       ;;
118
  esac
119
  # We did not find ourselves, most probably we were run as `sh COMMAND'
120
  # in which case we are not to be found in the path.
121
  if test "x$as_myself" = x; then
122
    as_myself=$0
123
  fi
124
  if test ! -f "$as_myself"; then
125
    { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
126
   { (exit 1); exit 1; }; }
127
  fi
128
  case $CONFIG_SHELL in
129
  '')
130
    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
131
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
132
do
133
  IFS=$as_save_IFS
134
  test -z "$as_dir" && as_dir=.
135
  for as_base in sh bash ksh sh5; do
136
         case $as_dir in
137
         /*)
138
           if ("$as_dir/$as_base" -c '
139
  as_lineno_1=$LINENO
140
  as_lineno_2=$LINENO
141
  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
142
  test "x$as_lineno_1" != "x$as_lineno_2" &&
143
  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
144
             $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
145
             $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
146
             CONFIG_SHELL=$as_dir/$as_base
147
             export CONFIG_SHELL
148
             exec "$CONFIG_SHELL" "$0" ${1+"$@"}
149
           fi;;
150
         esac
151
       done
152
done
153
;;
154
  esac
155
 
156
  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
157
  # uniformly replaced by the line number.  The first 'sed' inserts a
158
  # line-number line before each line; the second 'sed' does the real
159
  # work.  The second script uses 'N' to pair each line-number line
160
  # with the numbered line, and appends trailing '-' during
161
  # substitution so that $LINENO is not a special case at line end.
162
  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
163
  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
164
  sed '=' <$as_myself |
165
    sed '
166
      N
167
      s,$,-,
168
      : loop
169
      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
170
      t loop
171
      s,-$,,
172
      s,^['$as_cr_digits']*\n,,
173
    ' >$as_me.lineno &&
174
  chmod +x $as_me.lineno ||
175
    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
176
   { (exit 1); exit 1; }; }
177
 
178
  # Don't try to exec as it changes $[0], causing all sort of problems
179
  # (the dirname of $[0] is not the place where we might find the
180
  # original and so on.  Autoconf is especially sensible to this).
181
  . ./$as_me.lineno
182
  # Exit status is that of the last command.
183
  exit
184
}
185
 
186
 
187
case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
188
  *c*,-n*) ECHO_N= ECHO_C='
189
' ECHO_T='      ' ;;
190
  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
191
  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
192
esac
193
 
194
if expr a : '\(a\)' >/dev/null 2>&1; then
195
  as_expr=expr
196
else
197
  as_expr=false
198
fi
199
 
200
rm -f conf$$ conf$$.exe conf$$.file
201
echo >conf$$.file
202
if ln -s conf$$.file conf$$ 2>/dev/null; then
203
  # We could just check for DJGPP; but this test a) works b) is more generic
204
  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
205
  if test -f conf$$.exe; then
206
    # Don't use ln at all; we don't have any links
207
    as_ln_s='cp -p'
208
  else
209
    as_ln_s='ln -s'
210
  fi
211
elif ln conf$$.file conf$$ 2>/dev/null; then
212
  as_ln_s=ln
213
else
214
  as_ln_s='cp -p'
215
fi
216
rm -f conf$$ conf$$.exe conf$$.file
217
 
218
if mkdir -p . 2>/dev/null; then
219
  as_mkdir_p=:
220
else
221
  test -d ./-p && rmdir ./-p
222
  as_mkdir_p=false
223
fi
224
 
225
as_executable_p="test -f"
226
 
227
# Sed expression to map a string onto a valid CPP name.
228
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
229
 
230
# Sed expression to map a string onto a valid variable name.
231
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
232
 
233
 
234
# IFS
235
# We need space, tab and new line, in precisely that order.
236
as_nl='
237
'
238
IFS="   $as_nl"
239
 
240
# CDPATH.
241
$as_unset CDPATH
242
 
243
 
244
# Name of the host.
245
# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
246
# so uname gets run too.
247
ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
248
 
249
exec 6>&1
250
 
251
#
252
# Initializations.
253
#
254
ac_default_prefix=/usr/local
255
ac_config_libobj_dir=.
256
cross_compiling=no
257
subdirs=
258
MFLAGS=
259
MAKEFLAGS=
260
SHELL=${CONFIG_SHELL-/bin/sh}
261
 
262
# Maximum number of lines to put in a shell here document.
263
# This variable seems obsolete.  It should probably be removed, and
264
# only ac_max_sed_lines should be used.
265
: ${ac_max_here_lines=38}
266
 
267
# Identity of this package.
268
PACKAGE_NAME='GNU Fortran Runtime Library'
269
PACKAGE_TARNAME='libgfortran'
270
PACKAGE_VERSION='0.2'
271
PACKAGE_STRING='GNU Fortran Runtime Library 0.2'
272
PACKAGE_BUGREPORT=''
273
 
274
# Factoring default headers for most tests.
275
ac_includes_default="\
276
#include 
277
#if HAVE_SYS_TYPES_H
278
# include 
279
#endif
280
#if HAVE_SYS_STAT_H
281
# include 
282
#endif
283
#if STDC_HEADERS
284
# include 
285
# include 
286
#else
287
# if HAVE_STDLIB_H
288
#  include 
289
# endif
290
#endif
291
#if HAVE_STRING_H
292
# if !STDC_HEADERS && HAVE_MEMORY_H
293
#  include 
294
# endif
295
# include 
296
#endif
297
#if HAVE_STRINGS_H
298
# include 
299
#endif
300
#if HAVE_INTTYPES_H
301
# include 
302
#else
303
# if HAVE_STDINT_H
304
#  include 
305
# endif
306
#endif
307
#if HAVE_UNISTD_H
308
# include 
309
#endif"
310
 
311
ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os build_subdir host_subdir target_subdir host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA CYGPATH_W PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM mkdir_p AWK SET_MAKE am__leading_dot AMTAR am__tar am__untar MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT multi_basedir toolexecdir toolexeclibdir CC ac_ct_CC EXEEXT OBJEXT AM_FCFLAGS AM_CFLAGS AS ac_ct_AS AR ac_ct_AR RANLIB ac_ct_RANLIB LN_S LIBTOOL enable_shared enable_static FC FCFLAGS LDFLAGS ac_ct_FC extra_ldflags_libgfortran CPP CPPFLAGS EGREP FPU_HOST_HEADER LIBOBJS LTLIBOBJS'
312
ac_subst_files=''
313
 
314
# Initialize some variables set by options.
315
ac_init_help=
316
ac_init_version=false
317
# The variables have the same names as the options, with
318
# dashes changed to underlines.
319
cache_file=/dev/null
320
exec_prefix=NONE
321
no_create=
322
no_recursion=
323
prefix=NONE
324
program_prefix=NONE
325
program_suffix=NONE
326
program_transform_name=s,x,x,
327
silent=
328
site=
329
srcdir=
330
verbose=
331
x_includes=NONE
332
x_libraries=NONE
333
 
334
# Installation directory options.
335
# These are left unexpanded so users can "make install exec_prefix=/foo"
336
# and all the variables that are supposed to be based on exec_prefix
337
# by default will actually change.
338
# Use braces instead of parens because sh, perl, etc. also accept them.
339
bindir='${exec_prefix}/bin'
340
sbindir='${exec_prefix}/sbin'
341
libexecdir='${exec_prefix}/libexec'
342
datadir='${prefix}/share'
343
sysconfdir='${prefix}/etc'
344
sharedstatedir='${prefix}/com'
345
localstatedir='${prefix}/var'
346
libdir='${exec_prefix}/lib'
347
includedir='${prefix}/include'
348
oldincludedir='/usr/include'
349
infodir='${prefix}/info'
350
mandir='${prefix}/man'
351
 
352
ac_prev=
353
for ac_option
354
do
355
  # If the previous option needs an argument, assign it.
356
  if test -n "$ac_prev"; then
357
    eval "$ac_prev=\$ac_option"
358
    ac_prev=
359
    continue
360
  fi
361
 
362
  ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
363
 
364
  # Accept the important Cygnus configure options, so we can diagnose typos.
365
 
366
  case $ac_option in
367
 
368
  -bindir | --bindir | --bindi | --bind | --bin | --bi)
369
    ac_prev=bindir ;;
370
  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
371
    bindir=$ac_optarg ;;
372
 
373
  -build | --build | --buil | --bui | --bu)
374
    ac_prev=build_alias ;;
375
  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
376
    build_alias=$ac_optarg ;;
377
 
378
  -cache-file | --cache-file | --cache-fil | --cache-fi \
379
  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
380
    ac_prev=cache_file ;;
381
  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
382
  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
383
    cache_file=$ac_optarg ;;
384
 
385
  --config-cache | -C)
386
    cache_file=config.cache ;;
387
 
388
  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
389
    ac_prev=datadir ;;
390
  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
391
  | --da=*)
392
    datadir=$ac_optarg ;;
393
 
394
  -disable-* | --disable-*)
395
    ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
396
    # Reject names that are not valid shell variable names.
397
    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
398
      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
399
   { (exit 1); exit 1; }; }
400
    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
401
    eval "enable_$ac_feature=no" ;;
402
 
403
  -enable-* | --enable-*)
404
    ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
405
    # Reject names that are not valid shell variable names.
406
    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
407
      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
408
   { (exit 1); exit 1; }; }
409
    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
410
    case $ac_option in
411
      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
412
      *) ac_optarg=yes ;;
413
    esac
414
    eval "enable_$ac_feature='$ac_optarg'" ;;
415
 
416
  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
417
  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
418
  | --exec | --exe | --ex)
419
    ac_prev=exec_prefix ;;
420
  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
421
  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
422
  | --exec=* | --exe=* | --ex=*)
423
    exec_prefix=$ac_optarg ;;
424
 
425
  -gas | --gas | --ga | --g)
426
    # Obsolete; use --with-gas.
427
    with_gas=yes ;;
428
 
429
  -help | --help | --hel | --he | -h)
430
    ac_init_help=long ;;
431
  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
432
    ac_init_help=recursive ;;
433
  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
434
    ac_init_help=short ;;
435
 
436
  -host | --host | --hos | --ho)
437
    ac_prev=host_alias ;;
438
  -host=* | --host=* | --hos=* | --ho=*)
439
    host_alias=$ac_optarg ;;
440
 
441
  -includedir | --includedir | --includedi | --included | --include \
442
  | --includ | --inclu | --incl | --inc)
443
    ac_prev=includedir ;;
444
  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
445
  | --includ=* | --inclu=* | --incl=* | --inc=*)
446
    includedir=$ac_optarg ;;
447
 
448
  -infodir | --infodir | --infodi | --infod | --info | --inf)
449
    ac_prev=infodir ;;
450
  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
451
    infodir=$ac_optarg ;;
452
 
453
  -libdir | --libdir | --libdi | --libd)
454
    ac_prev=libdir ;;
455
  -libdir=* | --libdir=* | --libdi=* | --libd=*)
456
    libdir=$ac_optarg ;;
457
 
458
  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
459
  | --libexe | --libex | --libe)
460
    ac_prev=libexecdir ;;
461
  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
462
  | --libexe=* | --libex=* | --libe=*)
463
    libexecdir=$ac_optarg ;;
464
 
465
  -localstatedir | --localstatedir | --localstatedi | --localstated \
466
  | --localstate | --localstat | --localsta | --localst \
467
  | --locals | --local | --loca | --loc | --lo)
468
    ac_prev=localstatedir ;;
469
  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
470
  | --localstate=* | --localstat=* | --localsta=* | --localst=* \
471
  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
472
    localstatedir=$ac_optarg ;;
473
 
474
  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
475
    ac_prev=mandir ;;
476
  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
477
    mandir=$ac_optarg ;;
478
 
479
  -nfp | --nfp | --nf)
480
    # Obsolete; use --without-fp.
481
    with_fp=no ;;
482
 
483
  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
484
  | --no-cr | --no-c | -n)
485
    no_create=yes ;;
486
 
487
  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
488
  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
489
    no_recursion=yes ;;
490
 
491
  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
492
  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
493
  | --oldin | --oldi | --old | --ol | --o)
494
    ac_prev=oldincludedir ;;
495
  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
496
  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
497
  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
498
    oldincludedir=$ac_optarg ;;
499
 
500
  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
501
    ac_prev=prefix ;;
502
  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
503
    prefix=$ac_optarg ;;
504
 
505
  -program-prefix | --program-prefix | --program-prefi | --program-pref \
506
  | --program-pre | --program-pr | --program-p)
507
    ac_prev=program_prefix ;;
508
  -program-prefix=* | --program-prefix=* | --program-prefi=* \
509
  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
510
    program_prefix=$ac_optarg ;;
511
 
512
  -program-suffix | --program-suffix | --program-suffi | --program-suff \
513
  | --program-suf | --program-su | --program-s)
514
    ac_prev=program_suffix ;;
515
  -program-suffix=* | --program-suffix=* | --program-suffi=* \
516
  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
517
    program_suffix=$ac_optarg ;;
518
 
519
  -program-transform-name | --program-transform-name \
520
  | --program-transform-nam | --program-transform-na \
521
  | --program-transform-n | --program-transform- \
522
  | --program-transform | --program-transfor \
523
  | --program-transfo | --program-transf \
524
  | --program-trans | --program-tran \
525
  | --progr-tra | --program-tr | --program-t)
526
    ac_prev=program_transform_name ;;
527
  -program-transform-name=* | --program-transform-name=* \
528
  | --program-transform-nam=* | --program-transform-na=* \
529
  | --program-transform-n=* | --program-transform-=* \
530
  | --program-transform=* | --program-transfor=* \
531
  | --program-transfo=* | --program-transf=* \
532
  | --program-trans=* | --program-tran=* \
533
  | --progr-tra=* | --program-tr=* | --program-t=*)
534
    program_transform_name=$ac_optarg ;;
535
 
536
  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
537
  | -silent | --silent | --silen | --sile | --sil)
538
    silent=yes ;;
539
 
540
  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
541
    ac_prev=sbindir ;;
542
  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
543
  | --sbi=* | --sb=*)
544
    sbindir=$ac_optarg ;;
545
 
546
  -sharedstatedir | --sharedstatedir | --sharedstatedi \
547
  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
548
  | --sharedst | --shareds | --shared | --share | --shar \
549
  | --sha | --sh)
550
    ac_prev=sharedstatedir ;;
551
  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
552
  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
553
  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
554
  | --sha=* | --sh=*)
555
    sharedstatedir=$ac_optarg ;;
556
 
557
  -site | --site | --sit)
558
    ac_prev=site ;;
559
  -site=* | --site=* | --sit=*)
560
    site=$ac_optarg ;;
561
 
562
  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
563
    ac_prev=srcdir ;;
564
  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
565
    srcdir=$ac_optarg ;;
566
 
567
  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
568
  | --syscon | --sysco | --sysc | --sys | --sy)
569
    ac_prev=sysconfdir ;;
570
  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
571
  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
572
    sysconfdir=$ac_optarg ;;
573
 
574
  -target | --target | --targe | --targ | --tar | --ta | --t)
575
    ac_prev=target_alias ;;
576
  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
577
    target_alias=$ac_optarg ;;
578
 
579
  -v | -verbose | --verbose | --verbos | --verbo | --verb)
580
    verbose=yes ;;
581
 
582
  -version | --version | --versio | --versi | --vers | -V)
583
    ac_init_version=: ;;
584
 
585
  -with-* | --with-*)
586
    ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
587
    # Reject names that are not valid shell variable names.
588
    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
589
      { echo "$as_me: error: invalid package name: $ac_package" >&2
590
   { (exit 1); exit 1; }; }
591
    ac_package=`echo $ac_package| sed 's/-/_/g'`
592
    case $ac_option in
593
      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
594
      *) ac_optarg=yes ;;
595
    esac
596
    eval "with_$ac_package='$ac_optarg'" ;;
597
 
598
  -without-* | --without-*)
599
    ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
600
    # Reject names that are not valid shell variable names.
601
    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
602
      { echo "$as_me: error: invalid package name: $ac_package" >&2
603
   { (exit 1); exit 1; }; }
604
    ac_package=`echo $ac_package | sed 's/-/_/g'`
605
    eval "with_$ac_package=no" ;;
606
 
607
  --x)
608
    # Obsolete; use --with-x.
609
    with_x=yes ;;
610
 
611
  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
612
  | --x-incl | --x-inc | --x-in | --x-i)
613
    ac_prev=x_includes ;;
614
  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
615
  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
616
    x_includes=$ac_optarg ;;
617
 
618
  -x-libraries | --x-libraries | --x-librarie | --x-librari \
619
  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
620
    ac_prev=x_libraries ;;
621
  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
622
  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
623
    x_libraries=$ac_optarg ;;
624
 
625
  -*) { echo "$as_me: error: unrecognized option: $ac_option
626
Try \`$0 --help' for more information." >&2
627
   { (exit 1); exit 1; }; }
628
    ;;
629
 
630
  *=*)
631
    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
632
    # Reject names that are not valid shell variable names.
633
    expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
634
      { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
635
   { (exit 1); exit 1; }; }
636
    ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
637
    eval "$ac_envvar='$ac_optarg'"
638
    export $ac_envvar ;;
639
 
640
  *)
641
    # FIXME: should be removed in autoconf 3.0.
642
    echo "$as_me: WARNING: you should use --build, --host, --target" >&2
643
    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
644
      echo "$as_me: WARNING: invalid host type: $ac_option" >&2
645
    : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
646
    ;;
647
 
648
  esac
649
done
650
 
651
if test -n "$ac_prev"; then
652
  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
653
  { echo "$as_me: error: missing argument to $ac_option" >&2
654
   { (exit 1); exit 1; }; }
655
fi
656
 
657
# Be sure to have absolute paths.
658
for ac_var in exec_prefix prefix
659
do
660
  eval ac_val=$`echo $ac_var`
661
  case $ac_val in
662
    [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
663
    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
664
   { (exit 1); exit 1; }; };;
665
  esac
666
done
667
 
668
# Be sure to have absolute paths.
669
for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
670
              localstatedir libdir includedir oldincludedir infodir mandir
671
do
672
  eval ac_val=$`echo $ac_var`
673
  case $ac_val in
674
    [\\/$]* | ?:[\\/]* ) ;;
675
    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
676
   { (exit 1); exit 1; }; };;
677
  esac
678
done
679
 
680
# There might be people who depend on the old broken behavior: `$host'
681
# used to hold the argument of --host etc.
682
# FIXME: To remove some day.
683
build=$build_alias
684
host=$host_alias
685
target=$target_alias
686
 
687
# FIXME: To remove some day.
688
if test "x$host_alias" != x; then
689
  if test "x$build_alias" = x; then
690
    cross_compiling=maybe
691
    echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
692
    If a cross compiler is detected then cross compile mode will be used." >&2
693
  elif test "x$build_alias" != "x$host_alias"; then
694
    cross_compiling=yes
695
  fi
696
fi
697
 
698
ac_tool_prefix=
699
test -n "$host_alias" && ac_tool_prefix=$host_alias-
700
 
701
test "$silent" = yes && exec 6>/dev/null
702
 
703
 
704
# Find the source files, if location was not specified.
705
if test -z "$srcdir"; then
706
  ac_srcdir_defaulted=yes
707
  # Try the directory containing this script, then its parent.
708
  ac_confdir=`(dirname "$0") 2>/dev/null ||
709
$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
710
         X"$0" : 'X\(//\)[^/]' \| \
711
         X"$0" : 'X\(//\)$' \| \
712
         X"$0" : 'X\(/\)' \| \
713
         .     : '\(.\)' 2>/dev/null ||
714
echo X"$0" |
715
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
716
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
717
          /^X\(\/\/\)$/{ s//\1/; q; }
718
          /^X\(\/\).*/{ s//\1/; q; }
719
          s/.*/./; q'`
720
  srcdir=$ac_confdir
721
  if test ! -r $srcdir/$ac_unique_file; then
722
    srcdir=..
723
  fi
724
else
725
  ac_srcdir_defaulted=no
726
fi
727
if test ! -r $srcdir/$ac_unique_file; then
728
  if test "$ac_srcdir_defaulted" = yes; then
729
    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
730
   { (exit 1); exit 1; }; }
731
  else
732
    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
733
   { (exit 1); exit 1; }; }
734
  fi
735
fi
736
(cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
737
  { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
738
   { (exit 1); exit 1; }; }
739
srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
740
ac_env_build_alias_set=${build_alias+set}
741
ac_env_build_alias_value=$build_alias
742
ac_cv_env_build_alias_set=${build_alias+set}
743
ac_cv_env_build_alias_value=$build_alias
744
ac_env_host_alias_set=${host_alias+set}
745
ac_env_host_alias_value=$host_alias
746
ac_cv_env_host_alias_set=${host_alias+set}
747
ac_cv_env_host_alias_value=$host_alias
748
ac_env_target_alias_set=${target_alias+set}
749
ac_env_target_alias_value=$target_alias
750
ac_cv_env_target_alias_set=${target_alias+set}
751
ac_cv_env_target_alias_value=$target_alias
752
ac_env_FC_set=${FC+set}
753
ac_env_FC_value=$FC
754
ac_cv_env_FC_set=${FC+set}
755
ac_cv_env_FC_value=$FC
756
ac_env_FCFLAGS_set=${FCFLAGS+set}
757
ac_env_FCFLAGS_value=$FCFLAGS
758
ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
759
ac_cv_env_FCFLAGS_value=$FCFLAGS
760
ac_env_LDFLAGS_set=${LDFLAGS+set}
761
ac_env_LDFLAGS_value=$LDFLAGS
762
ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
763
ac_cv_env_LDFLAGS_value=$LDFLAGS
764
ac_env_CPP_set=${CPP+set}
765
ac_env_CPP_value=$CPP
766
ac_cv_env_CPP_set=${CPP+set}
767
ac_cv_env_CPP_value=$CPP
768
ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769
ac_env_CPPFLAGS_value=$CPPFLAGS
770
ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771
ac_cv_env_CPPFLAGS_value=$CPPFLAGS
772
 
773
#
774
# Report the --help message.
775
#
776
if test "$ac_init_help" = "long"; then
777
  # Omit some internal or obsolete options to make the list less imposing.
778
  # This message is too long to be a string in the A/UX 3.1 sh.
779
  cat <<_ACEOF
780
\`configure' configures GNU Fortran Runtime Library 0.2 to adapt to many kinds of systems.
781
 
782
Usage: $0 [OPTION]... [VAR=VALUE]...
783
 
784
To assign environment variables (e.g., CC, CFLAGS...), specify them as
785
VAR=VALUE.  See below for descriptions of some of the useful variables.
786
 
787
Defaults for the options are specified in brackets.
788
 
789
Configuration:
790
  -h, --help              display this help and exit
791
      --help=short        display options specific to this package
792
      --help=recursive    display the short help of all the included packages
793
  -V, --version           display version information and exit
794
  -q, --quiet, --silent   do not print \`checking...' messages
795
      --cache-file=FILE   cache test results in FILE [disabled]
796
  -C, --config-cache      alias for \`--cache-file=config.cache'
797
  -n, --no-create         do not create output files
798
      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
799
 
800
_ACEOF
801
 
802
  cat <<_ACEOF
803
Installation directories:
804
  --prefix=PREFIX         install architecture-independent files in PREFIX
805
                          [$ac_default_prefix]
806
  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
807
                          [PREFIX]
808
 
809
By default, \`make install' will install all the files in
810
\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
811
an installation prefix other than \`$ac_default_prefix' using \`--prefix',
812
for instance \`--prefix=\$HOME'.
813
 
814
For better control, use the options below.
815
 
816
Fine tuning of the installation directories:
817
  --bindir=DIR           user executables [EPREFIX/bin]
818
  --sbindir=DIR          system admin executables [EPREFIX/sbin]
819
  --libexecdir=DIR       program executables [EPREFIX/libexec]
820
  --datadir=DIR          read-only architecture-independent data [PREFIX/share]
821
  --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
822
  --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
823
  --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
824
  --libdir=DIR           object code libraries [EPREFIX/lib]
825
  --includedir=DIR       C header files [PREFIX/include]
826
  --oldincludedir=DIR    C header files for non-gcc [/usr/include]
827
  --infodir=DIR          info documentation [PREFIX/info]
828
  --mandir=DIR           man documentation [PREFIX/man]
829
_ACEOF
830
 
831
  cat <<\_ACEOF
832
 
833
Program names:
834
  --program-prefix=PREFIX            prepend PREFIX to installed program names
835
  --program-suffix=SUFFIX            append SUFFIX to installed program names
836
  --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
837
 
838
System types:
839
  --build=BUILD     configure for building on BUILD [guessed]
840
  --host=HOST       cross-compile to build programs to run on HOST [BUILD]
841
  --target=TARGET   configure for building compilers for TARGET [HOST]
842
_ACEOF
843
fi
844
 
845
if test -n "$ac_init_help"; then
846
  case $ac_init_help in
847
     short | recursive ) echo "Configuration of GNU Fortran Runtime Library 0.2:";;
848
   esac
849
  cat <<\_ACEOF
850
 
851
Optional Features:
852
  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
853
  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
854
  --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory
855
  --enable-maintainer-mode  enable make rules and dependencies not useful
856
                          (and sometimes confusing) to the casual installer
857
  --enable-multilib       build many library versions (default)
858
  --enable-shared=PKGS  build shared libraries default=yes
859
  --enable-static=PKGS  build static libraries default=yes
860
  --enable-fast-install=PKGS  optimize for fast installation default=yes
861
  --disable-libtool-lock  avoid locking (might break parallel builds)
862
  --disable-largefile     omit support for large files
863
 
864
Optional Packages:
865
  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
866
  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
867
  --with-gnu-ld           assume the C compiler uses GNU ld default=no
868
  --with-pic              try to use only PIC/non-PIC objects default=use both
869
 
870
Some influential environment variables:
871
  CC          C compiler command
872
  CFLAGS      C compiler flags
873
  LDFLAGS     linker flags, e.g. -L if you have libraries in a
874
              nonstandard directory 
875
  CPPFLAGS    C/C++ preprocessor flags, e.g. -I if you have
876
              headers in a nonstandard directory 
877
  FC          Fortran compiler command
878
  FCFLAGS     Fortran compiler flags
879
  CPP         C preprocessor
880
 
881
Use these variables to override the choices made by `configure' or to help
882
it to find libraries and programs with nonstandard names/locations.
883
 
884
_ACEOF
885
fi
886
 
887
if test "$ac_init_help" = "recursive"; then
888
  # If there are subdirs, report their specific --help.
889
  ac_popdir=`pwd`
890
  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
891
    test -d $ac_dir || continue
892
    ac_builddir=.
893
 
894
if test "$ac_dir" != .; then
895
  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
896
  # A "../" for each directory in $ac_dir_suffix.
897
  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
898
else
899
  ac_dir_suffix= ac_top_builddir=
900
fi
901
 
902
case $srcdir in
903
  .)  # No --srcdir option.  We are building in place.
904
    ac_srcdir=.
905
    if test -z "$ac_top_builddir"; then
906
       ac_top_srcdir=.
907
    else
908
       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
909
    fi ;;
910
  [\\/]* | ?:[\\/]* )  # Absolute path.
911
    ac_srcdir=$srcdir$ac_dir_suffix;
912
    ac_top_srcdir=$srcdir ;;
913
  *) # Relative path.
914
    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
915
    ac_top_srcdir=$ac_top_builddir$srcdir ;;
916
esac
917
 
918
# Do not use `cd foo && pwd` to compute absolute paths, because
919
# the directories may not exist.
920
case `pwd` in
921
.) ac_abs_builddir="$ac_dir";;
922
*)
923
  case "$ac_dir" in
924
  .) ac_abs_builddir=`pwd`;;
925
  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
926
  *) ac_abs_builddir=`pwd`/"$ac_dir";;
927
  esac;;
928
esac
929
case $ac_abs_builddir in
930
.) ac_abs_top_builddir=${ac_top_builddir}.;;
931
*)
932
  case ${ac_top_builddir}. in
933
  .) ac_abs_top_builddir=$ac_abs_builddir;;
934
  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
935
  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
936
  esac;;
937
esac
938
case $ac_abs_builddir in
939
.) ac_abs_srcdir=$ac_srcdir;;
940
*)
941
  case $ac_srcdir in
942
  .) ac_abs_srcdir=$ac_abs_builddir;;
943
  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
944
  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
945
  esac;;
946
esac
947
case $ac_abs_builddir in
948
.) ac_abs_top_srcdir=$ac_top_srcdir;;
949
*)
950
  case $ac_top_srcdir in
951
  .) ac_abs_top_srcdir=$ac_abs_builddir;;
952
  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
953
  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
954
  esac;;
955
esac
956
 
957
    cd $ac_dir
958
    # Check for guested configure; otherwise get Cygnus style configure.
959
    if test -f $ac_srcdir/configure.gnu; then
960
      echo
961
      $SHELL $ac_srcdir/configure.gnu  --help=recursive
962
    elif test -f $ac_srcdir/configure; then
963
      echo
964
      $SHELL $ac_srcdir/configure  --help=recursive
965
    elif test -f $ac_srcdir/configure.ac ||
966
           test -f $ac_srcdir/configure.in; then
967
      echo
968
      $ac_configure --help
969
    else
970
      echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
971
    fi
972
    cd $ac_popdir
973
  done
974
fi
975
 
976
test -n "$ac_init_help" && exit 0
977
if $ac_init_version; then
978
  cat <<\_ACEOF
979
GNU Fortran Runtime Library configure 0.2
980
generated by GNU Autoconf 2.59
981
 
982
Copyright (C) 2003 Free Software Foundation, Inc.
983
This configure script is free software; the Free Software Foundation
984
gives unlimited permission to copy, distribute and modify it.
985
_ACEOF
986
  exit 0
987
fi
988
exec 5>config.log
989
cat >&5 <<_ACEOF
990
This file contains any messages produced by compilers while
991
running configure, to aid debugging if configure makes a mistake.
992
 
993
It was created by GNU Fortran Runtime Library $as_me 0.2, which was
994
generated by GNU Autoconf 2.59.  Invocation command line was
995
 
996
  $ $0 $@
997
 
998
_ACEOF
999
{
1000
cat <<_ASUNAME
1001
## --------- ##
1002
## Platform. ##
1003
## --------- ##
1004
 
1005
hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1006
uname -m = `(uname -m) 2>/dev/null || echo unknown`
1007
uname -r = `(uname -r) 2>/dev/null || echo unknown`
1008
uname -s = `(uname -s) 2>/dev/null || echo unknown`
1009
uname -v = `(uname -v) 2>/dev/null || echo unknown`
1010
 
1011
/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1012
/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1013
 
1014
/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1015
/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1016
/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1017
hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1018
/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1019
/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1020
/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1021
 
1022
_ASUNAME
1023
 
1024
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1025
for as_dir in $PATH
1026
do
1027
  IFS=$as_save_IFS
1028
  test -z "$as_dir" && as_dir=.
1029
  echo "PATH: $as_dir"
1030
done
1031
 
1032
} >&5
1033
 
1034
cat >&5 <<_ACEOF
1035
 
1036
 
1037
## ----------- ##
1038
## Core tests. ##
1039
## ----------- ##
1040
 
1041
_ACEOF
1042
 
1043
 
1044
# Keep a trace of the command line.
1045
# Strip out --no-create and --no-recursion so they do not pile up.
1046
# Strip out --silent because we don't want to record it for future runs.
1047
# Also quote any args containing shell meta-characters.
1048
# Make two passes to allow for proper duplicate-argument suppression.
1049
ac_configure_args=
1050
ac_configure_args0=
1051
ac_configure_args1=
1052
ac_sep=
1053
ac_must_keep_next=false
1054
for ac_pass in 1 2
1055
do
1056
  for ac_arg
1057
  do
1058
    case $ac_arg in
1059
    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1060
    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1061
    | -silent | --silent | --silen | --sile | --sil)
1062
      continue ;;
1063
    *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1064
      ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1065
    esac
1066
    case $ac_pass in
1067
    1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1068
    2)
1069
      ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1070
      if test $ac_must_keep_next = true; then
1071
        ac_must_keep_next=false # Got value, back to normal.
1072
      else
1073
        case $ac_arg in
1074
          *=* | --config-cache | -C | -disable-* | --disable-* \
1075
          | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1076
          | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1077
          | -with-* | --with-* | -without-* | --without-* | --x)
1078
            case "$ac_configure_args0 " in
1079
              "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1080
            esac
1081
            ;;
1082
          -* ) ac_must_keep_next=true ;;
1083
        esac
1084
      fi
1085
      ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1086
      # Get rid of the leading space.
1087
      ac_sep=" "
1088
      ;;
1089
    esac
1090
  done
1091
done
1092
$as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1093
$as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1094
 
1095
# When interrupted or exit'd, cleanup temporary files, and complete
1096
# config.log.  We remove comments because anyway the quotes in there
1097
# would cause problems or look ugly.
1098
# WARNING: Be sure not to use single quotes in there, as some shells,
1099
# such as our DU 5.0 friend, will then `close' the trap.
1100
trap 'exit_status=$?
1101
  # Save into config.log some information that might help in debugging.
1102
  {
1103
    echo
1104
 
1105
    cat <<\_ASBOX
1106
## ---------------- ##
1107
## Cache variables. ##
1108
## ---------------- ##
1109
_ASBOX
1110
    echo
1111
    # The following way of writing the cache mishandles newlines in values,
1112
{
1113
  (set) 2>&1 |
1114
    case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1115
    *ac_space=\ *)
1116
      sed -n \
1117
        "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1118
          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1119
      ;;
1120
    *)
1121
      sed -n \
1122
        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1123
      ;;
1124
    esac;
1125
}
1126
    echo
1127
 
1128
    cat <<\_ASBOX
1129
## ----------------- ##
1130
## Output variables. ##
1131
## ----------------- ##
1132
_ASBOX
1133
    echo
1134
    for ac_var in $ac_subst_vars
1135
    do
1136
      eval ac_val=$`echo $ac_var`
1137
      echo "$ac_var='"'"'$ac_val'"'"'"
1138
    done | sort
1139
    echo
1140
 
1141
    if test -n "$ac_subst_files"; then
1142
      cat <<\_ASBOX
1143
## ------------- ##
1144
## Output files. ##
1145
## ------------- ##
1146
_ASBOX
1147
      echo
1148
      for ac_var in $ac_subst_files
1149
      do
1150
        eval ac_val=$`echo $ac_var`
1151
        echo "$ac_var='"'"'$ac_val'"'"'"
1152
      done | sort
1153
      echo
1154
    fi
1155
 
1156
    if test -s confdefs.h; then
1157
      cat <<\_ASBOX
1158
## ----------- ##
1159
## confdefs.h. ##
1160
## ----------- ##
1161
_ASBOX
1162
      echo
1163
      sed "/^$/d" confdefs.h | sort
1164
      echo
1165
    fi
1166
    test "$ac_signal" != 0 &&
1167
      echo "$as_me: caught signal $ac_signal"
1168
    echo "$as_me: exit $exit_status"
1169
  } >&5
1170
  rm -f core *.core &&
1171
  rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1172
    exit $exit_status
1173
     ' 0
1174
for ac_signal in 1 2 13 15; do
1175
  trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1176
done
1177
ac_signal=0
1178
 
1179
# confdefs.h avoids OS command line length limits that DEFS can exceed.
1180
rm -rf conftest* confdefs.h
1181
# AIX cpp loses on an empty file, so make sure it contains at least a newline.
1182
echo >confdefs.h
1183
 
1184
# Predefined preprocessor variables.
1185
 
1186
cat >>confdefs.h <<_ACEOF
1187
#define PACKAGE_NAME "$PACKAGE_NAME"
1188
_ACEOF
1189
 
1190
 
1191
cat >>confdefs.h <<_ACEOF
1192
#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1193
_ACEOF
1194
 
1195
 
1196
cat >>confdefs.h <<_ACEOF
1197
#define PACKAGE_VERSION "$PACKAGE_VERSION"
1198
_ACEOF
1199
 
1200
 
1201
cat >>confdefs.h <<_ACEOF
1202
#define PACKAGE_STRING "$PACKAGE_STRING"
1203
_ACEOF
1204
 
1205
 
1206
cat >>confdefs.h <<_ACEOF
1207
#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1208
_ACEOF
1209
 
1210
 
1211
# Let the site file select an alternate cache file if it wants to.
1212
# Prefer explicitly selected file to automatically selected ones.
1213
if test -z "$CONFIG_SITE"; then
1214
  if test "x$prefix" != xNONE; then
1215
    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1216
  else
1217
    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1218
  fi
1219
fi
1220
for ac_site_file in $CONFIG_SITE; do
1221
  if test -r "$ac_site_file"; then
1222
    { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1223
echo "$as_me: loading site script $ac_site_file" >&6;}
1224
    sed 's/^/| /' "$ac_site_file" >&5
1225
    . "$ac_site_file"
1226
  fi
1227
done
1228
 
1229
if test -r "$cache_file"; then
1230
  # Some versions of bash will fail to source /dev/null (special
1231
  # files actually), so we avoid doing that.
1232
  if test -f "$cache_file"; then
1233
    { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1234
echo "$as_me: loading cache $cache_file" >&6;}
1235
    case $cache_file in
1236
      [\\/]* | ?:[\\/]* ) . $cache_file;;
1237
      *)                      . ./$cache_file;;
1238
    esac
1239
  fi
1240
else
1241
  { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1242
echo "$as_me: creating cache $cache_file" >&6;}
1243
  >$cache_file
1244
fi
1245
 
1246
# Check that the precious variables saved in the cache have kept the same
1247
# value.
1248
ac_cache_corrupted=false
1249
for ac_var in `(set) 2>&1 |
1250
               sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1251
  eval ac_old_set=\$ac_cv_env_${ac_var}_set
1252
  eval ac_new_set=\$ac_env_${ac_var}_set
1253
  eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1254
  eval ac_new_val="\$ac_env_${ac_var}_value"
1255
  case $ac_old_set,$ac_new_set in
1256
    set,)
1257
      { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1258
echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1259
      ac_cache_corrupted=: ;;
1260
    ,set)
1261
      { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1262
echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1263
      ac_cache_corrupted=: ;;
1264
    ,);;
1265
    *)
1266
      if test "x$ac_old_val" != "x$ac_new_val"; then
1267
        { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1268
echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1269
        { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1270
echo "$as_me:   former value:  $ac_old_val" >&2;}
1271
        { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1272
echo "$as_me:   current value: $ac_new_val" >&2;}
1273
        ac_cache_corrupted=:
1274
      fi;;
1275
  esac
1276
  # Pass precious variables to config.status.
1277
  if test "$ac_new_set" = set; then
1278
    case $ac_new_val in
1279
    *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1280
      ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1281
    *) ac_arg=$ac_var=$ac_new_val ;;
1282
    esac
1283
    case " $ac_configure_args " in
1284
      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1285
      *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1286
    esac
1287
  fi
1288
done
1289
if $ac_cache_corrupted; then
1290
  { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1291
echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1292
  { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1293
echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1294
   { (exit 1); exit 1; }; }
1295
fi
1296
 
1297
ac_ext=c
1298
ac_cpp='$CPP $CPPFLAGS'
1299
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1300
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1301
ac_compiler_gnu=$ac_cv_c_compiler_gnu
1302
 
1303
 
1304
 
1305
 
1306
 
1307
 
1308
 
1309
 
1310
 
1311
 
1312
 
1313
 
1314
 
1315
 
1316
 
1317
 
1318
 
1319
 
1320
 
1321
 
1322
 
1323
 
1324
 
1325
 
1326
 
1327
 
1328
 
1329
          ac_config_headers="$ac_config_headers config.h"
1330
 
1331
ac_aux_dir=
1332
for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1333
  if test -f $ac_dir/install-sh; then
1334
    ac_aux_dir=$ac_dir
1335
    ac_install_sh="$ac_aux_dir/install-sh -c"
1336
    break
1337
  elif test -f $ac_dir/install.sh; then
1338
    ac_aux_dir=$ac_dir
1339
    ac_install_sh="$ac_aux_dir/install.sh -c"
1340
    break
1341
  elif test -f $ac_dir/shtool; then
1342
    ac_aux_dir=$ac_dir
1343
    ac_install_sh="$ac_aux_dir/shtool install -c"
1344
    break
1345
  fi
1346
done
1347
if test -z "$ac_aux_dir"; then
1348
  { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1349
echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1350
   { (exit 1); exit 1; }; }
1351
fi
1352
ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1353
ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1354
ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1355
 
1356
# Make sure we can run config.sub.
1357
$ac_config_sub sun4 >/dev/null 2>&1 ||
1358
  { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1359
echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1360
   { (exit 1); exit 1; }; }
1361
 
1362
echo "$as_me:$LINENO: checking build system type" >&5
1363
echo $ECHO_N "checking build system type... $ECHO_C" >&6
1364
if test "${ac_cv_build+set}" = set; then
1365
  echo $ECHO_N "(cached) $ECHO_C" >&6
1366
else
1367
  ac_cv_build_alias=$build_alias
1368
test -z "$ac_cv_build_alias" &&
1369
  ac_cv_build_alias=`$ac_config_guess`
1370
test -z "$ac_cv_build_alias" &&
1371
  { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1372
echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1373
   { (exit 1); exit 1; }; }
1374
ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1375
  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1376
echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1377
   { (exit 1); exit 1; }; }
1378
 
1379
fi
1380
echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1381
echo "${ECHO_T}$ac_cv_build" >&6
1382
build=$ac_cv_build
1383
build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1384
build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1385
build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1386
 
1387
 
1388
 case ${build_alias} in
1389
  "") build_noncanonical=${build} ;;
1390
  *) build_noncanonical=${build_alias} ;;
1391
esac
1392
 
1393
 case ${host_alias} in
1394
  "") host_noncanonical=${build_noncanonical} ;;
1395
  *) host_noncanonical=${host_alias} ;;
1396
esac
1397
 
1398
 case ${target_alias} in
1399
  "") target_noncanonical=${host_noncanonical} ;;
1400
  *) target_noncanonical=${target_alias} ;;
1401
esac
1402
 
1403
  # Prefix 'build-' so this never conflicts with target_subdir.
1404
build_subdir="build-${build_noncanonical}"
1405
# --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1406
if ( test $srcdir = . && test -d gcc ) \
1407
   || test -d $srcdir/../host-${host_noncanonical}; then
1408
  host_subdir="host-${host_noncanonical}"
1409
else
1410
  host_subdir=.
1411
fi
1412
# No prefix.
1413
target_subdir=${target_noncanonical}
1414
 
1415
 
1416
# -------
1417
# Options
1418
# -------
1419
 
1420
echo "$as_me:$LINENO: checking for --enable-version-specific-runtime-libs" >&5
1421
echo $ECHO_N "checking for --enable-version-specific-runtime-libs... $ECHO_C" >&6
1422
# Check whether --enable-version-specific-runtime-libs or --disable-version-specific-runtime-libs was given.
1423
if test "${enable_version_specific_runtime_libs+set}" = set; then
1424
  enableval="$enable_version_specific_runtime_libs"
1425
  case "$enableval" in
1426
 yes) version_specific_libs=yes ;;
1427
 no)  version_specific_libs=no ;;
1428
 *)   { { echo "$as_me:$LINENO: error: Unknown argument to enable/disable version-specific libs" >&5
1429
echo "$as_me: error: Unknown argument to enable/disable version-specific libs" >&2;}
1430
   { (exit 1); exit 1; }; };;
1431
 esac
1432
else
1433
  version_specific_libs=no
1434
fi;
1435
echo "$as_me:$LINENO: result: $version_specific_libs" >&5
1436
echo "${ECHO_T}$version_specific_libs" >&6
1437
 
1438
 
1439
# Gets build, host, target, *_vendor, *_cpu, *_os, etc.
1440
#
1441
# You will slowly go insane if you do not grok the following fact:  when
1442
# building this library, the top-level /target/ becomes the library's /host/.
1443
#
1444
# configure then causes --target to default to --host, exactly like any
1445
# other package using autoconf.  Therefore, 'target' and 'host' will
1446
# always be the same.  This makes sense both for native and cross compilers
1447
# just think about it for a little while.  :-)
1448
#
1449
# Also, if this library is being configured as part of a cross compiler, the
1450
# top-level configure script will pass the "real" host as $with_cross_host.
1451
#
1452
# Do not delete or change the following two lines.  For why, see
1453
# http://gcc.gnu.org/ml/libstdc++/2003-07/msg00451.html
1454
echo "$as_me:$LINENO: checking host system type" >&5
1455
echo $ECHO_N "checking host system type... $ECHO_C" >&6
1456
if test "${ac_cv_host+set}" = set; then
1457
  echo $ECHO_N "(cached) $ECHO_C" >&6
1458
else
1459
  ac_cv_host_alias=$host_alias
1460
test -z "$ac_cv_host_alias" &&
1461
  ac_cv_host_alias=$ac_cv_build_alias
1462
ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1463
  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1464
echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1465
   { (exit 1); exit 1; }; }
1466
 
1467
fi
1468
echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1469
echo "${ECHO_T}$ac_cv_host" >&6
1470
host=$ac_cv_host
1471
host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1472
host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1473
host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1474
 
1475
 
1476
echo "$as_me:$LINENO: checking target system type" >&5
1477
echo $ECHO_N "checking target system type... $ECHO_C" >&6
1478
if test "${ac_cv_target+set}" = set; then
1479
  echo $ECHO_N "(cached) $ECHO_C" >&6
1480
else
1481
  ac_cv_target_alias=$target_alias
1482
test "x$ac_cv_target_alias" = "x" &&
1483
  ac_cv_target_alias=$ac_cv_host_alias
1484
ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1485
  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1486
echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1487
   { (exit 1); exit 1; }; }
1488
 
1489
fi
1490
echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1491
echo "${ECHO_T}$ac_cv_target" >&6
1492
target=$ac_cv_target
1493
target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1494
target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1495
target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1496
 
1497
 
1498
# The aliases save the names the user supplied, while $host etc.
1499
# will get canonicalized.
1500
test -n "$target_alias" &&
1501
  test "$program_prefix$program_suffix$program_transform_name" = \
1502
    NONENONEs,x,x, &&
1503
  program_prefix=${target_alias}-
1504
target_alias=${target_alias-$host_alias}
1505
 
1506
# Sets up automake.  Must come after AC_CANONICAL_SYSTEM.  Each of the
1507
# following is magically included in AUTOMAKE_OPTIONS in each Makefile.am.
1508
#  1.8.2:  minimum required version
1509
#  no-define:  PACKAGE and VERSION will not be #define'd in config.h (a bunch
1510
#              of other PACKAGE_* variables will, however, and there's nothing
1511
#              we can do about that; they come from AC_INIT).
1512
#  foreign:  we don't follow the normal rules for GNU packages (no COPYING
1513
#            file in the top srcdir, etc, etc), so stop complaining.
1514
#  no-dependencies:  turns off auto dependency generation (just for now)
1515
#  -Wall:  turns on all automake warnings...
1516
#  -Wno-portability:  ...except this one, since GNU make is required.
1517
am__api_version="1.9"
1518
# Find a good install program.  We prefer a C program (faster),
1519
# so one script is as good as another.  But avoid the broken or
1520
# incompatible versions:
1521
# SysV /etc/install, /usr/sbin/install
1522
# SunOS /usr/etc/install
1523
# IRIX /sbin/install
1524
# AIX /bin/install
1525
# AmigaOS /C/install, which installs bootblocks on floppy discs
1526
# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1527
# AFS /usr/afsws/bin/install, which mishandles nonexistent args
1528
# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1529
# OS/2's system install, which has a completely different semantic
1530
# ./install, which can be erroneously created by make from ./install.sh.
1531
echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1532
echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1533
if test -z "$INSTALL"; then
1534
if test "${ac_cv_path_install+set}" = set; then
1535
  echo $ECHO_N "(cached) $ECHO_C" >&6
1536
else
1537
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1538
for as_dir in $PATH
1539
do
1540
  IFS=$as_save_IFS
1541
  test -z "$as_dir" && as_dir=.
1542
  # Account for people who put trailing slashes in PATH elements.
1543
case $as_dir/ in
1544
  ./ | .// | /cC/* | \
1545
  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1546
  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1547
  /usr/ucb/* ) ;;
1548
  *)
1549
    # OSF1 and SCO ODT 3.0 have their own names for install.
1550
    # Don't use installbsd from OSF since it installs stuff as root
1551
    # by default.
1552
    for ac_prog in ginstall scoinst install; do
1553
      for ac_exec_ext in '' $ac_executable_extensions; do
1554
        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1555
          if test $ac_prog = install &&
1556
            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1557
            # AIX install.  It has an incompatible calling convention.
1558
            :
1559
          elif test $ac_prog = install &&
1560
            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1561
            # program-specific install script used by HP pwplus--don't use.
1562
            :
1563
          else
1564
            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1565
            break 3
1566
          fi
1567
        fi
1568
      done
1569
    done
1570
    ;;
1571
esac
1572
done
1573
 
1574
 
1575
fi
1576
  if test "${ac_cv_path_install+set}" = set; then
1577
    INSTALL=$ac_cv_path_install
1578
  else
1579
    # As a last resort, use the slow shell script.  We don't cache a
1580
    # path for INSTALL within a source directory, because that will
1581
    # break other packages using the cache if that directory is
1582
    # removed, or if the path is relative.
1583
    INSTALL=$ac_install_sh
1584
  fi
1585
fi
1586
echo "$as_me:$LINENO: result: $INSTALL" >&5
1587
echo "${ECHO_T}$INSTALL" >&6
1588
 
1589
# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1590
# It thinks the first close brace ends the variable substitution.
1591
test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1592
 
1593
test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1594
 
1595
test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1596
 
1597
echo "$as_me:$LINENO: checking whether build environment is sane" >&5
1598
echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6
1599
# Just in case
1600
sleep 1
1601
echo timestamp > conftest.file
1602
# Do `set' in a subshell so we don't clobber the current shell's
1603
# arguments.  Must try -L first in case configure is actually a
1604
# symlink; some systems play weird games with the mod time of symlinks
1605
# (eg FreeBSD returns the mod time of the symlink's containing
1606
# directory).
1607
if (
1608
   set X `ls -Lt $srcdir/configure conftest.file 2> /dev/null`
1609
   if test "$*" = "X"; then
1610
      # -L didn't work.
1611
      set X `ls -t $srcdir/configure conftest.file`
1612
   fi
1613
   rm -f conftest.file
1614
   if test "$*" != "X $srcdir/configure conftest.file" \
1615
      && test "$*" != "X conftest.file $srcdir/configure"; then
1616
 
1617
      # If neither matched, then we have a broken ls.  This can happen
1618
      # if, for instance, CONFIG_SHELL is bash and it inherits a
1619
      # broken ls alias from the environment.  This has actually
1620
      # happened.  Such a system could not be considered "sane".
1621
      { { echo "$as_me:$LINENO: error: ls -t appears to fail.  Make sure there is not a broken
1622
alias in your environment" >&5
1623
echo "$as_me: error: ls -t appears to fail.  Make sure there is not a broken
1624
alias in your environment" >&2;}
1625
   { (exit 1); exit 1; }; }
1626
   fi
1627
 
1628
   test "$2" = conftest.file
1629
   )
1630
then
1631
   # Ok.
1632
   :
1633
else
1634
   { { echo "$as_me:$LINENO: error: newly created file is older than distributed files!
1635
Check your system clock" >&5
1636
echo "$as_me: error: newly created file is older than distributed files!
1637
Check your system clock" >&2;}
1638
   { (exit 1); exit 1; }; }
1639
fi
1640
echo "$as_me:$LINENO: result: yes" >&5
1641
echo "${ECHO_T}yes" >&6
1642
test "$program_prefix" != NONE &&
1643
  program_transform_name="s,^,$program_prefix,;$program_transform_name"
1644
# Use a double $ so make ignores it.
1645
test "$program_suffix" != NONE &&
1646
  program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1647
# Double any \ or $.  echo might interpret backslashes.
1648
# By default was `s,x,x', remove it if useless.
1649
cat <<\_ACEOF >conftest.sed
1650
s/[\\$]/&&/g;s/;s,x,x,$//
1651
_ACEOF
1652
program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1653
rm conftest.sed
1654
 
1655
# expand $ac_aux_dir to an absolute path
1656
am_aux_dir=`cd $ac_aux_dir && pwd`
1657
 
1658
test x"${MISSING+set}" = xset || MISSING="\${SHELL} $am_aux_dir/missing"
1659
# Use eval to expand $SHELL
1660
if eval "$MISSING --run true"; then
1661
  am_missing_run="$MISSING --run "
1662
else
1663
  am_missing_run=
1664
  { echo "$as_me:$LINENO: WARNING: \`missing' script is too old or missing" >&5
1665
echo "$as_me: WARNING: \`missing' script is too old or missing" >&2;}
1666
fi
1667
 
1668
if mkdir -p --version . >/dev/null 2>&1 && test ! -d ./--version; then
1669
  # We used to keeping the `.' as first argument, in order to
1670
  # allow $(mkdir_p) to be used without argument.  As in
1671
  #   $(mkdir_p) $(somedir)
1672
  # where $(somedir) is conditionally defined.  However this is wrong
1673
  # for two reasons:
1674
  #  1. if the package is installed by a user who cannot write `.'
1675
  #     make install will fail,
1676
  #  2. the above comment should most certainly read
1677
  #     $(mkdir_p) $(DESTDIR)$(somedir)
1678
  #     so it does not work when $(somedir) is undefined and
1679
  #     $(DESTDIR) is not.
1680
  #  To support the latter case, we have to write
1681
  #     test -z "$(somedir)" || $(mkdir_p) $(DESTDIR)$(somedir),
1682
  #  so the `.' trick is pointless.
1683
  mkdir_p='mkdir -p --'
1684
else
1685
  # On NextStep and OpenStep, the `mkdir' command does not
1686
  # recognize any option.  It will interpret all options as
1687
  # directories to create, and then abort because `.' already
1688
  # exists.
1689
  for d in ./-p ./--version;
1690
  do
1691
    test -d $d && rmdir $d
1692
  done
1693
  # $(mkinstalldirs) is defined by Automake if mkinstalldirs exists.
1694
  if test -f "$ac_aux_dir/mkinstalldirs"; then
1695
    mkdir_p='$(mkinstalldirs)'
1696
  else
1697
    mkdir_p='$(install_sh) -d'
1698
  fi
1699
fi
1700
 
1701
for ac_prog in gawk mawk nawk awk
1702
do
1703
  # Extract the first word of "$ac_prog", so it can be a program name with args.
1704
set dummy $ac_prog; ac_word=$2
1705
echo "$as_me:$LINENO: checking for $ac_word" >&5
1706
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1707
if test "${ac_cv_prog_AWK+set}" = set; then
1708
  echo $ECHO_N "(cached) $ECHO_C" >&6
1709
else
1710
  if test -n "$AWK"; then
1711
  ac_cv_prog_AWK="$AWK" # Let the user override the test.
1712
else
1713
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1714
for as_dir in $PATH
1715
do
1716
  IFS=$as_save_IFS
1717
  test -z "$as_dir" && as_dir=.
1718
  for ac_exec_ext in '' $ac_executable_extensions; do
1719
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1720
    ac_cv_prog_AWK="$ac_prog"
1721
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1722
    break 2
1723
  fi
1724
done
1725
done
1726
 
1727
fi
1728
fi
1729
AWK=$ac_cv_prog_AWK
1730
if test -n "$AWK"; then
1731
  echo "$as_me:$LINENO: result: $AWK" >&5
1732
echo "${ECHO_T}$AWK" >&6
1733
else
1734
  echo "$as_me:$LINENO: result: no" >&5
1735
echo "${ECHO_T}no" >&6
1736
fi
1737
 
1738
  test -n "$AWK" && break
1739
done
1740
 
1741
echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
1742
echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
1743
set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
1744
if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
1745
  echo $ECHO_N "(cached) $ECHO_C" >&6
1746
else
1747
  cat >conftest.make <<\_ACEOF
1748
all:
1749
        @echo 'ac_maketemp="$(MAKE)"'
1750
_ACEOF
1751
# GNU make sometimes prints "make[1]: Entering...", which would confuse us.
1752
eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
1753
if test -n "$ac_maketemp"; then
1754
  eval ac_cv_prog_make_${ac_make}_set=yes
1755
else
1756
  eval ac_cv_prog_make_${ac_make}_set=no
1757
fi
1758
rm -f conftest.make
1759
fi
1760
if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
1761
  echo "$as_me:$LINENO: result: yes" >&5
1762
echo "${ECHO_T}yes" >&6
1763
  SET_MAKE=
1764
else
1765
  echo "$as_me:$LINENO: result: no" >&5
1766
echo "${ECHO_T}no" >&6
1767
  SET_MAKE="MAKE=${MAKE-make}"
1768
fi
1769
 
1770
rm -rf .tst 2>/dev/null
1771
mkdir .tst 2>/dev/null
1772
if test -d .tst; then
1773
  am__leading_dot=.
1774
else
1775
  am__leading_dot=_
1776
fi
1777
rmdir .tst 2>/dev/null
1778
 
1779
# test to see if srcdir already configured
1780
if test "`cd $srcdir && pwd`" != "`pwd`" &&
1781
   test -f $srcdir/config.status; then
1782
  { { echo "$as_me:$LINENO: error: source directory already configured; run \"make distclean\" there first" >&5
1783
echo "$as_me: error: source directory already configured; run \"make distclean\" there first" >&2;}
1784
   { (exit 1); exit 1; }; }
1785
fi
1786
 
1787
# test whether we have cygpath
1788
if test -z "$CYGPATH_W"; then
1789
  if (cygpath --version) >/dev/null 2>/dev/null; then
1790
    CYGPATH_W='cygpath -w'
1791
  else
1792
    CYGPATH_W=echo
1793
  fi
1794
fi
1795
 
1796
 
1797
# Define the identity of the package.
1798
 PACKAGE='libgfortran'
1799
 VERSION='0.2'
1800
 
1801
 
1802
# Some tools Automake needs.
1803
 
1804
ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}
1805
 
1806
 
1807
AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}
1808
 
1809
 
1810
AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}
1811
 
1812
 
1813
AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}
1814
 
1815
 
1816
MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
1817
 
1818
install_sh=${install_sh-"$am_aux_dir/install-sh"}
1819
 
1820
# Installed binaries are usually stripped using `strip' when the user
1821
# run `make install-strip'.  However `strip' might not be the right
1822
# tool to use in cross-compilation environments, therefore Automake
1823
# will honor the `STRIP' environment variable to overrule this program.
1824
if test "$cross_compiling" != no; then
1825
  if test -n "$ac_tool_prefix"; then
1826
  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
1827
set dummy ${ac_tool_prefix}strip; ac_word=$2
1828
echo "$as_me:$LINENO: checking for $ac_word" >&5
1829
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1830
if test "${ac_cv_prog_STRIP+set}" = set; then
1831
  echo $ECHO_N "(cached) $ECHO_C" >&6
1832
else
1833
  if test -n "$STRIP"; then
1834
  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
1835
else
1836
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1837
for as_dir in $PATH
1838
do
1839
  IFS=$as_save_IFS
1840
  test -z "$as_dir" && as_dir=.
1841
  for ac_exec_ext in '' $ac_executable_extensions; do
1842
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1843
    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
1844
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1845
    break 2
1846
  fi
1847
done
1848
done
1849
 
1850
fi
1851
fi
1852
STRIP=$ac_cv_prog_STRIP
1853
if test -n "$STRIP"; then
1854
  echo "$as_me:$LINENO: result: $STRIP" >&5
1855
echo "${ECHO_T}$STRIP" >&6
1856
else
1857
  echo "$as_me:$LINENO: result: no" >&5
1858
echo "${ECHO_T}no" >&6
1859
fi
1860
 
1861
fi
1862
if test -z "$ac_cv_prog_STRIP"; then
1863
  ac_ct_STRIP=$STRIP
1864
  # Extract the first word of "strip", so it can be a program name with args.
1865
set dummy strip; ac_word=$2
1866
echo "$as_me:$LINENO: checking for $ac_word" >&5
1867
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1868
if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
1869
  echo $ECHO_N "(cached) $ECHO_C" >&6
1870
else
1871
  if test -n "$ac_ct_STRIP"; then
1872
  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
1873
else
1874
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1875
for as_dir in $PATH
1876
do
1877
  IFS=$as_save_IFS
1878
  test -z "$as_dir" && as_dir=.
1879
  for ac_exec_ext in '' $ac_executable_extensions; do
1880
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1881
    ac_cv_prog_ac_ct_STRIP="strip"
1882
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1883
    break 2
1884
  fi
1885
done
1886
done
1887
 
1888
  test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
1889
fi
1890
fi
1891
ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
1892
if test -n "$ac_ct_STRIP"; then
1893
  echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
1894
echo "${ECHO_T}$ac_ct_STRIP" >&6
1895
else
1896
  echo "$as_me:$LINENO: result: no" >&5
1897
echo "${ECHO_T}no" >&6
1898
fi
1899
 
1900
  STRIP=$ac_ct_STRIP
1901
else
1902
  STRIP="$ac_cv_prog_STRIP"
1903
fi
1904
 
1905
fi
1906
INSTALL_STRIP_PROGRAM="\${SHELL} \$(install_sh) -c -s"
1907
 
1908
# We need awk for the "check" target.  The system "awk" is bad on
1909
# some platforms.
1910
# Always define AMTAR for backward compatibility.
1911
 
1912
AMTAR=${AMTAR-"${am_missing_run}tar"}
1913
 
1914
am__tar='${AMTAR} chof - "$$tardir"'; am__untar='${AMTAR} xf -'
1915
 
1916
 
1917
 
1918
 
1919
 
1920
 
1921
echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
1922
echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
1923
    # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
1924
if test "${enable_maintainer_mode+set}" = set; then
1925
  enableval="$enable_maintainer_mode"
1926
  USE_MAINTAINER_MODE=$enableval
1927
else
1928
  USE_MAINTAINER_MODE=no
1929
fi;
1930
  echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
1931
echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
1932
 
1933
 
1934
if test $USE_MAINTAINER_MODE = yes; then
1935
  MAINTAINER_MODE_TRUE=
1936
  MAINTAINER_MODE_FALSE='#'
1937
else
1938
  MAINTAINER_MODE_TRUE='#'
1939
  MAINTAINER_MODE_FALSE=
1940
fi
1941
 
1942
  MAINT=$MAINTAINER_MODE_TRUE
1943
 
1944
 
1945
# Default to --enable-multilib
1946
# Check whether --enable-multilib or --disable-multilib was given.
1947
if test "${enable_multilib+set}" = set; then
1948
  enableval="$enable_multilib"
1949
  case "$enableval" in
1950
  yes) multilib=yes ;;
1951
  no)  multilib=no ;;
1952
  *)   { { echo "$as_me:$LINENO: error: bad value $enableval for multilib option" >&5
1953
echo "$as_me: error: bad value $enableval for multilib option" >&2;}
1954
   { (exit 1); exit 1; }; } ;;
1955
 esac
1956
else
1957
  multilib=yes
1958
fi;
1959
 
1960
# We may get other options which we leave undocumented:
1961
# --with-target-subdir, --with-multisrctop, --with-multisubdir
1962
# See config-ml.in if you want the gory details.
1963
 
1964
if test "$srcdir" = "."; then
1965
  if test "$with_target_subdir" != "."; then
1966
    multi_basedir="$srcdir/$with_multisrctop../.."
1967
  else
1968
    multi_basedir="$srcdir/$with_multisrctop.."
1969
  fi
1970
else
1971
  multi_basedir="$srcdir/.."
1972
fi
1973
 
1974
 
1975
          ac_config_commands="$ac_config_commands default-1"
1976
 
1977
 
1978
# Handy for debugging:
1979
#AC_MSG_NOTICE($build / $host / $target / $host_alias / $target_alias); sleep 5
1980
 
1981
# Are we being configured with some form of cross compiler?
1982
# NB: We don't actually need to know this just now, but when, say, a test
1983
#     suite is included, we'll have to know.
1984
if test "$build" != "$host"; then
1985
  LIBGFOR_IS_NATIVE=false
1986
 
1987
else
1988
  LIBGFOR_IS_NATIVE=true
1989
fi
1990
 
1991
# Calculate toolexeclibdir
1992
# Also toolexecdir, though it's only used in toolexeclibdir
1993
case ${version_specific_libs} in
1994
  yes)
1995
    # Need the gcc compiler version to know where to install libraries
1996
    # and header files if --enable-version-specific-runtime-libs option
1997
    # is selected.
1998
    toolexecdir='$(libdir)/gcc/$(target_alias)'
1999
    toolexeclibdir='$(toolexecdir)/$(gcc_version)$(MULTISUBDIR)'
2000
    ;;
2001
  no)
2002
    if test -n "$with_cross_host" &&
2003
       test x"$with_cross_host" != x"no"; then
2004
      # Install a library built with a cross compiler in tooldir, not libdir.
2005
      toolexecdir='$(exec_prefix)/$(target_alias)'
2006
      toolexeclibdir='$(toolexecdir)/lib'
2007
    else
2008
      toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
2009
      toolexeclibdir='$(libdir)'
2010
    fi
2011
    multi_os_directory=`$CC -print-multi-os-directory`
2012
    case $multi_os_directory in
2013
      .) ;; # Avoid trailing /.
2014
      *) toolexeclibdir=$toolexeclibdir/$multi_os_directory ;;
2015
    esac
2016
    ;;
2017
esac
2018
 
2019
 
2020
 
2021
# Check the compiler.
2022
# The same as in boehm-gc and libstdc++. Have to borrow it from there.
2023
# We must force CC to /not/ be precious variables; otherwise
2024
# the wrong, non-multilib-adjusted value will be used in multilibs.
2025
# As a side effect, we have to subst CFLAGS ourselves.
2026
 
2027
 
2028
 
2029
ac_ext=c
2030
ac_cpp='$CPP $CPPFLAGS'
2031
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2032
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2033
ac_compiler_gnu=$ac_cv_c_compiler_gnu
2034
if test -n "$ac_tool_prefix"; then
2035
  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2036
set dummy ${ac_tool_prefix}gcc; ac_word=$2
2037
echo "$as_me:$LINENO: checking for $ac_word" >&5
2038
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2039
if test "${ac_cv_prog_CC+set}" = set; then
2040
  echo $ECHO_N "(cached) $ECHO_C" >&6
2041
else
2042
  if test -n "$CC"; then
2043
  ac_cv_prog_CC="$CC" # Let the user override the test.
2044
else
2045
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2046
for as_dir in $PATH
2047
do
2048
  IFS=$as_save_IFS
2049
  test -z "$as_dir" && as_dir=.
2050
  for ac_exec_ext in '' $ac_executable_extensions; do
2051
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2052
    ac_cv_prog_CC="${ac_tool_prefix}gcc"
2053
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2054
    break 2
2055
  fi
2056
done
2057
done
2058
 
2059
fi
2060
fi
2061
CC=$ac_cv_prog_CC
2062
if test -n "$CC"; then
2063
  echo "$as_me:$LINENO: result: $CC" >&5
2064
echo "${ECHO_T}$CC" >&6
2065
else
2066
  echo "$as_me:$LINENO: result: no" >&5
2067
echo "${ECHO_T}no" >&6
2068
fi
2069
 
2070
fi
2071
if test -z "$ac_cv_prog_CC"; then
2072
  ac_ct_CC=$CC
2073
  # Extract the first word of "gcc", so it can be a program name with args.
2074
set dummy gcc; ac_word=$2
2075
echo "$as_me:$LINENO: checking for $ac_word" >&5
2076
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2077
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2078
  echo $ECHO_N "(cached) $ECHO_C" >&6
2079
else
2080
  if test -n "$ac_ct_CC"; then
2081
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2082
else
2083
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2084
for as_dir in $PATH
2085
do
2086
  IFS=$as_save_IFS
2087
  test -z "$as_dir" && as_dir=.
2088
  for ac_exec_ext in '' $ac_executable_extensions; do
2089
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2090
    ac_cv_prog_ac_ct_CC="gcc"
2091
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2092
    break 2
2093
  fi
2094
done
2095
done
2096
 
2097
fi
2098
fi
2099
ac_ct_CC=$ac_cv_prog_ac_ct_CC
2100
if test -n "$ac_ct_CC"; then
2101
  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2102
echo "${ECHO_T}$ac_ct_CC" >&6
2103
else
2104
  echo "$as_me:$LINENO: result: no" >&5
2105
echo "${ECHO_T}no" >&6
2106
fi
2107
 
2108
  CC=$ac_ct_CC
2109
else
2110
  CC="$ac_cv_prog_CC"
2111
fi
2112
 
2113
if test -z "$CC"; then
2114
  if test -n "$ac_tool_prefix"; then
2115
  # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2116
set dummy ${ac_tool_prefix}cc; ac_word=$2
2117
echo "$as_me:$LINENO: checking for $ac_word" >&5
2118
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2119
if test "${ac_cv_prog_CC+set}" = set; then
2120
  echo $ECHO_N "(cached) $ECHO_C" >&6
2121
else
2122
  if test -n "$CC"; then
2123
  ac_cv_prog_CC="$CC" # Let the user override the test.
2124
else
2125
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2126
for as_dir in $PATH
2127
do
2128
  IFS=$as_save_IFS
2129
  test -z "$as_dir" && as_dir=.
2130
  for ac_exec_ext in '' $ac_executable_extensions; do
2131
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2132
    ac_cv_prog_CC="${ac_tool_prefix}cc"
2133
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2134
    break 2
2135
  fi
2136
done
2137
done
2138
 
2139
fi
2140
fi
2141
CC=$ac_cv_prog_CC
2142
if test -n "$CC"; then
2143
  echo "$as_me:$LINENO: result: $CC" >&5
2144
echo "${ECHO_T}$CC" >&6
2145
else
2146
  echo "$as_me:$LINENO: result: no" >&5
2147
echo "${ECHO_T}no" >&6
2148
fi
2149
 
2150
fi
2151
if test -z "$ac_cv_prog_CC"; then
2152
  ac_ct_CC=$CC
2153
  # Extract the first word of "cc", so it can be a program name with args.
2154
set dummy cc; ac_word=$2
2155
echo "$as_me:$LINENO: checking for $ac_word" >&5
2156
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2157
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2158
  echo $ECHO_N "(cached) $ECHO_C" >&6
2159
else
2160
  if test -n "$ac_ct_CC"; then
2161
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2162
else
2163
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2164
for as_dir in $PATH
2165
do
2166
  IFS=$as_save_IFS
2167
  test -z "$as_dir" && as_dir=.
2168
  for ac_exec_ext in '' $ac_executable_extensions; do
2169
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2170
    ac_cv_prog_ac_ct_CC="cc"
2171
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2172
    break 2
2173
  fi
2174
done
2175
done
2176
 
2177
fi
2178
fi
2179
ac_ct_CC=$ac_cv_prog_ac_ct_CC
2180
if test -n "$ac_ct_CC"; then
2181
  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2182
echo "${ECHO_T}$ac_ct_CC" >&6
2183
else
2184
  echo "$as_me:$LINENO: result: no" >&5
2185
echo "${ECHO_T}no" >&6
2186
fi
2187
 
2188
  CC=$ac_ct_CC
2189
else
2190
  CC="$ac_cv_prog_CC"
2191
fi
2192
 
2193
fi
2194
if test -z "$CC"; then
2195
  # Extract the first word of "cc", so it can be a program name with args.
2196
set dummy cc; ac_word=$2
2197
echo "$as_me:$LINENO: checking for $ac_word" >&5
2198
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2199
if test "${ac_cv_prog_CC+set}" = set; then
2200
  echo $ECHO_N "(cached) $ECHO_C" >&6
2201
else
2202
  if test -n "$CC"; then
2203
  ac_cv_prog_CC="$CC" # Let the user override the test.
2204
else
2205
  ac_prog_rejected=no
2206
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2207
for as_dir in $PATH
2208
do
2209
  IFS=$as_save_IFS
2210
  test -z "$as_dir" && as_dir=.
2211
  for ac_exec_ext in '' $ac_executable_extensions; do
2212
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2213
    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2214
       ac_prog_rejected=yes
2215
       continue
2216
     fi
2217
    ac_cv_prog_CC="cc"
2218
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2219
    break 2
2220
  fi
2221
done
2222
done
2223
 
2224
if test $ac_prog_rejected = yes; then
2225
  # We found a bogon in the path, so make sure we never use it.
2226
  set dummy $ac_cv_prog_CC
2227
  shift
2228
  if test $# != 0; then
2229
    # We chose a different compiler from the bogus one.
2230
    # However, it has the same basename, so the bogon will be chosen
2231
    # first if we set CC to just the basename; use the full file name.
2232
    shift
2233
    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
2234
  fi
2235
fi
2236
fi
2237
fi
2238
CC=$ac_cv_prog_CC
2239
if test -n "$CC"; then
2240
  echo "$as_me:$LINENO: result: $CC" >&5
2241
echo "${ECHO_T}$CC" >&6
2242
else
2243
  echo "$as_me:$LINENO: result: no" >&5
2244
echo "${ECHO_T}no" >&6
2245
fi
2246
 
2247
fi
2248
if test -z "$CC"; then
2249
  if test -n "$ac_tool_prefix"; then
2250
  for ac_prog in cl
2251
  do
2252
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2253
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2254
echo "$as_me:$LINENO: checking for $ac_word" >&5
2255
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2256
if test "${ac_cv_prog_CC+set}" = set; then
2257
  echo $ECHO_N "(cached) $ECHO_C" >&6
2258
else
2259
  if test -n "$CC"; then
2260
  ac_cv_prog_CC="$CC" # Let the user override the test.
2261
else
2262
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2263
for as_dir in $PATH
2264
do
2265
  IFS=$as_save_IFS
2266
  test -z "$as_dir" && as_dir=.
2267
  for ac_exec_ext in '' $ac_executable_extensions; do
2268
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2269
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2270
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2271
    break 2
2272
  fi
2273
done
2274
done
2275
 
2276
fi
2277
fi
2278
CC=$ac_cv_prog_CC
2279
if test -n "$CC"; then
2280
  echo "$as_me:$LINENO: result: $CC" >&5
2281
echo "${ECHO_T}$CC" >&6
2282
else
2283
  echo "$as_me:$LINENO: result: no" >&5
2284
echo "${ECHO_T}no" >&6
2285
fi
2286
 
2287
    test -n "$CC" && break
2288
  done
2289
fi
2290
if test -z "$CC"; then
2291
  ac_ct_CC=$CC
2292
  for ac_prog in cl
2293
do
2294
  # Extract the first word of "$ac_prog", so it can be a program name with args.
2295
set dummy $ac_prog; ac_word=$2
2296
echo "$as_me:$LINENO: checking for $ac_word" >&5
2297
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2298
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2299
  echo $ECHO_N "(cached) $ECHO_C" >&6
2300
else
2301
  if test -n "$ac_ct_CC"; then
2302
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2303
else
2304
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2305
for as_dir in $PATH
2306
do
2307
  IFS=$as_save_IFS
2308
  test -z "$as_dir" && as_dir=.
2309
  for ac_exec_ext in '' $ac_executable_extensions; do
2310
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2311
    ac_cv_prog_ac_ct_CC="$ac_prog"
2312
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2313
    break 2
2314
  fi
2315
done
2316
done
2317
 
2318
fi
2319
fi
2320
ac_ct_CC=$ac_cv_prog_ac_ct_CC
2321
if test -n "$ac_ct_CC"; then
2322
  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2323
echo "${ECHO_T}$ac_ct_CC" >&6
2324
else
2325
  echo "$as_me:$LINENO: result: no" >&5
2326
echo "${ECHO_T}no" >&6
2327
fi
2328
 
2329
  test -n "$ac_ct_CC" && break
2330
done
2331
 
2332
  CC=$ac_ct_CC
2333
fi
2334
 
2335
fi
2336
 
2337
 
2338
test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2339
See \`config.log' for more details." >&5
2340
echo "$as_me: error: no acceptable C compiler found in \$PATH
2341
See \`config.log' for more details." >&2;}
2342
   { (exit 1); exit 1; }; }
2343
 
2344
# Provide some information about the compiler.
2345
echo "$as_me:$LINENO:" \
2346
     "checking for C compiler version" >&5
2347
ac_compiler=`set X $ac_compile; echo $2`
2348
{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version &5\"") >&5
2349
  (eval $ac_compiler --version &5) 2>&5
2350
  ac_status=$?
2351
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2352
  (exit $ac_status); }
2353
{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v &5\"") >&5
2354
  (eval $ac_compiler -v &5) 2>&5
2355
  ac_status=$?
2356
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2357
  (exit $ac_status); }
2358
{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V &5\"") >&5
2359
  (eval $ac_compiler -V &5) 2>&5
2360
  ac_status=$?
2361
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2362
  (exit $ac_status); }
2363
 
2364
cat >conftest.$ac_ext <<_ACEOF
2365
/* confdefs.h.  */
2366
_ACEOF
2367
cat confdefs.h >>conftest.$ac_ext
2368
cat >>conftest.$ac_ext <<_ACEOF
2369
/* end confdefs.h.  */
2370
 
2371
int
2372
main ()
2373
{
2374
 
2375
  ;
2376
  return 0;
2377
}
2378
_ACEOF
2379
# FIXME: Cleanup?
2380
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
2381
  (eval $ac_link) 2>&5
2382
  ac_status=$?
2383
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2384
  (exit $ac_status); }; then
2385
  gcc_no_link=no
2386
else
2387
  gcc_no_link=yes
2388
fi
2389
 
2390
if test x$gcc_no_link = xyes; then
2391
  # Setting cross_compile will disable run tests; it will
2392
  # also disable AC_CHECK_FILE but that's generally
2393
  # correct if we can't link.
2394
  cross_compiling=yes
2395
  EXEEXT=
2396
else
2397
  cat >conftest.$ac_ext <<_ACEOF
2398
/* confdefs.h.  */
2399
_ACEOF
2400
cat confdefs.h >>conftest.$ac_ext
2401
cat >>conftest.$ac_ext <<_ACEOF
2402
/* end confdefs.h.  */
2403
 
2404
int
2405
main ()
2406
{
2407
 
2408
  ;
2409
  return 0;
2410
}
2411
_ACEOF
2412
ac_clean_files_save=$ac_clean_files
2413
ac_clean_files="$ac_clean_files a.out a.exe b.out"
2414
# Try to create an executable without -o first, disregard a.out.
2415
# It will help us diagnose broken compilers, and finding out an intuition
2416
# of exeext.
2417
echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
2418
echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
2419
ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
2420
if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
2421
  (eval $ac_link_default) 2>&5
2422
  ac_status=$?
2423
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2424
  (exit $ac_status); }; then
2425
  # Find the output, starting from the most likely.  This scheme is
2426
# not robust to junk in `.', hence go to wildcards (a.*) only as a last
2427
# resort.
2428
 
2429
# Be careful to initialize this variable, since it used to be cached.
2430
# Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
2431
ac_cv_exeext=
2432
# b.out is created by i960 compilers.
2433
for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
2434
do
2435
  test -f "$ac_file" || continue
2436
  case $ac_file in
2437
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
2438
        ;;
2439
    conftest.$ac_ext )
2440
        # This is the source file.
2441
        ;;
2442
    [ab].out )
2443
        # We found the default executable, but exeext='' is most
2444
        # certainly right.
2445
        break;;
2446
    *.* )
2447
        ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
2448
        # FIXME: I believe we export ac_cv_exeext for Libtool,
2449
        # but it would be cool to find out if it's true.  Does anybody
2450
        # maintain Libtool? --akim.
2451
        export ac_cv_exeext
2452
        break;;
2453
    * )
2454
        break;;
2455
  esac
2456
done
2457
else
2458
  echo "$as_me: failed program was:" >&5
2459
sed 's/^/| /' conftest.$ac_ext >&5
2460
 
2461
{ { echo "$as_me:$LINENO: error: C compiler cannot create executables
2462
See \`config.log' for more details." >&5
2463
echo "$as_me: error: C compiler cannot create executables
2464
See \`config.log' for more details." >&2;}
2465
   { (exit 77); exit 77; }; }
2466
fi
2467
 
2468
ac_exeext=$ac_cv_exeext
2469
echo "$as_me:$LINENO: result: $ac_file" >&5
2470
echo "${ECHO_T}$ac_file" >&6
2471
 
2472
# Check the compiler produces executables we can run.  If not, either
2473
# the compiler is broken, or we cross compile.
2474
echo "$as_me:$LINENO: checking whether the C compiler works" >&5
2475
echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
2476
# FIXME: These cross compiler hacks should be removed for Autoconf 3.0
2477
# If not cross compiling, check that we can run a simple program.
2478
if test "$cross_compiling" != yes; then
2479
  if { ac_try='./$ac_file'
2480
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2481
  (eval $ac_try) 2>&5
2482
  ac_status=$?
2483
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2484
  (exit $ac_status); }; }; then
2485
    cross_compiling=no
2486
  else
2487
    if test "$cross_compiling" = maybe; then
2488
        cross_compiling=yes
2489
    else
2490
        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
2491
If you meant to cross compile, use \`--host'.
2492
See \`config.log' for more details." >&5
2493
echo "$as_me: error: cannot run C compiled programs.
2494
If you meant to cross compile, use \`--host'.
2495
See \`config.log' for more details." >&2;}
2496
   { (exit 1); exit 1; }; }
2497
    fi
2498
  fi
2499
fi
2500
echo "$as_me:$LINENO: result: yes" >&5
2501
echo "${ECHO_T}yes" >&6
2502
 
2503
rm -f a.out a.exe conftest$ac_cv_exeext b.out
2504
ac_clean_files=$ac_clean_files_save
2505
# Check the compiler produces executables we can run.  If not, either
2506
# the compiler is broken, or we cross compile.
2507
echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
2508
echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
2509
echo "$as_me:$LINENO: result: $cross_compiling" >&5
2510
echo "${ECHO_T}$cross_compiling" >&6
2511
 
2512
echo "$as_me:$LINENO: checking for suffix of executables" >&5
2513
echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
2514
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
2515
  (eval $ac_link) 2>&5
2516
  ac_status=$?
2517
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2518
  (exit $ac_status); }; then
2519
  # If both `conftest.exe' and `conftest' are `present' (well, observable)
2520
# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
2521
# work properly (i.e., refer to `conftest.exe'), while it won't with
2522
# `rm'.
2523
for ac_file in conftest.exe conftest conftest.*; do
2524
  test -f "$ac_file" || continue
2525
  case $ac_file in
2526
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
2527
    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
2528
          export ac_cv_exeext
2529
          break;;
2530
    * ) break;;
2531
  esac
2532
done
2533
else
2534
  { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
2535
See \`config.log' for more details." >&5
2536
echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
2537
See \`config.log' for more details." >&2;}
2538
   { (exit 1); exit 1; }; }
2539
fi
2540
 
2541
rm -f conftest$ac_cv_exeext
2542
echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
2543
echo "${ECHO_T}$ac_cv_exeext" >&6
2544
 
2545
rm -f conftest.$ac_ext
2546
EXEEXT=$ac_cv_exeext
2547
ac_exeext=$EXEEXT
2548
fi
2549
echo "$as_me:$LINENO: checking for suffix of object files" >&5
2550
echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
2551
if test "${ac_cv_objext+set}" = set; then
2552
  echo $ECHO_N "(cached) $ECHO_C" >&6
2553
else
2554
  cat >conftest.$ac_ext <<_ACEOF
2555
/* confdefs.h.  */
2556
_ACEOF
2557
cat confdefs.h >>conftest.$ac_ext
2558
cat >>conftest.$ac_ext <<_ACEOF
2559
/* end confdefs.h.  */
2560
 
2561
int
2562
main ()
2563
{
2564
 
2565
  ;
2566
  return 0;
2567
}
2568
_ACEOF
2569
rm -f conftest.o conftest.obj
2570
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2571
  (eval $ac_compile) 2>&5
2572
  ac_status=$?
2573
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2574
  (exit $ac_status); }; then
2575
  for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
2576
  case $ac_file in
2577
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
2578
    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
2579
       break;;
2580
  esac
2581
done
2582
else
2583
  echo "$as_me: failed program was:" >&5
2584
sed 's/^/| /' conftest.$ac_ext >&5
2585
 
2586
{ { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
2587
See \`config.log' for more details." >&5
2588
echo "$as_me: error: cannot compute suffix of object files: cannot compile
2589
See \`config.log' for more details." >&2;}
2590
   { (exit 1); exit 1; }; }
2591
fi
2592
 
2593
rm -f conftest.$ac_cv_objext conftest.$ac_ext
2594
fi
2595
echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
2596
echo "${ECHO_T}$ac_cv_objext" >&6
2597
OBJEXT=$ac_cv_objext
2598
ac_objext=$OBJEXT
2599
echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2600
echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2601
if test "${ac_cv_c_compiler_gnu+set}" = set; then
2602
  echo $ECHO_N "(cached) $ECHO_C" >&6
2603
else
2604
  cat >conftest.$ac_ext <<_ACEOF
2605
/* confdefs.h.  */
2606
_ACEOF
2607
cat confdefs.h >>conftest.$ac_ext
2608
cat >>conftest.$ac_ext <<_ACEOF
2609
/* end confdefs.h.  */
2610
 
2611
int
2612
main ()
2613
{
2614
#ifndef __GNUC__
2615
       choke me
2616
#endif
2617
 
2618
  ;
2619
  return 0;
2620
}
2621
_ACEOF
2622
rm -f conftest.$ac_objext
2623
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2624
  (eval $ac_compile) 2>conftest.er1
2625
  ac_status=$?
2626
  grep -v '^ *+' conftest.er1 >conftest.err
2627
  rm -f conftest.er1
2628
  cat conftest.err >&5
2629
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2630
  (exit $ac_status); } &&
2631
         { ac_try='test -z "$ac_c_werror_flag"
2632
                         || test ! -s conftest.err'
2633
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2634
  (eval $ac_try) 2>&5
2635
  ac_status=$?
2636
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2637
  (exit $ac_status); }; } &&
2638
         { ac_try='test -s conftest.$ac_objext'
2639
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2640
  (eval $ac_try) 2>&5
2641
  ac_status=$?
2642
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2643
  (exit $ac_status); }; }; then
2644
  ac_compiler_gnu=yes
2645
else
2646
  echo "$as_me: failed program was:" >&5
2647
sed 's/^/| /' conftest.$ac_ext >&5
2648
 
2649
ac_compiler_gnu=no
2650
fi
2651
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2652
ac_cv_c_compiler_gnu=$ac_compiler_gnu
2653
 
2654
fi
2655
echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2656
echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2657
GCC=`test $ac_compiler_gnu = yes && echo yes`
2658
ac_test_CFLAGS=${CFLAGS+set}
2659
ac_save_CFLAGS=$CFLAGS
2660
CFLAGS="-g"
2661
echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2662
echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2663
if test "${ac_cv_prog_cc_g+set}" = set; then
2664
  echo $ECHO_N "(cached) $ECHO_C" >&6
2665
else
2666
  cat >conftest.$ac_ext <<_ACEOF
2667
/* confdefs.h.  */
2668
_ACEOF
2669
cat confdefs.h >>conftest.$ac_ext
2670
cat >>conftest.$ac_ext <<_ACEOF
2671
/* end confdefs.h.  */
2672
 
2673
int
2674
main ()
2675
{
2676
 
2677
  ;
2678
  return 0;
2679
}
2680
_ACEOF
2681
rm -f conftest.$ac_objext
2682
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2683
  (eval $ac_compile) 2>conftest.er1
2684
  ac_status=$?
2685
  grep -v '^ *+' conftest.er1 >conftest.err
2686
  rm -f conftest.er1
2687
  cat conftest.err >&5
2688
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2689
  (exit $ac_status); } &&
2690
         { ac_try='test -z "$ac_c_werror_flag"
2691
                         || test ! -s conftest.err'
2692
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2693
  (eval $ac_try) 2>&5
2694
  ac_status=$?
2695
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2696
  (exit $ac_status); }; } &&
2697
         { ac_try='test -s conftest.$ac_objext'
2698
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2699
  (eval $ac_try) 2>&5
2700
  ac_status=$?
2701
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2702
  (exit $ac_status); }; }; then
2703
  ac_cv_prog_cc_g=yes
2704
else
2705
  echo "$as_me: failed program was:" >&5
2706
sed 's/^/| /' conftest.$ac_ext >&5
2707
 
2708
ac_cv_prog_cc_g=no
2709
fi
2710
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2711
fi
2712
echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2713
echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2714
if test "$ac_test_CFLAGS" = set; then
2715
  CFLAGS=$ac_save_CFLAGS
2716
elif test $ac_cv_prog_cc_g = yes; then
2717
  if test "$GCC" = yes; then
2718
    CFLAGS="-g -O2"
2719
  else
2720
    CFLAGS="-g"
2721
  fi
2722
else
2723
  if test "$GCC" = yes; then
2724
    CFLAGS="-O2"
2725
  else
2726
    CFLAGS=
2727
  fi
2728
fi
2729
echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2730
echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2731
if test "${ac_cv_prog_cc_stdc+set}" = set; then
2732
  echo $ECHO_N "(cached) $ECHO_C" >&6
2733
else
2734
  ac_cv_prog_cc_stdc=no
2735
ac_save_CC=$CC
2736
cat >conftest.$ac_ext <<_ACEOF
2737
/* confdefs.h.  */
2738
_ACEOF
2739
cat confdefs.h >>conftest.$ac_ext
2740
cat >>conftest.$ac_ext <<_ACEOF
2741
/* end confdefs.h.  */
2742
#include 
2743
#include 
2744
#include 
2745
#include 
2746
/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2747
struct buf { int x; };
2748
FILE * (*rcsopen) (struct buf *, struct stat *, int);
2749
static char *e (p, i)
2750
     char **p;
2751
     int i;
2752
{
2753
  return p[i];
2754
}
2755
static char *f (char * (*g) (char **, int), char **p, ...)
2756
{
2757
  char *s;
2758
  va_list v;
2759
  va_start (v,p);
2760
  s = g (p, va_arg (v,int));
2761
  va_end (v);
2762
  return s;
2763
}
2764
 
2765
/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2766
   function prototypes and stuff, but not '\xHH' hex character constants.
2767
   These don't provoke an error unfortunately, instead are silently treated
2768
   as 'x'.  The following induces an error, until -std1 is added to get
2769
   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2770
   array size at least.  It's necessary to write '\x00'==0 to get something
2771
   that's true only with -std1.  */
2772
int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2773
 
2774
int test (int i, double x);
2775
struct s1 {int (*f) (int a);};
2776
struct s2 {int (*f) (double a);};
2777
int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2778
int argc;
2779
char **argv;
2780
int
2781
main ()
2782
{
2783
return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2784
  ;
2785
  return 0;
2786
}
2787
_ACEOF
2788
# Don't try gcc -ansi; that turns off useful extensions and
2789
# breaks some systems' header files.
2790
# AIX                   -qlanglvl=ansi
2791
# Ultrix and OSF/1      -std1
2792
# HP-UX 10.20 and later -Ae
2793
# HP-UX older versions  -Aa -D_HPUX_SOURCE
2794
# SVR4                  -Xc -D__EXTENSIONS__
2795
for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2796
do
2797
  CC="$ac_save_CC $ac_arg"
2798
  rm -f conftest.$ac_objext
2799
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2800
  (eval $ac_compile) 2>conftest.er1
2801
  ac_status=$?
2802
  grep -v '^ *+' conftest.er1 >conftest.err
2803
  rm -f conftest.er1
2804
  cat conftest.err >&5
2805
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2806
  (exit $ac_status); } &&
2807
         { ac_try='test -z "$ac_c_werror_flag"
2808
                         || test ! -s conftest.err'
2809
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2810
  (eval $ac_try) 2>&5
2811
  ac_status=$?
2812
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2813
  (exit $ac_status); }; } &&
2814
         { ac_try='test -s conftest.$ac_objext'
2815
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2816
  (eval $ac_try) 2>&5
2817
  ac_status=$?
2818
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2819
  (exit $ac_status); }; }; then
2820
  ac_cv_prog_cc_stdc=$ac_arg
2821
break
2822
else
2823
  echo "$as_me: failed program was:" >&5
2824
sed 's/^/| /' conftest.$ac_ext >&5
2825
 
2826
fi
2827
rm -f conftest.err conftest.$ac_objext
2828
done
2829
rm -f conftest.$ac_ext conftest.$ac_objext
2830
CC=$ac_save_CC
2831
 
2832
fi
2833
 
2834
case "x$ac_cv_prog_cc_stdc" in
2835
  x|xno)
2836
    echo "$as_me:$LINENO: result: none needed" >&5
2837
echo "${ECHO_T}none needed" >&6 ;;
2838
  *)
2839
    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2840
echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2841
    CC="$CC $ac_cv_prog_cc_stdc" ;;
2842
esac
2843
 
2844
# Some people use a C++ compiler to compile C.  Since we use `exit',
2845
# in C++ we need to declare it.  In case someone uses the same compiler
2846
# for both compiling C and C++ we need to have the C++ compiler decide
2847
# the declaration of exit, since it's the most demanding environment.
2848
cat >conftest.$ac_ext <<_ACEOF
2849
#ifndef __cplusplus
2850
  choke me
2851
#endif
2852
_ACEOF
2853
rm -f conftest.$ac_objext
2854
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2855
  (eval $ac_compile) 2>conftest.er1
2856
  ac_status=$?
2857
  grep -v '^ *+' conftest.er1 >conftest.err
2858
  rm -f conftest.er1
2859
  cat conftest.err >&5
2860
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2861
  (exit $ac_status); } &&
2862
         { ac_try='test -z "$ac_c_werror_flag"
2863
                         || test ! -s conftest.err'
2864
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2865
  (eval $ac_try) 2>&5
2866
  ac_status=$?
2867
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2868
  (exit $ac_status); }; } &&
2869
         { ac_try='test -s conftest.$ac_objext'
2870
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2871
  (eval $ac_try) 2>&5
2872
  ac_status=$?
2873
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2874
  (exit $ac_status); }; }; then
2875
  for ac_declaration in \
2876
   '' \
2877
   'extern "C" void std::exit (int) throw (); using std::exit;' \
2878
   'extern "C" void std::exit (int); using std::exit;' \
2879
   'extern "C" void exit (int) throw ();' \
2880
   'extern "C" void exit (int);' \
2881
   'void exit (int);'
2882
do
2883
  cat >conftest.$ac_ext <<_ACEOF
2884
/* confdefs.h.  */
2885
_ACEOF
2886
cat confdefs.h >>conftest.$ac_ext
2887
cat >>conftest.$ac_ext <<_ACEOF
2888
/* end confdefs.h.  */
2889
$ac_declaration
2890
#include 
2891
int
2892
main ()
2893
{
2894
exit (42);
2895
  ;
2896
  return 0;
2897
}
2898
_ACEOF
2899
rm -f conftest.$ac_objext
2900
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2901
  (eval $ac_compile) 2>conftest.er1
2902
  ac_status=$?
2903
  grep -v '^ *+' conftest.er1 >conftest.err
2904
  rm -f conftest.er1
2905
  cat conftest.err >&5
2906
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2907
  (exit $ac_status); } &&
2908
         { ac_try='test -z "$ac_c_werror_flag"
2909
                         || test ! -s conftest.err'
2910
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2911
  (eval $ac_try) 2>&5
2912
  ac_status=$?
2913
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2914
  (exit $ac_status); }; } &&
2915
         { ac_try='test -s conftest.$ac_objext'
2916
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2917
  (eval $ac_try) 2>&5
2918
  ac_status=$?
2919
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2920
  (exit $ac_status); }; }; then
2921
  :
2922
else
2923
  echo "$as_me: failed program was:" >&5
2924
sed 's/^/| /' conftest.$ac_ext >&5
2925
 
2926
continue
2927
fi
2928
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2929
  cat >conftest.$ac_ext <<_ACEOF
2930
/* confdefs.h.  */
2931
_ACEOF
2932
cat confdefs.h >>conftest.$ac_ext
2933
cat >>conftest.$ac_ext <<_ACEOF
2934
/* end confdefs.h.  */
2935
$ac_declaration
2936
int
2937
main ()
2938
{
2939
exit (42);
2940
  ;
2941
  return 0;
2942
}
2943
_ACEOF
2944
rm -f conftest.$ac_objext
2945
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2946
  (eval $ac_compile) 2>conftest.er1
2947
  ac_status=$?
2948
  grep -v '^ *+' conftest.er1 >conftest.err
2949
  rm -f conftest.er1
2950
  cat conftest.err >&5
2951
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2952
  (exit $ac_status); } &&
2953
         { ac_try='test -z "$ac_c_werror_flag"
2954
                         || test ! -s conftest.err'
2955
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2956
  (eval $ac_try) 2>&5
2957
  ac_status=$?
2958
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2959
  (exit $ac_status); }; } &&
2960
         { ac_try='test -s conftest.$ac_objext'
2961
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2962
  (eval $ac_try) 2>&5
2963
  ac_status=$?
2964
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2965
  (exit $ac_status); }; }; then
2966
  break
2967
else
2968
  echo "$as_me: failed program was:" >&5
2969
sed 's/^/| /' conftest.$ac_ext >&5
2970
 
2971
fi
2972
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2973
done
2974
rm -f conftest*
2975
if test -n "$ac_declaration"; then
2976
  echo '#ifdef __cplusplus' >>confdefs.h
2977
  echo $ac_declaration      >>confdefs.h
2978
  echo '#endif'             >>confdefs.h
2979
fi
2980
 
2981
else
2982
  echo "$as_me: failed program was:" >&5
2983
sed 's/^/| /' conftest.$ac_ext >&5
2984
 
2985
fi
2986
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2987
ac_ext=c
2988
ac_cpp='$CPP $CPPFLAGS'
2989
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2990
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2991
ac_compiler_gnu=$ac_cv_c_compiler_gnu
2992
 
2993
 
2994
 
2995
# Add -Wall -fno-repack-arrays -fno-underscoring if we are using GCC.
2996
if test "x$GCC" = "xyes"; then
2997
  AM_FCFLAGS="-I . -Wall -fno-repack-arrays -fno-underscoring"
2998
  ## We like to use C99 routines when available.  This makes sure that
2999
  ## __STDC_VERSION__ is set such that libc includes make them available.
3000
  AM_CFLAGS="-std=gnu99 -Wall -Wstrict-prototypes -Wmissing-prototypes -Wold-style-definition -Wextra -Wwrite-strings"
3001
  ## Compile the following tests with the same system header contents
3002
  ## that we'll encounter when compiling our own source files.
3003
  CFLAGS="-std=gnu99 $CFLAGS"
3004
fi
3005
 
3006
 
3007
 
3008
# Find other programs we need.
3009
if test -n "$ac_tool_prefix"; then
3010
  # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
3011
set dummy ${ac_tool_prefix}as; ac_word=$2
3012
echo "$as_me:$LINENO: checking for $ac_word" >&5
3013
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3014
if test "${ac_cv_prog_AS+set}" = set; then
3015
  echo $ECHO_N "(cached) $ECHO_C" >&6
3016
else
3017
  if test -n "$AS"; then
3018
  ac_cv_prog_AS="$AS" # Let the user override the test.
3019
else
3020
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3021
for as_dir in $PATH
3022
do
3023
  IFS=$as_save_IFS
3024
  test -z "$as_dir" && as_dir=.
3025
  for ac_exec_ext in '' $ac_executable_extensions; do
3026
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3027
    ac_cv_prog_AS="${ac_tool_prefix}as"
3028
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3029
    break 2
3030
  fi
3031
done
3032
done
3033
 
3034
fi
3035
fi
3036
AS=$ac_cv_prog_AS
3037
if test -n "$AS"; then
3038
  echo "$as_me:$LINENO: result: $AS" >&5
3039
echo "${ECHO_T}$AS" >&6
3040
else
3041
  echo "$as_me:$LINENO: result: no" >&5
3042
echo "${ECHO_T}no" >&6
3043
fi
3044
 
3045
fi
3046
if test -z "$ac_cv_prog_AS"; then
3047
  ac_ct_AS=$AS
3048
  # Extract the first word of "as", so it can be a program name with args.
3049
set dummy as; ac_word=$2
3050
echo "$as_me:$LINENO: checking for $ac_word" >&5
3051
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3052
if test "${ac_cv_prog_ac_ct_AS+set}" = set; then
3053
  echo $ECHO_N "(cached) $ECHO_C" >&6
3054
else
3055
  if test -n "$ac_ct_AS"; then
3056
  ac_cv_prog_ac_ct_AS="$ac_ct_AS" # Let the user override the test.
3057
else
3058
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3059
for as_dir in $PATH
3060
do
3061
  IFS=$as_save_IFS
3062
  test -z "$as_dir" && as_dir=.
3063
  for ac_exec_ext in '' $ac_executable_extensions; do
3064
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3065
    ac_cv_prog_ac_ct_AS="as"
3066
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3067
    break 2
3068
  fi
3069
done
3070
done
3071
 
3072
fi
3073
fi
3074
ac_ct_AS=$ac_cv_prog_ac_ct_AS
3075
if test -n "$ac_ct_AS"; then
3076
  echo "$as_me:$LINENO: result: $ac_ct_AS" >&5
3077
echo "${ECHO_T}$ac_ct_AS" >&6
3078
else
3079
  echo "$as_me:$LINENO: result: no" >&5
3080
echo "${ECHO_T}no" >&6
3081
fi
3082
 
3083
  AS=$ac_ct_AS
3084
else
3085
  AS="$ac_cv_prog_AS"
3086
fi
3087
 
3088
if test -n "$ac_tool_prefix"; then
3089
  # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
3090
set dummy ${ac_tool_prefix}ar; ac_word=$2
3091
echo "$as_me:$LINENO: checking for $ac_word" >&5
3092
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3093
if test "${ac_cv_prog_AR+set}" = set; then
3094
  echo $ECHO_N "(cached) $ECHO_C" >&6
3095
else
3096
  if test -n "$AR"; then
3097
  ac_cv_prog_AR="$AR" # Let the user override the test.
3098
else
3099
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3100
for as_dir in $PATH
3101
do
3102
  IFS=$as_save_IFS
3103
  test -z "$as_dir" && as_dir=.
3104
  for ac_exec_ext in '' $ac_executable_extensions; do
3105
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3106
    ac_cv_prog_AR="${ac_tool_prefix}ar"
3107
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3108
    break 2
3109
  fi
3110
done
3111
done
3112
 
3113
fi
3114
fi
3115
AR=$ac_cv_prog_AR
3116
if test -n "$AR"; then
3117
  echo "$as_me:$LINENO: result: $AR" >&5
3118
echo "${ECHO_T}$AR" >&6
3119
else
3120
  echo "$as_me:$LINENO: result: no" >&5
3121
echo "${ECHO_T}no" >&6
3122
fi
3123
 
3124
fi
3125
if test -z "$ac_cv_prog_AR"; then
3126
  ac_ct_AR=$AR
3127
  # Extract the first word of "ar", so it can be a program name with args.
3128
set dummy ar; ac_word=$2
3129
echo "$as_me:$LINENO: checking for $ac_word" >&5
3130
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3131
if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
3132
  echo $ECHO_N "(cached) $ECHO_C" >&6
3133
else
3134
  if test -n "$ac_ct_AR"; then
3135
  ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
3136
else
3137
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3138
for as_dir in $PATH
3139
do
3140
  IFS=$as_save_IFS
3141
  test -z "$as_dir" && as_dir=.
3142
  for ac_exec_ext in '' $ac_executable_extensions; do
3143
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3144
    ac_cv_prog_ac_ct_AR="ar"
3145
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3146
    break 2
3147
  fi
3148
done
3149
done
3150
 
3151
fi
3152
fi
3153
ac_ct_AR=$ac_cv_prog_ac_ct_AR
3154
if test -n "$ac_ct_AR"; then
3155
  echo "$as_me:$LINENO: result: $ac_ct_AR" >&5
3156
echo "${ECHO_T}$ac_ct_AR" >&6
3157
else
3158
  echo "$as_me:$LINENO: result: no" >&5
3159
echo "${ECHO_T}no" >&6
3160
fi
3161
 
3162
  AR=$ac_ct_AR
3163
else
3164
  AR="$ac_cv_prog_AR"
3165
fi
3166
 
3167
if test -n "$ac_tool_prefix"; then
3168
  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3169
set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3170
echo "$as_me:$LINENO: checking for $ac_word" >&5
3171
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3172
if test "${ac_cv_prog_RANLIB+set}" = set; then
3173
  echo $ECHO_N "(cached) $ECHO_C" >&6
3174
else
3175
  if test -n "$RANLIB"; then
3176
  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3177
else
3178
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3179
for as_dir in $PATH
3180
do
3181
  IFS=$as_save_IFS
3182
  test -z "$as_dir" && as_dir=.
3183
  for ac_exec_ext in '' $ac_executable_extensions; do
3184
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3185
    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3186
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3187
    break 2
3188
  fi
3189
done
3190
done
3191
 
3192
fi
3193
fi
3194
RANLIB=$ac_cv_prog_RANLIB
3195
if test -n "$RANLIB"; then
3196
  echo "$as_me:$LINENO: result: $RANLIB" >&5
3197
echo "${ECHO_T}$RANLIB" >&6
3198
else
3199
  echo "$as_me:$LINENO: result: no" >&5
3200
echo "${ECHO_T}no" >&6
3201
fi
3202
 
3203
fi
3204
if test -z "$ac_cv_prog_RANLIB"; then
3205
  ac_ct_RANLIB=$RANLIB
3206
  # Extract the first word of "ranlib", so it can be a program name with args.
3207
set dummy ranlib; ac_word=$2
3208
echo "$as_me:$LINENO: checking for $ac_word" >&5
3209
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3210
if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3211
  echo $ECHO_N "(cached) $ECHO_C" >&6
3212
else
3213
  if test -n "$ac_ct_RANLIB"; then
3214
  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3215
else
3216
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3217
for as_dir in $PATH
3218
do
3219
  IFS=$as_save_IFS
3220
  test -z "$as_dir" && as_dir=.
3221
  for ac_exec_ext in '' $ac_executable_extensions; do
3222
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3223
    ac_cv_prog_ac_ct_RANLIB="ranlib"
3224
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3225
    break 2
3226
  fi
3227
done
3228
done
3229
 
3230
  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB="ranlib-not-found-in-path-error"
3231
fi
3232
fi
3233
ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3234
if test -n "$ac_ct_RANLIB"; then
3235
  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3236
echo "${ECHO_T}$ac_ct_RANLIB" >&6
3237
else
3238
  echo "$as_me:$LINENO: result: no" >&5
3239
echo "${ECHO_T}no" >&6
3240
fi
3241
 
3242
  RANLIB=$ac_ct_RANLIB
3243
else
3244
  RANLIB="$ac_cv_prog_RANLIB"
3245
fi
3246
 
3247
echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3248
echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3249
set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3250
if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3251
  echo $ECHO_N "(cached) $ECHO_C" >&6
3252
else
3253
  cat >conftest.make <<\_ACEOF
3254
all:
3255
        @echo 'ac_maketemp="$(MAKE)"'
3256
_ACEOF
3257
# GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3258
eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3259
if test -n "$ac_maketemp"; then
3260
  eval ac_cv_prog_make_${ac_make}_set=yes
3261
else
3262
  eval ac_cv_prog_make_${ac_make}_set=no
3263
fi
3264
rm -f conftest.make
3265
fi
3266
if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3267
  echo "$as_me:$LINENO: result: yes" >&5
3268
echo "${ECHO_T}yes" >&6
3269
  SET_MAKE=
3270
else
3271
  echo "$as_me:$LINENO: result: no" >&5
3272
echo "${ECHO_T}no" >&6
3273
  SET_MAKE="MAKE=${MAKE-make}"
3274
fi
3275
 
3276
# Find a good install program.  We prefer a C program (faster),
3277
# so one script is as good as another.  But avoid the broken or
3278
# incompatible versions:
3279
# SysV /etc/install, /usr/sbin/install
3280
# SunOS /usr/etc/install
3281
# IRIX /sbin/install
3282
# AIX /bin/install
3283
# AmigaOS /C/install, which installs bootblocks on floppy discs
3284
# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3285
# AFS /usr/afsws/bin/install, which mishandles nonexistent args
3286
# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3287
# OS/2's system install, which has a completely different semantic
3288
# ./install, which can be erroneously created by make from ./install.sh.
3289
echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3290
echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3291
if test -z "$INSTALL"; then
3292
if test "${ac_cv_path_install+set}" = set; then
3293
  echo $ECHO_N "(cached) $ECHO_C" >&6
3294
else
3295
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3296
for as_dir in $PATH
3297
do
3298
  IFS=$as_save_IFS
3299
  test -z "$as_dir" && as_dir=.
3300
  # Account for people who put trailing slashes in PATH elements.
3301
case $as_dir/ in
3302
  ./ | .// | /cC/* | \
3303
  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3304
  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3305
  /usr/ucb/* ) ;;
3306
  *)
3307
    # OSF1 and SCO ODT 3.0 have their own names for install.
3308
    # Don't use installbsd from OSF since it installs stuff as root
3309
    # by default.
3310
    for ac_prog in ginstall scoinst install; do
3311
      for ac_exec_ext in '' $ac_executable_extensions; do
3312
        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3313
          if test $ac_prog = install &&
3314
            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3315
            # AIX install.  It has an incompatible calling convention.
3316
            :
3317
          elif test $ac_prog = install &&
3318
            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3319
            # program-specific install script used by HP pwplus--don't use.
3320
            :
3321
          else
3322
            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3323
            break 3
3324
          fi
3325
        fi
3326
      done
3327
    done
3328
    ;;
3329
esac
3330
done
3331
 
3332
 
3333
fi
3334
  if test "${ac_cv_path_install+set}" = set; then
3335
    INSTALL=$ac_cv_path_install
3336
  else
3337
    # As a last resort, use the slow shell script.  We don't cache a
3338
    # path for INSTALL within a source directory, because that will
3339
    # break other packages using the cache if that directory is
3340
    # removed, or if the path is relative.
3341
    INSTALL=$ac_install_sh
3342
  fi
3343
fi
3344
echo "$as_me:$LINENO: result: $INSTALL" >&5
3345
echo "${ECHO_T}$INSTALL" >&6
3346
 
3347
# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3348
# It thinks the first close brace ends the variable substitution.
3349
test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3350
 
3351
test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3352
 
3353
test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3354
 
3355
 
3356
# Configure libtool
3357
#AC_MSG_NOTICE([====== Starting libtool configuration])
3358
 
3359
# Check whether --enable-shared or --disable-shared was given.
3360
if test "${enable_shared+set}" = set; then
3361
  enableval="$enable_shared"
3362
  p=${PACKAGE-default}
3363
case $enableval in
3364
yes) enable_shared=yes ;;
3365
no) enable_shared=no ;;
3366
*)
3367
  enable_shared=no
3368
  # Look at the argument we got.  We use all the common list separators.
3369
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3370
  for pkg in $enableval; do
3371
    if test "X$pkg" = "X$p"; then
3372
      enable_shared=yes
3373
    fi
3374
  done
3375
  IFS="$ac_save_ifs"
3376
  ;;
3377
esac
3378
else
3379
  enable_shared=yes
3380
fi;
3381
# Check whether --enable-static or --disable-static was given.
3382
if test "${enable_static+set}" = set; then
3383
  enableval="$enable_static"
3384
  p=${PACKAGE-default}
3385
case $enableval in
3386
yes) enable_static=yes ;;
3387
no) enable_static=no ;;
3388
*)
3389
  enable_static=no
3390
  # Look at the argument we got.  We use all the common list separators.
3391
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3392
  for pkg in $enableval; do
3393
    if test "X$pkg" = "X$p"; then
3394
      enable_static=yes
3395
    fi
3396
  done
3397
  IFS="$ac_save_ifs"
3398
  ;;
3399
esac
3400
else
3401
  enable_static=yes
3402
fi;
3403
# Check whether --enable-fast-install or --disable-fast-install was given.
3404
if test "${enable_fast_install+set}" = set; then
3405
  enableval="$enable_fast_install"
3406
  p=${PACKAGE-default}
3407
case $enableval in
3408
yes) enable_fast_install=yes ;;
3409
no) enable_fast_install=no ;;
3410
*)
3411
  enable_fast_install=no
3412
  # Look at the argument we got.  We use all the common list separators.
3413
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3414
  for pkg in $enableval; do
3415
    if test "X$pkg" = "X$p"; then
3416
      enable_fast_install=yes
3417
    fi
3418
  done
3419
  IFS="$ac_save_ifs"
3420
  ;;
3421
esac
3422
else
3423
  enable_fast_install=yes
3424
fi;
3425
 
3426
# Check whether --with-gnu-ld or --without-gnu-ld was given.
3427
if test "${with_gnu_ld+set}" = set; then
3428
  withval="$with_gnu_ld"
3429
  test "$withval" = no || with_gnu_ld=yes
3430
else
3431
  with_gnu_ld=no
3432
fi;
3433
ac_prog=ld
3434
if test "$GCC" = yes; then
3435
  # Check if gcc -print-prog-name=ld gives a path.
3436
  echo "$as_me:$LINENO: checking for ld used by GCC" >&5
3437
echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6
3438
  case $host in
3439
  *-*-mingw*)
3440
    # gcc leaves a trailing carriage return which upsets mingw
3441
    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
3442
  *)
3443
    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
3444
  esac
3445
  case $ac_prog in
3446
    # Accept absolute paths.
3447
    [\\/]* | [A-Za-z]:[\\/]*)
3448
      re_direlt='/[^/][^/]*/\.\./'
3449
      # Canonicalize the path of ld
3450
      ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
3451
      while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
3452
        ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
3453
      done
3454
      test -z "$LD" && LD="$ac_prog"
3455
      ;;
3456
  "")
3457
    # If it fails, then pretend we aren't using GCC.
3458
    ac_prog=ld
3459
    ;;
3460
  *)
3461
    # If it is relative, then search for the first ld in PATH.
3462
    with_gnu_ld=unknown
3463
    ;;
3464
  esac
3465
elif test "$with_gnu_ld" = yes; then
3466
  echo "$as_me:$LINENO: checking for GNU ld" >&5
3467
echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6
3468
else
3469
  echo "$as_me:$LINENO: checking for non-GNU ld" >&5
3470
echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6
3471
fi
3472
if test "${lt_cv_path_LD+set}" = set; then
3473
  echo $ECHO_N "(cached) $ECHO_C" >&6
3474
else
3475
  if test -z "$LD"; then
3476
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
3477
  for ac_dir in $PATH; do
3478
    test -z "$ac_dir" && ac_dir=.
3479
    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
3480
      lt_cv_path_LD="$ac_dir/$ac_prog"
3481
      # Check to see if the program is GNU ld.  I'd rather use --version,
3482
      # but apparently some GNU ld's only accept -v.
3483
      # Break only if it was the GNU/non-GNU ld that we prefer.
3484
      if "$lt_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
3485
        test "$with_gnu_ld" != no && break
3486
      else
3487
        test "$with_gnu_ld" != yes && break
3488
      fi
3489
    fi
3490
  done
3491
  IFS="$ac_save_ifs"
3492
else
3493
  lt_cv_path_LD="$LD" # Let the user override the test with a path.
3494
fi
3495
fi
3496
 
3497
LD="$lt_cv_path_LD"
3498
if test -n "$LD"; then
3499
  echo "$as_me:$LINENO: result: $LD" >&5
3500
echo "${ECHO_T}$LD" >&6
3501
else
3502
  echo "$as_me:$LINENO: result: no" >&5
3503
echo "${ECHO_T}no" >&6
3504
fi
3505
test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5
3506
echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}
3507
   { (exit 1); exit 1; }; }
3508
echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
3509
echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6
3510
if test "${lt_cv_prog_gnu_ld+set}" = set; then
3511
  echo $ECHO_N "(cached) $ECHO_C" >&6
3512
else
3513
  # I'd rather use --version here, but apparently some GNU ld's only accept -v.
3514
if $LD -v 2>&1 &5; then
3515
  lt_cv_prog_gnu_ld=yes
3516
else
3517
  lt_cv_prog_gnu_ld=no
3518
fi
3519
fi
3520
echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
3521
echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6
3522
with_gnu_ld=$lt_cv_prog_gnu_ld
3523
 
3524
 
3525
echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
3526
echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6
3527
if test "${lt_cv_ld_reload_flag+set}" = set; then
3528
  echo $ECHO_N "(cached) $ECHO_C" >&6
3529
else
3530
  lt_cv_ld_reload_flag='-r'
3531
fi
3532
echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
3533
echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6
3534
reload_flag=$lt_cv_ld_reload_flag
3535
test -n "$reload_flag" && reload_flag=" $reload_flag"
3536
 
3537
echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
3538
echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6
3539
if test "${lt_cv_path_NM+set}" = set; then
3540
  echo $ECHO_N "(cached) $ECHO_C" >&6
3541
else
3542
  if test -n "$NM"; then
3543
  # Let the user override the test.
3544
  lt_cv_path_NM="$NM"
3545
else
3546
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
3547
  for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
3548
    test -z "$ac_dir" && ac_dir=.
3549
    tmp_nm=$ac_dir/${ac_tool_prefix}nm
3550
    if test -f $tmp_nm || test -f $tmp_nm$ac_exeext ; then
3551
      # Check to see if the nm accepts a BSD-compat flag.
3552
      # Adding the `sed 1q' prevents false positives on HP-UX, which says:
3553
      #   nm: unknown option "B" ignored
3554
      # Tru64's nm complains that /dev/null is an invalid object file
3555
      if ($tmp_nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep '(/dev/null|Invalid file or object type)' >/dev/null; then
3556
        lt_cv_path_NM="$tmp_nm -B"
3557
        break
3558
      elif ($tmp_nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
3559
        lt_cv_path_NM="$tmp_nm -p"
3560
        break
3561
      else
3562
        lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
3563
        continue # so that we can try to find one that supports BSD flags
3564
      fi
3565
    fi
3566
  done
3567
  IFS="$ac_save_ifs"
3568
  test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm
3569
fi
3570
fi
3571
 
3572
NM="$lt_cv_path_NM"
3573
echo "$as_me:$LINENO: result: $NM" >&5
3574
echo "${ECHO_T}$NM" >&6
3575
 
3576
echo "$as_me:$LINENO: checking whether ln -s works" >&5
3577
echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3578
LN_S=$as_ln_s
3579
if test "$LN_S" = "ln -s"; then
3580
  echo "$as_me:$LINENO: result: yes" >&5
3581
echo "${ECHO_T}yes" >&6
3582
else
3583
  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3584
echo "${ECHO_T}no, using $LN_S" >&6
3585
fi
3586
 
3587
echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
3588
echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6
3589
if test "${lt_cv_deplibs_check_method+set}" = set; then
3590
  echo $ECHO_N "(cached) $ECHO_C" >&6
3591
else
3592
  lt_cv_file_magic_cmd='$MAGIC_CMD'
3593
lt_cv_file_magic_test_file=
3594
lt_cv_deplibs_check_method='unknown'
3595
# Need to set the preceding variable on all platforms that support
3596
# interlibrary dependencies.
3597
# 'none' -- dependencies not supported.
3598
# `unknown' -- same as none, but documents that we really don't know.
3599
# 'pass_all' -- all dependencies passed with no checks.
3600
# 'test_compile' -- check by making test program.
3601
# 'file_magic [regex]' -- check by looking for files in library path
3602
# which responds to the $file_magic_cmd with a given egrep regex.
3603
# If you have `file' or equivalent on your system and you're not sure
3604
# whether `pass_all' will *always* work, you probably want this one.
3605
 
3606
case $host_os in
3607
aix*)
3608
  lt_cv_deplibs_check_method=pass_all
3609
  ;;
3610
 
3611
beos*)
3612
  lt_cv_deplibs_check_method=pass_all
3613
  ;;
3614
 
3615
bsdi4*)
3616
  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
3617
  lt_cv_file_magic_cmd='/usr/bin/file -L'
3618
  lt_cv_file_magic_test_file=/shlib/libc.so
3619
  ;;
3620
 
3621
cygwin* | mingw* |pw32*)
3622
  lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
3623
  lt_cv_file_magic_cmd='$OBJDUMP -f'
3624
  ;;
3625
 
3626
darwin* | rhapsody*)
3627
  # this will be overwritten by pass_all, but leave it in just in case
3628
  lt_cv_deplibs_check_method='file_magic Mach-O dynamically linked shared library'
3629
  lt_cv_file_magic_cmd='/usr/bin/file -L'
3630
  case "$host_os" in
3631
  rhapsody* | darwin1.012)
3632
    lt_cv_file_magic_test_file='/System/Library/Frameworks/System.framework/System'
3633
    ;;
3634
  *) # Darwin 1.3 on
3635
    lt_cv_file_magic_test_file='/usr/lib/libSystem.dylib'
3636
    ;;
3637
  esac
3638
  lt_cv_deplibs_check_method=pass_all
3639
  ;;
3640
 
3641
freebsd* | kfreebsd*-gnu)
3642
  if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
3643
    case $host_cpu in
3644
    i*86 )
3645
      # Not sure whether the presence of OpenBSD here was a mistake.
3646
      # Let's accept both of them until this is cleared up.
3647
      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[3-9]86 (compact )?demand paged shared library'
3648
      lt_cv_file_magic_cmd=/usr/bin/file
3649
      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
3650
      ;;
3651
    esac
3652
  else
3653
    lt_cv_deplibs_check_method=pass_all
3654
  fi
3655
  ;;
3656
 
3657
gnu*)
3658
  lt_cv_deplibs_check_method=pass_all
3659
  ;;
3660
 
3661
hpux10.20*|hpux11*)
3662
  case $host_cpu in
3663
  hppa*)
3664
    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library'
3665
    lt_cv_file_magic_cmd=/usr/bin/file
3666
    lt_cv_file_magic_test_file=/usr/lib/libc.sl
3667
    ;;
3668
  ia64*)
3669
    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
3670
    lt_cv_file_magic_cmd=/usr/bin/file
3671
    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
3672
    ;;
3673
  esac
3674
  ;;
3675
 
3676
irix5* | irix6*)
3677
  case $host_os in
3678
  irix5*)
3679
    # this will be overridden with pass_all, but let us keep it just in case
3680
    lt_cv_deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1"
3681
    ;;
3682
  *)
3683
    case $LD in
3684
    *-32|*"-32 ") libmagic=32-bit;;
3685
    *-n32|*"-n32 ") libmagic=N32;;
3686
    *-64|*"-64 ") libmagic=64-bit;;
3687
    *) libmagic=never-match;;
3688
    esac
3689
    # this will be overridden with pass_all, but let us keep it just in case
3690
    lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[1234] dynamic lib MIPS - version 1"
3691
    ;;
3692
  esac
3693
  lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*`
3694
  lt_cv_deplibs_check_method=pass_all
3695
  ;;
3696
 
3697
# This must be Linux ELF.
3698
linux-gnu*)
3699
  lt_cv_deplibs_check_method=pass_all
3700
  ;;
3701
 
3702
netbsd* | knetbsd*-gnu)
3703
  if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
3704
    lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so\.[0-9]+\.[0-9]+$'
3705
  else
3706
    lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so$'
3707
  fi
3708
  ;;
3709
 
3710
newsos6)
3711
  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
3712
  lt_cv_file_magic_cmd=/usr/bin/file
3713
  lt_cv_file_magic_test_file=/usr/lib/libnls.so
3714
  ;;
3715
 
3716
osf3* | osf4* | osf5*)
3717
  # this will be overridden with pass_all, but let us keep it just in case
3718
  lt_cv_deplibs_check_method='file_magic COFF format alpha shared library'
3719
  lt_cv_file_magic_test_file=/shlib/libc.so
3720
  lt_cv_deplibs_check_method=pass_all
3721
  ;;
3722
 
3723
sco3.2v5*)
3724
  lt_cv_deplibs_check_method=pass_all
3725
  ;;
3726
 
3727
solaris*)
3728
  lt_cv_deplibs_check_method=pass_all
3729
  lt_cv_file_magic_test_file=/lib/libc.so
3730
  ;;
3731
 
3732
sysv5uw[78]* | sysv4*uw2*)
3733
  lt_cv_deplibs_check_method=pass_all
3734
  ;;
3735
 
3736
sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
3737
  case $host_vendor in
3738
  ncr)
3739
    lt_cv_deplibs_check_method=pass_all
3740
    ;;
3741
  motorola)
3742
    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
3743
    lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
3744
    ;;
3745
  esac
3746
  ;;
3747
esac
3748
 
3749
fi
3750
echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
3751
echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6
3752
file_magic_cmd=$lt_cv_file_magic_cmd
3753
deplibs_check_method=$lt_cv_deplibs_check_method
3754
 
3755
 
3756
 
3757
 
3758
 
3759
# Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
3760
 
3761
# find the maximum length of command line arguments
3762
echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
3763
echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6
3764
if test "${lt_cv_sys_max_cmd_len+set}" = set; then
3765
  echo $ECHO_N "(cached) $ECHO_C" >&6
3766
else
3767
    i=0
3768
  teststring="ABCD"
3769
 
3770
  case $build_os in
3771
  msdosdjgpp*)
3772
    # On DJGPP, this test can blow up pretty badly due to problems in libc
3773
    # (any single argument exceeding 2000 bytes causes a buffer overrun
3774
    # during glob expansion).  Even if it were fixed, the result of this
3775
    # check would be larger than it should be.
3776
    lt_cv_sys_max_cmd_len=12288;    # 12K is about right
3777
    ;;
3778
 
3779
  cygwin* | mingw*)
3780
    # On Win9x/ME, this test blows up -- it succeeds, but takes
3781
    # about 5 minutes as the teststring grows exponentially.
3782
    # Worse, since 9x/ME are not pre-emptively multitasking,
3783
    # you end up with a "frozen" computer, even though with patience
3784
    # the test eventually succeeds (with a max line length of 256k).
3785
    # Instead, let's just punt: use the minimum linelength reported by
3786
    # all of the supported platforms: 8192 (on NT/2K/XP).
3787
    lt_cv_sys_max_cmd_len=8192;
3788
    ;;
3789
 
3790
  amigaos*)
3791
    # On AmigaOS with pdksh, this test takes hours, literally.
3792
    # So we just punt and use a minimum line length of 8192.
3793
    lt_cv_sys_max_cmd_len=8192;
3794
    ;;
3795
 
3796
  netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
3797
    # This has been around since 386BSD, at least.  Likely further.
3798
    if test -x /sbin/sysctl; then
3799
      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
3800
    elif test -x /usr/sbin/sysctl; then
3801
      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
3802
    else
3803
      lt_cv_sys_max_cmd_len=65536 # usable default for *BSD
3804
    fi
3805
    # And add a safety zone
3806
    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
3807
    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
3808
    ;;
3809
  esac
3810
 
3811
fi
3812
 
3813
if test -n "$lt_cv_sys_max_cmd_len" ; then
3814
  echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
3815
echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6
3816
else
3817
  echo "$as_me:$LINENO: result: none" >&5
3818
echo "${ECHO_T}none" >&6
3819
fi
3820
 
3821
 
3822
# Only perform the check for file, if the check method requires it
3823
case $deplibs_check_method in
3824
file_magic*)
3825
  if test "$file_magic_cmd" = '$MAGIC_CMD'; then
3826
    echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
3827
echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6
3828
if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
3829
  echo $ECHO_N "(cached) $ECHO_C" >&6
3830
else
3831
  case $MAGIC_CMD in
3832
  /*)
3833
  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
3834
  ;;
3835
  ?:/*)
3836
  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
3837
  ;;
3838
  *)
3839
  ac_save_MAGIC_CMD="$MAGIC_CMD"
3840
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3841
  ac_dummy="/usr/bin:$PATH"
3842
  for ac_dir in $ac_dummy; do
3843
    test -z "$ac_dir" && ac_dir=.
3844
    if test -f $ac_dir/${ac_tool_prefix}file; then
3845
      lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
3846
      if test -n "$file_magic_test_file"; then
3847
        case $deplibs_check_method in
3848
        "file_magic "*)
3849
          file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
3850
          MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
3851
          if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
3852
            egrep "$file_magic_regex" > /dev/null; then
3853
            :
3854
          else
3855
            cat <&2
3856
 
3857
*** Warning: the command libtool uses to detect shared libraries,
3858
*** $file_magic_cmd, produces output that libtool cannot recognize.
3859
*** The result is that libtool may fail to recognize shared libraries
3860
*** as such.  This will affect the creation of libtool libraries that
3861
*** depend on shared libraries, but programs linked with such libtool
3862
*** libraries will work regardless of this problem.  Nevertheless, you
3863
*** may want to report the problem to your system manager and/or to
3864
*** bug-libtool@gnu.org
3865
 
3866
EOF
3867
          fi ;;
3868
        esac
3869
      fi
3870
      break
3871
    fi
3872
  done
3873
  IFS="$ac_save_ifs"
3874
  MAGIC_CMD="$ac_save_MAGIC_CMD"
3875
  ;;
3876
esac
3877
fi
3878
 
3879
MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
3880
if test -n "$MAGIC_CMD"; then
3881
  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
3882
echo "${ECHO_T}$MAGIC_CMD" >&6
3883
else
3884
  echo "$as_me:$LINENO: result: no" >&5
3885
echo "${ECHO_T}no" >&6
3886
fi
3887
 
3888
if test -z "$lt_cv_path_MAGIC_CMD"; then
3889
  if test -n "$ac_tool_prefix"; then
3890
    echo "$as_me:$LINENO: checking for file" >&5
3891
echo $ECHO_N "checking for file... $ECHO_C" >&6
3892
if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
3893
  echo $ECHO_N "(cached) $ECHO_C" >&6
3894
else
3895
  case $MAGIC_CMD in
3896
  /*)
3897
  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
3898
  ;;
3899
  ?:/*)
3900
  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
3901
  ;;
3902
  *)
3903
  ac_save_MAGIC_CMD="$MAGIC_CMD"
3904
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3905
  ac_dummy="/usr/bin:$PATH"
3906
  for ac_dir in $ac_dummy; do
3907
    test -z "$ac_dir" && ac_dir=.
3908
    if test -f $ac_dir/file; then
3909
      lt_cv_path_MAGIC_CMD="$ac_dir/file"
3910
      if test -n "$file_magic_test_file"; then
3911
        case $deplibs_check_method in
3912
        "file_magic "*)
3913
          file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
3914
          MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
3915
          if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
3916
            egrep "$file_magic_regex" > /dev/null; then
3917
            :
3918
          else
3919
            cat <&2
3920
 
3921
*** Warning: the command libtool uses to detect shared libraries,
3922
*** $file_magic_cmd, produces output that libtool cannot recognize.
3923
*** The result is that libtool may fail to recognize shared libraries
3924
*** as such.  This will affect the creation of libtool libraries that
3925
*** depend on shared libraries, but programs linked with such libtool
3926
*** libraries will work regardless of this problem.  Nevertheless, you
3927
*** may want to report the problem to your system manager and/or to
3928
*** bug-libtool@gnu.org
3929
 
3930
EOF
3931
          fi ;;
3932
        esac
3933
      fi
3934
      break
3935
    fi
3936
  done
3937
  IFS="$ac_save_ifs"
3938
  MAGIC_CMD="$ac_save_MAGIC_CMD"
3939
  ;;
3940
esac
3941
fi
3942
 
3943
MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
3944
if test -n "$MAGIC_CMD"; then
3945
  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
3946
echo "${ECHO_T}$MAGIC_CMD" >&6
3947
else
3948
  echo "$as_me:$LINENO: result: no" >&5
3949
echo "${ECHO_T}no" >&6
3950
fi
3951
 
3952
  else
3953
    MAGIC_CMD=:
3954
  fi
3955
fi
3956
 
3957
  fi
3958
  ;;
3959
esac
3960
 
3961
if test -n "$ac_tool_prefix"; then
3962
  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3963
set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3964
echo "$as_me:$LINENO: checking for $ac_word" >&5
3965
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3966
if test "${ac_cv_prog_RANLIB+set}" = set; then
3967
  echo $ECHO_N "(cached) $ECHO_C" >&6
3968
else
3969
  if test -n "$RANLIB"; then
3970
  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3971
else
3972
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3973
for as_dir in $PATH
3974
do
3975
  IFS=$as_save_IFS
3976
  test -z "$as_dir" && as_dir=.
3977
  for ac_exec_ext in '' $ac_executable_extensions; do
3978
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3979
    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3980
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3981
    break 2
3982
  fi
3983
done
3984
done
3985
 
3986
fi
3987
fi
3988
RANLIB=$ac_cv_prog_RANLIB
3989
if test -n "$RANLIB"; then
3990
  echo "$as_me:$LINENO: result: $RANLIB" >&5
3991
echo "${ECHO_T}$RANLIB" >&6
3992
else
3993
  echo "$as_me:$LINENO: result: no" >&5
3994
echo "${ECHO_T}no" >&6
3995
fi
3996
 
3997
fi
3998
if test -z "$ac_cv_prog_RANLIB"; then
3999
  ac_ct_RANLIB=$RANLIB
4000
  # Extract the first word of "ranlib", so it can be a program name with args.
4001
set dummy ranlib; ac_word=$2
4002
echo "$as_me:$LINENO: checking for $ac_word" >&5
4003
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4004
if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
4005
  echo $ECHO_N "(cached) $ECHO_C" >&6
4006
else
4007
  if test -n "$ac_ct_RANLIB"; then
4008
  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
4009
else
4010
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4011
for as_dir in $PATH
4012
do
4013
  IFS=$as_save_IFS
4014
  test -z "$as_dir" && as_dir=.
4015
  for ac_exec_ext in '' $ac_executable_extensions; do
4016
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4017
    ac_cv_prog_ac_ct_RANLIB="ranlib"
4018
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4019
    break 2
4020
  fi
4021
done
4022
done
4023
 
4024
  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
4025
fi
4026
fi
4027
ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
4028
if test -n "$ac_ct_RANLIB"; then
4029
  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
4030
echo "${ECHO_T}$ac_ct_RANLIB" >&6
4031
else
4032
  echo "$as_me:$LINENO: result: no" >&5
4033
echo "${ECHO_T}no" >&6
4034
fi
4035
 
4036
  RANLIB=$ac_ct_RANLIB
4037
else
4038
  RANLIB="$ac_cv_prog_RANLIB"
4039
fi
4040
 
4041
if test -n "$ac_tool_prefix"; then
4042
  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
4043
set dummy ${ac_tool_prefix}strip; ac_word=$2
4044
echo "$as_me:$LINENO: checking for $ac_word" >&5
4045
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4046
if test "${ac_cv_prog_STRIP+set}" = set; then
4047
  echo $ECHO_N "(cached) $ECHO_C" >&6
4048
else
4049
  if test -n "$STRIP"; then
4050
  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
4051
else
4052
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4053
for as_dir in $PATH
4054
do
4055
  IFS=$as_save_IFS
4056
  test -z "$as_dir" && as_dir=.
4057
  for ac_exec_ext in '' $ac_executable_extensions; do
4058
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4059
    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
4060
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4061
    break 2
4062
  fi
4063
done
4064
done
4065
 
4066
fi
4067
fi
4068
STRIP=$ac_cv_prog_STRIP
4069
if test -n "$STRIP"; then
4070
  echo "$as_me:$LINENO: result: $STRIP" >&5
4071
echo "${ECHO_T}$STRIP" >&6
4072
else
4073
  echo "$as_me:$LINENO: result: no" >&5
4074
echo "${ECHO_T}no" >&6
4075
fi
4076
 
4077
fi
4078
if test -z "$ac_cv_prog_STRIP"; then
4079
  ac_ct_STRIP=$STRIP
4080
  # Extract the first word of "strip", so it can be a program name with args.
4081
set dummy strip; ac_word=$2
4082
echo "$as_me:$LINENO: checking for $ac_word" >&5
4083
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4084
if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
4085
  echo $ECHO_N "(cached) $ECHO_C" >&6
4086
else
4087
  if test -n "$ac_ct_STRIP"; then
4088
  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
4089
else
4090
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4091
for as_dir in $PATH
4092
do
4093
  IFS=$as_save_IFS
4094
  test -z "$as_dir" && as_dir=.
4095
  for ac_exec_ext in '' $ac_executable_extensions; do
4096
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4097
    ac_cv_prog_ac_ct_STRIP="strip"
4098
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4099
    break 2
4100
  fi
4101
done
4102
done
4103
 
4104
  test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
4105
fi
4106
fi
4107
ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
4108
if test -n "$ac_ct_STRIP"; then
4109
  echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
4110
echo "${ECHO_T}$ac_ct_STRIP" >&6
4111
else
4112
  echo "$as_me:$LINENO: result: no" >&5
4113
echo "${ECHO_T}no" >&6
4114
fi
4115
 
4116
  STRIP=$ac_ct_STRIP
4117
else
4118
  STRIP="$ac_cv_prog_STRIP"
4119
fi
4120
 
4121
 
4122
# Check for any special flags to pass to ltconfig.
4123
libtool_flags="--cache-file=$cache_file"
4124
test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
4125
test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
4126
test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
4127
test "$GCC" = yes && libtool_flags="$libtool_flags --with-gcc"
4128
test "$lt_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
4129
 
4130
 
4131
# Check whether --enable-libtool-lock or --disable-libtool-lock was given.
4132
if test "${enable_libtool_lock+set}" = set; then
4133
  enableval="$enable_libtool_lock"
4134
 
4135
fi;
4136
test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
4137
test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
4138
 
4139
 
4140
# Check whether --with-pic or --without-pic was given.
4141
if test "${with_pic+set}" = set; then
4142
  withval="$with_pic"
4143
  pic_mode="$withval"
4144
else
4145
  pic_mode=default
4146
fi;
4147
test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
4148
test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
4149
 
4150
# Some flags need to be propagated to the compiler or linker for good
4151
# libtool support.
4152
case $host in
4153
*-*-irix6*)
4154
  # Find out which ABI we are using.
4155
  echo '#line 4155 "configure"' > conftest.$ac_ext
4156
  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4157
  (eval $ac_compile) 2>&5
4158
  ac_status=$?
4159
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4160
  (exit $ac_status); }; then
4161
   if test "$lt_cv_prog_gnu_ld" = yes; then
4162
    case `/usr/bin/file conftest.$ac_objext` in
4163
    *32-bit*)
4164
      LD="${LD-ld} -melf32bsmip"
4165
      ;;
4166
    *N32*)
4167
      LD="${LD-ld} -melf32bmipn32"
4168
      ;;
4169
    *64-bit*)
4170
      LD="${LD-ld} -melf64bmip"
4171
      ;;
4172
    esac
4173
   else
4174
    case `/usr/bin/file conftest.$ac_objext` in
4175
    *32-bit*)
4176
      LD="${LD-ld} -32"
4177
      ;;
4178
    *N32*)
4179
      LD="${LD-ld} -n32"
4180
      ;;
4181
    *64-bit*)
4182
      LD="${LD-ld} -64"
4183
      ;;
4184
    esac
4185
   fi
4186
  fi
4187
  rm -rf conftest*
4188
  ;;
4189
 
4190
ia64-*-hpux*)
4191
  # Find out which ABI we are using.
4192
  echo 'int i;' > conftest.$ac_ext
4193
  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4194
  (eval $ac_compile) 2>&5
4195
  ac_status=$?
4196
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4197
  (exit $ac_status); }; then
4198
    case "`/usr/bin/file conftest.o`" in
4199
    *ELF-32*)
4200
      HPUX_IA64_MODE="32"
4201
      ;;
4202
    *ELF-64*)
4203
      HPUX_IA64_MODE="64"
4204
      ;;
4205
    esac
4206
  fi
4207
  rm -rf conftest*
4208
  ;;
4209
 
4210
x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)
4211
  # Find out which ABI we are using.
4212
  echo 'int i;' > conftest.$ac_ext
4213
  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4214
  (eval $ac_compile) 2>&5
4215
  ac_status=$?
4216
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4217
  (exit $ac_status); }; then
4218
    case "`/usr/bin/file conftest.o`" in
4219
    *32-bit*)
4220
      case $host in
4221
        x86_64-*linux*)
4222
          LD="${LD-ld} -m elf_i386"
4223
          ;;
4224
        ppc64-*linux*|powerpc64-*linux*)
4225
          LD="${LD-ld} -m elf32ppclinux"
4226
          ;;
4227
        s390x-*linux*)
4228
          LD="${LD-ld} -m elf_s390"
4229
          ;;
4230
        sparc64-*linux*)
4231
          LD="${LD-ld} -m elf32_sparc"
4232
          ;;
4233
      esac
4234
      ;;
4235
    *64-bit*)
4236
      case $host in
4237
        x86_64-*linux*)
4238
          LD="${LD-ld} -m elf_x86_64"
4239
          ;;
4240
        ppc*-*linux*|powerpc*-*linux*)
4241
          LD="${LD-ld} -m elf64ppc"
4242
          ;;
4243
        s390*-*linux*)
4244
          LD="${LD-ld} -m elf64_s390"
4245
          ;;
4246
        sparc*-*linux*)
4247
          LD="${LD-ld} -m elf64_sparc"
4248
          ;;
4249
      esac
4250
      ;;
4251
    esac
4252
  fi
4253
  rm -rf conftest*
4254
  ;;
4255
 
4256
*-*-sco3.2v5*)
4257
  # On SCO OpenServer 5, we need -belf to get full-featured binaries.
4258
  SAVE_CFLAGS="$CFLAGS"
4259
  CFLAGS="$CFLAGS -belf"
4260
  echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
4261
echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6
4262
if test "${lt_cv_cc_needs_belf+set}" = set; then
4263
  echo $ECHO_N "(cached) $ECHO_C" >&6
4264
else
4265
 
4266
 
4267
     ac_ext=c
4268
ac_cpp='$CPP $CPPFLAGS'
4269
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4270
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4271
ac_compiler_gnu=$ac_cv_c_compiler_gnu
4272
 
4273
     if test x$gcc_no_link = xyes; then
4274
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
4275
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
4276
   { (exit 1); exit 1; }; }
4277
fi
4278
cat >conftest.$ac_ext <<_ACEOF
4279
/* confdefs.h.  */
4280
_ACEOF
4281
cat confdefs.h >>conftest.$ac_ext
4282
cat >>conftest.$ac_ext <<_ACEOF
4283
/* end confdefs.h.  */
4284
 
4285
int
4286
main ()
4287
{
4288
 
4289
  ;
4290
  return 0;
4291
}
4292
_ACEOF
4293
rm -f conftest.$ac_objext conftest$ac_exeext
4294
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4295
  (eval $ac_link) 2>conftest.er1
4296
  ac_status=$?
4297
  grep -v '^ *+' conftest.er1 >conftest.err
4298
  rm -f conftest.er1
4299
  cat conftest.err >&5
4300
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4301
  (exit $ac_status); } &&
4302
         { ac_try='test -z "$ac_c_werror_flag"
4303
                         || test ! -s conftest.err'
4304
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4305
  (eval $ac_try) 2>&5
4306
  ac_status=$?
4307
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4308
  (exit $ac_status); }; } &&
4309
         { ac_try='test -s conftest$ac_exeext'
4310
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4311
  (eval $ac_try) 2>&5
4312
  ac_status=$?
4313
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4314
  (exit $ac_status); }; }; then
4315
  lt_cv_cc_needs_belf=yes
4316
else
4317
  echo "$as_me: failed program was:" >&5
4318
sed 's/^/| /' conftest.$ac_ext >&5
4319
 
4320
lt_cv_cc_needs_belf=no
4321
fi
4322
rm -f conftest.err conftest.$ac_objext \
4323
      conftest$ac_exeext conftest.$ac_ext
4324
     ac_ext=c
4325
ac_cpp='$CPP $CPPFLAGS'
4326
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4327
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4328
ac_compiler_gnu=$ac_cv_c_compiler_gnu
4329
 
4330
fi
4331
echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
4332
echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6
4333
  if test x"$lt_cv_cc_needs_belf" != x"yes"; then
4334
    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
4335
    CFLAGS="$SAVE_CFLAGS"
4336
  fi
4337
  ;;
4338
 
4339
 
4340
esac
4341
 
4342
 
4343
# Save cache, so that ltconfig can load it
4344
cat >confcache <<\_ACEOF
4345
# This file is a shell script that caches the results of configure
4346
# tests run on this system so they can be shared between configure
4347
# scripts and configure runs, see configure's option --config-cache.
4348
# It is not useful on other systems.  If it contains results you don't
4349
# want to keep, you may remove or edit it.
4350
#
4351
# config.status only pays attention to the cache file if you give it
4352
# the --recheck option to rerun configure.
4353
#
4354
# `ac_cv_env_foo' variables (set or unset) will be overridden when
4355
# loading this file, other *unset* `ac_cv_foo' will be assigned the
4356
# following values.
4357
 
4358
_ACEOF
4359
 
4360
# The following way of writing the cache mishandles newlines in values,
4361
# but we know of no workaround that is simple, portable, and efficient.
4362
# So, don't put newlines in cache variables' values.
4363
# Ultrix sh set writes to stderr and can't be redirected directly,
4364
# and sets the high bit in the cache file unless we assign to the vars.
4365
{
4366
  (set) 2>&1 |
4367
    case `(ac_space=' '; set | grep ac_space) 2>&1` in
4368
    *ac_space=\ *)
4369
      # `set' does not quote correctly, so add quotes (double-quote
4370
      # substitution turns \\\\ into \\, and sed turns \\ into \).
4371
      sed -n \
4372
        "s/'/'\\\\''/g;
4373
          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
4374
      ;;
4375
    *)
4376
      # `set' quotes correctly as required by POSIX, so do not add quotes.
4377
      sed -n \
4378
        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
4379
      ;;
4380
    esac;
4381
} |
4382
  sed '
4383
     t clear
4384
     : clear
4385
     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
4386
     t end
4387
     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
4388
     : end' >>confcache
4389
if diff $cache_file confcache >/dev/null 2>&1; then :; else
4390
  if test -w $cache_file; then
4391
    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
4392
    cat confcache >$cache_file
4393
  else
4394
    echo "not updating unwritable cache $cache_file"
4395
  fi
4396
fi
4397
rm -f confcache
4398
 
4399
# Actually configure libtool.  ac_aux_dir is where install-sh is found.
4400
AR="$AR" LTCC="$CC" CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
4401
MAGIC_CMD="$MAGIC_CMD" LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
4402
LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
4403
AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
4404
objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
4405
deplibs_check_method="$deplibs_check_method" file_magic_cmd="$file_magic_cmd" \
4406
${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
4407
$libtool_flags --no-verify --build="$build" $ac_aux_dir/ltmain.sh $host \
4408
|| { { echo "$as_me:$LINENO: error: libtool configure failed" >&5
4409
echo "$as_me: error: libtool configure failed" >&2;}
4410
   { (exit 1); exit 1; }; }
4411
 
4412
# Reload cache, that may have been modified by ltconfig
4413
if test -r "$cache_file"; then
4414
  # Some versions of bash will fail to source /dev/null (special
4415
  # files actually), so we avoid doing that.
4416
  if test -f "$cache_file"; then
4417
    { echo "$as_me:$LINENO: loading cache $cache_file" >&5
4418
echo "$as_me: loading cache $cache_file" >&6;}
4419
    case $cache_file in
4420
      [\\/]* | ?:[\\/]* ) . $cache_file;;
4421
      *)                      . ./$cache_file;;
4422
    esac
4423
  fi
4424
else
4425
  { echo "$as_me:$LINENO: creating cache $cache_file" >&5
4426
echo "$as_me: creating cache $cache_file" >&6;}
4427
  >$cache_file
4428
fi
4429
 
4430
 
4431
# This can be used to rebuild libtool when needed
4432
LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh $ac_aux_dir/ltcf-c.sh"
4433
 
4434
# Always use our own libtool.
4435
LIBTOOL='$(SHELL) $(top_builddir)/libtool'
4436
 
4437
# Redirect the config.log output again, so that the ltconfig log is not
4438
# clobbered by the next message.
4439
exec 5>>./config.log
4440
 
4441
 
4442
 
4443
 
4444
 
4445
 
4446
 
4447
 
4448
#AC_MSG_NOTICE([====== Finished libtool configuration]) ; sleep 10
4449
 
4450
# We need gfortran to compile parts of the library
4451
#AC_PROG_FC(gfortran)
4452
FC="$GFORTRAN"
4453
ac_ext=${FC_SRCEXT-f}
4454
ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4455
ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4456
ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4457
if test -n "$ac_tool_prefix"; then
4458
  for ac_prog in gfortran
4459
  do
4460
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4461
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4462
echo "$as_me:$LINENO: checking for $ac_word" >&5
4463
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4464
if test "${ac_cv_prog_FC+set}" = set; then
4465
  echo $ECHO_N "(cached) $ECHO_C" >&6
4466
else
4467
  if test -n "$FC"; then
4468
  ac_cv_prog_FC="$FC" # Let the user override the test.
4469
else
4470
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4471
for as_dir in $PATH
4472
do
4473
  IFS=$as_save_IFS
4474
  test -z "$as_dir" && as_dir=.
4475
  for ac_exec_ext in '' $ac_executable_extensions; do
4476
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4477
    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
4478
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4479
    break 2
4480
  fi
4481
done
4482
done
4483
 
4484
fi
4485
fi
4486
FC=$ac_cv_prog_FC
4487
if test -n "$FC"; then
4488
  echo "$as_me:$LINENO: result: $FC" >&5
4489
echo "${ECHO_T}$FC" >&6
4490
else
4491
  echo "$as_me:$LINENO: result: no" >&5
4492
echo "${ECHO_T}no" >&6
4493
fi
4494
 
4495
    test -n "$FC" && break
4496
  done
4497
fi
4498
if test -z "$FC"; then
4499
  ac_ct_FC=$FC
4500
  for ac_prog in gfortran
4501
do
4502
  # Extract the first word of "$ac_prog", so it can be a program name with args.
4503
set dummy $ac_prog; ac_word=$2
4504
echo "$as_me:$LINENO: checking for $ac_word" >&5
4505
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4506
if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
4507
  echo $ECHO_N "(cached) $ECHO_C" >&6
4508
else
4509
  if test -n "$ac_ct_FC"; then
4510
  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
4511
else
4512
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4513
for as_dir in $PATH
4514
do
4515
  IFS=$as_save_IFS
4516
  test -z "$as_dir" && as_dir=.
4517
  for ac_exec_ext in '' $ac_executable_extensions; do
4518
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4519
    ac_cv_prog_ac_ct_FC="$ac_prog"
4520
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4521
    break 2
4522
  fi
4523
done
4524
done
4525
 
4526
fi
4527
fi
4528
ac_ct_FC=$ac_cv_prog_ac_ct_FC
4529
if test -n "$ac_ct_FC"; then
4530
  echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
4531
echo "${ECHO_T}$ac_ct_FC" >&6
4532
else
4533
  echo "$as_me:$LINENO: result: no" >&5
4534
echo "${ECHO_T}no" >&6
4535
fi
4536
 
4537
  test -n "$ac_ct_FC" && break
4538
done
4539
 
4540
  FC=$ac_ct_FC
4541
fi
4542
 
4543
 
4544
# Provide some information about the compiler.
4545
echo "$as_me:4545:" \
4546
     "checking for Fortran compiler version" >&5
4547
ac_compiler=`set X $ac_compile; echo $2`
4548
{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version &5\"") >&5
4549
  (eval $ac_compiler --version &5) 2>&5
4550
  ac_status=$?
4551
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4552
  (exit $ac_status); }
4553
{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v &5\"") >&5
4554
  (eval $ac_compiler -v &5) 2>&5
4555
  ac_status=$?
4556
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4557
  (exit $ac_status); }
4558
{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V &5\"") >&5
4559
  (eval $ac_compiler -V &5) 2>&5
4560
  ac_status=$?
4561
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4562
  (exit $ac_status); }
4563
rm -f a.out
4564
 
4565
# If we don't use `.F' as extension, the preprocessor is not run on the
4566
# input file.  (Note that this only needs to work for GNU compilers.)
4567
ac_save_ext=$ac_ext
4568
ac_ext=F
4569
echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
4570
echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
4571
if test "${ac_cv_fc_compiler_gnu+set}" = set; then
4572
  echo $ECHO_N "(cached) $ECHO_C" >&6
4573
else
4574
  cat >conftest.$ac_ext <<_ACEOF
4575
      program main
4576
#ifndef __GNUC__
4577
       choke me
4578
#endif
4579
 
4580
      end
4581
_ACEOF
4582
rm -f conftest.$ac_objext
4583
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4584
  (eval $ac_compile) 2>conftest.er1
4585
  ac_status=$?
4586
  grep -v '^ *+' conftest.er1 >conftest.err
4587
  rm -f conftest.er1
4588
  cat conftest.err >&5
4589
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4590
  (exit $ac_status); } &&
4591
         { ac_try='test -z "$ac_fc_werror_flag"
4592
                         || test ! -s conftest.err'
4593
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4594
  (eval $ac_try) 2>&5
4595
  ac_status=$?
4596
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4597
  (exit $ac_status); }; } &&
4598
         { ac_try='test -s conftest.$ac_objext'
4599
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4600
  (eval $ac_try) 2>&5
4601
  ac_status=$?
4602
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4603
  (exit $ac_status); }; }; then
4604
  ac_compiler_gnu=yes
4605
else
4606
  echo "$as_me: failed program was:" >&5
4607
sed 's/^/| /' conftest.$ac_ext >&5
4608
 
4609
ac_compiler_gnu=no
4610
fi
4611
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4612
ac_cv_fc_compiler_gnu=$ac_compiler_gnu
4613
 
4614
fi
4615
echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
4616
echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
4617
ac_ext=$ac_save_ext
4618
ac_test_FFLAGS=${FCFLAGS+set}
4619
ac_save_FFLAGS=$FCFLAGS
4620
FCFLAGS=
4621
echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
4622
echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
4623
if test "${ac_cv_prog_fc_g+set}" = set; then
4624
  echo $ECHO_N "(cached) $ECHO_C" >&6
4625
else
4626
  FCFLAGS=-g
4627
cat >conftest.$ac_ext <<_ACEOF
4628
      program main
4629
 
4630
      end
4631
_ACEOF
4632
rm -f conftest.$ac_objext
4633
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4634
  (eval $ac_compile) 2>conftest.er1
4635
  ac_status=$?
4636
  grep -v '^ *+' conftest.er1 >conftest.err
4637
  rm -f conftest.er1
4638
  cat conftest.err >&5
4639
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4640
  (exit $ac_status); } &&
4641
         { ac_try='test -z "$ac_fc_werror_flag"
4642
                         || test ! -s conftest.err'
4643
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4644
  (eval $ac_try) 2>&5
4645
  ac_status=$?
4646
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4647
  (exit $ac_status); }; } &&
4648
         { ac_try='test -s conftest.$ac_objext'
4649
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4650
  (eval $ac_try) 2>&5
4651
  ac_status=$?
4652
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4653
  (exit $ac_status); }; }; then
4654
  ac_cv_prog_fc_g=yes
4655
else
4656
  echo "$as_me: failed program was:" >&5
4657
sed 's/^/| /' conftest.$ac_ext >&5
4658
 
4659
ac_cv_prog_fc_g=no
4660
fi
4661
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4662
 
4663
fi
4664
echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
4665
echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
4666
if test "$ac_test_FFLAGS" = set; then
4667
  FCFLAGS=$ac_save_FFLAGS
4668
elif test $ac_cv_prog_fc_g = yes; then
4669
  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4670
    FCFLAGS="-g -O2"
4671
  else
4672
    FCFLAGS="-g"
4673
  fi
4674
else
4675
  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4676
    FCFLAGS="-O2"
4677
  else
4678
    FCFLAGS=
4679
  fi
4680
fi
4681
 
4682
ac_ext=c
4683
ac_cpp='$CPP $CPPFLAGS'
4684
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4685
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4686
ac_compiler_gnu=$ac_cv_c_compiler_gnu
4687
 
4688
 
4689
# extra LD Flags which are required for targets
4690
case "${host}" in
4691
  *-darwin*)
4692
    # Darwin needs -single_module when linking libgfortran
4693
    extra_ldflags_libgfortran=-Wl,-single_module
4694
    ;;
4695
esac
4696
 
4697
 
4698
# Check whether --enable-largefile or --disable-largefile was given.
4699
if test "${enable_largefile+set}" = set; then
4700
  enableval="$enable_largefile"
4701
 
4702
fi;
4703
if test "$enable_largefile" != no; then
4704
 
4705
  echo "$as_me:$LINENO: checking for special C compiler options needed for large files" >&5
4706
echo $ECHO_N "checking for special C compiler options needed for large files... $ECHO_C" >&6
4707
if test "${ac_cv_sys_largefile_CC+set}" = set; then
4708
  echo $ECHO_N "(cached) $ECHO_C" >&6
4709
else
4710
  ac_cv_sys_largefile_CC=no
4711
     if test "$GCC" != yes; then
4712
       ac_save_CC=$CC
4713
       while :; do
4714
         # IRIX 6.2 and later do not support large files by default,
4715
         # so use the C compiler's -n32 option if that helps.
4716
         cat >conftest.$ac_ext <<_ACEOF
4717
/* confdefs.h.  */
4718
_ACEOF
4719
cat confdefs.h >>conftest.$ac_ext
4720
cat >>conftest.$ac_ext <<_ACEOF
4721
/* end confdefs.h.  */
4722
#include 
4723
 /* Check that off_t can represent 2**63 - 1 correctly.
4724
    We can't simply define LARGE_OFF_T to be 9223372036854775807,
4725
    since some C++ compilers masquerading as C compilers
4726
    incorrectly reject 9223372036854775807.  */
4727
#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4728
  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4729
                       && LARGE_OFF_T % 2147483647 == 1)
4730
                      ? 1 : -1];
4731
int
4732
main ()
4733
{
4734
 
4735
  ;
4736
  return 0;
4737
}
4738
_ACEOF
4739
         rm -f conftest.$ac_objext
4740
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4741
  (eval $ac_compile) 2>conftest.er1
4742
  ac_status=$?
4743
  grep -v '^ *+' conftest.er1 >conftest.err
4744
  rm -f conftest.er1
4745
  cat conftest.err >&5
4746
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4747
  (exit $ac_status); } &&
4748
         { ac_try='test -z "$ac_c_werror_flag"
4749
                         || test ! -s conftest.err'
4750
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4751
  (eval $ac_try) 2>&5
4752
  ac_status=$?
4753
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4754
  (exit $ac_status); }; } &&
4755
         { ac_try='test -s conftest.$ac_objext'
4756
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4757
  (eval $ac_try) 2>&5
4758
  ac_status=$?
4759
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4760
  (exit $ac_status); }; }; then
4761
  break
4762
else
4763
  echo "$as_me: failed program was:" >&5
4764
sed 's/^/| /' conftest.$ac_ext >&5
4765
 
4766
fi
4767
rm -f conftest.err conftest.$ac_objext
4768
         CC="$CC -n32"
4769
         rm -f conftest.$ac_objext
4770
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4771
  (eval $ac_compile) 2>conftest.er1
4772
  ac_status=$?
4773
  grep -v '^ *+' conftest.er1 >conftest.err
4774
  rm -f conftest.er1
4775
  cat conftest.err >&5
4776
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4777
  (exit $ac_status); } &&
4778
         { ac_try='test -z "$ac_c_werror_flag"
4779
                         || test ! -s conftest.err'
4780
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4781
  (eval $ac_try) 2>&5
4782
  ac_status=$?
4783
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4784
  (exit $ac_status); }; } &&
4785
         { ac_try='test -s conftest.$ac_objext'
4786
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4787
  (eval $ac_try) 2>&5
4788
  ac_status=$?
4789
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4790
  (exit $ac_status); }; }; then
4791
  ac_cv_sys_largefile_CC=' -n32'; break
4792
else
4793
  echo "$as_me: failed program was:" >&5
4794
sed 's/^/| /' conftest.$ac_ext >&5
4795
 
4796
fi
4797
rm -f conftest.err conftest.$ac_objext
4798
         break
4799
       done
4800
       CC=$ac_save_CC
4801
       rm -f conftest.$ac_ext
4802
    fi
4803
fi
4804
echo "$as_me:$LINENO: result: $ac_cv_sys_largefile_CC" >&5
4805
echo "${ECHO_T}$ac_cv_sys_largefile_CC" >&6
4806
  if test "$ac_cv_sys_largefile_CC" != no; then
4807
    CC=$CC$ac_cv_sys_largefile_CC
4808
  fi
4809
 
4810
  echo "$as_me:$LINENO: checking for _FILE_OFFSET_BITS value needed for large files" >&5
4811
echo $ECHO_N "checking for _FILE_OFFSET_BITS value needed for large files... $ECHO_C" >&6
4812
if test "${ac_cv_sys_file_offset_bits+set}" = set; then
4813
  echo $ECHO_N "(cached) $ECHO_C" >&6
4814
else
4815
  while :; do
4816
  ac_cv_sys_file_offset_bits=no
4817
  cat >conftest.$ac_ext <<_ACEOF
4818
/* confdefs.h.  */
4819
_ACEOF
4820
cat confdefs.h >>conftest.$ac_ext
4821
cat >>conftest.$ac_ext <<_ACEOF
4822
/* end confdefs.h.  */
4823
#include 
4824
 /* Check that off_t can represent 2**63 - 1 correctly.
4825
    We can't simply define LARGE_OFF_T to be 9223372036854775807,
4826
    since some C++ compilers masquerading as C compilers
4827
    incorrectly reject 9223372036854775807.  */
4828
#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4829
  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4830
                       && LARGE_OFF_T % 2147483647 == 1)
4831
                      ? 1 : -1];
4832
int
4833
main ()
4834
{
4835
 
4836
  ;
4837
  return 0;
4838
}
4839
_ACEOF
4840
rm -f conftest.$ac_objext
4841
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4842
  (eval $ac_compile) 2>conftest.er1
4843
  ac_status=$?
4844
  grep -v '^ *+' conftest.er1 >conftest.err
4845
  rm -f conftest.er1
4846
  cat conftest.err >&5
4847
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4848
  (exit $ac_status); } &&
4849
         { ac_try='test -z "$ac_c_werror_flag"
4850
                         || test ! -s conftest.err'
4851
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4852
  (eval $ac_try) 2>&5
4853
  ac_status=$?
4854
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4855
  (exit $ac_status); }; } &&
4856
         { ac_try='test -s conftest.$ac_objext'
4857
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4858
  (eval $ac_try) 2>&5
4859
  ac_status=$?
4860
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4861
  (exit $ac_status); }; }; then
4862
  break
4863
else
4864
  echo "$as_me: failed program was:" >&5
4865
sed 's/^/| /' conftest.$ac_ext >&5
4866
 
4867
fi
4868
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4869
  cat >conftest.$ac_ext <<_ACEOF
4870
/* confdefs.h.  */
4871
_ACEOF
4872
cat confdefs.h >>conftest.$ac_ext
4873
cat >>conftest.$ac_ext <<_ACEOF
4874
/* end confdefs.h.  */
4875
#define _FILE_OFFSET_BITS 64
4876
#include 
4877
 /* Check that off_t can represent 2**63 - 1 correctly.
4878
    We can't simply define LARGE_OFF_T to be 9223372036854775807,
4879
    since some C++ compilers masquerading as C compilers
4880
    incorrectly reject 9223372036854775807.  */
4881
#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4882
  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4883
                       && LARGE_OFF_T % 2147483647 == 1)
4884
                      ? 1 : -1];
4885
int
4886
main ()
4887
{
4888
 
4889
  ;
4890
  return 0;
4891
}
4892
_ACEOF
4893
rm -f conftest.$ac_objext
4894
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4895
  (eval $ac_compile) 2>conftest.er1
4896
  ac_status=$?
4897
  grep -v '^ *+' conftest.er1 >conftest.err
4898
  rm -f conftest.er1
4899
  cat conftest.err >&5
4900
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4901
  (exit $ac_status); } &&
4902
         { ac_try='test -z "$ac_c_werror_flag"
4903
                         || test ! -s conftest.err'
4904
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4905
  (eval $ac_try) 2>&5
4906
  ac_status=$?
4907
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4908
  (exit $ac_status); }; } &&
4909
         { ac_try='test -s conftest.$ac_objext'
4910
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4911
  (eval $ac_try) 2>&5
4912
  ac_status=$?
4913
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4914
  (exit $ac_status); }; }; then
4915
  ac_cv_sys_file_offset_bits=64; break
4916
else
4917
  echo "$as_me: failed program was:" >&5
4918
sed 's/^/| /' conftest.$ac_ext >&5
4919
 
4920
fi
4921
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4922
  break
4923
done
4924
fi
4925
echo "$as_me:$LINENO: result: $ac_cv_sys_file_offset_bits" >&5
4926
echo "${ECHO_T}$ac_cv_sys_file_offset_bits" >&6
4927
if test "$ac_cv_sys_file_offset_bits" != no; then
4928
 
4929
cat >>confdefs.h <<_ACEOF
4930
#define _FILE_OFFSET_BITS $ac_cv_sys_file_offset_bits
4931
_ACEOF
4932
 
4933
fi
4934
rm -f conftest*
4935
  echo "$as_me:$LINENO: checking for _LARGE_FILES value needed for large files" >&5
4936
echo $ECHO_N "checking for _LARGE_FILES value needed for large files... $ECHO_C" >&6
4937
if test "${ac_cv_sys_large_files+set}" = set; then
4938
  echo $ECHO_N "(cached) $ECHO_C" >&6
4939
else
4940
  while :; do
4941
  ac_cv_sys_large_files=no
4942
  cat >conftest.$ac_ext <<_ACEOF
4943
/* confdefs.h.  */
4944
_ACEOF
4945
cat confdefs.h >>conftest.$ac_ext
4946
cat >>conftest.$ac_ext <<_ACEOF
4947
/* end confdefs.h.  */
4948
#include 
4949
 /* Check that off_t can represent 2**63 - 1 correctly.
4950
    We can't simply define LARGE_OFF_T to be 9223372036854775807,
4951
    since some C++ compilers masquerading as C compilers
4952
    incorrectly reject 9223372036854775807.  */
4953
#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4954
  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4955
                       && LARGE_OFF_T % 2147483647 == 1)
4956
                      ? 1 : -1];
4957
int
4958
main ()
4959
{
4960
 
4961
  ;
4962
  return 0;
4963
}
4964
_ACEOF
4965
rm -f conftest.$ac_objext
4966
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4967
  (eval $ac_compile) 2>conftest.er1
4968
  ac_status=$?
4969
  grep -v '^ *+' conftest.er1 >conftest.err
4970
  rm -f conftest.er1
4971
  cat conftest.err >&5
4972
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4973
  (exit $ac_status); } &&
4974
         { ac_try='test -z "$ac_c_werror_flag"
4975
                         || test ! -s conftest.err'
4976
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4977
  (eval $ac_try) 2>&5
4978
  ac_status=$?
4979
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4980
  (exit $ac_status); }; } &&
4981
         { ac_try='test -s conftest.$ac_objext'
4982
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4983
  (eval $ac_try) 2>&5
4984
  ac_status=$?
4985
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4986
  (exit $ac_status); }; }; then
4987
  break
4988
else
4989
  echo "$as_me: failed program was:" >&5
4990
sed 's/^/| /' conftest.$ac_ext >&5
4991
 
4992
fi
4993
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4994
  cat >conftest.$ac_ext <<_ACEOF
4995
/* confdefs.h.  */
4996
_ACEOF
4997
cat confdefs.h >>conftest.$ac_ext
4998
cat >>conftest.$ac_ext <<_ACEOF
4999
/* end confdefs.h.  */
5000
#define _LARGE_FILES 1
5001
#include 
5002
 /* Check that off_t can represent 2**63 - 1 correctly.
5003
    We can't simply define LARGE_OFF_T to be 9223372036854775807,
5004
    since some C++ compilers masquerading as C compilers
5005
    incorrectly reject 9223372036854775807.  */
5006
#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
5007
  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
5008
                       && LARGE_OFF_T % 2147483647 == 1)
5009
                      ? 1 : -1];
5010
int
5011
main ()
5012
{
5013
 
5014
  ;
5015
  return 0;
5016
}
5017
_ACEOF
5018
rm -f conftest.$ac_objext
5019
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5020
  (eval $ac_compile) 2>conftest.er1
5021
  ac_status=$?
5022
  grep -v '^ *+' conftest.er1 >conftest.err
5023
  rm -f conftest.er1
5024
  cat conftest.err >&5
5025
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5026
  (exit $ac_status); } &&
5027
         { ac_try='test -z "$ac_c_werror_flag"
5028
                         || test ! -s conftest.err'
5029
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5030
  (eval $ac_try) 2>&5
5031
  ac_status=$?
5032
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5033
  (exit $ac_status); }; } &&
5034
         { ac_try='test -s conftest.$ac_objext'
5035
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5036
  (eval $ac_try) 2>&5
5037
  ac_status=$?
5038
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5039
  (exit $ac_status); }; }; then
5040
  ac_cv_sys_large_files=1; break
5041
else
5042
  echo "$as_me: failed program was:" >&5
5043
sed 's/^/| /' conftest.$ac_ext >&5
5044
 
5045
fi
5046
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5047
  break
5048
done
5049
fi
5050
echo "$as_me:$LINENO: result: $ac_cv_sys_large_files" >&5
5051
echo "${ECHO_T}$ac_cv_sys_large_files" >&6
5052
if test "$ac_cv_sys_large_files" != no; then
5053
 
5054
cat >>confdefs.h <<_ACEOF
5055
#define _LARGE_FILES $ac_cv_sys_large_files
5056
_ACEOF
5057
 
5058
fi
5059
rm -f conftest*
5060
fi
5061
 
5062
if test x$gcc_no_link = xyes; then
5063
  if test "x${ac_cv_func_mmap_fixed_mapped+set}" != xset; then
5064
    ac_cv_func_mmap_fixed_mapped=no
5065
  fi
5066
fi
5067
if test "x${ac_cv_func_mmap_fixed_mapped}" != xno; then
5068
  ac_ext=c
5069
ac_cpp='$CPP $CPPFLAGS'
5070
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5071
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5072
ac_compiler_gnu=$ac_cv_c_compiler_gnu
5073
echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
5074
echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
5075
# On Suns, sometimes $CPP names a directory.
5076
if test -n "$CPP" && test -d "$CPP"; then
5077
  CPP=
5078
fi
5079
if test -z "$CPP"; then
5080
  if test "${ac_cv_prog_CPP+set}" = set; then
5081
  echo $ECHO_N "(cached) $ECHO_C" >&6
5082
else
5083
      # Double quotes because CPP needs to be expanded
5084
    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
5085
    do
5086
      ac_preproc_ok=false
5087
for ac_c_preproc_warn_flag in '' yes
5088
do
5089
  # Use a header file that comes with gcc, so configuring glibc
5090
  # with a fresh cross-compiler works.
5091
  # Prefer  to  if __STDC__ is defined, since
5092
  #  exists even on freestanding compilers.
5093
  # On the NeXT, cc -E runs the code through the compiler's parser,
5094
  # not just through cpp. "Syntax error" is here to catch this case.
5095
  cat >conftest.$ac_ext <<_ACEOF
5096
/* confdefs.h.  */
5097
_ACEOF
5098
cat confdefs.h >>conftest.$ac_ext
5099
cat >>conftest.$ac_ext <<_ACEOF
5100
/* end confdefs.h.  */
5101
#ifdef __STDC__
5102
# include 
5103
#else
5104
# include 
5105
#endif
5106
                     Syntax error
5107
_ACEOF
5108
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5109
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5110
  ac_status=$?
5111
  grep -v '^ *+' conftest.er1 >conftest.err
5112
  rm -f conftest.er1
5113
  cat conftest.err >&5
5114
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5115
  (exit $ac_status); } >/dev/null; then
5116
  if test -s conftest.err; then
5117
    ac_cpp_err=$ac_c_preproc_warn_flag
5118
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5119
  else
5120
    ac_cpp_err=
5121
  fi
5122
else
5123
  ac_cpp_err=yes
5124
fi
5125
if test -z "$ac_cpp_err"; then
5126
  :
5127
else
5128
  echo "$as_me: failed program was:" >&5
5129
sed 's/^/| /' conftest.$ac_ext >&5
5130
 
5131
  # Broken: fails on valid input.
5132
continue
5133
fi
5134
rm -f conftest.err conftest.$ac_ext
5135
 
5136
  # OK, works on sane cases.  Now check whether non-existent headers
5137
  # can be detected and how.
5138
  cat >conftest.$ac_ext <<_ACEOF
5139
/* confdefs.h.  */
5140
_ACEOF
5141
cat confdefs.h >>conftest.$ac_ext
5142
cat >>conftest.$ac_ext <<_ACEOF
5143
/* end confdefs.h.  */
5144
#include 
5145
_ACEOF
5146
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5147
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5148
  ac_status=$?
5149
  grep -v '^ *+' conftest.er1 >conftest.err
5150
  rm -f conftest.er1
5151
  cat conftest.err >&5
5152
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5153
  (exit $ac_status); } >/dev/null; then
5154
  if test -s conftest.err; then
5155
    ac_cpp_err=$ac_c_preproc_warn_flag
5156
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5157
  else
5158
    ac_cpp_err=
5159
  fi
5160
else
5161
  ac_cpp_err=yes
5162
fi
5163
if test -z "$ac_cpp_err"; then
5164
  # Broken: success on invalid input.
5165
continue
5166
else
5167
  echo "$as_me: failed program was:" >&5
5168
sed 's/^/| /' conftest.$ac_ext >&5
5169
 
5170
  # Passes both tests.
5171
ac_preproc_ok=:
5172
break
5173
fi
5174
rm -f conftest.err conftest.$ac_ext
5175
 
5176
done
5177
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5178
rm -f conftest.err conftest.$ac_ext
5179
if $ac_preproc_ok; then
5180
  break
5181
fi
5182
 
5183
    done
5184
    ac_cv_prog_CPP=$CPP
5185
 
5186
fi
5187
  CPP=$ac_cv_prog_CPP
5188
else
5189
  ac_cv_prog_CPP=$CPP
5190
fi
5191
echo "$as_me:$LINENO: result: $CPP" >&5
5192
echo "${ECHO_T}$CPP" >&6
5193
ac_preproc_ok=false
5194
for ac_c_preproc_warn_flag in '' yes
5195
do
5196
  # Use a header file that comes with gcc, so configuring glibc
5197
  # with a fresh cross-compiler works.
5198
  # Prefer  to  if __STDC__ is defined, since
5199
  #  exists even on freestanding compilers.
5200
  # On the NeXT, cc -E runs the code through the compiler's parser,
5201
  # not just through cpp. "Syntax error" is here to catch this case.
5202
  cat >conftest.$ac_ext <<_ACEOF
5203
/* confdefs.h.  */
5204
_ACEOF
5205
cat confdefs.h >>conftest.$ac_ext
5206
cat >>conftest.$ac_ext <<_ACEOF
5207
/* end confdefs.h.  */
5208
#ifdef __STDC__
5209
# include 
5210
#else
5211
# include 
5212
#endif
5213
                     Syntax error
5214
_ACEOF
5215
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5216
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5217
  ac_status=$?
5218
  grep -v '^ *+' conftest.er1 >conftest.err
5219
  rm -f conftest.er1
5220
  cat conftest.err >&5
5221
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5222
  (exit $ac_status); } >/dev/null; then
5223
  if test -s conftest.err; then
5224
    ac_cpp_err=$ac_c_preproc_warn_flag
5225
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5226
  else
5227
    ac_cpp_err=
5228
  fi
5229
else
5230
  ac_cpp_err=yes
5231
fi
5232
if test -z "$ac_cpp_err"; then
5233
  :
5234
else
5235
  echo "$as_me: failed program was:" >&5
5236
sed 's/^/| /' conftest.$ac_ext >&5
5237
 
5238
  # Broken: fails on valid input.
5239
continue
5240
fi
5241
rm -f conftest.err conftest.$ac_ext
5242
 
5243
  # OK, works on sane cases.  Now check whether non-existent headers
5244
  # can be detected and how.
5245
  cat >conftest.$ac_ext <<_ACEOF
5246
/* confdefs.h.  */
5247
_ACEOF
5248
cat confdefs.h >>conftest.$ac_ext
5249
cat >>conftest.$ac_ext <<_ACEOF
5250
/* end confdefs.h.  */
5251
#include 
5252
_ACEOF
5253
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5254
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5255
  ac_status=$?
5256
  grep -v '^ *+' conftest.er1 >conftest.err
5257
  rm -f conftest.er1
5258
  cat conftest.err >&5
5259
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5260
  (exit $ac_status); } >/dev/null; then
5261
  if test -s conftest.err; then
5262
    ac_cpp_err=$ac_c_preproc_warn_flag
5263
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5264
  else
5265
    ac_cpp_err=
5266
  fi
5267
else
5268
  ac_cpp_err=yes
5269
fi
5270
if test -z "$ac_cpp_err"; then
5271
  # Broken: success on invalid input.
5272
continue
5273
else
5274
  echo "$as_me: failed program was:" >&5
5275
sed 's/^/| /' conftest.$ac_ext >&5
5276
 
5277
  # Passes both tests.
5278
ac_preproc_ok=:
5279
break
5280
fi
5281
rm -f conftest.err conftest.$ac_ext
5282
 
5283
done
5284
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5285
rm -f conftest.err conftest.$ac_ext
5286
if $ac_preproc_ok; then
5287
  :
5288
else
5289
  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
5290
See \`config.log' for more details." >&5
5291
echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
5292
See \`config.log' for more details." >&2;}
5293
   { (exit 1); exit 1; }; }
5294
fi
5295
 
5296
ac_ext=c
5297
ac_cpp='$CPP $CPPFLAGS'
5298
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5299
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5300
ac_compiler_gnu=$ac_cv_c_compiler_gnu
5301
 
5302
 
5303
echo "$as_me:$LINENO: checking for egrep" >&5
5304
echo $ECHO_N "checking for egrep... $ECHO_C" >&6
5305
if test "${ac_cv_prog_egrep+set}" = set; then
5306
  echo $ECHO_N "(cached) $ECHO_C" >&6
5307
else
5308
  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
5309
    then ac_cv_prog_egrep='grep -E'
5310
    else ac_cv_prog_egrep='egrep'
5311
    fi
5312
fi
5313
echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
5314
echo "${ECHO_T}$ac_cv_prog_egrep" >&6
5315
 EGREP=$ac_cv_prog_egrep
5316
 
5317
 
5318
echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5319
echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5320
if test "${ac_cv_header_stdc+set}" = set; then
5321
  echo $ECHO_N "(cached) $ECHO_C" >&6
5322
else
5323
  cat >conftest.$ac_ext <<_ACEOF
5324
/* confdefs.h.  */
5325
_ACEOF
5326
cat confdefs.h >>conftest.$ac_ext
5327
cat >>conftest.$ac_ext <<_ACEOF
5328
/* end confdefs.h.  */
5329
#include 
5330
#include 
5331
#include 
5332
#include 
5333
 
5334
int
5335
main ()
5336
{
5337
 
5338
  ;
5339
  return 0;
5340
}
5341
_ACEOF
5342
rm -f conftest.$ac_objext
5343
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5344
  (eval $ac_compile) 2>conftest.er1
5345
  ac_status=$?
5346
  grep -v '^ *+' conftest.er1 >conftest.err
5347
  rm -f conftest.er1
5348
  cat conftest.err >&5
5349
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5350
  (exit $ac_status); } &&
5351
         { ac_try='test -z "$ac_c_werror_flag"
5352
                         || test ! -s conftest.err'
5353
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5354
  (eval $ac_try) 2>&5
5355
  ac_status=$?
5356
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5357
  (exit $ac_status); }; } &&
5358
         { ac_try='test -s conftest.$ac_objext'
5359
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5360
  (eval $ac_try) 2>&5
5361
  ac_status=$?
5362
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5363
  (exit $ac_status); }; }; then
5364
  ac_cv_header_stdc=yes
5365
else
5366
  echo "$as_me: failed program was:" >&5
5367
sed 's/^/| /' conftest.$ac_ext >&5
5368
 
5369
ac_cv_header_stdc=no
5370
fi
5371
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5372
 
5373
if test $ac_cv_header_stdc = yes; then
5374
  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5375
  cat >conftest.$ac_ext <<_ACEOF
5376
/* confdefs.h.  */
5377
_ACEOF
5378
cat confdefs.h >>conftest.$ac_ext
5379
cat >>conftest.$ac_ext <<_ACEOF
5380
/* end confdefs.h.  */
5381
#include 
5382
 
5383
_ACEOF
5384
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5385
  $EGREP "memchr" >/dev/null 2>&1; then
5386
  :
5387
else
5388
  ac_cv_header_stdc=no
5389
fi
5390
rm -f conftest*
5391
 
5392
fi
5393
 
5394
if test $ac_cv_header_stdc = yes; then
5395
  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5396
  cat >conftest.$ac_ext <<_ACEOF
5397
/* confdefs.h.  */
5398
_ACEOF
5399
cat confdefs.h >>conftest.$ac_ext
5400
cat >>conftest.$ac_ext <<_ACEOF
5401
/* end confdefs.h.  */
5402
#include 
5403
 
5404
_ACEOF
5405
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5406
  $EGREP "free" >/dev/null 2>&1; then
5407
  :
5408
else
5409
  ac_cv_header_stdc=no
5410
fi
5411
rm -f conftest*
5412
 
5413
fi
5414
 
5415
if test $ac_cv_header_stdc = yes; then
5416
  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5417
  if test "$cross_compiling" = yes; then
5418
  :
5419
else
5420
  cat >conftest.$ac_ext <<_ACEOF
5421
/* confdefs.h.  */
5422
_ACEOF
5423
cat confdefs.h >>conftest.$ac_ext
5424
cat >>conftest.$ac_ext <<_ACEOF
5425
/* end confdefs.h.  */
5426
#include 
5427
#if ((' ' & 0x0FF) == 0x020)
5428
# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5429
# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5430
#else
5431
# define ISLOWER(c) \
5432
                   (('a' <= (c) && (c) <= 'i') \
5433
                     || ('j' <= (c) && (c) <= 'r') \
5434
                     || ('s' <= (c) && (c) <= 'z'))
5435
# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5436
#endif
5437
 
5438
#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5439
int
5440
main ()
5441
{
5442
  int i;
5443
  for (i = 0; i < 256; i++)
5444
    if (XOR (islower (i), ISLOWER (i))
5445
        || toupper (i) != TOUPPER (i))
5446
      exit(2);
5447
  exit (0);
5448
}
5449
_ACEOF
5450
rm -f conftest$ac_exeext
5451
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5452
  (eval $ac_link) 2>&5
5453
  ac_status=$?
5454
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5455
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5456
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5457
  (eval $ac_try) 2>&5
5458
  ac_status=$?
5459
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5460
  (exit $ac_status); }; }; then
5461
  :
5462
else
5463
  echo "$as_me: program exited with status $ac_status" >&5
5464
echo "$as_me: failed program was:" >&5
5465
sed 's/^/| /' conftest.$ac_ext >&5
5466
 
5467
( exit $ac_status )
5468
ac_cv_header_stdc=no
5469
fi
5470
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5471
fi
5472
fi
5473
fi
5474
echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5475
echo "${ECHO_T}$ac_cv_header_stdc" >&6
5476
if test $ac_cv_header_stdc = yes; then
5477
 
5478
cat >>confdefs.h <<\_ACEOF
5479
#define STDC_HEADERS 1
5480
_ACEOF
5481
 
5482
fi
5483
 
5484
# On IRIX 5.3, sys/types and inttypes.h are conflicting.
5485
 
5486
 
5487
 
5488
 
5489
 
5490
 
5491
 
5492
 
5493
 
5494
for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5495
                  inttypes.h stdint.h unistd.h
5496
do
5497
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5498
echo "$as_me:$LINENO: checking for $ac_header" >&5
5499
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5500
if eval "test \"\${$as_ac_Header+set}\" = set"; then
5501
  echo $ECHO_N "(cached) $ECHO_C" >&6
5502
else
5503
  cat >conftest.$ac_ext <<_ACEOF
5504
/* confdefs.h.  */
5505
_ACEOF
5506
cat confdefs.h >>conftest.$ac_ext
5507
cat >>conftest.$ac_ext <<_ACEOF
5508
/* end confdefs.h.  */
5509
$ac_includes_default
5510
 
5511
#include <$ac_header>
5512
_ACEOF
5513
rm -f conftest.$ac_objext
5514
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5515
  (eval $ac_compile) 2>conftest.er1
5516
  ac_status=$?
5517
  grep -v '^ *+' conftest.er1 >conftest.err
5518
  rm -f conftest.er1
5519
  cat conftest.err >&5
5520
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5521
  (exit $ac_status); } &&
5522
         { ac_try='test -z "$ac_c_werror_flag"
5523
                         || test ! -s conftest.err'
5524
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5525
  (eval $ac_try) 2>&5
5526
  ac_status=$?
5527
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5528
  (exit $ac_status); }; } &&
5529
         { ac_try='test -s conftest.$ac_objext'
5530
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5531
  (eval $ac_try) 2>&5
5532
  ac_status=$?
5533
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5534
  (exit $ac_status); }; }; then
5535
  eval "$as_ac_Header=yes"
5536
else
5537
  echo "$as_me: failed program was:" >&5
5538
sed 's/^/| /' conftest.$ac_ext >&5
5539
 
5540
eval "$as_ac_Header=no"
5541
fi
5542
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5543
fi
5544
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5545
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5546
if test `eval echo '${'$as_ac_Header'}'` = yes; then
5547
  cat >>confdefs.h <<_ACEOF
5548
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5549
_ACEOF
5550
 
5551
fi
5552
 
5553
done
5554
 
5555
 
5556
 
5557
 
5558
for ac_header in stdlib.h unistd.h
5559
do
5560
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5561
if eval "test \"\${$as_ac_Header+set}\" = set"; then
5562
  echo "$as_me:$LINENO: checking for $ac_header" >&5
5563
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5564
if eval "test \"\${$as_ac_Header+set}\" = set"; then
5565
  echo $ECHO_N "(cached) $ECHO_C" >&6
5566
fi
5567
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5568
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5569
else
5570
  # Is the header compilable?
5571
echo "$as_me:$LINENO: checking $ac_header usability" >&5
5572
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
5573
cat >conftest.$ac_ext <<_ACEOF
5574
/* confdefs.h.  */
5575
_ACEOF
5576
cat confdefs.h >>conftest.$ac_ext
5577
cat >>conftest.$ac_ext <<_ACEOF
5578
/* end confdefs.h.  */
5579
$ac_includes_default
5580
#include <$ac_header>
5581
_ACEOF
5582
rm -f conftest.$ac_objext
5583
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5584
  (eval $ac_compile) 2>conftest.er1
5585
  ac_status=$?
5586
  grep -v '^ *+' conftest.er1 >conftest.err
5587
  rm -f conftest.er1
5588
  cat conftest.err >&5
5589
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5590
  (exit $ac_status); } &&
5591
         { ac_try='test -z "$ac_c_werror_flag"
5592
                         || test ! -s conftest.err'
5593
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5594
  (eval $ac_try) 2>&5
5595
  ac_status=$?
5596
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5597
  (exit $ac_status); }; } &&
5598
         { ac_try='test -s conftest.$ac_objext'
5599
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5600
  (eval $ac_try) 2>&5
5601
  ac_status=$?
5602
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5603
  (exit $ac_status); }; }; then
5604
  ac_header_compiler=yes
5605
else
5606
  echo "$as_me: failed program was:" >&5
5607
sed 's/^/| /' conftest.$ac_ext >&5
5608
 
5609
ac_header_compiler=no
5610
fi
5611
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5612
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5613
echo "${ECHO_T}$ac_header_compiler" >&6
5614
 
5615
# Is the header present?
5616
echo "$as_me:$LINENO: checking $ac_header presence" >&5
5617
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
5618
cat >conftest.$ac_ext <<_ACEOF
5619
/* confdefs.h.  */
5620
_ACEOF
5621
cat confdefs.h >>conftest.$ac_ext
5622
cat >>conftest.$ac_ext <<_ACEOF
5623
/* end confdefs.h.  */
5624
#include <$ac_header>
5625
_ACEOF
5626
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5627
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5628
  ac_status=$?
5629
  grep -v '^ *+' conftest.er1 >conftest.err
5630
  rm -f conftest.er1
5631
  cat conftest.err >&5
5632
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5633
  (exit $ac_status); } >/dev/null; then
5634
  if test -s conftest.err; then
5635
    ac_cpp_err=$ac_c_preproc_warn_flag
5636
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5637
  else
5638
    ac_cpp_err=
5639
  fi
5640
else
5641
  ac_cpp_err=yes
5642
fi
5643
if test -z "$ac_cpp_err"; then
5644
  ac_header_preproc=yes
5645
else
5646
  echo "$as_me: failed program was:" >&5
5647
sed 's/^/| /' conftest.$ac_ext >&5
5648
 
5649
  ac_header_preproc=no
5650
fi
5651
rm -f conftest.err conftest.$ac_ext
5652
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5653
echo "${ECHO_T}$ac_header_preproc" >&6
5654
 
5655
# So?  What about this header?
5656
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5657
  yes:no: )
5658
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
5659
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
5660
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
5661
echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
5662
    ac_header_preproc=yes
5663
    ;;
5664
  no:yes:* )
5665
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
5666
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
5667
    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
5668
echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
5669
    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
5670
echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
5671
    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
5672
echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
5673
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
5674
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
5675
    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
5676
echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
5677
    (
5678
      cat <<\_ASBOX
5679
## ------------------------------------------------------ ##
5680
## Report this to the GNU Fortran Runtime Library lists.  ##
5681
## ------------------------------------------------------ ##
5682
_ASBOX
5683
    ) |
5684
      sed "s/^/$as_me: WARNING:     /" >&2
5685
    ;;
5686
esac
5687
echo "$as_me:$LINENO: checking for $ac_header" >&5
5688
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5689
if eval "test \"\${$as_ac_Header+set}\" = set"; then
5690
  echo $ECHO_N "(cached) $ECHO_C" >&6
5691
else
5692
  eval "$as_ac_Header=\$ac_header_preproc"
5693
fi
5694
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5695
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5696
 
5697
fi
5698
if test `eval echo '${'$as_ac_Header'}'` = yes; then
5699
  cat >>confdefs.h <<_ACEOF
5700
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5701
_ACEOF
5702
 
5703
fi
5704
 
5705
done
5706
 
5707
 
5708
for ac_func in getpagesize
5709
do
5710
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
5711
echo "$as_me:$LINENO: checking for $ac_func" >&5
5712
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
5713
if eval "test \"\${$as_ac_var+set}\" = set"; then
5714
  echo $ECHO_N "(cached) $ECHO_C" >&6
5715
else
5716
  if test x$gcc_no_link = xyes; then
5717
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
5718
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
5719
   { (exit 1); exit 1; }; }
5720
fi
5721
cat >conftest.$ac_ext <<_ACEOF
5722
/* confdefs.h.  */
5723
_ACEOF
5724
cat confdefs.h >>conftest.$ac_ext
5725
cat >>conftest.$ac_ext <<_ACEOF
5726
/* end confdefs.h.  */
5727
/* Define $ac_func to an innocuous variant, in case  declares $ac_func.
5728
   For example, HP-UX 11i  declares gettimeofday.  */
5729
#define $ac_func innocuous_$ac_func
5730
 
5731
/* System header to define __stub macros and hopefully few prototypes,
5732
    which can conflict with char $ac_func (); below.
5733
    Prefer  to  if __STDC__ is defined, since
5734
     exists even on freestanding compilers.  */
5735
 
5736
#ifdef __STDC__
5737
# include 
5738
#else
5739
# include 
5740
#endif
5741
 
5742
#undef $ac_func
5743
 
5744
/* Override any gcc2 internal prototype to avoid an error.  */
5745
#ifdef __cplusplus
5746
extern "C"
5747
{
5748
#endif
5749
/* We use char because int might match the return type of a gcc2
5750
   builtin and then its argument prototype would still apply.  */
5751
char $ac_func ();
5752
/* The GNU C library defines this for functions which it implements
5753
    to always fail with ENOSYS.  Some functions are actually named
5754
    something starting with __ and the normal name is an alias.  */
5755
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5756
choke me
5757
#else
5758
char (*f) () = $ac_func;
5759
#endif
5760
#ifdef __cplusplus
5761
}
5762
#endif
5763
 
5764
int
5765
main ()
5766
{
5767
return f != $ac_func;
5768
  ;
5769
  return 0;
5770
}
5771
_ACEOF
5772
rm -f conftest.$ac_objext conftest$ac_exeext
5773
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5774
  (eval $ac_link) 2>conftest.er1
5775
  ac_status=$?
5776
  grep -v '^ *+' conftest.er1 >conftest.err
5777
  rm -f conftest.er1
5778
  cat conftest.err >&5
5779
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5780
  (exit $ac_status); } &&
5781
         { ac_try='test -z "$ac_c_werror_flag"
5782
                         || test ! -s conftest.err'
5783
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5784
  (eval $ac_try) 2>&5
5785
  ac_status=$?
5786
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5787
  (exit $ac_status); }; } &&
5788
         { ac_try='test -s conftest$ac_exeext'
5789
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5790
  (eval $ac_try) 2>&5
5791
  ac_status=$?
5792
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5793
  (exit $ac_status); }; }; then
5794
  eval "$as_ac_var=yes"
5795
else
5796
  echo "$as_me: failed program was:" >&5
5797
sed 's/^/| /' conftest.$ac_ext >&5
5798
 
5799
eval "$as_ac_var=no"
5800
fi
5801
rm -f conftest.err conftest.$ac_objext \
5802
      conftest$ac_exeext conftest.$ac_ext
5803
fi
5804
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
5805
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
5806
if test `eval echo '${'$as_ac_var'}'` = yes; then
5807
  cat >>confdefs.h <<_ACEOF
5808
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
5809
_ACEOF
5810
 
5811
fi
5812
done
5813
 
5814
echo "$as_me:$LINENO: checking for working mmap" >&5
5815
echo $ECHO_N "checking for working mmap... $ECHO_C" >&6
5816
if test "${ac_cv_func_mmap_fixed_mapped+set}" = set; then
5817
  echo $ECHO_N "(cached) $ECHO_C" >&6
5818
else
5819
  if test "$cross_compiling" = yes; then
5820
  ac_cv_func_mmap_fixed_mapped=no
5821
else
5822
  cat >conftest.$ac_ext <<_ACEOF
5823
/* confdefs.h.  */
5824
_ACEOF
5825
cat confdefs.h >>conftest.$ac_ext
5826
cat >>conftest.$ac_ext <<_ACEOF
5827
/* end confdefs.h.  */
5828
$ac_includes_default
5829
/* malloc might have been renamed as rpl_malloc. */
5830
#undef malloc
5831
 
5832
/* Thanks to Mike Haertel and Jim Avera for this test.
5833
   Here is a matrix of mmap possibilities:
5834
        mmap private not fixed
5835
        mmap private fixed at somewhere currently unmapped
5836
        mmap private fixed at somewhere already mapped
5837
        mmap shared not fixed
5838
        mmap shared fixed at somewhere currently unmapped
5839
        mmap shared fixed at somewhere already mapped
5840
   For private mappings, we should verify that changes cannot be read()
5841
   back from the file, nor mmap's back from the file at a different
5842
   address.  (There have been systems where private was not correctly
5843
   implemented like the infamous i386 svr4.0, and systems where the
5844
   VM page cache was not coherent with the file system buffer cache
5845
   like early versions of FreeBSD and possibly contemporary NetBSD.)
5846
   For shared mappings, we should conversely verify that changes get
5847
   propagated back to all the places they're supposed to be.
5848
 
5849
   Grep wants private fixed already mapped.
5850
   The main things grep needs to know about mmap are:
5851
   * does it exist and is it safe to write into the mmap'd area
5852
   * how to use it (BSD variants)  */
5853
 
5854
#include 
5855
#include 
5856
 
5857
#if !STDC_HEADERS && !HAVE_STDLIB_H
5858
char *malloc ();
5859
#endif
5860
 
5861
/* This mess was copied from the GNU getpagesize.h.  */
5862
#if !HAVE_GETPAGESIZE
5863
/* Assume that all systems that can run configure have sys/param.h.  */
5864
# if !HAVE_SYS_PARAM_H
5865
#  define HAVE_SYS_PARAM_H 1
5866
# endif
5867
 
5868
# ifdef _SC_PAGESIZE
5869
#  define getpagesize() sysconf(_SC_PAGESIZE)
5870
# else /* no _SC_PAGESIZE */
5871
#  if HAVE_SYS_PARAM_H
5872
#   include 
5873
#   ifdef EXEC_PAGESIZE
5874
#    define getpagesize() EXEC_PAGESIZE
5875
#   else /* no EXEC_PAGESIZE */
5876
#    ifdef NBPG
5877
#     define getpagesize() NBPG * CLSIZE
5878
#     ifndef CLSIZE
5879
#      define CLSIZE 1
5880
#     endif /* no CLSIZE */
5881
#    else /* no NBPG */
5882
#     ifdef NBPC
5883
#      define getpagesize() NBPC
5884
#     else /* no NBPC */
5885
#      ifdef PAGESIZE
5886
#       define getpagesize() PAGESIZE
5887
#      endif /* PAGESIZE */
5888
#     endif /* no NBPC */
5889
#    endif /* no NBPG */
5890
#   endif /* no EXEC_PAGESIZE */
5891
#  else /* no HAVE_SYS_PARAM_H */
5892
#   define getpagesize() 8192   /* punt totally */
5893
#  endif /* no HAVE_SYS_PARAM_H */
5894
# endif /* no _SC_PAGESIZE */
5895
 
5896
#endif /* no HAVE_GETPAGESIZE */
5897
 
5898
int
5899
main ()
5900
{
5901
  char *data, *data2, *data3;
5902
  int i, pagesize;
5903
  int fd;
5904
 
5905
  pagesize = getpagesize ();
5906
 
5907
  /* First, make a file with some known garbage in it. */
5908
  data = (char *) malloc (pagesize);
5909
  if (!data)
5910
    exit (1);
5911
  for (i = 0; i < pagesize; ++i)
5912
    *(data + i) = rand ();
5913
  umask (0);
5914
  fd = creat ("conftest.mmap", 0600);
5915
  if (fd < 0)
5916
    exit (1);
5917
  if (write (fd, data, pagesize) != pagesize)
5918
    exit (1);
5919
  close (fd);
5920
 
5921
  /* Next, try to mmap the file at a fixed address which already has
5922
     something else allocated at it.  If we can, also make sure that
5923
     we see the same garbage.  */
5924
  fd = open ("conftest.mmap", O_RDWR);
5925
  if (fd < 0)
5926
    exit (1);
5927
  data2 = (char *) malloc (2 * pagesize);
5928
  if (!data2)
5929
    exit (1);
5930
  data2 += (pagesize - ((long) data2 & (pagesize - 1))) & (pagesize - 1);
5931
  if (data2 != mmap (data2, pagesize, PROT_READ | PROT_WRITE,
5932
                     MAP_PRIVATE | MAP_FIXED, fd, 0L))
5933
    exit (1);
5934
  for (i = 0; i < pagesize; ++i)
5935
    if (*(data + i) != *(data2 + i))
5936
      exit (1);
5937
 
5938
  /* Finally, make sure that changes to the mapped area do not
5939
     percolate back to the file as seen by read().  (This is a bug on
5940
     some variants of i386 svr4.0.)  */
5941
  for (i = 0; i < pagesize; ++i)
5942
    *(data2 + i) = *(data2 + i) + 1;
5943
  data3 = (char *) malloc (pagesize);
5944
  if (!data3)
5945
    exit (1);
5946
  if (read (fd, data3, pagesize) != pagesize)
5947
    exit (1);
5948
  for (i = 0; i < pagesize; ++i)
5949
    if (*(data + i) != *(data3 + i))
5950
      exit (1);
5951
  close (fd);
5952
  exit (0);
5953
}
5954
_ACEOF
5955
rm -f conftest$ac_exeext
5956
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5957
  (eval $ac_link) 2>&5
5958
  ac_status=$?
5959
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5960
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5961
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5962
  (eval $ac_try) 2>&5
5963
  ac_status=$?
5964
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5965
  (exit $ac_status); }; }; then
5966
  ac_cv_func_mmap_fixed_mapped=yes
5967
else
5968
  echo "$as_me: program exited with status $ac_status" >&5
5969
echo "$as_me: failed program was:" >&5
5970
sed 's/^/| /' conftest.$ac_ext >&5
5971
 
5972
( exit $ac_status )
5973
ac_cv_func_mmap_fixed_mapped=no
5974
fi
5975
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5976
fi
5977
fi
5978
echo "$as_me:$LINENO: result: $ac_cv_func_mmap_fixed_mapped" >&5
5979
echo "${ECHO_T}$ac_cv_func_mmap_fixed_mapped" >&6
5980
if test $ac_cv_func_mmap_fixed_mapped = yes; then
5981
 
5982
cat >>confdefs.h <<\_ACEOF
5983
#define HAVE_MMAP 1
5984
_ACEOF
5985
 
5986
fi
5987
rm -f conftest.mmap
5988
 
5989
fi
5990
echo "$as_me:$LINENO: checking for off_t" >&5
5991
echo $ECHO_N "checking for off_t... $ECHO_C" >&6
5992
if test "${ac_cv_type_off_t+set}" = set; then
5993
  echo $ECHO_N "(cached) $ECHO_C" >&6
5994
else
5995
  cat >conftest.$ac_ext <<_ACEOF
5996
/* confdefs.h.  */
5997
_ACEOF
5998
cat confdefs.h >>conftest.$ac_ext
5999
cat >>conftest.$ac_ext <<_ACEOF
6000
/* end confdefs.h.  */
6001
$ac_includes_default
6002
int
6003
main ()
6004
{
6005
if ((off_t *) 0)
6006
  return 0;
6007
if (sizeof (off_t))
6008
  return 0;
6009
  ;
6010
  return 0;
6011
}
6012
_ACEOF
6013
rm -f conftest.$ac_objext
6014
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6015
  (eval $ac_compile) 2>conftest.er1
6016
  ac_status=$?
6017
  grep -v '^ *+' conftest.er1 >conftest.err
6018
  rm -f conftest.er1
6019
  cat conftest.err >&5
6020
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6021
  (exit $ac_status); } &&
6022
         { ac_try='test -z "$ac_c_werror_flag"
6023
                         || test ! -s conftest.err'
6024
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6025
  (eval $ac_try) 2>&5
6026
  ac_status=$?
6027
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6028
  (exit $ac_status); }; } &&
6029
         { ac_try='test -s conftest.$ac_objext'
6030
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6031
  (eval $ac_try) 2>&5
6032
  ac_status=$?
6033
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6034
  (exit $ac_status); }; }; then
6035
  ac_cv_type_off_t=yes
6036
else
6037
  echo "$as_me: failed program was:" >&5
6038
sed 's/^/| /' conftest.$ac_ext >&5
6039
 
6040
ac_cv_type_off_t=no
6041
fi
6042
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6043
fi
6044
echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
6045
echo "${ECHO_T}$ac_cv_type_off_t" >&6
6046
if test $ac_cv_type_off_t = yes; then
6047
  :
6048
else
6049
 
6050
cat >>confdefs.h <<_ACEOF
6051
#define off_t long
6052
_ACEOF
6053
 
6054
fi
6055
 
6056
 
6057
# check header files
6058
echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6059
echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
6060
if test "${ac_cv_header_stdc+set}" = set; then
6061
  echo $ECHO_N "(cached) $ECHO_C" >&6
6062
else
6063
  cat >conftest.$ac_ext <<_ACEOF
6064
/* confdefs.h.  */
6065
_ACEOF
6066
cat confdefs.h >>conftest.$ac_ext
6067
cat >>conftest.$ac_ext <<_ACEOF
6068
/* end confdefs.h.  */
6069
#include 
6070
#include 
6071
#include 
6072
#include 
6073
 
6074
int
6075
main ()
6076
{
6077
 
6078
  ;
6079
  return 0;
6080
}
6081
_ACEOF
6082
rm -f conftest.$ac_objext
6083
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6084
  (eval $ac_compile) 2>conftest.er1
6085
  ac_status=$?
6086
  grep -v '^ *+' conftest.er1 >conftest.err
6087
  rm -f conftest.er1
6088
  cat conftest.err >&5
6089
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6090
  (exit $ac_status); } &&
6091
         { ac_try='test -z "$ac_c_werror_flag"
6092
                         || test ! -s conftest.err'
6093
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6094
  (eval $ac_try) 2>&5
6095
  ac_status=$?
6096
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6097
  (exit $ac_status); }; } &&
6098
         { ac_try='test -s conftest.$ac_objext'
6099
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6100
  (eval $ac_try) 2>&5
6101
  ac_status=$?
6102
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6103
  (exit $ac_status); }; }; then
6104
  ac_cv_header_stdc=yes
6105
else
6106
  echo "$as_me: failed program was:" >&5
6107
sed 's/^/| /' conftest.$ac_ext >&5
6108
 
6109
ac_cv_header_stdc=no
6110
fi
6111
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6112
 
6113
if test $ac_cv_header_stdc = yes; then
6114
  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
6115
  cat >conftest.$ac_ext <<_ACEOF
6116
/* confdefs.h.  */
6117
_ACEOF
6118
cat confdefs.h >>conftest.$ac_ext
6119
cat >>conftest.$ac_ext <<_ACEOF
6120
/* end confdefs.h.  */
6121
#include 
6122
 
6123
_ACEOF
6124
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6125
  $EGREP "memchr" >/dev/null 2>&1; then
6126
  :
6127
else
6128
  ac_cv_header_stdc=no
6129
fi
6130
rm -f conftest*
6131
 
6132
fi
6133
 
6134
if test $ac_cv_header_stdc = yes; then
6135
  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
6136
  cat >conftest.$ac_ext <<_ACEOF
6137
/* confdefs.h.  */
6138
_ACEOF
6139
cat confdefs.h >>conftest.$ac_ext
6140
cat >>conftest.$ac_ext <<_ACEOF
6141
/* end confdefs.h.  */
6142
#include 
6143
 
6144
_ACEOF
6145
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6146
  $EGREP "free" >/dev/null 2>&1; then
6147
  :
6148
else
6149
  ac_cv_header_stdc=no
6150
fi
6151
rm -f conftest*
6152
 
6153
fi
6154
 
6155
if test $ac_cv_header_stdc = yes; then
6156
  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
6157
  if test "$cross_compiling" = yes; then
6158
  :
6159
else
6160
  cat >conftest.$ac_ext <<_ACEOF
6161
/* confdefs.h.  */
6162
_ACEOF
6163
cat confdefs.h >>conftest.$ac_ext
6164
cat >>conftest.$ac_ext <<_ACEOF
6165
/* end confdefs.h.  */
6166
#include 
6167
#if ((' ' & 0x0FF) == 0x020)
6168
# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
6169
# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
6170
#else
6171
# define ISLOWER(c) \
6172
                   (('a' <= (c) && (c) <= 'i') \
6173
                     || ('j' <= (c) && (c) <= 'r') \
6174
                     || ('s' <= (c) && (c) <= 'z'))
6175
# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
6176
#endif
6177
 
6178
#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
6179
int
6180
main ()
6181
{
6182
  int i;
6183
  for (i = 0; i < 256; i++)
6184
    if (XOR (islower (i), ISLOWER (i))
6185
        || toupper (i) != TOUPPER (i))
6186
      exit(2);
6187
  exit (0);
6188
}
6189
_ACEOF
6190
rm -f conftest$ac_exeext
6191
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6192
  (eval $ac_link) 2>&5
6193
  ac_status=$?
6194
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6195
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
6196
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6197
  (eval $ac_try) 2>&5
6198
  ac_status=$?
6199
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6200
  (exit $ac_status); }; }; then
6201
  :
6202
else
6203
  echo "$as_me: program exited with status $ac_status" >&5
6204
echo "$as_me: failed program was:" >&5
6205
sed 's/^/| /' conftest.$ac_ext >&5
6206
 
6207
( exit $ac_status )
6208
ac_cv_header_stdc=no
6209
fi
6210
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
6211
fi
6212
fi
6213
fi
6214
echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
6215
echo "${ECHO_T}$ac_cv_header_stdc" >&6
6216
if test $ac_cv_header_stdc = yes; then
6217
 
6218
cat >>confdefs.h <<\_ACEOF
6219
#define STDC_HEADERS 1
6220
_ACEOF
6221
 
6222
fi
6223
 
6224
 
6225
 
6226
 
6227
 
6228
 
6229
 
6230
 
6231
for ac_header in stdlib.h stdio.h string.h stddef.h math.h unistd.h signal.h
6232
do
6233
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6234
if eval "test \"\${$as_ac_Header+set}\" = set"; then
6235
  echo "$as_me:$LINENO: checking for $ac_header" >&5
6236
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6237
if eval "test \"\${$as_ac_Header+set}\" = set"; then
6238
  echo $ECHO_N "(cached) $ECHO_C" >&6
6239
fi
6240
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6241
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6242
else
6243
  # Is the header compilable?
6244
echo "$as_me:$LINENO: checking $ac_header usability" >&5
6245
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6246
cat >conftest.$ac_ext <<_ACEOF
6247
/* confdefs.h.  */
6248
_ACEOF
6249
cat confdefs.h >>conftest.$ac_ext
6250
cat >>conftest.$ac_ext <<_ACEOF
6251
/* end confdefs.h.  */
6252
$ac_includes_default
6253
#include <$ac_header>
6254
_ACEOF
6255
rm -f conftest.$ac_objext
6256
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6257
  (eval $ac_compile) 2>conftest.er1
6258
  ac_status=$?
6259
  grep -v '^ *+' conftest.er1 >conftest.err
6260
  rm -f conftest.er1
6261
  cat conftest.err >&5
6262
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6263
  (exit $ac_status); } &&
6264
         { ac_try='test -z "$ac_c_werror_flag"
6265
                         || test ! -s conftest.err'
6266
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6267
  (eval $ac_try) 2>&5
6268
  ac_status=$?
6269
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6270
  (exit $ac_status); }; } &&
6271
         { ac_try='test -s conftest.$ac_objext'
6272
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6273
  (eval $ac_try) 2>&5
6274
  ac_status=$?
6275
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6276
  (exit $ac_status); }; }; then
6277
  ac_header_compiler=yes
6278
else
6279
  echo "$as_me: failed program was:" >&5
6280
sed 's/^/| /' conftest.$ac_ext >&5
6281
 
6282
ac_header_compiler=no
6283
fi
6284
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6285
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6286
echo "${ECHO_T}$ac_header_compiler" >&6
6287
 
6288
# Is the header present?
6289
echo "$as_me:$LINENO: checking $ac_header presence" >&5
6290
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6291
cat >conftest.$ac_ext <<_ACEOF
6292
/* confdefs.h.  */
6293
_ACEOF
6294
cat confdefs.h >>conftest.$ac_ext
6295
cat >>conftest.$ac_ext <<_ACEOF
6296
/* end confdefs.h.  */
6297
#include <$ac_header>
6298
_ACEOF
6299
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6300
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6301
  ac_status=$?
6302
  grep -v '^ *+' conftest.er1 >conftest.err
6303
  rm -f conftest.er1
6304
  cat conftest.err >&5
6305
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6306
  (exit $ac_status); } >/dev/null; then
6307
  if test -s conftest.err; then
6308
    ac_cpp_err=$ac_c_preproc_warn_flag
6309
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6310
  else
6311
    ac_cpp_err=
6312
  fi
6313
else
6314
  ac_cpp_err=yes
6315
fi
6316
if test -z "$ac_cpp_err"; then
6317
  ac_header_preproc=yes
6318
else
6319
  echo "$as_me: failed program was:" >&5
6320
sed 's/^/| /' conftest.$ac_ext >&5
6321
 
6322
  ac_header_preproc=no
6323
fi
6324
rm -f conftest.err conftest.$ac_ext
6325
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6326
echo "${ECHO_T}$ac_header_preproc" >&6
6327
 
6328
# So?  What about this header?
6329
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6330
  yes:no: )
6331
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6332
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6333
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6334
echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6335
    ac_header_preproc=yes
6336
    ;;
6337
  no:yes:* )
6338
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6339
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6340
    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6341
echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6342
    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6343
echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6344
    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6345
echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6346
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6347
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6348
    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6349
echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6350
    (
6351
      cat <<\_ASBOX
6352
## ------------------------------------------------------ ##
6353
## Report this to the GNU Fortran Runtime Library lists.  ##
6354
## ------------------------------------------------------ ##
6355
_ASBOX
6356
    ) |
6357
      sed "s/^/$as_me: WARNING:     /" >&2
6358
    ;;
6359
esac
6360
echo "$as_me:$LINENO: checking for $ac_header" >&5
6361
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6362
if eval "test \"\${$as_ac_Header+set}\" = set"; then
6363
  echo $ECHO_N "(cached) $ECHO_C" >&6
6364
else
6365
  eval "$as_ac_Header=\$ac_header_preproc"
6366
fi
6367
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6368
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6369
 
6370
fi
6371
if test `eval echo '${'$as_ac_Header'}'` = yes; then
6372
  cat >>confdefs.h <<_ACEOF
6373
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6374
_ACEOF
6375
 
6376
fi
6377
 
6378
done
6379
 
6380
 
6381
 
6382
 
6383
 
6384
 
6385
for ac_header in time.h sys/params.h sys/time.h sys/times.h sys/resource.h
6386
do
6387
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6388
if eval "test \"\${$as_ac_Header+set}\" = set"; then
6389
  echo "$as_me:$LINENO: checking for $ac_header" >&5
6390
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6391
if eval "test \"\${$as_ac_Header+set}\" = set"; then
6392
  echo $ECHO_N "(cached) $ECHO_C" >&6
6393
fi
6394
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6395
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6396
else
6397
  # Is the header compilable?
6398
echo "$as_me:$LINENO: checking $ac_header usability" >&5
6399
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6400
cat >conftest.$ac_ext <<_ACEOF
6401
/* confdefs.h.  */
6402
_ACEOF
6403
cat confdefs.h >>conftest.$ac_ext
6404
cat >>conftest.$ac_ext <<_ACEOF
6405
/* end confdefs.h.  */
6406
$ac_includes_default
6407
#include <$ac_header>
6408
_ACEOF
6409
rm -f conftest.$ac_objext
6410
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6411
  (eval $ac_compile) 2>conftest.er1
6412
  ac_status=$?
6413
  grep -v '^ *+' conftest.er1 >conftest.err
6414
  rm -f conftest.er1
6415
  cat conftest.err >&5
6416
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6417
  (exit $ac_status); } &&
6418
         { ac_try='test -z "$ac_c_werror_flag"
6419
                         || test ! -s conftest.err'
6420
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6421
  (eval $ac_try) 2>&5
6422
  ac_status=$?
6423
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6424
  (exit $ac_status); }; } &&
6425
         { ac_try='test -s conftest.$ac_objext'
6426
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6427
  (eval $ac_try) 2>&5
6428
  ac_status=$?
6429
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6430
  (exit $ac_status); }; }; then
6431
  ac_header_compiler=yes
6432
else
6433
  echo "$as_me: failed program was:" >&5
6434
sed 's/^/| /' conftest.$ac_ext >&5
6435
 
6436
ac_header_compiler=no
6437
fi
6438
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6439
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6440
echo "${ECHO_T}$ac_header_compiler" >&6
6441
 
6442
# Is the header present?
6443
echo "$as_me:$LINENO: checking $ac_header presence" >&5
6444
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6445
cat >conftest.$ac_ext <<_ACEOF
6446
/* confdefs.h.  */
6447
_ACEOF
6448
cat confdefs.h >>conftest.$ac_ext
6449
cat >>conftest.$ac_ext <<_ACEOF
6450
/* end confdefs.h.  */
6451
#include <$ac_header>
6452
_ACEOF
6453
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6454
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6455
  ac_status=$?
6456
  grep -v '^ *+' conftest.er1 >conftest.err
6457
  rm -f conftest.er1
6458
  cat conftest.err >&5
6459
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6460
  (exit $ac_status); } >/dev/null; then
6461
  if test -s conftest.err; then
6462
    ac_cpp_err=$ac_c_preproc_warn_flag
6463
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6464
  else
6465
    ac_cpp_err=
6466
  fi
6467
else
6468
  ac_cpp_err=yes
6469
fi
6470
if test -z "$ac_cpp_err"; then
6471
  ac_header_preproc=yes
6472
else
6473
  echo "$as_me: failed program was:" >&5
6474
sed 's/^/| /' conftest.$ac_ext >&5
6475
 
6476
  ac_header_preproc=no
6477
fi
6478
rm -f conftest.err conftest.$ac_ext
6479
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6480
echo "${ECHO_T}$ac_header_preproc" >&6
6481
 
6482
# So?  What about this header?
6483
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6484
  yes:no: )
6485
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6486
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6487
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6488
echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6489
    ac_header_preproc=yes
6490
    ;;
6491
  no:yes:* )
6492
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6493
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6494
    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6495
echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6496
    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6497
echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6498
    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6499
echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6500
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6501
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6502
    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6503
echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6504
    (
6505
      cat <<\_ASBOX
6506
## ------------------------------------------------------ ##
6507
## Report this to the GNU Fortran Runtime Library lists.  ##
6508
## ------------------------------------------------------ ##
6509
_ASBOX
6510
    ) |
6511
      sed "s/^/$as_me: WARNING:     /" >&2
6512
    ;;
6513
esac
6514
echo "$as_me:$LINENO: checking for $ac_header" >&5
6515
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6516
if eval "test \"\${$as_ac_Header+set}\" = set"; then
6517
  echo $ECHO_N "(cached) $ECHO_C" >&6
6518
else
6519
  eval "$as_ac_Header=\$ac_header_preproc"
6520
fi
6521
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6522
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6523
 
6524
fi
6525
if test `eval echo '${'$as_ac_Header'}'` = yes; then
6526
  cat >>confdefs.h <<_ACEOF
6527
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6528
_ACEOF
6529
 
6530
fi
6531
 
6532
done
6533
 
6534
 
6535
 
6536
 
6537
 
6538
for ac_header in sys/types.h sys/stat.h floatingpoint.h ieeefp.h
6539
do
6540
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6541
if eval "test \"\${$as_ac_Header+set}\" = set"; then
6542
  echo "$as_me:$LINENO: checking for $ac_header" >&5
6543
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6544
if eval "test \"\${$as_ac_Header+set}\" = set"; then
6545
  echo $ECHO_N "(cached) $ECHO_C" >&6
6546
fi
6547
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6548
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6549
else
6550
  # Is the header compilable?
6551
echo "$as_me:$LINENO: checking $ac_header usability" >&5
6552
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6553
cat >conftest.$ac_ext <<_ACEOF
6554
/* confdefs.h.  */
6555
_ACEOF
6556
cat confdefs.h >>conftest.$ac_ext
6557
cat >>conftest.$ac_ext <<_ACEOF
6558
/* end confdefs.h.  */
6559
$ac_includes_default
6560
#include <$ac_header>
6561
_ACEOF
6562
rm -f conftest.$ac_objext
6563
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6564
  (eval $ac_compile) 2>conftest.er1
6565
  ac_status=$?
6566
  grep -v '^ *+' conftest.er1 >conftest.err
6567
  rm -f conftest.er1
6568
  cat conftest.err >&5
6569
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6570
  (exit $ac_status); } &&
6571
         { ac_try='test -z "$ac_c_werror_flag"
6572
                         || test ! -s conftest.err'
6573
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6574
  (eval $ac_try) 2>&5
6575
  ac_status=$?
6576
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6577
  (exit $ac_status); }; } &&
6578
         { ac_try='test -s conftest.$ac_objext'
6579
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6580
  (eval $ac_try) 2>&5
6581
  ac_status=$?
6582
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6583
  (exit $ac_status); }; }; then
6584
  ac_header_compiler=yes
6585
else
6586
  echo "$as_me: failed program was:" >&5
6587
sed 's/^/| /' conftest.$ac_ext >&5
6588
 
6589
ac_header_compiler=no
6590
fi
6591
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6592
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6593
echo "${ECHO_T}$ac_header_compiler" >&6
6594
 
6595
# Is the header present?
6596
echo "$as_me:$LINENO: checking $ac_header presence" >&5
6597
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
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
#include <$ac_header>
6605
_ACEOF
6606
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6607
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6608
  ac_status=$?
6609
  grep -v '^ *+' conftest.er1 >conftest.err
6610
  rm -f conftest.er1
6611
  cat conftest.err >&5
6612
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6613
  (exit $ac_status); } >/dev/null; then
6614
  if test -s conftest.err; then
6615
    ac_cpp_err=$ac_c_preproc_warn_flag
6616
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6617
  else
6618
    ac_cpp_err=
6619
  fi
6620
else
6621
  ac_cpp_err=yes
6622
fi
6623
if test -z "$ac_cpp_err"; then
6624
  ac_header_preproc=yes
6625
else
6626
  echo "$as_me: failed program was:" >&5
6627
sed 's/^/| /' conftest.$ac_ext >&5
6628
 
6629
  ac_header_preproc=no
6630
fi
6631
rm -f conftest.err conftest.$ac_ext
6632
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6633
echo "${ECHO_T}$ac_header_preproc" >&6
6634
 
6635
# So?  What about this header?
6636
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6637
  yes:no: )
6638
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6639
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6640
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6641
echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6642
    ac_header_preproc=yes
6643
    ;;
6644
  no:yes:* )
6645
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6646
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6647
    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6648
echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6649
    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6650
echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6651
    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6652
echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6653
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6654
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6655
    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6656
echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6657
    (
6658
      cat <<\_ASBOX
6659
## ------------------------------------------------------ ##
6660
## Report this to the GNU Fortran Runtime Library lists.  ##
6661
## ------------------------------------------------------ ##
6662
_ASBOX
6663
    ) |
6664
      sed "s/^/$as_me: WARNING:     /" >&2
6665
    ;;
6666
esac
6667
echo "$as_me:$LINENO: checking for $ac_header" >&5
6668
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6669
if eval "test \"\${$as_ac_Header+set}\" = set"; then
6670
  echo $ECHO_N "(cached) $ECHO_C" >&6
6671
else
6672
  eval "$as_ac_Header=\$ac_header_preproc"
6673
fi
6674
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6675
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6676
 
6677
fi
6678
if test `eval echo '${'$as_ac_Header'}'` = yes; then
6679
  cat >>confdefs.h <<_ACEOF
6680
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6681
_ACEOF
6682
 
6683
fi
6684
 
6685
done
6686
 
6687
 
6688
 
6689
 
6690
for ac_header in fenv.h fptrap.h float.h
6691
do
6692
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6693
if eval "test \"\${$as_ac_Header+set}\" = set"; then
6694
  echo "$as_me:$LINENO: checking for $ac_header" >&5
6695
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6696
if eval "test \"\${$as_ac_Header+set}\" = set"; then
6697
  echo $ECHO_N "(cached) $ECHO_C" >&6
6698
fi
6699
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6700
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6701
else
6702
  # Is the header compilable?
6703
echo "$as_me:$LINENO: checking $ac_header usability" >&5
6704
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6705
cat >conftest.$ac_ext <<_ACEOF
6706
/* confdefs.h.  */
6707
_ACEOF
6708
cat confdefs.h >>conftest.$ac_ext
6709
cat >>conftest.$ac_ext <<_ACEOF
6710
/* end confdefs.h.  */
6711
$ac_includes_default
6712
#include <$ac_header>
6713
_ACEOF
6714
rm -f conftest.$ac_objext
6715
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6716
  (eval $ac_compile) 2>conftest.er1
6717
  ac_status=$?
6718
  grep -v '^ *+' conftest.er1 >conftest.err
6719
  rm -f conftest.er1
6720
  cat conftest.err >&5
6721
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6722
  (exit $ac_status); } &&
6723
         { ac_try='test -z "$ac_c_werror_flag"
6724
                         || test ! -s conftest.err'
6725
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6726
  (eval $ac_try) 2>&5
6727
  ac_status=$?
6728
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6729
  (exit $ac_status); }; } &&
6730
         { ac_try='test -s conftest.$ac_objext'
6731
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6732
  (eval $ac_try) 2>&5
6733
  ac_status=$?
6734
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6735
  (exit $ac_status); }; }; then
6736
  ac_header_compiler=yes
6737
else
6738
  echo "$as_me: failed program was:" >&5
6739
sed 's/^/| /' conftest.$ac_ext >&5
6740
 
6741
ac_header_compiler=no
6742
fi
6743
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6744
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6745
echo "${ECHO_T}$ac_header_compiler" >&6
6746
 
6747
# Is the header present?
6748
echo "$as_me:$LINENO: checking $ac_header presence" >&5
6749
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6750
cat >conftest.$ac_ext <<_ACEOF
6751
/* confdefs.h.  */
6752
_ACEOF
6753
cat confdefs.h >>conftest.$ac_ext
6754
cat >>conftest.$ac_ext <<_ACEOF
6755
/* end confdefs.h.  */
6756
#include <$ac_header>
6757
_ACEOF
6758
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6759
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6760
  ac_status=$?
6761
  grep -v '^ *+' conftest.er1 >conftest.err
6762
  rm -f conftest.er1
6763
  cat conftest.err >&5
6764
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6765
  (exit $ac_status); } >/dev/null; then
6766
  if test -s conftest.err; then
6767
    ac_cpp_err=$ac_c_preproc_warn_flag
6768
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6769
  else
6770
    ac_cpp_err=
6771
  fi
6772
else
6773
  ac_cpp_err=yes
6774
fi
6775
if test -z "$ac_cpp_err"; then
6776
  ac_header_preproc=yes
6777
else
6778
  echo "$as_me: failed program was:" >&5
6779
sed 's/^/| /' conftest.$ac_ext >&5
6780
 
6781
  ac_header_preproc=no
6782
fi
6783
rm -f conftest.err conftest.$ac_ext
6784
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6785
echo "${ECHO_T}$ac_header_preproc" >&6
6786
 
6787
# So?  What about this header?
6788
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6789
  yes:no: )
6790
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6791
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6792
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6793
echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6794
    ac_header_preproc=yes
6795
    ;;
6796
  no:yes:* )
6797
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6798
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6799
    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6800
echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6801
    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6802
echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6803
    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6804
echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6805
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6806
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6807
    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6808
echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6809
    (
6810
      cat <<\_ASBOX
6811
## ------------------------------------------------------ ##
6812
## Report this to the GNU Fortran Runtime Library lists.  ##
6813
## ------------------------------------------------------ ##
6814
_ASBOX
6815
    ) |
6816
      sed "s/^/$as_me: WARNING:     /" >&2
6817
    ;;
6818
esac
6819
echo "$as_me:$LINENO: checking for $ac_header" >&5
6820
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6821
if eval "test \"\${$as_ac_Header+set}\" = set"; then
6822
  echo $ECHO_N "(cached) $ECHO_C" >&6
6823
else
6824
  eval "$as_ac_Header=\$ac_header_preproc"
6825
fi
6826
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6827
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6828
 
6829
fi
6830
if test `eval echo '${'$as_ac_Header'}'` = yes; then
6831
  cat >>confdefs.h <<_ACEOF
6832
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6833
_ACEOF
6834
 
6835
fi
6836
 
6837
done
6838
 
6839
if test "${ac_cv_header_complex_h+set}" = set; then
6840
  echo "$as_me:$LINENO: checking for complex.h" >&5
6841
echo $ECHO_N "checking for complex.h... $ECHO_C" >&6
6842
if test "${ac_cv_header_complex_h+set}" = set; then
6843
  echo $ECHO_N "(cached) $ECHO_C" >&6
6844
fi
6845
echo "$as_me:$LINENO: result: $ac_cv_header_complex_h" >&5
6846
echo "${ECHO_T}$ac_cv_header_complex_h" >&6
6847
else
6848
  # Is the header compilable?
6849
echo "$as_me:$LINENO: checking complex.h usability" >&5
6850
echo $ECHO_N "checking complex.h usability... $ECHO_C" >&6
6851
cat >conftest.$ac_ext <<_ACEOF
6852
/* confdefs.h.  */
6853
_ACEOF
6854
cat confdefs.h >>conftest.$ac_ext
6855
cat >>conftest.$ac_ext <<_ACEOF
6856
/* end confdefs.h.  */
6857
$ac_includes_default
6858
#include 
6859
_ACEOF
6860
rm -f conftest.$ac_objext
6861
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6862
  (eval $ac_compile) 2>conftest.er1
6863
  ac_status=$?
6864
  grep -v '^ *+' conftest.er1 >conftest.err
6865
  rm -f conftest.er1
6866
  cat conftest.err >&5
6867
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6868
  (exit $ac_status); } &&
6869
         { ac_try='test -z "$ac_c_werror_flag"
6870
                         || test ! -s conftest.err'
6871
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6872
  (eval $ac_try) 2>&5
6873
  ac_status=$?
6874
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6875
  (exit $ac_status); }; } &&
6876
         { ac_try='test -s conftest.$ac_objext'
6877
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6878
  (eval $ac_try) 2>&5
6879
  ac_status=$?
6880
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6881
  (exit $ac_status); }; }; then
6882
  ac_header_compiler=yes
6883
else
6884
  echo "$as_me: failed program was:" >&5
6885
sed 's/^/| /' conftest.$ac_ext >&5
6886
 
6887
ac_header_compiler=no
6888
fi
6889
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6890
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6891
echo "${ECHO_T}$ac_header_compiler" >&6
6892
 
6893
# Is the header present?
6894
echo "$as_me:$LINENO: checking complex.h presence" >&5
6895
echo $ECHO_N "checking complex.h presence... $ECHO_C" >&6
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
#include 
6903
_ACEOF
6904
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6905
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6906
  ac_status=$?
6907
  grep -v '^ *+' conftest.er1 >conftest.err
6908
  rm -f conftest.er1
6909
  cat conftest.err >&5
6910
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6911
  (exit $ac_status); } >/dev/null; then
6912
  if test -s conftest.err; then
6913
    ac_cpp_err=$ac_c_preproc_warn_flag
6914
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6915
  else
6916
    ac_cpp_err=
6917
  fi
6918
else
6919
  ac_cpp_err=yes
6920
fi
6921
if test -z "$ac_cpp_err"; then
6922
  ac_header_preproc=yes
6923
else
6924
  echo "$as_me: failed program was:" >&5
6925
sed 's/^/| /' conftest.$ac_ext >&5
6926
 
6927
  ac_header_preproc=no
6928
fi
6929
rm -f conftest.err conftest.$ac_ext
6930
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6931
echo "${ECHO_T}$ac_header_preproc" >&6
6932
 
6933
# So?  What about this header?
6934
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6935
  yes:no: )
6936
    { echo "$as_me:$LINENO: WARNING: complex.h: accepted by the compiler, rejected by the preprocessor!" >&5
6937
echo "$as_me: WARNING: complex.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6938
    { echo "$as_me:$LINENO: WARNING: complex.h: proceeding with the compiler's result" >&5
6939
echo "$as_me: WARNING: complex.h: proceeding with the compiler's result" >&2;}
6940
    ac_header_preproc=yes
6941
    ;;
6942
  no:yes:* )
6943
    { echo "$as_me:$LINENO: WARNING: complex.h: present but cannot be compiled" >&5
6944
echo "$as_me: WARNING: complex.h: present but cannot be compiled" >&2;}
6945
    { echo "$as_me:$LINENO: WARNING: complex.h:     check for missing prerequisite headers?" >&5
6946
echo "$as_me: WARNING: complex.h:     check for missing prerequisite headers?" >&2;}
6947
    { echo "$as_me:$LINENO: WARNING: complex.h: see the Autoconf documentation" >&5
6948
echo "$as_me: WARNING: complex.h: see the Autoconf documentation" >&2;}
6949
    { echo "$as_me:$LINENO: WARNING: complex.h:     section \"Present But Cannot Be Compiled\"" >&5
6950
echo "$as_me: WARNING: complex.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6951
    { echo "$as_me:$LINENO: WARNING: complex.h: proceeding with the preprocessor's result" >&5
6952
echo "$as_me: WARNING: complex.h: proceeding with the preprocessor's result" >&2;}
6953
    { echo "$as_me:$LINENO: WARNING: complex.h: in the future, the compiler will take precedence" >&5
6954
echo "$as_me: WARNING: complex.h: in the future, the compiler will take precedence" >&2;}
6955
    (
6956
      cat <<\_ASBOX
6957
## ------------------------------------------------------ ##
6958
## Report this to the GNU Fortran Runtime Library lists.  ##
6959
## ------------------------------------------------------ ##
6960
_ASBOX
6961
    ) |
6962
      sed "s/^/$as_me: WARNING:     /" >&2
6963
    ;;
6964
esac
6965
echo "$as_me:$LINENO: checking for complex.h" >&5
6966
echo $ECHO_N "checking for complex.h... $ECHO_C" >&6
6967
if test "${ac_cv_header_complex_h+set}" = set; then
6968
  echo $ECHO_N "(cached) $ECHO_C" >&6
6969
else
6970
  ac_cv_header_complex_h=$ac_header_preproc
6971
fi
6972
echo "$as_me:$LINENO: result: $ac_cv_header_complex_h" >&5
6973
echo "${ECHO_T}$ac_cv_header_complex_h" >&6
6974
 
6975
fi
6976
if test $ac_cv_header_complex_h = yes; then
6977
 
6978
cat >>confdefs.h <<\_ACEOF
6979
#define HAVE_COMPLEX_H 1
6980
_ACEOF
6981
 
6982
fi
6983
 
6984
 
6985
 
6986
 
6987
inttype_headers=`echo inttypes.h sys/inttypes.h  | sed -e 's/,/ /g'`
6988
 
6989
acx_cv_header_stdint=stddef.h
6990
acx_cv_header_stdint_kind="(already complete)"
6991
for i in stdint.h $inttype_headers; do
6992
  unset ac_cv_type_uintptr_t
6993
  unset ac_cv_type_uintmax_t
6994
  unset ac_cv_type_int_least32_t
6995
  unset ac_cv_type_int_fast32_t
6996
  unset ac_cv_type_uint64_t
6997
  echo $ECHO_N "looking for a compliant stdint.h in $i, $ECHO_C" >&6
6998
  echo "$as_me:$LINENO: checking for uintmax_t" >&5
6999
echo $ECHO_N "checking for uintmax_t... $ECHO_C" >&6
7000
if test "${ac_cv_type_uintmax_t+set}" = set; then
7001
  echo $ECHO_N "(cached) $ECHO_C" >&6
7002
else
7003
  cat >conftest.$ac_ext <<_ACEOF
7004
/* confdefs.h.  */
7005
_ACEOF
7006
cat confdefs.h >>conftest.$ac_ext
7007
cat >>conftest.$ac_ext <<_ACEOF
7008
/* end confdefs.h.  */
7009
#include 
7010
#include <$i>
7011
 
7012
int
7013
main ()
7014
{
7015
if ((uintmax_t *) 0)
7016
  return 0;
7017
if (sizeof (uintmax_t))
7018
  return 0;
7019
  ;
7020
  return 0;
7021
}
7022
_ACEOF
7023
rm -f conftest.$ac_objext
7024
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7025
  (eval $ac_compile) 2>conftest.er1
7026
  ac_status=$?
7027
  grep -v '^ *+' conftest.er1 >conftest.err
7028
  rm -f conftest.er1
7029
  cat conftest.err >&5
7030
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7031
  (exit $ac_status); } &&
7032
         { ac_try='test -z "$ac_c_werror_flag"
7033
                         || test ! -s conftest.err'
7034
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7035
  (eval $ac_try) 2>&5
7036
  ac_status=$?
7037
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7038
  (exit $ac_status); }; } &&
7039
         { ac_try='test -s conftest.$ac_objext'
7040
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7041
  (eval $ac_try) 2>&5
7042
  ac_status=$?
7043
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7044
  (exit $ac_status); }; }; then
7045
  ac_cv_type_uintmax_t=yes
7046
else
7047
  echo "$as_me: failed program was:" >&5
7048
sed 's/^/| /' conftest.$ac_ext >&5
7049
 
7050
ac_cv_type_uintmax_t=no
7051
fi
7052
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7053
fi
7054
echo "$as_me:$LINENO: result: $ac_cv_type_uintmax_t" >&5
7055
echo "${ECHO_T}$ac_cv_type_uintmax_t" >&6
7056
if test $ac_cv_type_uintmax_t = yes; then
7057
  acx_cv_header_stdint=$i
7058
else
7059
  continue
7060
fi
7061
 
7062
  echo "$as_me:$LINENO: checking for uintptr_t" >&5
7063
echo $ECHO_N "checking for uintptr_t... $ECHO_C" >&6
7064
if test "${ac_cv_type_uintptr_t+set}" = set; then
7065
  echo $ECHO_N "(cached) $ECHO_C" >&6
7066
else
7067
  cat >conftest.$ac_ext <<_ACEOF
7068
/* confdefs.h.  */
7069
_ACEOF
7070
cat confdefs.h >>conftest.$ac_ext
7071
cat >>conftest.$ac_ext <<_ACEOF
7072
/* end confdefs.h.  */
7073
#include 
7074
#include <$i>
7075
 
7076
int
7077
main ()
7078
{
7079
if ((uintptr_t *) 0)
7080
  return 0;
7081
if (sizeof (uintptr_t))
7082
  return 0;
7083
  ;
7084
  return 0;
7085
}
7086
_ACEOF
7087
rm -f conftest.$ac_objext
7088
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7089
  (eval $ac_compile) 2>conftest.er1
7090
  ac_status=$?
7091
  grep -v '^ *+' conftest.er1 >conftest.err
7092
  rm -f conftest.er1
7093
  cat conftest.err >&5
7094
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7095
  (exit $ac_status); } &&
7096
         { ac_try='test -z "$ac_c_werror_flag"
7097
                         || test ! -s conftest.err'
7098
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7099
  (eval $ac_try) 2>&5
7100
  ac_status=$?
7101
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7102
  (exit $ac_status); }; } &&
7103
         { ac_try='test -s conftest.$ac_objext'
7104
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7105
  (eval $ac_try) 2>&5
7106
  ac_status=$?
7107
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7108
  (exit $ac_status); }; }; then
7109
  ac_cv_type_uintptr_t=yes
7110
else
7111
  echo "$as_me: failed program was:" >&5
7112
sed 's/^/| /' conftest.$ac_ext >&5
7113
 
7114
ac_cv_type_uintptr_t=no
7115
fi
7116
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7117
fi
7118
echo "$as_me:$LINENO: result: $ac_cv_type_uintptr_t" >&5
7119
echo "${ECHO_T}$ac_cv_type_uintptr_t" >&6
7120
if test $ac_cv_type_uintptr_t = yes; then
7121
  :
7122
else
7123
  acx_cv_header_stdint_kind="(mostly complete)"
7124
fi
7125
 
7126
  echo "$as_me:$LINENO: checking for int_least32_t" >&5
7127
echo $ECHO_N "checking for int_least32_t... $ECHO_C" >&6
7128
if test "${ac_cv_type_int_least32_t+set}" = set; then
7129
  echo $ECHO_N "(cached) $ECHO_C" >&6
7130
else
7131
  cat >conftest.$ac_ext <<_ACEOF
7132
/* confdefs.h.  */
7133
_ACEOF
7134
cat confdefs.h >>conftest.$ac_ext
7135
cat >>conftest.$ac_ext <<_ACEOF
7136
/* end confdefs.h.  */
7137
#include 
7138
#include <$i>
7139
 
7140
int
7141
main ()
7142
{
7143
if ((int_least32_t *) 0)
7144
  return 0;
7145
if (sizeof (int_least32_t))
7146
  return 0;
7147
  ;
7148
  return 0;
7149
}
7150
_ACEOF
7151
rm -f conftest.$ac_objext
7152
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7153
  (eval $ac_compile) 2>conftest.er1
7154
  ac_status=$?
7155
  grep -v '^ *+' conftest.er1 >conftest.err
7156
  rm -f conftest.er1
7157
  cat conftest.err >&5
7158
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7159
  (exit $ac_status); } &&
7160
         { ac_try='test -z "$ac_c_werror_flag"
7161
                         || test ! -s conftest.err'
7162
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7163
  (eval $ac_try) 2>&5
7164
  ac_status=$?
7165
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7166
  (exit $ac_status); }; } &&
7167
         { ac_try='test -s conftest.$ac_objext'
7168
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7169
  (eval $ac_try) 2>&5
7170
  ac_status=$?
7171
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7172
  (exit $ac_status); }; }; then
7173
  ac_cv_type_int_least32_t=yes
7174
else
7175
  echo "$as_me: failed program was:" >&5
7176
sed 's/^/| /' conftest.$ac_ext >&5
7177
 
7178
ac_cv_type_int_least32_t=no
7179
fi
7180
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7181
fi
7182
echo "$as_me:$LINENO: result: $ac_cv_type_int_least32_t" >&5
7183
echo "${ECHO_T}$ac_cv_type_int_least32_t" >&6
7184
if test $ac_cv_type_int_least32_t = yes; then
7185
  :
7186
else
7187
  acx_cv_header_stdint_kind="(mostly complete)"
7188
fi
7189
 
7190
  echo "$as_me:$LINENO: checking for int_fast32_t" >&5
7191
echo $ECHO_N "checking for int_fast32_t... $ECHO_C" >&6
7192
if test "${ac_cv_type_int_fast32_t+set}" = set; then
7193
  echo $ECHO_N "(cached) $ECHO_C" >&6
7194
else
7195
  cat >conftest.$ac_ext <<_ACEOF
7196
/* confdefs.h.  */
7197
_ACEOF
7198
cat confdefs.h >>conftest.$ac_ext
7199
cat >>conftest.$ac_ext <<_ACEOF
7200
/* end confdefs.h.  */
7201
#include 
7202
#include <$i>
7203
 
7204
int
7205
main ()
7206
{
7207
if ((int_fast32_t *) 0)
7208
  return 0;
7209
if (sizeof (int_fast32_t))
7210
  return 0;
7211
  ;
7212
  return 0;
7213
}
7214
_ACEOF
7215
rm -f conftest.$ac_objext
7216
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7217
  (eval $ac_compile) 2>conftest.er1
7218
  ac_status=$?
7219
  grep -v '^ *+' conftest.er1 >conftest.err
7220
  rm -f conftest.er1
7221
  cat conftest.err >&5
7222
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7223
  (exit $ac_status); } &&
7224
         { ac_try='test -z "$ac_c_werror_flag"
7225
                         || test ! -s conftest.err'
7226
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7227
  (eval $ac_try) 2>&5
7228
  ac_status=$?
7229
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7230
  (exit $ac_status); }; } &&
7231
         { ac_try='test -s conftest.$ac_objext'
7232
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7233
  (eval $ac_try) 2>&5
7234
  ac_status=$?
7235
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7236
  (exit $ac_status); }; }; then
7237
  ac_cv_type_int_fast32_t=yes
7238
else
7239
  echo "$as_me: failed program was:" >&5
7240
sed 's/^/| /' conftest.$ac_ext >&5
7241
 
7242
ac_cv_type_int_fast32_t=no
7243
fi
7244
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7245
fi
7246
echo "$as_me:$LINENO: result: $ac_cv_type_int_fast32_t" >&5
7247
echo "${ECHO_T}$ac_cv_type_int_fast32_t" >&6
7248
if test $ac_cv_type_int_fast32_t = yes; then
7249
  :
7250
else
7251
  acx_cv_header_stdint_kind="(mostly complete)"
7252
fi
7253
 
7254
  echo "$as_me:$LINENO: checking for uint64_t" >&5
7255
echo $ECHO_N "checking for uint64_t... $ECHO_C" >&6
7256
if test "${ac_cv_type_uint64_t+set}" = set; then
7257
  echo $ECHO_N "(cached) $ECHO_C" >&6
7258
else
7259
  cat >conftest.$ac_ext <<_ACEOF
7260
/* confdefs.h.  */
7261
_ACEOF
7262
cat confdefs.h >>conftest.$ac_ext
7263
cat >>conftest.$ac_ext <<_ACEOF
7264
/* end confdefs.h.  */
7265
#include 
7266
#include <$i>
7267
 
7268
int
7269
main ()
7270
{
7271
if ((uint64_t *) 0)
7272
  return 0;
7273
if (sizeof (uint64_t))
7274
  return 0;
7275
  ;
7276
  return 0;
7277
}
7278
_ACEOF
7279
rm -f conftest.$ac_objext
7280
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7281
  (eval $ac_compile) 2>conftest.er1
7282
  ac_status=$?
7283
  grep -v '^ *+' conftest.er1 >conftest.err
7284
  rm -f conftest.er1
7285
  cat conftest.err >&5
7286
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7287
  (exit $ac_status); } &&
7288
         { ac_try='test -z "$ac_c_werror_flag"
7289
                         || test ! -s conftest.err'
7290
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7291
  (eval $ac_try) 2>&5
7292
  ac_status=$?
7293
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7294
  (exit $ac_status); }; } &&
7295
         { ac_try='test -s conftest.$ac_objext'
7296
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7297
  (eval $ac_try) 2>&5
7298
  ac_status=$?
7299
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7300
  (exit $ac_status); }; }; then
7301
  ac_cv_type_uint64_t=yes
7302
else
7303
  echo "$as_me: failed program was:" >&5
7304
sed 's/^/| /' conftest.$ac_ext >&5
7305
 
7306
ac_cv_type_uint64_t=no
7307
fi
7308
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7309
fi
7310
echo "$as_me:$LINENO: result: $ac_cv_type_uint64_t" >&5
7311
echo "${ECHO_T}$ac_cv_type_uint64_t" >&6
7312
if test $ac_cv_type_uint64_t = yes; then
7313
  :
7314
else
7315
  acx_cv_header_stdint_kind="(lacks uint64_t)"
7316
fi
7317
 
7318
  break
7319
done
7320
if test "$acx_cv_header_stdint" = stddef.h; then
7321
  acx_cv_header_stdint_kind="(lacks uintptr_t)"
7322
  for i in stdint.h $inttype_headers; do
7323
    unset ac_cv_type_uint32_t
7324
    unset ac_cv_type_uint64_t
7325
    echo $ECHO_N "looking for an incomplete stdint.h in $i, $ECHO_C" >&6
7326
    echo "$as_me:$LINENO: checking for uint32_t" >&5
7327
echo $ECHO_N "checking for uint32_t... $ECHO_C" >&6
7328
if test "${ac_cv_type_uint32_t+set}" = set; then
7329
  echo $ECHO_N "(cached) $ECHO_C" >&6
7330
else
7331
  cat >conftest.$ac_ext <<_ACEOF
7332
/* confdefs.h.  */
7333
_ACEOF
7334
cat confdefs.h >>conftest.$ac_ext
7335
cat >>conftest.$ac_ext <<_ACEOF
7336
/* end confdefs.h.  */
7337
#include 
7338
#include <$i>
7339
 
7340
int
7341
main ()
7342
{
7343
if ((uint32_t *) 0)
7344
  return 0;
7345
if (sizeof (uint32_t))
7346
  return 0;
7347
  ;
7348
  return 0;
7349
}
7350
_ACEOF
7351
rm -f conftest.$ac_objext
7352
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7353
  (eval $ac_compile) 2>conftest.er1
7354
  ac_status=$?
7355
  grep -v '^ *+' conftest.er1 >conftest.err
7356
  rm -f conftest.er1
7357
  cat conftest.err >&5
7358
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7359
  (exit $ac_status); } &&
7360
         { ac_try='test -z "$ac_c_werror_flag"
7361
                         || test ! -s conftest.err'
7362
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7363
  (eval $ac_try) 2>&5
7364
  ac_status=$?
7365
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7366
  (exit $ac_status); }; } &&
7367
         { ac_try='test -s conftest.$ac_objext'
7368
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7369
  (eval $ac_try) 2>&5
7370
  ac_status=$?
7371
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7372
  (exit $ac_status); }; }; then
7373
  ac_cv_type_uint32_t=yes
7374
else
7375
  echo "$as_me: failed program was:" >&5
7376
sed 's/^/| /' conftest.$ac_ext >&5
7377
 
7378
ac_cv_type_uint32_t=no
7379
fi
7380
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7381
fi
7382
echo "$as_me:$LINENO: result: $ac_cv_type_uint32_t" >&5
7383
echo "${ECHO_T}$ac_cv_type_uint32_t" >&6
7384
if test $ac_cv_type_uint32_t = yes; then
7385
  acx_cv_header_stdint=$i
7386
else
7387
  continue
7388
fi
7389
 
7390
    echo "$as_me:$LINENO: checking for uint64_t" >&5
7391
echo $ECHO_N "checking for uint64_t... $ECHO_C" >&6
7392
if test "${ac_cv_type_uint64_t+set}" = set; then
7393
  echo $ECHO_N "(cached) $ECHO_C" >&6
7394
else
7395
  cat >conftest.$ac_ext <<_ACEOF
7396
/* confdefs.h.  */
7397
_ACEOF
7398
cat confdefs.h >>conftest.$ac_ext
7399
cat >>conftest.$ac_ext <<_ACEOF
7400
/* end confdefs.h.  */
7401
#include 
7402
#include <$i>
7403
 
7404
int
7405
main ()
7406
{
7407
if ((uint64_t *) 0)
7408
  return 0;
7409
if (sizeof (uint64_t))
7410
  return 0;
7411
  ;
7412
  return 0;
7413
}
7414
_ACEOF
7415
rm -f conftest.$ac_objext
7416
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7417
  (eval $ac_compile) 2>conftest.er1
7418
  ac_status=$?
7419
  grep -v '^ *+' conftest.er1 >conftest.err
7420
  rm -f conftest.er1
7421
  cat conftest.err >&5
7422
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7423
  (exit $ac_status); } &&
7424
         { ac_try='test -z "$ac_c_werror_flag"
7425
                         || test ! -s conftest.err'
7426
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7427
  (eval $ac_try) 2>&5
7428
  ac_status=$?
7429
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7430
  (exit $ac_status); }; } &&
7431
         { ac_try='test -s conftest.$ac_objext'
7432
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7433
  (eval $ac_try) 2>&5
7434
  ac_status=$?
7435
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7436
  (exit $ac_status); }; }; then
7437
  ac_cv_type_uint64_t=yes
7438
else
7439
  echo "$as_me: failed program was:" >&5
7440
sed 's/^/| /' conftest.$ac_ext >&5
7441
 
7442
ac_cv_type_uint64_t=no
7443
fi
7444
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7445
fi
7446
echo "$as_me:$LINENO: result: $ac_cv_type_uint64_t" >&5
7447
echo "${ECHO_T}$ac_cv_type_uint64_t" >&6
7448
if test $ac_cv_type_uint64_t = yes; then
7449
  :
7450
else
7451
  acx_cv_header_stdint_kind="(lacks uintptr_t and uint64_t)"
7452
fi
7453
 
7454
    break
7455
  done
7456
fi
7457
if test "$acx_cv_header_stdint" = stddef.h; then
7458
  acx_cv_header_stdint_kind="(u_intXX_t style)"
7459
  for i in sys/types.h $inttype_headers; do
7460
    unset ac_cv_type_u_int32_t
7461
    unset ac_cv_type_u_int64_t
7462
    echo $ECHO_N "looking for u_intXX_t types in $i, $ECHO_C" >&6
7463
    echo "$as_me:$LINENO: checking for u_int32_t" >&5
7464
echo $ECHO_N "checking for u_int32_t... $ECHO_C" >&6
7465
if test "${ac_cv_type_u_int32_t+set}" = set; then
7466
  echo $ECHO_N "(cached) $ECHO_C" >&6
7467
else
7468
  cat >conftest.$ac_ext <<_ACEOF
7469
/* confdefs.h.  */
7470
_ACEOF
7471
cat confdefs.h >>conftest.$ac_ext
7472
cat >>conftest.$ac_ext <<_ACEOF
7473
/* end confdefs.h.  */
7474
#include 
7475
#include <$i>
7476
 
7477
int
7478
main ()
7479
{
7480
if ((u_int32_t *) 0)
7481
  return 0;
7482
if (sizeof (u_int32_t))
7483
  return 0;
7484
  ;
7485
  return 0;
7486
}
7487
_ACEOF
7488
rm -f conftest.$ac_objext
7489
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7490
  (eval $ac_compile) 2>conftest.er1
7491
  ac_status=$?
7492
  grep -v '^ *+' conftest.er1 >conftest.err
7493
  rm -f conftest.er1
7494
  cat conftest.err >&5
7495
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7496
  (exit $ac_status); } &&
7497
         { ac_try='test -z "$ac_c_werror_flag"
7498
                         || test ! -s conftest.err'
7499
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7500
  (eval $ac_try) 2>&5
7501
  ac_status=$?
7502
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7503
  (exit $ac_status); }; } &&
7504
         { ac_try='test -s conftest.$ac_objext'
7505
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7506
  (eval $ac_try) 2>&5
7507
  ac_status=$?
7508
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7509
  (exit $ac_status); }; }; then
7510
  ac_cv_type_u_int32_t=yes
7511
else
7512
  echo "$as_me: failed program was:" >&5
7513
sed 's/^/| /' conftest.$ac_ext >&5
7514
 
7515
ac_cv_type_u_int32_t=no
7516
fi
7517
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7518
fi
7519
echo "$as_me:$LINENO: result: $ac_cv_type_u_int32_t" >&5
7520
echo "${ECHO_T}$ac_cv_type_u_int32_t" >&6
7521
if test $ac_cv_type_u_int32_t = yes; then
7522
  acx_cv_header_stdint=$i
7523
else
7524
  continue
7525
fi
7526
 
7527
    echo "$as_me:$LINENO: checking for u_int64_t" >&5
7528
echo $ECHO_N "checking for u_int64_t... $ECHO_C" >&6
7529
if test "${ac_cv_type_u_int64_t+set}" = set; then
7530
  echo $ECHO_N "(cached) $ECHO_C" >&6
7531
else
7532
  cat >conftest.$ac_ext <<_ACEOF
7533
/* confdefs.h.  */
7534
_ACEOF
7535
cat confdefs.h >>conftest.$ac_ext
7536
cat >>conftest.$ac_ext <<_ACEOF
7537
/* end confdefs.h.  */
7538
#include 
7539
#include <$i>
7540
 
7541
int
7542
main ()
7543
{
7544
if ((u_int64_t *) 0)
7545
  return 0;
7546
if (sizeof (u_int64_t))
7547
  return 0;
7548
  ;
7549
  return 0;
7550
}
7551
_ACEOF
7552
rm -f conftest.$ac_objext
7553
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7554
  (eval $ac_compile) 2>conftest.er1
7555
  ac_status=$?
7556
  grep -v '^ *+' conftest.er1 >conftest.err
7557
  rm -f conftest.er1
7558
  cat conftest.err >&5
7559
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7560
  (exit $ac_status); } &&
7561
         { ac_try='test -z "$ac_c_werror_flag"
7562
                         || test ! -s conftest.err'
7563
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7564
  (eval $ac_try) 2>&5
7565
  ac_status=$?
7566
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7567
  (exit $ac_status); }; } &&
7568
         { ac_try='test -s conftest.$ac_objext'
7569
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7570
  (eval $ac_try) 2>&5
7571
  ac_status=$?
7572
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7573
  (exit $ac_status); }; }; then
7574
  ac_cv_type_u_int64_t=yes
7575
else
7576
  echo "$as_me: failed program was:" >&5
7577
sed 's/^/| /' conftest.$ac_ext >&5
7578
 
7579
ac_cv_type_u_int64_t=no
7580
fi
7581
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7582
fi
7583
echo "$as_me:$LINENO: result: $ac_cv_type_u_int64_t" >&5
7584
echo "${ECHO_T}$ac_cv_type_u_int64_t" >&6
7585
if test $ac_cv_type_u_int64_t = yes; then
7586
  :
7587
else
7588
  acx_cv_header_stdint_kind="(u_intXX_t style, lacks u_int64_t)"
7589
fi
7590
 
7591
    break
7592
  done
7593
fi
7594
if test "$acx_cv_header_stdint" = stddef.h; then
7595
  acx_cv_header_stdint_kind="(using manual detection)"
7596
fi
7597
 
7598
test -z "$ac_cv_type_uintptr_t" && ac_cv_type_uintptr_t=no
7599
test -z "$ac_cv_type_uint64_t" && ac_cv_type_uint64_t=no
7600
test -z "$ac_cv_type_u_int64_t" && ac_cv_type_u_int64_t=no
7601
test -z "$ac_cv_type_int_least32_t" && ac_cv_type_int_least32_t=no
7602
test -z "$ac_cv_type_int_fast32_t" && ac_cv_type_int_fast32_t=no
7603
 
7604
# ----------------- Summarize what we found so far
7605
 
7606
echo "$as_me:$LINENO: checking what to include in gstdint.h" >&5
7607
echo $ECHO_N "checking what to include in gstdint.h... $ECHO_C" >&6
7608
 
7609
case `$as_basename gstdint.h ||
7610
$as_expr X/gstdint.h : '.*/\([^/][^/]*\)/*$' \| \
7611
         Xgstdint.h : 'X\(//\)$' \| \
7612
         Xgstdint.h : 'X\(/\)$' \| \
7613
         .     : '\(.\)' 2>/dev/null ||
7614
echo X/gstdint.h |
7615
    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
7616
          /^X\/\(\/\/\)$/{ s//\1/; q; }
7617
          /^X\/\(\/\).*/{ s//\1/; q; }
7618
          s/.*/./; q'` in
7619
  stdint.h) { echo "$as_me:$LINENO: WARNING: are you sure you want it there?" >&5
7620
echo "$as_me: WARNING: are you sure you want it there?" >&2;} ;;
7621
  inttypes.h) { echo "$as_me:$LINENO: WARNING: are you sure you want it there?" >&5
7622
echo "$as_me: WARNING: are you sure you want it there?" >&2;} ;;
7623
  *) ;;
7624
esac
7625
 
7626
echo "$as_me:$LINENO: result: $acx_cv_header_stdint $acx_cv_header_stdint_kind" >&5
7627
echo "${ECHO_T}$acx_cv_header_stdint $acx_cv_header_stdint_kind" >&6
7628
 
7629
# ----------------- done included file, check C basic types --------
7630
 
7631
# Lacking an uintptr_t?  Test size of void *
7632
case "$acx_cv_header_stdint:$ac_cv_type_uintptr_t" in
7633
  stddef.h:* | *:no) echo "$as_me:$LINENO: checking for void *" >&5
7634
echo $ECHO_N "checking for void *... $ECHO_C" >&6
7635
if test "${ac_cv_type_void_p+set}" = set; then
7636
  echo $ECHO_N "(cached) $ECHO_C" >&6
7637
else
7638
  cat >conftest.$ac_ext <<_ACEOF
7639
/* confdefs.h.  */
7640
_ACEOF
7641
cat confdefs.h >>conftest.$ac_ext
7642
cat >>conftest.$ac_ext <<_ACEOF
7643
/* end confdefs.h.  */
7644
$ac_includes_default
7645
int
7646
main ()
7647
{
7648
if ((void * *) 0)
7649
  return 0;
7650
if (sizeof (void *))
7651
  return 0;
7652
  ;
7653
  return 0;
7654
}
7655
_ACEOF
7656
rm -f conftest.$ac_objext
7657
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7658
  (eval $ac_compile) 2>conftest.er1
7659
  ac_status=$?
7660
  grep -v '^ *+' conftest.er1 >conftest.err
7661
  rm -f conftest.er1
7662
  cat conftest.err >&5
7663
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7664
  (exit $ac_status); } &&
7665
         { ac_try='test -z "$ac_c_werror_flag"
7666
                         || test ! -s conftest.err'
7667
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7668
  (eval $ac_try) 2>&5
7669
  ac_status=$?
7670
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7671
  (exit $ac_status); }; } &&
7672
         { ac_try='test -s conftest.$ac_objext'
7673
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7674
  (eval $ac_try) 2>&5
7675
  ac_status=$?
7676
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7677
  (exit $ac_status); }; }; then
7678
  ac_cv_type_void_p=yes
7679
else
7680
  echo "$as_me: failed program was:" >&5
7681
sed 's/^/| /' conftest.$ac_ext >&5
7682
 
7683
ac_cv_type_void_p=no
7684
fi
7685
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7686
fi
7687
echo "$as_me:$LINENO: result: $ac_cv_type_void_p" >&5
7688
echo "${ECHO_T}$ac_cv_type_void_p" >&6
7689
 
7690
echo "$as_me:$LINENO: checking size of void *" >&5
7691
echo $ECHO_N "checking size of void *... $ECHO_C" >&6
7692
if test "${ac_cv_sizeof_void_p+set}" = set; then
7693
  echo $ECHO_N "(cached) $ECHO_C" >&6
7694
else
7695
  if test "$ac_cv_type_void_p" = yes; then
7696
  # The cast to unsigned long works around a bug in the HP C Compiler
7697
  # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
7698
  # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
7699
  # This bug is HP SR number 8606223364.
7700
  if test "$cross_compiling" = yes; then
7701
  # Depending upon the size, compute the lo and hi bounds.
7702
cat >conftest.$ac_ext <<_ACEOF
7703
/* confdefs.h.  */
7704
_ACEOF
7705
cat confdefs.h >>conftest.$ac_ext
7706
cat >>conftest.$ac_ext <<_ACEOF
7707
/* end confdefs.h.  */
7708
$ac_includes_default
7709
int
7710
main ()
7711
{
7712
static int test_array [1 - 2 * !(((long) (sizeof (void *))) >= 0)];
7713
test_array [0] = 0
7714
 
7715
  ;
7716
  return 0;
7717
}
7718
_ACEOF
7719
rm -f conftest.$ac_objext
7720
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7721
  (eval $ac_compile) 2>conftest.er1
7722
  ac_status=$?
7723
  grep -v '^ *+' conftest.er1 >conftest.err
7724
  rm -f conftest.er1
7725
  cat conftest.err >&5
7726
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7727
  (exit $ac_status); } &&
7728
         { ac_try='test -z "$ac_c_werror_flag"
7729
                         || test ! -s conftest.err'
7730
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7731
  (eval $ac_try) 2>&5
7732
  ac_status=$?
7733
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7734
  (exit $ac_status); }; } &&
7735
         { ac_try='test -s conftest.$ac_objext'
7736
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7737
  (eval $ac_try) 2>&5
7738
  ac_status=$?
7739
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7740
  (exit $ac_status); }; }; then
7741
  ac_lo=0 ac_mid=0
7742
  while :; do
7743
    cat >conftest.$ac_ext <<_ACEOF
7744
/* confdefs.h.  */
7745
_ACEOF
7746
cat confdefs.h >>conftest.$ac_ext
7747
cat >>conftest.$ac_ext <<_ACEOF
7748
/* end confdefs.h.  */
7749
$ac_includes_default
7750
int
7751
main ()
7752
{
7753
static int test_array [1 - 2 * !(((long) (sizeof (void *))) <= $ac_mid)];
7754
test_array [0] = 0
7755
 
7756
  ;
7757
  return 0;
7758
}
7759
_ACEOF
7760
rm -f conftest.$ac_objext
7761
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7762
  (eval $ac_compile) 2>conftest.er1
7763
  ac_status=$?
7764
  grep -v '^ *+' conftest.er1 >conftest.err
7765
  rm -f conftest.er1
7766
  cat conftest.err >&5
7767
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7768
  (exit $ac_status); } &&
7769
         { ac_try='test -z "$ac_c_werror_flag"
7770
                         || test ! -s conftest.err'
7771
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7772
  (eval $ac_try) 2>&5
7773
  ac_status=$?
7774
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7775
  (exit $ac_status); }; } &&
7776
         { ac_try='test -s conftest.$ac_objext'
7777
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7778
  (eval $ac_try) 2>&5
7779
  ac_status=$?
7780
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7781
  (exit $ac_status); }; }; then
7782
  ac_hi=$ac_mid; break
7783
else
7784
  echo "$as_me: failed program was:" >&5
7785
sed 's/^/| /' conftest.$ac_ext >&5
7786
 
7787
ac_lo=`expr $ac_mid + 1`
7788
                    if test $ac_lo -le $ac_mid; then
7789
                      ac_lo= ac_hi=
7790
                      break
7791
                    fi
7792
                    ac_mid=`expr 2 '*' $ac_mid + 1`
7793
fi
7794
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7795
  done
7796
else
7797
  echo "$as_me: failed program was:" >&5
7798
sed 's/^/| /' conftest.$ac_ext >&5
7799
 
7800
cat >conftest.$ac_ext <<_ACEOF
7801
/* confdefs.h.  */
7802
_ACEOF
7803
cat confdefs.h >>conftest.$ac_ext
7804
cat >>conftest.$ac_ext <<_ACEOF
7805
/* end confdefs.h.  */
7806
$ac_includes_default
7807
int
7808
main ()
7809
{
7810
static int test_array [1 - 2 * !(((long) (sizeof (void *))) < 0)];
7811
test_array [0] = 0
7812
 
7813
  ;
7814
  return 0;
7815
}
7816
_ACEOF
7817
rm -f conftest.$ac_objext
7818
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7819
  (eval $ac_compile) 2>conftest.er1
7820
  ac_status=$?
7821
  grep -v '^ *+' conftest.er1 >conftest.err
7822
  rm -f conftest.er1
7823
  cat conftest.err >&5
7824
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7825
  (exit $ac_status); } &&
7826
         { ac_try='test -z "$ac_c_werror_flag"
7827
                         || test ! -s conftest.err'
7828
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7829
  (eval $ac_try) 2>&5
7830
  ac_status=$?
7831
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7832
  (exit $ac_status); }; } &&
7833
         { ac_try='test -s conftest.$ac_objext'
7834
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7835
  (eval $ac_try) 2>&5
7836
  ac_status=$?
7837
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7838
  (exit $ac_status); }; }; then
7839
  ac_hi=-1 ac_mid=-1
7840
  while :; do
7841
    cat >conftest.$ac_ext <<_ACEOF
7842
/* confdefs.h.  */
7843
_ACEOF
7844
cat confdefs.h >>conftest.$ac_ext
7845
cat >>conftest.$ac_ext <<_ACEOF
7846
/* end confdefs.h.  */
7847
$ac_includes_default
7848
int
7849
main ()
7850
{
7851
static int test_array [1 - 2 * !(((long) (sizeof (void *))) >= $ac_mid)];
7852
test_array [0] = 0
7853
 
7854
  ;
7855
  return 0;
7856
}
7857
_ACEOF
7858
rm -f conftest.$ac_objext
7859
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7860
  (eval $ac_compile) 2>conftest.er1
7861
  ac_status=$?
7862
  grep -v '^ *+' conftest.er1 >conftest.err
7863
  rm -f conftest.er1
7864
  cat conftest.err >&5
7865
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7866
  (exit $ac_status); } &&
7867
         { ac_try='test -z "$ac_c_werror_flag"
7868
                         || test ! -s conftest.err'
7869
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7870
  (eval $ac_try) 2>&5
7871
  ac_status=$?
7872
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7873
  (exit $ac_status); }; } &&
7874
         { ac_try='test -s conftest.$ac_objext'
7875
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7876
  (eval $ac_try) 2>&5
7877
  ac_status=$?
7878
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7879
  (exit $ac_status); }; }; then
7880
  ac_lo=$ac_mid; break
7881
else
7882
  echo "$as_me: failed program was:" >&5
7883
sed 's/^/| /' conftest.$ac_ext >&5
7884
 
7885
ac_hi=`expr '(' $ac_mid ')' - 1`
7886
                       if test $ac_mid -le $ac_hi; then
7887
                         ac_lo= ac_hi=
7888
                         break
7889
                       fi
7890
                       ac_mid=`expr 2 '*' $ac_mid`
7891
fi
7892
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7893
  done
7894
else
7895
  echo "$as_me: failed program was:" >&5
7896
sed 's/^/| /' conftest.$ac_ext >&5
7897
 
7898
ac_lo= ac_hi=
7899
fi
7900
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7901
fi
7902
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7903
# Binary search between lo and hi bounds.
7904
while test "x$ac_lo" != "x$ac_hi"; do
7905
  ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
7906
  cat >conftest.$ac_ext <<_ACEOF
7907
/* confdefs.h.  */
7908
_ACEOF
7909
cat confdefs.h >>conftest.$ac_ext
7910
cat >>conftest.$ac_ext <<_ACEOF
7911
/* end confdefs.h.  */
7912
$ac_includes_default
7913
int
7914
main ()
7915
{
7916
static int test_array [1 - 2 * !(((long) (sizeof (void *))) <= $ac_mid)];
7917
test_array [0] = 0
7918
 
7919
  ;
7920
  return 0;
7921
}
7922
_ACEOF
7923
rm -f conftest.$ac_objext
7924
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7925
  (eval $ac_compile) 2>conftest.er1
7926
  ac_status=$?
7927
  grep -v '^ *+' conftest.er1 >conftest.err
7928
  rm -f conftest.er1
7929
  cat conftest.err >&5
7930
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7931
  (exit $ac_status); } &&
7932
         { ac_try='test -z "$ac_c_werror_flag"
7933
                         || test ! -s conftest.err'
7934
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7935
  (eval $ac_try) 2>&5
7936
  ac_status=$?
7937
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7938
  (exit $ac_status); }; } &&
7939
         { ac_try='test -s conftest.$ac_objext'
7940
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7941
  (eval $ac_try) 2>&5
7942
  ac_status=$?
7943
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7944
  (exit $ac_status); }; }; then
7945
  ac_hi=$ac_mid
7946
else
7947
  echo "$as_me: failed program was:" >&5
7948
sed 's/^/| /' conftest.$ac_ext >&5
7949
 
7950
ac_lo=`expr '(' $ac_mid ')' + 1`
7951
fi
7952
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7953
done
7954
case $ac_lo in
7955
?*) ac_cv_sizeof_void_p=$ac_lo;;
7956
'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (void *), 77
7957
See \`config.log' for more details." >&5
7958
echo "$as_me: error: cannot compute sizeof (void *), 77
7959
See \`config.log' for more details." >&2;}
7960
   { (exit 1); exit 1; }; } ;;
7961
esac
7962
else
7963
  if test "$cross_compiling" = yes; then
7964
  { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
7965
See \`config.log' for more details." >&5
7966
echo "$as_me: error: cannot run test program while cross compiling
7967
See \`config.log' for more details." >&2;}
7968
   { (exit 1); exit 1; }; }
7969
else
7970
  cat >conftest.$ac_ext <<_ACEOF
7971
/* confdefs.h.  */
7972
_ACEOF
7973
cat confdefs.h >>conftest.$ac_ext
7974
cat >>conftest.$ac_ext <<_ACEOF
7975
/* end confdefs.h.  */
7976
$ac_includes_default
7977
long longval () { return (long) (sizeof (void *)); }
7978
unsigned long ulongval () { return (long) (sizeof (void *)); }
7979
#include 
7980
#include 
7981
int
7982
main ()
7983
{
7984
 
7985
  FILE *f = fopen ("conftest.val", "w");
7986
  if (! f)
7987
    exit (1);
7988
  if (((long) (sizeof (void *))) < 0)
7989
    {
7990
      long i = longval ();
7991
      if (i != ((long) (sizeof (void *))))
7992
        exit (1);
7993
      fprintf (f, "%ld\n", i);
7994
    }
7995
  else
7996
    {
7997
      unsigned long i = ulongval ();
7998
      if (i != ((long) (sizeof (void *))))
7999
        exit (1);
8000
      fprintf (f, "%lu\n", i);
8001
    }
8002
  exit (ferror (f) || fclose (f) != 0);
8003
 
8004
  ;
8005
  return 0;
8006
}
8007
_ACEOF
8008
rm -f conftest$ac_exeext
8009
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8010
  (eval $ac_link) 2>&5
8011
  ac_status=$?
8012
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8013
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8014
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8015
  (eval $ac_try) 2>&5
8016
  ac_status=$?
8017
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8018
  (exit $ac_status); }; }; then
8019
  ac_cv_sizeof_void_p=`cat conftest.val`
8020
else
8021
  echo "$as_me: program exited with status $ac_status" >&5
8022
echo "$as_me: failed program was:" >&5
8023
sed 's/^/| /' conftest.$ac_ext >&5
8024
 
8025
( exit $ac_status )
8026
{ { echo "$as_me:$LINENO: error: cannot compute sizeof (void *), 77
8027
See \`config.log' for more details." >&5
8028
echo "$as_me: error: cannot compute sizeof (void *), 77
8029
See \`config.log' for more details." >&2;}
8030
   { (exit 1); exit 1; }; }
8031
fi
8032
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8033
fi
8034
fi
8035
rm -f conftest.val
8036
else
8037
  ac_cv_sizeof_void_p=0
8038
fi
8039
fi
8040
echo "$as_me:$LINENO: result: $ac_cv_sizeof_void_p" >&5
8041
echo "${ECHO_T}$ac_cv_sizeof_void_p" >&6
8042
cat >>confdefs.h <<_ACEOF
8043
#define SIZEOF_VOID_P $ac_cv_sizeof_void_p
8044
_ACEOF
8045
 
8046
 ;;
8047
esac
8048
 
8049
# Lacking an uint64_t?  Test size of long
8050
case "$acx_cv_header_stdint:$ac_cv_type_uint64_t:$ac_cv_type_u_int64_t" in
8051
  stddef.h:*:* | *:no:no) echo "$as_me:$LINENO: checking for long" >&5
8052
echo $ECHO_N "checking for long... $ECHO_C" >&6
8053
if test "${ac_cv_type_long+set}" = set; then
8054
  echo $ECHO_N "(cached) $ECHO_C" >&6
8055
else
8056
  cat >conftest.$ac_ext <<_ACEOF
8057
/* confdefs.h.  */
8058
_ACEOF
8059
cat confdefs.h >>conftest.$ac_ext
8060
cat >>conftest.$ac_ext <<_ACEOF
8061
/* end confdefs.h.  */
8062
$ac_includes_default
8063
int
8064
main ()
8065
{
8066
if ((long *) 0)
8067
  return 0;
8068
if (sizeof (long))
8069
  return 0;
8070
  ;
8071
  return 0;
8072
}
8073
_ACEOF
8074
rm -f conftest.$ac_objext
8075
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8076
  (eval $ac_compile) 2>conftest.er1
8077
  ac_status=$?
8078
  grep -v '^ *+' conftest.er1 >conftest.err
8079
  rm -f conftest.er1
8080
  cat conftest.err >&5
8081
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8082
  (exit $ac_status); } &&
8083
         { ac_try='test -z "$ac_c_werror_flag"
8084
                         || test ! -s conftest.err'
8085
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8086
  (eval $ac_try) 2>&5
8087
  ac_status=$?
8088
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8089
  (exit $ac_status); }; } &&
8090
         { ac_try='test -s conftest.$ac_objext'
8091
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8092
  (eval $ac_try) 2>&5
8093
  ac_status=$?
8094
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8095
  (exit $ac_status); }; }; then
8096
  ac_cv_type_long=yes
8097
else
8098
  echo "$as_me: failed program was:" >&5
8099
sed 's/^/| /' conftest.$ac_ext >&5
8100
 
8101
ac_cv_type_long=no
8102
fi
8103
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8104
fi
8105
echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5
8106
echo "${ECHO_T}$ac_cv_type_long" >&6
8107
 
8108
echo "$as_me:$LINENO: checking size of long" >&5
8109
echo $ECHO_N "checking size of long... $ECHO_C" >&6
8110
if test "${ac_cv_sizeof_long+set}" = set; then
8111
  echo $ECHO_N "(cached) $ECHO_C" >&6
8112
else
8113
  if test "$ac_cv_type_long" = yes; then
8114
  # The cast to unsigned long works around a bug in the HP C Compiler
8115
  # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
8116
  # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
8117
  # This bug is HP SR number 8606223364.
8118
  if test "$cross_compiling" = yes; then
8119
  # Depending upon the size, compute the lo and hi bounds.
8120
cat >conftest.$ac_ext <<_ACEOF
8121
/* confdefs.h.  */
8122
_ACEOF
8123
cat confdefs.h >>conftest.$ac_ext
8124
cat >>conftest.$ac_ext <<_ACEOF
8125
/* end confdefs.h.  */
8126
$ac_includes_default
8127
int
8128
main ()
8129
{
8130
static int test_array [1 - 2 * !(((long) (sizeof (long))) >= 0)];
8131
test_array [0] = 0
8132
 
8133
  ;
8134
  return 0;
8135
}
8136
_ACEOF
8137
rm -f conftest.$ac_objext
8138
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8139
  (eval $ac_compile) 2>conftest.er1
8140
  ac_status=$?
8141
  grep -v '^ *+' conftest.er1 >conftest.err
8142
  rm -f conftest.er1
8143
  cat conftest.err >&5
8144
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8145
  (exit $ac_status); } &&
8146
         { ac_try='test -z "$ac_c_werror_flag"
8147
                         || test ! -s conftest.err'
8148
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8149
  (eval $ac_try) 2>&5
8150
  ac_status=$?
8151
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8152
  (exit $ac_status); }; } &&
8153
         { ac_try='test -s conftest.$ac_objext'
8154
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8155
  (eval $ac_try) 2>&5
8156
  ac_status=$?
8157
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8158
  (exit $ac_status); }; }; then
8159
  ac_lo=0 ac_mid=0
8160
  while :; do
8161
    cat >conftest.$ac_ext <<_ACEOF
8162
/* confdefs.h.  */
8163
_ACEOF
8164
cat confdefs.h >>conftest.$ac_ext
8165
cat >>conftest.$ac_ext <<_ACEOF
8166
/* end confdefs.h.  */
8167
$ac_includes_default
8168
int
8169
main ()
8170
{
8171
static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];
8172
test_array [0] = 0
8173
 
8174
  ;
8175
  return 0;
8176
}
8177
_ACEOF
8178
rm -f conftest.$ac_objext
8179
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8180
  (eval $ac_compile) 2>conftest.er1
8181
  ac_status=$?
8182
  grep -v '^ *+' conftest.er1 >conftest.err
8183
  rm -f conftest.er1
8184
  cat conftest.err >&5
8185
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8186
  (exit $ac_status); } &&
8187
         { ac_try='test -z "$ac_c_werror_flag"
8188
                         || test ! -s conftest.err'
8189
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8190
  (eval $ac_try) 2>&5
8191
  ac_status=$?
8192
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8193
  (exit $ac_status); }; } &&
8194
         { ac_try='test -s conftest.$ac_objext'
8195
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8196
  (eval $ac_try) 2>&5
8197
  ac_status=$?
8198
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8199
  (exit $ac_status); }; }; then
8200
  ac_hi=$ac_mid; break
8201
else
8202
  echo "$as_me: failed program was:" >&5
8203
sed 's/^/| /' conftest.$ac_ext >&5
8204
 
8205
ac_lo=`expr $ac_mid + 1`
8206
                    if test $ac_lo -le $ac_mid; then
8207
                      ac_lo= ac_hi=
8208
                      break
8209
                    fi
8210
                    ac_mid=`expr 2 '*' $ac_mid + 1`
8211
fi
8212
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8213
  done
8214
else
8215
  echo "$as_me: failed program was:" >&5
8216
sed 's/^/| /' conftest.$ac_ext >&5
8217
 
8218
cat >conftest.$ac_ext <<_ACEOF
8219
/* confdefs.h.  */
8220
_ACEOF
8221
cat confdefs.h >>conftest.$ac_ext
8222
cat >>conftest.$ac_ext <<_ACEOF
8223
/* end confdefs.h.  */
8224
$ac_includes_default
8225
int
8226
main ()
8227
{
8228
static int test_array [1 - 2 * !(((long) (sizeof (long))) < 0)];
8229
test_array [0] = 0
8230
 
8231
  ;
8232
  return 0;
8233
}
8234
_ACEOF
8235
rm -f conftest.$ac_objext
8236
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8237
  (eval $ac_compile) 2>conftest.er1
8238
  ac_status=$?
8239
  grep -v '^ *+' conftest.er1 >conftest.err
8240
  rm -f conftest.er1
8241
  cat conftest.err >&5
8242
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8243
  (exit $ac_status); } &&
8244
         { ac_try='test -z "$ac_c_werror_flag"
8245
                         || test ! -s conftest.err'
8246
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8247
  (eval $ac_try) 2>&5
8248
  ac_status=$?
8249
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8250
  (exit $ac_status); }; } &&
8251
         { ac_try='test -s conftest.$ac_objext'
8252
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8253
  (eval $ac_try) 2>&5
8254
  ac_status=$?
8255
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8256
  (exit $ac_status); }; }; then
8257
  ac_hi=-1 ac_mid=-1
8258
  while :; do
8259
    cat >conftest.$ac_ext <<_ACEOF
8260
/* confdefs.h.  */
8261
_ACEOF
8262
cat confdefs.h >>conftest.$ac_ext
8263
cat >>conftest.$ac_ext <<_ACEOF
8264
/* end confdefs.h.  */
8265
$ac_includes_default
8266
int
8267
main ()
8268
{
8269
static int test_array [1 - 2 * !(((long) (sizeof (long))) >= $ac_mid)];
8270
test_array [0] = 0
8271
 
8272
  ;
8273
  return 0;
8274
}
8275
_ACEOF
8276
rm -f conftest.$ac_objext
8277
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8278
  (eval $ac_compile) 2>conftest.er1
8279
  ac_status=$?
8280
  grep -v '^ *+' conftest.er1 >conftest.err
8281
  rm -f conftest.er1
8282
  cat conftest.err >&5
8283
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8284
  (exit $ac_status); } &&
8285
         { ac_try='test -z "$ac_c_werror_flag"
8286
                         || test ! -s conftest.err'
8287
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8288
  (eval $ac_try) 2>&5
8289
  ac_status=$?
8290
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8291
  (exit $ac_status); }; } &&
8292
         { ac_try='test -s conftest.$ac_objext'
8293
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8294
  (eval $ac_try) 2>&5
8295
  ac_status=$?
8296
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8297
  (exit $ac_status); }; }; then
8298
  ac_lo=$ac_mid; break
8299
else
8300
  echo "$as_me: failed program was:" >&5
8301
sed 's/^/| /' conftest.$ac_ext >&5
8302
 
8303
ac_hi=`expr '(' $ac_mid ')' - 1`
8304
                       if test $ac_mid -le $ac_hi; then
8305
                         ac_lo= ac_hi=
8306
                         break
8307
                       fi
8308
                       ac_mid=`expr 2 '*' $ac_mid`
8309
fi
8310
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8311
  done
8312
else
8313
  echo "$as_me: failed program was:" >&5
8314
sed 's/^/| /' conftest.$ac_ext >&5
8315
 
8316
ac_lo= ac_hi=
8317
fi
8318
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8319
fi
8320
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8321
# Binary search between lo and hi bounds.
8322
while test "x$ac_lo" != "x$ac_hi"; do
8323
  ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
8324
  cat >conftest.$ac_ext <<_ACEOF
8325
/* confdefs.h.  */
8326
_ACEOF
8327
cat confdefs.h >>conftest.$ac_ext
8328
cat >>conftest.$ac_ext <<_ACEOF
8329
/* end confdefs.h.  */
8330
$ac_includes_default
8331
int
8332
main ()
8333
{
8334
static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];
8335
test_array [0] = 0
8336
 
8337
  ;
8338
  return 0;
8339
}
8340
_ACEOF
8341
rm -f conftest.$ac_objext
8342
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8343
  (eval $ac_compile) 2>conftest.er1
8344
  ac_status=$?
8345
  grep -v '^ *+' conftest.er1 >conftest.err
8346
  rm -f conftest.er1
8347
  cat conftest.err >&5
8348
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8349
  (exit $ac_status); } &&
8350
         { ac_try='test -z "$ac_c_werror_flag"
8351
                         || test ! -s conftest.err'
8352
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8353
  (eval $ac_try) 2>&5
8354
  ac_status=$?
8355
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8356
  (exit $ac_status); }; } &&
8357
         { ac_try='test -s conftest.$ac_objext'
8358
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8359
  (eval $ac_try) 2>&5
8360
  ac_status=$?
8361
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8362
  (exit $ac_status); }; }; then
8363
  ac_hi=$ac_mid
8364
else
8365
  echo "$as_me: failed program was:" >&5
8366
sed 's/^/| /' conftest.$ac_ext >&5
8367
 
8368
ac_lo=`expr '(' $ac_mid ')' + 1`
8369
fi
8370
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8371
done
8372
case $ac_lo in
8373
?*) ac_cv_sizeof_long=$ac_lo;;
8374
'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77
8375
See \`config.log' for more details." >&5
8376
echo "$as_me: error: cannot compute sizeof (long), 77
8377
See \`config.log' for more details." >&2;}
8378
   { (exit 1); exit 1; }; } ;;
8379
esac
8380
else
8381
  if test "$cross_compiling" = yes; then
8382
  { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
8383
See \`config.log' for more details." >&5
8384
echo "$as_me: error: cannot run test program while cross compiling
8385
See \`config.log' for more details." >&2;}
8386
   { (exit 1); exit 1; }; }
8387
else
8388
  cat >conftest.$ac_ext <<_ACEOF
8389
/* confdefs.h.  */
8390
_ACEOF
8391
cat confdefs.h >>conftest.$ac_ext
8392
cat >>conftest.$ac_ext <<_ACEOF
8393
/* end confdefs.h.  */
8394
$ac_includes_default
8395
long longval () { return (long) (sizeof (long)); }
8396
unsigned long ulongval () { return (long) (sizeof (long)); }
8397
#include 
8398
#include 
8399
int
8400
main ()
8401
{
8402
 
8403
  FILE *f = fopen ("conftest.val", "w");
8404
  if (! f)
8405
    exit (1);
8406
  if (((long) (sizeof (long))) < 0)
8407
    {
8408
      long i = longval ();
8409
      if (i != ((long) (sizeof (long))))
8410
        exit (1);
8411
      fprintf (f, "%ld\n", i);
8412
    }
8413
  else
8414
    {
8415
      unsigned long i = ulongval ();
8416
      if (i != ((long) (sizeof (long))))
8417
        exit (1);
8418
      fprintf (f, "%lu\n", i);
8419
    }
8420
  exit (ferror (f) || fclose (f) != 0);
8421
 
8422
  ;
8423
  return 0;
8424
}
8425
_ACEOF
8426
rm -f conftest$ac_exeext
8427
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8428
  (eval $ac_link) 2>&5
8429
  ac_status=$?
8430
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8431
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8432
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8433
  (eval $ac_try) 2>&5
8434
  ac_status=$?
8435
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8436
  (exit $ac_status); }; }; then
8437
  ac_cv_sizeof_long=`cat conftest.val`
8438
else
8439
  echo "$as_me: program exited with status $ac_status" >&5
8440
echo "$as_me: failed program was:" >&5
8441
sed 's/^/| /' conftest.$ac_ext >&5
8442
 
8443
( exit $ac_status )
8444
{ { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77
8445
See \`config.log' for more details." >&5
8446
echo "$as_me: error: cannot compute sizeof (long), 77
8447
See \`config.log' for more details." >&2;}
8448
   { (exit 1); exit 1; }; }
8449
fi
8450
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8451
fi
8452
fi
8453
rm -f conftest.val
8454
else
8455
  ac_cv_sizeof_long=0
8456
fi
8457
fi
8458
echo "$as_me:$LINENO: result: $ac_cv_sizeof_long" >&5
8459
echo "${ECHO_T}$ac_cv_sizeof_long" >&6
8460
cat >>confdefs.h <<_ACEOF
8461
#define SIZEOF_LONG $ac_cv_sizeof_long
8462
_ACEOF
8463
 
8464
 ;;
8465
esac
8466
 
8467
if test $acx_cv_header_stdint = stddef.h; then
8468
  # Lacking a good header?  Test size of everything and deduce all types.
8469
  echo "$as_me:$LINENO: checking for int" >&5
8470
echo $ECHO_N "checking for int... $ECHO_C" >&6
8471
if test "${ac_cv_type_int+set}" = set; then
8472
  echo $ECHO_N "(cached) $ECHO_C" >&6
8473
else
8474
  cat >conftest.$ac_ext <<_ACEOF
8475
/* confdefs.h.  */
8476
_ACEOF
8477
cat confdefs.h >>conftest.$ac_ext
8478
cat >>conftest.$ac_ext <<_ACEOF
8479
/* end confdefs.h.  */
8480
$ac_includes_default
8481
int
8482
main ()
8483
{
8484
if ((int *) 0)
8485
  return 0;
8486
if (sizeof (int))
8487
  return 0;
8488
  ;
8489
  return 0;
8490
}
8491
_ACEOF
8492
rm -f conftest.$ac_objext
8493
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8494
  (eval $ac_compile) 2>conftest.er1
8495
  ac_status=$?
8496
  grep -v '^ *+' conftest.er1 >conftest.err
8497
  rm -f conftest.er1
8498
  cat conftest.err >&5
8499
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8500
  (exit $ac_status); } &&
8501
         { ac_try='test -z "$ac_c_werror_flag"
8502
                         || test ! -s conftest.err'
8503
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8504
  (eval $ac_try) 2>&5
8505
  ac_status=$?
8506
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8507
  (exit $ac_status); }; } &&
8508
         { ac_try='test -s conftest.$ac_objext'
8509
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8510
  (eval $ac_try) 2>&5
8511
  ac_status=$?
8512
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8513
  (exit $ac_status); }; }; then
8514
  ac_cv_type_int=yes
8515
else
8516
  echo "$as_me: failed program was:" >&5
8517
sed 's/^/| /' conftest.$ac_ext >&5
8518
 
8519
ac_cv_type_int=no
8520
fi
8521
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8522
fi
8523
echo "$as_me:$LINENO: result: $ac_cv_type_int" >&5
8524
echo "${ECHO_T}$ac_cv_type_int" >&6
8525
 
8526
echo "$as_me:$LINENO: checking size of int" >&5
8527
echo $ECHO_N "checking size of int... $ECHO_C" >&6
8528
if test "${ac_cv_sizeof_int+set}" = set; then
8529
  echo $ECHO_N "(cached) $ECHO_C" >&6
8530
else
8531
  if test "$ac_cv_type_int" = yes; then
8532
  # The cast to unsigned long works around a bug in the HP C Compiler
8533
  # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
8534
  # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
8535
  # This bug is HP SR number 8606223364.
8536
  if test "$cross_compiling" = yes; then
8537
  # Depending upon the size, compute the lo and hi bounds.
8538
cat >conftest.$ac_ext <<_ACEOF
8539
/* confdefs.h.  */
8540
_ACEOF
8541
cat confdefs.h >>conftest.$ac_ext
8542
cat >>conftest.$ac_ext <<_ACEOF
8543
/* end confdefs.h.  */
8544
$ac_includes_default
8545
int
8546
main ()
8547
{
8548
static int test_array [1 - 2 * !(((long) (sizeof (int))) >= 0)];
8549
test_array [0] = 0
8550
 
8551
  ;
8552
  return 0;
8553
}
8554
_ACEOF
8555
rm -f conftest.$ac_objext
8556
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8557
  (eval $ac_compile) 2>conftest.er1
8558
  ac_status=$?
8559
  grep -v '^ *+' conftest.er1 >conftest.err
8560
  rm -f conftest.er1
8561
  cat conftest.err >&5
8562
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8563
  (exit $ac_status); } &&
8564
         { ac_try='test -z "$ac_c_werror_flag"
8565
                         || test ! -s conftest.err'
8566
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8567
  (eval $ac_try) 2>&5
8568
  ac_status=$?
8569
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8570
  (exit $ac_status); }; } &&
8571
         { ac_try='test -s conftest.$ac_objext'
8572
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8573
  (eval $ac_try) 2>&5
8574
  ac_status=$?
8575
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8576
  (exit $ac_status); }; }; then
8577
  ac_lo=0 ac_mid=0
8578
  while :; do
8579
    cat >conftest.$ac_ext <<_ACEOF
8580
/* confdefs.h.  */
8581
_ACEOF
8582
cat confdefs.h >>conftest.$ac_ext
8583
cat >>conftest.$ac_ext <<_ACEOF
8584
/* end confdefs.h.  */
8585
$ac_includes_default
8586
int
8587
main ()
8588
{
8589
static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)];
8590
test_array [0] = 0
8591
 
8592
  ;
8593
  return 0;
8594
}
8595
_ACEOF
8596
rm -f conftest.$ac_objext
8597
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8598
  (eval $ac_compile) 2>conftest.er1
8599
  ac_status=$?
8600
  grep -v '^ *+' conftest.er1 >conftest.err
8601
  rm -f conftest.er1
8602
  cat conftest.err >&5
8603
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8604
  (exit $ac_status); } &&
8605
         { ac_try='test -z "$ac_c_werror_flag"
8606
                         || test ! -s conftest.err'
8607
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8608
  (eval $ac_try) 2>&5
8609
  ac_status=$?
8610
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8611
  (exit $ac_status); }; } &&
8612
         { ac_try='test -s conftest.$ac_objext'
8613
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8614
  (eval $ac_try) 2>&5
8615
  ac_status=$?
8616
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8617
  (exit $ac_status); }; }; then
8618
  ac_hi=$ac_mid; break
8619
else
8620
  echo "$as_me: failed program was:" >&5
8621
sed 's/^/| /' conftest.$ac_ext >&5
8622
 
8623
ac_lo=`expr $ac_mid + 1`
8624
                    if test $ac_lo -le $ac_mid; then
8625
                      ac_lo= ac_hi=
8626
                      break
8627
                    fi
8628
                    ac_mid=`expr 2 '*' $ac_mid + 1`
8629
fi
8630
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8631
  done
8632
else
8633
  echo "$as_me: failed program was:" >&5
8634
sed 's/^/| /' conftest.$ac_ext >&5
8635
 
8636
cat >conftest.$ac_ext <<_ACEOF
8637
/* confdefs.h.  */
8638
_ACEOF
8639
cat confdefs.h >>conftest.$ac_ext
8640
cat >>conftest.$ac_ext <<_ACEOF
8641
/* end confdefs.h.  */
8642
$ac_includes_default
8643
int
8644
main ()
8645
{
8646
static int test_array [1 - 2 * !(((long) (sizeof (int))) < 0)];
8647
test_array [0] = 0
8648
 
8649
  ;
8650
  return 0;
8651
}
8652
_ACEOF
8653
rm -f conftest.$ac_objext
8654
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8655
  (eval $ac_compile) 2>conftest.er1
8656
  ac_status=$?
8657
  grep -v '^ *+' conftest.er1 >conftest.err
8658
  rm -f conftest.er1
8659
  cat conftest.err >&5
8660
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8661
  (exit $ac_status); } &&
8662
         { ac_try='test -z "$ac_c_werror_flag"
8663
                         || test ! -s conftest.err'
8664
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8665
  (eval $ac_try) 2>&5
8666
  ac_status=$?
8667
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8668
  (exit $ac_status); }; } &&
8669
         { ac_try='test -s conftest.$ac_objext'
8670
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8671
  (eval $ac_try) 2>&5
8672
  ac_status=$?
8673
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8674
  (exit $ac_status); }; }; then
8675
  ac_hi=-1 ac_mid=-1
8676
  while :; do
8677
    cat >conftest.$ac_ext <<_ACEOF
8678
/* confdefs.h.  */
8679
_ACEOF
8680
cat confdefs.h >>conftest.$ac_ext
8681
cat >>conftest.$ac_ext <<_ACEOF
8682
/* end confdefs.h.  */
8683
$ac_includes_default
8684
int
8685
main ()
8686
{
8687
static int test_array [1 - 2 * !(((long) (sizeof (int))) >= $ac_mid)];
8688
test_array [0] = 0
8689
 
8690
  ;
8691
  return 0;
8692
}
8693
_ACEOF
8694
rm -f conftest.$ac_objext
8695
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8696
  (eval $ac_compile) 2>conftest.er1
8697
  ac_status=$?
8698
  grep -v '^ *+' conftest.er1 >conftest.err
8699
  rm -f conftest.er1
8700
  cat conftest.err >&5
8701
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8702
  (exit $ac_status); } &&
8703
         { ac_try='test -z "$ac_c_werror_flag"
8704
                         || test ! -s conftest.err'
8705
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8706
  (eval $ac_try) 2>&5
8707
  ac_status=$?
8708
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8709
  (exit $ac_status); }; } &&
8710
         { ac_try='test -s conftest.$ac_objext'
8711
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8712
  (eval $ac_try) 2>&5
8713
  ac_status=$?
8714
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8715
  (exit $ac_status); }; }; then
8716
  ac_lo=$ac_mid; break
8717
else
8718
  echo "$as_me: failed program was:" >&5
8719
sed 's/^/| /' conftest.$ac_ext >&5
8720
 
8721
ac_hi=`expr '(' $ac_mid ')' - 1`
8722
                       if test $ac_mid -le $ac_hi; then
8723
                         ac_lo= ac_hi=
8724
                         break
8725
                       fi
8726
                       ac_mid=`expr 2 '*' $ac_mid`
8727
fi
8728
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8729
  done
8730
else
8731
  echo "$as_me: failed program was:" >&5
8732
sed 's/^/| /' conftest.$ac_ext >&5
8733
 
8734
ac_lo= ac_hi=
8735
fi
8736
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8737
fi
8738
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8739
# Binary search between lo and hi bounds.
8740
while test "x$ac_lo" != "x$ac_hi"; do
8741
  ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
8742
  cat >conftest.$ac_ext <<_ACEOF
8743
/* confdefs.h.  */
8744
_ACEOF
8745
cat confdefs.h >>conftest.$ac_ext
8746
cat >>conftest.$ac_ext <<_ACEOF
8747
/* end confdefs.h.  */
8748
$ac_includes_default
8749
int
8750
main ()
8751
{
8752
static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)];
8753
test_array [0] = 0
8754
 
8755
  ;
8756
  return 0;
8757
}
8758
_ACEOF
8759
rm -f conftest.$ac_objext
8760
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8761
  (eval $ac_compile) 2>conftest.er1
8762
  ac_status=$?
8763
  grep -v '^ *+' conftest.er1 >conftest.err
8764
  rm -f conftest.er1
8765
  cat conftest.err >&5
8766
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8767
  (exit $ac_status); } &&
8768
         { ac_try='test -z "$ac_c_werror_flag"
8769
                         || test ! -s conftest.err'
8770
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8771
  (eval $ac_try) 2>&5
8772
  ac_status=$?
8773
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8774
  (exit $ac_status); }; } &&
8775
         { ac_try='test -s conftest.$ac_objext'
8776
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8777
  (eval $ac_try) 2>&5
8778
  ac_status=$?
8779
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8780
  (exit $ac_status); }; }; then
8781
  ac_hi=$ac_mid
8782
else
8783
  echo "$as_me: failed program was:" >&5
8784
sed 's/^/| /' conftest.$ac_ext >&5
8785
 
8786
ac_lo=`expr '(' $ac_mid ')' + 1`
8787
fi
8788
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8789
done
8790
case $ac_lo in
8791
?*) ac_cv_sizeof_int=$ac_lo;;
8792
'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77
8793
See \`config.log' for more details." >&5
8794
echo "$as_me: error: cannot compute sizeof (int), 77
8795
See \`config.log' for more details." >&2;}
8796
   { (exit 1); exit 1; }; } ;;
8797
esac
8798
else
8799
  if test "$cross_compiling" = yes; then
8800
  { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
8801
See \`config.log' for more details." >&5
8802
echo "$as_me: error: cannot run test program while cross compiling
8803
See \`config.log' for more details." >&2;}
8804
   { (exit 1); exit 1; }; }
8805
else
8806
  cat >conftest.$ac_ext <<_ACEOF
8807
/* confdefs.h.  */
8808
_ACEOF
8809
cat confdefs.h >>conftest.$ac_ext
8810
cat >>conftest.$ac_ext <<_ACEOF
8811
/* end confdefs.h.  */
8812
$ac_includes_default
8813
long longval () { return (long) (sizeof (int)); }
8814
unsigned long ulongval () { return (long) (sizeof (int)); }
8815
#include 
8816
#include 
8817
int
8818
main ()
8819
{
8820
 
8821
  FILE *f = fopen ("conftest.val", "w");
8822
  if (! f)
8823
    exit (1);
8824
  if (((long) (sizeof (int))) < 0)
8825
    {
8826
      long i = longval ();
8827
      if (i != ((long) (sizeof (int))))
8828
        exit (1);
8829
      fprintf (f, "%ld\n", i);
8830
    }
8831
  else
8832
    {
8833
      unsigned long i = ulongval ();
8834
      if (i != ((long) (sizeof (int))))
8835
        exit (1);
8836
      fprintf (f, "%lu\n", i);
8837
    }
8838
  exit (ferror (f) || fclose (f) != 0);
8839
 
8840
  ;
8841
  return 0;
8842
}
8843
_ACEOF
8844
rm -f conftest$ac_exeext
8845
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8846
  (eval $ac_link) 2>&5
8847
  ac_status=$?
8848
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8849
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8850
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8851
  (eval $ac_try) 2>&5
8852
  ac_status=$?
8853
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8854
  (exit $ac_status); }; }; then
8855
  ac_cv_sizeof_int=`cat conftest.val`
8856
else
8857
  echo "$as_me: program exited with status $ac_status" >&5
8858
echo "$as_me: failed program was:" >&5
8859
sed 's/^/| /' conftest.$ac_ext >&5
8860
 
8861
( exit $ac_status )
8862
{ { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77
8863
See \`config.log' for more details." >&5
8864
echo "$as_me: error: cannot compute sizeof (int), 77
8865
See \`config.log' for more details." >&2;}
8866
   { (exit 1); exit 1; }; }
8867
fi
8868
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8869
fi
8870
fi
8871
rm -f conftest.val
8872
else
8873
  ac_cv_sizeof_int=0
8874
fi
8875
fi
8876
echo "$as_me:$LINENO: result: $ac_cv_sizeof_int" >&5
8877
echo "${ECHO_T}$ac_cv_sizeof_int" >&6
8878
cat >>confdefs.h <<_ACEOF
8879
#define SIZEOF_INT $ac_cv_sizeof_int
8880
_ACEOF
8881
 
8882
 
8883
  echo "$as_me:$LINENO: checking for short" >&5
8884
echo $ECHO_N "checking for short... $ECHO_C" >&6
8885
if test "${ac_cv_type_short+set}" = set; then
8886
  echo $ECHO_N "(cached) $ECHO_C" >&6
8887
else
8888
  cat >conftest.$ac_ext <<_ACEOF
8889
/* confdefs.h.  */
8890
_ACEOF
8891
cat confdefs.h >>conftest.$ac_ext
8892
cat >>conftest.$ac_ext <<_ACEOF
8893
/* end confdefs.h.  */
8894
$ac_includes_default
8895
int
8896
main ()
8897
{
8898
if ((short *) 0)
8899
  return 0;
8900
if (sizeof (short))
8901
  return 0;
8902
  ;
8903
  return 0;
8904
}
8905
_ACEOF
8906
rm -f conftest.$ac_objext
8907
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8908
  (eval $ac_compile) 2>conftest.er1
8909
  ac_status=$?
8910
  grep -v '^ *+' conftest.er1 >conftest.err
8911
  rm -f conftest.er1
8912
  cat conftest.err >&5
8913
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8914
  (exit $ac_status); } &&
8915
         { ac_try='test -z "$ac_c_werror_flag"
8916
                         || test ! -s conftest.err'
8917
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8918
  (eval $ac_try) 2>&5
8919
  ac_status=$?
8920
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8921
  (exit $ac_status); }; } &&
8922
         { ac_try='test -s conftest.$ac_objext'
8923
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8924
  (eval $ac_try) 2>&5
8925
  ac_status=$?
8926
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8927
  (exit $ac_status); }; }; then
8928
  ac_cv_type_short=yes
8929
else
8930
  echo "$as_me: failed program was:" >&5
8931
sed 's/^/| /' conftest.$ac_ext >&5
8932
 
8933
ac_cv_type_short=no
8934
fi
8935
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8936
fi
8937
echo "$as_me:$LINENO: result: $ac_cv_type_short" >&5
8938
echo "${ECHO_T}$ac_cv_type_short" >&6
8939
 
8940
echo "$as_me:$LINENO: checking size of short" >&5
8941
echo $ECHO_N "checking size of short... $ECHO_C" >&6
8942
if test "${ac_cv_sizeof_short+set}" = set; then
8943
  echo $ECHO_N "(cached) $ECHO_C" >&6
8944
else
8945
  if test "$ac_cv_type_short" = yes; then
8946
  # The cast to unsigned long works around a bug in the HP C Compiler
8947
  # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
8948
  # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
8949
  # This bug is HP SR number 8606223364.
8950
  if test "$cross_compiling" = yes; then
8951
  # Depending upon the size, compute the lo and hi bounds.
8952
cat >conftest.$ac_ext <<_ACEOF
8953
/* confdefs.h.  */
8954
_ACEOF
8955
cat confdefs.h >>conftest.$ac_ext
8956
cat >>conftest.$ac_ext <<_ACEOF
8957
/* end confdefs.h.  */
8958
$ac_includes_default
8959
int
8960
main ()
8961
{
8962
static int test_array [1 - 2 * !(((long) (sizeof (short))) >= 0)];
8963
test_array [0] = 0
8964
 
8965
  ;
8966
  return 0;
8967
}
8968
_ACEOF
8969
rm -f conftest.$ac_objext
8970
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8971
  (eval $ac_compile) 2>conftest.er1
8972
  ac_status=$?
8973
  grep -v '^ *+' conftest.er1 >conftest.err
8974
  rm -f conftest.er1
8975
  cat conftest.err >&5
8976
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8977
  (exit $ac_status); } &&
8978
         { ac_try='test -z "$ac_c_werror_flag"
8979
                         || test ! -s conftest.err'
8980
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8981
  (eval $ac_try) 2>&5
8982
  ac_status=$?
8983
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8984
  (exit $ac_status); }; } &&
8985
         { ac_try='test -s conftest.$ac_objext'
8986
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8987
  (eval $ac_try) 2>&5
8988
  ac_status=$?
8989
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8990
  (exit $ac_status); }; }; then
8991
  ac_lo=0 ac_mid=0
8992
  while :; do
8993
    cat >conftest.$ac_ext <<_ACEOF
8994
/* confdefs.h.  */
8995
_ACEOF
8996
cat confdefs.h >>conftest.$ac_ext
8997
cat >>conftest.$ac_ext <<_ACEOF
8998
/* end confdefs.h.  */
8999
$ac_includes_default
9000
int
9001
main ()
9002
{
9003
static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)];
9004
test_array [0] = 0
9005
 
9006
  ;
9007
  return 0;
9008
}
9009
_ACEOF
9010
rm -f conftest.$ac_objext
9011
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9012
  (eval $ac_compile) 2>conftest.er1
9013
  ac_status=$?
9014
  grep -v '^ *+' conftest.er1 >conftest.err
9015
  rm -f conftest.er1
9016
  cat conftest.err >&5
9017
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9018
  (exit $ac_status); } &&
9019
         { ac_try='test -z "$ac_c_werror_flag"
9020
                         || test ! -s conftest.err'
9021
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9022
  (eval $ac_try) 2>&5
9023
  ac_status=$?
9024
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9025
  (exit $ac_status); }; } &&
9026
         { ac_try='test -s conftest.$ac_objext'
9027
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9028
  (eval $ac_try) 2>&5
9029
  ac_status=$?
9030
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9031
  (exit $ac_status); }; }; then
9032
  ac_hi=$ac_mid; break
9033
else
9034
  echo "$as_me: failed program was:" >&5
9035
sed 's/^/| /' conftest.$ac_ext >&5
9036
 
9037
ac_lo=`expr $ac_mid + 1`
9038
                    if test $ac_lo -le $ac_mid; then
9039
                      ac_lo= ac_hi=
9040
                      break
9041
                    fi
9042
                    ac_mid=`expr 2 '*' $ac_mid + 1`
9043
fi
9044
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9045
  done
9046
else
9047
  echo "$as_me: failed program was:" >&5
9048
sed 's/^/| /' conftest.$ac_ext >&5
9049
 
9050
cat >conftest.$ac_ext <<_ACEOF
9051
/* confdefs.h.  */
9052
_ACEOF
9053
cat confdefs.h >>conftest.$ac_ext
9054
cat >>conftest.$ac_ext <<_ACEOF
9055
/* end confdefs.h.  */
9056
$ac_includes_default
9057
int
9058
main ()
9059
{
9060
static int test_array [1 - 2 * !(((long) (sizeof (short))) < 0)];
9061
test_array [0] = 0
9062
 
9063
  ;
9064
  return 0;
9065
}
9066
_ACEOF
9067
rm -f conftest.$ac_objext
9068
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9069
  (eval $ac_compile) 2>conftest.er1
9070
  ac_status=$?
9071
  grep -v '^ *+' conftest.er1 >conftest.err
9072
  rm -f conftest.er1
9073
  cat conftest.err >&5
9074
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9075
  (exit $ac_status); } &&
9076
         { ac_try='test -z "$ac_c_werror_flag"
9077
                         || test ! -s conftest.err'
9078
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9079
  (eval $ac_try) 2>&5
9080
  ac_status=$?
9081
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9082
  (exit $ac_status); }; } &&
9083
         { ac_try='test -s conftest.$ac_objext'
9084
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9085
  (eval $ac_try) 2>&5
9086
  ac_status=$?
9087
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9088
  (exit $ac_status); }; }; then
9089
  ac_hi=-1 ac_mid=-1
9090
  while :; do
9091
    cat >conftest.$ac_ext <<_ACEOF
9092
/* confdefs.h.  */
9093
_ACEOF
9094
cat confdefs.h >>conftest.$ac_ext
9095
cat >>conftest.$ac_ext <<_ACEOF
9096
/* end confdefs.h.  */
9097
$ac_includes_default
9098
int
9099
main ()
9100
{
9101
static int test_array [1 - 2 * !(((long) (sizeof (short))) >= $ac_mid)];
9102
test_array [0] = 0
9103
 
9104
  ;
9105
  return 0;
9106
}
9107
_ACEOF
9108
rm -f conftest.$ac_objext
9109
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9110
  (eval $ac_compile) 2>conftest.er1
9111
  ac_status=$?
9112
  grep -v '^ *+' conftest.er1 >conftest.err
9113
  rm -f conftest.er1
9114
  cat conftest.err >&5
9115
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9116
  (exit $ac_status); } &&
9117
         { ac_try='test -z "$ac_c_werror_flag"
9118
                         || test ! -s conftest.err'
9119
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9120
  (eval $ac_try) 2>&5
9121
  ac_status=$?
9122
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9123
  (exit $ac_status); }; } &&
9124
         { ac_try='test -s conftest.$ac_objext'
9125
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9126
  (eval $ac_try) 2>&5
9127
  ac_status=$?
9128
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9129
  (exit $ac_status); }; }; then
9130
  ac_lo=$ac_mid; break
9131
else
9132
  echo "$as_me: failed program was:" >&5
9133
sed 's/^/| /' conftest.$ac_ext >&5
9134
 
9135
ac_hi=`expr '(' $ac_mid ')' - 1`
9136
                       if test $ac_mid -le $ac_hi; then
9137
                         ac_lo= ac_hi=
9138
                         break
9139
                       fi
9140
                       ac_mid=`expr 2 '*' $ac_mid`
9141
fi
9142
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9143
  done
9144
else
9145
  echo "$as_me: failed program was:" >&5
9146
sed 's/^/| /' conftest.$ac_ext >&5
9147
 
9148
ac_lo= ac_hi=
9149
fi
9150
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9151
fi
9152
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9153
# Binary search between lo and hi bounds.
9154
while test "x$ac_lo" != "x$ac_hi"; do
9155
  ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
9156
  cat >conftest.$ac_ext <<_ACEOF
9157
/* confdefs.h.  */
9158
_ACEOF
9159
cat confdefs.h >>conftest.$ac_ext
9160
cat >>conftest.$ac_ext <<_ACEOF
9161
/* end confdefs.h.  */
9162
$ac_includes_default
9163
int
9164
main ()
9165
{
9166
static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)];
9167
test_array [0] = 0
9168
 
9169
  ;
9170
  return 0;
9171
}
9172
_ACEOF
9173
rm -f conftest.$ac_objext
9174
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9175
  (eval $ac_compile) 2>conftest.er1
9176
  ac_status=$?
9177
  grep -v '^ *+' conftest.er1 >conftest.err
9178
  rm -f conftest.er1
9179
  cat conftest.err >&5
9180
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9181
  (exit $ac_status); } &&
9182
         { ac_try='test -z "$ac_c_werror_flag"
9183
                         || test ! -s conftest.err'
9184
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9185
  (eval $ac_try) 2>&5
9186
  ac_status=$?
9187
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9188
  (exit $ac_status); }; } &&
9189
         { ac_try='test -s conftest.$ac_objext'
9190
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9191
  (eval $ac_try) 2>&5
9192
  ac_status=$?
9193
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9194
  (exit $ac_status); }; }; then
9195
  ac_hi=$ac_mid
9196
else
9197
  echo "$as_me: failed program was:" >&5
9198
sed 's/^/| /' conftest.$ac_ext >&5
9199
 
9200
ac_lo=`expr '(' $ac_mid ')' + 1`
9201
fi
9202
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9203
done
9204
case $ac_lo in
9205
?*) ac_cv_sizeof_short=$ac_lo;;
9206
'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77
9207
See \`config.log' for more details." >&5
9208
echo "$as_me: error: cannot compute sizeof (short), 77
9209
See \`config.log' for more details." >&2;}
9210
   { (exit 1); exit 1; }; } ;;
9211
esac
9212
else
9213
  if test "$cross_compiling" = yes; then
9214
  { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
9215
See \`config.log' for more details." >&5
9216
echo "$as_me: error: cannot run test program while cross compiling
9217
See \`config.log' for more details." >&2;}
9218
   { (exit 1); exit 1; }; }
9219
else
9220
  cat >conftest.$ac_ext <<_ACEOF
9221
/* confdefs.h.  */
9222
_ACEOF
9223
cat confdefs.h >>conftest.$ac_ext
9224
cat >>conftest.$ac_ext <<_ACEOF
9225
/* end confdefs.h.  */
9226
$ac_includes_default
9227
long longval () { return (long) (sizeof (short)); }
9228
unsigned long ulongval () { return (long) (sizeof (short)); }
9229
#include 
9230
#include 
9231
int
9232
main ()
9233
{
9234
 
9235
  FILE *f = fopen ("conftest.val", "w");
9236
  if (! f)
9237
    exit (1);
9238
  if (((long) (sizeof (short))) < 0)
9239
    {
9240
      long i = longval ();
9241
      if (i != ((long) (sizeof (short))))
9242
        exit (1);
9243
      fprintf (f, "%ld\n", i);
9244
    }
9245
  else
9246
    {
9247
      unsigned long i = ulongval ();
9248
      if (i != ((long) (sizeof (short))))
9249
        exit (1);
9250
      fprintf (f, "%lu\n", i);
9251
    }
9252
  exit (ferror (f) || fclose (f) != 0);
9253
 
9254
  ;
9255
  return 0;
9256
}
9257
_ACEOF
9258
rm -f conftest$ac_exeext
9259
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9260
  (eval $ac_link) 2>&5
9261
  ac_status=$?
9262
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9263
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9264
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9265
  (eval $ac_try) 2>&5
9266
  ac_status=$?
9267
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9268
  (exit $ac_status); }; }; then
9269
  ac_cv_sizeof_short=`cat conftest.val`
9270
else
9271
  echo "$as_me: program exited with status $ac_status" >&5
9272
echo "$as_me: failed program was:" >&5
9273
sed 's/^/| /' conftest.$ac_ext >&5
9274
 
9275
( exit $ac_status )
9276
{ { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77
9277
See \`config.log' for more details." >&5
9278
echo "$as_me: error: cannot compute sizeof (short), 77
9279
See \`config.log' for more details." >&2;}
9280
   { (exit 1); exit 1; }; }
9281
fi
9282
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9283
fi
9284
fi
9285
rm -f conftest.val
9286
else
9287
  ac_cv_sizeof_short=0
9288
fi
9289
fi
9290
echo "$as_me:$LINENO: result: $ac_cv_sizeof_short" >&5
9291
echo "${ECHO_T}$ac_cv_sizeof_short" >&6
9292
cat >>confdefs.h <<_ACEOF
9293
#define SIZEOF_SHORT $ac_cv_sizeof_short
9294
_ACEOF
9295
 
9296
 
9297
  echo "$as_me:$LINENO: checking for char" >&5
9298
echo $ECHO_N "checking for char... $ECHO_C" >&6
9299
if test "${ac_cv_type_char+set}" = set; then
9300
  echo $ECHO_N "(cached) $ECHO_C" >&6
9301
else
9302
  cat >conftest.$ac_ext <<_ACEOF
9303
/* confdefs.h.  */
9304
_ACEOF
9305
cat confdefs.h >>conftest.$ac_ext
9306
cat >>conftest.$ac_ext <<_ACEOF
9307
/* end confdefs.h.  */
9308
$ac_includes_default
9309
int
9310
main ()
9311
{
9312
if ((char *) 0)
9313
  return 0;
9314
if (sizeof (char))
9315
  return 0;
9316
  ;
9317
  return 0;
9318
}
9319
_ACEOF
9320
rm -f conftest.$ac_objext
9321
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9322
  (eval $ac_compile) 2>conftest.er1
9323
  ac_status=$?
9324
  grep -v '^ *+' conftest.er1 >conftest.err
9325
  rm -f conftest.er1
9326
  cat conftest.err >&5
9327
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9328
  (exit $ac_status); } &&
9329
         { ac_try='test -z "$ac_c_werror_flag"
9330
                         || test ! -s conftest.err'
9331
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9332
  (eval $ac_try) 2>&5
9333
  ac_status=$?
9334
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9335
  (exit $ac_status); }; } &&
9336
         { ac_try='test -s conftest.$ac_objext'
9337
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9338
  (eval $ac_try) 2>&5
9339
  ac_status=$?
9340
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9341
  (exit $ac_status); }; }; then
9342
  ac_cv_type_char=yes
9343
else
9344
  echo "$as_me: failed program was:" >&5
9345
sed 's/^/| /' conftest.$ac_ext >&5
9346
 
9347
ac_cv_type_char=no
9348
fi
9349
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9350
fi
9351
echo "$as_me:$LINENO: result: $ac_cv_type_char" >&5
9352
echo "${ECHO_T}$ac_cv_type_char" >&6
9353
 
9354
echo "$as_me:$LINENO: checking size of char" >&5
9355
echo $ECHO_N "checking size of char... $ECHO_C" >&6
9356
if test "${ac_cv_sizeof_char+set}" = set; then
9357
  echo $ECHO_N "(cached) $ECHO_C" >&6
9358
else
9359
  if test "$ac_cv_type_char" = yes; then
9360
  # The cast to unsigned long works around a bug in the HP C Compiler
9361
  # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
9362
  # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
9363
  # This bug is HP SR number 8606223364.
9364
  if test "$cross_compiling" = yes; then
9365
  # Depending upon the size, compute the lo and hi bounds.
9366
cat >conftest.$ac_ext <<_ACEOF
9367
/* confdefs.h.  */
9368
_ACEOF
9369
cat confdefs.h >>conftest.$ac_ext
9370
cat >>conftest.$ac_ext <<_ACEOF
9371
/* end confdefs.h.  */
9372
$ac_includes_default
9373
int
9374
main ()
9375
{
9376
static int test_array [1 - 2 * !(((long) (sizeof (char))) >= 0)];
9377
test_array [0] = 0
9378
 
9379
  ;
9380
  return 0;
9381
}
9382
_ACEOF
9383
rm -f conftest.$ac_objext
9384
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9385
  (eval $ac_compile) 2>conftest.er1
9386
  ac_status=$?
9387
  grep -v '^ *+' conftest.er1 >conftest.err
9388
  rm -f conftest.er1
9389
  cat conftest.err >&5
9390
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9391
  (exit $ac_status); } &&
9392
         { ac_try='test -z "$ac_c_werror_flag"
9393
                         || test ! -s conftest.err'
9394
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9395
  (eval $ac_try) 2>&5
9396
  ac_status=$?
9397
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9398
  (exit $ac_status); }; } &&
9399
         { ac_try='test -s conftest.$ac_objext'
9400
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9401
  (eval $ac_try) 2>&5
9402
  ac_status=$?
9403
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9404
  (exit $ac_status); }; }; then
9405
  ac_lo=0 ac_mid=0
9406
  while :; do
9407
    cat >conftest.$ac_ext <<_ACEOF
9408
/* confdefs.h.  */
9409
_ACEOF
9410
cat confdefs.h >>conftest.$ac_ext
9411
cat >>conftest.$ac_ext <<_ACEOF
9412
/* end confdefs.h.  */
9413
$ac_includes_default
9414
int
9415
main ()
9416
{
9417
static int test_array [1 - 2 * !(((long) (sizeof (char))) <= $ac_mid)];
9418
test_array [0] = 0
9419
 
9420
  ;
9421
  return 0;
9422
}
9423
_ACEOF
9424
rm -f conftest.$ac_objext
9425
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9426
  (eval $ac_compile) 2>conftest.er1
9427
  ac_status=$?
9428
  grep -v '^ *+' conftest.er1 >conftest.err
9429
  rm -f conftest.er1
9430
  cat conftest.err >&5
9431
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9432
  (exit $ac_status); } &&
9433
         { ac_try='test -z "$ac_c_werror_flag"
9434
                         || test ! -s conftest.err'
9435
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9436
  (eval $ac_try) 2>&5
9437
  ac_status=$?
9438
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9439
  (exit $ac_status); }; } &&
9440
         { ac_try='test -s conftest.$ac_objext'
9441
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9442
  (eval $ac_try) 2>&5
9443
  ac_status=$?
9444
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9445
  (exit $ac_status); }; }; then
9446
  ac_hi=$ac_mid; break
9447
else
9448
  echo "$as_me: failed program was:" >&5
9449
sed 's/^/| /' conftest.$ac_ext >&5
9450
 
9451
ac_lo=`expr $ac_mid + 1`
9452
                    if test $ac_lo -le $ac_mid; then
9453
                      ac_lo= ac_hi=
9454
                      break
9455
                    fi
9456
                    ac_mid=`expr 2 '*' $ac_mid + 1`
9457
fi
9458
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9459
  done
9460
else
9461
  echo "$as_me: failed program was:" >&5
9462
sed 's/^/| /' conftest.$ac_ext >&5
9463
 
9464
cat >conftest.$ac_ext <<_ACEOF
9465
/* confdefs.h.  */
9466
_ACEOF
9467
cat confdefs.h >>conftest.$ac_ext
9468
cat >>conftest.$ac_ext <<_ACEOF
9469
/* end confdefs.h.  */
9470
$ac_includes_default
9471
int
9472
main ()
9473
{
9474
static int test_array [1 - 2 * !(((long) (sizeof (char))) < 0)];
9475
test_array [0] = 0
9476
 
9477
  ;
9478
  return 0;
9479
}
9480
_ACEOF
9481
rm -f conftest.$ac_objext
9482
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9483
  (eval $ac_compile) 2>conftest.er1
9484
  ac_status=$?
9485
  grep -v '^ *+' conftest.er1 >conftest.err
9486
  rm -f conftest.er1
9487
  cat conftest.err >&5
9488
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9489
  (exit $ac_status); } &&
9490
         { ac_try='test -z "$ac_c_werror_flag"
9491
                         || test ! -s conftest.err'
9492
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9493
  (eval $ac_try) 2>&5
9494
  ac_status=$?
9495
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9496
  (exit $ac_status); }; } &&
9497
         { ac_try='test -s conftest.$ac_objext'
9498
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9499
  (eval $ac_try) 2>&5
9500
  ac_status=$?
9501
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9502
  (exit $ac_status); }; }; then
9503
  ac_hi=-1 ac_mid=-1
9504
  while :; do
9505
    cat >conftest.$ac_ext <<_ACEOF
9506
/* confdefs.h.  */
9507
_ACEOF
9508
cat confdefs.h >>conftest.$ac_ext
9509
cat >>conftest.$ac_ext <<_ACEOF
9510
/* end confdefs.h.  */
9511
$ac_includes_default
9512
int
9513
main ()
9514
{
9515
static int test_array [1 - 2 * !(((long) (sizeof (char))) >= $ac_mid)];
9516
test_array [0] = 0
9517
 
9518
  ;
9519
  return 0;
9520
}
9521
_ACEOF
9522
rm -f conftest.$ac_objext
9523
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9524
  (eval $ac_compile) 2>conftest.er1
9525
  ac_status=$?
9526
  grep -v '^ *+' conftest.er1 >conftest.err
9527
  rm -f conftest.er1
9528
  cat conftest.err >&5
9529
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9530
  (exit $ac_status); } &&
9531
         { ac_try='test -z "$ac_c_werror_flag"
9532
                         || test ! -s conftest.err'
9533
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9534
  (eval $ac_try) 2>&5
9535
  ac_status=$?
9536
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9537
  (exit $ac_status); }; } &&
9538
         { ac_try='test -s conftest.$ac_objext'
9539
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9540
  (eval $ac_try) 2>&5
9541
  ac_status=$?
9542
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9543
  (exit $ac_status); }; }; then
9544
  ac_lo=$ac_mid; break
9545
else
9546
  echo "$as_me: failed program was:" >&5
9547
sed 's/^/| /' conftest.$ac_ext >&5
9548
 
9549
ac_hi=`expr '(' $ac_mid ')' - 1`
9550
                       if test $ac_mid -le $ac_hi; then
9551
                         ac_lo= ac_hi=
9552
                         break
9553
                       fi
9554
                       ac_mid=`expr 2 '*' $ac_mid`
9555
fi
9556
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9557
  done
9558
else
9559
  echo "$as_me: failed program was:" >&5
9560
sed 's/^/| /' conftest.$ac_ext >&5
9561
 
9562
ac_lo= ac_hi=
9563
fi
9564
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9565
fi
9566
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9567
# Binary search between lo and hi bounds.
9568
while test "x$ac_lo" != "x$ac_hi"; do
9569
  ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
9570
  cat >conftest.$ac_ext <<_ACEOF
9571
/* confdefs.h.  */
9572
_ACEOF
9573
cat confdefs.h >>conftest.$ac_ext
9574
cat >>conftest.$ac_ext <<_ACEOF
9575
/* end confdefs.h.  */
9576
$ac_includes_default
9577
int
9578
main ()
9579
{
9580
static int test_array [1 - 2 * !(((long) (sizeof (char))) <= $ac_mid)];
9581
test_array [0] = 0
9582
 
9583
  ;
9584
  return 0;
9585
}
9586
_ACEOF
9587
rm -f conftest.$ac_objext
9588
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9589
  (eval $ac_compile) 2>conftest.er1
9590
  ac_status=$?
9591
  grep -v '^ *+' conftest.er1 >conftest.err
9592
  rm -f conftest.er1
9593
  cat conftest.err >&5
9594
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9595
  (exit $ac_status); } &&
9596
         { ac_try='test -z "$ac_c_werror_flag"
9597
                         || test ! -s conftest.err'
9598
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9599
  (eval $ac_try) 2>&5
9600
  ac_status=$?
9601
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9602
  (exit $ac_status); }; } &&
9603
         { ac_try='test -s conftest.$ac_objext'
9604
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9605
  (eval $ac_try) 2>&5
9606
  ac_status=$?
9607
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9608
  (exit $ac_status); }; }; then
9609
  ac_hi=$ac_mid
9610
else
9611
  echo "$as_me: failed program was:" >&5
9612
sed 's/^/| /' conftest.$ac_ext >&5
9613
 
9614
ac_lo=`expr '(' $ac_mid ')' + 1`
9615
fi
9616
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9617
done
9618
case $ac_lo in
9619
?*) ac_cv_sizeof_char=$ac_lo;;
9620
'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (char), 77
9621
See \`config.log' for more details." >&5
9622
echo "$as_me: error: cannot compute sizeof (char), 77
9623
See \`config.log' for more details." >&2;}
9624
   { (exit 1); exit 1; }; } ;;
9625
esac
9626
else
9627
  if test "$cross_compiling" = yes; then
9628
  { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
9629
See \`config.log' for more details." >&5
9630
echo "$as_me: error: cannot run test program while cross compiling
9631
See \`config.log' for more details." >&2;}
9632
   { (exit 1); exit 1; }; }
9633
else
9634
  cat >conftest.$ac_ext <<_ACEOF
9635
/* confdefs.h.  */
9636
_ACEOF
9637
cat confdefs.h >>conftest.$ac_ext
9638
cat >>conftest.$ac_ext <<_ACEOF
9639
/* end confdefs.h.  */
9640
$ac_includes_default
9641
long longval () { return (long) (sizeof (char)); }
9642
unsigned long ulongval () { return (long) (sizeof (char)); }
9643
#include 
9644
#include 
9645
int
9646
main ()
9647
{
9648
 
9649
  FILE *f = fopen ("conftest.val", "w");
9650
  if (! f)
9651
    exit (1);
9652
  if (((long) (sizeof (char))) < 0)
9653
    {
9654
      long i = longval ();
9655
      if (i != ((long) (sizeof (char))))
9656
        exit (1);
9657
      fprintf (f, "%ld\n", i);
9658
    }
9659
  else
9660
    {
9661
      unsigned long i = ulongval ();
9662
      if (i != ((long) (sizeof (char))))
9663
        exit (1);
9664
      fprintf (f, "%lu\n", i);
9665
    }
9666
  exit (ferror (f) || fclose (f) != 0);
9667
 
9668
  ;
9669
  return 0;
9670
}
9671
_ACEOF
9672
rm -f conftest$ac_exeext
9673
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9674
  (eval $ac_link) 2>&5
9675
  ac_status=$?
9676
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9677
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9678
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9679
  (eval $ac_try) 2>&5
9680
  ac_status=$?
9681
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9682
  (exit $ac_status); }; }; then
9683
  ac_cv_sizeof_char=`cat conftest.val`
9684
else
9685
  echo "$as_me: program exited with status $ac_status" >&5
9686
echo "$as_me: failed program was:" >&5
9687
sed 's/^/| /' conftest.$ac_ext >&5
9688
 
9689
( exit $ac_status )
9690
{ { echo "$as_me:$LINENO: error: cannot compute sizeof (char), 77
9691
See \`config.log' for more details." >&5
9692
echo "$as_me: error: cannot compute sizeof (char), 77
9693
See \`config.log' for more details." >&2;}
9694
   { (exit 1); exit 1; }; }
9695
fi
9696
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9697
fi
9698
fi
9699
rm -f conftest.val
9700
else
9701
  ac_cv_sizeof_char=0
9702
fi
9703
fi
9704
echo "$as_me:$LINENO: result: $ac_cv_sizeof_char" >&5
9705
echo "${ECHO_T}$ac_cv_sizeof_char" >&6
9706
cat >>confdefs.h <<_ACEOF
9707
#define SIZEOF_CHAR $ac_cv_sizeof_char
9708
_ACEOF
9709
 
9710
 
9711
 
9712
  echo "$as_me:$LINENO: checking for type equivalent to int8_t" >&5
9713
echo $ECHO_N "checking for type equivalent to int8_t... $ECHO_C" >&6
9714
  case "$ac_cv_sizeof_char" in
9715
    1) acx_cv_type_int8_t=char ;;
9716
    *) { { echo "$as_me:$LINENO: error: no 8-bit type" >&5
9717
echo "$as_me: error: no 8-bit type" >&2;}
9718
   { (exit please report a bug); exit please report a bug; }; }
9719
  esac
9720
  echo "$as_me:$LINENO: result: $acx_cv_type_int8_t" >&5
9721
echo "${ECHO_T}$acx_cv_type_int8_t" >&6
9722
 
9723
  echo "$as_me:$LINENO: checking for type equivalent to int16_t" >&5
9724
echo $ECHO_N "checking for type equivalent to int16_t... $ECHO_C" >&6
9725
  case "$ac_cv_sizeof_int:$ac_cv_sizeof_short" in
9726
    2:*) acx_cv_type_int16_t=int ;;
9727
    *:2) acx_cv_type_int16_t=short ;;
9728
    *) { { echo "$as_me:$LINENO: error: no 16-bit type" >&5
9729
echo "$as_me: error: no 16-bit type" >&2;}
9730
   { (exit please report a bug); exit please report a bug; }; }
9731
  esac
9732
  echo "$as_me:$LINENO: result: $acx_cv_type_int16_t" >&5
9733
echo "${ECHO_T}$acx_cv_type_int16_t" >&6
9734
 
9735
  echo "$as_me:$LINENO: checking for type equivalent to int32_t" >&5
9736
echo $ECHO_N "checking for type equivalent to int32_t... $ECHO_C" >&6
9737
  case "$ac_cv_sizeof_int:$ac_cv_sizeof_long" in
9738
    4:*) acx_cv_type_int32_t=int ;;
9739
    *:4) acx_cv_type_int32_t=long ;;
9740
    *) { { echo "$as_me:$LINENO: error: no 32-bit type" >&5
9741
echo "$as_me: error: no 32-bit type" >&2;}
9742
   { (exit please report a bug); exit please report a bug; }; }
9743
  esac
9744
  echo "$as_me:$LINENO: result: $acx_cv_type_int32_t" >&5
9745
echo "${ECHO_T}$acx_cv_type_int32_t" >&6
9746
fi
9747
 
9748
# These tests are here to make the output prettier
9749
 
9750
if test "$ac_cv_type_uint64_t" != yes && test "$ac_cv_type_u_int64_t" != yes; then
9751
  case "$ac_cv_sizeof_long" in
9752
    8) acx_cv_type_int64_t=long ;;
9753
  esac
9754
  echo "$as_me:$LINENO: checking for type equivalent to int64_t" >&5
9755
echo $ECHO_N "checking for type equivalent to int64_t... $ECHO_C" >&6
9756
  echo "$as_me:$LINENO: result: ${acx_cv_type_int64_t-'using preprocessor symbols'}" >&5
9757
echo "${ECHO_T}${acx_cv_type_int64_t-'using preprocessor symbols'}" >&6
9758
fi
9759
 
9760
# Now we can use the above types
9761
 
9762
if test "$ac_cv_type_uintptr_t" != yes; then
9763
  echo "$as_me:$LINENO: checking for type equivalent to intptr_t" >&5
9764
echo $ECHO_N "checking for type equivalent to intptr_t... $ECHO_C" >&6
9765
  case $ac_cv_sizeof_void_p in
9766
    2) acx_cv_type_intptr_t=int16_t ;;
9767
    4) acx_cv_type_intptr_t=int32_t ;;
9768
    8) acx_cv_type_intptr_t=int64_t ;;
9769
    *) { { echo "$as_me:$LINENO: error: no equivalent for intptr_t" >&5
9770
echo "$as_me: error: no equivalent for intptr_t" >&2;}
9771
   { (exit please report a bug); exit please report a bug; }; }
9772
  esac
9773
  echo "$as_me:$LINENO: result: $acx_cv_type_intptr_t" >&5
9774
echo "${ECHO_T}$acx_cv_type_intptr_t" >&6
9775
fi
9776
 
9777
# ----------------- done all checks, emit header -------------
9778
          ac_config_commands="$ac_config_commands gstdint.h"
9779
 
9780
 
9781
 
9782
 
9783
echo "$as_me:$LINENO: checking for struct stat.st_blksize" >&5
9784
echo $ECHO_N "checking for struct stat.st_blksize... $ECHO_C" >&6
9785
if test "${ac_cv_member_struct_stat_st_blksize+set}" = set; then
9786
  echo $ECHO_N "(cached) $ECHO_C" >&6
9787
else
9788
  cat >conftest.$ac_ext <<_ACEOF
9789
/* confdefs.h.  */
9790
_ACEOF
9791
cat confdefs.h >>conftest.$ac_ext
9792
cat >>conftest.$ac_ext <<_ACEOF
9793
/* end confdefs.h.  */
9794
$ac_includes_default
9795
int
9796
main ()
9797
{
9798
static struct stat ac_aggr;
9799
if (ac_aggr.st_blksize)
9800
return 0;
9801
  ;
9802
  return 0;
9803
}
9804
_ACEOF
9805
rm -f conftest.$ac_objext
9806
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9807
  (eval $ac_compile) 2>conftest.er1
9808
  ac_status=$?
9809
  grep -v '^ *+' conftest.er1 >conftest.err
9810
  rm -f conftest.er1
9811
  cat conftest.err >&5
9812
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9813
  (exit $ac_status); } &&
9814
         { ac_try='test -z "$ac_c_werror_flag"
9815
                         || test ! -s conftest.err'
9816
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9817
  (eval $ac_try) 2>&5
9818
  ac_status=$?
9819
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9820
  (exit $ac_status); }; } &&
9821
         { ac_try='test -s conftest.$ac_objext'
9822
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9823
  (eval $ac_try) 2>&5
9824
  ac_status=$?
9825
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9826
  (exit $ac_status); }; }; then
9827
  ac_cv_member_struct_stat_st_blksize=yes
9828
else
9829
  echo "$as_me: failed program was:" >&5
9830
sed 's/^/| /' conftest.$ac_ext >&5
9831
 
9832
cat >conftest.$ac_ext <<_ACEOF
9833
/* confdefs.h.  */
9834
_ACEOF
9835
cat confdefs.h >>conftest.$ac_ext
9836
cat >>conftest.$ac_ext <<_ACEOF
9837
/* end confdefs.h.  */
9838
$ac_includes_default
9839
int
9840
main ()
9841
{
9842
static struct stat ac_aggr;
9843
if (sizeof ac_aggr.st_blksize)
9844
return 0;
9845
  ;
9846
  return 0;
9847
}
9848
_ACEOF
9849
rm -f conftest.$ac_objext
9850
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9851
  (eval $ac_compile) 2>conftest.er1
9852
  ac_status=$?
9853
  grep -v '^ *+' conftest.er1 >conftest.err
9854
  rm -f conftest.er1
9855
  cat conftest.err >&5
9856
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9857
  (exit $ac_status); } &&
9858
         { ac_try='test -z "$ac_c_werror_flag"
9859
                         || test ! -s conftest.err'
9860
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9861
  (eval $ac_try) 2>&5
9862
  ac_status=$?
9863
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9864
  (exit $ac_status); }; } &&
9865
         { ac_try='test -s conftest.$ac_objext'
9866
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9867
  (eval $ac_try) 2>&5
9868
  ac_status=$?
9869
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9870
  (exit $ac_status); }; }; then
9871
  ac_cv_member_struct_stat_st_blksize=yes
9872
else
9873
  echo "$as_me: failed program was:" >&5
9874
sed 's/^/| /' conftest.$ac_ext >&5
9875
 
9876
ac_cv_member_struct_stat_st_blksize=no
9877
fi
9878
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9879
fi
9880
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9881
fi
9882
echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blksize" >&5
9883
echo "${ECHO_T}$ac_cv_member_struct_stat_st_blksize" >&6
9884
if test $ac_cv_member_struct_stat_st_blksize = yes; then
9885
 
9886
cat >>confdefs.h <<_ACEOF
9887
#define HAVE_STRUCT_STAT_ST_BLKSIZE 1
9888
_ACEOF
9889
 
9890
 
9891
fi
9892
 
9893
echo "$as_me:$LINENO: checking for struct stat.st_blocks" >&5
9894
echo $ECHO_N "checking for struct stat.st_blocks... $ECHO_C" >&6
9895
if test "${ac_cv_member_struct_stat_st_blocks+set}" = set; then
9896
  echo $ECHO_N "(cached) $ECHO_C" >&6
9897
else
9898
  cat >conftest.$ac_ext <<_ACEOF
9899
/* confdefs.h.  */
9900
_ACEOF
9901
cat confdefs.h >>conftest.$ac_ext
9902
cat >>conftest.$ac_ext <<_ACEOF
9903
/* end confdefs.h.  */
9904
$ac_includes_default
9905
int
9906
main ()
9907
{
9908
static struct stat ac_aggr;
9909
if (ac_aggr.st_blocks)
9910
return 0;
9911
  ;
9912
  return 0;
9913
}
9914
_ACEOF
9915
rm -f conftest.$ac_objext
9916
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9917
  (eval $ac_compile) 2>conftest.er1
9918
  ac_status=$?
9919
  grep -v '^ *+' conftest.er1 >conftest.err
9920
  rm -f conftest.er1
9921
  cat conftest.err >&5
9922
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9923
  (exit $ac_status); } &&
9924
         { ac_try='test -z "$ac_c_werror_flag"
9925
                         || test ! -s conftest.err'
9926
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9927
  (eval $ac_try) 2>&5
9928
  ac_status=$?
9929
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9930
  (exit $ac_status); }; } &&
9931
         { ac_try='test -s conftest.$ac_objext'
9932
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9933
  (eval $ac_try) 2>&5
9934
  ac_status=$?
9935
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9936
  (exit $ac_status); }; }; then
9937
  ac_cv_member_struct_stat_st_blocks=yes
9938
else
9939
  echo "$as_me: failed program was:" >&5
9940
sed 's/^/| /' conftest.$ac_ext >&5
9941
 
9942
cat >conftest.$ac_ext <<_ACEOF
9943
/* confdefs.h.  */
9944
_ACEOF
9945
cat confdefs.h >>conftest.$ac_ext
9946
cat >>conftest.$ac_ext <<_ACEOF
9947
/* end confdefs.h.  */
9948
$ac_includes_default
9949
int
9950
main ()
9951
{
9952
static struct stat ac_aggr;
9953
if (sizeof ac_aggr.st_blocks)
9954
return 0;
9955
  ;
9956
  return 0;
9957
}
9958
_ACEOF
9959
rm -f conftest.$ac_objext
9960
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9961
  (eval $ac_compile) 2>conftest.er1
9962
  ac_status=$?
9963
  grep -v '^ *+' conftest.er1 >conftest.err
9964
  rm -f conftest.er1
9965
  cat conftest.err >&5
9966
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9967
  (exit $ac_status); } &&
9968
         { ac_try='test -z "$ac_c_werror_flag"
9969
                         || test ! -s conftest.err'
9970
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9971
  (eval $ac_try) 2>&5
9972
  ac_status=$?
9973
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9974
  (exit $ac_status); }; } &&
9975
         { ac_try='test -s conftest.$ac_objext'
9976
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9977
  (eval $ac_try) 2>&5
9978
  ac_status=$?
9979
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9980
  (exit $ac_status); }; }; then
9981
  ac_cv_member_struct_stat_st_blocks=yes
9982
else
9983
  echo "$as_me: failed program was:" >&5
9984
sed 's/^/| /' conftest.$ac_ext >&5
9985
 
9986
ac_cv_member_struct_stat_st_blocks=no
9987
fi
9988
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9989
fi
9990
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9991
fi
9992
echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blocks" >&5
9993
echo "${ECHO_T}$ac_cv_member_struct_stat_st_blocks" >&6
9994
if test $ac_cv_member_struct_stat_st_blocks = yes; then
9995
 
9996
cat >>confdefs.h <<_ACEOF
9997
#define HAVE_STRUCT_STAT_ST_BLOCKS 1
9998
_ACEOF
9999
 
10000
 
10001
fi
10002
 
10003
echo "$as_me:$LINENO: checking for struct stat.st_rdev" >&5
10004
echo $ECHO_N "checking for struct stat.st_rdev... $ECHO_C" >&6
10005
if test "${ac_cv_member_struct_stat_st_rdev+set}" = set; then
10006
  echo $ECHO_N "(cached) $ECHO_C" >&6
10007
else
10008
  cat >conftest.$ac_ext <<_ACEOF
10009
/* confdefs.h.  */
10010
_ACEOF
10011
cat confdefs.h >>conftest.$ac_ext
10012
cat >>conftest.$ac_ext <<_ACEOF
10013
/* end confdefs.h.  */
10014
$ac_includes_default
10015
int
10016
main ()
10017
{
10018
static struct stat ac_aggr;
10019
if (ac_aggr.st_rdev)
10020
return 0;
10021
  ;
10022
  return 0;
10023
}
10024
_ACEOF
10025
rm -f conftest.$ac_objext
10026
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10027
  (eval $ac_compile) 2>conftest.er1
10028
  ac_status=$?
10029
  grep -v '^ *+' conftest.er1 >conftest.err
10030
  rm -f conftest.er1
10031
  cat conftest.err >&5
10032
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10033
  (exit $ac_status); } &&
10034
         { ac_try='test -z "$ac_c_werror_flag"
10035
                         || test ! -s conftest.err'
10036
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10037
  (eval $ac_try) 2>&5
10038
  ac_status=$?
10039
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10040
  (exit $ac_status); }; } &&
10041
         { ac_try='test -s conftest.$ac_objext'
10042
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10043
  (eval $ac_try) 2>&5
10044
  ac_status=$?
10045
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10046
  (exit $ac_status); }; }; then
10047
  ac_cv_member_struct_stat_st_rdev=yes
10048
else
10049
  echo "$as_me: failed program was:" >&5
10050
sed 's/^/| /' conftest.$ac_ext >&5
10051
 
10052
cat >conftest.$ac_ext <<_ACEOF
10053
/* confdefs.h.  */
10054
_ACEOF
10055
cat confdefs.h >>conftest.$ac_ext
10056
cat >>conftest.$ac_ext <<_ACEOF
10057
/* end confdefs.h.  */
10058
$ac_includes_default
10059
int
10060
main ()
10061
{
10062
static struct stat ac_aggr;
10063
if (sizeof ac_aggr.st_rdev)
10064
return 0;
10065
  ;
10066
  return 0;
10067
}
10068
_ACEOF
10069
rm -f conftest.$ac_objext
10070
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10071
  (eval $ac_compile) 2>conftest.er1
10072
  ac_status=$?
10073
  grep -v '^ *+' conftest.er1 >conftest.err
10074
  rm -f conftest.er1
10075
  cat conftest.err >&5
10076
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10077
  (exit $ac_status); } &&
10078
         { ac_try='test -z "$ac_c_werror_flag"
10079
                         || test ! -s conftest.err'
10080
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10081
  (eval $ac_try) 2>&5
10082
  ac_status=$?
10083
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10084
  (exit $ac_status); }; } &&
10085
         { ac_try='test -s conftest.$ac_objext'
10086
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10087
  (eval $ac_try) 2>&5
10088
  ac_status=$?
10089
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10090
  (exit $ac_status); }; }; then
10091
  ac_cv_member_struct_stat_st_rdev=yes
10092
else
10093
  echo "$as_me: failed program was:" >&5
10094
sed 's/^/| /' conftest.$ac_ext >&5
10095
 
10096
ac_cv_member_struct_stat_st_rdev=no
10097
fi
10098
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10099
fi
10100
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10101
fi
10102
echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_rdev" >&5
10103
echo "${ECHO_T}$ac_cv_member_struct_stat_st_rdev" >&6
10104
if test $ac_cv_member_struct_stat_st_rdev = yes; then
10105
 
10106
cat >>confdefs.h <<_ACEOF
10107
#define HAVE_STRUCT_STAT_ST_RDEV 1
10108
_ACEOF
10109
 
10110
 
10111
fi
10112
 
10113
 
10114
# Check for library functions.
10115
 
10116
 
10117
 
10118
 
10119
 
10120
 
10121
 
10122
 
10123
for ac_func in getrusage times mkstemp strtof strtold snprintf ftruncate chsize
10124
do
10125
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10126
echo "$as_me:$LINENO: checking for $ac_func" >&5
10127
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10128
if eval "test \"\${$as_ac_var+set}\" = set"; then
10129
  echo $ECHO_N "(cached) $ECHO_C" >&6
10130
else
10131
  if test x$gcc_no_link = xyes; then
10132
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10133
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10134
   { (exit 1); exit 1; }; }
10135
fi
10136
cat >conftest.$ac_ext <<_ACEOF
10137
/* confdefs.h.  */
10138
_ACEOF
10139
cat confdefs.h >>conftest.$ac_ext
10140
cat >>conftest.$ac_ext <<_ACEOF
10141
/* end confdefs.h.  */
10142
/* Define $ac_func to an innocuous variant, in case  declares $ac_func.
10143
   For example, HP-UX 11i  declares gettimeofday.  */
10144
#define $ac_func innocuous_$ac_func
10145
 
10146
/* System header to define __stub macros and hopefully few prototypes,
10147
    which can conflict with char $ac_func (); below.
10148
    Prefer  to  if __STDC__ is defined, since
10149
     exists even on freestanding compilers.  */
10150
 
10151
#ifdef __STDC__
10152
# include 
10153
#else
10154
# include 
10155
#endif
10156
 
10157
#undef $ac_func
10158
 
10159
/* Override any gcc2 internal prototype to avoid an error.  */
10160
#ifdef __cplusplus
10161
extern "C"
10162
{
10163
#endif
10164
/* We use char because int might match the return type of a gcc2
10165
   builtin and then its argument prototype would still apply.  */
10166
char $ac_func ();
10167
/* The GNU C library defines this for functions which it implements
10168
    to always fail with ENOSYS.  Some functions are actually named
10169
    something starting with __ and the normal name is an alias.  */
10170
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10171
choke me
10172
#else
10173
char (*f) () = $ac_func;
10174
#endif
10175
#ifdef __cplusplus
10176
}
10177
#endif
10178
 
10179
int
10180
main ()
10181
{
10182
return f != $ac_func;
10183
  ;
10184
  return 0;
10185
}
10186
_ACEOF
10187
rm -f conftest.$ac_objext conftest$ac_exeext
10188
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10189
  (eval $ac_link) 2>conftest.er1
10190
  ac_status=$?
10191
  grep -v '^ *+' conftest.er1 >conftest.err
10192
  rm -f conftest.er1
10193
  cat conftest.err >&5
10194
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10195
  (exit $ac_status); } &&
10196
         { ac_try='test -z "$ac_c_werror_flag"
10197
                         || test ! -s conftest.err'
10198
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10199
  (eval $ac_try) 2>&5
10200
  ac_status=$?
10201
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10202
  (exit $ac_status); }; } &&
10203
         { ac_try='test -s conftest$ac_exeext'
10204
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10205
  (eval $ac_try) 2>&5
10206
  ac_status=$?
10207
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10208
  (exit $ac_status); }; }; then
10209
  eval "$as_ac_var=yes"
10210
else
10211
  echo "$as_me: failed program was:" >&5
10212
sed 's/^/| /' conftest.$ac_ext >&5
10213
 
10214
eval "$as_ac_var=no"
10215
fi
10216
rm -f conftest.err conftest.$ac_objext \
10217
      conftest$ac_exeext conftest.$ac_ext
10218
fi
10219
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10220
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10221
if test `eval echo '${'$as_ac_var'}'` = yes; then
10222
  cat >>confdefs.h <<_ACEOF
10223
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10224
_ACEOF
10225
 
10226
fi
10227
done
10228
 
10229
 
10230
 
10231
 
10232
 
10233
 
10234
 
10235
 
10236
 
10237
for ac_func in chdir strerror getlogin gethostname kill link symlink perror
10238
do
10239
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10240
echo "$as_me:$LINENO: checking for $ac_func" >&5
10241
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10242
if eval "test \"\${$as_ac_var+set}\" = set"; then
10243
  echo $ECHO_N "(cached) $ECHO_C" >&6
10244
else
10245
  if test x$gcc_no_link = xyes; then
10246
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10247
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10248
   { (exit 1); exit 1; }; }
10249
fi
10250
cat >conftest.$ac_ext <<_ACEOF
10251
/* confdefs.h.  */
10252
_ACEOF
10253
cat confdefs.h >>conftest.$ac_ext
10254
cat >>conftest.$ac_ext <<_ACEOF
10255
/* end confdefs.h.  */
10256
/* Define $ac_func to an innocuous variant, in case  declares $ac_func.
10257
   For example, HP-UX 11i  declares gettimeofday.  */
10258
#define $ac_func innocuous_$ac_func
10259
 
10260
/* System header to define __stub macros and hopefully few prototypes,
10261
    which can conflict with char $ac_func (); below.
10262
    Prefer  to  if __STDC__ is defined, since
10263
     exists even on freestanding compilers.  */
10264
 
10265
#ifdef __STDC__
10266
# include 
10267
#else
10268
# include 
10269
#endif
10270
 
10271
#undef $ac_func
10272
 
10273
/* Override any gcc2 internal prototype to avoid an error.  */
10274
#ifdef __cplusplus
10275
extern "C"
10276
{
10277
#endif
10278
/* We use char because int might match the return type of a gcc2
10279
   builtin and then its argument prototype would still apply.  */
10280
char $ac_func ();
10281
/* The GNU C library defines this for functions which it implements
10282
    to always fail with ENOSYS.  Some functions are actually named
10283
    something starting with __ and the normal name is an alias.  */
10284
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10285
choke me
10286
#else
10287
char (*f) () = $ac_func;
10288
#endif
10289
#ifdef __cplusplus
10290
}
10291
#endif
10292
 
10293
int
10294
main ()
10295
{
10296
return f != $ac_func;
10297
  ;
10298
  return 0;
10299
}
10300
_ACEOF
10301
rm -f conftest.$ac_objext conftest$ac_exeext
10302
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10303
  (eval $ac_link) 2>conftest.er1
10304
  ac_status=$?
10305
  grep -v '^ *+' conftest.er1 >conftest.err
10306
  rm -f conftest.er1
10307
  cat conftest.err >&5
10308
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10309
  (exit $ac_status); } &&
10310
         { ac_try='test -z "$ac_c_werror_flag"
10311
                         || test ! -s conftest.err'
10312
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10313
  (eval $ac_try) 2>&5
10314
  ac_status=$?
10315
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10316
  (exit $ac_status); }; } &&
10317
         { ac_try='test -s conftest$ac_exeext'
10318
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10319
  (eval $ac_try) 2>&5
10320
  ac_status=$?
10321
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10322
  (exit $ac_status); }; }; then
10323
  eval "$as_ac_var=yes"
10324
else
10325
  echo "$as_me: failed program was:" >&5
10326
sed 's/^/| /' conftest.$ac_ext >&5
10327
 
10328
eval "$as_ac_var=no"
10329
fi
10330
rm -f conftest.err conftest.$ac_objext \
10331
      conftest$ac_exeext conftest.$ac_ext
10332
fi
10333
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10334
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10335
if test `eval echo '${'$as_ac_var'}'` = yes; then
10336
  cat >>confdefs.h <<_ACEOF
10337
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10338
_ACEOF
10339
 
10340
fi
10341
done
10342
 
10343
 
10344
 
10345
 
10346
 
10347
 
10348
 
10349
for ac_func in sleep time ttyname signal alarm ctime
10350
do
10351
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10352
echo "$as_me:$LINENO: checking for $ac_func" >&5
10353
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10354
if eval "test \"\${$as_ac_var+set}\" = set"; then
10355
  echo $ECHO_N "(cached) $ECHO_C" >&6
10356
else
10357
  if test x$gcc_no_link = xyes; then
10358
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10359
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10360
   { (exit 1); exit 1; }; }
10361
fi
10362
cat >conftest.$ac_ext <<_ACEOF
10363
/* confdefs.h.  */
10364
_ACEOF
10365
cat confdefs.h >>conftest.$ac_ext
10366
cat >>conftest.$ac_ext <<_ACEOF
10367
/* end confdefs.h.  */
10368
/* Define $ac_func to an innocuous variant, in case  declares $ac_func.
10369
   For example, HP-UX 11i  declares gettimeofday.  */
10370
#define $ac_func innocuous_$ac_func
10371
 
10372
/* System header to define __stub macros and hopefully few prototypes,
10373
    which can conflict with char $ac_func (); below.
10374
    Prefer  to  if __STDC__ is defined, since
10375
     exists even on freestanding compilers.  */
10376
 
10377
#ifdef __STDC__
10378
# include 
10379
#else
10380
# include 
10381
#endif
10382
 
10383
#undef $ac_func
10384
 
10385
/* Override any gcc2 internal prototype to avoid an error.  */
10386
#ifdef __cplusplus
10387
extern "C"
10388
{
10389
#endif
10390
/* We use char because int might match the return type of a gcc2
10391
   builtin and then its argument prototype would still apply.  */
10392
char $ac_func ();
10393
/* The GNU C library defines this for functions which it implements
10394
    to always fail with ENOSYS.  Some functions are actually named
10395
    something starting with __ and the normal name is an alias.  */
10396
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10397
choke me
10398
#else
10399
char (*f) () = $ac_func;
10400
#endif
10401
#ifdef __cplusplus
10402
}
10403
#endif
10404
 
10405
int
10406
main ()
10407
{
10408
return f != $ac_func;
10409
  ;
10410
  return 0;
10411
}
10412
_ACEOF
10413
rm -f conftest.$ac_objext conftest$ac_exeext
10414
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10415
  (eval $ac_link) 2>conftest.er1
10416
  ac_status=$?
10417
  grep -v '^ *+' conftest.er1 >conftest.err
10418
  rm -f conftest.er1
10419
  cat conftest.err >&5
10420
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10421
  (exit $ac_status); } &&
10422
         { ac_try='test -z "$ac_c_werror_flag"
10423
                         || test ! -s conftest.err'
10424
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10425
  (eval $ac_try) 2>&5
10426
  ac_status=$?
10427
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10428
  (exit $ac_status); }; } &&
10429
         { ac_try='test -s conftest$ac_exeext'
10430
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10431
  (eval $ac_try) 2>&5
10432
  ac_status=$?
10433
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10434
  (exit $ac_status); }; }; then
10435
  eval "$as_ac_var=yes"
10436
else
10437
  echo "$as_me: failed program was:" >&5
10438
sed 's/^/| /' conftest.$ac_ext >&5
10439
 
10440
eval "$as_ac_var=no"
10441
fi
10442
rm -f conftest.err conftest.$ac_objext \
10443
      conftest$ac_exeext conftest.$ac_ext
10444
fi
10445
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10446
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10447
if test `eval echo '${'$as_ac_var'}'` = yes; then
10448
  cat >>confdefs.h <<_ACEOF
10449
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10450
_ACEOF
10451
 
10452
fi
10453
done
10454
 
10455
 
10456
# Check libc for getgid, getpid, getuid
10457
echo "$as_me:$LINENO: checking for getgid in -lc" >&5
10458
echo $ECHO_N "checking for getgid in -lc... $ECHO_C" >&6
10459
if test "${ac_cv_lib_c_getgid+set}" = set; then
10460
  echo $ECHO_N "(cached) $ECHO_C" >&6
10461
else
10462
  ac_check_lib_save_LIBS=$LIBS
10463
LIBS="-lc  $LIBS"
10464
if test x$gcc_no_link = xyes; then
10465
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10466
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10467
   { (exit 1); exit 1; }; }
10468
fi
10469
cat >conftest.$ac_ext <<_ACEOF
10470
/* confdefs.h.  */
10471
_ACEOF
10472
cat confdefs.h >>conftest.$ac_ext
10473
cat >>conftest.$ac_ext <<_ACEOF
10474
/* end confdefs.h.  */
10475
 
10476
/* Override any gcc2 internal prototype to avoid an error.  */
10477
#ifdef __cplusplus
10478
extern "C"
10479
#endif
10480
/* We use char because int might match the return type of a gcc2
10481
   builtin and then its argument prototype would still apply.  */
10482
char getgid ();
10483
int
10484
main ()
10485
{
10486
getgid ();
10487
  ;
10488
  return 0;
10489
}
10490
_ACEOF
10491
rm -f conftest.$ac_objext conftest$ac_exeext
10492
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10493
  (eval $ac_link) 2>conftest.er1
10494
  ac_status=$?
10495
  grep -v '^ *+' conftest.er1 >conftest.err
10496
  rm -f conftest.er1
10497
  cat conftest.err >&5
10498
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10499
  (exit $ac_status); } &&
10500
         { ac_try='test -z "$ac_c_werror_flag"
10501
                         || test ! -s conftest.err'
10502
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10503
  (eval $ac_try) 2>&5
10504
  ac_status=$?
10505
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10506
  (exit $ac_status); }; } &&
10507
         { ac_try='test -s conftest$ac_exeext'
10508
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10509
  (eval $ac_try) 2>&5
10510
  ac_status=$?
10511
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10512
  (exit $ac_status); }; }; then
10513
  ac_cv_lib_c_getgid=yes
10514
else
10515
  echo "$as_me: failed program was:" >&5
10516
sed 's/^/| /' conftest.$ac_ext >&5
10517
 
10518
ac_cv_lib_c_getgid=no
10519
fi
10520
rm -f conftest.err conftest.$ac_objext \
10521
      conftest$ac_exeext conftest.$ac_ext
10522
LIBS=$ac_check_lib_save_LIBS
10523
fi
10524
echo "$as_me:$LINENO: result: $ac_cv_lib_c_getgid" >&5
10525
echo "${ECHO_T}$ac_cv_lib_c_getgid" >&6
10526
if test $ac_cv_lib_c_getgid = yes; then
10527
 
10528
cat >>confdefs.h <<\_ACEOF
10529
#define HAVE_GETGID 1
10530
_ACEOF
10531
 
10532
fi
10533
 
10534
echo "$as_me:$LINENO: checking for getpid in -lc" >&5
10535
echo $ECHO_N "checking for getpid in -lc... $ECHO_C" >&6
10536
if test "${ac_cv_lib_c_getpid+set}" = set; then
10537
  echo $ECHO_N "(cached) $ECHO_C" >&6
10538
else
10539
  ac_check_lib_save_LIBS=$LIBS
10540
LIBS="-lc  $LIBS"
10541
if test x$gcc_no_link = xyes; then
10542
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10543
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10544
   { (exit 1); exit 1; }; }
10545
fi
10546
cat >conftest.$ac_ext <<_ACEOF
10547
/* confdefs.h.  */
10548
_ACEOF
10549
cat confdefs.h >>conftest.$ac_ext
10550
cat >>conftest.$ac_ext <<_ACEOF
10551
/* end confdefs.h.  */
10552
 
10553
/* Override any gcc2 internal prototype to avoid an error.  */
10554
#ifdef __cplusplus
10555
extern "C"
10556
#endif
10557
/* We use char because int might match the return type of a gcc2
10558
   builtin and then its argument prototype would still apply.  */
10559
char getpid ();
10560
int
10561
main ()
10562
{
10563
getpid ();
10564
  ;
10565
  return 0;
10566
}
10567
_ACEOF
10568
rm -f conftest.$ac_objext conftest$ac_exeext
10569
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10570
  (eval $ac_link) 2>conftest.er1
10571
  ac_status=$?
10572
  grep -v '^ *+' conftest.er1 >conftest.err
10573
  rm -f conftest.er1
10574
  cat conftest.err >&5
10575
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10576
  (exit $ac_status); } &&
10577
         { ac_try='test -z "$ac_c_werror_flag"
10578
                         || test ! -s conftest.err'
10579
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10580
  (eval $ac_try) 2>&5
10581
  ac_status=$?
10582
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10583
  (exit $ac_status); }; } &&
10584
         { ac_try='test -s conftest$ac_exeext'
10585
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10586
  (eval $ac_try) 2>&5
10587
  ac_status=$?
10588
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10589
  (exit $ac_status); }; }; then
10590
  ac_cv_lib_c_getpid=yes
10591
else
10592
  echo "$as_me: failed program was:" >&5
10593
sed 's/^/| /' conftest.$ac_ext >&5
10594
 
10595
ac_cv_lib_c_getpid=no
10596
fi
10597
rm -f conftest.err conftest.$ac_objext \
10598
      conftest$ac_exeext conftest.$ac_ext
10599
LIBS=$ac_check_lib_save_LIBS
10600
fi
10601
echo "$as_me:$LINENO: result: $ac_cv_lib_c_getpid" >&5
10602
echo "${ECHO_T}$ac_cv_lib_c_getpid" >&6
10603
if test $ac_cv_lib_c_getpid = yes; then
10604
 
10605
cat >>confdefs.h <<\_ACEOF
10606
#define HAVE_GETPID 1
10607
_ACEOF
10608
 
10609
fi
10610
 
10611
echo "$as_me:$LINENO: checking for getuid in -lc" >&5
10612
echo $ECHO_N "checking for getuid in -lc... $ECHO_C" >&6
10613
if test "${ac_cv_lib_c_getuid+set}" = set; then
10614
  echo $ECHO_N "(cached) $ECHO_C" >&6
10615
else
10616
  ac_check_lib_save_LIBS=$LIBS
10617
LIBS="-lc  $LIBS"
10618
if test x$gcc_no_link = xyes; then
10619
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10620
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10621
   { (exit 1); exit 1; }; }
10622
fi
10623
cat >conftest.$ac_ext <<_ACEOF
10624
/* confdefs.h.  */
10625
_ACEOF
10626
cat confdefs.h >>conftest.$ac_ext
10627
cat >>conftest.$ac_ext <<_ACEOF
10628
/* end confdefs.h.  */
10629
 
10630
/* Override any gcc2 internal prototype to avoid an error.  */
10631
#ifdef __cplusplus
10632
extern "C"
10633
#endif
10634
/* We use char because int might match the return type of a gcc2
10635
   builtin and then its argument prototype would still apply.  */
10636
char getuid ();
10637
int
10638
main ()
10639
{
10640
getuid ();
10641
  ;
10642
  return 0;
10643
}
10644
_ACEOF
10645
rm -f conftest.$ac_objext conftest$ac_exeext
10646
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10647
  (eval $ac_link) 2>conftest.er1
10648
  ac_status=$?
10649
  grep -v '^ *+' conftest.er1 >conftest.err
10650
  rm -f conftest.er1
10651
  cat conftest.err >&5
10652
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10653
  (exit $ac_status); } &&
10654
         { ac_try='test -z "$ac_c_werror_flag"
10655
                         || test ! -s conftest.err'
10656
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10657
  (eval $ac_try) 2>&5
10658
  ac_status=$?
10659
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10660
  (exit $ac_status); }; } &&
10661
         { ac_try='test -s conftest$ac_exeext'
10662
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10663
  (eval $ac_try) 2>&5
10664
  ac_status=$?
10665
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10666
  (exit $ac_status); }; }; then
10667
  ac_cv_lib_c_getuid=yes
10668
else
10669
  echo "$as_me: failed program was:" >&5
10670
sed 's/^/| /' conftest.$ac_ext >&5
10671
 
10672
ac_cv_lib_c_getuid=no
10673
fi
10674
rm -f conftest.err conftest.$ac_objext \
10675
      conftest$ac_exeext conftest.$ac_ext
10676
LIBS=$ac_check_lib_save_LIBS
10677
fi
10678
echo "$as_me:$LINENO: result: $ac_cv_lib_c_getuid" >&5
10679
echo "${ECHO_T}$ac_cv_lib_c_getuid" >&6
10680
if test $ac_cv_lib_c_getuid = yes; then
10681
 
10682
cat >>confdefs.h <<\_ACEOF
10683
#define HAVE_GETUID 1
10684
_ACEOF
10685
 
10686
fi
10687
 
10688
 
10689
# Check for C99 (and other IEEE) math functions
10690
# ??? This list seems awful long. Is there a better way to test for these?
10691
echo "$as_me:$LINENO: checking for acosf in -lm" >&5
10692
echo $ECHO_N "checking for acosf in -lm... $ECHO_C" >&6
10693
if test "${ac_cv_lib_m_acosf+set}" = set; then
10694
  echo $ECHO_N "(cached) $ECHO_C" >&6
10695
else
10696
  ac_check_lib_save_LIBS=$LIBS
10697
LIBS="-lm  $LIBS"
10698
if test x$gcc_no_link = xyes; then
10699
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10700
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10701
   { (exit 1); exit 1; }; }
10702
fi
10703
cat >conftest.$ac_ext <<_ACEOF
10704
/* confdefs.h.  */
10705
_ACEOF
10706
cat confdefs.h >>conftest.$ac_ext
10707
cat >>conftest.$ac_ext <<_ACEOF
10708
/* end confdefs.h.  */
10709
 
10710
/* Override any gcc2 internal prototype to avoid an error.  */
10711
#ifdef __cplusplus
10712
extern "C"
10713
#endif
10714
/* We use char because int might match the return type of a gcc2
10715
   builtin and then its argument prototype would still apply.  */
10716
char acosf ();
10717
int
10718
main ()
10719
{
10720
acosf ();
10721
  ;
10722
  return 0;
10723
}
10724
_ACEOF
10725
rm -f conftest.$ac_objext conftest$ac_exeext
10726
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10727
  (eval $ac_link) 2>conftest.er1
10728
  ac_status=$?
10729
  grep -v '^ *+' conftest.er1 >conftest.err
10730
  rm -f conftest.er1
10731
  cat conftest.err >&5
10732
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10733
  (exit $ac_status); } &&
10734
         { ac_try='test -z "$ac_c_werror_flag"
10735
                         || test ! -s conftest.err'
10736
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10737
  (eval $ac_try) 2>&5
10738
  ac_status=$?
10739
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10740
  (exit $ac_status); }; } &&
10741
         { ac_try='test -s conftest$ac_exeext'
10742
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10743
  (eval $ac_try) 2>&5
10744
  ac_status=$?
10745
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10746
  (exit $ac_status); }; }; then
10747
  ac_cv_lib_m_acosf=yes
10748
else
10749
  echo "$as_me: failed program was:" >&5
10750
sed 's/^/| /' conftest.$ac_ext >&5
10751
 
10752
ac_cv_lib_m_acosf=no
10753
fi
10754
rm -f conftest.err conftest.$ac_objext \
10755
      conftest$ac_exeext conftest.$ac_ext
10756
LIBS=$ac_check_lib_save_LIBS
10757
fi
10758
echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosf" >&5
10759
echo "${ECHO_T}$ac_cv_lib_m_acosf" >&6
10760
if test $ac_cv_lib_m_acosf = yes; then
10761
 
10762
cat >>confdefs.h <<\_ACEOF
10763
#define HAVE_ACOSF 1
10764
_ACEOF
10765
 
10766
fi
10767
 
10768
echo "$as_me:$LINENO: checking for acos in -lm" >&5
10769
echo $ECHO_N "checking for acos in -lm... $ECHO_C" >&6
10770
if test "${ac_cv_lib_m_acos+set}" = set; then
10771
  echo $ECHO_N "(cached) $ECHO_C" >&6
10772
else
10773
  ac_check_lib_save_LIBS=$LIBS
10774
LIBS="-lm  $LIBS"
10775
if test x$gcc_no_link = xyes; then
10776
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10777
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10778
   { (exit 1); exit 1; }; }
10779
fi
10780
cat >conftest.$ac_ext <<_ACEOF
10781
/* confdefs.h.  */
10782
_ACEOF
10783
cat confdefs.h >>conftest.$ac_ext
10784
cat >>conftest.$ac_ext <<_ACEOF
10785
/* end confdefs.h.  */
10786
 
10787
/* Override any gcc2 internal prototype to avoid an error.  */
10788
#ifdef __cplusplus
10789
extern "C"
10790
#endif
10791
/* We use char because int might match the return type of a gcc2
10792
   builtin and then its argument prototype would still apply.  */
10793
char acos ();
10794
int
10795
main ()
10796
{
10797
acos ();
10798
  ;
10799
  return 0;
10800
}
10801
_ACEOF
10802
rm -f conftest.$ac_objext conftest$ac_exeext
10803
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10804
  (eval $ac_link) 2>conftest.er1
10805
  ac_status=$?
10806
  grep -v '^ *+' conftest.er1 >conftest.err
10807
  rm -f conftest.er1
10808
  cat conftest.err >&5
10809
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10810
  (exit $ac_status); } &&
10811
         { ac_try='test -z "$ac_c_werror_flag"
10812
                         || test ! -s conftest.err'
10813
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10814
  (eval $ac_try) 2>&5
10815
  ac_status=$?
10816
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10817
  (exit $ac_status); }; } &&
10818
         { ac_try='test -s conftest$ac_exeext'
10819
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10820
  (eval $ac_try) 2>&5
10821
  ac_status=$?
10822
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10823
  (exit $ac_status); }; }; then
10824
  ac_cv_lib_m_acos=yes
10825
else
10826
  echo "$as_me: failed program was:" >&5
10827
sed 's/^/| /' conftest.$ac_ext >&5
10828
 
10829
ac_cv_lib_m_acos=no
10830
fi
10831
rm -f conftest.err conftest.$ac_objext \
10832
      conftest$ac_exeext conftest.$ac_ext
10833
LIBS=$ac_check_lib_save_LIBS
10834
fi
10835
echo "$as_me:$LINENO: result: $ac_cv_lib_m_acos" >&5
10836
echo "${ECHO_T}$ac_cv_lib_m_acos" >&6
10837
if test $ac_cv_lib_m_acos = yes; then
10838
 
10839
cat >>confdefs.h <<\_ACEOF
10840
#define HAVE_ACOS 1
10841
_ACEOF
10842
 
10843
fi
10844
 
10845
echo "$as_me:$LINENO: checking for acosl in -lm" >&5
10846
echo $ECHO_N "checking for acosl in -lm... $ECHO_C" >&6
10847
if test "${ac_cv_lib_m_acosl+set}" = set; then
10848
  echo $ECHO_N "(cached) $ECHO_C" >&6
10849
else
10850
  ac_check_lib_save_LIBS=$LIBS
10851
LIBS="-lm  $LIBS"
10852
if test x$gcc_no_link = xyes; then
10853
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10854
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10855
   { (exit 1); exit 1; }; }
10856
fi
10857
cat >conftest.$ac_ext <<_ACEOF
10858
/* confdefs.h.  */
10859
_ACEOF
10860
cat confdefs.h >>conftest.$ac_ext
10861
cat >>conftest.$ac_ext <<_ACEOF
10862
/* end confdefs.h.  */
10863
 
10864
/* Override any gcc2 internal prototype to avoid an error.  */
10865
#ifdef __cplusplus
10866
extern "C"
10867
#endif
10868
/* We use char because int might match the return type of a gcc2
10869
   builtin and then its argument prototype would still apply.  */
10870
char acosl ();
10871
int
10872
main ()
10873
{
10874
acosl ();
10875
  ;
10876
  return 0;
10877
}
10878
_ACEOF
10879
rm -f conftest.$ac_objext conftest$ac_exeext
10880
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10881
  (eval $ac_link) 2>conftest.er1
10882
  ac_status=$?
10883
  grep -v '^ *+' conftest.er1 >conftest.err
10884
  rm -f conftest.er1
10885
  cat conftest.err >&5
10886
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10887
  (exit $ac_status); } &&
10888
         { ac_try='test -z "$ac_c_werror_flag"
10889
                         || test ! -s conftest.err'
10890
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10891
  (eval $ac_try) 2>&5
10892
  ac_status=$?
10893
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10894
  (exit $ac_status); }; } &&
10895
         { ac_try='test -s conftest$ac_exeext'
10896
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10897
  (eval $ac_try) 2>&5
10898
  ac_status=$?
10899
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10900
  (exit $ac_status); }; }; then
10901
  ac_cv_lib_m_acosl=yes
10902
else
10903
  echo "$as_me: failed program was:" >&5
10904
sed 's/^/| /' conftest.$ac_ext >&5
10905
 
10906
ac_cv_lib_m_acosl=no
10907
fi
10908
rm -f conftest.err conftest.$ac_objext \
10909
      conftest$ac_exeext conftest.$ac_ext
10910
LIBS=$ac_check_lib_save_LIBS
10911
fi
10912
echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosl" >&5
10913
echo "${ECHO_T}$ac_cv_lib_m_acosl" >&6
10914
if test $ac_cv_lib_m_acosl = yes; then
10915
 
10916
cat >>confdefs.h <<\_ACEOF
10917
#define HAVE_ACOSL 1
10918
_ACEOF
10919
 
10920
fi
10921
 
10922
echo "$as_me:$LINENO: checking for acoshf in -lm" >&5
10923
echo $ECHO_N "checking for acoshf in -lm... $ECHO_C" >&6
10924
if test "${ac_cv_lib_m_acoshf+set}" = set; then
10925
  echo $ECHO_N "(cached) $ECHO_C" >&6
10926
else
10927
  ac_check_lib_save_LIBS=$LIBS
10928
LIBS="-lm  $LIBS"
10929
if test x$gcc_no_link = xyes; then
10930
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10931
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10932
   { (exit 1); exit 1; }; }
10933
fi
10934
cat >conftest.$ac_ext <<_ACEOF
10935
/* confdefs.h.  */
10936
_ACEOF
10937
cat confdefs.h >>conftest.$ac_ext
10938
cat >>conftest.$ac_ext <<_ACEOF
10939
/* end confdefs.h.  */
10940
 
10941
/* Override any gcc2 internal prototype to avoid an error.  */
10942
#ifdef __cplusplus
10943
extern "C"
10944
#endif
10945
/* We use char because int might match the return type of a gcc2
10946
   builtin and then its argument prototype would still apply.  */
10947
char acoshf ();
10948
int
10949
main ()
10950
{
10951
acoshf ();
10952
  ;
10953
  return 0;
10954
}
10955
_ACEOF
10956
rm -f conftest.$ac_objext conftest$ac_exeext
10957
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10958
  (eval $ac_link) 2>conftest.er1
10959
  ac_status=$?
10960
  grep -v '^ *+' conftest.er1 >conftest.err
10961
  rm -f conftest.er1
10962
  cat conftest.err >&5
10963
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10964
  (exit $ac_status); } &&
10965
         { ac_try='test -z "$ac_c_werror_flag"
10966
                         || test ! -s conftest.err'
10967
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10968
  (eval $ac_try) 2>&5
10969
  ac_status=$?
10970
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10971
  (exit $ac_status); }; } &&
10972
         { ac_try='test -s conftest$ac_exeext'
10973
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10974
  (eval $ac_try) 2>&5
10975
  ac_status=$?
10976
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10977
  (exit $ac_status); }; }; then
10978
  ac_cv_lib_m_acoshf=yes
10979
else
10980
  echo "$as_me: failed program was:" >&5
10981
sed 's/^/| /' conftest.$ac_ext >&5
10982
 
10983
ac_cv_lib_m_acoshf=no
10984
fi
10985
rm -f conftest.err conftest.$ac_objext \
10986
      conftest$ac_exeext conftest.$ac_ext
10987
LIBS=$ac_check_lib_save_LIBS
10988
fi
10989
echo "$as_me:$LINENO: result: $ac_cv_lib_m_acoshf" >&5
10990
echo "${ECHO_T}$ac_cv_lib_m_acoshf" >&6
10991
if test $ac_cv_lib_m_acoshf = yes; then
10992
 
10993
cat >>confdefs.h <<\_ACEOF
10994
#define HAVE_ACOSHF 1
10995
_ACEOF
10996
 
10997
fi
10998
 
10999
echo "$as_me:$LINENO: checking for acosh in -lm" >&5
11000
echo $ECHO_N "checking for acosh in -lm... $ECHO_C" >&6
11001
if test "${ac_cv_lib_m_acosh+set}" = set; then
11002
  echo $ECHO_N "(cached) $ECHO_C" >&6
11003
else
11004
  ac_check_lib_save_LIBS=$LIBS
11005
LIBS="-lm  $LIBS"
11006
if test x$gcc_no_link = xyes; then
11007
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11008
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11009
   { (exit 1); exit 1; }; }
11010
fi
11011
cat >conftest.$ac_ext <<_ACEOF
11012
/* confdefs.h.  */
11013
_ACEOF
11014
cat confdefs.h >>conftest.$ac_ext
11015
cat >>conftest.$ac_ext <<_ACEOF
11016
/* end confdefs.h.  */
11017
 
11018
/* Override any gcc2 internal prototype to avoid an error.  */
11019
#ifdef __cplusplus
11020
extern "C"
11021
#endif
11022
/* We use char because int might match the return type of a gcc2
11023
   builtin and then its argument prototype would still apply.  */
11024
char acosh ();
11025
int
11026
main ()
11027
{
11028
acosh ();
11029
  ;
11030
  return 0;
11031
}
11032
_ACEOF
11033
rm -f conftest.$ac_objext conftest$ac_exeext
11034
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11035
  (eval $ac_link) 2>conftest.er1
11036
  ac_status=$?
11037
  grep -v '^ *+' conftest.er1 >conftest.err
11038
  rm -f conftest.er1
11039
  cat conftest.err >&5
11040
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11041
  (exit $ac_status); } &&
11042
         { ac_try='test -z "$ac_c_werror_flag"
11043
                         || test ! -s conftest.err'
11044
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11045
  (eval $ac_try) 2>&5
11046
  ac_status=$?
11047
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11048
  (exit $ac_status); }; } &&
11049
         { ac_try='test -s conftest$ac_exeext'
11050
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11051
  (eval $ac_try) 2>&5
11052
  ac_status=$?
11053
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11054
  (exit $ac_status); }; }; then
11055
  ac_cv_lib_m_acosh=yes
11056
else
11057
  echo "$as_me: failed program was:" >&5
11058
sed 's/^/| /' conftest.$ac_ext >&5
11059
 
11060
ac_cv_lib_m_acosh=no
11061
fi
11062
rm -f conftest.err conftest.$ac_objext \
11063
      conftest$ac_exeext conftest.$ac_ext
11064
LIBS=$ac_check_lib_save_LIBS
11065
fi
11066
echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosh" >&5
11067
echo "${ECHO_T}$ac_cv_lib_m_acosh" >&6
11068
if test $ac_cv_lib_m_acosh = yes; then
11069
 
11070
cat >>confdefs.h <<\_ACEOF
11071
#define HAVE_ACOSH 1
11072
_ACEOF
11073
 
11074
fi
11075
 
11076
echo "$as_me:$LINENO: checking for acoshl in -lm" >&5
11077
echo $ECHO_N "checking for acoshl in -lm... $ECHO_C" >&6
11078
if test "${ac_cv_lib_m_acoshl+set}" = set; then
11079
  echo $ECHO_N "(cached) $ECHO_C" >&6
11080
else
11081
  ac_check_lib_save_LIBS=$LIBS
11082
LIBS="-lm  $LIBS"
11083
if test x$gcc_no_link = xyes; then
11084
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11085
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11086
   { (exit 1); exit 1; }; }
11087
fi
11088
cat >conftest.$ac_ext <<_ACEOF
11089
/* confdefs.h.  */
11090
_ACEOF
11091
cat confdefs.h >>conftest.$ac_ext
11092
cat >>conftest.$ac_ext <<_ACEOF
11093
/* end confdefs.h.  */
11094
 
11095
/* Override any gcc2 internal prototype to avoid an error.  */
11096
#ifdef __cplusplus
11097
extern "C"
11098
#endif
11099
/* We use char because int might match the return type of a gcc2
11100
   builtin and then its argument prototype would still apply.  */
11101
char acoshl ();
11102
int
11103
main ()
11104
{
11105
acoshl ();
11106
  ;
11107
  return 0;
11108
}
11109
_ACEOF
11110
rm -f conftest.$ac_objext conftest$ac_exeext
11111
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11112
  (eval $ac_link) 2>conftest.er1
11113
  ac_status=$?
11114
  grep -v '^ *+' conftest.er1 >conftest.err
11115
  rm -f conftest.er1
11116
  cat conftest.err >&5
11117
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11118
  (exit $ac_status); } &&
11119
         { ac_try='test -z "$ac_c_werror_flag"
11120
                         || test ! -s conftest.err'
11121
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11122
  (eval $ac_try) 2>&5
11123
  ac_status=$?
11124
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11125
  (exit $ac_status); }; } &&
11126
         { ac_try='test -s conftest$ac_exeext'
11127
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11128
  (eval $ac_try) 2>&5
11129
  ac_status=$?
11130
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11131
  (exit $ac_status); }; }; then
11132
  ac_cv_lib_m_acoshl=yes
11133
else
11134
  echo "$as_me: failed program was:" >&5
11135
sed 's/^/| /' conftest.$ac_ext >&5
11136
 
11137
ac_cv_lib_m_acoshl=no
11138
fi
11139
rm -f conftest.err conftest.$ac_objext \
11140
      conftest$ac_exeext conftest.$ac_ext
11141
LIBS=$ac_check_lib_save_LIBS
11142
fi
11143
echo "$as_me:$LINENO: result: $ac_cv_lib_m_acoshl" >&5
11144
echo "${ECHO_T}$ac_cv_lib_m_acoshl" >&6
11145
if test $ac_cv_lib_m_acoshl = yes; then
11146
 
11147
cat >>confdefs.h <<\_ACEOF
11148
#define HAVE_ACOSHL 1
11149
_ACEOF
11150
 
11151
fi
11152
 
11153
echo "$as_me:$LINENO: checking for asinf in -lm" >&5
11154
echo $ECHO_N "checking for asinf in -lm... $ECHO_C" >&6
11155
if test "${ac_cv_lib_m_asinf+set}" = set; then
11156
  echo $ECHO_N "(cached) $ECHO_C" >&6
11157
else
11158
  ac_check_lib_save_LIBS=$LIBS
11159
LIBS="-lm  $LIBS"
11160
if test x$gcc_no_link = xyes; then
11161
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11162
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11163
   { (exit 1); exit 1; }; }
11164
fi
11165
cat >conftest.$ac_ext <<_ACEOF
11166
/* confdefs.h.  */
11167
_ACEOF
11168
cat confdefs.h >>conftest.$ac_ext
11169
cat >>conftest.$ac_ext <<_ACEOF
11170
/* end confdefs.h.  */
11171
 
11172
/* Override any gcc2 internal prototype to avoid an error.  */
11173
#ifdef __cplusplus
11174
extern "C"
11175
#endif
11176
/* We use char because int might match the return type of a gcc2
11177
   builtin and then its argument prototype would still apply.  */
11178
char asinf ();
11179
int
11180
main ()
11181
{
11182
asinf ();
11183
  ;
11184
  return 0;
11185
}
11186
_ACEOF
11187
rm -f conftest.$ac_objext conftest$ac_exeext
11188
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11189
  (eval $ac_link) 2>conftest.er1
11190
  ac_status=$?
11191
  grep -v '^ *+' conftest.er1 >conftest.err
11192
  rm -f conftest.er1
11193
  cat conftest.err >&5
11194
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11195
  (exit $ac_status); } &&
11196
         { ac_try='test -z "$ac_c_werror_flag"
11197
                         || test ! -s conftest.err'
11198
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11199
  (eval $ac_try) 2>&5
11200
  ac_status=$?
11201
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11202
  (exit $ac_status); }; } &&
11203
         { ac_try='test -s conftest$ac_exeext'
11204
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11205
  (eval $ac_try) 2>&5
11206
  ac_status=$?
11207
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11208
  (exit $ac_status); }; }; then
11209
  ac_cv_lib_m_asinf=yes
11210
else
11211
  echo "$as_me: failed program was:" >&5
11212
sed 's/^/| /' conftest.$ac_ext >&5
11213
 
11214
ac_cv_lib_m_asinf=no
11215
fi
11216
rm -f conftest.err conftest.$ac_objext \
11217
      conftest$ac_exeext conftest.$ac_ext
11218
LIBS=$ac_check_lib_save_LIBS
11219
fi
11220
echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinf" >&5
11221
echo "${ECHO_T}$ac_cv_lib_m_asinf" >&6
11222
if test $ac_cv_lib_m_asinf = yes; then
11223
 
11224
cat >>confdefs.h <<\_ACEOF
11225
#define HAVE_ASINF 1
11226
_ACEOF
11227
 
11228
fi
11229
 
11230
echo "$as_me:$LINENO: checking for asin in -lm" >&5
11231
echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
11232
if test "${ac_cv_lib_m_asin+set}" = set; then
11233
  echo $ECHO_N "(cached) $ECHO_C" >&6
11234
else
11235
  ac_check_lib_save_LIBS=$LIBS
11236
LIBS="-lm  $LIBS"
11237
if test x$gcc_no_link = xyes; then
11238
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11239
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11240
   { (exit 1); exit 1; }; }
11241
fi
11242
cat >conftest.$ac_ext <<_ACEOF
11243
/* confdefs.h.  */
11244
_ACEOF
11245
cat confdefs.h >>conftest.$ac_ext
11246
cat >>conftest.$ac_ext <<_ACEOF
11247
/* end confdefs.h.  */
11248
 
11249
/* Override any gcc2 internal prototype to avoid an error.  */
11250
#ifdef __cplusplus
11251
extern "C"
11252
#endif
11253
/* We use char because int might match the return type of a gcc2
11254
   builtin and then its argument prototype would still apply.  */
11255
char asin ();
11256
int
11257
main ()
11258
{
11259
asin ();
11260
  ;
11261
  return 0;
11262
}
11263
_ACEOF
11264
rm -f conftest.$ac_objext conftest$ac_exeext
11265
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11266
  (eval $ac_link) 2>conftest.er1
11267
  ac_status=$?
11268
  grep -v '^ *+' conftest.er1 >conftest.err
11269
  rm -f conftest.er1
11270
  cat conftest.err >&5
11271
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11272
  (exit $ac_status); } &&
11273
         { ac_try='test -z "$ac_c_werror_flag"
11274
                         || test ! -s conftest.err'
11275
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11276
  (eval $ac_try) 2>&5
11277
  ac_status=$?
11278
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11279
  (exit $ac_status); }; } &&
11280
         { ac_try='test -s conftest$ac_exeext'
11281
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11282
  (eval $ac_try) 2>&5
11283
  ac_status=$?
11284
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11285
  (exit $ac_status); }; }; then
11286
  ac_cv_lib_m_asin=yes
11287
else
11288
  echo "$as_me: failed program was:" >&5
11289
sed 's/^/| /' conftest.$ac_ext >&5
11290
 
11291
ac_cv_lib_m_asin=no
11292
fi
11293
rm -f conftest.err conftest.$ac_objext \
11294
      conftest$ac_exeext conftest.$ac_ext
11295
LIBS=$ac_check_lib_save_LIBS
11296
fi
11297
echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
11298
echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
11299
if test $ac_cv_lib_m_asin = yes; then
11300
 
11301
cat >>confdefs.h <<\_ACEOF
11302
#define HAVE_ASIN 1
11303
_ACEOF
11304
 
11305
fi
11306
 
11307
echo "$as_me:$LINENO: checking for asinl in -lm" >&5
11308
echo $ECHO_N "checking for asinl in -lm... $ECHO_C" >&6
11309
if test "${ac_cv_lib_m_asinl+set}" = set; then
11310
  echo $ECHO_N "(cached) $ECHO_C" >&6
11311
else
11312
  ac_check_lib_save_LIBS=$LIBS
11313
LIBS="-lm  $LIBS"
11314
if test x$gcc_no_link = xyes; then
11315
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11316
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11317
   { (exit 1); exit 1; }; }
11318
fi
11319
cat >conftest.$ac_ext <<_ACEOF
11320
/* confdefs.h.  */
11321
_ACEOF
11322
cat confdefs.h >>conftest.$ac_ext
11323
cat >>conftest.$ac_ext <<_ACEOF
11324
/* end confdefs.h.  */
11325
 
11326
/* Override any gcc2 internal prototype to avoid an error.  */
11327
#ifdef __cplusplus
11328
extern "C"
11329
#endif
11330
/* We use char because int might match the return type of a gcc2
11331
   builtin and then its argument prototype would still apply.  */
11332
char asinl ();
11333
int
11334
main ()
11335
{
11336
asinl ();
11337
  ;
11338
  return 0;
11339
}
11340
_ACEOF
11341
rm -f conftest.$ac_objext conftest$ac_exeext
11342
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11343
  (eval $ac_link) 2>conftest.er1
11344
  ac_status=$?
11345
  grep -v '^ *+' conftest.er1 >conftest.err
11346
  rm -f conftest.er1
11347
  cat conftest.err >&5
11348
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11349
  (exit $ac_status); } &&
11350
         { ac_try='test -z "$ac_c_werror_flag"
11351
                         || test ! -s conftest.err'
11352
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11353
  (eval $ac_try) 2>&5
11354
  ac_status=$?
11355
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11356
  (exit $ac_status); }; } &&
11357
         { ac_try='test -s conftest$ac_exeext'
11358
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11359
  (eval $ac_try) 2>&5
11360
  ac_status=$?
11361
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11362
  (exit $ac_status); }; }; then
11363
  ac_cv_lib_m_asinl=yes
11364
else
11365
  echo "$as_me: failed program was:" >&5
11366
sed 's/^/| /' conftest.$ac_ext >&5
11367
 
11368
ac_cv_lib_m_asinl=no
11369
fi
11370
rm -f conftest.err conftest.$ac_objext \
11371
      conftest$ac_exeext conftest.$ac_ext
11372
LIBS=$ac_check_lib_save_LIBS
11373
fi
11374
echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinl" >&5
11375
echo "${ECHO_T}$ac_cv_lib_m_asinl" >&6
11376
if test $ac_cv_lib_m_asinl = yes; then
11377
 
11378
cat >>confdefs.h <<\_ACEOF
11379
#define HAVE_ASINL 1
11380
_ACEOF
11381
 
11382
fi
11383
 
11384
echo "$as_me:$LINENO: checking for asinhf in -lm" >&5
11385
echo $ECHO_N "checking for asinhf in -lm... $ECHO_C" >&6
11386
if test "${ac_cv_lib_m_asinhf+set}" = set; then
11387
  echo $ECHO_N "(cached) $ECHO_C" >&6
11388
else
11389
  ac_check_lib_save_LIBS=$LIBS
11390
LIBS="-lm  $LIBS"
11391
if test x$gcc_no_link = xyes; then
11392
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11393
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11394
   { (exit 1); exit 1; }; }
11395
fi
11396
cat >conftest.$ac_ext <<_ACEOF
11397
/* confdefs.h.  */
11398
_ACEOF
11399
cat confdefs.h >>conftest.$ac_ext
11400
cat >>conftest.$ac_ext <<_ACEOF
11401
/* end confdefs.h.  */
11402
 
11403
/* Override any gcc2 internal prototype to avoid an error.  */
11404
#ifdef __cplusplus
11405
extern "C"
11406
#endif
11407
/* We use char because int might match the return type of a gcc2
11408
   builtin and then its argument prototype would still apply.  */
11409
char asinhf ();
11410
int
11411
main ()
11412
{
11413
asinhf ();
11414
  ;
11415
  return 0;
11416
}
11417
_ACEOF
11418
rm -f conftest.$ac_objext conftest$ac_exeext
11419
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11420
  (eval $ac_link) 2>conftest.er1
11421
  ac_status=$?
11422
  grep -v '^ *+' conftest.er1 >conftest.err
11423
  rm -f conftest.er1
11424
  cat conftest.err >&5
11425
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11426
  (exit $ac_status); } &&
11427
         { ac_try='test -z "$ac_c_werror_flag"
11428
                         || test ! -s conftest.err'
11429
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11430
  (eval $ac_try) 2>&5
11431
  ac_status=$?
11432
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11433
  (exit $ac_status); }; } &&
11434
         { ac_try='test -s conftest$ac_exeext'
11435
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11436
  (eval $ac_try) 2>&5
11437
  ac_status=$?
11438
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11439
  (exit $ac_status); }; }; then
11440
  ac_cv_lib_m_asinhf=yes
11441
else
11442
  echo "$as_me: failed program was:" >&5
11443
sed 's/^/| /' conftest.$ac_ext >&5
11444
 
11445
ac_cv_lib_m_asinhf=no
11446
fi
11447
rm -f conftest.err conftest.$ac_objext \
11448
      conftest$ac_exeext conftest.$ac_ext
11449
LIBS=$ac_check_lib_save_LIBS
11450
fi
11451
echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinhf" >&5
11452
echo "${ECHO_T}$ac_cv_lib_m_asinhf" >&6
11453
if test $ac_cv_lib_m_asinhf = yes; then
11454
 
11455
cat >>confdefs.h <<\_ACEOF
11456
#define HAVE_ASINHF 1
11457
_ACEOF
11458
 
11459
fi
11460
 
11461
echo "$as_me:$LINENO: checking for asinh in -lm" >&5
11462
echo $ECHO_N "checking for asinh in -lm... $ECHO_C" >&6
11463
if test "${ac_cv_lib_m_asinh+set}" = set; then
11464
  echo $ECHO_N "(cached) $ECHO_C" >&6
11465
else
11466
  ac_check_lib_save_LIBS=$LIBS
11467
LIBS="-lm  $LIBS"
11468
if test x$gcc_no_link = xyes; then
11469
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11470
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11471
   { (exit 1); exit 1; }; }
11472
fi
11473
cat >conftest.$ac_ext <<_ACEOF
11474
/* confdefs.h.  */
11475
_ACEOF
11476
cat confdefs.h >>conftest.$ac_ext
11477
cat >>conftest.$ac_ext <<_ACEOF
11478
/* end confdefs.h.  */
11479
 
11480
/* Override any gcc2 internal prototype to avoid an error.  */
11481
#ifdef __cplusplus
11482
extern "C"
11483
#endif
11484
/* We use char because int might match the return type of a gcc2
11485
   builtin and then its argument prototype would still apply.  */
11486
char asinh ();
11487
int
11488
main ()
11489
{
11490
asinh ();
11491
  ;
11492
  return 0;
11493
}
11494
_ACEOF
11495
rm -f conftest.$ac_objext conftest$ac_exeext
11496
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11497
  (eval $ac_link) 2>conftest.er1
11498
  ac_status=$?
11499
  grep -v '^ *+' conftest.er1 >conftest.err
11500
  rm -f conftest.er1
11501
  cat conftest.err >&5
11502
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11503
  (exit $ac_status); } &&
11504
         { ac_try='test -z "$ac_c_werror_flag"
11505
                         || test ! -s conftest.err'
11506
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11507
  (eval $ac_try) 2>&5
11508
  ac_status=$?
11509
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11510
  (exit $ac_status); }; } &&
11511
         { ac_try='test -s conftest$ac_exeext'
11512
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11513
  (eval $ac_try) 2>&5
11514
  ac_status=$?
11515
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11516
  (exit $ac_status); }; }; then
11517
  ac_cv_lib_m_asinh=yes
11518
else
11519
  echo "$as_me: failed program was:" >&5
11520
sed 's/^/| /' conftest.$ac_ext >&5
11521
 
11522
ac_cv_lib_m_asinh=no
11523
fi
11524
rm -f conftest.err conftest.$ac_objext \
11525
      conftest$ac_exeext conftest.$ac_ext
11526
LIBS=$ac_check_lib_save_LIBS
11527
fi
11528
echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinh" >&5
11529
echo "${ECHO_T}$ac_cv_lib_m_asinh" >&6
11530
if test $ac_cv_lib_m_asinh = yes; then
11531
 
11532
cat >>confdefs.h <<\_ACEOF
11533
#define HAVE_ASINH 1
11534
_ACEOF
11535
 
11536
fi
11537
 
11538
echo "$as_me:$LINENO: checking for asinhl in -lm" >&5
11539
echo $ECHO_N "checking for asinhl in -lm... $ECHO_C" >&6
11540
if test "${ac_cv_lib_m_asinhl+set}" = set; then
11541
  echo $ECHO_N "(cached) $ECHO_C" >&6
11542
else
11543
  ac_check_lib_save_LIBS=$LIBS
11544
LIBS="-lm  $LIBS"
11545
if test x$gcc_no_link = xyes; then
11546
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11547
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11548
   { (exit 1); exit 1; }; }
11549
fi
11550
cat >conftest.$ac_ext <<_ACEOF
11551
/* confdefs.h.  */
11552
_ACEOF
11553
cat confdefs.h >>conftest.$ac_ext
11554
cat >>conftest.$ac_ext <<_ACEOF
11555
/* end confdefs.h.  */
11556
 
11557
/* Override any gcc2 internal prototype to avoid an error.  */
11558
#ifdef __cplusplus
11559
extern "C"
11560
#endif
11561
/* We use char because int might match the return type of a gcc2
11562
   builtin and then its argument prototype would still apply.  */
11563
char asinhl ();
11564
int
11565
main ()
11566
{
11567
asinhl ();
11568
  ;
11569
  return 0;
11570
}
11571
_ACEOF
11572
rm -f conftest.$ac_objext conftest$ac_exeext
11573
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11574
  (eval $ac_link) 2>conftest.er1
11575
  ac_status=$?
11576
  grep -v '^ *+' conftest.er1 >conftest.err
11577
  rm -f conftest.er1
11578
  cat conftest.err >&5
11579
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11580
  (exit $ac_status); } &&
11581
         { ac_try='test -z "$ac_c_werror_flag"
11582
                         || test ! -s conftest.err'
11583
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11584
  (eval $ac_try) 2>&5
11585
  ac_status=$?
11586
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11587
  (exit $ac_status); }; } &&
11588
         { ac_try='test -s conftest$ac_exeext'
11589
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11590
  (eval $ac_try) 2>&5
11591
  ac_status=$?
11592
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11593
  (exit $ac_status); }; }; then
11594
  ac_cv_lib_m_asinhl=yes
11595
else
11596
  echo "$as_me: failed program was:" >&5
11597
sed 's/^/| /' conftest.$ac_ext >&5
11598
 
11599
ac_cv_lib_m_asinhl=no
11600
fi
11601
rm -f conftest.err conftest.$ac_objext \
11602
      conftest$ac_exeext conftest.$ac_ext
11603
LIBS=$ac_check_lib_save_LIBS
11604
fi
11605
echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinhl" >&5
11606
echo "${ECHO_T}$ac_cv_lib_m_asinhl" >&6
11607
if test $ac_cv_lib_m_asinhl = yes; then
11608
 
11609
cat >>confdefs.h <<\_ACEOF
11610
#define HAVE_ASINHL 1
11611
_ACEOF
11612
 
11613
fi
11614
 
11615
echo "$as_me:$LINENO: checking for atan2f in -lm" >&5
11616
echo $ECHO_N "checking for atan2f in -lm... $ECHO_C" >&6
11617
if test "${ac_cv_lib_m_atan2f+set}" = set; then
11618
  echo $ECHO_N "(cached) $ECHO_C" >&6
11619
else
11620
  ac_check_lib_save_LIBS=$LIBS
11621
LIBS="-lm  $LIBS"
11622
if test x$gcc_no_link = xyes; then
11623
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11624
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11625
   { (exit 1); exit 1; }; }
11626
fi
11627
cat >conftest.$ac_ext <<_ACEOF
11628
/* confdefs.h.  */
11629
_ACEOF
11630
cat confdefs.h >>conftest.$ac_ext
11631
cat >>conftest.$ac_ext <<_ACEOF
11632
/* end confdefs.h.  */
11633
 
11634
/* Override any gcc2 internal prototype to avoid an error.  */
11635
#ifdef __cplusplus
11636
extern "C"
11637
#endif
11638
/* We use char because int might match the return type of a gcc2
11639
   builtin and then its argument prototype would still apply.  */
11640
char atan2f ();
11641
int
11642
main ()
11643
{
11644
atan2f ();
11645
  ;
11646
  return 0;
11647
}
11648
_ACEOF
11649
rm -f conftest.$ac_objext conftest$ac_exeext
11650
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11651
  (eval $ac_link) 2>conftest.er1
11652
  ac_status=$?
11653
  grep -v '^ *+' conftest.er1 >conftest.err
11654
  rm -f conftest.er1
11655
  cat conftest.err >&5
11656
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11657
  (exit $ac_status); } &&
11658
         { ac_try='test -z "$ac_c_werror_flag"
11659
                         || test ! -s conftest.err'
11660
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11661
  (eval $ac_try) 2>&5
11662
  ac_status=$?
11663
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11664
  (exit $ac_status); }; } &&
11665
         { ac_try='test -s conftest$ac_exeext'
11666
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11667
  (eval $ac_try) 2>&5
11668
  ac_status=$?
11669
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11670
  (exit $ac_status); }; }; then
11671
  ac_cv_lib_m_atan2f=yes
11672
else
11673
  echo "$as_me: failed program was:" >&5
11674
sed 's/^/| /' conftest.$ac_ext >&5
11675
 
11676
ac_cv_lib_m_atan2f=no
11677
fi
11678
rm -f conftest.err conftest.$ac_objext \
11679
      conftest$ac_exeext conftest.$ac_ext
11680
LIBS=$ac_check_lib_save_LIBS
11681
fi
11682
echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2f" >&5
11683
echo "${ECHO_T}$ac_cv_lib_m_atan2f" >&6
11684
if test $ac_cv_lib_m_atan2f = yes; then
11685
 
11686
cat >>confdefs.h <<\_ACEOF
11687
#define HAVE_ATAN2F 1
11688
_ACEOF
11689
 
11690
fi
11691
 
11692
echo "$as_me:$LINENO: checking for atan2 in -lm" >&5
11693
echo $ECHO_N "checking for atan2 in -lm... $ECHO_C" >&6
11694
if test "${ac_cv_lib_m_atan2+set}" = set; then
11695
  echo $ECHO_N "(cached) $ECHO_C" >&6
11696
else
11697
  ac_check_lib_save_LIBS=$LIBS
11698
LIBS="-lm  $LIBS"
11699
if test x$gcc_no_link = xyes; then
11700
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11701
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11702
   { (exit 1); exit 1; }; }
11703
fi
11704
cat >conftest.$ac_ext <<_ACEOF
11705
/* confdefs.h.  */
11706
_ACEOF
11707
cat confdefs.h >>conftest.$ac_ext
11708
cat >>conftest.$ac_ext <<_ACEOF
11709
/* end confdefs.h.  */
11710
 
11711
/* Override any gcc2 internal prototype to avoid an error.  */
11712
#ifdef __cplusplus
11713
extern "C"
11714
#endif
11715
/* We use char because int might match the return type of a gcc2
11716
   builtin and then its argument prototype would still apply.  */
11717
char atan2 ();
11718
int
11719
main ()
11720
{
11721
atan2 ();
11722
  ;
11723
  return 0;
11724
}
11725
_ACEOF
11726
rm -f conftest.$ac_objext conftest$ac_exeext
11727
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11728
  (eval $ac_link) 2>conftest.er1
11729
  ac_status=$?
11730
  grep -v '^ *+' conftest.er1 >conftest.err
11731
  rm -f conftest.er1
11732
  cat conftest.err >&5
11733
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11734
  (exit $ac_status); } &&
11735
         { ac_try='test -z "$ac_c_werror_flag"
11736
                         || test ! -s conftest.err'
11737
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11738
  (eval $ac_try) 2>&5
11739
  ac_status=$?
11740
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11741
  (exit $ac_status); }; } &&
11742
         { ac_try='test -s conftest$ac_exeext'
11743
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11744
  (eval $ac_try) 2>&5
11745
  ac_status=$?
11746
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11747
  (exit $ac_status); }; }; then
11748
  ac_cv_lib_m_atan2=yes
11749
else
11750
  echo "$as_me: failed program was:" >&5
11751
sed 's/^/| /' conftest.$ac_ext >&5
11752
 
11753
ac_cv_lib_m_atan2=no
11754
fi
11755
rm -f conftest.err conftest.$ac_objext \
11756
      conftest$ac_exeext conftest.$ac_ext
11757
LIBS=$ac_check_lib_save_LIBS
11758
fi
11759
echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2" >&5
11760
echo "${ECHO_T}$ac_cv_lib_m_atan2" >&6
11761
if test $ac_cv_lib_m_atan2 = yes; then
11762
 
11763
cat >>confdefs.h <<\_ACEOF
11764
#define HAVE_ATAN2 1
11765
_ACEOF
11766
 
11767
fi
11768
 
11769
echo "$as_me:$LINENO: checking for atan2l in -lm" >&5
11770
echo $ECHO_N "checking for atan2l in -lm... $ECHO_C" >&6
11771
if test "${ac_cv_lib_m_atan2l+set}" = set; then
11772
  echo $ECHO_N "(cached) $ECHO_C" >&6
11773
else
11774
  ac_check_lib_save_LIBS=$LIBS
11775
LIBS="-lm  $LIBS"
11776
if test x$gcc_no_link = xyes; then
11777
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11778
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11779
   { (exit 1); exit 1; }; }
11780
fi
11781
cat >conftest.$ac_ext <<_ACEOF
11782
/* confdefs.h.  */
11783
_ACEOF
11784
cat confdefs.h >>conftest.$ac_ext
11785
cat >>conftest.$ac_ext <<_ACEOF
11786
/* end confdefs.h.  */
11787
 
11788
/* Override any gcc2 internal prototype to avoid an error.  */
11789
#ifdef __cplusplus
11790
extern "C"
11791
#endif
11792
/* We use char because int might match the return type of a gcc2
11793
   builtin and then its argument prototype would still apply.  */
11794
char atan2l ();
11795
int
11796
main ()
11797
{
11798
atan2l ();
11799
  ;
11800
  return 0;
11801
}
11802
_ACEOF
11803
rm -f conftest.$ac_objext conftest$ac_exeext
11804
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11805
  (eval $ac_link) 2>conftest.er1
11806
  ac_status=$?
11807
  grep -v '^ *+' conftest.er1 >conftest.err
11808
  rm -f conftest.er1
11809
  cat conftest.err >&5
11810
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11811
  (exit $ac_status); } &&
11812
         { ac_try='test -z "$ac_c_werror_flag"
11813
                         || test ! -s conftest.err'
11814
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11815
  (eval $ac_try) 2>&5
11816
  ac_status=$?
11817
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11818
  (exit $ac_status); }; } &&
11819
         { ac_try='test -s conftest$ac_exeext'
11820
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11821
  (eval $ac_try) 2>&5
11822
  ac_status=$?
11823
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11824
  (exit $ac_status); }; }; then
11825
  ac_cv_lib_m_atan2l=yes
11826
else
11827
  echo "$as_me: failed program was:" >&5
11828
sed 's/^/| /' conftest.$ac_ext >&5
11829
 
11830
ac_cv_lib_m_atan2l=no
11831
fi
11832
rm -f conftest.err conftest.$ac_objext \
11833
      conftest$ac_exeext conftest.$ac_ext
11834
LIBS=$ac_check_lib_save_LIBS
11835
fi
11836
echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2l" >&5
11837
echo "${ECHO_T}$ac_cv_lib_m_atan2l" >&6
11838
if test $ac_cv_lib_m_atan2l = yes; then
11839
 
11840
cat >>confdefs.h <<\_ACEOF
11841
#define HAVE_ATAN2L 1
11842
_ACEOF
11843
 
11844
fi
11845
 
11846
echo "$as_me:$LINENO: checking for atanf in -lm" >&5
11847
echo $ECHO_N "checking for atanf in -lm... $ECHO_C" >&6
11848
if test "${ac_cv_lib_m_atanf+set}" = set; then
11849
  echo $ECHO_N "(cached) $ECHO_C" >&6
11850
else
11851
  ac_check_lib_save_LIBS=$LIBS
11852
LIBS="-lm  $LIBS"
11853
if test x$gcc_no_link = xyes; then
11854
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11855
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11856
   { (exit 1); exit 1; }; }
11857
fi
11858
cat >conftest.$ac_ext <<_ACEOF
11859
/* confdefs.h.  */
11860
_ACEOF
11861
cat confdefs.h >>conftest.$ac_ext
11862
cat >>conftest.$ac_ext <<_ACEOF
11863
/* end confdefs.h.  */
11864
 
11865
/* Override any gcc2 internal prototype to avoid an error.  */
11866
#ifdef __cplusplus
11867
extern "C"
11868
#endif
11869
/* We use char because int might match the return type of a gcc2
11870
   builtin and then its argument prototype would still apply.  */
11871
char atanf ();
11872
int
11873
main ()
11874
{
11875
atanf ();
11876
  ;
11877
  return 0;
11878
}
11879
_ACEOF
11880
rm -f conftest.$ac_objext conftest$ac_exeext
11881
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11882
  (eval $ac_link) 2>conftest.er1
11883
  ac_status=$?
11884
  grep -v '^ *+' conftest.er1 >conftest.err
11885
  rm -f conftest.er1
11886
  cat conftest.err >&5
11887
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11888
  (exit $ac_status); } &&
11889
         { ac_try='test -z "$ac_c_werror_flag"
11890
                         || test ! -s conftest.err'
11891
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11892
  (eval $ac_try) 2>&5
11893
  ac_status=$?
11894
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11895
  (exit $ac_status); }; } &&
11896
         { ac_try='test -s conftest$ac_exeext'
11897
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11898
  (eval $ac_try) 2>&5
11899
  ac_status=$?
11900
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11901
  (exit $ac_status); }; }; then
11902
  ac_cv_lib_m_atanf=yes
11903
else
11904
  echo "$as_me: failed program was:" >&5
11905
sed 's/^/| /' conftest.$ac_ext >&5
11906
 
11907
ac_cv_lib_m_atanf=no
11908
fi
11909
rm -f conftest.err conftest.$ac_objext \
11910
      conftest$ac_exeext conftest.$ac_ext
11911
LIBS=$ac_check_lib_save_LIBS
11912
fi
11913
echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanf" >&5
11914
echo "${ECHO_T}$ac_cv_lib_m_atanf" >&6
11915
if test $ac_cv_lib_m_atanf = yes; then
11916
 
11917
cat >>confdefs.h <<\_ACEOF
11918
#define HAVE_ATANF 1
11919
_ACEOF
11920
 
11921
fi
11922
 
11923
echo "$as_me:$LINENO: checking for atan in -lm" >&5
11924
echo $ECHO_N "checking for atan in -lm... $ECHO_C" >&6
11925
if test "${ac_cv_lib_m_atan+set}" = set; then
11926
  echo $ECHO_N "(cached) $ECHO_C" >&6
11927
else
11928
  ac_check_lib_save_LIBS=$LIBS
11929
LIBS="-lm  $LIBS"
11930
if test x$gcc_no_link = xyes; then
11931
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11932
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11933
   { (exit 1); exit 1; }; }
11934
fi
11935
cat >conftest.$ac_ext <<_ACEOF
11936
/* confdefs.h.  */
11937
_ACEOF
11938
cat confdefs.h >>conftest.$ac_ext
11939
cat >>conftest.$ac_ext <<_ACEOF
11940
/* end confdefs.h.  */
11941
 
11942
/* Override any gcc2 internal prototype to avoid an error.  */
11943
#ifdef __cplusplus
11944
extern "C"
11945
#endif
11946
/* We use char because int might match the return type of a gcc2
11947
   builtin and then its argument prototype would still apply.  */
11948
char atan ();
11949
int
11950
main ()
11951
{
11952
atan ();
11953
  ;
11954
  return 0;
11955
}
11956
_ACEOF
11957
rm -f conftest.$ac_objext conftest$ac_exeext
11958
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11959
  (eval $ac_link) 2>conftest.er1
11960
  ac_status=$?
11961
  grep -v '^ *+' conftest.er1 >conftest.err
11962
  rm -f conftest.er1
11963
  cat conftest.err >&5
11964
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11965
  (exit $ac_status); } &&
11966
         { ac_try='test -z "$ac_c_werror_flag"
11967
                         || test ! -s conftest.err'
11968
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11969
  (eval $ac_try) 2>&5
11970
  ac_status=$?
11971
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11972
  (exit $ac_status); }; } &&
11973
         { ac_try='test -s conftest$ac_exeext'
11974
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11975
  (eval $ac_try) 2>&5
11976
  ac_status=$?
11977
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11978
  (exit $ac_status); }; }; then
11979
  ac_cv_lib_m_atan=yes
11980
else
11981
  echo "$as_me: failed program was:" >&5
11982
sed 's/^/| /' conftest.$ac_ext >&5
11983
 
11984
ac_cv_lib_m_atan=no
11985
fi
11986
rm -f conftest.err conftest.$ac_objext \
11987
      conftest$ac_exeext conftest.$ac_ext
11988
LIBS=$ac_check_lib_save_LIBS
11989
fi
11990
echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan" >&5
11991
echo "${ECHO_T}$ac_cv_lib_m_atan" >&6
11992
if test $ac_cv_lib_m_atan = yes; then
11993
 
11994
cat >>confdefs.h <<\_ACEOF
11995
#define HAVE_ATAN 1
11996
_ACEOF
11997
 
11998
fi
11999
 
12000
echo "$as_me:$LINENO: checking for atanl in -lm" >&5
12001
echo $ECHO_N "checking for atanl in -lm... $ECHO_C" >&6
12002
if test "${ac_cv_lib_m_atanl+set}" = set; then
12003
  echo $ECHO_N "(cached) $ECHO_C" >&6
12004
else
12005
  ac_check_lib_save_LIBS=$LIBS
12006
LIBS="-lm  $LIBS"
12007
if test x$gcc_no_link = xyes; then
12008
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12009
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12010
   { (exit 1); exit 1; }; }
12011
fi
12012
cat >conftest.$ac_ext <<_ACEOF
12013
/* confdefs.h.  */
12014
_ACEOF
12015
cat confdefs.h >>conftest.$ac_ext
12016
cat >>conftest.$ac_ext <<_ACEOF
12017
/* end confdefs.h.  */
12018
 
12019
/* Override any gcc2 internal prototype to avoid an error.  */
12020
#ifdef __cplusplus
12021
extern "C"
12022
#endif
12023
/* We use char because int might match the return type of a gcc2
12024
   builtin and then its argument prototype would still apply.  */
12025
char atanl ();
12026
int
12027
main ()
12028
{
12029
atanl ();
12030
  ;
12031
  return 0;
12032
}
12033
_ACEOF
12034
rm -f conftest.$ac_objext conftest$ac_exeext
12035
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12036
  (eval $ac_link) 2>conftest.er1
12037
  ac_status=$?
12038
  grep -v '^ *+' conftest.er1 >conftest.err
12039
  rm -f conftest.er1
12040
  cat conftest.err >&5
12041
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12042
  (exit $ac_status); } &&
12043
         { ac_try='test -z "$ac_c_werror_flag"
12044
                         || test ! -s conftest.err'
12045
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12046
  (eval $ac_try) 2>&5
12047
  ac_status=$?
12048
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12049
  (exit $ac_status); }; } &&
12050
         { ac_try='test -s conftest$ac_exeext'
12051
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12052
  (eval $ac_try) 2>&5
12053
  ac_status=$?
12054
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12055
  (exit $ac_status); }; }; then
12056
  ac_cv_lib_m_atanl=yes
12057
else
12058
  echo "$as_me: failed program was:" >&5
12059
sed 's/^/| /' conftest.$ac_ext >&5
12060
 
12061
ac_cv_lib_m_atanl=no
12062
fi
12063
rm -f conftest.err conftest.$ac_objext \
12064
      conftest$ac_exeext conftest.$ac_ext
12065
LIBS=$ac_check_lib_save_LIBS
12066
fi
12067
echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanl" >&5
12068
echo "${ECHO_T}$ac_cv_lib_m_atanl" >&6
12069
if test $ac_cv_lib_m_atanl = yes; then
12070
 
12071
cat >>confdefs.h <<\_ACEOF
12072
#define HAVE_ATANL 1
12073
_ACEOF
12074
 
12075
fi
12076
 
12077
echo "$as_me:$LINENO: checking for atanhf in -lm" >&5
12078
echo $ECHO_N "checking for atanhf in -lm... $ECHO_C" >&6
12079
if test "${ac_cv_lib_m_atanhf+set}" = set; then
12080
  echo $ECHO_N "(cached) $ECHO_C" >&6
12081
else
12082
  ac_check_lib_save_LIBS=$LIBS
12083
LIBS="-lm  $LIBS"
12084
if test x$gcc_no_link = xyes; then
12085
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12086
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12087
   { (exit 1); exit 1; }; }
12088
fi
12089
cat >conftest.$ac_ext <<_ACEOF
12090
/* confdefs.h.  */
12091
_ACEOF
12092
cat confdefs.h >>conftest.$ac_ext
12093
cat >>conftest.$ac_ext <<_ACEOF
12094
/* end confdefs.h.  */
12095
 
12096
/* Override any gcc2 internal prototype to avoid an error.  */
12097
#ifdef __cplusplus
12098
extern "C"
12099
#endif
12100
/* We use char because int might match the return type of a gcc2
12101
   builtin and then its argument prototype would still apply.  */
12102
char atanhf ();
12103
int
12104
main ()
12105
{
12106
atanhf ();
12107
  ;
12108
  return 0;
12109
}
12110
_ACEOF
12111
rm -f conftest.$ac_objext conftest$ac_exeext
12112
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12113
  (eval $ac_link) 2>conftest.er1
12114
  ac_status=$?
12115
  grep -v '^ *+' conftest.er1 >conftest.err
12116
  rm -f conftest.er1
12117
  cat conftest.err >&5
12118
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12119
  (exit $ac_status); } &&
12120
         { ac_try='test -z "$ac_c_werror_flag"
12121
                         || test ! -s conftest.err'
12122
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12123
  (eval $ac_try) 2>&5
12124
  ac_status=$?
12125
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12126
  (exit $ac_status); }; } &&
12127
         { ac_try='test -s conftest$ac_exeext'
12128
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12129
  (eval $ac_try) 2>&5
12130
  ac_status=$?
12131
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12132
  (exit $ac_status); }; }; then
12133
  ac_cv_lib_m_atanhf=yes
12134
else
12135
  echo "$as_me: failed program was:" >&5
12136
sed 's/^/| /' conftest.$ac_ext >&5
12137
 
12138
ac_cv_lib_m_atanhf=no
12139
fi
12140
rm -f conftest.err conftest.$ac_objext \
12141
      conftest$ac_exeext conftest.$ac_ext
12142
LIBS=$ac_check_lib_save_LIBS
12143
fi
12144
echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanhf" >&5
12145
echo "${ECHO_T}$ac_cv_lib_m_atanhf" >&6
12146
if test $ac_cv_lib_m_atanhf = yes; then
12147
 
12148
cat >>confdefs.h <<\_ACEOF
12149
#define HAVE_ATANHF 1
12150
_ACEOF
12151
 
12152
fi
12153
 
12154
echo "$as_me:$LINENO: checking for atanh in -lm" >&5
12155
echo $ECHO_N "checking for atanh in -lm... $ECHO_C" >&6
12156
if test "${ac_cv_lib_m_atanh+set}" = set; then
12157
  echo $ECHO_N "(cached) $ECHO_C" >&6
12158
else
12159
  ac_check_lib_save_LIBS=$LIBS
12160
LIBS="-lm  $LIBS"
12161
if test x$gcc_no_link = xyes; then
12162
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12163
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12164
   { (exit 1); exit 1; }; }
12165
fi
12166
cat >conftest.$ac_ext <<_ACEOF
12167
/* confdefs.h.  */
12168
_ACEOF
12169
cat confdefs.h >>conftest.$ac_ext
12170
cat >>conftest.$ac_ext <<_ACEOF
12171
/* end confdefs.h.  */
12172
 
12173
/* Override any gcc2 internal prototype to avoid an error.  */
12174
#ifdef __cplusplus
12175
extern "C"
12176
#endif
12177
/* We use char because int might match the return type of a gcc2
12178
   builtin and then its argument prototype would still apply.  */
12179
char atanh ();
12180
int
12181
main ()
12182
{
12183
atanh ();
12184
  ;
12185
  return 0;
12186
}
12187
_ACEOF
12188
rm -f conftest.$ac_objext conftest$ac_exeext
12189
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12190
  (eval $ac_link) 2>conftest.er1
12191
  ac_status=$?
12192
  grep -v '^ *+' conftest.er1 >conftest.err
12193
  rm -f conftest.er1
12194
  cat conftest.err >&5
12195
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12196
  (exit $ac_status); } &&
12197
         { ac_try='test -z "$ac_c_werror_flag"
12198
                         || test ! -s conftest.err'
12199
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12200
  (eval $ac_try) 2>&5
12201
  ac_status=$?
12202
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12203
  (exit $ac_status); }; } &&
12204
         { ac_try='test -s conftest$ac_exeext'
12205
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12206
  (eval $ac_try) 2>&5
12207
  ac_status=$?
12208
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12209
  (exit $ac_status); }; }; then
12210
  ac_cv_lib_m_atanh=yes
12211
else
12212
  echo "$as_me: failed program was:" >&5
12213
sed 's/^/| /' conftest.$ac_ext >&5
12214
 
12215
ac_cv_lib_m_atanh=no
12216
fi
12217
rm -f conftest.err conftest.$ac_objext \
12218
      conftest$ac_exeext conftest.$ac_ext
12219
LIBS=$ac_check_lib_save_LIBS
12220
fi
12221
echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanh" >&5
12222
echo "${ECHO_T}$ac_cv_lib_m_atanh" >&6
12223
if test $ac_cv_lib_m_atanh = yes; then
12224
 
12225
cat >>confdefs.h <<\_ACEOF
12226
#define HAVE_ATANH 1
12227
_ACEOF
12228
 
12229
fi
12230
 
12231
echo "$as_me:$LINENO: checking for atanhl in -lm" >&5
12232
echo $ECHO_N "checking for atanhl in -lm... $ECHO_C" >&6
12233
if test "${ac_cv_lib_m_atanhl+set}" = set; then
12234
  echo $ECHO_N "(cached) $ECHO_C" >&6
12235
else
12236
  ac_check_lib_save_LIBS=$LIBS
12237
LIBS="-lm  $LIBS"
12238
if test x$gcc_no_link = xyes; then
12239
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12240
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12241
   { (exit 1); exit 1; }; }
12242
fi
12243
cat >conftest.$ac_ext <<_ACEOF
12244
/* confdefs.h.  */
12245
_ACEOF
12246
cat confdefs.h >>conftest.$ac_ext
12247
cat >>conftest.$ac_ext <<_ACEOF
12248
/* end confdefs.h.  */
12249
 
12250
/* Override any gcc2 internal prototype to avoid an error.  */
12251
#ifdef __cplusplus
12252
extern "C"
12253
#endif
12254
/* We use char because int might match the return type of a gcc2
12255
   builtin and then its argument prototype would still apply.  */
12256
char atanhl ();
12257
int
12258
main ()
12259
{
12260
atanhl ();
12261
  ;
12262
  return 0;
12263
}
12264
_ACEOF
12265
rm -f conftest.$ac_objext conftest$ac_exeext
12266
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12267
  (eval $ac_link) 2>conftest.er1
12268
  ac_status=$?
12269
  grep -v '^ *+' conftest.er1 >conftest.err
12270
  rm -f conftest.er1
12271
  cat conftest.err >&5
12272
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12273
  (exit $ac_status); } &&
12274
         { ac_try='test -z "$ac_c_werror_flag"
12275
                         || test ! -s conftest.err'
12276
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12277
  (eval $ac_try) 2>&5
12278
  ac_status=$?
12279
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12280
  (exit $ac_status); }; } &&
12281
         { ac_try='test -s conftest$ac_exeext'
12282
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12283
  (eval $ac_try) 2>&5
12284
  ac_status=$?
12285
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12286
  (exit $ac_status); }; }; then
12287
  ac_cv_lib_m_atanhl=yes
12288
else
12289
  echo "$as_me: failed program was:" >&5
12290
sed 's/^/| /' conftest.$ac_ext >&5
12291
 
12292
ac_cv_lib_m_atanhl=no
12293
fi
12294
rm -f conftest.err conftest.$ac_objext \
12295
      conftest$ac_exeext conftest.$ac_ext
12296
LIBS=$ac_check_lib_save_LIBS
12297
fi
12298
echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanhl" >&5
12299
echo "${ECHO_T}$ac_cv_lib_m_atanhl" >&6
12300
if test $ac_cv_lib_m_atanhl = yes; then
12301
 
12302
cat >>confdefs.h <<\_ACEOF
12303
#define HAVE_ATANHL 1
12304
_ACEOF
12305
 
12306
fi
12307
 
12308
echo "$as_me:$LINENO: checking for cargf in -lm" >&5
12309
echo $ECHO_N "checking for cargf in -lm... $ECHO_C" >&6
12310
if test "${ac_cv_lib_m_cargf+set}" = set; then
12311
  echo $ECHO_N "(cached) $ECHO_C" >&6
12312
else
12313
  ac_check_lib_save_LIBS=$LIBS
12314
LIBS="-lm  $LIBS"
12315
if test x$gcc_no_link = xyes; then
12316
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12317
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12318
   { (exit 1); exit 1; }; }
12319
fi
12320
cat >conftest.$ac_ext <<_ACEOF
12321
/* confdefs.h.  */
12322
_ACEOF
12323
cat confdefs.h >>conftest.$ac_ext
12324
cat >>conftest.$ac_ext <<_ACEOF
12325
/* end confdefs.h.  */
12326
 
12327
/* Override any gcc2 internal prototype to avoid an error.  */
12328
#ifdef __cplusplus
12329
extern "C"
12330
#endif
12331
/* We use char because int might match the return type of a gcc2
12332
   builtin and then its argument prototype would still apply.  */
12333
char cargf ();
12334
int
12335
main ()
12336
{
12337
cargf ();
12338
  ;
12339
  return 0;
12340
}
12341
_ACEOF
12342
rm -f conftest.$ac_objext conftest$ac_exeext
12343
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12344
  (eval $ac_link) 2>conftest.er1
12345
  ac_status=$?
12346
  grep -v '^ *+' conftest.er1 >conftest.err
12347
  rm -f conftest.er1
12348
  cat conftest.err >&5
12349
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12350
  (exit $ac_status); } &&
12351
         { ac_try='test -z "$ac_c_werror_flag"
12352
                         || test ! -s conftest.err'
12353
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12354
  (eval $ac_try) 2>&5
12355
  ac_status=$?
12356
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12357
  (exit $ac_status); }; } &&
12358
         { ac_try='test -s conftest$ac_exeext'
12359
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12360
  (eval $ac_try) 2>&5
12361
  ac_status=$?
12362
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12363
  (exit $ac_status); }; }; then
12364
  ac_cv_lib_m_cargf=yes
12365
else
12366
  echo "$as_me: failed program was:" >&5
12367
sed 's/^/| /' conftest.$ac_ext >&5
12368
 
12369
ac_cv_lib_m_cargf=no
12370
fi
12371
rm -f conftest.err conftest.$ac_objext \
12372
      conftest$ac_exeext conftest.$ac_ext
12373
LIBS=$ac_check_lib_save_LIBS
12374
fi
12375
echo "$as_me:$LINENO: result: $ac_cv_lib_m_cargf" >&5
12376
echo "${ECHO_T}$ac_cv_lib_m_cargf" >&6
12377
if test $ac_cv_lib_m_cargf = yes; then
12378
 
12379
cat >>confdefs.h <<\_ACEOF
12380
#define HAVE_CARGF 1
12381
_ACEOF
12382
 
12383
fi
12384
 
12385
echo "$as_me:$LINENO: checking for carg in -lm" >&5
12386
echo $ECHO_N "checking for carg in -lm... $ECHO_C" >&6
12387
if test "${ac_cv_lib_m_carg+set}" = set; then
12388
  echo $ECHO_N "(cached) $ECHO_C" >&6
12389
else
12390
  ac_check_lib_save_LIBS=$LIBS
12391
LIBS="-lm  $LIBS"
12392
if test x$gcc_no_link = xyes; then
12393
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12394
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12395
   { (exit 1); exit 1; }; }
12396
fi
12397
cat >conftest.$ac_ext <<_ACEOF
12398
/* confdefs.h.  */
12399
_ACEOF
12400
cat confdefs.h >>conftest.$ac_ext
12401
cat >>conftest.$ac_ext <<_ACEOF
12402
/* end confdefs.h.  */
12403
 
12404
/* Override any gcc2 internal prototype to avoid an error.  */
12405
#ifdef __cplusplus
12406
extern "C"
12407
#endif
12408
/* We use char because int might match the return type of a gcc2
12409
   builtin and then its argument prototype would still apply.  */
12410
char carg ();
12411
int
12412
main ()
12413
{
12414
carg ();
12415
  ;
12416
  return 0;
12417
}
12418
_ACEOF
12419
rm -f conftest.$ac_objext conftest$ac_exeext
12420
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12421
  (eval $ac_link) 2>conftest.er1
12422
  ac_status=$?
12423
  grep -v '^ *+' conftest.er1 >conftest.err
12424
  rm -f conftest.er1
12425
  cat conftest.err >&5
12426
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12427
  (exit $ac_status); } &&
12428
         { ac_try='test -z "$ac_c_werror_flag"
12429
                         || test ! -s conftest.err'
12430
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12431
  (eval $ac_try) 2>&5
12432
  ac_status=$?
12433
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12434
  (exit $ac_status); }; } &&
12435
         { ac_try='test -s conftest$ac_exeext'
12436
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12437
  (eval $ac_try) 2>&5
12438
  ac_status=$?
12439
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12440
  (exit $ac_status); }; }; then
12441
  ac_cv_lib_m_carg=yes
12442
else
12443
  echo "$as_me: failed program was:" >&5
12444
sed 's/^/| /' conftest.$ac_ext >&5
12445
 
12446
ac_cv_lib_m_carg=no
12447
fi
12448
rm -f conftest.err conftest.$ac_objext \
12449
      conftest$ac_exeext conftest.$ac_ext
12450
LIBS=$ac_check_lib_save_LIBS
12451
fi
12452
echo "$as_me:$LINENO: result: $ac_cv_lib_m_carg" >&5
12453
echo "${ECHO_T}$ac_cv_lib_m_carg" >&6
12454
if test $ac_cv_lib_m_carg = yes; then
12455
 
12456
cat >>confdefs.h <<\_ACEOF
12457
#define HAVE_CARG 1
12458
_ACEOF
12459
 
12460
fi
12461
 
12462
echo "$as_me:$LINENO: checking for cargl in -lm" >&5
12463
echo $ECHO_N "checking for cargl in -lm... $ECHO_C" >&6
12464
if test "${ac_cv_lib_m_cargl+set}" = set; then
12465
  echo $ECHO_N "(cached) $ECHO_C" >&6
12466
else
12467
  ac_check_lib_save_LIBS=$LIBS
12468
LIBS="-lm  $LIBS"
12469
if test x$gcc_no_link = xyes; then
12470
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12471
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12472
   { (exit 1); exit 1; }; }
12473
fi
12474
cat >conftest.$ac_ext <<_ACEOF
12475
/* confdefs.h.  */
12476
_ACEOF
12477
cat confdefs.h >>conftest.$ac_ext
12478
cat >>conftest.$ac_ext <<_ACEOF
12479
/* end confdefs.h.  */
12480
 
12481
/* Override any gcc2 internal prototype to avoid an error.  */
12482
#ifdef __cplusplus
12483
extern "C"
12484
#endif
12485
/* We use char because int might match the return type of a gcc2
12486
   builtin and then its argument prototype would still apply.  */
12487
char cargl ();
12488
int
12489
main ()
12490
{
12491
cargl ();
12492
  ;
12493
  return 0;
12494
}
12495
_ACEOF
12496
rm -f conftest.$ac_objext conftest$ac_exeext
12497
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12498
  (eval $ac_link) 2>conftest.er1
12499
  ac_status=$?
12500
  grep -v '^ *+' conftest.er1 >conftest.err
12501
  rm -f conftest.er1
12502
  cat conftest.err >&5
12503
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12504
  (exit $ac_status); } &&
12505
         { ac_try='test -z "$ac_c_werror_flag"
12506
                         || test ! -s conftest.err'
12507
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12508
  (eval $ac_try) 2>&5
12509
  ac_status=$?
12510
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12511
  (exit $ac_status); }; } &&
12512
         { ac_try='test -s conftest$ac_exeext'
12513
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12514
  (eval $ac_try) 2>&5
12515
  ac_status=$?
12516
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12517
  (exit $ac_status); }; }; then
12518
  ac_cv_lib_m_cargl=yes
12519
else
12520
  echo "$as_me: failed program was:" >&5
12521
sed 's/^/| /' conftest.$ac_ext >&5
12522
 
12523
ac_cv_lib_m_cargl=no
12524
fi
12525
rm -f conftest.err conftest.$ac_objext \
12526
      conftest$ac_exeext conftest.$ac_ext
12527
LIBS=$ac_check_lib_save_LIBS
12528
fi
12529
echo "$as_me:$LINENO: result: $ac_cv_lib_m_cargl" >&5
12530
echo "${ECHO_T}$ac_cv_lib_m_cargl" >&6
12531
if test $ac_cv_lib_m_cargl = yes; then
12532
 
12533
cat >>confdefs.h <<\_ACEOF
12534
#define HAVE_CARGL 1
12535
_ACEOF
12536
 
12537
fi
12538
 
12539
echo "$as_me:$LINENO: checking for ceilf in -lm" >&5
12540
echo $ECHO_N "checking for ceilf in -lm... $ECHO_C" >&6
12541
if test "${ac_cv_lib_m_ceilf+set}" = set; then
12542
  echo $ECHO_N "(cached) $ECHO_C" >&6
12543
else
12544
  ac_check_lib_save_LIBS=$LIBS
12545
LIBS="-lm  $LIBS"
12546
if test x$gcc_no_link = xyes; then
12547
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12548
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12549
   { (exit 1); exit 1; }; }
12550
fi
12551
cat >conftest.$ac_ext <<_ACEOF
12552
/* confdefs.h.  */
12553
_ACEOF
12554
cat confdefs.h >>conftest.$ac_ext
12555
cat >>conftest.$ac_ext <<_ACEOF
12556
/* end confdefs.h.  */
12557
 
12558
/* Override any gcc2 internal prototype to avoid an error.  */
12559
#ifdef __cplusplus
12560
extern "C"
12561
#endif
12562
/* We use char because int might match the return type of a gcc2
12563
   builtin and then its argument prototype would still apply.  */
12564
char ceilf ();
12565
int
12566
main ()
12567
{
12568
ceilf ();
12569
  ;
12570
  return 0;
12571
}
12572
_ACEOF
12573
rm -f conftest.$ac_objext conftest$ac_exeext
12574
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12575
  (eval $ac_link) 2>conftest.er1
12576
  ac_status=$?
12577
  grep -v '^ *+' conftest.er1 >conftest.err
12578
  rm -f conftest.er1
12579
  cat conftest.err >&5
12580
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12581
  (exit $ac_status); } &&
12582
         { ac_try='test -z "$ac_c_werror_flag"
12583
                         || test ! -s conftest.err'
12584
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12585
  (eval $ac_try) 2>&5
12586
  ac_status=$?
12587
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12588
  (exit $ac_status); }; } &&
12589
         { ac_try='test -s conftest$ac_exeext'
12590
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12591
  (eval $ac_try) 2>&5
12592
  ac_status=$?
12593
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12594
  (exit $ac_status); }; }; then
12595
  ac_cv_lib_m_ceilf=yes
12596
else
12597
  echo "$as_me: failed program was:" >&5
12598
sed 's/^/| /' conftest.$ac_ext >&5
12599
 
12600
ac_cv_lib_m_ceilf=no
12601
fi
12602
rm -f conftest.err conftest.$ac_objext \
12603
      conftest$ac_exeext conftest.$ac_ext
12604
LIBS=$ac_check_lib_save_LIBS
12605
fi
12606
echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceilf" >&5
12607
echo "${ECHO_T}$ac_cv_lib_m_ceilf" >&6
12608
if test $ac_cv_lib_m_ceilf = yes; then
12609
 
12610
cat >>confdefs.h <<\_ACEOF
12611
#define HAVE_CEILF 1
12612
_ACEOF
12613
 
12614
fi
12615
 
12616
echo "$as_me:$LINENO: checking for ceil in -lm" >&5
12617
echo $ECHO_N "checking for ceil in -lm... $ECHO_C" >&6
12618
if test "${ac_cv_lib_m_ceil+set}" = set; then
12619
  echo $ECHO_N "(cached) $ECHO_C" >&6
12620
else
12621
  ac_check_lib_save_LIBS=$LIBS
12622
LIBS="-lm  $LIBS"
12623
if test x$gcc_no_link = xyes; then
12624
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12625
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12626
   { (exit 1); exit 1; }; }
12627
fi
12628
cat >conftest.$ac_ext <<_ACEOF
12629
/* confdefs.h.  */
12630
_ACEOF
12631
cat confdefs.h >>conftest.$ac_ext
12632
cat >>conftest.$ac_ext <<_ACEOF
12633
/* end confdefs.h.  */
12634
 
12635
/* Override any gcc2 internal prototype to avoid an error.  */
12636
#ifdef __cplusplus
12637
extern "C"
12638
#endif
12639
/* We use char because int might match the return type of a gcc2
12640
   builtin and then its argument prototype would still apply.  */
12641
char ceil ();
12642
int
12643
main ()
12644
{
12645
ceil ();
12646
  ;
12647
  return 0;
12648
}
12649
_ACEOF
12650
rm -f conftest.$ac_objext conftest$ac_exeext
12651
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12652
  (eval $ac_link) 2>conftest.er1
12653
  ac_status=$?
12654
  grep -v '^ *+' conftest.er1 >conftest.err
12655
  rm -f conftest.er1
12656
  cat conftest.err >&5
12657
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12658
  (exit $ac_status); } &&
12659
         { ac_try='test -z "$ac_c_werror_flag"
12660
                         || test ! -s conftest.err'
12661
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12662
  (eval $ac_try) 2>&5
12663
  ac_status=$?
12664
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12665
  (exit $ac_status); }; } &&
12666
         { ac_try='test -s conftest$ac_exeext'
12667
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12668
  (eval $ac_try) 2>&5
12669
  ac_status=$?
12670
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12671
  (exit $ac_status); }; }; then
12672
  ac_cv_lib_m_ceil=yes
12673
else
12674
  echo "$as_me: failed program was:" >&5
12675
sed 's/^/| /' conftest.$ac_ext >&5
12676
 
12677
ac_cv_lib_m_ceil=no
12678
fi
12679
rm -f conftest.err conftest.$ac_objext \
12680
      conftest$ac_exeext conftest.$ac_ext
12681
LIBS=$ac_check_lib_save_LIBS
12682
fi
12683
echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceil" >&5
12684
echo "${ECHO_T}$ac_cv_lib_m_ceil" >&6
12685
if test $ac_cv_lib_m_ceil = yes; then
12686
 
12687
cat >>confdefs.h <<\_ACEOF
12688
#define HAVE_CEIL 1
12689
_ACEOF
12690
 
12691
fi
12692
 
12693
echo "$as_me:$LINENO: checking for ceill in -lm" >&5
12694
echo $ECHO_N "checking for ceill in -lm... $ECHO_C" >&6
12695
if test "${ac_cv_lib_m_ceill+set}" = set; then
12696
  echo $ECHO_N "(cached) $ECHO_C" >&6
12697
else
12698
  ac_check_lib_save_LIBS=$LIBS
12699
LIBS="-lm  $LIBS"
12700
if test x$gcc_no_link = xyes; then
12701
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12702
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12703
   { (exit 1); exit 1; }; }
12704
fi
12705
cat >conftest.$ac_ext <<_ACEOF
12706
/* confdefs.h.  */
12707
_ACEOF
12708
cat confdefs.h >>conftest.$ac_ext
12709
cat >>conftest.$ac_ext <<_ACEOF
12710
/* end confdefs.h.  */
12711
 
12712
/* Override any gcc2 internal prototype to avoid an error.  */
12713
#ifdef __cplusplus
12714
extern "C"
12715
#endif
12716
/* We use char because int might match the return type of a gcc2
12717
   builtin and then its argument prototype would still apply.  */
12718
char ceill ();
12719
int
12720
main ()
12721
{
12722
ceill ();
12723
  ;
12724
  return 0;
12725
}
12726
_ACEOF
12727
rm -f conftest.$ac_objext conftest$ac_exeext
12728
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12729
  (eval $ac_link) 2>conftest.er1
12730
  ac_status=$?
12731
  grep -v '^ *+' conftest.er1 >conftest.err
12732
  rm -f conftest.er1
12733
  cat conftest.err >&5
12734
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12735
  (exit $ac_status); } &&
12736
         { ac_try='test -z "$ac_c_werror_flag"
12737
                         || test ! -s conftest.err'
12738
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12739
  (eval $ac_try) 2>&5
12740
  ac_status=$?
12741
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12742
  (exit $ac_status); }; } &&
12743
         { ac_try='test -s conftest$ac_exeext'
12744
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12745
  (eval $ac_try) 2>&5
12746
  ac_status=$?
12747
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12748
  (exit $ac_status); }; }; then
12749
  ac_cv_lib_m_ceill=yes
12750
else
12751
  echo "$as_me: failed program was:" >&5
12752
sed 's/^/| /' conftest.$ac_ext >&5
12753
 
12754
ac_cv_lib_m_ceill=no
12755
fi
12756
rm -f conftest.err conftest.$ac_objext \
12757
      conftest$ac_exeext conftest.$ac_ext
12758
LIBS=$ac_check_lib_save_LIBS
12759
fi
12760
echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceill" >&5
12761
echo "${ECHO_T}$ac_cv_lib_m_ceill" >&6
12762
if test $ac_cv_lib_m_ceill = yes; then
12763
 
12764
cat >>confdefs.h <<\_ACEOF
12765
#define HAVE_CEILL 1
12766
_ACEOF
12767
 
12768
fi
12769
 
12770
echo "$as_me:$LINENO: checking for copysignf in -lm" >&5
12771
echo $ECHO_N "checking for copysignf in -lm... $ECHO_C" >&6
12772
if test "${ac_cv_lib_m_copysignf+set}" = set; then
12773
  echo $ECHO_N "(cached) $ECHO_C" >&6
12774
else
12775
  ac_check_lib_save_LIBS=$LIBS
12776
LIBS="-lm  $LIBS"
12777
if test x$gcc_no_link = xyes; then
12778
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12779
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12780
   { (exit 1); exit 1; }; }
12781
fi
12782
cat >conftest.$ac_ext <<_ACEOF
12783
/* confdefs.h.  */
12784
_ACEOF
12785
cat confdefs.h >>conftest.$ac_ext
12786
cat >>conftest.$ac_ext <<_ACEOF
12787
/* end confdefs.h.  */
12788
 
12789
/* Override any gcc2 internal prototype to avoid an error.  */
12790
#ifdef __cplusplus
12791
extern "C"
12792
#endif
12793
/* We use char because int might match the return type of a gcc2
12794
   builtin and then its argument prototype would still apply.  */
12795
char copysignf ();
12796
int
12797
main ()
12798
{
12799
copysignf ();
12800
  ;
12801
  return 0;
12802
}
12803
_ACEOF
12804
rm -f conftest.$ac_objext conftest$ac_exeext
12805
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12806
  (eval $ac_link) 2>conftest.er1
12807
  ac_status=$?
12808
  grep -v '^ *+' conftest.er1 >conftest.err
12809
  rm -f conftest.er1
12810
  cat conftest.err >&5
12811
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12812
  (exit $ac_status); } &&
12813
         { ac_try='test -z "$ac_c_werror_flag"
12814
                         || test ! -s conftest.err'
12815
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12816
  (eval $ac_try) 2>&5
12817
  ac_status=$?
12818
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12819
  (exit $ac_status); }; } &&
12820
         { ac_try='test -s conftest$ac_exeext'
12821
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12822
  (eval $ac_try) 2>&5
12823
  ac_status=$?
12824
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12825
  (exit $ac_status); }; }; then
12826
  ac_cv_lib_m_copysignf=yes
12827
else
12828
  echo "$as_me: failed program was:" >&5
12829
sed 's/^/| /' conftest.$ac_ext >&5
12830
 
12831
ac_cv_lib_m_copysignf=no
12832
fi
12833
rm -f conftest.err conftest.$ac_objext \
12834
      conftest$ac_exeext conftest.$ac_ext
12835
LIBS=$ac_check_lib_save_LIBS
12836
fi
12837
echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysignf" >&5
12838
echo "${ECHO_T}$ac_cv_lib_m_copysignf" >&6
12839
if test $ac_cv_lib_m_copysignf = yes; then
12840
 
12841
cat >>confdefs.h <<\_ACEOF
12842
#define HAVE_COPYSIGNF 1
12843
_ACEOF
12844
 
12845
fi
12846
 
12847
echo "$as_me:$LINENO: checking for copysign in -lm" >&5
12848
echo $ECHO_N "checking for copysign in -lm... $ECHO_C" >&6
12849
if test "${ac_cv_lib_m_copysign+set}" = set; then
12850
  echo $ECHO_N "(cached) $ECHO_C" >&6
12851
else
12852
  ac_check_lib_save_LIBS=$LIBS
12853
LIBS="-lm  $LIBS"
12854
if test x$gcc_no_link = xyes; then
12855
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12856
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12857
   { (exit 1); exit 1; }; }
12858
fi
12859
cat >conftest.$ac_ext <<_ACEOF
12860
/* confdefs.h.  */
12861
_ACEOF
12862
cat confdefs.h >>conftest.$ac_ext
12863
cat >>conftest.$ac_ext <<_ACEOF
12864
/* end confdefs.h.  */
12865
 
12866
/* Override any gcc2 internal prototype to avoid an error.  */
12867
#ifdef __cplusplus
12868
extern "C"
12869
#endif
12870
/* We use char because int might match the return type of a gcc2
12871
   builtin and then its argument prototype would still apply.  */
12872
char copysign ();
12873
int
12874
main ()
12875
{
12876
copysign ();
12877
  ;
12878
  return 0;
12879
}
12880
_ACEOF
12881
rm -f conftest.$ac_objext conftest$ac_exeext
12882
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12883
  (eval $ac_link) 2>conftest.er1
12884
  ac_status=$?
12885
  grep -v '^ *+' conftest.er1 >conftest.err
12886
  rm -f conftest.er1
12887
  cat conftest.err >&5
12888
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12889
  (exit $ac_status); } &&
12890
         { ac_try='test -z "$ac_c_werror_flag"
12891
                         || test ! -s conftest.err'
12892
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12893
  (eval $ac_try) 2>&5
12894
  ac_status=$?
12895
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12896
  (exit $ac_status); }; } &&
12897
         { ac_try='test -s conftest$ac_exeext'
12898
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12899
  (eval $ac_try) 2>&5
12900
  ac_status=$?
12901
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12902
  (exit $ac_status); }; }; then
12903
  ac_cv_lib_m_copysign=yes
12904
else
12905
  echo "$as_me: failed program was:" >&5
12906
sed 's/^/| /' conftest.$ac_ext >&5
12907
 
12908
ac_cv_lib_m_copysign=no
12909
fi
12910
rm -f conftest.err conftest.$ac_objext \
12911
      conftest$ac_exeext conftest.$ac_ext
12912
LIBS=$ac_check_lib_save_LIBS
12913
fi
12914
echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysign" >&5
12915
echo "${ECHO_T}$ac_cv_lib_m_copysign" >&6
12916
if test $ac_cv_lib_m_copysign = yes; then
12917
 
12918
cat >>confdefs.h <<\_ACEOF
12919
#define HAVE_COPYSIGN 1
12920
_ACEOF
12921
 
12922
fi
12923
 
12924
echo "$as_me:$LINENO: checking for copysignl in -lm" >&5
12925
echo $ECHO_N "checking for copysignl in -lm... $ECHO_C" >&6
12926
if test "${ac_cv_lib_m_copysignl+set}" = set; then
12927
  echo $ECHO_N "(cached) $ECHO_C" >&6
12928
else
12929
  ac_check_lib_save_LIBS=$LIBS
12930
LIBS="-lm  $LIBS"
12931
if test x$gcc_no_link = xyes; then
12932
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12933
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12934
   { (exit 1); exit 1; }; }
12935
fi
12936
cat >conftest.$ac_ext <<_ACEOF
12937
/* confdefs.h.  */
12938
_ACEOF
12939
cat confdefs.h >>conftest.$ac_ext
12940
cat >>conftest.$ac_ext <<_ACEOF
12941
/* end confdefs.h.  */
12942
 
12943
/* Override any gcc2 internal prototype to avoid an error.  */
12944
#ifdef __cplusplus
12945
extern "C"
12946
#endif
12947
/* We use char because int might match the return type of a gcc2
12948
   builtin and then its argument prototype would still apply.  */
12949
char copysignl ();
12950
int
12951
main ()
12952
{
12953
copysignl ();
12954
  ;
12955
  return 0;
12956
}
12957
_ACEOF
12958
rm -f conftest.$ac_objext conftest$ac_exeext
12959
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12960
  (eval $ac_link) 2>conftest.er1
12961
  ac_status=$?
12962
  grep -v '^ *+' conftest.er1 >conftest.err
12963
  rm -f conftest.er1
12964
  cat conftest.err >&5
12965
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12966
  (exit $ac_status); } &&
12967
         { ac_try='test -z "$ac_c_werror_flag"
12968
                         || test ! -s conftest.err'
12969
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12970
  (eval $ac_try) 2>&5
12971
  ac_status=$?
12972
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12973
  (exit $ac_status); }; } &&
12974
         { ac_try='test -s conftest$ac_exeext'
12975
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12976
  (eval $ac_try) 2>&5
12977
  ac_status=$?
12978
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12979
  (exit $ac_status); }; }; then
12980
  ac_cv_lib_m_copysignl=yes
12981
else
12982
  echo "$as_me: failed program was:" >&5
12983
sed 's/^/| /' conftest.$ac_ext >&5
12984
 
12985
ac_cv_lib_m_copysignl=no
12986
fi
12987
rm -f conftest.err conftest.$ac_objext \
12988
      conftest$ac_exeext conftest.$ac_ext
12989
LIBS=$ac_check_lib_save_LIBS
12990
fi
12991
echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysignl" >&5
12992
echo "${ECHO_T}$ac_cv_lib_m_copysignl" >&6
12993
if test $ac_cv_lib_m_copysignl = yes; then
12994
 
12995
cat >>confdefs.h <<\_ACEOF
12996
#define HAVE_COPYSIGNL 1
12997
_ACEOF
12998
 
12999
fi
13000
 
13001
echo "$as_me:$LINENO: checking for cosf in -lm" >&5
13002
echo $ECHO_N "checking for cosf in -lm... $ECHO_C" >&6
13003
if test "${ac_cv_lib_m_cosf+set}" = set; then
13004
  echo $ECHO_N "(cached) $ECHO_C" >&6
13005
else
13006
  ac_check_lib_save_LIBS=$LIBS
13007
LIBS="-lm  $LIBS"
13008
if test x$gcc_no_link = xyes; then
13009
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13010
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13011
   { (exit 1); exit 1; }; }
13012
fi
13013
cat >conftest.$ac_ext <<_ACEOF
13014
/* confdefs.h.  */
13015
_ACEOF
13016
cat confdefs.h >>conftest.$ac_ext
13017
cat >>conftest.$ac_ext <<_ACEOF
13018
/* end confdefs.h.  */
13019
 
13020
/* Override any gcc2 internal prototype to avoid an error.  */
13021
#ifdef __cplusplus
13022
extern "C"
13023
#endif
13024
/* We use char because int might match the return type of a gcc2
13025
   builtin and then its argument prototype would still apply.  */
13026
char cosf ();
13027
int
13028
main ()
13029
{
13030
cosf ();
13031
  ;
13032
  return 0;
13033
}
13034
_ACEOF
13035
rm -f conftest.$ac_objext conftest$ac_exeext
13036
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13037
  (eval $ac_link) 2>conftest.er1
13038
  ac_status=$?
13039
  grep -v '^ *+' conftest.er1 >conftest.err
13040
  rm -f conftest.er1
13041
  cat conftest.err >&5
13042
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13043
  (exit $ac_status); } &&
13044
         { ac_try='test -z "$ac_c_werror_flag"
13045
                         || test ! -s conftest.err'
13046
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13047
  (eval $ac_try) 2>&5
13048
  ac_status=$?
13049
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13050
  (exit $ac_status); }; } &&
13051
         { ac_try='test -s conftest$ac_exeext'
13052
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13053
  (eval $ac_try) 2>&5
13054
  ac_status=$?
13055
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13056
  (exit $ac_status); }; }; then
13057
  ac_cv_lib_m_cosf=yes
13058
else
13059
  echo "$as_me: failed program was:" >&5
13060
sed 's/^/| /' conftest.$ac_ext >&5
13061
 
13062
ac_cv_lib_m_cosf=no
13063
fi
13064
rm -f conftest.err conftest.$ac_objext \
13065
      conftest$ac_exeext conftest.$ac_ext
13066
LIBS=$ac_check_lib_save_LIBS
13067
fi
13068
echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosf" >&5
13069
echo "${ECHO_T}$ac_cv_lib_m_cosf" >&6
13070
if test $ac_cv_lib_m_cosf = yes; then
13071
 
13072
cat >>confdefs.h <<\_ACEOF
13073
#define HAVE_COSF 1
13074
_ACEOF
13075
 
13076
fi
13077
 
13078
echo "$as_me:$LINENO: checking for cos in -lm" >&5
13079
echo $ECHO_N "checking for cos in -lm... $ECHO_C" >&6
13080
if test "${ac_cv_lib_m_cos+set}" = set; then
13081
  echo $ECHO_N "(cached) $ECHO_C" >&6
13082
else
13083
  ac_check_lib_save_LIBS=$LIBS
13084
LIBS="-lm  $LIBS"
13085
if test x$gcc_no_link = xyes; then
13086
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13087
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13088
   { (exit 1); exit 1; }; }
13089
fi
13090
cat >conftest.$ac_ext <<_ACEOF
13091
/* confdefs.h.  */
13092
_ACEOF
13093
cat confdefs.h >>conftest.$ac_ext
13094
cat >>conftest.$ac_ext <<_ACEOF
13095
/* end confdefs.h.  */
13096
 
13097
/* Override any gcc2 internal prototype to avoid an error.  */
13098
#ifdef __cplusplus
13099
extern "C"
13100
#endif
13101
/* We use char because int might match the return type of a gcc2
13102
   builtin and then its argument prototype would still apply.  */
13103
char cos ();
13104
int
13105
main ()
13106
{
13107
cos ();
13108
  ;
13109
  return 0;
13110
}
13111
_ACEOF
13112
rm -f conftest.$ac_objext conftest$ac_exeext
13113
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13114
  (eval $ac_link) 2>conftest.er1
13115
  ac_status=$?
13116
  grep -v '^ *+' conftest.er1 >conftest.err
13117
  rm -f conftest.er1
13118
  cat conftest.err >&5
13119
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13120
  (exit $ac_status); } &&
13121
         { ac_try='test -z "$ac_c_werror_flag"
13122
                         || test ! -s conftest.err'
13123
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13124
  (eval $ac_try) 2>&5
13125
  ac_status=$?
13126
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13127
  (exit $ac_status); }; } &&
13128
         { ac_try='test -s conftest$ac_exeext'
13129
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13130
  (eval $ac_try) 2>&5
13131
  ac_status=$?
13132
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13133
  (exit $ac_status); }; }; then
13134
  ac_cv_lib_m_cos=yes
13135
else
13136
  echo "$as_me: failed program was:" >&5
13137
sed 's/^/| /' conftest.$ac_ext >&5
13138
 
13139
ac_cv_lib_m_cos=no
13140
fi
13141
rm -f conftest.err conftest.$ac_objext \
13142
      conftest$ac_exeext conftest.$ac_ext
13143
LIBS=$ac_check_lib_save_LIBS
13144
fi
13145
echo "$as_me:$LINENO: result: $ac_cv_lib_m_cos" >&5
13146
echo "${ECHO_T}$ac_cv_lib_m_cos" >&6
13147
if test $ac_cv_lib_m_cos = yes; then
13148
 
13149
cat >>confdefs.h <<\_ACEOF
13150
#define HAVE_COS 1
13151
_ACEOF
13152
 
13153
fi
13154
 
13155
echo "$as_me:$LINENO: checking for cosl in -lm" >&5
13156
echo $ECHO_N "checking for cosl in -lm... $ECHO_C" >&6
13157
if test "${ac_cv_lib_m_cosl+set}" = set; then
13158
  echo $ECHO_N "(cached) $ECHO_C" >&6
13159
else
13160
  ac_check_lib_save_LIBS=$LIBS
13161
LIBS="-lm  $LIBS"
13162
if test x$gcc_no_link = xyes; then
13163
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13164
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13165
   { (exit 1); exit 1; }; }
13166
fi
13167
cat >conftest.$ac_ext <<_ACEOF
13168
/* confdefs.h.  */
13169
_ACEOF
13170
cat confdefs.h >>conftest.$ac_ext
13171
cat >>conftest.$ac_ext <<_ACEOF
13172
/* end confdefs.h.  */
13173
 
13174
/* Override any gcc2 internal prototype to avoid an error.  */
13175
#ifdef __cplusplus
13176
extern "C"
13177
#endif
13178
/* We use char because int might match the return type of a gcc2
13179
   builtin and then its argument prototype would still apply.  */
13180
char cosl ();
13181
int
13182
main ()
13183
{
13184
cosl ();
13185
  ;
13186
  return 0;
13187
}
13188
_ACEOF
13189
rm -f conftest.$ac_objext conftest$ac_exeext
13190
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13191
  (eval $ac_link) 2>conftest.er1
13192
  ac_status=$?
13193
  grep -v '^ *+' conftest.er1 >conftest.err
13194
  rm -f conftest.er1
13195
  cat conftest.err >&5
13196
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13197
  (exit $ac_status); } &&
13198
         { ac_try='test -z "$ac_c_werror_flag"
13199
                         || test ! -s conftest.err'
13200
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13201
  (eval $ac_try) 2>&5
13202
  ac_status=$?
13203
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13204
  (exit $ac_status); }; } &&
13205
         { ac_try='test -s conftest$ac_exeext'
13206
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13207
  (eval $ac_try) 2>&5
13208
  ac_status=$?
13209
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13210
  (exit $ac_status); }; }; then
13211
  ac_cv_lib_m_cosl=yes
13212
else
13213
  echo "$as_me: failed program was:" >&5
13214
sed 's/^/| /' conftest.$ac_ext >&5
13215
 
13216
ac_cv_lib_m_cosl=no
13217
fi
13218
rm -f conftest.err conftest.$ac_objext \
13219
      conftest$ac_exeext conftest.$ac_ext
13220
LIBS=$ac_check_lib_save_LIBS
13221
fi
13222
echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosl" >&5
13223
echo "${ECHO_T}$ac_cv_lib_m_cosl" >&6
13224
if test $ac_cv_lib_m_cosl = yes; then
13225
 
13226
cat >>confdefs.h <<\_ACEOF
13227
#define HAVE_COSL 1
13228
_ACEOF
13229
 
13230
fi
13231
 
13232
echo "$as_me:$LINENO: checking for ccosf in -lm" >&5
13233
echo $ECHO_N "checking for ccosf in -lm... $ECHO_C" >&6
13234
if test "${ac_cv_lib_m_ccosf+set}" = set; then
13235
  echo $ECHO_N "(cached) $ECHO_C" >&6
13236
else
13237
  ac_check_lib_save_LIBS=$LIBS
13238
LIBS="-lm  $LIBS"
13239
if test x$gcc_no_link = xyes; then
13240
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13241
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13242
   { (exit 1); exit 1; }; }
13243
fi
13244
cat >conftest.$ac_ext <<_ACEOF
13245
/* confdefs.h.  */
13246
_ACEOF
13247
cat confdefs.h >>conftest.$ac_ext
13248
cat >>conftest.$ac_ext <<_ACEOF
13249
/* end confdefs.h.  */
13250
 
13251
/* Override any gcc2 internal prototype to avoid an error.  */
13252
#ifdef __cplusplus
13253
extern "C"
13254
#endif
13255
/* We use char because int might match the return type of a gcc2
13256
   builtin and then its argument prototype would still apply.  */
13257
char ccosf ();
13258
int
13259
main ()
13260
{
13261
ccosf ();
13262
  ;
13263
  return 0;
13264
}
13265
_ACEOF
13266
rm -f conftest.$ac_objext conftest$ac_exeext
13267
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13268
  (eval $ac_link) 2>conftest.er1
13269
  ac_status=$?
13270
  grep -v '^ *+' conftest.er1 >conftest.err
13271
  rm -f conftest.er1
13272
  cat conftest.err >&5
13273
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13274
  (exit $ac_status); } &&
13275
         { ac_try='test -z "$ac_c_werror_flag"
13276
                         || test ! -s conftest.err'
13277
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13278
  (eval $ac_try) 2>&5
13279
  ac_status=$?
13280
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13281
  (exit $ac_status); }; } &&
13282
         { ac_try='test -s conftest$ac_exeext'
13283
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13284
  (eval $ac_try) 2>&5
13285
  ac_status=$?
13286
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13287
  (exit $ac_status); }; }; then
13288
  ac_cv_lib_m_ccosf=yes
13289
else
13290
  echo "$as_me: failed program was:" >&5
13291
sed 's/^/| /' conftest.$ac_ext >&5
13292
 
13293
ac_cv_lib_m_ccosf=no
13294
fi
13295
rm -f conftest.err conftest.$ac_objext \
13296
      conftest$ac_exeext conftest.$ac_ext
13297
LIBS=$ac_check_lib_save_LIBS
13298
fi
13299
echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosf" >&5
13300
echo "${ECHO_T}$ac_cv_lib_m_ccosf" >&6
13301
if test $ac_cv_lib_m_ccosf = yes; then
13302
 
13303
cat >>confdefs.h <<\_ACEOF
13304
#define HAVE_CCOSF 1
13305
_ACEOF
13306
 
13307
fi
13308
 
13309
echo "$as_me:$LINENO: checking for ccos in -lm" >&5
13310
echo $ECHO_N "checking for ccos in -lm... $ECHO_C" >&6
13311
if test "${ac_cv_lib_m_ccos+set}" = set; then
13312
  echo $ECHO_N "(cached) $ECHO_C" >&6
13313
else
13314
  ac_check_lib_save_LIBS=$LIBS
13315
LIBS="-lm  $LIBS"
13316
if test x$gcc_no_link = xyes; then
13317
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13318
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13319
   { (exit 1); exit 1; }; }
13320
fi
13321
cat >conftest.$ac_ext <<_ACEOF
13322
/* confdefs.h.  */
13323
_ACEOF
13324
cat confdefs.h >>conftest.$ac_ext
13325
cat >>conftest.$ac_ext <<_ACEOF
13326
/* end confdefs.h.  */
13327
 
13328
/* Override any gcc2 internal prototype to avoid an error.  */
13329
#ifdef __cplusplus
13330
extern "C"
13331
#endif
13332
/* We use char because int might match the return type of a gcc2
13333
   builtin and then its argument prototype would still apply.  */
13334
char ccos ();
13335
int
13336
main ()
13337
{
13338
ccos ();
13339
  ;
13340
  return 0;
13341
}
13342
_ACEOF
13343
rm -f conftest.$ac_objext conftest$ac_exeext
13344
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13345
  (eval $ac_link) 2>conftest.er1
13346
  ac_status=$?
13347
  grep -v '^ *+' conftest.er1 >conftest.err
13348
  rm -f conftest.er1
13349
  cat conftest.err >&5
13350
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13351
  (exit $ac_status); } &&
13352
         { ac_try='test -z "$ac_c_werror_flag"
13353
                         || test ! -s conftest.err'
13354
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13355
  (eval $ac_try) 2>&5
13356
  ac_status=$?
13357
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13358
  (exit $ac_status); }; } &&
13359
         { ac_try='test -s conftest$ac_exeext'
13360
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13361
  (eval $ac_try) 2>&5
13362
  ac_status=$?
13363
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13364
  (exit $ac_status); }; }; then
13365
  ac_cv_lib_m_ccos=yes
13366
else
13367
  echo "$as_me: failed program was:" >&5
13368
sed 's/^/| /' conftest.$ac_ext >&5
13369
 
13370
ac_cv_lib_m_ccos=no
13371
fi
13372
rm -f conftest.err conftest.$ac_objext \
13373
      conftest$ac_exeext conftest.$ac_ext
13374
LIBS=$ac_check_lib_save_LIBS
13375
fi
13376
echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccos" >&5
13377
echo "${ECHO_T}$ac_cv_lib_m_ccos" >&6
13378
if test $ac_cv_lib_m_ccos = yes; then
13379
 
13380
cat >>confdefs.h <<\_ACEOF
13381
#define HAVE_CCOS 1
13382
_ACEOF
13383
 
13384
fi
13385
 
13386
echo "$as_me:$LINENO: checking for ccosl in -lm" >&5
13387
echo $ECHO_N "checking for ccosl in -lm... $ECHO_C" >&6
13388
if test "${ac_cv_lib_m_ccosl+set}" = set; then
13389
  echo $ECHO_N "(cached) $ECHO_C" >&6
13390
else
13391
  ac_check_lib_save_LIBS=$LIBS
13392
LIBS="-lm  $LIBS"
13393
if test x$gcc_no_link = xyes; then
13394
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13395
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13396
   { (exit 1); exit 1; }; }
13397
fi
13398
cat >conftest.$ac_ext <<_ACEOF
13399
/* confdefs.h.  */
13400
_ACEOF
13401
cat confdefs.h >>conftest.$ac_ext
13402
cat >>conftest.$ac_ext <<_ACEOF
13403
/* end confdefs.h.  */
13404
 
13405
/* Override any gcc2 internal prototype to avoid an error.  */
13406
#ifdef __cplusplus
13407
extern "C"
13408
#endif
13409
/* We use char because int might match the return type of a gcc2
13410
   builtin and then its argument prototype would still apply.  */
13411
char ccosl ();
13412
int
13413
main ()
13414
{
13415
ccosl ();
13416
  ;
13417
  return 0;
13418
}
13419
_ACEOF
13420
rm -f conftest.$ac_objext conftest$ac_exeext
13421
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13422
  (eval $ac_link) 2>conftest.er1
13423
  ac_status=$?
13424
  grep -v '^ *+' conftest.er1 >conftest.err
13425
  rm -f conftest.er1
13426
  cat conftest.err >&5
13427
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13428
  (exit $ac_status); } &&
13429
         { ac_try='test -z "$ac_c_werror_flag"
13430
                         || test ! -s conftest.err'
13431
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13432
  (eval $ac_try) 2>&5
13433
  ac_status=$?
13434
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13435
  (exit $ac_status); }; } &&
13436
         { ac_try='test -s conftest$ac_exeext'
13437
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13438
  (eval $ac_try) 2>&5
13439
  ac_status=$?
13440
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13441
  (exit $ac_status); }; }; then
13442
  ac_cv_lib_m_ccosl=yes
13443
else
13444
  echo "$as_me: failed program was:" >&5
13445
sed 's/^/| /' conftest.$ac_ext >&5
13446
 
13447
ac_cv_lib_m_ccosl=no
13448
fi
13449
rm -f conftest.err conftest.$ac_objext \
13450
      conftest$ac_exeext conftest.$ac_ext
13451
LIBS=$ac_check_lib_save_LIBS
13452
fi
13453
echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosl" >&5
13454
echo "${ECHO_T}$ac_cv_lib_m_ccosl" >&6
13455
if test $ac_cv_lib_m_ccosl = yes; then
13456
 
13457
cat >>confdefs.h <<\_ACEOF
13458
#define HAVE_CCOSL 1
13459
_ACEOF
13460
 
13461
fi
13462
 
13463
echo "$as_me:$LINENO: checking for coshf in -lm" >&5
13464
echo $ECHO_N "checking for coshf in -lm... $ECHO_C" >&6
13465
if test "${ac_cv_lib_m_coshf+set}" = set; then
13466
  echo $ECHO_N "(cached) $ECHO_C" >&6
13467
else
13468
  ac_check_lib_save_LIBS=$LIBS
13469
LIBS="-lm  $LIBS"
13470
if test x$gcc_no_link = xyes; then
13471
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13472
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13473
   { (exit 1); exit 1; }; }
13474
fi
13475
cat >conftest.$ac_ext <<_ACEOF
13476
/* confdefs.h.  */
13477
_ACEOF
13478
cat confdefs.h >>conftest.$ac_ext
13479
cat >>conftest.$ac_ext <<_ACEOF
13480
/* end confdefs.h.  */
13481
 
13482
/* Override any gcc2 internal prototype to avoid an error.  */
13483
#ifdef __cplusplus
13484
extern "C"
13485
#endif
13486
/* We use char because int might match the return type of a gcc2
13487
   builtin and then its argument prototype would still apply.  */
13488
char coshf ();
13489
int
13490
main ()
13491
{
13492
coshf ();
13493
  ;
13494
  return 0;
13495
}
13496
_ACEOF
13497
rm -f conftest.$ac_objext conftest$ac_exeext
13498
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13499
  (eval $ac_link) 2>conftest.er1
13500
  ac_status=$?
13501
  grep -v '^ *+' conftest.er1 >conftest.err
13502
  rm -f conftest.er1
13503
  cat conftest.err >&5
13504
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13505
  (exit $ac_status); } &&
13506
         { ac_try='test -z "$ac_c_werror_flag"
13507
                         || test ! -s conftest.err'
13508
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13509
  (eval $ac_try) 2>&5
13510
  ac_status=$?
13511
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13512
  (exit $ac_status); }; } &&
13513
         { ac_try='test -s conftest$ac_exeext'
13514
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13515
  (eval $ac_try) 2>&5
13516
  ac_status=$?
13517
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13518
  (exit $ac_status); }; }; then
13519
  ac_cv_lib_m_coshf=yes
13520
else
13521
  echo "$as_me: failed program was:" >&5
13522
sed 's/^/| /' conftest.$ac_ext >&5
13523
 
13524
ac_cv_lib_m_coshf=no
13525
fi
13526
rm -f conftest.err conftest.$ac_objext \
13527
      conftest$ac_exeext conftest.$ac_ext
13528
LIBS=$ac_check_lib_save_LIBS
13529
fi
13530
echo "$as_me:$LINENO: result: $ac_cv_lib_m_coshf" >&5
13531
echo "${ECHO_T}$ac_cv_lib_m_coshf" >&6
13532
if test $ac_cv_lib_m_coshf = yes; then
13533
 
13534
cat >>confdefs.h <<\_ACEOF
13535
#define HAVE_COSHF 1
13536
_ACEOF
13537
 
13538
fi
13539
 
13540
echo "$as_me:$LINENO: checking for cosh in -lm" >&5
13541
echo $ECHO_N "checking for cosh in -lm... $ECHO_C" >&6
13542
if test "${ac_cv_lib_m_cosh+set}" = set; then
13543
  echo $ECHO_N "(cached) $ECHO_C" >&6
13544
else
13545
  ac_check_lib_save_LIBS=$LIBS
13546
LIBS="-lm  $LIBS"
13547
if test x$gcc_no_link = xyes; then
13548
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13549
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13550
   { (exit 1); exit 1; }; }
13551
fi
13552
cat >conftest.$ac_ext <<_ACEOF
13553
/* confdefs.h.  */
13554
_ACEOF
13555
cat confdefs.h >>conftest.$ac_ext
13556
cat >>conftest.$ac_ext <<_ACEOF
13557
/* end confdefs.h.  */
13558
 
13559
/* Override any gcc2 internal prototype to avoid an error.  */
13560
#ifdef __cplusplus
13561
extern "C"
13562
#endif
13563
/* We use char because int might match the return type of a gcc2
13564
   builtin and then its argument prototype would still apply.  */
13565
char cosh ();
13566
int
13567
main ()
13568
{
13569
cosh ();
13570
  ;
13571
  return 0;
13572
}
13573
_ACEOF
13574
rm -f conftest.$ac_objext conftest$ac_exeext
13575
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13576
  (eval $ac_link) 2>conftest.er1
13577
  ac_status=$?
13578
  grep -v '^ *+' conftest.er1 >conftest.err
13579
  rm -f conftest.er1
13580
  cat conftest.err >&5
13581
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13582
  (exit $ac_status); } &&
13583
         { ac_try='test -z "$ac_c_werror_flag"
13584
                         || test ! -s conftest.err'
13585
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13586
  (eval $ac_try) 2>&5
13587
  ac_status=$?
13588
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13589
  (exit $ac_status); }; } &&
13590
         { ac_try='test -s conftest$ac_exeext'
13591
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13592
  (eval $ac_try) 2>&5
13593
  ac_status=$?
13594
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13595
  (exit $ac_status); }; }; then
13596
  ac_cv_lib_m_cosh=yes
13597
else
13598
  echo "$as_me: failed program was:" >&5
13599
sed 's/^/| /' conftest.$ac_ext >&5
13600
 
13601
ac_cv_lib_m_cosh=no
13602
fi
13603
rm -f conftest.err conftest.$ac_objext \
13604
      conftest$ac_exeext conftest.$ac_ext
13605
LIBS=$ac_check_lib_save_LIBS
13606
fi
13607
echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosh" >&5
13608
echo "${ECHO_T}$ac_cv_lib_m_cosh" >&6
13609
if test $ac_cv_lib_m_cosh = yes; then
13610
 
13611
cat >>confdefs.h <<\_ACEOF
13612
#define HAVE_COSH 1
13613
_ACEOF
13614
 
13615
fi
13616
 
13617
echo "$as_me:$LINENO: checking for coshl in -lm" >&5
13618
echo $ECHO_N "checking for coshl in -lm... $ECHO_C" >&6
13619
if test "${ac_cv_lib_m_coshl+set}" = set; then
13620
  echo $ECHO_N "(cached) $ECHO_C" >&6
13621
else
13622
  ac_check_lib_save_LIBS=$LIBS
13623
LIBS="-lm  $LIBS"
13624
if test x$gcc_no_link = xyes; then
13625
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13626
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13627
   { (exit 1); exit 1; }; }
13628
fi
13629
cat >conftest.$ac_ext <<_ACEOF
13630
/* confdefs.h.  */
13631
_ACEOF
13632
cat confdefs.h >>conftest.$ac_ext
13633
cat >>conftest.$ac_ext <<_ACEOF
13634
/* end confdefs.h.  */
13635
 
13636
/* Override any gcc2 internal prototype to avoid an error.  */
13637
#ifdef __cplusplus
13638
extern "C"
13639
#endif
13640
/* We use char because int might match the return type of a gcc2
13641
   builtin and then its argument prototype would still apply.  */
13642
char coshl ();
13643
int
13644
main ()
13645
{
13646
coshl ();
13647
  ;
13648
  return 0;
13649
}
13650
_ACEOF
13651
rm -f conftest.$ac_objext conftest$ac_exeext
13652
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13653
  (eval $ac_link) 2>conftest.er1
13654
  ac_status=$?
13655
  grep -v '^ *+' conftest.er1 >conftest.err
13656
  rm -f conftest.er1
13657
  cat conftest.err >&5
13658
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13659
  (exit $ac_status); } &&
13660
         { ac_try='test -z "$ac_c_werror_flag"
13661
                         || test ! -s conftest.err'
13662
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13663
  (eval $ac_try) 2>&5
13664
  ac_status=$?
13665
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13666
  (exit $ac_status); }; } &&
13667
         { ac_try='test -s conftest$ac_exeext'
13668
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13669
  (eval $ac_try) 2>&5
13670
  ac_status=$?
13671
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13672
  (exit $ac_status); }; }; then
13673
  ac_cv_lib_m_coshl=yes
13674
else
13675
  echo "$as_me: failed program was:" >&5
13676
sed 's/^/| /' conftest.$ac_ext >&5
13677
 
13678
ac_cv_lib_m_coshl=no
13679
fi
13680
rm -f conftest.err conftest.$ac_objext \
13681
      conftest$ac_exeext conftest.$ac_ext
13682
LIBS=$ac_check_lib_save_LIBS
13683
fi
13684
echo "$as_me:$LINENO: result: $ac_cv_lib_m_coshl" >&5
13685
echo "${ECHO_T}$ac_cv_lib_m_coshl" >&6
13686
if test $ac_cv_lib_m_coshl = yes; then
13687
 
13688
cat >>confdefs.h <<\_ACEOF
13689
#define HAVE_COSHL 1
13690
_ACEOF
13691
 
13692
fi
13693
 
13694
echo "$as_me:$LINENO: checking for ccoshf in -lm" >&5
13695
echo $ECHO_N "checking for ccoshf in -lm... $ECHO_C" >&6
13696
if test "${ac_cv_lib_m_ccoshf+set}" = set; then
13697
  echo $ECHO_N "(cached) $ECHO_C" >&6
13698
else
13699
  ac_check_lib_save_LIBS=$LIBS
13700
LIBS="-lm  $LIBS"
13701
if test x$gcc_no_link = xyes; then
13702
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13703
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13704
   { (exit 1); exit 1; }; }
13705
fi
13706
cat >conftest.$ac_ext <<_ACEOF
13707
/* confdefs.h.  */
13708
_ACEOF
13709
cat confdefs.h >>conftest.$ac_ext
13710
cat >>conftest.$ac_ext <<_ACEOF
13711
/* end confdefs.h.  */
13712
 
13713
/* Override any gcc2 internal prototype to avoid an error.  */
13714
#ifdef __cplusplus
13715
extern "C"
13716
#endif
13717
/* We use char because int might match the return type of a gcc2
13718
   builtin and then its argument prototype would still apply.  */
13719
char ccoshf ();
13720
int
13721
main ()
13722
{
13723
ccoshf ();
13724
  ;
13725
  return 0;
13726
}
13727
_ACEOF
13728
rm -f conftest.$ac_objext conftest$ac_exeext
13729
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13730
  (eval $ac_link) 2>conftest.er1
13731
  ac_status=$?
13732
  grep -v '^ *+' conftest.er1 >conftest.err
13733
  rm -f conftest.er1
13734
  cat conftest.err >&5
13735
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13736
  (exit $ac_status); } &&
13737
         { ac_try='test -z "$ac_c_werror_flag"
13738
                         || test ! -s conftest.err'
13739
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13740
  (eval $ac_try) 2>&5
13741
  ac_status=$?
13742
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13743
  (exit $ac_status); }; } &&
13744
         { ac_try='test -s conftest$ac_exeext'
13745
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13746
  (eval $ac_try) 2>&5
13747
  ac_status=$?
13748
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13749
  (exit $ac_status); }; }; then
13750
  ac_cv_lib_m_ccoshf=yes
13751
else
13752
  echo "$as_me: failed program was:" >&5
13753
sed 's/^/| /' conftest.$ac_ext >&5
13754
 
13755
ac_cv_lib_m_ccoshf=no
13756
fi
13757
rm -f conftest.err conftest.$ac_objext \
13758
      conftest$ac_exeext conftest.$ac_ext
13759
LIBS=$ac_check_lib_save_LIBS
13760
fi
13761
echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccoshf" >&5
13762
echo "${ECHO_T}$ac_cv_lib_m_ccoshf" >&6
13763
if test $ac_cv_lib_m_ccoshf = yes; then
13764
 
13765
cat >>confdefs.h <<\_ACEOF
13766
#define HAVE_CCOSHF 1
13767
_ACEOF
13768
 
13769
fi
13770
 
13771
echo "$as_me:$LINENO: checking for ccosh in -lm" >&5
13772
echo $ECHO_N "checking for ccosh in -lm... $ECHO_C" >&6
13773
if test "${ac_cv_lib_m_ccosh+set}" = set; then
13774
  echo $ECHO_N "(cached) $ECHO_C" >&6
13775
else
13776
  ac_check_lib_save_LIBS=$LIBS
13777
LIBS="-lm  $LIBS"
13778
if test x$gcc_no_link = xyes; then
13779
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13780
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13781
   { (exit 1); exit 1; }; }
13782
fi
13783
cat >conftest.$ac_ext <<_ACEOF
13784
/* confdefs.h.  */
13785
_ACEOF
13786
cat confdefs.h >>conftest.$ac_ext
13787
cat >>conftest.$ac_ext <<_ACEOF
13788
/* end confdefs.h.  */
13789
 
13790
/* Override any gcc2 internal prototype to avoid an error.  */
13791
#ifdef __cplusplus
13792
extern "C"
13793
#endif
13794
/* We use char because int might match the return type of a gcc2
13795
   builtin and then its argument prototype would still apply.  */
13796
char ccosh ();
13797
int
13798
main ()
13799
{
13800
ccosh ();
13801
  ;
13802
  return 0;
13803
}
13804
_ACEOF
13805
rm -f conftest.$ac_objext conftest$ac_exeext
13806
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13807
  (eval $ac_link) 2>conftest.er1
13808
  ac_status=$?
13809
  grep -v '^ *+' conftest.er1 >conftest.err
13810
  rm -f conftest.er1
13811
  cat conftest.err >&5
13812
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13813
  (exit $ac_status); } &&
13814
         { ac_try='test -z "$ac_c_werror_flag"
13815
                         || test ! -s conftest.err'
13816
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13817
  (eval $ac_try) 2>&5
13818
  ac_status=$?
13819
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13820
  (exit $ac_status); }; } &&
13821
         { ac_try='test -s conftest$ac_exeext'
13822
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13823
  (eval $ac_try) 2>&5
13824
  ac_status=$?
13825
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13826
  (exit $ac_status); }; }; then
13827
  ac_cv_lib_m_ccosh=yes
13828
else
13829
  echo "$as_me: failed program was:" >&5
13830
sed 's/^/| /' conftest.$ac_ext >&5
13831
 
13832
ac_cv_lib_m_ccosh=no
13833
fi
13834
rm -f conftest.err conftest.$ac_objext \
13835
      conftest$ac_exeext conftest.$ac_ext
13836
LIBS=$ac_check_lib_save_LIBS
13837
fi
13838
echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosh" >&5
13839
echo "${ECHO_T}$ac_cv_lib_m_ccosh" >&6
13840
if test $ac_cv_lib_m_ccosh = yes; then
13841
 
13842
cat >>confdefs.h <<\_ACEOF
13843
#define HAVE_CCOSH 1
13844
_ACEOF
13845
 
13846
fi
13847
 
13848
echo "$as_me:$LINENO: checking for ccoshl in -lm" >&5
13849
echo $ECHO_N "checking for ccoshl in -lm... $ECHO_C" >&6
13850
if test "${ac_cv_lib_m_ccoshl+set}" = set; then
13851
  echo $ECHO_N "(cached) $ECHO_C" >&6
13852
else
13853
  ac_check_lib_save_LIBS=$LIBS
13854
LIBS="-lm  $LIBS"
13855
if test x$gcc_no_link = xyes; then
13856
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13857
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13858
   { (exit 1); exit 1; }; }
13859
fi
13860
cat >conftest.$ac_ext <<_ACEOF
13861
/* confdefs.h.  */
13862
_ACEOF
13863
cat confdefs.h >>conftest.$ac_ext
13864
cat >>conftest.$ac_ext <<_ACEOF
13865
/* end confdefs.h.  */
13866
 
13867
/* Override any gcc2 internal prototype to avoid an error.  */
13868
#ifdef __cplusplus
13869
extern "C"
13870
#endif
13871
/* We use char because int might match the return type of a gcc2
13872
   builtin and then its argument prototype would still apply.  */
13873
char ccoshl ();
13874
int
13875
main ()
13876
{
13877
ccoshl ();
13878
  ;
13879
  return 0;
13880
}
13881
_ACEOF
13882
rm -f conftest.$ac_objext conftest$ac_exeext
13883
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13884
  (eval $ac_link) 2>conftest.er1
13885
  ac_status=$?
13886
  grep -v '^ *+' conftest.er1 >conftest.err
13887
  rm -f conftest.er1
13888
  cat conftest.err >&5
13889
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13890
  (exit $ac_status); } &&
13891
         { ac_try='test -z "$ac_c_werror_flag"
13892
                         || test ! -s conftest.err'
13893
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13894
  (eval $ac_try) 2>&5
13895
  ac_status=$?
13896
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13897
  (exit $ac_status); }; } &&
13898
         { ac_try='test -s conftest$ac_exeext'
13899
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13900
  (eval $ac_try) 2>&5
13901
  ac_status=$?
13902
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13903
  (exit $ac_status); }; }; then
13904
  ac_cv_lib_m_ccoshl=yes
13905
else
13906
  echo "$as_me: failed program was:" >&5
13907
sed 's/^/| /' conftest.$ac_ext >&5
13908
 
13909
ac_cv_lib_m_ccoshl=no
13910
fi
13911
rm -f conftest.err conftest.$ac_objext \
13912
      conftest$ac_exeext conftest.$ac_ext
13913
LIBS=$ac_check_lib_save_LIBS
13914
fi
13915
echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccoshl" >&5
13916
echo "${ECHO_T}$ac_cv_lib_m_ccoshl" >&6
13917
if test $ac_cv_lib_m_ccoshl = yes; then
13918
 
13919
cat >>confdefs.h <<\_ACEOF
13920
#define HAVE_CCOSHL 1
13921
_ACEOF
13922
 
13923
fi
13924
 
13925
echo "$as_me:$LINENO: checking for expf in -lm" >&5
13926
echo $ECHO_N "checking for expf in -lm... $ECHO_C" >&6
13927
if test "${ac_cv_lib_m_expf+set}" = set; then
13928
  echo $ECHO_N "(cached) $ECHO_C" >&6
13929
else
13930
  ac_check_lib_save_LIBS=$LIBS
13931
LIBS="-lm  $LIBS"
13932
if test x$gcc_no_link = xyes; then
13933
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13934
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13935
   { (exit 1); exit 1; }; }
13936
fi
13937
cat >conftest.$ac_ext <<_ACEOF
13938
/* confdefs.h.  */
13939
_ACEOF
13940
cat confdefs.h >>conftest.$ac_ext
13941
cat >>conftest.$ac_ext <<_ACEOF
13942
/* end confdefs.h.  */
13943
 
13944
/* Override any gcc2 internal prototype to avoid an error.  */
13945
#ifdef __cplusplus
13946
extern "C"
13947
#endif
13948
/* We use char because int might match the return type of a gcc2
13949
   builtin and then its argument prototype would still apply.  */
13950
char expf ();
13951
int
13952
main ()
13953
{
13954
expf ();
13955
  ;
13956
  return 0;
13957
}
13958
_ACEOF
13959
rm -f conftest.$ac_objext conftest$ac_exeext
13960
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13961
  (eval $ac_link) 2>conftest.er1
13962
  ac_status=$?
13963
  grep -v '^ *+' conftest.er1 >conftest.err
13964
  rm -f conftest.er1
13965
  cat conftest.err >&5
13966
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13967
  (exit $ac_status); } &&
13968
         { ac_try='test -z "$ac_c_werror_flag"
13969
                         || test ! -s conftest.err'
13970
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13971
  (eval $ac_try) 2>&5
13972
  ac_status=$?
13973
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13974
  (exit $ac_status); }; } &&
13975
         { ac_try='test -s conftest$ac_exeext'
13976
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13977
  (eval $ac_try) 2>&5
13978
  ac_status=$?
13979
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13980
  (exit $ac_status); }; }; then
13981
  ac_cv_lib_m_expf=yes
13982
else
13983
  echo "$as_me: failed program was:" >&5
13984
sed 's/^/| /' conftest.$ac_ext >&5
13985
 
13986
ac_cv_lib_m_expf=no
13987
fi
13988
rm -f conftest.err conftest.$ac_objext \
13989
      conftest$ac_exeext conftest.$ac_ext
13990
LIBS=$ac_check_lib_save_LIBS
13991
fi
13992
echo "$as_me:$LINENO: result: $ac_cv_lib_m_expf" >&5
13993
echo "${ECHO_T}$ac_cv_lib_m_expf" >&6
13994
if test $ac_cv_lib_m_expf = yes; then
13995
 
13996
cat >>confdefs.h <<\_ACEOF
13997
#define HAVE_EXPF 1
13998
_ACEOF
13999
 
14000
fi
14001
 
14002
echo "$as_me:$LINENO: checking for exp in -lm" >&5
14003
echo $ECHO_N "checking for exp in -lm... $ECHO_C" >&6
14004
if test "${ac_cv_lib_m_exp+set}" = set; then
14005
  echo $ECHO_N "(cached) $ECHO_C" >&6
14006
else
14007
  ac_check_lib_save_LIBS=$LIBS
14008
LIBS="-lm  $LIBS"
14009
if test x$gcc_no_link = xyes; then
14010
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14011
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14012
   { (exit 1); exit 1; }; }
14013
fi
14014
cat >conftest.$ac_ext <<_ACEOF
14015
/* confdefs.h.  */
14016
_ACEOF
14017
cat confdefs.h >>conftest.$ac_ext
14018
cat >>conftest.$ac_ext <<_ACEOF
14019
/* end confdefs.h.  */
14020
 
14021
/* Override any gcc2 internal prototype to avoid an error.  */
14022
#ifdef __cplusplus
14023
extern "C"
14024
#endif
14025
/* We use char because int might match the return type of a gcc2
14026
   builtin and then its argument prototype would still apply.  */
14027
char exp ();
14028
int
14029
main ()
14030
{
14031
exp ();
14032
  ;
14033
  return 0;
14034
}
14035
_ACEOF
14036
rm -f conftest.$ac_objext conftest$ac_exeext
14037
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14038
  (eval $ac_link) 2>conftest.er1
14039
  ac_status=$?
14040
  grep -v '^ *+' conftest.er1 >conftest.err
14041
  rm -f conftest.er1
14042
  cat conftest.err >&5
14043
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14044
  (exit $ac_status); } &&
14045
         { ac_try='test -z "$ac_c_werror_flag"
14046
                         || test ! -s conftest.err'
14047
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14048
  (eval $ac_try) 2>&5
14049
  ac_status=$?
14050
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14051
  (exit $ac_status); }; } &&
14052
         { ac_try='test -s conftest$ac_exeext'
14053
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14054
  (eval $ac_try) 2>&5
14055
  ac_status=$?
14056
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14057
  (exit $ac_status); }; }; then
14058
  ac_cv_lib_m_exp=yes
14059
else
14060
  echo "$as_me: failed program was:" >&5
14061
sed 's/^/| /' conftest.$ac_ext >&5
14062
 
14063
ac_cv_lib_m_exp=no
14064
fi
14065
rm -f conftest.err conftest.$ac_objext \
14066
      conftest$ac_exeext conftest.$ac_ext
14067
LIBS=$ac_check_lib_save_LIBS
14068
fi
14069
echo "$as_me:$LINENO: result: $ac_cv_lib_m_exp" >&5
14070
echo "${ECHO_T}$ac_cv_lib_m_exp" >&6
14071
if test $ac_cv_lib_m_exp = yes; then
14072
 
14073
cat >>confdefs.h <<\_ACEOF
14074
#define HAVE_EXP 1
14075
_ACEOF
14076
 
14077
fi
14078
 
14079
echo "$as_me:$LINENO: checking for expl in -lm" >&5
14080
echo $ECHO_N "checking for expl in -lm... $ECHO_C" >&6
14081
if test "${ac_cv_lib_m_expl+set}" = set; then
14082
  echo $ECHO_N "(cached) $ECHO_C" >&6
14083
else
14084
  ac_check_lib_save_LIBS=$LIBS
14085
LIBS="-lm  $LIBS"
14086
if test x$gcc_no_link = xyes; then
14087
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14088
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14089
   { (exit 1); exit 1; }; }
14090
fi
14091
cat >conftest.$ac_ext <<_ACEOF
14092
/* confdefs.h.  */
14093
_ACEOF
14094
cat confdefs.h >>conftest.$ac_ext
14095
cat >>conftest.$ac_ext <<_ACEOF
14096
/* end confdefs.h.  */
14097
 
14098
/* Override any gcc2 internal prototype to avoid an error.  */
14099
#ifdef __cplusplus
14100
extern "C"
14101
#endif
14102
/* We use char because int might match the return type of a gcc2
14103
   builtin and then its argument prototype would still apply.  */
14104
char expl ();
14105
int
14106
main ()
14107
{
14108
expl ();
14109
  ;
14110
  return 0;
14111
}
14112
_ACEOF
14113
rm -f conftest.$ac_objext conftest$ac_exeext
14114
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14115
  (eval $ac_link) 2>conftest.er1
14116
  ac_status=$?
14117
  grep -v '^ *+' conftest.er1 >conftest.err
14118
  rm -f conftest.er1
14119
  cat conftest.err >&5
14120
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14121
  (exit $ac_status); } &&
14122
         { ac_try='test -z "$ac_c_werror_flag"
14123
                         || test ! -s conftest.err'
14124
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14125
  (eval $ac_try) 2>&5
14126
  ac_status=$?
14127
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14128
  (exit $ac_status); }; } &&
14129
         { ac_try='test -s conftest$ac_exeext'
14130
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14131
  (eval $ac_try) 2>&5
14132
  ac_status=$?
14133
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14134
  (exit $ac_status); }; }; then
14135
  ac_cv_lib_m_expl=yes
14136
else
14137
  echo "$as_me: failed program was:" >&5
14138
sed 's/^/| /' conftest.$ac_ext >&5
14139
 
14140
ac_cv_lib_m_expl=no
14141
fi
14142
rm -f conftest.err conftest.$ac_objext \
14143
      conftest$ac_exeext conftest.$ac_ext
14144
LIBS=$ac_check_lib_save_LIBS
14145
fi
14146
echo "$as_me:$LINENO: result: $ac_cv_lib_m_expl" >&5
14147
echo "${ECHO_T}$ac_cv_lib_m_expl" >&6
14148
if test $ac_cv_lib_m_expl = yes; then
14149
 
14150
cat >>confdefs.h <<\_ACEOF
14151
#define HAVE_EXPL 1
14152
_ACEOF
14153
 
14154
fi
14155
 
14156
echo "$as_me:$LINENO: checking for cexpf in -lm" >&5
14157
echo $ECHO_N "checking for cexpf in -lm... $ECHO_C" >&6
14158
if test "${ac_cv_lib_m_cexpf+set}" = set; then
14159
  echo $ECHO_N "(cached) $ECHO_C" >&6
14160
else
14161
  ac_check_lib_save_LIBS=$LIBS
14162
LIBS="-lm  $LIBS"
14163
if test x$gcc_no_link = xyes; then
14164
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14165
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14166
   { (exit 1); exit 1; }; }
14167
fi
14168
cat >conftest.$ac_ext <<_ACEOF
14169
/* confdefs.h.  */
14170
_ACEOF
14171
cat confdefs.h >>conftest.$ac_ext
14172
cat >>conftest.$ac_ext <<_ACEOF
14173
/* end confdefs.h.  */
14174
 
14175
/* Override any gcc2 internal prototype to avoid an error.  */
14176
#ifdef __cplusplus
14177
extern "C"
14178
#endif
14179
/* We use char because int might match the return type of a gcc2
14180
   builtin and then its argument prototype would still apply.  */
14181
char cexpf ();
14182
int
14183
main ()
14184
{
14185
cexpf ();
14186
  ;
14187
  return 0;
14188
}
14189
_ACEOF
14190
rm -f conftest.$ac_objext conftest$ac_exeext
14191
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14192
  (eval $ac_link) 2>conftest.er1
14193
  ac_status=$?
14194
  grep -v '^ *+' conftest.er1 >conftest.err
14195
  rm -f conftest.er1
14196
  cat conftest.err >&5
14197
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14198
  (exit $ac_status); } &&
14199
         { ac_try='test -z "$ac_c_werror_flag"
14200
                         || test ! -s conftest.err'
14201
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14202
  (eval $ac_try) 2>&5
14203
  ac_status=$?
14204
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14205
  (exit $ac_status); }; } &&
14206
         { ac_try='test -s conftest$ac_exeext'
14207
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14208
  (eval $ac_try) 2>&5
14209
  ac_status=$?
14210
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14211
  (exit $ac_status); }; }; then
14212
  ac_cv_lib_m_cexpf=yes
14213
else
14214
  echo "$as_me: failed program was:" >&5
14215
sed 's/^/| /' conftest.$ac_ext >&5
14216
 
14217
ac_cv_lib_m_cexpf=no
14218
fi
14219
rm -f conftest.err conftest.$ac_objext \
14220
      conftest$ac_exeext conftest.$ac_ext
14221
LIBS=$ac_check_lib_save_LIBS
14222
fi
14223
echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexpf" >&5
14224
echo "${ECHO_T}$ac_cv_lib_m_cexpf" >&6
14225
if test $ac_cv_lib_m_cexpf = yes; then
14226
 
14227
cat >>confdefs.h <<\_ACEOF
14228
#define HAVE_CEXPF 1
14229
_ACEOF
14230
 
14231
fi
14232
 
14233
echo "$as_me:$LINENO: checking for cexp in -lm" >&5
14234
echo $ECHO_N "checking for cexp in -lm... $ECHO_C" >&6
14235
if test "${ac_cv_lib_m_cexp+set}" = set; then
14236
  echo $ECHO_N "(cached) $ECHO_C" >&6
14237
else
14238
  ac_check_lib_save_LIBS=$LIBS
14239
LIBS="-lm  $LIBS"
14240
if test x$gcc_no_link = xyes; then
14241
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14242
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14243
   { (exit 1); exit 1; }; }
14244
fi
14245
cat >conftest.$ac_ext <<_ACEOF
14246
/* confdefs.h.  */
14247
_ACEOF
14248
cat confdefs.h >>conftest.$ac_ext
14249
cat >>conftest.$ac_ext <<_ACEOF
14250
/* end confdefs.h.  */
14251
 
14252
/* Override any gcc2 internal prototype to avoid an error.  */
14253
#ifdef __cplusplus
14254
extern "C"
14255
#endif
14256
/* We use char because int might match the return type of a gcc2
14257
   builtin and then its argument prototype would still apply.  */
14258
char cexp ();
14259
int
14260
main ()
14261
{
14262
cexp ();
14263
  ;
14264
  return 0;
14265
}
14266
_ACEOF
14267
rm -f conftest.$ac_objext conftest$ac_exeext
14268
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14269
  (eval $ac_link) 2>conftest.er1
14270
  ac_status=$?
14271
  grep -v '^ *+' conftest.er1 >conftest.err
14272
  rm -f conftest.er1
14273
  cat conftest.err >&5
14274
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14275
  (exit $ac_status); } &&
14276
         { ac_try='test -z "$ac_c_werror_flag"
14277
                         || test ! -s conftest.err'
14278
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14279
  (eval $ac_try) 2>&5
14280
  ac_status=$?
14281
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14282
  (exit $ac_status); }; } &&
14283
         { ac_try='test -s conftest$ac_exeext'
14284
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14285
  (eval $ac_try) 2>&5
14286
  ac_status=$?
14287
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14288
  (exit $ac_status); }; }; then
14289
  ac_cv_lib_m_cexp=yes
14290
else
14291
  echo "$as_me: failed program was:" >&5
14292
sed 's/^/| /' conftest.$ac_ext >&5
14293
 
14294
ac_cv_lib_m_cexp=no
14295
fi
14296
rm -f conftest.err conftest.$ac_objext \
14297
      conftest$ac_exeext conftest.$ac_ext
14298
LIBS=$ac_check_lib_save_LIBS
14299
fi
14300
echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexp" >&5
14301
echo "${ECHO_T}$ac_cv_lib_m_cexp" >&6
14302
if test $ac_cv_lib_m_cexp = yes; then
14303
 
14304
cat >>confdefs.h <<\_ACEOF
14305
#define HAVE_CEXP 1
14306
_ACEOF
14307
 
14308
fi
14309
 
14310
echo "$as_me:$LINENO: checking for cexpl in -lm" >&5
14311
echo $ECHO_N "checking for cexpl in -lm... $ECHO_C" >&6
14312
if test "${ac_cv_lib_m_cexpl+set}" = set; then
14313
  echo $ECHO_N "(cached) $ECHO_C" >&6
14314
else
14315
  ac_check_lib_save_LIBS=$LIBS
14316
LIBS="-lm  $LIBS"
14317
if test x$gcc_no_link = xyes; then
14318
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14319
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14320
   { (exit 1); exit 1; }; }
14321
fi
14322
cat >conftest.$ac_ext <<_ACEOF
14323
/* confdefs.h.  */
14324
_ACEOF
14325
cat confdefs.h >>conftest.$ac_ext
14326
cat >>conftest.$ac_ext <<_ACEOF
14327
/* end confdefs.h.  */
14328
 
14329
/* Override any gcc2 internal prototype to avoid an error.  */
14330
#ifdef __cplusplus
14331
extern "C"
14332
#endif
14333
/* We use char because int might match the return type of a gcc2
14334
   builtin and then its argument prototype would still apply.  */
14335
char cexpl ();
14336
int
14337
main ()
14338
{
14339
cexpl ();
14340
  ;
14341
  return 0;
14342
}
14343
_ACEOF
14344
rm -f conftest.$ac_objext conftest$ac_exeext
14345
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14346
  (eval $ac_link) 2>conftest.er1
14347
  ac_status=$?
14348
  grep -v '^ *+' conftest.er1 >conftest.err
14349
  rm -f conftest.er1
14350
  cat conftest.err >&5
14351
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14352
  (exit $ac_status); } &&
14353
         { ac_try='test -z "$ac_c_werror_flag"
14354
                         || test ! -s conftest.err'
14355
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14356
  (eval $ac_try) 2>&5
14357
  ac_status=$?
14358
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14359
  (exit $ac_status); }; } &&
14360
         { ac_try='test -s conftest$ac_exeext'
14361
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14362
  (eval $ac_try) 2>&5
14363
  ac_status=$?
14364
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14365
  (exit $ac_status); }; }; then
14366
  ac_cv_lib_m_cexpl=yes
14367
else
14368
  echo "$as_me: failed program was:" >&5
14369
sed 's/^/| /' conftest.$ac_ext >&5
14370
 
14371
ac_cv_lib_m_cexpl=no
14372
fi
14373
rm -f conftest.err conftest.$ac_objext \
14374
      conftest$ac_exeext conftest.$ac_ext
14375
LIBS=$ac_check_lib_save_LIBS
14376
fi
14377
echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexpl" >&5
14378
echo "${ECHO_T}$ac_cv_lib_m_cexpl" >&6
14379
if test $ac_cv_lib_m_cexpl = yes; then
14380
 
14381
cat >>confdefs.h <<\_ACEOF
14382
#define HAVE_CEXPL 1
14383
_ACEOF
14384
 
14385
fi
14386
 
14387
echo "$as_me:$LINENO: checking for fabsf in -lm" >&5
14388
echo $ECHO_N "checking for fabsf in -lm... $ECHO_C" >&6
14389
if test "${ac_cv_lib_m_fabsf+set}" = set; then
14390
  echo $ECHO_N "(cached) $ECHO_C" >&6
14391
else
14392
  ac_check_lib_save_LIBS=$LIBS
14393
LIBS="-lm  $LIBS"
14394
if test x$gcc_no_link = xyes; then
14395
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14396
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14397
   { (exit 1); exit 1; }; }
14398
fi
14399
cat >conftest.$ac_ext <<_ACEOF
14400
/* confdefs.h.  */
14401
_ACEOF
14402
cat confdefs.h >>conftest.$ac_ext
14403
cat >>conftest.$ac_ext <<_ACEOF
14404
/* end confdefs.h.  */
14405
 
14406
/* Override any gcc2 internal prototype to avoid an error.  */
14407
#ifdef __cplusplus
14408
extern "C"
14409
#endif
14410
/* We use char because int might match the return type of a gcc2
14411
   builtin and then its argument prototype would still apply.  */
14412
char fabsf ();
14413
int
14414
main ()
14415
{
14416
fabsf ();
14417
  ;
14418
  return 0;
14419
}
14420
_ACEOF
14421
rm -f conftest.$ac_objext conftest$ac_exeext
14422
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14423
  (eval $ac_link) 2>conftest.er1
14424
  ac_status=$?
14425
  grep -v '^ *+' conftest.er1 >conftest.err
14426
  rm -f conftest.er1
14427
  cat conftest.err >&5
14428
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14429
  (exit $ac_status); } &&
14430
         { ac_try='test -z "$ac_c_werror_flag"
14431
                         || test ! -s conftest.err'
14432
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14433
  (eval $ac_try) 2>&5
14434
  ac_status=$?
14435
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14436
  (exit $ac_status); }; } &&
14437
         { ac_try='test -s conftest$ac_exeext'
14438
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14439
  (eval $ac_try) 2>&5
14440
  ac_status=$?
14441
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14442
  (exit $ac_status); }; }; then
14443
  ac_cv_lib_m_fabsf=yes
14444
else
14445
  echo "$as_me: failed program was:" >&5
14446
sed 's/^/| /' conftest.$ac_ext >&5
14447
 
14448
ac_cv_lib_m_fabsf=no
14449
fi
14450
rm -f conftest.err conftest.$ac_objext \
14451
      conftest$ac_exeext conftest.$ac_ext
14452
LIBS=$ac_check_lib_save_LIBS
14453
fi
14454
echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabsf" >&5
14455
echo "${ECHO_T}$ac_cv_lib_m_fabsf" >&6
14456
if test $ac_cv_lib_m_fabsf = yes; then
14457
 
14458
cat >>confdefs.h <<\_ACEOF
14459
#define HAVE_FABSF 1
14460
_ACEOF
14461
 
14462
fi
14463
 
14464
echo "$as_me:$LINENO: checking for fabs in -lm" >&5
14465
echo $ECHO_N "checking for fabs in -lm... $ECHO_C" >&6
14466
if test "${ac_cv_lib_m_fabs+set}" = set; then
14467
  echo $ECHO_N "(cached) $ECHO_C" >&6
14468
else
14469
  ac_check_lib_save_LIBS=$LIBS
14470
LIBS="-lm  $LIBS"
14471
if test x$gcc_no_link = xyes; then
14472
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14473
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14474
   { (exit 1); exit 1; }; }
14475
fi
14476
cat >conftest.$ac_ext <<_ACEOF
14477
/* confdefs.h.  */
14478
_ACEOF
14479
cat confdefs.h >>conftest.$ac_ext
14480
cat >>conftest.$ac_ext <<_ACEOF
14481
/* end confdefs.h.  */
14482
 
14483
/* Override any gcc2 internal prototype to avoid an error.  */
14484
#ifdef __cplusplus
14485
extern "C"
14486
#endif
14487
/* We use char because int might match the return type of a gcc2
14488
   builtin and then its argument prototype would still apply.  */
14489
char fabs ();
14490
int
14491
main ()
14492
{
14493
fabs ();
14494
  ;
14495
  return 0;
14496
}
14497
_ACEOF
14498
rm -f conftest.$ac_objext conftest$ac_exeext
14499
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14500
  (eval $ac_link) 2>conftest.er1
14501
  ac_status=$?
14502
  grep -v '^ *+' conftest.er1 >conftest.err
14503
  rm -f conftest.er1
14504
  cat conftest.err >&5
14505
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14506
  (exit $ac_status); } &&
14507
         { ac_try='test -z "$ac_c_werror_flag"
14508
                         || test ! -s conftest.err'
14509
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14510
  (eval $ac_try) 2>&5
14511
  ac_status=$?
14512
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14513
  (exit $ac_status); }; } &&
14514
         { ac_try='test -s conftest$ac_exeext'
14515
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14516
  (eval $ac_try) 2>&5
14517
  ac_status=$?
14518
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14519
  (exit $ac_status); }; }; then
14520
  ac_cv_lib_m_fabs=yes
14521
else
14522
  echo "$as_me: failed program was:" >&5
14523
sed 's/^/| /' conftest.$ac_ext >&5
14524
 
14525
ac_cv_lib_m_fabs=no
14526
fi
14527
rm -f conftest.err conftest.$ac_objext \
14528
      conftest$ac_exeext conftest.$ac_ext
14529
LIBS=$ac_check_lib_save_LIBS
14530
fi
14531
echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabs" >&5
14532
echo "${ECHO_T}$ac_cv_lib_m_fabs" >&6
14533
if test $ac_cv_lib_m_fabs = yes; then
14534
 
14535
cat >>confdefs.h <<\_ACEOF
14536
#define HAVE_FABS 1
14537
_ACEOF
14538
 
14539
fi
14540
 
14541
echo "$as_me:$LINENO: checking for fabsl in -lm" >&5
14542
echo $ECHO_N "checking for fabsl in -lm... $ECHO_C" >&6
14543
if test "${ac_cv_lib_m_fabsl+set}" = set; then
14544
  echo $ECHO_N "(cached) $ECHO_C" >&6
14545
else
14546
  ac_check_lib_save_LIBS=$LIBS
14547
LIBS="-lm  $LIBS"
14548
if test x$gcc_no_link = xyes; then
14549
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14550
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14551
   { (exit 1); exit 1; }; }
14552
fi
14553
cat >conftest.$ac_ext <<_ACEOF
14554
/* confdefs.h.  */
14555
_ACEOF
14556
cat confdefs.h >>conftest.$ac_ext
14557
cat >>conftest.$ac_ext <<_ACEOF
14558
/* end confdefs.h.  */
14559
 
14560
/* Override any gcc2 internal prototype to avoid an error.  */
14561
#ifdef __cplusplus
14562
extern "C"
14563
#endif
14564
/* We use char because int might match the return type of a gcc2
14565
   builtin and then its argument prototype would still apply.  */
14566
char fabsl ();
14567
int
14568
main ()
14569
{
14570
fabsl ();
14571
  ;
14572
  return 0;
14573
}
14574
_ACEOF
14575
rm -f conftest.$ac_objext conftest$ac_exeext
14576
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14577
  (eval $ac_link) 2>conftest.er1
14578
  ac_status=$?
14579
  grep -v '^ *+' conftest.er1 >conftest.err
14580
  rm -f conftest.er1
14581
  cat conftest.err >&5
14582
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14583
  (exit $ac_status); } &&
14584
         { ac_try='test -z "$ac_c_werror_flag"
14585
                         || test ! -s conftest.err'
14586
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14587
  (eval $ac_try) 2>&5
14588
  ac_status=$?
14589
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14590
  (exit $ac_status); }; } &&
14591
         { ac_try='test -s conftest$ac_exeext'
14592
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14593
  (eval $ac_try) 2>&5
14594
  ac_status=$?
14595
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14596
  (exit $ac_status); }; }; then
14597
  ac_cv_lib_m_fabsl=yes
14598
else
14599
  echo "$as_me: failed program was:" >&5
14600
sed 's/^/| /' conftest.$ac_ext >&5
14601
 
14602
ac_cv_lib_m_fabsl=no
14603
fi
14604
rm -f conftest.err conftest.$ac_objext \
14605
      conftest$ac_exeext conftest.$ac_ext
14606
LIBS=$ac_check_lib_save_LIBS
14607
fi
14608
echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabsl" >&5
14609
echo "${ECHO_T}$ac_cv_lib_m_fabsl" >&6
14610
if test $ac_cv_lib_m_fabsl = yes; then
14611
 
14612
cat >>confdefs.h <<\_ACEOF
14613
#define HAVE_FABSL 1
14614
_ACEOF
14615
 
14616
fi
14617
 
14618
echo "$as_me:$LINENO: checking for cabsf in -lm" >&5
14619
echo $ECHO_N "checking for cabsf in -lm... $ECHO_C" >&6
14620
if test "${ac_cv_lib_m_cabsf+set}" = set; then
14621
  echo $ECHO_N "(cached) $ECHO_C" >&6
14622
else
14623
  ac_check_lib_save_LIBS=$LIBS
14624
LIBS="-lm  $LIBS"
14625
if test x$gcc_no_link = xyes; then
14626
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14627
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14628
   { (exit 1); exit 1; }; }
14629
fi
14630
cat >conftest.$ac_ext <<_ACEOF
14631
/* confdefs.h.  */
14632
_ACEOF
14633
cat confdefs.h >>conftest.$ac_ext
14634
cat >>conftest.$ac_ext <<_ACEOF
14635
/* end confdefs.h.  */
14636
 
14637
/* Override any gcc2 internal prototype to avoid an error.  */
14638
#ifdef __cplusplus
14639
extern "C"
14640
#endif
14641
/* We use char because int might match the return type of a gcc2
14642
   builtin and then its argument prototype would still apply.  */
14643
char cabsf ();
14644
int
14645
main ()
14646
{
14647
cabsf ();
14648
  ;
14649
  return 0;
14650
}
14651
_ACEOF
14652
rm -f conftest.$ac_objext conftest$ac_exeext
14653
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14654
  (eval $ac_link) 2>conftest.er1
14655
  ac_status=$?
14656
  grep -v '^ *+' conftest.er1 >conftest.err
14657
  rm -f conftest.er1
14658
  cat conftest.err >&5
14659
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14660
  (exit $ac_status); } &&
14661
         { ac_try='test -z "$ac_c_werror_flag"
14662
                         || test ! -s conftest.err'
14663
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14664
  (eval $ac_try) 2>&5
14665
  ac_status=$?
14666
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14667
  (exit $ac_status); }; } &&
14668
         { ac_try='test -s conftest$ac_exeext'
14669
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14670
  (eval $ac_try) 2>&5
14671
  ac_status=$?
14672
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14673
  (exit $ac_status); }; }; then
14674
  ac_cv_lib_m_cabsf=yes
14675
else
14676
  echo "$as_me: failed program was:" >&5
14677
sed 's/^/| /' conftest.$ac_ext >&5
14678
 
14679
ac_cv_lib_m_cabsf=no
14680
fi
14681
rm -f conftest.err conftest.$ac_objext \
14682
      conftest$ac_exeext conftest.$ac_ext
14683
LIBS=$ac_check_lib_save_LIBS
14684
fi
14685
echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabsf" >&5
14686
echo "${ECHO_T}$ac_cv_lib_m_cabsf" >&6
14687
if test $ac_cv_lib_m_cabsf = yes; then
14688
 
14689
cat >>confdefs.h <<\_ACEOF
14690
#define HAVE_CABSF 1
14691
_ACEOF
14692
 
14693
fi
14694
 
14695
echo "$as_me:$LINENO: checking for cabs in -lm" >&5
14696
echo $ECHO_N "checking for cabs in -lm... $ECHO_C" >&6
14697
if test "${ac_cv_lib_m_cabs+set}" = set; then
14698
  echo $ECHO_N "(cached) $ECHO_C" >&6
14699
else
14700
  ac_check_lib_save_LIBS=$LIBS
14701
LIBS="-lm  $LIBS"
14702
if test x$gcc_no_link = xyes; then
14703
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14704
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14705
   { (exit 1); exit 1; }; }
14706
fi
14707
cat >conftest.$ac_ext <<_ACEOF
14708
/* confdefs.h.  */
14709
_ACEOF
14710
cat confdefs.h >>conftest.$ac_ext
14711
cat >>conftest.$ac_ext <<_ACEOF
14712
/* end confdefs.h.  */
14713
 
14714
/* Override any gcc2 internal prototype to avoid an error.  */
14715
#ifdef __cplusplus
14716
extern "C"
14717
#endif
14718
/* We use char because int might match the return type of a gcc2
14719
   builtin and then its argument prototype would still apply.  */
14720
char cabs ();
14721
int
14722
main ()
14723
{
14724
cabs ();
14725
  ;
14726
  return 0;
14727
}
14728
_ACEOF
14729
rm -f conftest.$ac_objext conftest$ac_exeext
14730
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14731
  (eval $ac_link) 2>conftest.er1
14732
  ac_status=$?
14733
  grep -v '^ *+' conftest.er1 >conftest.err
14734
  rm -f conftest.er1
14735
  cat conftest.err >&5
14736
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14737
  (exit $ac_status); } &&
14738
         { ac_try='test -z "$ac_c_werror_flag"
14739
                         || test ! -s conftest.err'
14740
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14741
  (eval $ac_try) 2>&5
14742
  ac_status=$?
14743
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14744
  (exit $ac_status); }; } &&
14745
         { ac_try='test -s conftest$ac_exeext'
14746
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14747
  (eval $ac_try) 2>&5
14748
  ac_status=$?
14749
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14750
  (exit $ac_status); }; }; then
14751
  ac_cv_lib_m_cabs=yes
14752
else
14753
  echo "$as_me: failed program was:" >&5
14754
sed 's/^/| /' conftest.$ac_ext >&5
14755
 
14756
ac_cv_lib_m_cabs=no
14757
fi
14758
rm -f conftest.err conftest.$ac_objext \
14759
      conftest$ac_exeext conftest.$ac_ext
14760
LIBS=$ac_check_lib_save_LIBS
14761
fi
14762
echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabs" >&5
14763
echo "${ECHO_T}$ac_cv_lib_m_cabs" >&6
14764
if test $ac_cv_lib_m_cabs = yes; then
14765
 
14766
cat >>confdefs.h <<\_ACEOF
14767
#define HAVE_CABS 1
14768
_ACEOF
14769
 
14770
fi
14771
 
14772
echo "$as_me:$LINENO: checking for cabsl in -lm" >&5
14773
echo $ECHO_N "checking for cabsl in -lm... $ECHO_C" >&6
14774
if test "${ac_cv_lib_m_cabsl+set}" = set; then
14775
  echo $ECHO_N "(cached) $ECHO_C" >&6
14776
else
14777
  ac_check_lib_save_LIBS=$LIBS
14778
LIBS="-lm  $LIBS"
14779
if test x$gcc_no_link = xyes; then
14780
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14781
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14782
   { (exit 1); exit 1; }; }
14783
fi
14784
cat >conftest.$ac_ext <<_ACEOF
14785
/* confdefs.h.  */
14786
_ACEOF
14787
cat confdefs.h >>conftest.$ac_ext
14788
cat >>conftest.$ac_ext <<_ACEOF
14789
/* end confdefs.h.  */
14790
 
14791
/* Override any gcc2 internal prototype to avoid an error.  */
14792
#ifdef __cplusplus
14793
extern "C"
14794
#endif
14795
/* We use char because int might match the return type of a gcc2
14796
   builtin and then its argument prototype would still apply.  */
14797
char cabsl ();
14798
int
14799
main ()
14800
{
14801
cabsl ();
14802
  ;
14803
  return 0;
14804
}
14805
_ACEOF
14806
rm -f conftest.$ac_objext conftest$ac_exeext
14807
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14808
  (eval $ac_link) 2>conftest.er1
14809
  ac_status=$?
14810
  grep -v '^ *+' conftest.er1 >conftest.err
14811
  rm -f conftest.er1
14812
  cat conftest.err >&5
14813
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14814
  (exit $ac_status); } &&
14815
         { ac_try='test -z "$ac_c_werror_flag"
14816
                         || test ! -s conftest.err'
14817
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14818
  (eval $ac_try) 2>&5
14819
  ac_status=$?
14820
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14821
  (exit $ac_status); }; } &&
14822
         { ac_try='test -s conftest$ac_exeext'
14823
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14824
  (eval $ac_try) 2>&5
14825
  ac_status=$?
14826
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14827
  (exit $ac_status); }; }; then
14828
  ac_cv_lib_m_cabsl=yes
14829
else
14830
  echo "$as_me: failed program was:" >&5
14831
sed 's/^/| /' conftest.$ac_ext >&5
14832
 
14833
ac_cv_lib_m_cabsl=no
14834
fi
14835
rm -f conftest.err conftest.$ac_objext \
14836
      conftest$ac_exeext conftest.$ac_ext
14837
LIBS=$ac_check_lib_save_LIBS
14838
fi
14839
echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabsl" >&5
14840
echo "${ECHO_T}$ac_cv_lib_m_cabsl" >&6
14841
if test $ac_cv_lib_m_cabsl = yes; then
14842
 
14843
cat >>confdefs.h <<\_ACEOF
14844
#define HAVE_CABSL 1
14845
_ACEOF
14846
 
14847
fi
14848
 
14849
echo "$as_me:$LINENO: checking for floorf in -lm" >&5
14850
echo $ECHO_N "checking for floorf in -lm... $ECHO_C" >&6
14851
if test "${ac_cv_lib_m_floorf+set}" = set; then
14852
  echo $ECHO_N "(cached) $ECHO_C" >&6
14853
else
14854
  ac_check_lib_save_LIBS=$LIBS
14855
LIBS="-lm  $LIBS"
14856
if test x$gcc_no_link = xyes; then
14857
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14858
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14859
   { (exit 1); exit 1; }; }
14860
fi
14861
cat >conftest.$ac_ext <<_ACEOF
14862
/* confdefs.h.  */
14863
_ACEOF
14864
cat confdefs.h >>conftest.$ac_ext
14865
cat >>conftest.$ac_ext <<_ACEOF
14866
/* end confdefs.h.  */
14867
 
14868
/* Override any gcc2 internal prototype to avoid an error.  */
14869
#ifdef __cplusplus
14870
extern "C"
14871
#endif
14872
/* We use char because int might match the return type of a gcc2
14873
   builtin and then its argument prototype would still apply.  */
14874
char floorf ();
14875
int
14876
main ()
14877
{
14878
floorf ();
14879
  ;
14880
  return 0;
14881
}
14882
_ACEOF
14883
rm -f conftest.$ac_objext conftest$ac_exeext
14884
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14885
  (eval $ac_link) 2>conftest.er1
14886
  ac_status=$?
14887
  grep -v '^ *+' conftest.er1 >conftest.err
14888
  rm -f conftest.er1
14889
  cat conftest.err >&5
14890
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14891
  (exit $ac_status); } &&
14892
         { ac_try='test -z "$ac_c_werror_flag"
14893
                         || test ! -s conftest.err'
14894
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14895
  (eval $ac_try) 2>&5
14896
  ac_status=$?
14897
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14898
  (exit $ac_status); }; } &&
14899
         { ac_try='test -s conftest$ac_exeext'
14900
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14901
  (eval $ac_try) 2>&5
14902
  ac_status=$?
14903
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14904
  (exit $ac_status); }; }; then
14905
  ac_cv_lib_m_floorf=yes
14906
else
14907
  echo "$as_me: failed program was:" >&5
14908
sed 's/^/| /' conftest.$ac_ext >&5
14909
 
14910
ac_cv_lib_m_floorf=no
14911
fi
14912
rm -f conftest.err conftest.$ac_objext \
14913
      conftest$ac_exeext conftest.$ac_ext
14914
LIBS=$ac_check_lib_save_LIBS
14915
fi
14916
echo "$as_me:$LINENO: result: $ac_cv_lib_m_floorf" >&5
14917
echo "${ECHO_T}$ac_cv_lib_m_floorf" >&6
14918
if test $ac_cv_lib_m_floorf = yes; then
14919
 
14920
cat >>confdefs.h <<\_ACEOF
14921
#define HAVE_FLOORF 1
14922
_ACEOF
14923
 
14924
fi
14925
 
14926
echo "$as_me:$LINENO: checking for floor in -lm" >&5
14927
echo $ECHO_N "checking for floor in -lm... $ECHO_C" >&6
14928
if test "${ac_cv_lib_m_floor+set}" = set; then
14929
  echo $ECHO_N "(cached) $ECHO_C" >&6
14930
else
14931
  ac_check_lib_save_LIBS=$LIBS
14932
LIBS="-lm  $LIBS"
14933
if test x$gcc_no_link = xyes; then
14934
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14935
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14936
   { (exit 1); exit 1; }; }
14937
fi
14938
cat >conftest.$ac_ext <<_ACEOF
14939
/* confdefs.h.  */
14940
_ACEOF
14941
cat confdefs.h >>conftest.$ac_ext
14942
cat >>conftest.$ac_ext <<_ACEOF
14943
/* end confdefs.h.  */
14944
 
14945
/* Override any gcc2 internal prototype to avoid an error.  */
14946
#ifdef __cplusplus
14947
extern "C"
14948
#endif
14949
/* We use char because int might match the return type of a gcc2
14950
   builtin and then its argument prototype would still apply.  */
14951
char floor ();
14952
int
14953
main ()
14954
{
14955
floor ();
14956
  ;
14957
  return 0;
14958
}
14959
_ACEOF
14960
rm -f conftest.$ac_objext conftest$ac_exeext
14961
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14962
  (eval $ac_link) 2>conftest.er1
14963
  ac_status=$?
14964
  grep -v '^ *+' conftest.er1 >conftest.err
14965
  rm -f conftest.er1
14966
  cat conftest.err >&5
14967
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14968
  (exit $ac_status); } &&
14969
         { ac_try='test -z "$ac_c_werror_flag"
14970
                         || test ! -s conftest.err'
14971
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14972
  (eval $ac_try) 2>&5
14973
  ac_status=$?
14974
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14975
  (exit $ac_status); }; } &&
14976
         { ac_try='test -s conftest$ac_exeext'
14977
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14978
  (eval $ac_try) 2>&5
14979
  ac_status=$?
14980
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14981
  (exit $ac_status); }; }; then
14982
  ac_cv_lib_m_floor=yes
14983
else
14984
  echo "$as_me: failed program was:" >&5
14985
sed 's/^/| /' conftest.$ac_ext >&5
14986
 
14987
ac_cv_lib_m_floor=no
14988
fi
14989
rm -f conftest.err conftest.$ac_objext \
14990
      conftest$ac_exeext conftest.$ac_ext
14991
LIBS=$ac_check_lib_save_LIBS
14992
fi
14993
echo "$as_me:$LINENO: result: $ac_cv_lib_m_floor" >&5
14994
echo "${ECHO_T}$ac_cv_lib_m_floor" >&6
14995
if test $ac_cv_lib_m_floor = yes; then
14996
 
14997
cat >>confdefs.h <<\_ACEOF
14998
#define HAVE_FLOOR 1
14999
_ACEOF
15000
 
15001
fi
15002
 
15003
echo "$as_me:$LINENO: checking for floorl in -lm" >&5
15004
echo $ECHO_N "checking for floorl in -lm... $ECHO_C" >&6
15005
if test "${ac_cv_lib_m_floorl+set}" = set; then
15006
  echo $ECHO_N "(cached) $ECHO_C" >&6
15007
else
15008
  ac_check_lib_save_LIBS=$LIBS
15009
LIBS="-lm  $LIBS"
15010
if test x$gcc_no_link = xyes; then
15011
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15012
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15013
   { (exit 1); exit 1; }; }
15014
fi
15015
cat >conftest.$ac_ext <<_ACEOF
15016
/* confdefs.h.  */
15017
_ACEOF
15018
cat confdefs.h >>conftest.$ac_ext
15019
cat >>conftest.$ac_ext <<_ACEOF
15020
/* end confdefs.h.  */
15021
 
15022
/* Override any gcc2 internal prototype to avoid an error.  */
15023
#ifdef __cplusplus
15024
extern "C"
15025
#endif
15026
/* We use char because int might match the return type of a gcc2
15027
   builtin and then its argument prototype would still apply.  */
15028
char floorl ();
15029
int
15030
main ()
15031
{
15032
floorl ();
15033
  ;
15034
  return 0;
15035
}
15036
_ACEOF
15037
rm -f conftest.$ac_objext conftest$ac_exeext
15038
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15039
  (eval $ac_link) 2>conftest.er1
15040
  ac_status=$?
15041
  grep -v '^ *+' conftest.er1 >conftest.err
15042
  rm -f conftest.er1
15043
  cat conftest.err >&5
15044
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15045
  (exit $ac_status); } &&
15046
         { ac_try='test -z "$ac_c_werror_flag"
15047
                         || test ! -s conftest.err'
15048
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15049
  (eval $ac_try) 2>&5
15050
  ac_status=$?
15051
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15052
  (exit $ac_status); }; } &&
15053
         { ac_try='test -s conftest$ac_exeext'
15054
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15055
  (eval $ac_try) 2>&5
15056
  ac_status=$?
15057
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15058
  (exit $ac_status); }; }; then
15059
  ac_cv_lib_m_floorl=yes
15060
else
15061
  echo "$as_me: failed program was:" >&5
15062
sed 's/^/| /' conftest.$ac_ext >&5
15063
 
15064
ac_cv_lib_m_floorl=no
15065
fi
15066
rm -f conftest.err conftest.$ac_objext \
15067
      conftest$ac_exeext conftest.$ac_ext
15068
LIBS=$ac_check_lib_save_LIBS
15069
fi
15070
echo "$as_me:$LINENO: result: $ac_cv_lib_m_floorl" >&5
15071
echo "${ECHO_T}$ac_cv_lib_m_floorl" >&6
15072
if test $ac_cv_lib_m_floorl = yes; then
15073
 
15074
cat >>confdefs.h <<\_ACEOF
15075
#define HAVE_FLOORL 1
15076
_ACEOF
15077
 
15078
fi
15079
 
15080
echo "$as_me:$LINENO: checking for frexpf in -lm" >&5
15081
echo $ECHO_N "checking for frexpf in -lm... $ECHO_C" >&6
15082
if test "${ac_cv_lib_m_frexpf+set}" = set; then
15083
  echo $ECHO_N "(cached) $ECHO_C" >&6
15084
else
15085
  ac_check_lib_save_LIBS=$LIBS
15086
LIBS="-lm  $LIBS"
15087
if test x$gcc_no_link = xyes; then
15088
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15089
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15090
   { (exit 1); exit 1; }; }
15091
fi
15092
cat >conftest.$ac_ext <<_ACEOF
15093
/* confdefs.h.  */
15094
_ACEOF
15095
cat confdefs.h >>conftest.$ac_ext
15096
cat >>conftest.$ac_ext <<_ACEOF
15097
/* end confdefs.h.  */
15098
 
15099
/* Override any gcc2 internal prototype to avoid an error.  */
15100
#ifdef __cplusplus
15101
extern "C"
15102
#endif
15103
/* We use char because int might match the return type of a gcc2
15104
   builtin and then its argument prototype would still apply.  */
15105
char frexpf ();
15106
int
15107
main ()
15108
{
15109
frexpf ();
15110
  ;
15111
  return 0;
15112
}
15113
_ACEOF
15114
rm -f conftest.$ac_objext conftest$ac_exeext
15115
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15116
  (eval $ac_link) 2>conftest.er1
15117
  ac_status=$?
15118
  grep -v '^ *+' conftest.er1 >conftest.err
15119
  rm -f conftest.er1
15120
  cat conftest.err >&5
15121
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15122
  (exit $ac_status); } &&
15123
         { ac_try='test -z "$ac_c_werror_flag"
15124
                         || test ! -s conftest.err'
15125
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15126
  (eval $ac_try) 2>&5
15127
  ac_status=$?
15128
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15129
  (exit $ac_status); }; } &&
15130
         { ac_try='test -s conftest$ac_exeext'
15131
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15132
  (eval $ac_try) 2>&5
15133
  ac_status=$?
15134
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15135
  (exit $ac_status); }; }; then
15136
  ac_cv_lib_m_frexpf=yes
15137
else
15138
  echo "$as_me: failed program was:" >&5
15139
sed 's/^/| /' conftest.$ac_ext >&5
15140
 
15141
ac_cv_lib_m_frexpf=no
15142
fi
15143
rm -f conftest.err conftest.$ac_objext \
15144
      conftest$ac_exeext conftest.$ac_ext
15145
LIBS=$ac_check_lib_save_LIBS
15146
fi
15147
echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexpf" >&5
15148
echo "${ECHO_T}$ac_cv_lib_m_frexpf" >&6
15149
if test $ac_cv_lib_m_frexpf = yes; then
15150
 
15151
cat >>confdefs.h <<\_ACEOF
15152
#define HAVE_FREXPF 1
15153
_ACEOF
15154
 
15155
fi
15156
 
15157
echo "$as_me:$LINENO: checking for frexp in -lm" >&5
15158
echo $ECHO_N "checking for frexp in -lm... $ECHO_C" >&6
15159
if test "${ac_cv_lib_m_frexp+set}" = set; then
15160
  echo $ECHO_N "(cached) $ECHO_C" >&6
15161
else
15162
  ac_check_lib_save_LIBS=$LIBS
15163
LIBS="-lm  $LIBS"
15164
if test x$gcc_no_link = xyes; then
15165
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15166
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15167
   { (exit 1); exit 1; }; }
15168
fi
15169
cat >conftest.$ac_ext <<_ACEOF
15170
/* confdefs.h.  */
15171
_ACEOF
15172
cat confdefs.h >>conftest.$ac_ext
15173
cat >>conftest.$ac_ext <<_ACEOF
15174
/* end confdefs.h.  */
15175
 
15176
/* Override any gcc2 internal prototype to avoid an error.  */
15177
#ifdef __cplusplus
15178
extern "C"
15179
#endif
15180
/* We use char because int might match the return type of a gcc2
15181
   builtin and then its argument prototype would still apply.  */
15182
char frexp ();
15183
int
15184
main ()
15185
{
15186
frexp ();
15187
  ;
15188
  return 0;
15189
}
15190
_ACEOF
15191
rm -f conftest.$ac_objext conftest$ac_exeext
15192
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15193
  (eval $ac_link) 2>conftest.er1
15194
  ac_status=$?
15195
  grep -v '^ *+' conftest.er1 >conftest.err
15196
  rm -f conftest.er1
15197
  cat conftest.err >&5
15198
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15199
  (exit $ac_status); } &&
15200
         { ac_try='test -z "$ac_c_werror_flag"
15201
                         || test ! -s conftest.err'
15202
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15203
  (eval $ac_try) 2>&5
15204
  ac_status=$?
15205
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15206
  (exit $ac_status); }; } &&
15207
         { ac_try='test -s conftest$ac_exeext'
15208
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15209
  (eval $ac_try) 2>&5
15210
  ac_status=$?
15211
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15212
  (exit $ac_status); }; }; then
15213
  ac_cv_lib_m_frexp=yes
15214
else
15215
  echo "$as_me: failed program was:" >&5
15216
sed 's/^/| /' conftest.$ac_ext >&5
15217
 
15218
ac_cv_lib_m_frexp=no
15219
fi
15220
rm -f conftest.err conftest.$ac_objext \
15221
      conftest$ac_exeext conftest.$ac_ext
15222
LIBS=$ac_check_lib_save_LIBS
15223
fi
15224
echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexp" >&5
15225
echo "${ECHO_T}$ac_cv_lib_m_frexp" >&6
15226
if test $ac_cv_lib_m_frexp = yes; then
15227
 
15228
cat >>confdefs.h <<\_ACEOF
15229
#define HAVE_FREXP 1
15230
_ACEOF
15231
 
15232
fi
15233
 
15234
echo "$as_me:$LINENO: checking for frexpl in -lm" >&5
15235
echo $ECHO_N "checking for frexpl in -lm... $ECHO_C" >&6
15236
if test "${ac_cv_lib_m_frexpl+set}" = set; then
15237
  echo $ECHO_N "(cached) $ECHO_C" >&6
15238
else
15239
  ac_check_lib_save_LIBS=$LIBS
15240
LIBS="-lm  $LIBS"
15241
if test x$gcc_no_link = xyes; then
15242
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15243
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15244
   { (exit 1); exit 1; }; }
15245
fi
15246
cat >conftest.$ac_ext <<_ACEOF
15247
/* confdefs.h.  */
15248
_ACEOF
15249
cat confdefs.h >>conftest.$ac_ext
15250
cat >>conftest.$ac_ext <<_ACEOF
15251
/* end confdefs.h.  */
15252
 
15253
/* Override any gcc2 internal prototype to avoid an error.  */
15254
#ifdef __cplusplus
15255
extern "C"
15256
#endif
15257
/* We use char because int might match the return type of a gcc2
15258
   builtin and then its argument prototype would still apply.  */
15259
char frexpl ();
15260
int
15261
main ()
15262
{
15263
frexpl ();
15264
  ;
15265
  return 0;
15266
}
15267
_ACEOF
15268
rm -f conftest.$ac_objext conftest$ac_exeext
15269
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15270
  (eval $ac_link) 2>conftest.er1
15271
  ac_status=$?
15272
  grep -v '^ *+' conftest.er1 >conftest.err
15273
  rm -f conftest.er1
15274
  cat conftest.err >&5
15275
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15276
  (exit $ac_status); } &&
15277
         { ac_try='test -z "$ac_c_werror_flag"
15278
                         || test ! -s conftest.err'
15279
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15280
  (eval $ac_try) 2>&5
15281
  ac_status=$?
15282
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15283
  (exit $ac_status); }; } &&
15284
         { ac_try='test -s conftest$ac_exeext'
15285
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15286
  (eval $ac_try) 2>&5
15287
  ac_status=$?
15288
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15289
  (exit $ac_status); }; }; then
15290
  ac_cv_lib_m_frexpl=yes
15291
else
15292
  echo "$as_me: failed program was:" >&5
15293
sed 's/^/| /' conftest.$ac_ext >&5
15294
 
15295
ac_cv_lib_m_frexpl=no
15296
fi
15297
rm -f conftest.err conftest.$ac_objext \
15298
      conftest$ac_exeext conftest.$ac_ext
15299
LIBS=$ac_check_lib_save_LIBS
15300
fi
15301
echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexpl" >&5
15302
echo "${ECHO_T}$ac_cv_lib_m_frexpl" >&6
15303
if test $ac_cv_lib_m_frexpl = yes; then
15304
 
15305
cat >>confdefs.h <<\_ACEOF
15306
#define HAVE_FREXPL 1
15307
_ACEOF
15308
 
15309
fi
15310
 
15311
echo "$as_me:$LINENO: checking for hypotf in -lm" >&5
15312
echo $ECHO_N "checking for hypotf in -lm... $ECHO_C" >&6
15313
if test "${ac_cv_lib_m_hypotf+set}" = set; then
15314
  echo $ECHO_N "(cached) $ECHO_C" >&6
15315
else
15316
  ac_check_lib_save_LIBS=$LIBS
15317
LIBS="-lm  $LIBS"
15318
if test x$gcc_no_link = xyes; then
15319
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15320
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15321
   { (exit 1); exit 1; }; }
15322
fi
15323
cat >conftest.$ac_ext <<_ACEOF
15324
/* confdefs.h.  */
15325
_ACEOF
15326
cat confdefs.h >>conftest.$ac_ext
15327
cat >>conftest.$ac_ext <<_ACEOF
15328
/* end confdefs.h.  */
15329
 
15330
/* Override any gcc2 internal prototype to avoid an error.  */
15331
#ifdef __cplusplus
15332
extern "C"
15333
#endif
15334
/* We use char because int might match the return type of a gcc2
15335
   builtin and then its argument prototype would still apply.  */
15336
char hypotf ();
15337
int
15338
main ()
15339
{
15340
hypotf ();
15341
  ;
15342
  return 0;
15343
}
15344
_ACEOF
15345
rm -f conftest.$ac_objext conftest$ac_exeext
15346
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15347
  (eval $ac_link) 2>conftest.er1
15348
  ac_status=$?
15349
  grep -v '^ *+' conftest.er1 >conftest.err
15350
  rm -f conftest.er1
15351
  cat conftest.err >&5
15352
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15353
  (exit $ac_status); } &&
15354
         { ac_try='test -z "$ac_c_werror_flag"
15355
                         || test ! -s conftest.err'
15356
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15357
  (eval $ac_try) 2>&5
15358
  ac_status=$?
15359
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15360
  (exit $ac_status); }; } &&
15361
         { ac_try='test -s conftest$ac_exeext'
15362
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15363
  (eval $ac_try) 2>&5
15364
  ac_status=$?
15365
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15366
  (exit $ac_status); }; }; then
15367
  ac_cv_lib_m_hypotf=yes
15368
else
15369
  echo "$as_me: failed program was:" >&5
15370
sed 's/^/| /' conftest.$ac_ext >&5
15371
 
15372
ac_cv_lib_m_hypotf=no
15373
fi
15374
rm -f conftest.err conftest.$ac_objext \
15375
      conftest$ac_exeext conftest.$ac_ext
15376
LIBS=$ac_check_lib_save_LIBS
15377
fi
15378
echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypotf" >&5
15379
echo "${ECHO_T}$ac_cv_lib_m_hypotf" >&6
15380
if test $ac_cv_lib_m_hypotf = yes; then
15381
 
15382
cat >>confdefs.h <<\_ACEOF
15383
#define HAVE_HYPOTF 1
15384
_ACEOF
15385
 
15386
fi
15387
 
15388
echo "$as_me:$LINENO: checking for hypot in -lm" >&5
15389
echo $ECHO_N "checking for hypot in -lm... $ECHO_C" >&6
15390
if test "${ac_cv_lib_m_hypot+set}" = set; then
15391
  echo $ECHO_N "(cached) $ECHO_C" >&6
15392
else
15393
  ac_check_lib_save_LIBS=$LIBS
15394
LIBS="-lm  $LIBS"
15395
if test x$gcc_no_link = xyes; then
15396
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15397
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15398
   { (exit 1); exit 1; }; }
15399
fi
15400
cat >conftest.$ac_ext <<_ACEOF
15401
/* confdefs.h.  */
15402
_ACEOF
15403
cat confdefs.h >>conftest.$ac_ext
15404
cat >>conftest.$ac_ext <<_ACEOF
15405
/* end confdefs.h.  */
15406
 
15407
/* Override any gcc2 internal prototype to avoid an error.  */
15408
#ifdef __cplusplus
15409
extern "C"
15410
#endif
15411
/* We use char because int might match the return type of a gcc2
15412
   builtin and then its argument prototype would still apply.  */
15413
char hypot ();
15414
int
15415
main ()
15416
{
15417
hypot ();
15418
  ;
15419
  return 0;
15420
}
15421
_ACEOF
15422
rm -f conftest.$ac_objext conftest$ac_exeext
15423
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15424
  (eval $ac_link) 2>conftest.er1
15425
  ac_status=$?
15426
  grep -v '^ *+' conftest.er1 >conftest.err
15427
  rm -f conftest.er1
15428
  cat conftest.err >&5
15429
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15430
  (exit $ac_status); } &&
15431
         { ac_try='test -z "$ac_c_werror_flag"
15432
                         || test ! -s conftest.err'
15433
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15434
  (eval $ac_try) 2>&5
15435
  ac_status=$?
15436
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15437
  (exit $ac_status); }; } &&
15438
         { ac_try='test -s conftest$ac_exeext'
15439
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15440
  (eval $ac_try) 2>&5
15441
  ac_status=$?
15442
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15443
  (exit $ac_status); }; }; then
15444
  ac_cv_lib_m_hypot=yes
15445
else
15446
  echo "$as_me: failed program was:" >&5
15447
sed 's/^/| /' conftest.$ac_ext >&5
15448
 
15449
ac_cv_lib_m_hypot=no
15450
fi
15451
rm -f conftest.err conftest.$ac_objext \
15452
      conftest$ac_exeext conftest.$ac_ext
15453
LIBS=$ac_check_lib_save_LIBS
15454
fi
15455
echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypot" >&5
15456
echo "${ECHO_T}$ac_cv_lib_m_hypot" >&6
15457
if test $ac_cv_lib_m_hypot = yes; then
15458
 
15459
cat >>confdefs.h <<\_ACEOF
15460
#define HAVE_HYPOT 1
15461
_ACEOF
15462
 
15463
fi
15464
 
15465
echo "$as_me:$LINENO: checking for hypotl in -lm" >&5
15466
echo $ECHO_N "checking for hypotl in -lm... $ECHO_C" >&6
15467
if test "${ac_cv_lib_m_hypotl+set}" = set; then
15468
  echo $ECHO_N "(cached) $ECHO_C" >&6
15469
else
15470
  ac_check_lib_save_LIBS=$LIBS
15471
LIBS="-lm  $LIBS"
15472
if test x$gcc_no_link = xyes; then
15473
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15474
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15475
   { (exit 1); exit 1; }; }
15476
fi
15477
cat >conftest.$ac_ext <<_ACEOF
15478
/* confdefs.h.  */
15479
_ACEOF
15480
cat confdefs.h >>conftest.$ac_ext
15481
cat >>conftest.$ac_ext <<_ACEOF
15482
/* end confdefs.h.  */
15483
 
15484
/* Override any gcc2 internal prototype to avoid an error.  */
15485
#ifdef __cplusplus
15486
extern "C"
15487
#endif
15488
/* We use char because int might match the return type of a gcc2
15489
   builtin and then its argument prototype would still apply.  */
15490
char hypotl ();
15491
int
15492
main ()
15493
{
15494
hypotl ();
15495
  ;
15496
  return 0;
15497
}
15498
_ACEOF
15499
rm -f conftest.$ac_objext conftest$ac_exeext
15500
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15501
  (eval $ac_link) 2>conftest.er1
15502
  ac_status=$?
15503
  grep -v '^ *+' conftest.er1 >conftest.err
15504
  rm -f conftest.er1
15505
  cat conftest.err >&5
15506
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15507
  (exit $ac_status); } &&
15508
         { ac_try='test -z "$ac_c_werror_flag"
15509
                         || test ! -s conftest.err'
15510
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15511
  (eval $ac_try) 2>&5
15512
  ac_status=$?
15513
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15514
  (exit $ac_status); }; } &&
15515
         { ac_try='test -s conftest$ac_exeext'
15516
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15517
  (eval $ac_try) 2>&5
15518
  ac_status=$?
15519
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15520
  (exit $ac_status); }; }; then
15521
  ac_cv_lib_m_hypotl=yes
15522
else
15523
  echo "$as_me: failed program was:" >&5
15524
sed 's/^/| /' conftest.$ac_ext >&5
15525
 
15526
ac_cv_lib_m_hypotl=no
15527
fi
15528
rm -f conftest.err conftest.$ac_objext \
15529
      conftest$ac_exeext conftest.$ac_ext
15530
LIBS=$ac_check_lib_save_LIBS
15531
fi
15532
echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypotl" >&5
15533
echo "${ECHO_T}$ac_cv_lib_m_hypotl" >&6
15534
if test $ac_cv_lib_m_hypotl = yes; then
15535
 
15536
cat >>confdefs.h <<\_ACEOF
15537
#define HAVE_HYPOTL 1
15538
_ACEOF
15539
 
15540
fi
15541
 
15542
echo "$as_me:$LINENO: checking for logf in -lm" >&5
15543
echo $ECHO_N "checking for logf in -lm... $ECHO_C" >&6
15544
if test "${ac_cv_lib_m_logf+set}" = set; then
15545
  echo $ECHO_N "(cached) $ECHO_C" >&6
15546
else
15547
  ac_check_lib_save_LIBS=$LIBS
15548
LIBS="-lm  $LIBS"
15549
if test x$gcc_no_link = xyes; then
15550
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15551
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15552
   { (exit 1); exit 1; }; }
15553
fi
15554
cat >conftest.$ac_ext <<_ACEOF
15555
/* confdefs.h.  */
15556
_ACEOF
15557
cat confdefs.h >>conftest.$ac_ext
15558
cat >>conftest.$ac_ext <<_ACEOF
15559
/* end confdefs.h.  */
15560
 
15561
/* Override any gcc2 internal prototype to avoid an error.  */
15562
#ifdef __cplusplus
15563
extern "C"
15564
#endif
15565
/* We use char because int might match the return type of a gcc2
15566
   builtin and then its argument prototype would still apply.  */
15567
char logf ();
15568
int
15569
main ()
15570
{
15571
logf ();
15572
  ;
15573
  return 0;
15574
}
15575
_ACEOF
15576
rm -f conftest.$ac_objext conftest$ac_exeext
15577
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15578
  (eval $ac_link) 2>conftest.er1
15579
  ac_status=$?
15580
  grep -v '^ *+' conftest.er1 >conftest.err
15581
  rm -f conftest.er1
15582
  cat conftest.err >&5
15583
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15584
  (exit $ac_status); } &&
15585
         { ac_try='test -z "$ac_c_werror_flag"
15586
                         || test ! -s conftest.err'
15587
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15588
  (eval $ac_try) 2>&5
15589
  ac_status=$?
15590
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15591
  (exit $ac_status); }; } &&
15592
         { ac_try='test -s conftest$ac_exeext'
15593
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15594
  (eval $ac_try) 2>&5
15595
  ac_status=$?
15596
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15597
  (exit $ac_status); }; }; then
15598
  ac_cv_lib_m_logf=yes
15599
else
15600
  echo "$as_me: failed program was:" >&5
15601
sed 's/^/| /' conftest.$ac_ext >&5
15602
 
15603
ac_cv_lib_m_logf=no
15604
fi
15605
rm -f conftest.err conftest.$ac_objext \
15606
      conftest$ac_exeext conftest.$ac_ext
15607
LIBS=$ac_check_lib_save_LIBS
15608
fi
15609
echo "$as_me:$LINENO: result: $ac_cv_lib_m_logf" >&5
15610
echo "${ECHO_T}$ac_cv_lib_m_logf" >&6
15611
if test $ac_cv_lib_m_logf = yes; then
15612
 
15613
cat >>confdefs.h <<\_ACEOF
15614
#define HAVE_LOGF 1
15615
_ACEOF
15616
 
15617
fi
15618
 
15619
echo "$as_me:$LINENO: checking for log in -lm" >&5
15620
echo $ECHO_N "checking for log in -lm... $ECHO_C" >&6
15621
if test "${ac_cv_lib_m_log+set}" = set; then
15622
  echo $ECHO_N "(cached) $ECHO_C" >&6
15623
else
15624
  ac_check_lib_save_LIBS=$LIBS
15625
LIBS="-lm  $LIBS"
15626
if test x$gcc_no_link = xyes; then
15627
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15628
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15629
   { (exit 1); exit 1; }; }
15630
fi
15631
cat >conftest.$ac_ext <<_ACEOF
15632
/* confdefs.h.  */
15633
_ACEOF
15634
cat confdefs.h >>conftest.$ac_ext
15635
cat >>conftest.$ac_ext <<_ACEOF
15636
/* end confdefs.h.  */
15637
 
15638
/* Override any gcc2 internal prototype to avoid an error.  */
15639
#ifdef __cplusplus
15640
extern "C"
15641
#endif
15642
/* We use char because int might match the return type of a gcc2
15643
   builtin and then its argument prototype would still apply.  */
15644
char log ();
15645
int
15646
main ()
15647
{
15648
log ();
15649
  ;
15650
  return 0;
15651
}
15652
_ACEOF
15653
rm -f conftest.$ac_objext conftest$ac_exeext
15654
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15655
  (eval $ac_link) 2>conftest.er1
15656
  ac_status=$?
15657
  grep -v '^ *+' conftest.er1 >conftest.err
15658
  rm -f conftest.er1
15659
  cat conftest.err >&5
15660
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15661
  (exit $ac_status); } &&
15662
         { ac_try='test -z "$ac_c_werror_flag"
15663
                         || test ! -s conftest.err'
15664
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15665
  (eval $ac_try) 2>&5
15666
  ac_status=$?
15667
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15668
  (exit $ac_status); }; } &&
15669
         { ac_try='test -s conftest$ac_exeext'
15670
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15671
  (eval $ac_try) 2>&5
15672
  ac_status=$?
15673
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15674
  (exit $ac_status); }; }; then
15675
  ac_cv_lib_m_log=yes
15676
else
15677
  echo "$as_me: failed program was:" >&5
15678
sed 's/^/| /' conftest.$ac_ext >&5
15679
 
15680
ac_cv_lib_m_log=no
15681
fi
15682
rm -f conftest.err conftest.$ac_objext \
15683
      conftest$ac_exeext conftest.$ac_ext
15684
LIBS=$ac_check_lib_save_LIBS
15685
fi
15686
echo "$as_me:$LINENO: result: $ac_cv_lib_m_log" >&5
15687
echo "${ECHO_T}$ac_cv_lib_m_log" >&6
15688
if test $ac_cv_lib_m_log = yes; then
15689
 
15690
cat >>confdefs.h <<\_ACEOF
15691
#define HAVE_LOG 1
15692
_ACEOF
15693
 
15694
fi
15695
 
15696
echo "$as_me:$LINENO: checking for logl in -lm" >&5
15697
echo $ECHO_N "checking for logl in -lm... $ECHO_C" >&6
15698
if test "${ac_cv_lib_m_logl+set}" = set; then
15699
  echo $ECHO_N "(cached) $ECHO_C" >&6
15700
else
15701
  ac_check_lib_save_LIBS=$LIBS
15702
LIBS="-lm  $LIBS"
15703
if test x$gcc_no_link = xyes; then
15704
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15705
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15706
   { (exit 1); exit 1; }; }
15707
fi
15708
cat >conftest.$ac_ext <<_ACEOF
15709
/* confdefs.h.  */
15710
_ACEOF
15711
cat confdefs.h >>conftest.$ac_ext
15712
cat >>conftest.$ac_ext <<_ACEOF
15713
/* end confdefs.h.  */
15714
 
15715
/* Override any gcc2 internal prototype to avoid an error.  */
15716
#ifdef __cplusplus
15717
extern "C"
15718
#endif
15719
/* We use char because int might match the return type of a gcc2
15720
   builtin and then its argument prototype would still apply.  */
15721
char logl ();
15722
int
15723
main ()
15724
{
15725
logl ();
15726
  ;
15727
  return 0;
15728
}
15729
_ACEOF
15730
rm -f conftest.$ac_objext conftest$ac_exeext
15731
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15732
  (eval $ac_link) 2>conftest.er1
15733
  ac_status=$?
15734
  grep -v '^ *+' conftest.er1 >conftest.err
15735
  rm -f conftest.er1
15736
  cat conftest.err >&5
15737
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15738
  (exit $ac_status); } &&
15739
         { ac_try='test -z "$ac_c_werror_flag"
15740
                         || test ! -s conftest.err'
15741
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15742
  (eval $ac_try) 2>&5
15743
  ac_status=$?
15744
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15745
  (exit $ac_status); }; } &&
15746
         { ac_try='test -s conftest$ac_exeext'
15747
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15748
  (eval $ac_try) 2>&5
15749
  ac_status=$?
15750
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15751
  (exit $ac_status); }; }; then
15752
  ac_cv_lib_m_logl=yes
15753
else
15754
  echo "$as_me: failed program was:" >&5
15755
sed 's/^/| /' conftest.$ac_ext >&5
15756
 
15757
ac_cv_lib_m_logl=no
15758
fi
15759
rm -f conftest.err conftest.$ac_objext \
15760
      conftest$ac_exeext conftest.$ac_ext
15761
LIBS=$ac_check_lib_save_LIBS
15762
fi
15763
echo "$as_me:$LINENO: result: $ac_cv_lib_m_logl" >&5
15764
echo "${ECHO_T}$ac_cv_lib_m_logl" >&6
15765
if test $ac_cv_lib_m_logl = yes; then
15766
 
15767
cat >>confdefs.h <<\_ACEOF
15768
#define HAVE_LOGL 1
15769
_ACEOF
15770
 
15771
fi
15772
 
15773
echo "$as_me:$LINENO: checking for clogf in -lm" >&5
15774
echo $ECHO_N "checking for clogf in -lm... $ECHO_C" >&6
15775
if test "${ac_cv_lib_m_clogf+set}" = set; then
15776
  echo $ECHO_N "(cached) $ECHO_C" >&6
15777
else
15778
  ac_check_lib_save_LIBS=$LIBS
15779
LIBS="-lm  $LIBS"
15780
if test x$gcc_no_link = xyes; then
15781
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15782
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15783
   { (exit 1); exit 1; }; }
15784
fi
15785
cat >conftest.$ac_ext <<_ACEOF
15786
/* confdefs.h.  */
15787
_ACEOF
15788
cat confdefs.h >>conftest.$ac_ext
15789
cat >>conftest.$ac_ext <<_ACEOF
15790
/* end confdefs.h.  */
15791
 
15792
/* Override any gcc2 internal prototype to avoid an error.  */
15793
#ifdef __cplusplus
15794
extern "C"
15795
#endif
15796
/* We use char because int might match the return type of a gcc2
15797
   builtin and then its argument prototype would still apply.  */
15798
char clogf ();
15799
int
15800
main ()
15801
{
15802
clogf ();
15803
  ;
15804
  return 0;
15805
}
15806
_ACEOF
15807
rm -f conftest.$ac_objext conftest$ac_exeext
15808
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15809
  (eval $ac_link) 2>conftest.er1
15810
  ac_status=$?
15811
  grep -v '^ *+' conftest.er1 >conftest.err
15812
  rm -f conftest.er1
15813
  cat conftest.err >&5
15814
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15815
  (exit $ac_status); } &&
15816
         { ac_try='test -z "$ac_c_werror_flag"
15817
                         || test ! -s conftest.err'
15818
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15819
  (eval $ac_try) 2>&5
15820
  ac_status=$?
15821
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15822
  (exit $ac_status); }; } &&
15823
         { ac_try='test -s conftest$ac_exeext'
15824
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15825
  (eval $ac_try) 2>&5
15826
  ac_status=$?
15827
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15828
  (exit $ac_status); }; }; then
15829
  ac_cv_lib_m_clogf=yes
15830
else
15831
  echo "$as_me: failed program was:" >&5
15832
sed 's/^/| /' conftest.$ac_ext >&5
15833
 
15834
ac_cv_lib_m_clogf=no
15835
fi
15836
rm -f conftest.err conftest.$ac_objext \
15837
      conftest$ac_exeext conftest.$ac_ext
15838
LIBS=$ac_check_lib_save_LIBS
15839
fi
15840
echo "$as_me:$LINENO: result: $ac_cv_lib_m_clogf" >&5
15841
echo "${ECHO_T}$ac_cv_lib_m_clogf" >&6
15842
if test $ac_cv_lib_m_clogf = yes; then
15843
 
15844
cat >>confdefs.h <<\_ACEOF
15845
#define HAVE_CLOGF 1
15846
_ACEOF
15847
 
15848
fi
15849
 
15850
echo "$as_me:$LINENO: checking for clog in -lm" >&5
15851
echo $ECHO_N "checking for clog in -lm... $ECHO_C" >&6
15852
if test "${ac_cv_lib_m_clog+set}" = set; then
15853
  echo $ECHO_N "(cached) $ECHO_C" >&6
15854
else
15855
  ac_check_lib_save_LIBS=$LIBS
15856
LIBS="-lm  $LIBS"
15857
if test x$gcc_no_link = xyes; then
15858
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15859
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15860
   { (exit 1); exit 1; }; }
15861
fi
15862
cat >conftest.$ac_ext <<_ACEOF
15863
/* confdefs.h.  */
15864
_ACEOF
15865
cat confdefs.h >>conftest.$ac_ext
15866
cat >>conftest.$ac_ext <<_ACEOF
15867
/* end confdefs.h.  */
15868
 
15869
/* Override any gcc2 internal prototype to avoid an error.  */
15870
#ifdef __cplusplus
15871
extern "C"
15872
#endif
15873
/* We use char because int might match the return type of a gcc2
15874
   builtin and then its argument prototype would still apply.  */
15875
char clog ();
15876
int
15877
main ()
15878
{
15879
clog ();
15880
  ;
15881
  return 0;
15882
}
15883
_ACEOF
15884
rm -f conftest.$ac_objext conftest$ac_exeext
15885
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15886
  (eval $ac_link) 2>conftest.er1
15887
  ac_status=$?
15888
  grep -v '^ *+' conftest.er1 >conftest.err
15889
  rm -f conftest.er1
15890
  cat conftest.err >&5
15891
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15892
  (exit $ac_status); } &&
15893
         { ac_try='test -z "$ac_c_werror_flag"
15894
                         || test ! -s conftest.err'
15895
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15896
  (eval $ac_try) 2>&5
15897
  ac_status=$?
15898
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15899
  (exit $ac_status); }; } &&
15900
         { ac_try='test -s conftest$ac_exeext'
15901
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15902
  (eval $ac_try) 2>&5
15903
  ac_status=$?
15904
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15905
  (exit $ac_status); }; }; then
15906
  ac_cv_lib_m_clog=yes
15907
else
15908
  echo "$as_me: failed program was:" >&5
15909
sed 's/^/| /' conftest.$ac_ext >&5
15910
 
15911
ac_cv_lib_m_clog=no
15912
fi
15913
rm -f conftest.err conftest.$ac_objext \
15914
      conftest$ac_exeext conftest.$ac_ext
15915
LIBS=$ac_check_lib_save_LIBS
15916
fi
15917
echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog" >&5
15918
echo "${ECHO_T}$ac_cv_lib_m_clog" >&6
15919
if test $ac_cv_lib_m_clog = yes; then
15920
 
15921
cat >>confdefs.h <<\_ACEOF
15922
#define HAVE_CLOG 1
15923
_ACEOF
15924
 
15925
fi
15926
 
15927
echo "$as_me:$LINENO: checking for clogl in -lm" >&5
15928
echo $ECHO_N "checking for clogl in -lm... $ECHO_C" >&6
15929
if test "${ac_cv_lib_m_clogl+set}" = set; then
15930
  echo $ECHO_N "(cached) $ECHO_C" >&6
15931
else
15932
  ac_check_lib_save_LIBS=$LIBS
15933
LIBS="-lm  $LIBS"
15934
if test x$gcc_no_link = xyes; then
15935
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15936
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15937
   { (exit 1); exit 1; }; }
15938
fi
15939
cat >conftest.$ac_ext <<_ACEOF
15940
/* confdefs.h.  */
15941
_ACEOF
15942
cat confdefs.h >>conftest.$ac_ext
15943
cat >>conftest.$ac_ext <<_ACEOF
15944
/* end confdefs.h.  */
15945
 
15946
/* Override any gcc2 internal prototype to avoid an error.  */
15947
#ifdef __cplusplus
15948
extern "C"
15949
#endif
15950
/* We use char because int might match the return type of a gcc2
15951
   builtin and then its argument prototype would still apply.  */
15952
char clogl ();
15953
int
15954
main ()
15955
{
15956
clogl ();
15957
  ;
15958
  return 0;
15959
}
15960
_ACEOF
15961
rm -f conftest.$ac_objext conftest$ac_exeext
15962
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15963
  (eval $ac_link) 2>conftest.er1
15964
  ac_status=$?
15965
  grep -v '^ *+' conftest.er1 >conftest.err
15966
  rm -f conftest.er1
15967
  cat conftest.err >&5
15968
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15969
  (exit $ac_status); } &&
15970
         { ac_try='test -z "$ac_c_werror_flag"
15971
                         || test ! -s conftest.err'
15972
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15973
  (eval $ac_try) 2>&5
15974
  ac_status=$?
15975
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15976
  (exit $ac_status); }; } &&
15977
         { ac_try='test -s conftest$ac_exeext'
15978
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15979
  (eval $ac_try) 2>&5
15980
  ac_status=$?
15981
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15982
  (exit $ac_status); }; }; then
15983
  ac_cv_lib_m_clogl=yes
15984
else
15985
  echo "$as_me: failed program was:" >&5
15986
sed 's/^/| /' conftest.$ac_ext >&5
15987
 
15988
ac_cv_lib_m_clogl=no
15989
fi
15990
rm -f conftest.err conftest.$ac_objext \
15991
      conftest$ac_exeext conftest.$ac_ext
15992
LIBS=$ac_check_lib_save_LIBS
15993
fi
15994
echo "$as_me:$LINENO: result: $ac_cv_lib_m_clogl" >&5
15995
echo "${ECHO_T}$ac_cv_lib_m_clogl" >&6
15996
if test $ac_cv_lib_m_clogl = yes; then
15997
 
15998
cat >>confdefs.h <<\_ACEOF
15999
#define HAVE_CLOGL 1
16000
_ACEOF
16001
 
16002
fi
16003
 
16004
echo "$as_me:$LINENO: checking for log10f in -lm" >&5
16005
echo $ECHO_N "checking for log10f in -lm... $ECHO_C" >&6
16006
if test "${ac_cv_lib_m_log10f+set}" = set; then
16007
  echo $ECHO_N "(cached) $ECHO_C" >&6
16008
else
16009
  ac_check_lib_save_LIBS=$LIBS
16010
LIBS="-lm  $LIBS"
16011
if test x$gcc_no_link = xyes; then
16012
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16013
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16014
   { (exit 1); exit 1; }; }
16015
fi
16016
cat >conftest.$ac_ext <<_ACEOF
16017
/* confdefs.h.  */
16018
_ACEOF
16019
cat confdefs.h >>conftest.$ac_ext
16020
cat >>conftest.$ac_ext <<_ACEOF
16021
/* end confdefs.h.  */
16022
 
16023
/* Override any gcc2 internal prototype to avoid an error.  */
16024
#ifdef __cplusplus
16025
extern "C"
16026
#endif
16027
/* We use char because int might match the return type of a gcc2
16028
   builtin and then its argument prototype would still apply.  */
16029
char log10f ();
16030
int
16031
main ()
16032
{
16033
log10f ();
16034
  ;
16035
  return 0;
16036
}
16037
_ACEOF
16038
rm -f conftest.$ac_objext conftest$ac_exeext
16039
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16040
  (eval $ac_link) 2>conftest.er1
16041
  ac_status=$?
16042
  grep -v '^ *+' conftest.er1 >conftest.err
16043
  rm -f conftest.er1
16044
  cat conftest.err >&5
16045
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16046
  (exit $ac_status); } &&
16047
         { ac_try='test -z "$ac_c_werror_flag"
16048
                         || test ! -s conftest.err'
16049
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16050
  (eval $ac_try) 2>&5
16051
  ac_status=$?
16052
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16053
  (exit $ac_status); }; } &&
16054
         { ac_try='test -s conftest$ac_exeext'
16055
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16056
  (eval $ac_try) 2>&5
16057
  ac_status=$?
16058
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16059
  (exit $ac_status); }; }; then
16060
  ac_cv_lib_m_log10f=yes
16061
else
16062
  echo "$as_me: failed program was:" >&5
16063
sed 's/^/| /' conftest.$ac_ext >&5
16064
 
16065
ac_cv_lib_m_log10f=no
16066
fi
16067
rm -f conftest.err conftest.$ac_objext \
16068
      conftest$ac_exeext conftest.$ac_ext
16069
LIBS=$ac_check_lib_save_LIBS
16070
fi
16071
echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10f" >&5
16072
echo "${ECHO_T}$ac_cv_lib_m_log10f" >&6
16073
if test $ac_cv_lib_m_log10f = yes; then
16074
 
16075
cat >>confdefs.h <<\_ACEOF
16076
#define HAVE_LOG10F 1
16077
_ACEOF
16078
 
16079
fi
16080
 
16081
echo "$as_me:$LINENO: checking for log10 in -lm" >&5
16082
echo $ECHO_N "checking for log10 in -lm... $ECHO_C" >&6
16083
if test "${ac_cv_lib_m_log10+set}" = set; then
16084
  echo $ECHO_N "(cached) $ECHO_C" >&6
16085
else
16086
  ac_check_lib_save_LIBS=$LIBS
16087
LIBS="-lm  $LIBS"
16088
if test x$gcc_no_link = xyes; then
16089
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16090
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16091
   { (exit 1); exit 1; }; }
16092
fi
16093
cat >conftest.$ac_ext <<_ACEOF
16094
/* confdefs.h.  */
16095
_ACEOF
16096
cat confdefs.h >>conftest.$ac_ext
16097
cat >>conftest.$ac_ext <<_ACEOF
16098
/* end confdefs.h.  */
16099
 
16100
/* Override any gcc2 internal prototype to avoid an error.  */
16101
#ifdef __cplusplus
16102
extern "C"
16103
#endif
16104
/* We use char because int might match the return type of a gcc2
16105
   builtin and then its argument prototype would still apply.  */
16106
char log10 ();
16107
int
16108
main ()
16109
{
16110
log10 ();
16111
  ;
16112
  return 0;
16113
}
16114
_ACEOF
16115
rm -f conftest.$ac_objext conftest$ac_exeext
16116
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16117
  (eval $ac_link) 2>conftest.er1
16118
  ac_status=$?
16119
  grep -v '^ *+' conftest.er1 >conftest.err
16120
  rm -f conftest.er1
16121
  cat conftest.err >&5
16122
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16123
  (exit $ac_status); } &&
16124
         { ac_try='test -z "$ac_c_werror_flag"
16125
                         || test ! -s conftest.err'
16126
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16127
  (eval $ac_try) 2>&5
16128
  ac_status=$?
16129
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16130
  (exit $ac_status); }; } &&
16131
         { ac_try='test -s conftest$ac_exeext'
16132
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16133
  (eval $ac_try) 2>&5
16134
  ac_status=$?
16135
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16136
  (exit $ac_status); }; }; then
16137
  ac_cv_lib_m_log10=yes
16138
else
16139
  echo "$as_me: failed program was:" >&5
16140
sed 's/^/| /' conftest.$ac_ext >&5
16141
 
16142
ac_cv_lib_m_log10=no
16143
fi
16144
rm -f conftest.err conftest.$ac_objext \
16145
      conftest$ac_exeext conftest.$ac_ext
16146
LIBS=$ac_check_lib_save_LIBS
16147
fi
16148
echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10" >&5
16149
echo "${ECHO_T}$ac_cv_lib_m_log10" >&6
16150
if test $ac_cv_lib_m_log10 = yes; then
16151
 
16152
cat >>confdefs.h <<\_ACEOF
16153
#define HAVE_LOG10 1
16154
_ACEOF
16155
 
16156
fi
16157
 
16158
echo "$as_me:$LINENO: checking for log10l in -lm" >&5
16159
echo $ECHO_N "checking for log10l in -lm... $ECHO_C" >&6
16160
if test "${ac_cv_lib_m_log10l+set}" = set; then
16161
  echo $ECHO_N "(cached) $ECHO_C" >&6
16162
else
16163
  ac_check_lib_save_LIBS=$LIBS
16164
LIBS="-lm  $LIBS"
16165
if test x$gcc_no_link = xyes; then
16166
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16167
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16168
   { (exit 1); exit 1; }; }
16169
fi
16170
cat >conftest.$ac_ext <<_ACEOF
16171
/* confdefs.h.  */
16172
_ACEOF
16173
cat confdefs.h >>conftest.$ac_ext
16174
cat >>conftest.$ac_ext <<_ACEOF
16175
/* end confdefs.h.  */
16176
 
16177
/* Override any gcc2 internal prototype to avoid an error.  */
16178
#ifdef __cplusplus
16179
extern "C"
16180
#endif
16181
/* We use char because int might match the return type of a gcc2
16182
   builtin and then its argument prototype would still apply.  */
16183
char log10l ();
16184
int
16185
main ()
16186
{
16187
log10l ();
16188
  ;
16189
  return 0;
16190
}
16191
_ACEOF
16192
rm -f conftest.$ac_objext conftest$ac_exeext
16193
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16194
  (eval $ac_link) 2>conftest.er1
16195
  ac_status=$?
16196
  grep -v '^ *+' conftest.er1 >conftest.err
16197
  rm -f conftest.er1
16198
  cat conftest.err >&5
16199
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16200
  (exit $ac_status); } &&
16201
         { ac_try='test -z "$ac_c_werror_flag"
16202
                         || test ! -s conftest.err'
16203
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16204
  (eval $ac_try) 2>&5
16205
  ac_status=$?
16206
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16207
  (exit $ac_status); }; } &&
16208
         { ac_try='test -s conftest$ac_exeext'
16209
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16210
  (eval $ac_try) 2>&5
16211
  ac_status=$?
16212
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16213
  (exit $ac_status); }; }; then
16214
  ac_cv_lib_m_log10l=yes
16215
else
16216
  echo "$as_me: failed program was:" >&5
16217
sed 's/^/| /' conftest.$ac_ext >&5
16218
 
16219
ac_cv_lib_m_log10l=no
16220
fi
16221
rm -f conftest.err conftest.$ac_objext \
16222
      conftest$ac_exeext conftest.$ac_ext
16223
LIBS=$ac_check_lib_save_LIBS
16224
fi
16225
echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10l" >&5
16226
echo "${ECHO_T}$ac_cv_lib_m_log10l" >&6
16227
if test $ac_cv_lib_m_log10l = yes; then
16228
 
16229
cat >>confdefs.h <<\_ACEOF
16230
#define HAVE_LOG10L 1
16231
_ACEOF
16232
 
16233
fi
16234
 
16235
echo "$as_me:$LINENO: checking for clog10f in -lm" >&5
16236
echo $ECHO_N "checking for clog10f in -lm... $ECHO_C" >&6
16237
if test "${ac_cv_lib_m_clog10f+set}" = set; then
16238
  echo $ECHO_N "(cached) $ECHO_C" >&6
16239
else
16240
  ac_check_lib_save_LIBS=$LIBS
16241
LIBS="-lm  $LIBS"
16242
if test x$gcc_no_link = xyes; then
16243
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16244
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16245
   { (exit 1); exit 1; }; }
16246
fi
16247
cat >conftest.$ac_ext <<_ACEOF
16248
/* confdefs.h.  */
16249
_ACEOF
16250
cat confdefs.h >>conftest.$ac_ext
16251
cat >>conftest.$ac_ext <<_ACEOF
16252
/* end confdefs.h.  */
16253
 
16254
/* Override any gcc2 internal prototype to avoid an error.  */
16255
#ifdef __cplusplus
16256
extern "C"
16257
#endif
16258
/* We use char because int might match the return type of a gcc2
16259
   builtin and then its argument prototype would still apply.  */
16260
char clog10f ();
16261
int
16262
main ()
16263
{
16264
clog10f ();
16265
  ;
16266
  return 0;
16267
}
16268
_ACEOF
16269
rm -f conftest.$ac_objext conftest$ac_exeext
16270
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16271
  (eval $ac_link) 2>conftest.er1
16272
  ac_status=$?
16273
  grep -v '^ *+' conftest.er1 >conftest.err
16274
  rm -f conftest.er1
16275
  cat conftest.err >&5
16276
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16277
  (exit $ac_status); } &&
16278
         { ac_try='test -z "$ac_c_werror_flag"
16279
                         || test ! -s conftest.err'
16280
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16281
  (eval $ac_try) 2>&5
16282
  ac_status=$?
16283
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16284
  (exit $ac_status); }; } &&
16285
         { ac_try='test -s conftest$ac_exeext'
16286
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16287
  (eval $ac_try) 2>&5
16288
  ac_status=$?
16289
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16290
  (exit $ac_status); }; }; then
16291
  ac_cv_lib_m_clog10f=yes
16292
else
16293
  echo "$as_me: failed program was:" >&5
16294
sed 's/^/| /' conftest.$ac_ext >&5
16295
 
16296
ac_cv_lib_m_clog10f=no
16297
fi
16298
rm -f conftest.err conftest.$ac_objext \
16299
      conftest$ac_exeext conftest.$ac_ext
16300
LIBS=$ac_check_lib_save_LIBS
16301
fi
16302
echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10f" >&5
16303
echo "${ECHO_T}$ac_cv_lib_m_clog10f" >&6
16304
if test $ac_cv_lib_m_clog10f = yes; then
16305
 
16306
cat >>confdefs.h <<\_ACEOF
16307
#define HAVE_CLOG10F 1
16308
_ACEOF
16309
 
16310
fi
16311
 
16312
echo "$as_me:$LINENO: checking for clog10 in -lm" >&5
16313
echo $ECHO_N "checking for clog10 in -lm... $ECHO_C" >&6
16314
if test "${ac_cv_lib_m_clog10+set}" = set; then
16315
  echo $ECHO_N "(cached) $ECHO_C" >&6
16316
else
16317
  ac_check_lib_save_LIBS=$LIBS
16318
LIBS="-lm  $LIBS"
16319
if test x$gcc_no_link = xyes; then
16320
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16321
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16322
   { (exit 1); exit 1; }; }
16323
fi
16324
cat >conftest.$ac_ext <<_ACEOF
16325
/* confdefs.h.  */
16326
_ACEOF
16327
cat confdefs.h >>conftest.$ac_ext
16328
cat >>conftest.$ac_ext <<_ACEOF
16329
/* end confdefs.h.  */
16330
 
16331
/* Override any gcc2 internal prototype to avoid an error.  */
16332
#ifdef __cplusplus
16333
extern "C"
16334
#endif
16335
/* We use char because int might match the return type of a gcc2
16336
   builtin and then its argument prototype would still apply.  */
16337
char clog10 ();
16338
int
16339
main ()
16340
{
16341
clog10 ();
16342
  ;
16343
  return 0;
16344
}
16345
_ACEOF
16346
rm -f conftest.$ac_objext conftest$ac_exeext
16347
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16348
  (eval $ac_link) 2>conftest.er1
16349
  ac_status=$?
16350
  grep -v '^ *+' conftest.er1 >conftest.err
16351
  rm -f conftest.er1
16352
  cat conftest.err >&5
16353
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16354
  (exit $ac_status); } &&
16355
         { ac_try='test -z "$ac_c_werror_flag"
16356
                         || test ! -s conftest.err'
16357
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16358
  (eval $ac_try) 2>&5
16359
  ac_status=$?
16360
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16361
  (exit $ac_status); }; } &&
16362
         { ac_try='test -s conftest$ac_exeext'
16363
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16364
  (eval $ac_try) 2>&5
16365
  ac_status=$?
16366
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16367
  (exit $ac_status); }; }; then
16368
  ac_cv_lib_m_clog10=yes
16369
else
16370
  echo "$as_me: failed program was:" >&5
16371
sed 's/^/| /' conftest.$ac_ext >&5
16372
 
16373
ac_cv_lib_m_clog10=no
16374
fi
16375
rm -f conftest.err conftest.$ac_objext \
16376
      conftest$ac_exeext conftest.$ac_ext
16377
LIBS=$ac_check_lib_save_LIBS
16378
fi
16379
echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10" >&5
16380
echo "${ECHO_T}$ac_cv_lib_m_clog10" >&6
16381
if test $ac_cv_lib_m_clog10 = yes; then
16382
 
16383
cat >>confdefs.h <<\_ACEOF
16384
#define HAVE_CLOG10 1
16385
_ACEOF
16386
 
16387
fi
16388
 
16389
echo "$as_me:$LINENO: checking for clog10l in -lm" >&5
16390
echo $ECHO_N "checking for clog10l in -lm... $ECHO_C" >&6
16391
if test "${ac_cv_lib_m_clog10l+set}" = set; then
16392
  echo $ECHO_N "(cached) $ECHO_C" >&6
16393
else
16394
  ac_check_lib_save_LIBS=$LIBS
16395
LIBS="-lm  $LIBS"
16396
if test x$gcc_no_link = xyes; then
16397
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16398
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16399
   { (exit 1); exit 1; }; }
16400
fi
16401
cat >conftest.$ac_ext <<_ACEOF
16402
/* confdefs.h.  */
16403
_ACEOF
16404
cat confdefs.h >>conftest.$ac_ext
16405
cat >>conftest.$ac_ext <<_ACEOF
16406
/* end confdefs.h.  */
16407
 
16408
/* Override any gcc2 internal prototype to avoid an error.  */
16409
#ifdef __cplusplus
16410
extern "C"
16411
#endif
16412
/* We use char because int might match the return type of a gcc2
16413
   builtin and then its argument prototype would still apply.  */
16414
char clog10l ();
16415
int
16416
main ()
16417
{
16418
clog10l ();
16419
  ;
16420
  return 0;
16421
}
16422
_ACEOF
16423
rm -f conftest.$ac_objext conftest$ac_exeext
16424
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16425
  (eval $ac_link) 2>conftest.er1
16426
  ac_status=$?
16427
  grep -v '^ *+' conftest.er1 >conftest.err
16428
  rm -f conftest.er1
16429
  cat conftest.err >&5
16430
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16431
  (exit $ac_status); } &&
16432
         { ac_try='test -z "$ac_c_werror_flag"
16433
                         || test ! -s conftest.err'
16434
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16435
  (eval $ac_try) 2>&5
16436
  ac_status=$?
16437
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16438
  (exit $ac_status); }; } &&
16439
         { ac_try='test -s conftest$ac_exeext'
16440
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16441
  (eval $ac_try) 2>&5
16442
  ac_status=$?
16443
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16444
  (exit $ac_status); }; }; then
16445
  ac_cv_lib_m_clog10l=yes
16446
else
16447
  echo "$as_me: failed program was:" >&5
16448
sed 's/^/| /' conftest.$ac_ext >&5
16449
 
16450
ac_cv_lib_m_clog10l=no
16451
fi
16452
rm -f conftest.err conftest.$ac_objext \
16453
      conftest$ac_exeext conftest.$ac_ext
16454
LIBS=$ac_check_lib_save_LIBS
16455
fi
16456
echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10l" >&5
16457
echo "${ECHO_T}$ac_cv_lib_m_clog10l" >&6
16458
if test $ac_cv_lib_m_clog10l = yes; then
16459
 
16460
cat >>confdefs.h <<\_ACEOF
16461
#define HAVE_CLOG10L 1
16462
_ACEOF
16463
 
16464
fi
16465
 
16466
echo "$as_me:$LINENO: checking for nextafterf in -lm" >&5
16467
echo $ECHO_N "checking for nextafterf in -lm... $ECHO_C" >&6
16468
if test "${ac_cv_lib_m_nextafterf+set}" = set; then
16469
  echo $ECHO_N "(cached) $ECHO_C" >&6
16470
else
16471
  ac_check_lib_save_LIBS=$LIBS
16472
LIBS="-lm  $LIBS"
16473
if test x$gcc_no_link = xyes; then
16474
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16475
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16476
   { (exit 1); exit 1; }; }
16477
fi
16478
cat >conftest.$ac_ext <<_ACEOF
16479
/* confdefs.h.  */
16480
_ACEOF
16481
cat confdefs.h >>conftest.$ac_ext
16482
cat >>conftest.$ac_ext <<_ACEOF
16483
/* end confdefs.h.  */
16484
 
16485
/* Override any gcc2 internal prototype to avoid an error.  */
16486
#ifdef __cplusplus
16487
extern "C"
16488
#endif
16489
/* We use char because int might match the return type of a gcc2
16490
   builtin and then its argument prototype would still apply.  */
16491
char nextafterf ();
16492
int
16493
main ()
16494
{
16495
nextafterf ();
16496
  ;
16497
  return 0;
16498
}
16499
_ACEOF
16500
rm -f conftest.$ac_objext conftest$ac_exeext
16501
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16502
  (eval $ac_link) 2>conftest.er1
16503
  ac_status=$?
16504
  grep -v '^ *+' conftest.er1 >conftest.err
16505
  rm -f conftest.er1
16506
  cat conftest.err >&5
16507
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16508
  (exit $ac_status); } &&
16509
         { ac_try='test -z "$ac_c_werror_flag"
16510
                         || test ! -s conftest.err'
16511
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16512
  (eval $ac_try) 2>&5
16513
  ac_status=$?
16514
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16515
  (exit $ac_status); }; } &&
16516
         { ac_try='test -s conftest$ac_exeext'
16517
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16518
  (eval $ac_try) 2>&5
16519
  ac_status=$?
16520
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16521
  (exit $ac_status); }; }; then
16522
  ac_cv_lib_m_nextafterf=yes
16523
else
16524
  echo "$as_me: failed program was:" >&5
16525
sed 's/^/| /' conftest.$ac_ext >&5
16526
 
16527
ac_cv_lib_m_nextafterf=no
16528
fi
16529
rm -f conftest.err conftest.$ac_objext \
16530
      conftest$ac_exeext conftest.$ac_ext
16531
LIBS=$ac_check_lib_save_LIBS
16532
fi
16533
echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafterf" >&5
16534
echo "${ECHO_T}$ac_cv_lib_m_nextafterf" >&6
16535
if test $ac_cv_lib_m_nextafterf = yes; then
16536
 
16537
cat >>confdefs.h <<\_ACEOF
16538
#define HAVE_NEXTAFTERF 1
16539
_ACEOF
16540
 
16541
fi
16542
 
16543
echo "$as_me:$LINENO: checking for nextafter in -lm" >&5
16544
echo $ECHO_N "checking for nextafter in -lm... $ECHO_C" >&6
16545
if test "${ac_cv_lib_m_nextafter+set}" = set; then
16546
  echo $ECHO_N "(cached) $ECHO_C" >&6
16547
else
16548
  ac_check_lib_save_LIBS=$LIBS
16549
LIBS="-lm  $LIBS"
16550
if test x$gcc_no_link = xyes; then
16551
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16552
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16553
   { (exit 1); exit 1; }; }
16554
fi
16555
cat >conftest.$ac_ext <<_ACEOF
16556
/* confdefs.h.  */
16557
_ACEOF
16558
cat confdefs.h >>conftest.$ac_ext
16559
cat >>conftest.$ac_ext <<_ACEOF
16560
/* end confdefs.h.  */
16561
 
16562
/* Override any gcc2 internal prototype to avoid an error.  */
16563
#ifdef __cplusplus
16564
extern "C"
16565
#endif
16566
/* We use char because int might match the return type of a gcc2
16567
   builtin and then its argument prototype would still apply.  */
16568
char nextafter ();
16569
int
16570
main ()
16571
{
16572
nextafter ();
16573
  ;
16574
  return 0;
16575
}
16576
_ACEOF
16577
rm -f conftest.$ac_objext conftest$ac_exeext
16578
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16579
  (eval $ac_link) 2>conftest.er1
16580
  ac_status=$?
16581
  grep -v '^ *+' conftest.er1 >conftest.err
16582
  rm -f conftest.er1
16583
  cat conftest.err >&5
16584
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16585
  (exit $ac_status); } &&
16586
         { ac_try='test -z "$ac_c_werror_flag"
16587
                         || test ! -s conftest.err'
16588
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16589
  (eval $ac_try) 2>&5
16590
  ac_status=$?
16591
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16592
  (exit $ac_status); }; } &&
16593
         { ac_try='test -s conftest$ac_exeext'
16594
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16595
  (eval $ac_try) 2>&5
16596
  ac_status=$?
16597
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16598
  (exit $ac_status); }; }; then
16599
  ac_cv_lib_m_nextafter=yes
16600
else
16601
  echo "$as_me: failed program was:" >&5
16602
sed 's/^/| /' conftest.$ac_ext >&5
16603
 
16604
ac_cv_lib_m_nextafter=no
16605
fi
16606
rm -f conftest.err conftest.$ac_objext \
16607
      conftest$ac_exeext conftest.$ac_ext
16608
LIBS=$ac_check_lib_save_LIBS
16609
fi
16610
echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafter" >&5
16611
echo "${ECHO_T}$ac_cv_lib_m_nextafter" >&6
16612
if test $ac_cv_lib_m_nextafter = yes; then
16613
 
16614
cat >>confdefs.h <<\_ACEOF
16615
#define HAVE_NEXTAFTER 1
16616
_ACEOF
16617
 
16618
fi
16619
 
16620
echo "$as_me:$LINENO: checking for nextafterl in -lm" >&5
16621
echo $ECHO_N "checking for nextafterl in -lm... $ECHO_C" >&6
16622
if test "${ac_cv_lib_m_nextafterl+set}" = set; then
16623
  echo $ECHO_N "(cached) $ECHO_C" >&6
16624
else
16625
  ac_check_lib_save_LIBS=$LIBS
16626
LIBS="-lm  $LIBS"
16627
if test x$gcc_no_link = xyes; then
16628
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16629
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16630
   { (exit 1); exit 1; }; }
16631
fi
16632
cat >conftest.$ac_ext <<_ACEOF
16633
/* confdefs.h.  */
16634
_ACEOF
16635
cat confdefs.h >>conftest.$ac_ext
16636
cat >>conftest.$ac_ext <<_ACEOF
16637
/* end confdefs.h.  */
16638
 
16639
/* Override any gcc2 internal prototype to avoid an error.  */
16640
#ifdef __cplusplus
16641
extern "C"
16642
#endif
16643
/* We use char because int might match the return type of a gcc2
16644
   builtin and then its argument prototype would still apply.  */
16645
char nextafterl ();
16646
int
16647
main ()
16648
{
16649
nextafterl ();
16650
  ;
16651
  return 0;
16652
}
16653
_ACEOF
16654
rm -f conftest.$ac_objext conftest$ac_exeext
16655
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16656
  (eval $ac_link) 2>conftest.er1
16657
  ac_status=$?
16658
  grep -v '^ *+' conftest.er1 >conftest.err
16659
  rm -f conftest.er1
16660
  cat conftest.err >&5
16661
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16662
  (exit $ac_status); } &&
16663
         { ac_try='test -z "$ac_c_werror_flag"
16664
                         || test ! -s conftest.err'
16665
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16666
  (eval $ac_try) 2>&5
16667
  ac_status=$?
16668
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16669
  (exit $ac_status); }; } &&
16670
         { ac_try='test -s conftest$ac_exeext'
16671
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16672
  (eval $ac_try) 2>&5
16673
  ac_status=$?
16674
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16675
  (exit $ac_status); }; }; then
16676
  ac_cv_lib_m_nextafterl=yes
16677
else
16678
  echo "$as_me: failed program was:" >&5
16679
sed 's/^/| /' conftest.$ac_ext >&5
16680
 
16681
ac_cv_lib_m_nextafterl=no
16682
fi
16683
rm -f conftest.err conftest.$ac_objext \
16684
      conftest$ac_exeext conftest.$ac_ext
16685
LIBS=$ac_check_lib_save_LIBS
16686
fi
16687
echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafterl" >&5
16688
echo "${ECHO_T}$ac_cv_lib_m_nextafterl" >&6
16689
if test $ac_cv_lib_m_nextafterl = yes; then
16690
 
16691
cat >>confdefs.h <<\_ACEOF
16692
#define HAVE_NEXTAFTERL 1
16693
_ACEOF
16694
 
16695
fi
16696
 
16697
echo "$as_me:$LINENO: checking for powf in -lm" >&5
16698
echo $ECHO_N "checking for powf in -lm... $ECHO_C" >&6
16699
if test "${ac_cv_lib_m_powf+set}" = set; then
16700
  echo $ECHO_N "(cached) $ECHO_C" >&6
16701
else
16702
  ac_check_lib_save_LIBS=$LIBS
16703
LIBS="-lm  $LIBS"
16704
if test x$gcc_no_link = xyes; then
16705
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16706
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16707
   { (exit 1); exit 1; }; }
16708
fi
16709
cat >conftest.$ac_ext <<_ACEOF
16710
/* confdefs.h.  */
16711
_ACEOF
16712
cat confdefs.h >>conftest.$ac_ext
16713
cat >>conftest.$ac_ext <<_ACEOF
16714
/* end confdefs.h.  */
16715
 
16716
/* Override any gcc2 internal prototype to avoid an error.  */
16717
#ifdef __cplusplus
16718
extern "C"
16719
#endif
16720
/* We use char because int might match the return type of a gcc2
16721
   builtin and then its argument prototype would still apply.  */
16722
char powf ();
16723
int
16724
main ()
16725
{
16726
powf ();
16727
  ;
16728
  return 0;
16729
}
16730
_ACEOF
16731
rm -f conftest.$ac_objext conftest$ac_exeext
16732
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16733
  (eval $ac_link) 2>conftest.er1
16734
  ac_status=$?
16735
  grep -v '^ *+' conftest.er1 >conftest.err
16736
  rm -f conftest.er1
16737
  cat conftest.err >&5
16738
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16739
  (exit $ac_status); } &&
16740
         { ac_try='test -z "$ac_c_werror_flag"
16741
                         || test ! -s conftest.err'
16742
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16743
  (eval $ac_try) 2>&5
16744
  ac_status=$?
16745
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16746
  (exit $ac_status); }; } &&
16747
         { ac_try='test -s conftest$ac_exeext'
16748
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16749
  (eval $ac_try) 2>&5
16750
  ac_status=$?
16751
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16752
  (exit $ac_status); }; }; then
16753
  ac_cv_lib_m_powf=yes
16754
else
16755
  echo "$as_me: failed program was:" >&5
16756
sed 's/^/| /' conftest.$ac_ext >&5
16757
 
16758
ac_cv_lib_m_powf=no
16759
fi
16760
rm -f conftest.err conftest.$ac_objext \
16761
      conftest$ac_exeext conftest.$ac_ext
16762
LIBS=$ac_check_lib_save_LIBS
16763
fi
16764
echo "$as_me:$LINENO: result: $ac_cv_lib_m_powf" >&5
16765
echo "${ECHO_T}$ac_cv_lib_m_powf" >&6
16766
if test $ac_cv_lib_m_powf = yes; then
16767
 
16768
cat >>confdefs.h <<\_ACEOF
16769
#define HAVE_POWF 1
16770
_ACEOF
16771
 
16772
fi
16773
 
16774
echo "$as_me:$LINENO: checking for pow in -lm" >&5
16775
echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
16776
if test "${ac_cv_lib_m_pow+set}" = set; then
16777
  echo $ECHO_N "(cached) $ECHO_C" >&6
16778
else
16779
  ac_check_lib_save_LIBS=$LIBS
16780
LIBS="-lm  $LIBS"
16781
if test x$gcc_no_link = xyes; then
16782
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16783
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16784
   { (exit 1); exit 1; }; }
16785
fi
16786
cat >conftest.$ac_ext <<_ACEOF
16787
/* confdefs.h.  */
16788
_ACEOF
16789
cat confdefs.h >>conftest.$ac_ext
16790
cat >>conftest.$ac_ext <<_ACEOF
16791
/* end confdefs.h.  */
16792
 
16793
/* Override any gcc2 internal prototype to avoid an error.  */
16794
#ifdef __cplusplus
16795
extern "C"
16796
#endif
16797
/* We use char because int might match the return type of a gcc2
16798
   builtin and then its argument prototype would still apply.  */
16799
char pow ();
16800
int
16801
main ()
16802
{
16803
pow ();
16804
  ;
16805
  return 0;
16806
}
16807
_ACEOF
16808
rm -f conftest.$ac_objext conftest$ac_exeext
16809
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16810
  (eval $ac_link) 2>conftest.er1
16811
  ac_status=$?
16812
  grep -v '^ *+' conftest.er1 >conftest.err
16813
  rm -f conftest.er1
16814
  cat conftest.err >&5
16815
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16816
  (exit $ac_status); } &&
16817
         { ac_try='test -z "$ac_c_werror_flag"
16818
                         || test ! -s conftest.err'
16819
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16820
  (eval $ac_try) 2>&5
16821
  ac_status=$?
16822
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16823
  (exit $ac_status); }; } &&
16824
         { ac_try='test -s conftest$ac_exeext'
16825
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16826
  (eval $ac_try) 2>&5
16827
  ac_status=$?
16828
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16829
  (exit $ac_status); }; }; then
16830
  ac_cv_lib_m_pow=yes
16831
else
16832
  echo "$as_me: failed program was:" >&5
16833
sed 's/^/| /' conftest.$ac_ext >&5
16834
 
16835
ac_cv_lib_m_pow=no
16836
fi
16837
rm -f conftest.err conftest.$ac_objext \
16838
      conftest$ac_exeext conftest.$ac_ext
16839
LIBS=$ac_check_lib_save_LIBS
16840
fi
16841
echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
16842
echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
16843
if test $ac_cv_lib_m_pow = yes; then
16844
 
16845
cat >>confdefs.h <<\_ACEOF
16846
#define HAVE_POW 1
16847
_ACEOF
16848
 
16849
fi
16850
 
16851
echo "$as_me:$LINENO: checking for powl in -lm" >&5
16852
echo $ECHO_N "checking for powl in -lm... $ECHO_C" >&6
16853
if test "${ac_cv_lib_m_powl+set}" = set; then
16854
  echo $ECHO_N "(cached) $ECHO_C" >&6
16855
else
16856
  ac_check_lib_save_LIBS=$LIBS
16857
LIBS="-lm  $LIBS"
16858
if test x$gcc_no_link = xyes; then
16859
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16860
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16861
   { (exit 1); exit 1; }; }
16862
fi
16863
cat >conftest.$ac_ext <<_ACEOF
16864
/* confdefs.h.  */
16865
_ACEOF
16866
cat confdefs.h >>conftest.$ac_ext
16867
cat >>conftest.$ac_ext <<_ACEOF
16868
/* end confdefs.h.  */
16869
 
16870
/* Override any gcc2 internal prototype to avoid an error.  */
16871
#ifdef __cplusplus
16872
extern "C"
16873
#endif
16874
/* We use char because int might match the return type of a gcc2
16875
   builtin and then its argument prototype would still apply.  */
16876
char powl ();
16877
int
16878
main ()
16879
{
16880
powl ();
16881
  ;
16882
  return 0;
16883
}
16884
_ACEOF
16885
rm -f conftest.$ac_objext conftest$ac_exeext
16886
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16887
  (eval $ac_link) 2>conftest.er1
16888
  ac_status=$?
16889
  grep -v '^ *+' conftest.er1 >conftest.err
16890
  rm -f conftest.er1
16891
  cat conftest.err >&5
16892
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16893
  (exit $ac_status); } &&
16894
         { ac_try='test -z "$ac_c_werror_flag"
16895
                         || test ! -s conftest.err'
16896
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16897
  (eval $ac_try) 2>&5
16898
  ac_status=$?
16899
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16900
  (exit $ac_status); }; } &&
16901
         { ac_try='test -s conftest$ac_exeext'
16902
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16903
  (eval $ac_try) 2>&5
16904
  ac_status=$?
16905
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16906
  (exit $ac_status); }; }; then
16907
  ac_cv_lib_m_powl=yes
16908
else
16909
  echo "$as_me: failed program was:" >&5
16910
sed 's/^/| /' conftest.$ac_ext >&5
16911
 
16912
ac_cv_lib_m_powl=no
16913
fi
16914
rm -f conftest.err conftest.$ac_objext \
16915
      conftest$ac_exeext conftest.$ac_ext
16916
LIBS=$ac_check_lib_save_LIBS
16917
fi
16918
echo "$as_me:$LINENO: result: $ac_cv_lib_m_powl" >&5
16919
echo "${ECHO_T}$ac_cv_lib_m_powl" >&6
16920
if test $ac_cv_lib_m_powl = yes; then
16921
 
16922
cat >>confdefs.h <<\_ACEOF
16923
#define HAVE_POWL 1
16924
_ACEOF
16925
 
16926
fi
16927
 
16928
echo "$as_me:$LINENO: checking for cpowf in -lm" >&5
16929
echo $ECHO_N "checking for cpowf in -lm... $ECHO_C" >&6
16930
if test "${ac_cv_lib_m_cpowf+set}" = set; then
16931
  echo $ECHO_N "(cached) $ECHO_C" >&6
16932
else
16933
  ac_check_lib_save_LIBS=$LIBS
16934
LIBS="-lm  $LIBS"
16935
if test x$gcc_no_link = xyes; then
16936
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16937
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16938
   { (exit 1); exit 1; }; }
16939
fi
16940
cat >conftest.$ac_ext <<_ACEOF
16941
/* confdefs.h.  */
16942
_ACEOF
16943
cat confdefs.h >>conftest.$ac_ext
16944
cat >>conftest.$ac_ext <<_ACEOF
16945
/* end confdefs.h.  */
16946
 
16947
/* Override any gcc2 internal prototype to avoid an error.  */
16948
#ifdef __cplusplus
16949
extern "C"
16950
#endif
16951
/* We use char because int might match the return type of a gcc2
16952
   builtin and then its argument prototype would still apply.  */
16953
char cpowf ();
16954
int
16955
main ()
16956
{
16957
cpowf ();
16958
  ;
16959
  return 0;
16960
}
16961
_ACEOF
16962
rm -f conftest.$ac_objext conftest$ac_exeext
16963
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16964
  (eval $ac_link) 2>conftest.er1
16965
  ac_status=$?
16966
  grep -v '^ *+' conftest.er1 >conftest.err
16967
  rm -f conftest.er1
16968
  cat conftest.err >&5
16969
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16970
  (exit $ac_status); } &&
16971
         { ac_try='test -z "$ac_c_werror_flag"
16972
                         || test ! -s conftest.err'
16973
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16974
  (eval $ac_try) 2>&5
16975
  ac_status=$?
16976
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16977
  (exit $ac_status); }; } &&
16978
         { ac_try='test -s conftest$ac_exeext'
16979
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16980
  (eval $ac_try) 2>&5
16981
  ac_status=$?
16982
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
16983
  (exit $ac_status); }; }; then
16984
  ac_cv_lib_m_cpowf=yes
16985
else
16986
  echo "$as_me: failed program was:" >&5
16987
sed 's/^/| /' conftest.$ac_ext >&5
16988
 
16989
ac_cv_lib_m_cpowf=no
16990
fi
16991
rm -f conftest.err conftest.$ac_objext \
16992
      conftest$ac_exeext conftest.$ac_ext
16993
LIBS=$ac_check_lib_save_LIBS
16994
fi
16995
echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpowf" >&5
16996
echo "${ECHO_T}$ac_cv_lib_m_cpowf" >&6
16997
if test $ac_cv_lib_m_cpowf = yes; then
16998
 
16999
cat >>confdefs.h <<\_ACEOF
17000
#define HAVE_CPOWF 1
17001
_ACEOF
17002
 
17003
fi
17004
 
17005
echo "$as_me:$LINENO: checking for cpow in -lm" >&5
17006
echo $ECHO_N "checking for cpow in -lm... $ECHO_C" >&6
17007
if test "${ac_cv_lib_m_cpow+set}" = set; then
17008
  echo $ECHO_N "(cached) $ECHO_C" >&6
17009
else
17010
  ac_check_lib_save_LIBS=$LIBS
17011
LIBS="-lm  $LIBS"
17012
if test x$gcc_no_link = xyes; then
17013
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17014
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17015
   { (exit 1); exit 1; }; }
17016
fi
17017
cat >conftest.$ac_ext <<_ACEOF
17018
/* confdefs.h.  */
17019
_ACEOF
17020
cat confdefs.h >>conftest.$ac_ext
17021
cat >>conftest.$ac_ext <<_ACEOF
17022
/* end confdefs.h.  */
17023
 
17024
/* Override any gcc2 internal prototype to avoid an error.  */
17025
#ifdef __cplusplus
17026
extern "C"
17027
#endif
17028
/* We use char because int might match the return type of a gcc2
17029
   builtin and then its argument prototype would still apply.  */
17030
char cpow ();
17031
int
17032
main ()
17033
{
17034
cpow ();
17035
  ;
17036
  return 0;
17037
}
17038
_ACEOF
17039
rm -f conftest.$ac_objext conftest$ac_exeext
17040
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17041
  (eval $ac_link) 2>conftest.er1
17042
  ac_status=$?
17043
  grep -v '^ *+' conftest.er1 >conftest.err
17044
  rm -f conftest.er1
17045
  cat conftest.err >&5
17046
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17047
  (exit $ac_status); } &&
17048
         { ac_try='test -z "$ac_c_werror_flag"
17049
                         || test ! -s conftest.err'
17050
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17051
  (eval $ac_try) 2>&5
17052
  ac_status=$?
17053
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17054
  (exit $ac_status); }; } &&
17055
         { ac_try='test -s conftest$ac_exeext'
17056
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17057
  (eval $ac_try) 2>&5
17058
  ac_status=$?
17059
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17060
  (exit $ac_status); }; }; then
17061
  ac_cv_lib_m_cpow=yes
17062
else
17063
  echo "$as_me: failed program was:" >&5
17064
sed 's/^/| /' conftest.$ac_ext >&5
17065
 
17066
ac_cv_lib_m_cpow=no
17067
fi
17068
rm -f conftest.err conftest.$ac_objext \
17069
      conftest$ac_exeext conftest.$ac_ext
17070
LIBS=$ac_check_lib_save_LIBS
17071
fi
17072
echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpow" >&5
17073
echo "${ECHO_T}$ac_cv_lib_m_cpow" >&6
17074
if test $ac_cv_lib_m_cpow = yes; then
17075
 
17076
cat >>confdefs.h <<\_ACEOF
17077
#define HAVE_CPOW 1
17078
_ACEOF
17079
 
17080
fi
17081
 
17082
echo "$as_me:$LINENO: checking for cpowl in -lm" >&5
17083
echo $ECHO_N "checking for cpowl in -lm... $ECHO_C" >&6
17084
if test "${ac_cv_lib_m_cpowl+set}" = set; then
17085
  echo $ECHO_N "(cached) $ECHO_C" >&6
17086
else
17087
  ac_check_lib_save_LIBS=$LIBS
17088
LIBS="-lm  $LIBS"
17089
if test x$gcc_no_link = xyes; then
17090
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17091
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17092
   { (exit 1); exit 1; }; }
17093
fi
17094
cat >conftest.$ac_ext <<_ACEOF
17095
/* confdefs.h.  */
17096
_ACEOF
17097
cat confdefs.h >>conftest.$ac_ext
17098
cat >>conftest.$ac_ext <<_ACEOF
17099
/* end confdefs.h.  */
17100
 
17101
/* Override any gcc2 internal prototype to avoid an error.  */
17102
#ifdef __cplusplus
17103
extern "C"
17104
#endif
17105
/* We use char because int might match the return type of a gcc2
17106
   builtin and then its argument prototype would still apply.  */
17107
char cpowl ();
17108
int
17109
main ()
17110
{
17111
cpowl ();
17112
  ;
17113
  return 0;
17114
}
17115
_ACEOF
17116
rm -f conftest.$ac_objext conftest$ac_exeext
17117
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17118
  (eval $ac_link) 2>conftest.er1
17119
  ac_status=$?
17120
  grep -v '^ *+' conftest.er1 >conftest.err
17121
  rm -f conftest.er1
17122
  cat conftest.err >&5
17123
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17124
  (exit $ac_status); } &&
17125
         { ac_try='test -z "$ac_c_werror_flag"
17126
                         || test ! -s conftest.err'
17127
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17128
  (eval $ac_try) 2>&5
17129
  ac_status=$?
17130
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17131
  (exit $ac_status); }; } &&
17132
         { ac_try='test -s conftest$ac_exeext'
17133
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17134
  (eval $ac_try) 2>&5
17135
  ac_status=$?
17136
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17137
  (exit $ac_status); }; }; then
17138
  ac_cv_lib_m_cpowl=yes
17139
else
17140
  echo "$as_me: failed program was:" >&5
17141
sed 's/^/| /' conftest.$ac_ext >&5
17142
 
17143
ac_cv_lib_m_cpowl=no
17144
fi
17145
rm -f conftest.err conftest.$ac_objext \
17146
      conftest$ac_exeext conftest.$ac_ext
17147
LIBS=$ac_check_lib_save_LIBS
17148
fi
17149
echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpowl" >&5
17150
echo "${ECHO_T}$ac_cv_lib_m_cpowl" >&6
17151
if test $ac_cv_lib_m_cpowl = yes; then
17152
 
17153
cat >>confdefs.h <<\_ACEOF
17154
#define HAVE_CPOWL 1
17155
_ACEOF
17156
 
17157
fi
17158
 
17159
echo "$as_me:$LINENO: checking for roundf in -lm" >&5
17160
echo $ECHO_N "checking for roundf in -lm... $ECHO_C" >&6
17161
if test "${ac_cv_lib_m_roundf+set}" = set; then
17162
  echo $ECHO_N "(cached) $ECHO_C" >&6
17163
else
17164
  ac_check_lib_save_LIBS=$LIBS
17165
LIBS="-lm  $LIBS"
17166
if test x$gcc_no_link = xyes; then
17167
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17168
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17169
   { (exit 1); exit 1; }; }
17170
fi
17171
cat >conftest.$ac_ext <<_ACEOF
17172
/* confdefs.h.  */
17173
_ACEOF
17174
cat confdefs.h >>conftest.$ac_ext
17175
cat >>conftest.$ac_ext <<_ACEOF
17176
/* end confdefs.h.  */
17177
 
17178
/* Override any gcc2 internal prototype to avoid an error.  */
17179
#ifdef __cplusplus
17180
extern "C"
17181
#endif
17182
/* We use char because int might match the return type of a gcc2
17183
   builtin and then its argument prototype would still apply.  */
17184
char roundf ();
17185
int
17186
main ()
17187
{
17188
roundf ();
17189
  ;
17190
  return 0;
17191
}
17192
_ACEOF
17193
rm -f conftest.$ac_objext conftest$ac_exeext
17194
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17195
  (eval $ac_link) 2>conftest.er1
17196
  ac_status=$?
17197
  grep -v '^ *+' conftest.er1 >conftest.err
17198
  rm -f conftest.er1
17199
  cat conftest.err >&5
17200
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17201
  (exit $ac_status); } &&
17202
         { ac_try='test -z "$ac_c_werror_flag"
17203
                         || test ! -s conftest.err'
17204
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17205
  (eval $ac_try) 2>&5
17206
  ac_status=$?
17207
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17208
  (exit $ac_status); }; } &&
17209
         { ac_try='test -s conftest$ac_exeext'
17210
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17211
  (eval $ac_try) 2>&5
17212
  ac_status=$?
17213
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17214
  (exit $ac_status); }; }; then
17215
  ac_cv_lib_m_roundf=yes
17216
else
17217
  echo "$as_me: failed program was:" >&5
17218
sed 's/^/| /' conftest.$ac_ext >&5
17219
 
17220
ac_cv_lib_m_roundf=no
17221
fi
17222
rm -f conftest.err conftest.$ac_objext \
17223
      conftest$ac_exeext conftest.$ac_ext
17224
LIBS=$ac_check_lib_save_LIBS
17225
fi
17226
echo "$as_me:$LINENO: result: $ac_cv_lib_m_roundf" >&5
17227
echo "${ECHO_T}$ac_cv_lib_m_roundf" >&6
17228
if test $ac_cv_lib_m_roundf = yes; then
17229
 
17230
cat >>confdefs.h <<\_ACEOF
17231
#define HAVE_ROUNDF 1
17232
_ACEOF
17233
 
17234
fi
17235
 
17236
echo "$as_me:$LINENO: checking for round in -lm" >&5
17237
echo $ECHO_N "checking for round in -lm... $ECHO_C" >&6
17238
if test "${ac_cv_lib_m_round+set}" = set; then
17239
  echo $ECHO_N "(cached) $ECHO_C" >&6
17240
else
17241
  ac_check_lib_save_LIBS=$LIBS
17242
LIBS="-lm  $LIBS"
17243
if test x$gcc_no_link = xyes; then
17244
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17245
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17246
   { (exit 1); exit 1; }; }
17247
fi
17248
cat >conftest.$ac_ext <<_ACEOF
17249
/* confdefs.h.  */
17250
_ACEOF
17251
cat confdefs.h >>conftest.$ac_ext
17252
cat >>conftest.$ac_ext <<_ACEOF
17253
/* end confdefs.h.  */
17254
 
17255
/* Override any gcc2 internal prototype to avoid an error.  */
17256
#ifdef __cplusplus
17257
extern "C"
17258
#endif
17259
/* We use char because int might match the return type of a gcc2
17260
   builtin and then its argument prototype would still apply.  */
17261
char round ();
17262
int
17263
main ()
17264
{
17265
round ();
17266
  ;
17267
  return 0;
17268
}
17269
_ACEOF
17270
rm -f conftest.$ac_objext conftest$ac_exeext
17271
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17272
  (eval $ac_link) 2>conftest.er1
17273
  ac_status=$?
17274
  grep -v '^ *+' conftest.er1 >conftest.err
17275
  rm -f conftest.er1
17276
  cat conftest.err >&5
17277
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17278
  (exit $ac_status); } &&
17279
         { ac_try='test -z "$ac_c_werror_flag"
17280
                         || test ! -s conftest.err'
17281
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17282
  (eval $ac_try) 2>&5
17283
  ac_status=$?
17284
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17285
  (exit $ac_status); }; } &&
17286
         { ac_try='test -s conftest$ac_exeext'
17287
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17288
  (eval $ac_try) 2>&5
17289
  ac_status=$?
17290
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17291
  (exit $ac_status); }; }; then
17292
  ac_cv_lib_m_round=yes
17293
else
17294
  echo "$as_me: failed program was:" >&5
17295
sed 's/^/| /' conftest.$ac_ext >&5
17296
 
17297
ac_cv_lib_m_round=no
17298
fi
17299
rm -f conftest.err conftest.$ac_objext \
17300
      conftest$ac_exeext conftest.$ac_ext
17301
LIBS=$ac_check_lib_save_LIBS
17302
fi
17303
echo "$as_me:$LINENO: result: $ac_cv_lib_m_round" >&5
17304
echo "${ECHO_T}$ac_cv_lib_m_round" >&6
17305
if test $ac_cv_lib_m_round = yes; then
17306
 
17307
cat >>confdefs.h <<\_ACEOF
17308
#define HAVE_ROUND 1
17309
_ACEOF
17310
 
17311
fi
17312
 
17313
echo "$as_me:$LINENO: checking for roundl in -lm" >&5
17314
echo $ECHO_N "checking for roundl in -lm... $ECHO_C" >&6
17315
if test "${ac_cv_lib_m_roundl+set}" = set; then
17316
  echo $ECHO_N "(cached) $ECHO_C" >&6
17317
else
17318
  ac_check_lib_save_LIBS=$LIBS
17319
LIBS="-lm  $LIBS"
17320
if test x$gcc_no_link = xyes; then
17321
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17322
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17323
   { (exit 1); exit 1; }; }
17324
fi
17325
cat >conftest.$ac_ext <<_ACEOF
17326
/* confdefs.h.  */
17327
_ACEOF
17328
cat confdefs.h >>conftest.$ac_ext
17329
cat >>conftest.$ac_ext <<_ACEOF
17330
/* end confdefs.h.  */
17331
 
17332
/* Override any gcc2 internal prototype to avoid an error.  */
17333
#ifdef __cplusplus
17334
extern "C"
17335
#endif
17336
/* We use char because int might match the return type of a gcc2
17337
   builtin and then its argument prototype would still apply.  */
17338
char roundl ();
17339
int
17340
main ()
17341
{
17342
roundl ();
17343
  ;
17344
  return 0;
17345
}
17346
_ACEOF
17347
rm -f conftest.$ac_objext conftest$ac_exeext
17348
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17349
  (eval $ac_link) 2>conftest.er1
17350
  ac_status=$?
17351
  grep -v '^ *+' conftest.er1 >conftest.err
17352
  rm -f conftest.er1
17353
  cat conftest.err >&5
17354
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17355
  (exit $ac_status); } &&
17356
         { ac_try='test -z "$ac_c_werror_flag"
17357
                         || test ! -s conftest.err'
17358
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17359
  (eval $ac_try) 2>&5
17360
  ac_status=$?
17361
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17362
  (exit $ac_status); }; } &&
17363
         { ac_try='test -s conftest$ac_exeext'
17364
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17365
  (eval $ac_try) 2>&5
17366
  ac_status=$?
17367
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17368
  (exit $ac_status); }; }; then
17369
  ac_cv_lib_m_roundl=yes
17370
else
17371
  echo "$as_me: failed program was:" >&5
17372
sed 's/^/| /' conftest.$ac_ext >&5
17373
 
17374
ac_cv_lib_m_roundl=no
17375
fi
17376
rm -f conftest.err conftest.$ac_objext \
17377
      conftest$ac_exeext conftest.$ac_ext
17378
LIBS=$ac_check_lib_save_LIBS
17379
fi
17380
echo "$as_me:$LINENO: result: $ac_cv_lib_m_roundl" >&5
17381
echo "${ECHO_T}$ac_cv_lib_m_roundl" >&6
17382
if test $ac_cv_lib_m_roundl = yes; then
17383
 
17384
cat >>confdefs.h <<\_ACEOF
17385
#define HAVE_ROUNDL 1
17386
_ACEOF
17387
 
17388
fi
17389
 
17390
echo "$as_me:$LINENO: checking for scalbnf in -lm" >&5
17391
echo $ECHO_N "checking for scalbnf in -lm... $ECHO_C" >&6
17392
if test "${ac_cv_lib_m_scalbnf+set}" = set; then
17393
  echo $ECHO_N "(cached) $ECHO_C" >&6
17394
else
17395
  ac_check_lib_save_LIBS=$LIBS
17396
LIBS="-lm  $LIBS"
17397
if test x$gcc_no_link = xyes; then
17398
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17399
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17400
   { (exit 1); exit 1; }; }
17401
fi
17402
cat >conftest.$ac_ext <<_ACEOF
17403
/* confdefs.h.  */
17404
_ACEOF
17405
cat confdefs.h >>conftest.$ac_ext
17406
cat >>conftest.$ac_ext <<_ACEOF
17407
/* end confdefs.h.  */
17408
 
17409
/* Override any gcc2 internal prototype to avoid an error.  */
17410
#ifdef __cplusplus
17411
extern "C"
17412
#endif
17413
/* We use char because int might match the return type of a gcc2
17414
   builtin and then its argument prototype would still apply.  */
17415
char scalbnf ();
17416
int
17417
main ()
17418
{
17419
scalbnf ();
17420
  ;
17421
  return 0;
17422
}
17423
_ACEOF
17424
rm -f conftest.$ac_objext conftest$ac_exeext
17425
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17426
  (eval $ac_link) 2>conftest.er1
17427
  ac_status=$?
17428
  grep -v '^ *+' conftest.er1 >conftest.err
17429
  rm -f conftest.er1
17430
  cat conftest.err >&5
17431
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17432
  (exit $ac_status); } &&
17433
         { ac_try='test -z "$ac_c_werror_flag"
17434
                         || test ! -s conftest.err'
17435
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17436
  (eval $ac_try) 2>&5
17437
  ac_status=$?
17438
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17439
  (exit $ac_status); }; } &&
17440
         { ac_try='test -s conftest$ac_exeext'
17441
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17442
  (eval $ac_try) 2>&5
17443
  ac_status=$?
17444
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17445
  (exit $ac_status); }; }; then
17446
  ac_cv_lib_m_scalbnf=yes
17447
else
17448
  echo "$as_me: failed program was:" >&5
17449
sed 's/^/| /' conftest.$ac_ext >&5
17450
 
17451
ac_cv_lib_m_scalbnf=no
17452
fi
17453
rm -f conftest.err conftest.$ac_objext \
17454
      conftest$ac_exeext conftest.$ac_ext
17455
LIBS=$ac_check_lib_save_LIBS
17456
fi
17457
echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbnf" >&5
17458
echo "${ECHO_T}$ac_cv_lib_m_scalbnf" >&6
17459
if test $ac_cv_lib_m_scalbnf = yes; then
17460
 
17461
cat >>confdefs.h <<\_ACEOF
17462
#define HAVE_SCALBNF 1
17463
_ACEOF
17464
 
17465
fi
17466
 
17467
echo "$as_me:$LINENO: checking for scalbn in -lm" >&5
17468
echo $ECHO_N "checking for scalbn in -lm... $ECHO_C" >&6
17469
if test "${ac_cv_lib_m_scalbn+set}" = set; then
17470
  echo $ECHO_N "(cached) $ECHO_C" >&6
17471
else
17472
  ac_check_lib_save_LIBS=$LIBS
17473
LIBS="-lm  $LIBS"
17474
if test x$gcc_no_link = xyes; then
17475
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17476
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17477
   { (exit 1); exit 1; }; }
17478
fi
17479
cat >conftest.$ac_ext <<_ACEOF
17480
/* confdefs.h.  */
17481
_ACEOF
17482
cat confdefs.h >>conftest.$ac_ext
17483
cat >>conftest.$ac_ext <<_ACEOF
17484
/* end confdefs.h.  */
17485
 
17486
/* Override any gcc2 internal prototype to avoid an error.  */
17487
#ifdef __cplusplus
17488
extern "C"
17489
#endif
17490
/* We use char because int might match the return type of a gcc2
17491
   builtin and then its argument prototype would still apply.  */
17492
char scalbn ();
17493
int
17494
main ()
17495
{
17496
scalbn ();
17497
  ;
17498
  return 0;
17499
}
17500
_ACEOF
17501
rm -f conftest.$ac_objext conftest$ac_exeext
17502
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17503
  (eval $ac_link) 2>conftest.er1
17504
  ac_status=$?
17505
  grep -v '^ *+' conftest.er1 >conftest.err
17506
  rm -f conftest.er1
17507
  cat conftest.err >&5
17508
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17509
  (exit $ac_status); } &&
17510
         { ac_try='test -z "$ac_c_werror_flag"
17511
                         || test ! -s conftest.err'
17512
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17513
  (eval $ac_try) 2>&5
17514
  ac_status=$?
17515
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17516
  (exit $ac_status); }; } &&
17517
         { ac_try='test -s conftest$ac_exeext'
17518
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17519
  (eval $ac_try) 2>&5
17520
  ac_status=$?
17521
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17522
  (exit $ac_status); }; }; then
17523
  ac_cv_lib_m_scalbn=yes
17524
else
17525
  echo "$as_me: failed program was:" >&5
17526
sed 's/^/| /' conftest.$ac_ext >&5
17527
 
17528
ac_cv_lib_m_scalbn=no
17529
fi
17530
rm -f conftest.err conftest.$ac_objext \
17531
      conftest$ac_exeext conftest.$ac_ext
17532
LIBS=$ac_check_lib_save_LIBS
17533
fi
17534
echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbn" >&5
17535
echo "${ECHO_T}$ac_cv_lib_m_scalbn" >&6
17536
if test $ac_cv_lib_m_scalbn = yes; then
17537
 
17538
cat >>confdefs.h <<\_ACEOF
17539
#define HAVE_SCALBN 1
17540
_ACEOF
17541
 
17542
fi
17543
 
17544
echo "$as_me:$LINENO: checking for scalbnl in -lm" >&5
17545
echo $ECHO_N "checking for scalbnl in -lm... $ECHO_C" >&6
17546
if test "${ac_cv_lib_m_scalbnl+set}" = set; then
17547
  echo $ECHO_N "(cached) $ECHO_C" >&6
17548
else
17549
  ac_check_lib_save_LIBS=$LIBS
17550
LIBS="-lm  $LIBS"
17551
if test x$gcc_no_link = xyes; then
17552
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17553
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17554
   { (exit 1); exit 1; }; }
17555
fi
17556
cat >conftest.$ac_ext <<_ACEOF
17557
/* confdefs.h.  */
17558
_ACEOF
17559
cat confdefs.h >>conftest.$ac_ext
17560
cat >>conftest.$ac_ext <<_ACEOF
17561
/* end confdefs.h.  */
17562
 
17563
/* Override any gcc2 internal prototype to avoid an error.  */
17564
#ifdef __cplusplus
17565
extern "C"
17566
#endif
17567
/* We use char because int might match the return type of a gcc2
17568
   builtin and then its argument prototype would still apply.  */
17569
char scalbnl ();
17570
int
17571
main ()
17572
{
17573
scalbnl ();
17574
  ;
17575
  return 0;
17576
}
17577
_ACEOF
17578
rm -f conftest.$ac_objext conftest$ac_exeext
17579
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17580
  (eval $ac_link) 2>conftest.er1
17581
  ac_status=$?
17582
  grep -v '^ *+' conftest.er1 >conftest.err
17583
  rm -f conftest.er1
17584
  cat conftest.err >&5
17585
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17586
  (exit $ac_status); } &&
17587
         { ac_try='test -z "$ac_c_werror_flag"
17588
                         || test ! -s conftest.err'
17589
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17590
  (eval $ac_try) 2>&5
17591
  ac_status=$?
17592
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17593
  (exit $ac_status); }; } &&
17594
         { ac_try='test -s conftest$ac_exeext'
17595
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17596
  (eval $ac_try) 2>&5
17597
  ac_status=$?
17598
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17599
  (exit $ac_status); }; }; then
17600
  ac_cv_lib_m_scalbnl=yes
17601
else
17602
  echo "$as_me: failed program was:" >&5
17603
sed 's/^/| /' conftest.$ac_ext >&5
17604
 
17605
ac_cv_lib_m_scalbnl=no
17606
fi
17607
rm -f conftest.err conftest.$ac_objext \
17608
      conftest$ac_exeext conftest.$ac_ext
17609
LIBS=$ac_check_lib_save_LIBS
17610
fi
17611
echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbnl" >&5
17612
echo "${ECHO_T}$ac_cv_lib_m_scalbnl" >&6
17613
if test $ac_cv_lib_m_scalbnl = yes; then
17614
 
17615
cat >>confdefs.h <<\_ACEOF
17616
#define HAVE_SCALBNL 1
17617
_ACEOF
17618
 
17619
fi
17620
 
17621
echo "$as_me:$LINENO: checking for sinf in -lm" >&5
17622
echo $ECHO_N "checking for sinf in -lm... $ECHO_C" >&6
17623
if test "${ac_cv_lib_m_sinf+set}" = set; then
17624
  echo $ECHO_N "(cached) $ECHO_C" >&6
17625
else
17626
  ac_check_lib_save_LIBS=$LIBS
17627
LIBS="-lm  $LIBS"
17628
if test x$gcc_no_link = xyes; then
17629
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17630
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17631
   { (exit 1); exit 1; }; }
17632
fi
17633
cat >conftest.$ac_ext <<_ACEOF
17634
/* confdefs.h.  */
17635
_ACEOF
17636
cat confdefs.h >>conftest.$ac_ext
17637
cat >>conftest.$ac_ext <<_ACEOF
17638
/* end confdefs.h.  */
17639
 
17640
/* Override any gcc2 internal prototype to avoid an error.  */
17641
#ifdef __cplusplus
17642
extern "C"
17643
#endif
17644
/* We use char because int might match the return type of a gcc2
17645
   builtin and then its argument prototype would still apply.  */
17646
char sinf ();
17647
int
17648
main ()
17649
{
17650
sinf ();
17651
  ;
17652
  return 0;
17653
}
17654
_ACEOF
17655
rm -f conftest.$ac_objext conftest$ac_exeext
17656
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17657
  (eval $ac_link) 2>conftest.er1
17658
  ac_status=$?
17659
  grep -v '^ *+' conftest.er1 >conftest.err
17660
  rm -f conftest.er1
17661
  cat conftest.err >&5
17662
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17663
  (exit $ac_status); } &&
17664
         { ac_try='test -z "$ac_c_werror_flag"
17665
                         || test ! -s conftest.err'
17666
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17667
  (eval $ac_try) 2>&5
17668
  ac_status=$?
17669
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17670
  (exit $ac_status); }; } &&
17671
         { ac_try='test -s conftest$ac_exeext'
17672
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17673
  (eval $ac_try) 2>&5
17674
  ac_status=$?
17675
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17676
  (exit $ac_status); }; }; then
17677
  ac_cv_lib_m_sinf=yes
17678
else
17679
  echo "$as_me: failed program was:" >&5
17680
sed 's/^/| /' conftest.$ac_ext >&5
17681
 
17682
ac_cv_lib_m_sinf=no
17683
fi
17684
rm -f conftest.err conftest.$ac_objext \
17685
      conftest$ac_exeext conftest.$ac_ext
17686
LIBS=$ac_check_lib_save_LIBS
17687
fi
17688
echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinf" >&5
17689
echo "${ECHO_T}$ac_cv_lib_m_sinf" >&6
17690
if test $ac_cv_lib_m_sinf = yes; then
17691
 
17692
cat >>confdefs.h <<\_ACEOF
17693
#define HAVE_SINF 1
17694
_ACEOF
17695
 
17696
fi
17697
 
17698
echo "$as_me:$LINENO: checking for sin in -lm" >&5
17699
echo $ECHO_N "checking for sin in -lm... $ECHO_C" >&6
17700
if test "${ac_cv_lib_m_sin+set}" = set; then
17701
  echo $ECHO_N "(cached) $ECHO_C" >&6
17702
else
17703
  ac_check_lib_save_LIBS=$LIBS
17704
LIBS="-lm  $LIBS"
17705
if test x$gcc_no_link = xyes; then
17706
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17707
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17708
   { (exit 1); exit 1; }; }
17709
fi
17710
cat >conftest.$ac_ext <<_ACEOF
17711
/* confdefs.h.  */
17712
_ACEOF
17713
cat confdefs.h >>conftest.$ac_ext
17714
cat >>conftest.$ac_ext <<_ACEOF
17715
/* end confdefs.h.  */
17716
 
17717
/* Override any gcc2 internal prototype to avoid an error.  */
17718
#ifdef __cplusplus
17719
extern "C"
17720
#endif
17721
/* We use char because int might match the return type of a gcc2
17722
   builtin and then its argument prototype would still apply.  */
17723
char sin ();
17724
int
17725
main ()
17726
{
17727
sin ();
17728
  ;
17729
  return 0;
17730
}
17731
_ACEOF
17732
rm -f conftest.$ac_objext conftest$ac_exeext
17733
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17734
  (eval $ac_link) 2>conftest.er1
17735
  ac_status=$?
17736
  grep -v '^ *+' conftest.er1 >conftest.err
17737
  rm -f conftest.er1
17738
  cat conftest.err >&5
17739
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17740
  (exit $ac_status); } &&
17741
         { ac_try='test -z "$ac_c_werror_flag"
17742
                         || test ! -s conftest.err'
17743
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17744
  (eval $ac_try) 2>&5
17745
  ac_status=$?
17746
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17747
  (exit $ac_status); }; } &&
17748
         { ac_try='test -s conftest$ac_exeext'
17749
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17750
  (eval $ac_try) 2>&5
17751
  ac_status=$?
17752
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17753
  (exit $ac_status); }; }; then
17754
  ac_cv_lib_m_sin=yes
17755
else
17756
  echo "$as_me: failed program was:" >&5
17757
sed 's/^/| /' conftest.$ac_ext >&5
17758
 
17759
ac_cv_lib_m_sin=no
17760
fi
17761
rm -f conftest.err conftest.$ac_objext \
17762
      conftest$ac_exeext conftest.$ac_ext
17763
LIBS=$ac_check_lib_save_LIBS
17764
fi
17765
echo "$as_me:$LINENO: result: $ac_cv_lib_m_sin" >&5
17766
echo "${ECHO_T}$ac_cv_lib_m_sin" >&6
17767
if test $ac_cv_lib_m_sin = yes; then
17768
 
17769
cat >>confdefs.h <<\_ACEOF
17770
#define HAVE_SIN 1
17771
_ACEOF
17772
 
17773
fi
17774
 
17775
echo "$as_me:$LINENO: checking for sinl in -lm" >&5
17776
echo $ECHO_N "checking for sinl in -lm... $ECHO_C" >&6
17777
if test "${ac_cv_lib_m_sinl+set}" = set; then
17778
  echo $ECHO_N "(cached) $ECHO_C" >&6
17779
else
17780
  ac_check_lib_save_LIBS=$LIBS
17781
LIBS="-lm  $LIBS"
17782
if test x$gcc_no_link = xyes; then
17783
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17784
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17785
   { (exit 1); exit 1; }; }
17786
fi
17787
cat >conftest.$ac_ext <<_ACEOF
17788
/* confdefs.h.  */
17789
_ACEOF
17790
cat confdefs.h >>conftest.$ac_ext
17791
cat >>conftest.$ac_ext <<_ACEOF
17792
/* end confdefs.h.  */
17793
 
17794
/* Override any gcc2 internal prototype to avoid an error.  */
17795
#ifdef __cplusplus
17796
extern "C"
17797
#endif
17798
/* We use char because int might match the return type of a gcc2
17799
   builtin and then its argument prototype would still apply.  */
17800
char sinl ();
17801
int
17802
main ()
17803
{
17804
sinl ();
17805
  ;
17806
  return 0;
17807
}
17808
_ACEOF
17809
rm -f conftest.$ac_objext conftest$ac_exeext
17810
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17811
  (eval $ac_link) 2>conftest.er1
17812
  ac_status=$?
17813
  grep -v '^ *+' conftest.er1 >conftest.err
17814
  rm -f conftest.er1
17815
  cat conftest.err >&5
17816
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17817
  (exit $ac_status); } &&
17818
         { ac_try='test -z "$ac_c_werror_flag"
17819
                         || test ! -s conftest.err'
17820
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17821
  (eval $ac_try) 2>&5
17822
  ac_status=$?
17823
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17824
  (exit $ac_status); }; } &&
17825
         { ac_try='test -s conftest$ac_exeext'
17826
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17827
  (eval $ac_try) 2>&5
17828
  ac_status=$?
17829
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17830
  (exit $ac_status); }; }; then
17831
  ac_cv_lib_m_sinl=yes
17832
else
17833
  echo "$as_me: failed program was:" >&5
17834
sed 's/^/| /' conftest.$ac_ext >&5
17835
 
17836
ac_cv_lib_m_sinl=no
17837
fi
17838
rm -f conftest.err conftest.$ac_objext \
17839
      conftest$ac_exeext conftest.$ac_ext
17840
LIBS=$ac_check_lib_save_LIBS
17841
fi
17842
echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinl" >&5
17843
echo "${ECHO_T}$ac_cv_lib_m_sinl" >&6
17844
if test $ac_cv_lib_m_sinl = yes; then
17845
 
17846
cat >>confdefs.h <<\_ACEOF
17847
#define HAVE_SINL 1
17848
_ACEOF
17849
 
17850
fi
17851
 
17852
echo "$as_me:$LINENO: checking for csinf in -lm" >&5
17853
echo $ECHO_N "checking for csinf in -lm... $ECHO_C" >&6
17854
if test "${ac_cv_lib_m_csinf+set}" = set; then
17855
  echo $ECHO_N "(cached) $ECHO_C" >&6
17856
else
17857
  ac_check_lib_save_LIBS=$LIBS
17858
LIBS="-lm  $LIBS"
17859
if test x$gcc_no_link = xyes; then
17860
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17861
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17862
   { (exit 1); exit 1; }; }
17863
fi
17864
cat >conftest.$ac_ext <<_ACEOF
17865
/* confdefs.h.  */
17866
_ACEOF
17867
cat confdefs.h >>conftest.$ac_ext
17868
cat >>conftest.$ac_ext <<_ACEOF
17869
/* end confdefs.h.  */
17870
 
17871
/* Override any gcc2 internal prototype to avoid an error.  */
17872
#ifdef __cplusplus
17873
extern "C"
17874
#endif
17875
/* We use char because int might match the return type of a gcc2
17876
   builtin and then its argument prototype would still apply.  */
17877
char csinf ();
17878
int
17879
main ()
17880
{
17881
csinf ();
17882
  ;
17883
  return 0;
17884
}
17885
_ACEOF
17886
rm -f conftest.$ac_objext conftest$ac_exeext
17887
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17888
  (eval $ac_link) 2>conftest.er1
17889
  ac_status=$?
17890
  grep -v '^ *+' conftest.er1 >conftest.err
17891
  rm -f conftest.er1
17892
  cat conftest.err >&5
17893
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17894
  (exit $ac_status); } &&
17895
         { ac_try='test -z "$ac_c_werror_flag"
17896
                         || test ! -s conftest.err'
17897
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17898
  (eval $ac_try) 2>&5
17899
  ac_status=$?
17900
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17901
  (exit $ac_status); }; } &&
17902
         { ac_try='test -s conftest$ac_exeext'
17903
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17904
  (eval $ac_try) 2>&5
17905
  ac_status=$?
17906
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17907
  (exit $ac_status); }; }; then
17908
  ac_cv_lib_m_csinf=yes
17909
else
17910
  echo "$as_me: failed program was:" >&5
17911
sed 's/^/| /' conftest.$ac_ext >&5
17912
 
17913
ac_cv_lib_m_csinf=no
17914
fi
17915
rm -f conftest.err conftest.$ac_objext \
17916
      conftest$ac_exeext conftest.$ac_ext
17917
LIBS=$ac_check_lib_save_LIBS
17918
fi
17919
echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinf" >&5
17920
echo "${ECHO_T}$ac_cv_lib_m_csinf" >&6
17921
if test $ac_cv_lib_m_csinf = yes; then
17922
 
17923
cat >>confdefs.h <<\_ACEOF
17924
#define HAVE_CSINF 1
17925
_ACEOF
17926
 
17927
fi
17928
 
17929
echo "$as_me:$LINENO: checking for csin in -lm" >&5
17930
echo $ECHO_N "checking for csin in -lm... $ECHO_C" >&6
17931
if test "${ac_cv_lib_m_csin+set}" = set; then
17932
  echo $ECHO_N "(cached) $ECHO_C" >&6
17933
else
17934
  ac_check_lib_save_LIBS=$LIBS
17935
LIBS="-lm  $LIBS"
17936
if test x$gcc_no_link = xyes; then
17937
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17938
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17939
   { (exit 1); exit 1; }; }
17940
fi
17941
cat >conftest.$ac_ext <<_ACEOF
17942
/* confdefs.h.  */
17943
_ACEOF
17944
cat confdefs.h >>conftest.$ac_ext
17945
cat >>conftest.$ac_ext <<_ACEOF
17946
/* end confdefs.h.  */
17947
 
17948
/* Override any gcc2 internal prototype to avoid an error.  */
17949
#ifdef __cplusplus
17950
extern "C"
17951
#endif
17952
/* We use char because int might match the return type of a gcc2
17953
   builtin and then its argument prototype would still apply.  */
17954
char csin ();
17955
int
17956
main ()
17957
{
17958
csin ();
17959
  ;
17960
  return 0;
17961
}
17962
_ACEOF
17963
rm -f conftest.$ac_objext conftest$ac_exeext
17964
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17965
  (eval $ac_link) 2>conftest.er1
17966
  ac_status=$?
17967
  grep -v '^ *+' conftest.er1 >conftest.err
17968
  rm -f conftest.er1
17969
  cat conftest.err >&5
17970
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17971
  (exit $ac_status); } &&
17972
         { ac_try='test -z "$ac_c_werror_flag"
17973
                         || test ! -s conftest.err'
17974
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17975
  (eval $ac_try) 2>&5
17976
  ac_status=$?
17977
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17978
  (exit $ac_status); }; } &&
17979
         { ac_try='test -s conftest$ac_exeext'
17980
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17981
  (eval $ac_try) 2>&5
17982
  ac_status=$?
17983
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
17984
  (exit $ac_status); }; }; then
17985
  ac_cv_lib_m_csin=yes
17986
else
17987
  echo "$as_me: failed program was:" >&5
17988
sed 's/^/| /' conftest.$ac_ext >&5
17989
 
17990
ac_cv_lib_m_csin=no
17991
fi
17992
rm -f conftest.err conftest.$ac_objext \
17993
      conftest$ac_exeext conftest.$ac_ext
17994
LIBS=$ac_check_lib_save_LIBS
17995
fi
17996
echo "$as_me:$LINENO: result: $ac_cv_lib_m_csin" >&5
17997
echo "${ECHO_T}$ac_cv_lib_m_csin" >&6
17998
if test $ac_cv_lib_m_csin = yes; then
17999
 
18000
cat >>confdefs.h <<\_ACEOF
18001
#define HAVE_CSIN 1
18002
_ACEOF
18003
 
18004
fi
18005
 
18006
echo "$as_me:$LINENO: checking for csinl in -lm" >&5
18007
echo $ECHO_N "checking for csinl in -lm... $ECHO_C" >&6
18008
if test "${ac_cv_lib_m_csinl+set}" = set; then
18009
  echo $ECHO_N "(cached) $ECHO_C" >&6
18010
else
18011
  ac_check_lib_save_LIBS=$LIBS
18012
LIBS="-lm  $LIBS"
18013
if test x$gcc_no_link = xyes; then
18014
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18015
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18016
   { (exit 1); exit 1; }; }
18017
fi
18018
cat >conftest.$ac_ext <<_ACEOF
18019
/* confdefs.h.  */
18020
_ACEOF
18021
cat confdefs.h >>conftest.$ac_ext
18022
cat >>conftest.$ac_ext <<_ACEOF
18023
/* end confdefs.h.  */
18024
 
18025
/* Override any gcc2 internal prototype to avoid an error.  */
18026
#ifdef __cplusplus
18027
extern "C"
18028
#endif
18029
/* We use char because int might match the return type of a gcc2
18030
   builtin and then its argument prototype would still apply.  */
18031
char csinl ();
18032
int
18033
main ()
18034
{
18035
csinl ();
18036
  ;
18037
  return 0;
18038
}
18039
_ACEOF
18040
rm -f conftest.$ac_objext conftest$ac_exeext
18041
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18042
  (eval $ac_link) 2>conftest.er1
18043
  ac_status=$?
18044
  grep -v '^ *+' conftest.er1 >conftest.err
18045
  rm -f conftest.er1
18046
  cat conftest.err >&5
18047
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18048
  (exit $ac_status); } &&
18049
         { ac_try='test -z "$ac_c_werror_flag"
18050
                         || test ! -s conftest.err'
18051
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18052
  (eval $ac_try) 2>&5
18053
  ac_status=$?
18054
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18055
  (exit $ac_status); }; } &&
18056
         { ac_try='test -s conftest$ac_exeext'
18057
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18058
  (eval $ac_try) 2>&5
18059
  ac_status=$?
18060
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18061
  (exit $ac_status); }; }; then
18062
  ac_cv_lib_m_csinl=yes
18063
else
18064
  echo "$as_me: failed program was:" >&5
18065
sed 's/^/| /' conftest.$ac_ext >&5
18066
 
18067
ac_cv_lib_m_csinl=no
18068
fi
18069
rm -f conftest.err conftest.$ac_objext \
18070
      conftest$ac_exeext conftest.$ac_ext
18071
LIBS=$ac_check_lib_save_LIBS
18072
fi
18073
echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinl" >&5
18074
echo "${ECHO_T}$ac_cv_lib_m_csinl" >&6
18075
if test $ac_cv_lib_m_csinl = yes; then
18076
 
18077
cat >>confdefs.h <<\_ACEOF
18078
#define HAVE_CSINL 1
18079
_ACEOF
18080
 
18081
fi
18082
 
18083
echo "$as_me:$LINENO: checking for sinhf in -lm" >&5
18084
echo $ECHO_N "checking for sinhf in -lm... $ECHO_C" >&6
18085
if test "${ac_cv_lib_m_sinhf+set}" = set; then
18086
  echo $ECHO_N "(cached) $ECHO_C" >&6
18087
else
18088
  ac_check_lib_save_LIBS=$LIBS
18089
LIBS="-lm  $LIBS"
18090
if test x$gcc_no_link = xyes; then
18091
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18092
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18093
   { (exit 1); exit 1; }; }
18094
fi
18095
cat >conftest.$ac_ext <<_ACEOF
18096
/* confdefs.h.  */
18097
_ACEOF
18098
cat confdefs.h >>conftest.$ac_ext
18099
cat >>conftest.$ac_ext <<_ACEOF
18100
/* end confdefs.h.  */
18101
 
18102
/* Override any gcc2 internal prototype to avoid an error.  */
18103
#ifdef __cplusplus
18104
extern "C"
18105
#endif
18106
/* We use char because int might match the return type of a gcc2
18107
   builtin and then its argument prototype would still apply.  */
18108
char sinhf ();
18109
int
18110
main ()
18111
{
18112
sinhf ();
18113
  ;
18114
  return 0;
18115
}
18116
_ACEOF
18117
rm -f conftest.$ac_objext conftest$ac_exeext
18118
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18119
  (eval $ac_link) 2>conftest.er1
18120
  ac_status=$?
18121
  grep -v '^ *+' conftest.er1 >conftest.err
18122
  rm -f conftest.er1
18123
  cat conftest.err >&5
18124
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18125
  (exit $ac_status); } &&
18126
         { ac_try='test -z "$ac_c_werror_flag"
18127
                         || test ! -s conftest.err'
18128
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18129
  (eval $ac_try) 2>&5
18130
  ac_status=$?
18131
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18132
  (exit $ac_status); }; } &&
18133
         { ac_try='test -s conftest$ac_exeext'
18134
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18135
  (eval $ac_try) 2>&5
18136
  ac_status=$?
18137
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18138
  (exit $ac_status); }; }; then
18139
  ac_cv_lib_m_sinhf=yes
18140
else
18141
  echo "$as_me: failed program was:" >&5
18142
sed 's/^/| /' conftest.$ac_ext >&5
18143
 
18144
ac_cv_lib_m_sinhf=no
18145
fi
18146
rm -f conftest.err conftest.$ac_objext \
18147
      conftest$ac_exeext conftest.$ac_ext
18148
LIBS=$ac_check_lib_save_LIBS
18149
fi
18150
echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinhf" >&5
18151
echo "${ECHO_T}$ac_cv_lib_m_sinhf" >&6
18152
if test $ac_cv_lib_m_sinhf = yes; then
18153
 
18154
cat >>confdefs.h <<\_ACEOF
18155
#define HAVE_SINHF 1
18156
_ACEOF
18157
 
18158
fi
18159
 
18160
echo "$as_me:$LINENO: checking for sinh in -lm" >&5
18161
echo $ECHO_N "checking for sinh in -lm... $ECHO_C" >&6
18162
if test "${ac_cv_lib_m_sinh+set}" = set; then
18163
  echo $ECHO_N "(cached) $ECHO_C" >&6
18164
else
18165
  ac_check_lib_save_LIBS=$LIBS
18166
LIBS="-lm  $LIBS"
18167
if test x$gcc_no_link = xyes; then
18168
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18169
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18170
   { (exit 1); exit 1; }; }
18171
fi
18172
cat >conftest.$ac_ext <<_ACEOF
18173
/* confdefs.h.  */
18174
_ACEOF
18175
cat confdefs.h >>conftest.$ac_ext
18176
cat >>conftest.$ac_ext <<_ACEOF
18177
/* end confdefs.h.  */
18178
 
18179
/* Override any gcc2 internal prototype to avoid an error.  */
18180
#ifdef __cplusplus
18181
extern "C"
18182
#endif
18183
/* We use char because int might match the return type of a gcc2
18184
   builtin and then its argument prototype would still apply.  */
18185
char sinh ();
18186
int
18187
main ()
18188
{
18189
sinh ();
18190
  ;
18191
  return 0;
18192
}
18193
_ACEOF
18194
rm -f conftest.$ac_objext conftest$ac_exeext
18195
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18196
  (eval $ac_link) 2>conftest.er1
18197
  ac_status=$?
18198
  grep -v '^ *+' conftest.er1 >conftest.err
18199
  rm -f conftest.er1
18200
  cat conftest.err >&5
18201
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18202
  (exit $ac_status); } &&
18203
         { ac_try='test -z "$ac_c_werror_flag"
18204
                         || test ! -s conftest.err'
18205
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18206
  (eval $ac_try) 2>&5
18207
  ac_status=$?
18208
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18209
  (exit $ac_status); }; } &&
18210
         { ac_try='test -s conftest$ac_exeext'
18211
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18212
  (eval $ac_try) 2>&5
18213
  ac_status=$?
18214
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18215
  (exit $ac_status); }; }; then
18216
  ac_cv_lib_m_sinh=yes
18217
else
18218
  echo "$as_me: failed program was:" >&5
18219
sed 's/^/| /' conftest.$ac_ext >&5
18220
 
18221
ac_cv_lib_m_sinh=no
18222
fi
18223
rm -f conftest.err conftest.$ac_objext \
18224
      conftest$ac_exeext conftest.$ac_ext
18225
LIBS=$ac_check_lib_save_LIBS
18226
fi
18227
echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinh" >&5
18228
echo "${ECHO_T}$ac_cv_lib_m_sinh" >&6
18229
if test $ac_cv_lib_m_sinh = yes; then
18230
 
18231
cat >>confdefs.h <<\_ACEOF
18232
#define HAVE_SINH 1
18233
_ACEOF
18234
 
18235
fi
18236
 
18237
echo "$as_me:$LINENO: checking for sinhl in -lm" >&5
18238
echo $ECHO_N "checking for sinhl in -lm... $ECHO_C" >&6
18239
if test "${ac_cv_lib_m_sinhl+set}" = set; then
18240
  echo $ECHO_N "(cached) $ECHO_C" >&6
18241
else
18242
  ac_check_lib_save_LIBS=$LIBS
18243
LIBS="-lm  $LIBS"
18244
if test x$gcc_no_link = xyes; then
18245
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18246
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18247
   { (exit 1); exit 1; }; }
18248
fi
18249
cat >conftest.$ac_ext <<_ACEOF
18250
/* confdefs.h.  */
18251
_ACEOF
18252
cat confdefs.h >>conftest.$ac_ext
18253
cat >>conftest.$ac_ext <<_ACEOF
18254
/* end confdefs.h.  */
18255
 
18256
/* Override any gcc2 internal prototype to avoid an error.  */
18257
#ifdef __cplusplus
18258
extern "C"
18259
#endif
18260
/* We use char because int might match the return type of a gcc2
18261
   builtin and then its argument prototype would still apply.  */
18262
char sinhl ();
18263
int
18264
main ()
18265
{
18266
sinhl ();
18267
  ;
18268
  return 0;
18269
}
18270
_ACEOF
18271
rm -f conftest.$ac_objext conftest$ac_exeext
18272
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18273
  (eval $ac_link) 2>conftest.er1
18274
  ac_status=$?
18275
  grep -v '^ *+' conftest.er1 >conftest.err
18276
  rm -f conftest.er1
18277
  cat conftest.err >&5
18278
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18279
  (exit $ac_status); } &&
18280
         { ac_try='test -z "$ac_c_werror_flag"
18281
                         || test ! -s conftest.err'
18282
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18283
  (eval $ac_try) 2>&5
18284
  ac_status=$?
18285
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18286
  (exit $ac_status); }; } &&
18287
         { ac_try='test -s conftest$ac_exeext'
18288
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18289
  (eval $ac_try) 2>&5
18290
  ac_status=$?
18291
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18292
  (exit $ac_status); }; }; then
18293
  ac_cv_lib_m_sinhl=yes
18294
else
18295
  echo "$as_me: failed program was:" >&5
18296
sed 's/^/| /' conftest.$ac_ext >&5
18297
 
18298
ac_cv_lib_m_sinhl=no
18299
fi
18300
rm -f conftest.err conftest.$ac_objext \
18301
      conftest$ac_exeext conftest.$ac_ext
18302
LIBS=$ac_check_lib_save_LIBS
18303
fi
18304
echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinhl" >&5
18305
echo "${ECHO_T}$ac_cv_lib_m_sinhl" >&6
18306
if test $ac_cv_lib_m_sinhl = yes; then
18307
 
18308
cat >>confdefs.h <<\_ACEOF
18309
#define HAVE_SINHL 1
18310
_ACEOF
18311
 
18312
fi
18313
 
18314
echo "$as_me:$LINENO: checking for csinhf in -lm" >&5
18315
echo $ECHO_N "checking for csinhf in -lm... $ECHO_C" >&6
18316
if test "${ac_cv_lib_m_csinhf+set}" = set; then
18317
  echo $ECHO_N "(cached) $ECHO_C" >&6
18318
else
18319
  ac_check_lib_save_LIBS=$LIBS
18320
LIBS="-lm  $LIBS"
18321
if test x$gcc_no_link = xyes; then
18322
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18323
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18324
   { (exit 1); exit 1; }; }
18325
fi
18326
cat >conftest.$ac_ext <<_ACEOF
18327
/* confdefs.h.  */
18328
_ACEOF
18329
cat confdefs.h >>conftest.$ac_ext
18330
cat >>conftest.$ac_ext <<_ACEOF
18331
/* end confdefs.h.  */
18332
 
18333
/* Override any gcc2 internal prototype to avoid an error.  */
18334
#ifdef __cplusplus
18335
extern "C"
18336
#endif
18337
/* We use char because int might match the return type of a gcc2
18338
   builtin and then its argument prototype would still apply.  */
18339
char csinhf ();
18340
int
18341
main ()
18342
{
18343
csinhf ();
18344
  ;
18345
  return 0;
18346
}
18347
_ACEOF
18348
rm -f conftest.$ac_objext conftest$ac_exeext
18349
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18350
  (eval $ac_link) 2>conftest.er1
18351
  ac_status=$?
18352
  grep -v '^ *+' conftest.er1 >conftest.err
18353
  rm -f conftest.er1
18354
  cat conftest.err >&5
18355
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18356
  (exit $ac_status); } &&
18357
         { ac_try='test -z "$ac_c_werror_flag"
18358
                         || test ! -s conftest.err'
18359
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18360
  (eval $ac_try) 2>&5
18361
  ac_status=$?
18362
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18363
  (exit $ac_status); }; } &&
18364
         { ac_try='test -s conftest$ac_exeext'
18365
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18366
  (eval $ac_try) 2>&5
18367
  ac_status=$?
18368
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18369
  (exit $ac_status); }; }; then
18370
  ac_cv_lib_m_csinhf=yes
18371
else
18372
  echo "$as_me: failed program was:" >&5
18373
sed 's/^/| /' conftest.$ac_ext >&5
18374
 
18375
ac_cv_lib_m_csinhf=no
18376
fi
18377
rm -f conftest.err conftest.$ac_objext \
18378
      conftest$ac_exeext conftest.$ac_ext
18379
LIBS=$ac_check_lib_save_LIBS
18380
fi
18381
echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinhf" >&5
18382
echo "${ECHO_T}$ac_cv_lib_m_csinhf" >&6
18383
if test $ac_cv_lib_m_csinhf = yes; then
18384
 
18385
cat >>confdefs.h <<\_ACEOF
18386
#define HAVE_CSINHF 1
18387
_ACEOF
18388
 
18389
fi
18390
 
18391
echo "$as_me:$LINENO: checking for csinh in -lm" >&5
18392
echo $ECHO_N "checking for csinh in -lm... $ECHO_C" >&6
18393
if test "${ac_cv_lib_m_csinh+set}" = set; then
18394
  echo $ECHO_N "(cached) $ECHO_C" >&6
18395
else
18396
  ac_check_lib_save_LIBS=$LIBS
18397
LIBS="-lm  $LIBS"
18398
if test x$gcc_no_link = xyes; then
18399
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18400
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18401
   { (exit 1); exit 1; }; }
18402
fi
18403
cat >conftest.$ac_ext <<_ACEOF
18404
/* confdefs.h.  */
18405
_ACEOF
18406
cat confdefs.h >>conftest.$ac_ext
18407
cat >>conftest.$ac_ext <<_ACEOF
18408
/* end confdefs.h.  */
18409
 
18410
/* Override any gcc2 internal prototype to avoid an error.  */
18411
#ifdef __cplusplus
18412
extern "C"
18413
#endif
18414
/* We use char because int might match the return type of a gcc2
18415
   builtin and then its argument prototype would still apply.  */
18416
char csinh ();
18417
int
18418
main ()
18419
{
18420
csinh ();
18421
  ;
18422
  return 0;
18423
}
18424
_ACEOF
18425
rm -f conftest.$ac_objext conftest$ac_exeext
18426
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18427
  (eval $ac_link) 2>conftest.er1
18428
  ac_status=$?
18429
  grep -v '^ *+' conftest.er1 >conftest.err
18430
  rm -f conftest.er1
18431
  cat conftest.err >&5
18432
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18433
  (exit $ac_status); } &&
18434
         { ac_try='test -z "$ac_c_werror_flag"
18435
                         || test ! -s conftest.err'
18436
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18437
  (eval $ac_try) 2>&5
18438
  ac_status=$?
18439
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18440
  (exit $ac_status); }; } &&
18441
         { ac_try='test -s conftest$ac_exeext'
18442
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18443
  (eval $ac_try) 2>&5
18444
  ac_status=$?
18445
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18446
  (exit $ac_status); }; }; then
18447
  ac_cv_lib_m_csinh=yes
18448
else
18449
  echo "$as_me: failed program was:" >&5
18450
sed 's/^/| /' conftest.$ac_ext >&5
18451
 
18452
ac_cv_lib_m_csinh=no
18453
fi
18454
rm -f conftest.err conftest.$ac_objext \
18455
      conftest$ac_exeext conftest.$ac_ext
18456
LIBS=$ac_check_lib_save_LIBS
18457
fi
18458
echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinh" >&5
18459
echo "${ECHO_T}$ac_cv_lib_m_csinh" >&6
18460
if test $ac_cv_lib_m_csinh = yes; then
18461
 
18462
cat >>confdefs.h <<\_ACEOF
18463
#define HAVE_CSINH 1
18464
_ACEOF
18465
 
18466
fi
18467
 
18468
echo "$as_me:$LINENO: checking for csinhl in -lm" >&5
18469
echo $ECHO_N "checking for csinhl in -lm... $ECHO_C" >&6
18470
if test "${ac_cv_lib_m_csinhl+set}" = set; then
18471
  echo $ECHO_N "(cached) $ECHO_C" >&6
18472
else
18473
  ac_check_lib_save_LIBS=$LIBS
18474
LIBS="-lm  $LIBS"
18475
if test x$gcc_no_link = xyes; then
18476
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18477
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18478
   { (exit 1); exit 1; }; }
18479
fi
18480
cat >conftest.$ac_ext <<_ACEOF
18481
/* confdefs.h.  */
18482
_ACEOF
18483
cat confdefs.h >>conftest.$ac_ext
18484
cat >>conftest.$ac_ext <<_ACEOF
18485
/* end confdefs.h.  */
18486
 
18487
/* Override any gcc2 internal prototype to avoid an error.  */
18488
#ifdef __cplusplus
18489
extern "C"
18490
#endif
18491
/* We use char because int might match the return type of a gcc2
18492
   builtin and then its argument prototype would still apply.  */
18493
char csinhl ();
18494
int
18495
main ()
18496
{
18497
csinhl ();
18498
  ;
18499
  return 0;
18500
}
18501
_ACEOF
18502
rm -f conftest.$ac_objext conftest$ac_exeext
18503
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18504
  (eval $ac_link) 2>conftest.er1
18505
  ac_status=$?
18506
  grep -v '^ *+' conftest.er1 >conftest.err
18507
  rm -f conftest.er1
18508
  cat conftest.err >&5
18509
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18510
  (exit $ac_status); } &&
18511
         { ac_try='test -z "$ac_c_werror_flag"
18512
                         || test ! -s conftest.err'
18513
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18514
  (eval $ac_try) 2>&5
18515
  ac_status=$?
18516
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18517
  (exit $ac_status); }; } &&
18518
         { ac_try='test -s conftest$ac_exeext'
18519
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18520
  (eval $ac_try) 2>&5
18521
  ac_status=$?
18522
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18523
  (exit $ac_status); }; }; then
18524
  ac_cv_lib_m_csinhl=yes
18525
else
18526
  echo "$as_me: failed program was:" >&5
18527
sed 's/^/| /' conftest.$ac_ext >&5
18528
 
18529
ac_cv_lib_m_csinhl=no
18530
fi
18531
rm -f conftest.err conftest.$ac_objext \
18532
      conftest$ac_exeext conftest.$ac_ext
18533
LIBS=$ac_check_lib_save_LIBS
18534
fi
18535
echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinhl" >&5
18536
echo "${ECHO_T}$ac_cv_lib_m_csinhl" >&6
18537
if test $ac_cv_lib_m_csinhl = yes; then
18538
 
18539
cat >>confdefs.h <<\_ACEOF
18540
#define HAVE_CSINHL 1
18541
_ACEOF
18542
 
18543
fi
18544
 
18545
echo "$as_me:$LINENO: checking for sqrtf in -lm" >&5
18546
echo $ECHO_N "checking for sqrtf in -lm... $ECHO_C" >&6
18547
if test "${ac_cv_lib_m_sqrtf+set}" = set; then
18548
  echo $ECHO_N "(cached) $ECHO_C" >&6
18549
else
18550
  ac_check_lib_save_LIBS=$LIBS
18551
LIBS="-lm  $LIBS"
18552
if test x$gcc_no_link = xyes; then
18553
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18554
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18555
   { (exit 1); exit 1; }; }
18556
fi
18557
cat >conftest.$ac_ext <<_ACEOF
18558
/* confdefs.h.  */
18559
_ACEOF
18560
cat confdefs.h >>conftest.$ac_ext
18561
cat >>conftest.$ac_ext <<_ACEOF
18562
/* end confdefs.h.  */
18563
 
18564
/* Override any gcc2 internal prototype to avoid an error.  */
18565
#ifdef __cplusplus
18566
extern "C"
18567
#endif
18568
/* We use char because int might match the return type of a gcc2
18569
   builtin and then its argument prototype would still apply.  */
18570
char sqrtf ();
18571
int
18572
main ()
18573
{
18574
sqrtf ();
18575
  ;
18576
  return 0;
18577
}
18578
_ACEOF
18579
rm -f conftest.$ac_objext conftest$ac_exeext
18580
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18581
  (eval $ac_link) 2>conftest.er1
18582
  ac_status=$?
18583
  grep -v '^ *+' conftest.er1 >conftest.err
18584
  rm -f conftest.er1
18585
  cat conftest.err >&5
18586
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18587
  (exit $ac_status); } &&
18588
         { ac_try='test -z "$ac_c_werror_flag"
18589
                         || test ! -s conftest.err'
18590
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18591
  (eval $ac_try) 2>&5
18592
  ac_status=$?
18593
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18594
  (exit $ac_status); }; } &&
18595
         { ac_try='test -s conftest$ac_exeext'
18596
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18597
  (eval $ac_try) 2>&5
18598
  ac_status=$?
18599
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18600
  (exit $ac_status); }; }; then
18601
  ac_cv_lib_m_sqrtf=yes
18602
else
18603
  echo "$as_me: failed program was:" >&5
18604
sed 's/^/| /' conftest.$ac_ext >&5
18605
 
18606
ac_cv_lib_m_sqrtf=no
18607
fi
18608
rm -f conftest.err conftest.$ac_objext \
18609
      conftest$ac_exeext conftest.$ac_ext
18610
LIBS=$ac_check_lib_save_LIBS
18611
fi
18612
echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrtf" >&5
18613
echo "${ECHO_T}$ac_cv_lib_m_sqrtf" >&6
18614
if test $ac_cv_lib_m_sqrtf = yes; then
18615
 
18616
cat >>confdefs.h <<\_ACEOF
18617
#define HAVE_SQRTF 1
18618
_ACEOF
18619
 
18620
fi
18621
 
18622
echo "$as_me:$LINENO: checking for sqrt in -lm" >&5
18623
echo $ECHO_N "checking for sqrt in -lm... $ECHO_C" >&6
18624
if test "${ac_cv_lib_m_sqrt+set}" = set; then
18625
  echo $ECHO_N "(cached) $ECHO_C" >&6
18626
else
18627
  ac_check_lib_save_LIBS=$LIBS
18628
LIBS="-lm  $LIBS"
18629
if test x$gcc_no_link = xyes; then
18630
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18631
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18632
   { (exit 1); exit 1; }; }
18633
fi
18634
cat >conftest.$ac_ext <<_ACEOF
18635
/* confdefs.h.  */
18636
_ACEOF
18637
cat confdefs.h >>conftest.$ac_ext
18638
cat >>conftest.$ac_ext <<_ACEOF
18639
/* end confdefs.h.  */
18640
 
18641
/* Override any gcc2 internal prototype to avoid an error.  */
18642
#ifdef __cplusplus
18643
extern "C"
18644
#endif
18645
/* We use char because int might match the return type of a gcc2
18646
   builtin and then its argument prototype would still apply.  */
18647
char sqrt ();
18648
int
18649
main ()
18650
{
18651
sqrt ();
18652
  ;
18653
  return 0;
18654
}
18655
_ACEOF
18656
rm -f conftest.$ac_objext conftest$ac_exeext
18657
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18658
  (eval $ac_link) 2>conftest.er1
18659
  ac_status=$?
18660
  grep -v '^ *+' conftest.er1 >conftest.err
18661
  rm -f conftest.er1
18662
  cat conftest.err >&5
18663
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18664
  (exit $ac_status); } &&
18665
         { ac_try='test -z "$ac_c_werror_flag"
18666
                         || test ! -s conftest.err'
18667
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18668
  (eval $ac_try) 2>&5
18669
  ac_status=$?
18670
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18671
  (exit $ac_status); }; } &&
18672
         { ac_try='test -s conftest$ac_exeext'
18673
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18674
  (eval $ac_try) 2>&5
18675
  ac_status=$?
18676
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18677
  (exit $ac_status); }; }; then
18678
  ac_cv_lib_m_sqrt=yes
18679
else
18680
  echo "$as_me: failed program was:" >&5
18681
sed 's/^/| /' conftest.$ac_ext >&5
18682
 
18683
ac_cv_lib_m_sqrt=no
18684
fi
18685
rm -f conftest.err conftest.$ac_objext \
18686
      conftest$ac_exeext conftest.$ac_ext
18687
LIBS=$ac_check_lib_save_LIBS
18688
fi
18689
echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrt" >&5
18690
echo "${ECHO_T}$ac_cv_lib_m_sqrt" >&6
18691
if test $ac_cv_lib_m_sqrt = yes; then
18692
 
18693
cat >>confdefs.h <<\_ACEOF
18694
#define HAVE_SQRT 1
18695
_ACEOF
18696
 
18697
fi
18698
 
18699
echo "$as_me:$LINENO: checking for sqrtl in -lm" >&5
18700
echo $ECHO_N "checking for sqrtl in -lm... $ECHO_C" >&6
18701
if test "${ac_cv_lib_m_sqrtl+set}" = set; then
18702
  echo $ECHO_N "(cached) $ECHO_C" >&6
18703
else
18704
  ac_check_lib_save_LIBS=$LIBS
18705
LIBS="-lm  $LIBS"
18706
if test x$gcc_no_link = xyes; then
18707
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18708
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18709
   { (exit 1); exit 1; }; }
18710
fi
18711
cat >conftest.$ac_ext <<_ACEOF
18712
/* confdefs.h.  */
18713
_ACEOF
18714
cat confdefs.h >>conftest.$ac_ext
18715
cat >>conftest.$ac_ext <<_ACEOF
18716
/* end confdefs.h.  */
18717
 
18718
/* Override any gcc2 internal prototype to avoid an error.  */
18719
#ifdef __cplusplus
18720
extern "C"
18721
#endif
18722
/* We use char because int might match the return type of a gcc2
18723
   builtin and then its argument prototype would still apply.  */
18724
char sqrtl ();
18725
int
18726
main ()
18727
{
18728
sqrtl ();
18729
  ;
18730
  return 0;
18731
}
18732
_ACEOF
18733
rm -f conftest.$ac_objext conftest$ac_exeext
18734
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18735
  (eval $ac_link) 2>conftest.er1
18736
  ac_status=$?
18737
  grep -v '^ *+' conftest.er1 >conftest.err
18738
  rm -f conftest.er1
18739
  cat conftest.err >&5
18740
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18741
  (exit $ac_status); } &&
18742
         { ac_try='test -z "$ac_c_werror_flag"
18743
                         || test ! -s conftest.err'
18744
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18745
  (eval $ac_try) 2>&5
18746
  ac_status=$?
18747
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18748
  (exit $ac_status); }; } &&
18749
         { ac_try='test -s conftest$ac_exeext'
18750
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18751
  (eval $ac_try) 2>&5
18752
  ac_status=$?
18753
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18754
  (exit $ac_status); }; }; then
18755
  ac_cv_lib_m_sqrtl=yes
18756
else
18757
  echo "$as_me: failed program was:" >&5
18758
sed 's/^/| /' conftest.$ac_ext >&5
18759
 
18760
ac_cv_lib_m_sqrtl=no
18761
fi
18762
rm -f conftest.err conftest.$ac_objext \
18763
      conftest$ac_exeext conftest.$ac_ext
18764
LIBS=$ac_check_lib_save_LIBS
18765
fi
18766
echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrtl" >&5
18767
echo "${ECHO_T}$ac_cv_lib_m_sqrtl" >&6
18768
if test $ac_cv_lib_m_sqrtl = yes; then
18769
 
18770
cat >>confdefs.h <<\_ACEOF
18771
#define HAVE_SQRTL 1
18772
_ACEOF
18773
 
18774
fi
18775
 
18776
echo "$as_me:$LINENO: checking for csqrtf in -lm" >&5
18777
echo $ECHO_N "checking for csqrtf in -lm... $ECHO_C" >&6
18778
if test "${ac_cv_lib_m_csqrtf+set}" = set; then
18779
  echo $ECHO_N "(cached) $ECHO_C" >&6
18780
else
18781
  ac_check_lib_save_LIBS=$LIBS
18782
LIBS="-lm  $LIBS"
18783
if test x$gcc_no_link = xyes; then
18784
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18785
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18786
   { (exit 1); exit 1; }; }
18787
fi
18788
cat >conftest.$ac_ext <<_ACEOF
18789
/* confdefs.h.  */
18790
_ACEOF
18791
cat confdefs.h >>conftest.$ac_ext
18792
cat >>conftest.$ac_ext <<_ACEOF
18793
/* end confdefs.h.  */
18794
 
18795
/* Override any gcc2 internal prototype to avoid an error.  */
18796
#ifdef __cplusplus
18797
extern "C"
18798
#endif
18799
/* We use char because int might match the return type of a gcc2
18800
   builtin and then its argument prototype would still apply.  */
18801
char csqrtf ();
18802
int
18803
main ()
18804
{
18805
csqrtf ();
18806
  ;
18807
  return 0;
18808
}
18809
_ACEOF
18810
rm -f conftest.$ac_objext conftest$ac_exeext
18811
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18812
  (eval $ac_link) 2>conftest.er1
18813
  ac_status=$?
18814
  grep -v '^ *+' conftest.er1 >conftest.err
18815
  rm -f conftest.er1
18816
  cat conftest.err >&5
18817
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18818
  (exit $ac_status); } &&
18819
         { ac_try='test -z "$ac_c_werror_flag"
18820
                         || test ! -s conftest.err'
18821
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18822
  (eval $ac_try) 2>&5
18823
  ac_status=$?
18824
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18825
  (exit $ac_status); }; } &&
18826
         { ac_try='test -s conftest$ac_exeext'
18827
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18828
  (eval $ac_try) 2>&5
18829
  ac_status=$?
18830
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18831
  (exit $ac_status); }; }; then
18832
  ac_cv_lib_m_csqrtf=yes
18833
else
18834
  echo "$as_me: failed program was:" >&5
18835
sed 's/^/| /' conftest.$ac_ext >&5
18836
 
18837
ac_cv_lib_m_csqrtf=no
18838
fi
18839
rm -f conftest.err conftest.$ac_objext \
18840
      conftest$ac_exeext conftest.$ac_ext
18841
LIBS=$ac_check_lib_save_LIBS
18842
fi
18843
echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrtf" >&5
18844
echo "${ECHO_T}$ac_cv_lib_m_csqrtf" >&6
18845
if test $ac_cv_lib_m_csqrtf = yes; then
18846
 
18847
cat >>confdefs.h <<\_ACEOF
18848
#define HAVE_CSQRTF 1
18849
_ACEOF
18850
 
18851
fi
18852
 
18853
echo "$as_me:$LINENO: checking for csqrt in -lm" >&5
18854
echo $ECHO_N "checking for csqrt in -lm... $ECHO_C" >&6
18855
if test "${ac_cv_lib_m_csqrt+set}" = set; then
18856
  echo $ECHO_N "(cached) $ECHO_C" >&6
18857
else
18858
  ac_check_lib_save_LIBS=$LIBS
18859
LIBS="-lm  $LIBS"
18860
if test x$gcc_no_link = xyes; then
18861
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18862
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18863
   { (exit 1); exit 1; }; }
18864
fi
18865
cat >conftest.$ac_ext <<_ACEOF
18866
/* confdefs.h.  */
18867
_ACEOF
18868
cat confdefs.h >>conftest.$ac_ext
18869
cat >>conftest.$ac_ext <<_ACEOF
18870
/* end confdefs.h.  */
18871
 
18872
/* Override any gcc2 internal prototype to avoid an error.  */
18873
#ifdef __cplusplus
18874
extern "C"
18875
#endif
18876
/* We use char because int might match the return type of a gcc2
18877
   builtin and then its argument prototype would still apply.  */
18878
char csqrt ();
18879
int
18880
main ()
18881
{
18882
csqrt ();
18883
  ;
18884
  return 0;
18885
}
18886
_ACEOF
18887
rm -f conftest.$ac_objext conftest$ac_exeext
18888
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18889
  (eval $ac_link) 2>conftest.er1
18890
  ac_status=$?
18891
  grep -v '^ *+' conftest.er1 >conftest.err
18892
  rm -f conftest.er1
18893
  cat conftest.err >&5
18894
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18895
  (exit $ac_status); } &&
18896
         { ac_try='test -z "$ac_c_werror_flag"
18897
                         || test ! -s conftest.err'
18898
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18899
  (eval $ac_try) 2>&5
18900
  ac_status=$?
18901
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18902
  (exit $ac_status); }; } &&
18903
         { ac_try='test -s conftest$ac_exeext'
18904
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18905
  (eval $ac_try) 2>&5
18906
  ac_status=$?
18907
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18908
  (exit $ac_status); }; }; then
18909
  ac_cv_lib_m_csqrt=yes
18910
else
18911
  echo "$as_me: failed program was:" >&5
18912
sed 's/^/| /' conftest.$ac_ext >&5
18913
 
18914
ac_cv_lib_m_csqrt=no
18915
fi
18916
rm -f conftest.err conftest.$ac_objext \
18917
      conftest$ac_exeext conftest.$ac_ext
18918
LIBS=$ac_check_lib_save_LIBS
18919
fi
18920
echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrt" >&5
18921
echo "${ECHO_T}$ac_cv_lib_m_csqrt" >&6
18922
if test $ac_cv_lib_m_csqrt = yes; then
18923
 
18924
cat >>confdefs.h <<\_ACEOF
18925
#define HAVE_CSQRT 1
18926
_ACEOF
18927
 
18928
fi
18929
 
18930
echo "$as_me:$LINENO: checking for csqrtl in -lm" >&5
18931
echo $ECHO_N "checking for csqrtl in -lm... $ECHO_C" >&6
18932
if test "${ac_cv_lib_m_csqrtl+set}" = set; then
18933
  echo $ECHO_N "(cached) $ECHO_C" >&6
18934
else
18935
  ac_check_lib_save_LIBS=$LIBS
18936
LIBS="-lm  $LIBS"
18937
if test x$gcc_no_link = xyes; then
18938
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18939
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18940
   { (exit 1); exit 1; }; }
18941
fi
18942
cat >conftest.$ac_ext <<_ACEOF
18943
/* confdefs.h.  */
18944
_ACEOF
18945
cat confdefs.h >>conftest.$ac_ext
18946
cat >>conftest.$ac_ext <<_ACEOF
18947
/* end confdefs.h.  */
18948
 
18949
/* Override any gcc2 internal prototype to avoid an error.  */
18950
#ifdef __cplusplus
18951
extern "C"
18952
#endif
18953
/* We use char because int might match the return type of a gcc2
18954
   builtin and then its argument prototype would still apply.  */
18955
char csqrtl ();
18956
int
18957
main ()
18958
{
18959
csqrtl ();
18960
  ;
18961
  return 0;
18962
}
18963
_ACEOF
18964
rm -f conftest.$ac_objext conftest$ac_exeext
18965
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18966
  (eval $ac_link) 2>conftest.er1
18967
  ac_status=$?
18968
  grep -v '^ *+' conftest.er1 >conftest.err
18969
  rm -f conftest.er1
18970
  cat conftest.err >&5
18971
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18972
  (exit $ac_status); } &&
18973
         { ac_try='test -z "$ac_c_werror_flag"
18974
                         || test ! -s conftest.err'
18975
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18976
  (eval $ac_try) 2>&5
18977
  ac_status=$?
18978
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18979
  (exit $ac_status); }; } &&
18980
         { ac_try='test -s conftest$ac_exeext'
18981
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18982
  (eval $ac_try) 2>&5
18983
  ac_status=$?
18984
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18985
  (exit $ac_status); }; }; then
18986
  ac_cv_lib_m_csqrtl=yes
18987
else
18988
  echo "$as_me: failed program was:" >&5
18989
sed 's/^/| /' conftest.$ac_ext >&5
18990
 
18991
ac_cv_lib_m_csqrtl=no
18992
fi
18993
rm -f conftest.err conftest.$ac_objext \
18994
      conftest$ac_exeext conftest.$ac_ext
18995
LIBS=$ac_check_lib_save_LIBS
18996
fi
18997
echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrtl" >&5
18998
echo "${ECHO_T}$ac_cv_lib_m_csqrtl" >&6
18999
if test $ac_cv_lib_m_csqrtl = yes; then
19000
 
19001
cat >>confdefs.h <<\_ACEOF
19002
#define HAVE_CSQRTL 1
19003
_ACEOF
19004
 
19005
fi
19006
 
19007
echo "$as_me:$LINENO: checking for tanf in -lm" >&5
19008
echo $ECHO_N "checking for tanf in -lm... $ECHO_C" >&6
19009
if test "${ac_cv_lib_m_tanf+set}" = set; then
19010
  echo $ECHO_N "(cached) $ECHO_C" >&6
19011
else
19012
  ac_check_lib_save_LIBS=$LIBS
19013
LIBS="-lm  $LIBS"
19014
if test x$gcc_no_link = xyes; then
19015
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19016
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19017
   { (exit 1); exit 1; }; }
19018
fi
19019
cat >conftest.$ac_ext <<_ACEOF
19020
/* confdefs.h.  */
19021
_ACEOF
19022
cat confdefs.h >>conftest.$ac_ext
19023
cat >>conftest.$ac_ext <<_ACEOF
19024
/* end confdefs.h.  */
19025
 
19026
/* Override any gcc2 internal prototype to avoid an error.  */
19027
#ifdef __cplusplus
19028
extern "C"
19029
#endif
19030
/* We use char because int might match the return type of a gcc2
19031
   builtin and then its argument prototype would still apply.  */
19032
char tanf ();
19033
int
19034
main ()
19035
{
19036
tanf ();
19037
  ;
19038
  return 0;
19039
}
19040
_ACEOF
19041
rm -f conftest.$ac_objext conftest$ac_exeext
19042
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19043
  (eval $ac_link) 2>conftest.er1
19044
  ac_status=$?
19045
  grep -v '^ *+' conftest.er1 >conftest.err
19046
  rm -f conftest.er1
19047
  cat conftest.err >&5
19048
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19049
  (exit $ac_status); } &&
19050
         { ac_try='test -z "$ac_c_werror_flag"
19051
                         || test ! -s conftest.err'
19052
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19053
  (eval $ac_try) 2>&5
19054
  ac_status=$?
19055
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19056
  (exit $ac_status); }; } &&
19057
         { ac_try='test -s conftest$ac_exeext'
19058
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19059
  (eval $ac_try) 2>&5
19060
  ac_status=$?
19061
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19062
  (exit $ac_status); }; }; then
19063
  ac_cv_lib_m_tanf=yes
19064
else
19065
  echo "$as_me: failed program was:" >&5
19066
sed 's/^/| /' conftest.$ac_ext >&5
19067
 
19068
ac_cv_lib_m_tanf=no
19069
fi
19070
rm -f conftest.err conftest.$ac_objext \
19071
      conftest$ac_exeext conftest.$ac_ext
19072
LIBS=$ac_check_lib_save_LIBS
19073
fi
19074
echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanf" >&5
19075
echo "${ECHO_T}$ac_cv_lib_m_tanf" >&6
19076
if test $ac_cv_lib_m_tanf = yes; then
19077
 
19078
cat >>confdefs.h <<\_ACEOF
19079
#define HAVE_TANF 1
19080
_ACEOF
19081
 
19082
fi
19083
 
19084
echo "$as_me:$LINENO: checking for tan in -lm" >&5
19085
echo $ECHO_N "checking for tan in -lm... $ECHO_C" >&6
19086
if test "${ac_cv_lib_m_tan+set}" = set; then
19087
  echo $ECHO_N "(cached) $ECHO_C" >&6
19088
else
19089
  ac_check_lib_save_LIBS=$LIBS
19090
LIBS="-lm  $LIBS"
19091
if test x$gcc_no_link = xyes; then
19092
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19093
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19094
   { (exit 1); exit 1; }; }
19095
fi
19096
cat >conftest.$ac_ext <<_ACEOF
19097
/* confdefs.h.  */
19098
_ACEOF
19099
cat confdefs.h >>conftest.$ac_ext
19100
cat >>conftest.$ac_ext <<_ACEOF
19101
/* end confdefs.h.  */
19102
 
19103
/* Override any gcc2 internal prototype to avoid an error.  */
19104
#ifdef __cplusplus
19105
extern "C"
19106
#endif
19107
/* We use char because int might match the return type of a gcc2
19108
   builtin and then its argument prototype would still apply.  */
19109
char tan ();
19110
int
19111
main ()
19112
{
19113
tan ();
19114
  ;
19115
  return 0;
19116
}
19117
_ACEOF
19118
rm -f conftest.$ac_objext conftest$ac_exeext
19119
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19120
  (eval $ac_link) 2>conftest.er1
19121
  ac_status=$?
19122
  grep -v '^ *+' conftest.er1 >conftest.err
19123
  rm -f conftest.er1
19124
  cat conftest.err >&5
19125
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19126
  (exit $ac_status); } &&
19127
         { ac_try='test -z "$ac_c_werror_flag"
19128
                         || test ! -s conftest.err'
19129
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19130
  (eval $ac_try) 2>&5
19131
  ac_status=$?
19132
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19133
  (exit $ac_status); }; } &&
19134
         { ac_try='test -s conftest$ac_exeext'
19135
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19136
  (eval $ac_try) 2>&5
19137
  ac_status=$?
19138
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19139
  (exit $ac_status); }; }; then
19140
  ac_cv_lib_m_tan=yes
19141
else
19142
  echo "$as_me: failed program was:" >&5
19143
sed 's/^/| /' conftest.$ac_ext >&5
19144
 
19145
ac_cv_lib_m_tan=no
19146
fi
19147
rm -f conftest.err conftest.$ac_objext \
19148
      conftest$ac_exeext conftest.$ac_ext
19149
LIBS=$ac_check_lib_save_LIBS
19150
fi
19151
echo "$as_me:$LINENO: result: $ac_cv_lib_m_tan" >&5
19152
echo "${ECHO_T}$ac_cv_lib_m_tan" >&6
19153
if test $ac_cv_lib_m_tan = yes; then
19154
 
19155
cat >>confdefs.h <<\_ACEOF
19156
#define HAVE_TAN 1
19157
_ACEOF
19158
 
19159
fi
19160
 
19161
echo "$as_me:$LINENO: checking for tanl in -lm" >&5
19162
echo $ECHO_N "checking for tanl in -lm... $ECHO_C" >&6
19163
if test "${ac_cv_lib_m_tanl+set}" = set; then
19164
  echo $ECHO_N "(cached) $ECHO_C" >&6
19165
else
19166
  ac_check_lib_save_LIBS=$LIBS
19167
LIBS="-lm  $LIBS"
19168
if test x$gcc_no_link = xyes; then
19169
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19170
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19171
   { (exit 1); exit 1; }; }
19172
fi
19173
cat >conftest.$ac_ext <<_ACEOF
19174
/* confdefs.h.  */
19175
_ACEOF
19176
cat confdefs.h >>conftest.$ac_ext
19177
cat >>conftest.$ac_ext <<_ACEOF
19178
/* end confdefs.h.  */
19179
 
19180
/* Override any gcc2 internal prototype to avoid an error.  */
19181
#ifdef __cplusplus
19182
extern "C"
19183
#endif
19184
/* We use char because int might match the return type of a gcc2
19185
   builtin and then its argument prototype would still apply.  */
19186
char tanl ();
19187
int
19188
main ()
19189
{
19190
tanl ();
19191
  ;
19192
  return 0;
19193
}
19194
_ACEOF
19195
rm -f conftest.$ac_objext conftest$ac_exeext
19196
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19197
  (eval $ac_link) 2>conftest.er1
19198
  ac_status=$?
19199
  grep -v '^ *+' conftest.er1 >conftest.err
19200
  rm -f conftest.er1
19201
  cat conftest.err >&5
19202
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19203
  (exit $ac_status); } &&
19204
         { ac_try='test -z "$ac_c_werror_flag"
19205
                         || test ! -s conftest.err'
19206
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19207
  (eval $ac_try) 2>&5
19208
  ac_status=$?
19209
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19210
  (exit $ac_status); }; } &&
19211
         { ac_try='test -s conftest$ac_exeext'
19212
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19213
  (eval $ac_try) 2>&5
19214
  ac_status=$?
19215
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19216
  (exit $ac_status); }; }; then
19217
  ac_cv_lib_m_tanl=yes
19218
else
19219
  echo "$as_me: failed program was:" >&5
19220
sed 's/^/| /' conftest.$ac_ext >&5
19221
 
19222
ac_cv_lib_m_tanl=no
19223
fi
19224
rm -f conftest.err conftest.$ac_objext \
19225
      conftest$ac_exeext conftest.$ac_ext
19226
LIBS=$ac_check_lib_save_LIBS
19227
fi
19228
echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanl" >&5
19229
echo "${ECHO_T}$ac_cv_lib_m_tanl" >&6
19230
if test $ac_cv_lib_m_tanl = yes; then
19231
 
19232
cat >>confdefs.h <<\_ACEOF
19233
#define HAVE_TANL 1
19234
_ACEOF
19235
 
19236
fi
19237
 
19238
echo "$as_me:$LINENO: checking for ctanf in -lm" >&5
19239
echo $ECHO_N "checking for ctanf in -lm... $ECHO_C" >&6
19240
if test "${ac_cv_lib_m_ctanf+set}" = set; then
19241
  echo $ECHO_N "(cached) $ECHO_C" >&6
19242
else
19243
  ac_check_lib_save_LIBS=$LIBS
19244
LIBS="-lm  $LIBS"
19245
if test x$gcc_no_link = xyes; then
19246
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19247
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19248
   { (exit 1); exit 1; }; }
19249
fi
19250
cat >conftest.$ac_ext <<_ACEOF
19251
/* confdefs.h.  */
19252
_ACEOF
19253
cat confdefs.h >>conftest.$ac_ext
19254
cat >>conftest.$ac_ext <<_ACEOF
19255
/* end confdefs.h.  */
19256
 
19257
/* Override any gcc2 internal prototype to avoid an error.  */
19258
#ifdef __cplusplus
19259
extern "C"
19260
#endif
19261
/* We use char because int might match the return type of a gcc2
19262
   builtin and then its argument prototype would still apply.  */
19263
char ctanf ();
19264
int
19265
main ()
19266
{
19267
ctanf ();
19268
  ;
19269
  return 0;
19270
}
19271
_ACEOF
19272
rm -f conftest.$ac_objext conftest$ac_exeext
19273
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19274
  (eval $ac_link) 2>conftest.er1
19275
  ac_status=$?
19276
  grep -v '^ *+' conftest.er1 >conftest.err
19277
  rm -f conftest.er1
19278
  cat conftest.err >&5
19279
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19280
  (exit $ac_status); } &&
19281
         { ac_try='test -z "$ac_c_werror_flag"
19282
                         || test ! -s conftest.err'
19283
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19284
  (eval $ac_try) 2>&5
19285
  ac_status=$?
19286
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19287
  (exit $ac_status); }; } &&
19288
         { ac_try='test -s conftest$ac_exeext'
19289
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19290
  (eval $ac_try) 2>&5
19291
  ac_status=$?
19292
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19293
  (exit $ac_status); }; }; then
19294
  ac_cv_lib_m_ctanf=yes
19295
else
19296
  echo "$as_me: failed program was:" >&5
19297
sed 's/^/| /' conftest.$ac_ext >&5
19298
 
19299
ac_cv_lib_m_ctanf=no
19300
fi
19301
rm -f conftest.err conftest.$ac_objext \
19302
      conftest$ac_exeext conftest.$ac_ext
19303
LIBS=$ac_check_lib_save_LIBS
19304
fi
19305
echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanf" >&5
19306
echo "${ECHO_T}$ac_cv_lib_m_ctanf" >&6
19307
if test $ac_cv_lib_m_ctanf = yes; then
19308
 
19309
cat >>confdefs.h <<\_ACEOF
19310
#define HAVE_CTANF 1
19311
_ACEOF
19312
 
19313
fi
19314
 
19315
echo "$as_me:$LINENO: checking for ctan in -lm" >&5
19316
echo $ECHO_N "checking for ctan in -lm... $ECHO_C" >&6
19317
if test "${ac_cv_lib_m_ctan+set}" = set; then
19318
  echo $ECHO_N "(cached) $ECHO_C" >&6
19319
else
19320
  ac_check_lib_save_LIBS=$LIBS
19321
LIBS="-lm  $LIBS"
19322
if test x$gcc_no_link = xyes; then
19323
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19324
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19325
   { (exit 1); exit 1; }; }
19326
fi
19327
cat >conftest.$ac_ext <<_ACEOF
19328
/* confdefs.h.  */
19329
_ACEOF
19330
cat confdefs.h >>conftest.$ac_ext
19331
cat >>conftest.$ac_ext <<_ACEOF
19332
/* end confdefs.h.  */
19333
 
19334
/* Override any gcc2 internal prototype to avoid an error.  */
19335
#ifdef __cplusplus
19336
extern "C"
19337
#endif
19338
/* We use char because int might match the return type of a gcc2
19339
   builtin and then its argument prototype would still apply.  */
19340
char ctan ();
19341
int
19342
main ()
19343
{
19344
ctan ();
19345
  ;
19346
  return 0;
19347
}
19348
_ACEOF
19349
rm -f conftest.$ac_objext conftest$ac_exeext
19350
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19351
  (eval $ac_link) 2>conftest.er1
19352
  ac_status=$?
19353
  grep -v '^ *+' conftest.er1 >conftest.err
19354
  rm -f conftest.er1
19355
  cat conftest.err >&5
19356
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19357
  (exit $ac_status); } &&
19358
         { ac_try='test -z "$ac_c_werror_flag"
19359
                         || test ! -s conftest.err'
19360
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19361
  (eval $ac_try) 2>&5
19362
  ac_status=$?
19363
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19364
  (exit $ac_status); }; } &&
19365
         { ac_try='test -s conftest$ac_exeext'
19366
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19367
  (eval $ac_try) 2>&5
19368
  ac_status=$?
19369
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19370
  (exit $ac_status); }; }; then
19371
  ac_cv_lib_m_ctan=yes
19372
else
19373
  echo "$as_me: failed program was:" >&5
19374
sed 's/^/| /' conftest.$ac_ext >&5
19375
 
19376
ac_cv_lib_m_ctan=no
19377
fi
19378
rm -f conftest.err conftest.$ac_objext \
19379
      conftest$ac_exeext conftest.$ac_ext
19380
LIBS=$ac_check_lib_save_LIBS
19381
fi
19382
echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctan" >&5
19383
echo "${ECHO_T}$ac_cv_lib_m_ctan" >&6
19384
if test $ac_cv_lib_m_ctan = yes; then
19385
 
19386
cat >>confdefs.h <<\_ACEOF
19387
#define HAVE_CTAN 1
19388
_ACEOF
19389
 
19390
fi
19391
 
19392
echo "$as_me:$LINENO: checking for ctanl in -lm" >&5
19393
echo $ECHO_N "checking for ctanl in -lm... $ECHO_C" >&6
19394
if test "${ac_cv_lib_m_ctanl+set}" = set; then
19395
  echo $ECHO_N "(cached) $ECHO_C" >&6
19396
else
19397
  ac_check_lib_save_LIBS=$LIBS
19398
LIBS="-lm  $LIBS"
19399
if test x$gcc_no_link = xyes; then
19400
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19401
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19402
   { (exit 1); exit 1; }; }
19403
fi
19404
cat >conftest.$ac_ext <<_ACEOF
19405
/* confdefs.h.  */
19406
_ACEOF
19407
cat confdefs.h >>conftest.$ac_ext
19408
cat >>conftest.$ac_ext <<_ACEOF
19409
/* end confdefs.h.  */
19410
 
19411
/* Override any gcc2 internal prototype to avoid an error.  */
19412
#ifdef __cplusplus
19413
extern "C"
19414
#endif
19415
/* We use char because int might match the return type of a gcc2
19416
   builtin and then its argument prototype would still apply.  */
19417
char ctanl ();
19418
int
19419
main ()
19420
{
19421
ctanl ();
19422
  ;
19423
  return 0;
19424
}
19425
_ACEOF
19426
rm -f conftest.$ac_objext conftest$ac_exeext
19427
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19428
  (eval $ac_link) 2>conftest.er1
19429
  ac_status=$?
19430
  grep -v '^ *+' conftest.er1 >conftest.err
19431
  rm -f conftest.er1
19432
  cat conftest.err >&5
19433
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19434
  (exit $ac_status); } &&
19435
         { ac_try='test -z "$ac_c_werror_flag"
19436
                         || test ! -s conftest.err'
19437
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19438
  (eval $ac_try) 2>&5
19439
  ac_status=$?
19440
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19441
  (exit $ac_status); }; } &&
19442
         { ac_try='test -s conftest$ac_exeext'
19443
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19444
  (eval $ac_try) 2>&5
19445
  ac_status=$?
19446
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19447
  (exit $ac_status); }; }; then
19448
  ac_cv_lib_m_ctanl=yes
19449
else
19450
  echo "$as_me: failed program was:" >&5
19451
sed 's/^/| /' conftest.$ac_ext >&5
19452
 
19453
ac_cv_lib_m_ctanl=no
19454
fi
19455
rm -f conftest.err conftest.$ac_objext \
19456
      conftest$ac_exeext conftest.$ac_ext
19457
LIBS=$ac_check_lib_save_LIBS
19458
fi
19459
echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanl" >&5
19460
echo "${ECHO_T}$ac_cv_lib_m_ctanl" >&6
19461
if test $ac_cv_lib_m_ctanl = yes; then
19462
 
19463
cat >>confdefs.h <<\_ACEOF
19464
#define HAVE_CTANL 1
19465
_ACEOF
19466
 
19467
fi
19468
 
19469
echo "$as_me:$LINENO: checking for tanhf in -lm" >&5
19470
echo $ECHO_N "checking for tanhf in -lm... $ECHO_C" >&6
19471
if test "${ac_cv_lib_m_tanhf+set}" = set; then
19472
  echo $ECHO_N "(cached) $ECHO_C" >&6
19473
else
19474
  ac_check_lib_save_LIBS=$LIBS
19475
LIBS="-lm  $LIBS"
19476
if test x$gcc_no_link = xyes; then
19477
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19478
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19479
   { (exit 1); exit 1; }; }
19480
fi
19481
cat >conftest.$ac_ext <<_ACEOF
19482
/* confdefs.h.  */
19483
_ACEOF
19484
cat confdefs.h >>conftest.$ac_ext
19485
cat >>conftest.$ac_ext <<_ACEOF
19486
/* end confdefs.h.  */
19487
 
19488
/* Override any gcc2 internal prototype to avoid an error.  */
19489
#ifdef __cplusplus
19490
extern "C"
19491
#endif
19492
/* We use char because int might match the return type of a gcc2
19493
   builtin and then its argument prototype would still apply.  */
19494
char tanhf ();
19495
int
19496
main ()
19497
{
19498
tanhf ();
19499
  ;
19500
  return 0;
19501
}
19502
_ACEOF
19503
rm -f conftest.$ac_objext conftest$ac_exeext
19504
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19505
  (eval $ac_link) 2>conftest.er1
19506
  ac_status=$?
19507
  grep -v '^ *+' conftest.er1 >conftest.err
19508
  rm -f conftest.er1
19509
  cat conftest.err >&5
19510
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19511
  (exit $ac_status); } &&
19512
         { ac_try='test -z "$ac_c_werror_flag"
19513
                         || test ! -s conftest.err'
19514
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19515
  (eval $ac_try) 2>&5
19516
  ac_status=$?
19517
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19518
  (exit $ac_status); }; } &&
19519
         { ac_try='test -s conftest$ac_exeext'
19520
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19521
  (eval $ac_try) 2>&5
19522
  ac_status=$?
19523
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19524
  (exit $ac_status); }; }; then
19525
  ac_cv_lib_m_tanhf=yes
19526
else
19527
  echo "$as_me: failed program was:" >&5
19528
sed 's/^/| /' conftest.$ac_ext >&5
19529
 
19530
ac_cv_lib_m_tanhf=no
19531
fi
19532
rm -f conftest.err conftest.$ac_objext \
19533
      conftest$ac_exeext conftest.$ac_ext
19534
LIBS=$ac_check_lib_save_LIBS
19535
fi
19536
echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanhf" >&5
19537
echo "${ECHO_T}$ac_cv_lib_m_tanhf" >&6
19538
if test $ac_cv_lib_m_tanhf = yes; then
19539
 
19540
cat >>confdefs.h <<\_ACEOF
19541
#define HAVE_TANHF 1
19542
_ACEOF
19543
 
19544
fi
19545
 
19546
echo "$as_me:$LINENO: checking for tanh in -lm" >&5
19547
echo $ECHO_N "checking for tanh in -lm... $ECHO_C" >&6
19548
if test "${ac_cv_lib_m_tanh+set}" = set; then
19549
  echo $ECHO_N "(cached) $ECHO_C" >&6
19550
else
19551
  ac_check_lib_save_LIBS=$LIBS
19552
LIBS="-lm  $LIBS"
19553
if test x$gcc_no_link = xyes; then
19554
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19555
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19556
   { (exit 1); exit 1; }; }
19557
fi
19558
cat >conftest.$ac_ext <<_ACEOF
19559
/* confdefs.h.  */
19560
_ACEOF
19561
cat confdefs.h >>conftest.$ac_ext
19562
cat >>conftest.$ac_ext <<_ACEOF
19563
/* end confdefs.h.  */
19564
 
19565
/* Override any gcc2 internal prototype to avoid an error.  */
19566
#ifdef __cplusplus
19567
extern "C"
19568
#endif
19569
/* We use char because int might match the return type of a gcc2
19570
   builtin and then its argument prototype would still apply.  */
19571
char tanh ();
19572
int
19573
main ()
19574
{
19575
tanh ();
19576
  ;
19577
  return 0;
19578
}
19579
_ACEOF
19580
rm -f conftest.$ac_objext conftest$ac_exeext
19581
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19582
  (eval $ac_link) 2>conftest.er1
19583
  ac_status=$?
19584
  grep -v '^ *+' conftest.er1 >conftest.err
19585
  rm -f conftest.er1
19586
  cat conftest.err >&5
19587
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19588
  (exit $ac_status); } &&
19589
         { ac_try='test -z "$ac_c_werror_flag"
19590
                         || test ! -s conftest.err'
19591
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19592
  (eval $ac_try) 2>&5
19593
  ac_status=$?
19594
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19595
  (exit $ac_status); }; } &&
19596
         { ac_try='test -s conftest$ac_exeext'
19597
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19598
  (eval $ac_try) 2>&5
19599
  ac_status=$?
19600
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19601
  (exit $ac_status); }; }; then
19602
  ac_cv_lib_m_tanh=yes
19603
else
19604
  echo "$as_me: failed program was:" >&5
19605
sed 's/^/| /' conftest.$ac_ext >&5
19606
 
19607
ac_cv_lib_m_tanh=no
19608
fi
19609
rm -f conftest.err conftest.$ac_objext \
19610
      conftest$ac_exeext conftest.$ac_ext
19611
LIBS=$ac_check_lib_save_LIBS
19612
fi
19613
echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanh" >&5
19614
echo "${ECHO_T}$ac_cv_lib_m_tanh" >&6
19615
if test $ac_cv_lib_m_tanh = yes; then
19616
 
19617
cat >>confdefs.h <<\_ACEOF
19618
#define HAVE_TANH 1
19619
_ACEOF
19620
 
19621
fi
19622
 
19623
echo "$as_me:$LINENO: checking for tanhl in -lm" >&5
19624
echo $ECHO_N "checking for tanhl in -lm... $ECHO_C" >&6
19625
if test "${ac_cv_lib_m_tanhl+set}" = set; then
19626
  echo $ECHO_N "(cached) $ECHO_C" >&6
19627
else
19628
  ac_check_lib_save_LIBS=$LIBS
19629
LIBS="-lm  $LIBS"
19630
if test x$gcc_no_link = xyes; then
19631
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19632
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19633
   { (exit 1); exit 1; }; }
19634
fi
19635
cat >conftest.$ac_ext <<_ACEOF
19636
/* confdefs.h.  */
19637
_ACEOF
19638
cat confdefs.h >>conftest.$ac_ext
19639
cat >>conftest.$ac_ext <<_ACEOF
19640
/* end confdefs.h.  */
19641
 
19642
/* Override any gcc2 internal prototype to avoid an error.  */
19643
#ifdef __cplusplus
19644
extern "C"
19645
#endif
19646
/* We use char because int might match the return type of a gcc2
19647
   builtin and then its argument prototype would still apply.  */
19648
char tanhl ();
19649
int
19650
main ()
19651
{
19652
tanhl ();
19653
  ;
19654
  return 0;
19655
}
19656
_ACEOF
19657
rm -f conftest.$ac_objext conftest$ac_exeext
19658
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19659
  (eval $ac_link) 2>conftest.er1
19660
  ac_status=$?
19661
  grep -v '^ *+' conftest.er1 >conftest.err
19662
  rm -f conftest.er1
19663
  cat conftest.err >&5
19664
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19665
  (exit $ac_status); } &&
19666
         { ac_try='test -z "$ac_c_werror_flag"
19667
                         || test ! -s conftest.err'
19668
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19669
  (eval $ac_try) 2>&5
19670
  ac_status=$?
19671
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19672
  (exit $ac_status); }; } &&
19673
         { ac_try='test -s conftest$ac_exeext'
19674
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19675
  (eval $ac_try) 2>&5
19676
  ac_status=$?
19677
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19678
  (exit $ac_status); }; }; then
19679
  ac_cv_lib_m_tanhl=yes
19680
else
19681
  echo "$as_me: failed program was:" >&5
19682
sed 's/^/| /' conftest.$ac_ext >&5
19683
 
19684
ac_cv_lib_m_tanhl=no
19685
fi
19686
rm -f conftest.err conftest.$ac_objext \
19687
      conftest$ac_exeext conftest.$ac_ext
19688
LIBS=$ac_check_lib_save_LIBS
19689
fi
19690
echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanhl" >&5
19691
echo "${ECHO_T}$ac_cv_lib_m_tanhl" >&6
19692
if test $ac_cv_lib_m_tanhl = yes; then
19693
 
19694
cat >>confdefs.h <<\_ACEOF
19695
#define HAVE_TANHL 1
19696
_ACEOF
19697
 
19698
fi
19699
 
19700
echo "$as_me:$LINENO: checking for ctanhf in -lm" >&5
19701
echo $ECHO_N "checking for ctanhf in -lm... $ECHO_C" >&6
19702
if test "${ac_cv_lib_m_ctanhf+set}" = set; then
19703
  echo $ECHO_N "(cached) $ECHO_C" >&6
19704
else
19705
  ac_check_lib_save_LIBS=$LIBS
19706
LIBS="-lm  $LIBS"
19707
if test x$gcc_no_link = xyes; then
19708
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19709
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19710
   { (exit 1); exit 1; }; }
19711
fi
19712
cat >conftest.$ac_ext <<_ACEOF
19713
/* confdefs.h.  */
19714
_ACEOF
19715
cat confdefs.h >>conftest.$ac_ext
19716
cat >>conftest.$ac_ext <<_ACEOF
19717
/* end confdefs.h.  */
19718
 
19719
/* Override any gcc2 internal prototype to avoid an error.  */
19720
#ifdef __cplusplus
19721
extern "C"
19722
#endif
19723
/* We use char because int might match the return type of a gcc2
19724
   builtin and then its argument prototype would still apply.  */
19725
char ctanhf ();
19726
int
19727
main ()
19728
{
19729
ctanhf ();
19730
  ;
19731
  return 0;
19732
}
19733
_ACEOF
19734
rm -f conftest.$ac_objext conftest$ac_exeext
19735
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19736
  (eval $ac_link) 2>conftest.er1
19737
  ac_status=$?
19738
  grep -v '^ *+' conftest.er1 >conftest.err
19739
  rm -f conftest.er1
19740
  cat conftest.err >&5
19741
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19742
  (exit $ac_status); } &&
19743
         { ac_try='test -z "$ac_c_werror_flag"
19744
                         || test ! -s conftest.err'
19745
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19746
  (eval $ac_try) 2>&5
19747
  ac_status=$?
19748
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19749
  (exit $ac_status); }; } &&
19750
         { ac_try='test -s conftest$ac_exeext'
19751
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19752
  (eval $ac_try) 2>&5
19753
  ac_status=$?
19754
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19755
  (exit $ac_status); }; }; then
19756
  ac_cv_lib_m_ctanhf=yes
19757
else
19758
  echo "$as_me: failed program was:" >&5
19759
sed 's/^/| /' conftest.$ac_ext >&5
19760
 
19761
ac_cv_lib_m_ctanhf=no
19762
fi
19763
rm -f conftest.err conftest.$ac_objext \
19764
      conftest$ac_exeext conftest.$ac_ext
19765
LIBS=$ac_check_lib_save_LIBS
19766
fi
19767
echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanhf" >&5
19768
echo "${ECHO_T}$ac_cv_lib_m_ctanhf" >&6
19769
if test $ac_cv_lib_m_ctanhf = yes; then
19770
 
19771
cat >>confdefs.h <<\_ACEOF
19772
#define HAVE_CTANHF 1
19773
_ACEOF
19774
 
19775
fi
19776
 
19777
echo "$as_me:$LINENO: checking for ctanh in -lm" >&5
19778
echo $ECHO_N "checking for ctanh in -lm... $ECHO_C" >&6
19779
if test "${ac_cv_lib_m_ctanh+set}" = set; then
19780
  echo $ECHO_N "(cached) $ECHO_C" >&6
19781
else
19782
  ac_check_lib_save_LIBS=$LIBS
19783
LIBS="-lm  $LIBS"
19784
if test x$gcc_no_link = xyes; then
19785
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19786
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19787
   { (exit 1); exit 1; }; }
19788
fi
19789
cat >conftest.$ac_ext <<_ACEOF
19790
/* confdefs.h.  */
19791
_ACEOF
19792
cat confdefs.h >>conftest.$ac_ext
19793
cat >>conftest.$ac_ext <<_ACEOF
19794
/* end confdefs.h.  */
19795
 
19796
/* Override any gcc2 internal prototype to avoid an error.  */
19797
#ifdef __cplusplus
19798
extern "C"
19799
#endif
19800
/* We use char because int might match the return type of a gcc2
19801
   builtin and then its argument prototype would still apply.  */
19802
char ctanh ();
19803
int
19804
main ()
19805
{
19806
ctanh ();
19807
  ;
19808
  return 0;
19809
}
19810
_ACEOF
19811
rm -f conftest.$ac_objext conftest$ac_exeext
19812
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19813
  (eval $ac_link) 2>conftest.er1
19814
  ac_status=$?
19815
  grep -v '^ *+' conftest.er1 >conftest.err
19816
  rm -f conftest.er1
19817
  cat conftest.err >&5
19818
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19819
  (exit $ac_status); } &&
19820
         { ac_try='test -z "$ac_c_werror_flag"
19821
                         || test ! -s conftest.err'
19822
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19823
  (eval $ac_try) 2>&5
19824
  ac_status=$?
19825
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19826
  (exit $ac_status); }; } &&
19827
         { ac_try='test -s conftest$ac_exeext'
19828
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19829
  (eval $ac_try) 2>&5
19830
  ac_status=$?
19831
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19832
  (exit $ac_status); }; }; then
19833
  ac_cv_lib_m_ctanh=yes
19834
else
19835
  echo "$as_me: failed program was:" >&5
19836
sed 's/^/| /' conftest.$ac_ext >&5
19837
 
19838
ac_cv_lib_m_ctanh=no
19839
fi
19840
rm -f conftest.err conftest.$ac_objext \
19841
      conftest$ac_exeext conftest.$ac_ext
19842
LIBS=$ac_check_lib_save_LIBS
19843
fi
19844
echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanh" >&5
19845
echo "${ECHO_T}$ac_cv_lib_m_ctanh" >&6
19846
if test $ac_cv_lib_m_ctanh = yes; then
19847
 
19848
cat >>confdefs.h <<\_ACEOF
19849
#define HAVE_CTANH 1
19850
_ACEOF
19851
 
19852
fi
19853
 
19854
echo "$as_me:$LINENO: checking for ctanhl in -lm" >&5
19855
echo $ECHO_N "checking for ctanhl in -lm... $ECHO_C" >&6
19856
if test "${ac_cv_lib_m_ctanhl+set}" = set; then
19857
  echo $ECHO_N "(cached) $ECHO_C" >&6
19858
else
19859
  ac_check_lib_save_LIBS=$LIBS
19860
LIBS="-lm  $LIBS"
19861
if test x$gcc_no_link = xyes; then
19862
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19863
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19864
   { (exit 1); exit 1; }; }
19865
fi
19866
cat >conftest.$ac_ext <<_ACEOF
19867
/* confdefs.h.  */
19868
_ACEOF
19869
cat confdefs.h >>conftest.$ac_ext
19870
cat >>conftest.$ac_ext <<_ACEOF
19871
/* end confdefs.h.  */
19872
 
19873
/* Override any gcc2 internal prototype to avoid an error.  */
19874
#ifdef __cplusplus
19875
extern "C"
19876
#endif
19877
/* We use char because int might match the return type of a gcc2
19878
   builtin and then its argument prototype would still apply.  */
19879
char ctanhl ();
19880
int
19881
main ()
19882
{
19883
ctanhl ();
19884
  ;
19885
  return 0;
19886
}
19887
_ACEOF
19888
rm -f conftest.$ac_objext conftest$ac_exeext
19889
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19890
  (eval $ac_link) 2>conftest.er1
19891
  ac_status=$?
19892
  grep -v '^ *+' conftest.er1 >conftest.err
19893
  rm -f conftest.er1
19894
  cat conftest.err >&5
19895
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19896
  (exit $ac_status); } &&
19897
         { ac_try='test -z "$ac_c_werror_flag"
19898
                         || test ! -s conftest.err'
19899
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19900
  (eval $ac_try) 2>&5
19901
  ac_status=$?
19902
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19903
  (exit $ac_status); }; } &&
19904
         { ac_try='test -s conftest$ac_exeext'
19905
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19906
  (eval $ac_try) 2>&5
19907
  ac_status=$?
19908
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19909
  (exit $ac_status); }; }; then
19910
  ac_cv_lib_m_ctanhl=yes
19911
else
19912
  echo "$as_me: failed program was:" >&5
19913
sed 's/^/| /' conftest.$ac_ext >&5
19914
 
19915
ac_cv_lib_m_ctanhl=no
19916
fi
19917
rm -f conftest.err conftest.$ac_objext \
19918
      conftest$ac_exeext conftest.$ac_ext
19919
LIBS=$ac_check_lib_save_LIBS
19920
fi
19921
echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanhl" >&5
19922
echo "${ECHO_T}$ac_cv_lib_m_ctanhl" >&6
19923
if test $ac_cv_lib_m_ctanhl = yes; then
19924
 
19925
cat >>confdefs.h <<\_ACEOF
19926
#define HAVE_CTANHL 1
19927
_ACEOF
19928
 
19929
fi
19930
 
19931
echo "$as_me:$LINENO: checking for truncf in -lm" >&5
19932
echo $ECHO_N "checking for truncf in -lm... $ECHO_C" >&6
19933
if test "${ac_cv_lib_m_truncf+set}" = set; then
19934
  echo $ECHO_N "(cached) $ECHO_C" >&6
19935
else
19936
  ac_check_lib_save_LIBS=$LIBS
19937
LIBS="-lm  $LIBS"
19938
if test x$gcc_no_link = xyes; then
19939
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19940
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19941
   { (exit 1); exit 1; }; }
19942
fi
19943
cat >conftest.$ac_ext <<_ACEOF
19944
/* confdefs.h.  */
19945
_ACEOF
19946
cat confdefs.h >>conftest.$ac_ext
19947
cat >>conftest.$ac_ext <<_ACEOF
19948
/* end confdefs.h.  */
19949
 
19950
/* Override any gcc2 internal prototype to avoid an error.  */
19951
#ifdef __cplusplus
19952
extern "C"
19953
#endif
19954
/* We use char because int might match the return type of a gcc2
19955
   builtin and then its argument prototype would still apply.  */
19956
char truncf ();
19957
int
19958
main ()
19959
{
19960
truncf ();
19961
  ;
19962
  return 0;
19963
}
19964
_ACEOF
19965
rm -f conftest.$ac_objext conftest$ac_exeext
19966
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19967
  (eval $ac_link) 2>conftest.er1
19968
  ac_status=$?
19969
  grep -v '^ *+' conftest.er1 >conftest.err
19970
  rm -f conftest.er1
19971
  cat conftest.err >&5
19972
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19973
  (exit $ac_status); } &&
19974
         { ac_try='test -z "$ac_c_werror_flag"
19975
                         || test ! -s conftest.err'
19976
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19977
  (eval $ac_try) 2>&5
19978
  ac_status=$?
19979
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19980
  (exit $ac_status); }; } &&
19981
         { ac_try='test -s conftest$ac_exeext'
19982
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19983
  (eval $ac_try) 2>&5
19984
  ac_status=$?
19985
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
19986
  (exit $ac_status); }; }; then
19987
  ac_cv_lib_m_truncf=yes
19988
else
19989
  echo "$as_me: failed program was:" >&5
19990
sed 's/^/| /' conftest.$ac_ext >&5
19991
 
19992
ac_cv_lib_m_truncf=no
19993
fi
19994
rm -f conftest.err conftest.$ac_objext \
19995
      conftest$ac_exeext conftest.$ac_ext
19996
LIBS=$ac_check_lib_save_LIBS
19997
fi
19998
echo "$as_me:$LINENO: result: $ac_cv_lib_m_truncf" >&5
19999
echo "${ECHO_T}$ac_cv_lib_m_truncf" >&6
20000
if test $ac_cv_lib_m_truncf = yes; then
20001
 
20002
cat >>confdefs.h <<\_ACEOF
20003
#define HAVE_TRUNCF 1
20004
_ACEOF
20005
 
20006
fi
20007
 
20008
echo "$as_me:$LINENO: checking for trunc in -lm" >&5
20009
echo $ECHO_N "checking for trunc in -lm... $ECHO_C" >&6
20010
if test "${ac_cv_lib_m_trunc+set}" = set; then
20011
  echo $ECHO_N "(cached) $ECHO_C" >&6
20012
else
20013
  ac_check_lib_save_LIBS=$LIBS
20014
LIBS="-lm  $LIBS"
20015
if test x$gcc_no_link = xyes; then
20016
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20017
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20018
   { (exit 1); exit 1; }; }
20019
fi
20020
cat >conftest.$ac_ext <<_ACEOF
20021
/* confdefs.h.  */
20022
_ACEOF
20023
cat confdefs.h >>conftest.$ac_ext
20024
cat >>conftest.$ac_ext <<_ACEOF
20025
/* end confdefs.h.  */
20026
 
20027
/* Override any gcc2 internal prototype to avoid an error.  */
20028
#ifdef __cplusplus
20029
extern "C"
20030
#endif
20031
/* We use char because int might match the return type of a gcc2
20032
   builtin and then its argument prototype would still apply.  */
20033
char trunc ();
20034
int
20035
main ()
20036
{
20037
trunc ();
20038
  ;
20039
  return 0;
20040
}
20041
_ACEOF
20042
rm -f conftest.$ac_objext conftest$ac_exeext
20043
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20044
  (eval $ac_link) 2>conftest.er1
20045
  ac_status=$?
20046
  grep -v '^ *+' conftest.er1 >conftest.err
20047
  rm -f conftest.er1
20048
  cat conftest.err >&5
20049
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20050
  (exit $ac_status); } &&
20051
         { ac_try='test -z "$ac_c_werror_flag"
20052
                         || test ! -s conftest.err'
20053
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20054
  (eval $ac_try) 2>&5
20055
  ac_status=$?
20056
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20057
  (exit $ac_status); }; } &&
20058
         { ac_try='test -s conftest$ac_exeext'
20059
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20060
  (eval $ac_try) 2>&5
20061
  ac_status=$?
20062
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20063
  (exit $ac_status); }; }; then
20064
  ac_cv_lib_m_trunc=yes
20065
else
20066
  echo "$as_me: failed program was:" >&5
20067
sed 's/^/| /' conftest.$ac_ext >&5
20068
 
20069
ac_cv_lib_m_trunc=no
20070
fi
20071
rm -f conftest.err conftest.$ac_objext \
20072
      conftest$ac_exeext conftest.$ac_ext
20073
LIBS=$ac_check_lib_save_LIBS
20074
fi
20075
echo "$as_me:$LINENO: result: $ac_cv_lib_m_trunc" >&5
20076
echo "${ECHO_T}$ac_cv_lib_m_trunc" >&6
20077
if test $ac_cv_lib_m_trunc = yes; then
20078
 
20079
cat >>confdefs.h <<\_ACEOF
20080
#define HAVE_TRUNC 1
20081
_ACEOF
20082
 
20083
fi
20084
 
20085
echo "$as_me:$LINENO: checking for truncl in -lm" >&5
20086
echo $ECHO_N "checking for truncl in -lm... $ECHO_C" >&6
20087
if test "${ac_cv_lib_m_truncl+set}" = set; then
20088
  echo $ECHO_N "(cached) $ECHO_C" >&6
20089
else
20090
  ac_check_lib_save_LIBS=$LIBS
20091
LIBS="-lm  $LIBS"
20092
if test x$gcc_no_link = xyes; then
20093
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20094
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20095
   { (exit 1); exit 1; }; }
20096
fi
20097
cat >conftest.$ac_ext <<_ACEOF
20098
/* confdefs.h.  */
20099
_ACEOF
20100
cat confdefs.h >>conftest.$ac_ext
20101
cat >>conftest.$ac_ext <<_ACEOF
20102
/* end confdefs.h.  */
20103
 
20104
/* Override any gcc2 internal prototype to avoid an error.  */
20105
#ifdef __cplusplus
20106
extern "C"
20107
#endif
20108
/* We use char because int might match the return type of a gcc2
20109
   builtin and then its argument prototype would still apply.  */
20110
char truncl ();
20111
int
20112
main ()
20113
{
20114
truncl ();
20115
  ;
20116
  return 0;
20117
}
20118
_ACEOF
20119
rm -f conftest.$ac_objext conftest$ac_exeext
20120
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20121
  (eval $ac_link) 2>conftest.er1
20122
  ac_status=$?
20123
  grep -v '^ *+' conftest.er1 >conftest.err
20124
  rm -f conftest.er1
20125
  cat conftest.err >&5
20126
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20127
  (exit $ac_status); } &&
20128
         { ac_try='test -z "$ac_c_werror_flag"
20129
                         || test ! -s conftest.err'
20130
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20131
  (eval $ac_try) 2>&5
20132
  ac_status=$?
20133
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20134
  (exit $ac_status); }; } &&
20135
         { ac_try='test -s conftest$ac_exeext'
20136
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20137
  (eval $ac_try) 2>&5
20138
  ac_status=$?
20139
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20140
  (exit $ac_status); }; }; then
20141
  ac_cv_lib_m_truncl=yes
20142
else
20143
  echo "$as_me: failed program was:" >&5
20144
sed 's/^/| /' conftest.$ac_ext >&5
20145
 
20146
ac_cv_lib_m_truncl=no
20147
fi
20148
rm -f conftest.err conftest.$ac_objext \
20149
      conftest$ac_exeext conftest.$ac_ext
20150
LIBS=$ac_check_lib_save_LIBS
20151
fi
20152
echo "$as_me:$LINENO: result: $ac_cv_lib_m_truncl" >&5
20153
echo "${ECHO_T}$ac_cv_lib_m_truncl" >&6
20154
if test $ac_cv_lib_m_truncl = yes; then
20155
 
20156
cat >>confdefs.h <<\_ACEOF
20157
#define HAVE_TRUNCL 1
20158
_ACEOF
20159
 
20160
fi
20161
 
20162
echo "$as_me:$LINENO: checking for erff in -lm" >&5
20163
echo $ECHO_N "checking for erff in -lm... $ECHO_C" >&6
20164
if test "${ac_cv_lib_m_erff+set}" = set; then
20165
  echo $ECHO_N "(cached) $ECHO_C" >&6
20166
else
20167
  ac_check_lib_save_LIBS=$LIBS
20168
LIBS="-lm  $LIBS"
20169
if test x$gcc_no_link = xyes; then
20170
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20171
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20172
   { (exit 1); exit 1; }; }
20173
fi
20174
cat >conftest.$ac_ext <<_ACEOF
20175
/* confdefs.h.  */
20176
_ACEOF
20177
cat confdefs.h >>conftest.$ac_ext
20178
cat >>conftest.$ac_ext <<_ACEOF
20179
/* end confdefs.h.  */
20180
 
20181
/* Override any gcc2 internal prototype to avoid an error.  */
20182
#ifdef __cplusplus
20183
extern "C"
20184
#endif
20185
/* We use char because int might match the return type of a gcc2
20186
   builtin and then its argument prototype would still apply.  */
20187
char erff ();
20188
int
20189
main ()
20190
{
20191
erff ();
20192
  ;
20193
  return 0;
20194
}
20195
_ACEOF
20196
rm -f conftest.$ac_objext conftest$ac_exeext
20197
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20198
  (eval $ac_link) 2>conftest.er1
20199
  ac_status=$?
20200
  grep -v '^ *+' conftest.er1 >conftest.err
20201
  rm -f conftest.er1
20202
  cat conftest.err >&5
20203
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20204
  (exit $ac_status); } &&
20205
         { ac_try='test -z "$ac_c_werror_flag"
20206
                         || test ! -s conftest.err'
20207
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20208
  (eval $ac_try) 2>&5
20209
  ac_status=$?
20210
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20211
  (exit $ac_status); }; } &&
20212
         { ac_try='test -s conftest$ac_exeext'
20213
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20214
  (eval $ac_try) 2>&5
20215
  ac_status=$?
20216
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20217
  (exit $ac_status); }; }; then
20218
  ac_cv_lib_m_erff=yes
20219
else
20220
  echo "$as_me: failed program was:" >&5
20221
sed 's/^/| /' conftest.$ac_ext >&5
20222
 
20223
ac_cv_lib_m_erff=no
20224
fi
20225
rm -f conftest.err conftest.$ac_objext \
20226
      conftest$ac_exeext conftest.$ac_ext
20227
LIBS=$ac_check_lib_save_LIBS
20228
fi
20229
echo "$as_me:$LINENO: result: $ac_cv_lib_m_erff" >&5
20230
echo "${ECHO_T}$ac_cv_lib_m_erff" >&6
20231
if test $ac_cv_lib_m_erff = yes; then
20232
 
20233
cat >>confdefs.h <<\_ACEOF
20234
#define HAVE_ERFF 1
20235
_ACEOF
20236
 
20237
fi
20238
 
20239
echo "$as_me:$LINENO: checking for erf in -lm" >&5
20240
echo $ECHO_N "checking for erf in -lm... $ECHO_C" >&6
20241
if test "${ac_cv_lib_m_erf+set}" = set; then
20242
  echo $ECHO_N "(cached) $ECHO_C" >&6
20243
else
20244
  ac_check_lib_save_LIBS=$LIBS
20245
LIBS="-lm  $LIBS"
20246
if test x$gcc_no_link = xyes; then
20247
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20248
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20249
   { (exit 1); exit 1; }; }
20250
fi
20251
cat >conftest.$ac_ext <<_ACEOF
20252
/* confdefs.h.  */
20253
_ACEOF
20254
cat confdefs.h >>conftest.$ac_ext
20255
cat >>conftest.$ac_ext <<_ACEOF
20256
/* end confdefs.h.  */
20257
 
20258
/* Override any gcc2 internal prototype to avoid an error.  */
20259
#ifdef __cplusplus
20260
extern "C"
20261
#endif
20262
/* We use char because int might match the return type of a gcc2
20263
   builtin and then its argument prototype would still apply.  */
20264
char erf ();
20265
int
20266
main ()
20267
{
20268
erf ();
20269
  ;
20270
  return 0;
20271
}
20272
_ACEOF
20273
rm -f conftest.$ac_objext conftest$ac_exeext
20274
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20275
  (eval $ac_link) 2>conftest.er1
20276
  ac_status=$?
20277
  grep -v '^ *+' conftest.er1 >conftest.err
20278
  rm -f conftest.er1
20279
  cat conftest.err >&5
20280
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20281
  (exit $ac_status); } &&
20282
         { ac_try='test -z "$ac_c_werror_flag"
20283
                         || test ! -s conftest.err'
20284
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20285
  (eval $ac_try) 2>&5
20286
  ac_status=$?
20287
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20288
  (exit $ac_status); }; } &&
20289
         { ac_try='test -s conftest$ac_exeext'
20290
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20291
  (eval $ac_try) 2>&5
20292
  ac_status=$?
20293
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20294
  (exit $ac_status); }; }; then
20295
  ac_cv_lib_m_erf=yes
20296
else
20297
  echo "$as_me: failed program was:" >&5
20298
sed 's/^/| /' conftest.$ac_ext >&5
20299
 
20300
ac_cv_lib_m_erf=no
20301
fi
20302
rm -f conftest.err conftest.$ac_objext \
20303
      conftest$ac_exeext conftest.$ac_ext
20304
LIBS=$ac_check_lib_save_LIBS
20305
fi
20306
echo "$as_me:$LINENO: result: $ac_cv_lib_m_erf" >&5
20307
echo "${ECHO_T}$ac_cv_lib_m_erf" >&6
20308
if test $ac_cv_lib_m_erf = yes; then
20309
 
20310
cat >>confdefs.h <<\_ACEOF
20311
#define HAVE_ERF 1
20312
_ACEOF
20313
 
20314
fi
20315
 
20316
echo "$as_me:$LINENO: checking for erfl in -lm" >&5
20317
echo $ECHO_N "checking for erfl in -lm... $ECHO_C" >&6
20318
if test "${ac_cv_lib_m_erfl+set}" = set; then
20319
  echo $ECHO_N "(cached) $ECHO_C" >&6
20320
else
20321
  ac_check_lib_save_LIBS=$LIBS
20322
LIBS="-lm  $LIBS"
20323
if test x$gcc_no_link = xyes; then
20324
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20325
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20326
   { (exit 1); exit 1; }; }
20327
fi
20328
cat >conftest.$ac_ext <<_ACEOF
20329
/* confdefs.h.  */
20330
_ACEOF
20331
cat confdefs.h >>conftest.$ac_ext
20332
cat >>conftest.$ac_ext <<_ACEOF
20333
/* end confdefs.h.  */
20334
 
20335
/* Override any gcc2 internal prototype to avoid an error.  */
20336
#ifdef __cplusplus
20337
extern "C"
20338
#endif
20339
/* We use char because int might match the return type of a gcc2
20340
   builtin and then its argument prototype would still apply.  */
20341
char erfl ();
20342
int
20343
main ()
20344
{
20345
erfl ();
20346
  ;
20347
  return 0;
20348
}
20349
_ACEOF
20350
rm -f conftest.$ac_objext conftest$ac_exeext
20351
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20352
  (eval $ac_link) 2>conftest.er1
20353
  ac_status=$?
20354
  grep -v '^ *+' conftest.er1 >conftest.err
20355
  rm -f conftest.er1
20356
  cat conftest.err >&5
20357
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20358
  (exit $ac_status); } &&
20359
         { ac_try='test -z "$ac_c_werror_flag"
20360
                         || test ! -s conftest.err'
20361
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20362
  (eval $ac_try) 2>&5
20363
  ac_status=$?
20364
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20365
  (exit $ac_status); }; } &&
20366
         { ac_try='test -s conftest$ac_exeext'
20367
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20368
  (eval $ac_try) 2>&5
20369
  ac_status=$?
20370
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20371
  (exit $ac_status); }; }; then
20372
  ac_cv_lib_m_erfl=yes
20373
else
20374
  echo "$as_me: failed program was:" >&5
20375
sed 's/^/| /' conftest.$ac_ext >&5
20376
 
20377
ac_cv_lib_m_erfl=no
20378
fi
20379
rm -f conftest.err conftest.$ac_objext \
20380
      conftest$ac_exeext conftest.$ac_ext
20381
LIBS=$ac_check_lib_save_LIBS
20382
fi
20383
echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfl" >&5
20384
echo "${ECHO_T}$ac_cv_lib_m_erfl" >&6
20385
if test $ac_cv_lib_m_erfl = yes; then
20386
 
20387
cat >>confdefs.h <<\_ACEOF
20388
#define HAVE_ERFL 1
20389
_ACEOF
20390
 
20391
fi
20392
 
20393
echo "$as_me:$LINENO: checking for erfcf in -lm" >&5
20394
echo $ECHO_N "checking for erfcf in -lm... $ECHO_C" >&6
20395
if test "${ac_cv_lib_m_erfcf+set}" = set; then
20396
  echo $ECHO_N "(cached) $ECHO_C" >&6
20397
else
20398
  ac_check_lib_save_LIBS=$LIBS
20399
LIBS="-lm  $LIBS"
20400
if test x$gcc_no_link = xyes; then
20401
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20402
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20403
   { (exit 1); exit 1; }; }
20404
fi
20405
cat >conftest.$ac_ext <<_ACEOF
20406
/* confdefs.h.  */
20407
_ACEOF
20408
cat confdefs.h >>conftest.$ac_ext
20409
cat >>conftest.$ac_ext <<_ACEOF
20410
/* end confdefs.h.  */
20411
 
20412
/* Override any gcc2 internal prototype to avoid an error.  */
20413
#ifdef __cplusplus
20414
extern "C"
20415
#endif
20416
/* We use char because int might match the return type of a gcc2
20417
   builtin and then its argument prototype would still apply.  */
20418
char erfcf ();
20419
int
20420
main ()
20421
{
20422
erfcf ();
20423
  ;
20424
  return 0;
20425
}
20426
_ACEOF
20427
rm -f conftest.$ac_objext conftest$ac_exeext
20428
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20429
  (eval $ac_link) 2>conftest.er1
20430
  ac_status=$?
20431
  grep -v '^ *+' conftest.er1 >conftest.err
20432
  rm -f conftest.er1
20433
  cat conftest.err >&5
20434
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20435
  (exit $ac_status); } &&
20436
         { ac_try='test -z "$ac_c_werror_flag"
20437
                         || test ! -s conftest.err'
20438
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20439
  (eval $ac_try) 2>&5
20440
  ac_status=$?
20441
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20442
  (exit $ac_status); }; } &&
20443
         { ac_try='test -s conftest$ac_exeext'
20444
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20445
  (eval $ac_try) 2>&5
20446
  ac_status=$?
20447
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20448
  (exit $ac_status); }; }; then
20449
  ac_cv_lib_m_erfcf=yes
20450
else
20451
  echo "$as_me: failed program was:" >&5
20452
sed 's/^/| /' conftest.$ac_ext >&5
20453
 
20454
ac_cv_lib_m_erfcf=no
20455
fi
20456
rm -f conftest.err conftest.$ac_objext \
20457
      conftest$ac_exeext conftest.$ac_ext
20458
LIBS=$ac_check_lib_save_LIBS
20459
fi
20460
echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfcf" >&5
20461
echo "${ECHO_T}$ac_cv_lib_m_erfcf" >&6
20462
if test $ac_cv_lib_m_erfcf = yes; then
20463
 
20464
cat >>confdefs.h <<\_ACEOF
20465
#define HAVE_ERFCF 1
20466
_ACEOF
20467
 
20468
fi
20469
 
20470
echo "$as_me:$LINENO: checking for erfc in -lm" >&5
20471
echo $ECHO_N "checking for erfc in -lm... $ECHO_C" >&6
20472
if test "${ac_cv_lib_m_erfc+set}" = set; then
20473
  echo $ECHO_N "(cached) $ECHO_C" >&6
20474
else
20475
  ac_check_lib_save_LIBS=$LIBS
20476
LIBS="-lm  $LIBS"
20477
if test x$gcc_no_link = xyes; then
20478
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20479
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20480
   { (exit 1); exit 1; }; }
20481
fi
20482
cat >conftest.$ac_ext <<_ACEOF
20483
/* confdefs.h.  */
20484
_ACEOF
20485
cat confdefs.h >>conftest.$ac_ext
20486
cat >>conftest.$ac_ext <<_ACEOF
20487
/* end confdefs.h.  */
20488
 
20489
/* Override any gcc2 internal prototype to avoid an error.  */
20490
#ifdef __cplusplus
20491
extern "C"
20492
#endif
20493
/* We use char because int might match the return type of a gcc2
20494
   builtin and then its argument prototype would still apply.  */
20495
char erfc ();
20496
int
20497
main ()
20498
{
20499
erfc ();
20500
  ;
20501
  return 0;
20502
}
20503
_ACEOF
20504
rm -f conftest.$ac_objext conftest$ac_exeext
20505
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20506
  (eval $ac_link) 2>conftest.er1
20507
  ac_status=$?
20508
  grep -v '^ *+' conftest.er1 >conftest.err
20509
  rm -f conftest.er1
20510
  cat conftest.err >&5
20511
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20512
  (exit $ac_status); } &&
20513
         { ac_try='test -z "$ac_c_werror_flag"
20514
                         || test ! -s conftest.err'
20515
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20516
  (eval $ac_try) 2>&5
20517
  ac_status=$?
20518
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20519
  (exit $ac_status); }; } &&
20520
         { ac_try='test -s conftest$ac_exeext'
20521
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20522
  (eval $ac_try) 2>&5
20523
  ac_status=$?
20524
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20525
  (exit $ac_status); }; }; then
20526
  ac_cv_lib_m_erfc=yes
20527
else
20528
  echo "$as_me: failed program was:" >&5
20529
sed 's/^/| /' conftest.$ac_ext >&5
20530
 
20531
ac_cv_lib_m_erfc=no
20532
fi
20533
rm -f conftest.err conftest.$ac_objext \
20534
      conftest$ac_exeext conftest.$ac_ext
20535
LIBS=$ac_check_lib_save_LIBS
20536
fi
20537
echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfc" >&5
20538
echo "${ECHO_T}$ac_cv_lib_m_erfc" >&6
20539
if test $ac_cv_lib_m_erfc = yes; then
20540
 
20541
cat >>confdefs.h <<\_ACEOF
20542
#define HAVE_ERFC 1
20543
_ACEOF
20544
 
20545
fi
20546
 
20547
echo "$as_me:$LINENO: checking for erfcl in -lm" >&5
20548
echo $ECHO_N "checking for erfcl in -lm... $ECHO_C" >&6
20549
if test "${ac_cv_lib_m_erfcl+set}" = set; then
20550
  echo $ECHO_N "(cached) $ECHO_C" >&6
20551
else
20552
  ac_check_lib_save_LIBS=$LIBS
20553
LIBS="-lm  $LIBS"
20554
if test x$gcc_no_link = xyes; then
20555
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20556
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20557
   { (exit 1); exit 1; }; }
20558
fi
20559
cat >conftest.$ac_ext <<_ACEOF
20560
/* confdefs.h.  */
20561
_ACEOF
20562
cat confdefs.h >>conftest.$ac_ext
20563
cat >>conftest.$ac_ext <<_ACEOF
20564
/* end confdefs.h.  */
20565
 
20566
/* Override any gcc2 internal prototype to avoid an error.  */
20567
#ifdef __cplusplus
20568
extern "C"
20569
#endif
20570
/* We use char because int might match the return type of a gcc2
20571
   builtin and then its argument prototype would still apply.  */
20572
char erfcl ();
20573
int
20574
main ()
20575
{
20576
erfcl ();
20577
  ;
20578
  return 0;
20579
}
20580
_ACEOF
20581
rm -f conftest.$ac_objext conftest$ac_exeext
20582
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20583
  (eval $ac_link) 2>conftest.er1
20584
  ac_status=$?
20585
  grep -v '^ *+' conftest.er1 >conftest.err
20586
  rm -f conftest.er1
20587
  cat conftest.err >&5
20588
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20589
  (exit $ac_status); } &&
20590
         { ac_try='test -z "$ac_c_werror_flag"
20591
                         || test ! -s conftest.err'
20592
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20593
  (eval $ac_try) 2>&5
20594
  ac_status=$?
20595
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20596
  (exit $ac_status); }; } &&
20597
         { ac_try='test -s conftest$ac_exeext'
20598
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20599
  (eval $ac_try) 2>&5
20600
  ac_status=$?
20601
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20602
  (exit $ac_status); }; }; then
20603
  ac_cv_lib_m_erfcl=yes
20604
else
20605
  echo "$as_me: failed program was:" >&5
20606
sed 's/^/| /' conftest.$ac_ext >&5
20607
 
20608
ac_cv_lib_m_erfcl=no
20609
fi
20610
rm -f conftest.err conftest.$ac_objext \
20611
      conftest$ac_exeext conftest.$ac_ext
20612
LIBS=$ac_check_lib_save_LIBS
20613
fi
20614
echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfcl" >&5
20615
echo "${ECHO_T}$ac_cv_lib_m_erfcl" >&6
20616
if test $ac_cv_lib_m_erfcl = yes; then
20617
 
20618
cat >>confdefs.h <<\_ACEOF
20619
#define HAVE_ERFCL 1
20620
_ACEOF
20621
 
20622
fi
20623
 
20624
echo "$as_me:$LINENO: checking for j0f in -lm" >&5
20625
echo $ECHO_N "checking for j0f in -lm... $ECHO_C" >&6
20626
if test "${ac_cv_lib_m_j0f+set}" = set; then
20627
  echo $ECHO_N "(cached) $ECHO_C" >&6
20628
else
20629
  ac_check_lib_save_LIBS=$LIBS
20630
LIBS="-lm  $LIBS"
20631
if test x$gcc_no_link = xyes; then
20632
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20633
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20634
   { (exit 1); exit 1; }; }
20635
fi
20636
cat >conftest.$ac_ext <<_ACEOF
20637
/* confdefs.h.  */
20638
_ACEOF
20639
cat confdefs.h >>conftest.$ac_ext
20640
cat >>conftest.$ac_ext <<_ACEOF
20641
/* end confdefs.h.  */
20642
 
20643
/* Override any gcc2 internal prototype to avoid an error.  */
20644
#ifdef __cplusplus
20645
extern "C"
20646
#endif
20647
/* We use char because int might match the return type of a gcc2
20648
   builtin and then its argument prototype would still apply.  */
20649
char j0f ();
20650
int
20651
main ()
20652
{
20653
j0f ();
20654
  ;
20655
  return 0;
20656
}
20657
_ACEOF
20658
rm -f conftest.$ac_objext conftest$ac_exeext
20659
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20660
  (eval $ac_link) 2>conftest.er1
20661
  ac_status=$?
20662
  grep -v '^ *+' conftest.er1 >conftest.err
20663
  rm -f conftest.er1
20664
  cat conftest.err >&5
20665
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20666
  (exit $ac_status); } &&
20667
         { ac_try='test -z "$ac_c_werror_flag"
20668
                         || test ! -s conftest.err'
20669
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20670
  (eval $ac_try) 2>&5
20671
  ac_status=$?
20672
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20673
  (exit $ac_status); }; } &&
20674
         { ac_try='test -s conftest$ac_exeext'
20675
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20676
  (eval $ac_try) 2>&5
20677
  ac_status=$?
20678
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20679
  (exit $ac_status); }; }; then
20680
  ac_cv_lib_m_j0f=yes
20681
else
20682
  echo "$as_me: failed program was:" >&5
20683
sed 's/^/| /' conftest.$ac_ext >&5
20684
 
20685
ac_cv_lib_m_j0f=no
20686
fi
20687
rm -f conftest.err conftest.$ac_objext \
20688
      conftest$ac_exeext conftest.$ac_ext
20689
LIBS=$ac_check_lib_save_LIBS
20690
fi
20691
echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0f" >&5
20692
echo "${ECHO_T}$ac_cv_lib_m_j0f" >&6
20693
if test $ac_cv_lib_m_j0f = yes; then
20694
 
20695
cat >>confdefs.h <<\_ACEOF
20696
#define HAVE_J0F 1
20697
_ACEOF
20698
 
20699
fi
20700
 
20701
echo "$as_me:$LINENO: checking for j0 in -lm" >&5
20702
echo $ECHO_N "checking for j0 in -lm... $ECHO_C" >&6
20703
if test "${ac_cv_lib_m_j0+set}" = set; then
20704
  echo $ECHO_N "(cached) $ECHO_C" >&6
20705
else
20706
  ac_check_lib_save_LIBS=$LIBS
20707
LIBS="-lm  $LIBS"
20708
if test x$gcc_no_link = xyes; then
20709
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20710
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20711
   { (exit 1); exit 1; }; }
20712
fi
20713
cat >conftest.$ac_ext <<_ACEOF
20714
/* confdefs.h.  */
20715
_ACEOF
20716
cat confdefs.h >>conftest.$ac_ext
20717
cat >>conftest.$ac_ext <<_ACEOF
20718
/* end confdefs.h.  */
20719
 
20720
/* Override any gcc2 internal prototype to avoid an error.  */
20721
#ifdef __cplusplus
20722
extern "C"
20723
#endif
20724
/* We use char because int might match the return type of a gcc2
20725
   builtin and then its argument prototype would still apply.  */
20726
char j0 ();
20727
int
20728
main ()
20729
{
20730
j0 ();
20731
  ;
20732
  return 0;
20733
}
20734
_ACEOF
20735
rm -f conftest.$ac_objext conftest$ac_exeext
20736
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20737
  (eval $ac_link) 2>conftest.er1
20738
  ac_status=$?
20739
  grep -v '^ *+' conftest.er1 >conftest.err
20740
  rm -f conftest.er1
20741
  cat conftest.err >&5
20742
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20743
  (exit $ac_status); } &&
20744
         { ac_try='test -z "$ac_c_werror_flag"
20745
                         || test ! -s conftest.err'
20746
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20747
  (eval $ac_try) 2>&5
20748
  ac_status=$?
20749
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20750
  (exit $ac_status); }; } &&
20751
         { ac_try='test -s conftest$ac_exeext'
20752
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20753
  (eval $ac_try) 2>&5
20754
  ac_status=$?
20755
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20756
  (exit $ac_status); }; }; then
20757
  ac_cv_lib_m_j0=yes
20758
else
20759
  echo "$as_me: failed program was:" >&5
20760
sed 's/^/| /' conftest.$ac_ext >&5
20761
 
20762
ac_cv_lib_m_j0=no
20763
fi
20764
rm -f conftest.err conftest.$ac_objext \
20765
      conftest$ac_exeext conftest.$ac_ext
20766
LIBS=$ac_check_lib_save_LIBS
20767
fi
20768
echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0" >&5
20769
echo "${ECHO_T}$ac_cv_lib_m_j0" >&6
20770
if test $ac_cv_lib_m_j0 = yes; then
20771
 
20772
cat >>confdefs.h <<\_ACEOF
20773
#define HAVE_J0 1
20774
_ACEOF
20775
 
20776
fi
20777
 
20778
echo "$as_me:$LINENO: checking for j0l in -lm" >&5
20779
echo $ECHO_N "checking for j0l in -lm... $ECHO_C" >&6
20780
if test "${ac_cv_lib_m_j0l+set}" = set; then
20781
  echo $ECHO_N "(cached) $ECHO_C" >&6
20782
else
20783
  ac_check_lib_save_LIBS=$LIBS
20784
LIBS="-lm  $LIBS"
20785
if test x$gcc_no_link = xyes; then
20786
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20787
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20788
   { (exit 1); exit 1; }; }
20789
fi
20790
cat >conftest.$ac_ext <<_ACEOF
20791
/* confdefs.h.  */
20792
_ACEOF
20793
cat confdefs.h >>conftest.$ac_ext
20794
cat >>conftest.$ac_ext <<_ACEOF
20795
/* end confdefs.h.  */
20796
 
20797
/* Override any gcc2 internal prototype to avoid an error.  */
20798
#ifdef __cplusplus
20799
extern "C"
20800
#endif
20801
/* We use char because int might match the return type of a gcc2
20802
   builtin and then its argument prototype would still apply.  */
20803
char j0l ();
20804
int
20805
main ()
20806
{
20807
j0l ();
20808
  ;
20809
  return 0;
20810
}
20811
_ACEOF
20812
rm -f conftest.$ac_objext conftest$ac_exeext
20813
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20814
  (eval $ac_link) 2>conftest.er1
20815
  ac_status=$?
20816
  grep -v '^ *+' conftest.er1 >conftest.err
20817
  rm -f conftest.er1
20818
  cat conftest.err >&5
20819
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20820
  (exit $ac_status); } &&
20821
         { ac_try='test -z "$ac_c_werror_flag"
20822
                         || test ! -s conftest.err'
20823
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20824
  (eval $ac_try) 2>&5
20825
  ac_status=$?
20826
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20827
  (exit $ac_status); }; } &&
20828
         { ac_try='test -s conftest$ac_exeext'
20829
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20830
  (eval $ac_try) 2>&5
20831
  ac_status=$?
20832
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20833
  (exit $ac_status); }; }; then
20834
  ac_cv_lib_m_j0l=yes
20835
else
20836
  echo "$as_me: failed program was:" >&5
20837
sed 's/^/| /' conftest.$ac_ext >&5
20838
 
20839
ac_cv_lib_m_j0l=no
20840
fi
20841
rm -f conftest.err conftest.$ac_objext \
20842
      conftest$ac_exeext conftest.$ac_ext
20843
LIBS=$ac_check_lib_save_LIBS
20844
fi
20845
echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0l" >&5
20846
echo "${ECHO_T}$ac_cv_lib_m_j0l" >&6
20847
if test $ac_cv_lib_m_j0l = yes; then
20848
 
20849
cat >>confdefs.h <<\_ACEOF
20850
#define HAVE_J0L 1
20851
_ACEOF
20852
 
20853
fi
20854
 
20855
echo "$as_me:$LINENO: checking for j1f in -lm" >&5
20856
echo $ECHO_N "checking for j1f in -lm... $ECHO_C" >&6
20857
if test "${ac_cv_lib_m_j1f+set}" = set; then
20858
  echo $ECHO_N "(cached) $ECHO_C" >&6
20859
else
20860
  ac_check_lib_save_LIBS=$LIBS
20861
LIBS="-lm  $LIBS"
20862
if test x$gcc_no_link = xyes; then
20863
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20864
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20865
   { (exit 1); exit 1; }; }
20866
fi
20867
cat >conftest.$ac_ext <<_ACEOF
20868
/* confdefs.h.  */
20869
_ACEOF
20870
cat confdefs.h >>conftest.$ac_ext
20871
cat >>conftest.$ac_ext <<_ACEOF
20872
/* end confdefs.h.  */
20873
 
20874
/* Override any gcc2 internal prototype to avoid an error.  */
20875
#ifdef __cplusplus
20876
extern "C"
20877
#endif
20878
/* We use char because int might match the return type of a gcc2
20879
   builtin and then its argument prototype would still apply.  */
20880
char j1f ();
20881
int
20882
main ()
20883
{
20884
j1f ();
20885
  ;
20886
  return 0;
20887
}
20888
_ACEOF
20889
rm -f conftest.$ac_objext conftest$ac_exeext
20890
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20891
  (eval $ac_link) 2>conftest.er1
20892
  ac_status=$?
20893
  grep -v '^ *+' conftest.er1 >conftest.err
20894
  rm -f conftest.er1
20895
  cat conftest.err >&5
20896
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20897
  (exit $ac_status); } &&
20898
         { ac_try='test -z "$ac_c_werror_flag"
20899
                         || test ! -s conftest.err'
20900
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20901
  (eval $ac_try) 2>&5
20902
  ac_status=$?
20903
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20904
  (exit $ac_status); }; } &&
20905
         { ac_try='test -s conftest$ac_exeext'
20906
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20907
  (eval $ac_try) 2>&5
20908
  ac_status=$?
20909
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20910
  (exit $ac_status); }; }; then
20911
  ac_cv_lib_m_j1f=yes
20912
else
20913
  echo "$as_me: failed program was:" >&5
20914
sed 's/^/| /' conftest.$ac_ext >&5
20915
 
20916
ac_cv_lib_m_j1f=no
20917
fi
20918
rm -f conftest.err conftest.$ac_objext \
20919
      conftest$ac_exeext conftest.$ac_ext
20920
LIBS=$ac_check_lib_save_LIBS
20921
fi
20922
echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1f" >&5
20923
echo "${ECHO_T}$ac_cv_lib_m_j1f" >&6
20924
if test $ac_cv_lib_m_j1f = yes; then
20925
 
20926
cat >>confdefs.h <<\_ACEOF
20927
#define HAVE_J1F 1
20928
_ACEOF
20929
 
20930
fi
20931
 
20932
echo "$as_me:$LINENO: checking for j1 in -lm" >&5
20933
echo $ECHO_N "checking for j1 in -lm... $ECHO_C" >&6
20934
if test "${ac_cv_lib_m_j1+set}" = set; then
20935
  echo $ECHO_N "(cached) $ECHO_C" >&6
20936
else
20937
  ac_check_lib_save_LIBS=$LIBS
20938
LIBS="-lm  $LIBS"
20939
if test x$gcc_no_link = xyes; then
20940
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20941
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20942
   { (exit 1); exit 1; }; }
20943
fi
20944
cat >conftest.$ac_ext <<_ACEOF
20945
/* confdefs.h.  */
20946
_ACEOF
20947
cat confdefs.h >>conftest.$ac_ext
20948
cat >>conftest.$ac_ext <<_ACEOF
20949
/* end confdefs.h.  */
20950
 
20951
/* Override any gcc2 internal prototype to avoid an error.  */
20952
#ifdef __cplusplus
20953
extern "C"
20954
#endif
20955
/* We use char because int might match the return type of a gcc2
20956
   builtin and then its argument prototype would still apply.  */
20957
char j1 ();
20958
int
20959
main ()
20960
{
20961
j1 ();
20962
  ;
20963
  return 0;
20964
}
20965
_ACEOF
20966
rm -f conftest.$ac_objext conftest$ac_exeext
20967
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20968
  (eval $ac_link) 2>conftest.er1
20969
  ac_status=$?
20970
  grep -v '^ *+' conftest.er1 >conftest.err
20971
  rm -f conftest.er1
20972
  cat conftest.err >&5
20973
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20974
  (exit $ac_status); } &&
20975
         { ac_try='test -z "$ac_c_werror_flag"
20976
                         || test ! -s conftest.err'
20977
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20978
  (eval $ac_try) 2>&5
20979
  ac_status=$?
20980
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20981
  (exit $ac_status); }; } &&
20982
         { ac_try='test -s conftest$ac_exeext'
20983
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20984
  (eval $ac_try) 2>&5
20985
  ac_status=$?
20986
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20987
  (exit $ac_status); }; }; then
20988
  ac_cv_lib_m_j1=yes
20989
else
20990
  echo "$as_me: failed program was:" >&5
20991
sed 's/^/| /' conftest.$ac_ext >&5
20992
 
20993
ac_cv_lib_m_j1=no
20994
fi
20995
rm -f conftest.err conftest.$ac_objext \
20996
      conftest$ac_exeext conftest.$ac_ext
20997
LIBS=$ac_check_lib_save_LIBS
20998
fi
20999
echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1" >&5
21000
echo "${ECHO_T}$ac_cv_lib_m_j1" >&6
21001
if test $ac_cv_lib_m_j1 = yes; then
21002
 
21003
cat >>confdefs.h <<\_ACEOF
21004
#define HAVE_J1 1
21005
_ACEOF
21006
 
21007
fi
21008
 
21009
echo "$as_me:$LINENO: checking for j1l in -lm" >&5
21010
echo $ECHO_N "checking for j1l in -lm... $ECHO_C" >&6
21011
if test "${ac_cv_lib_m_j1l+set}" = set; then
21012
  echo $ECHO_N "(cached) $ECHO_C" >&6
21013
else
21014
  ac_check_lib_save_LIBS=$LIBS
21015
LIBS="-lm  $LIBS"
21016
if test x$gcc_no_link = xyes; then
21017
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21018
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21019
   { (exit 1); exit 1; }; }
21020
fi
21021
cat >conftest.$ac_ext <<_ACEOF
21022
/* confdefs.h.  */
21023
_ACEOF
21024
cat confdefs.h >>conftest.$ac_ext
21025
cat >>conftest.$ac_ext <<_ACEOF
21026
/* end confdefs.h.  */
21027
 
21028
/* Override any gcc2 internal prototype to avoid an error.  */
21029
#ifdef __cplusplus
21030
extern "C"
21031
#endif
21032
/* We use char because int might match the return type of a gcc2
21033
   builtin and then its argument prototype would still apply.  */
21034
char j1l ();
21035
int
21036
main ()
21037
{
21038
j1l ();
21039
  ;
21040
  return 0;
21041
}
21042
_ACEOF
21043
rm -f conftest.$ac_objext conftest$ac_exeext
21044
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21045
  (eval $ac_link) 2>conftest.er1
21046
  ac_status=$?
21047
  grep -v '^ *+' conftest.er1 >conftest.err
21048
  rm -f conftest.er1
21049
  cat conftest.err >&5
21050
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21051
  (exit $ac_status); } &&
21052
         { ac_try='test -z "$ac_c_werror_flag"
21053
                         || test ! -s conftest.err'
21054
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21055
  (eval $ac_try) 2>&5
21056
  ac_status=$?
21057
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21058
  (exit $ac_status); }; } &&
21059
         { ac_try='test -s conftest$ac_exeext'
21060
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21061
  (eval $ac_try) 2>&5
21062
  ac_status=$?
21063
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21064
  (exit $ac_status); }; }; then
21065
  ac_cv_lib_m_j1l=yes
21066
else
21067
  echo "$as_me: failed program was:" >&5
21068
sed 's/^/| /' conftest.$ac_ext >&5
21069
 
21070
ac_cv_lib_m_j1l=no
21071
fi
21072
rm -f conftest.err conftest.$ac_objext \
21073
      conftest$ac_exeext conftest.$ac_ext
21074
LIBS=$ac_check_lib_save_LIBS
21075
fi
21076
echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1l" >&5
21077
echo "${ECHO_T}$ac_cv_lib_m_j1l" >&6
21078
if test $ac_cv_lib_m_j1l = yes; then
21079
 
21080
cat >>confdefs.h <<\_ACEOF
21081
#define HAVE_J1L 1
21082
_ACEOF
21083
 
21084
fi
21085
 
21086
echo "$as_me:$LINENO: checking for jnf in -lm" >&5
21087
echo $ECHO_N "checking for jnf in -lm... $ECHO_C" >&6
21088
if test "${ac_cv_lib_m_jnf+set}" = set; then
21089
  echo $ECHO_N "(cached) $ECHO_C" >&6
21090
else
21091
  ac_check_lib_save_LIBS=$LIBS
21092
LIBS="-lm  $LIBS"
21093
if test x$gcc_no_link = xyes; then
21094
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21095
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21096
   { (exit 1); exit 1; }; }
21097
fi
21098
cat >conftest.$ac_ext <<_ACEOF
21099
/* confdefs.h.  */
21100
_ACEOF
21101
cat confdefs.h >>conftest.$ac_ext
21102
cat >>conftest.$ac_ext <<_ACEOF
21103
/* end confdefs.h.  */
21104
 
21105
/* Override any gcc2 internal prototype to avoid an error.  */
21106
#ifdef __cplusplus
21107
extern "C"
21108
#endif
21109
/* We use char because int might match the return type of a gcc2
21110
   builtin and then its argument prototype would still apply.  */
21111
char jnf ();
21112
int
21113
main ()
21114
{
21115
jnf ();
21116
  ;
21117
  return 0;
21118
}
21119
_ACEOF
21120
rm -f conftest.$ac_objext conftest$ac_exeext
21121
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21122
  (eval $ac_link) 2>conftest.er1
21123
  ac_status=$?
21124
  grep -v '^ *+' conftest.er1 >conftest.err
21125
  rm -f conftest.er1
21126
  cat conftest.err >&5
21127
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21128
  (exit $ac_status); } &&
21129
         { ac_try='test -z "$ac_c_werror_flag"
21130
                         || test ! -s conftest.err'
21131
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21132
  (eval $ac_try) 2>&5
21133
  ac_status=$?
21134
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21135
  (exit $ac_status); }; } &&
21136
         { ac_try='test -s conftest$ac_exeext'
21137
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21138
  (eval $ac_try) 2>&5
21139
  ac_status=$?
21140
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21141
  (exit $ac_status); }; }; then
21142
  ac_cv_lib_m_jnf=yes
21143
else
21144
  echo "$as_me: failed program was:" >&5
21145
sed 's/^/| /' conftest.$ac_ext >&5
21146
 
21147
ac_cv_lib_m_jnf=no
21148
fi
21149
rm -f conftest.err conftest.$ac_objext \
21150
      conftest$ac_exeext conftest.$ac_ext
21151
LIBS=$ac_check_lib_save_LIBS
21152
fi
21153
echo "$as_me:$LINENO: result: $ac_cv_lib_m_jnf" >&5
21154
echo "${ECHO_T}$ac_cv_lib_m_jnf" >&6
21155
if test $ac_cv_lib_m_jnf = yes; then
21156
 
21157
cat >>confdefs.h <<\_ACEOF
21158
#define HAVE_JNF 1
21159
_ACEOF
21160
 
21161
fi
21162
 
21163
echo "$as_me:$LINENO: checking for jn in -lm" >&5
21164
echo $ECHO_N "checking for jn in -lm... $ECHO_C" >&6
21165
if test "${ac_cv_lib_m_jn+set}" = set; then
21166
  echo $ECHO_N "(cached) $ECHO_C" >&6
21167
else
21168
  ac_check_lib_save_LIBS=$LIBS
21169
LIBS="-lm  $LIBS"
21170
if test x$gcc_no_link = xyes; then
21171
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21172
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21173
   { (exit 1); exit 1; }; }
21174
fi
21175
cat >conftest.$ac_ext <<_ACEOF
21176
/* confdefs.h.  */
21177
_ACEOF
21178
cat confdefs.h >>conftest.$ac_ext
21179
cat >>conftest.$ac_ext <<_ACEOF
21180
/* end confdefs.h.  */
21181
 
21182
/* Override any gcc2 internal prototype to avoid an error.  */
21183
#ifdef __cplusplus
21184
extern "C"
21185
#endif
21186
/* We use char because int might match the return type of a gcc2
21187
   builtin and then its argument prototype would still apply.  */
21188
char jn ();
21189
int
21190
main ()
21191
{
21192
jn ();
21193
  ;
21194
  return 0;
21195
}
21196
_ACEOF
21197
rm -f conftest.$ac_objext conftest$ac_exeext
21198
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21199
  (eval $ac_link) 2>conftest.er1
21200
  ac_status=$?
21201
  grep -v '^ *+' conftest.er1 >conftest.err
21202
  rm -f conftest.er1
21203
  cat conftest.err >&5
21204
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21205
  (exit $ac_status); } &&
21206
         { ac_try='test -z "$ac_c_werror_flag"
21207
                         || test ! -s conftest.err'
21208
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21209
  (eval $ac_try) 2>&5
21210
  ac_status=$?
21211
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21212
  (exit $ac_status); }; } &&
21213
         { ac_try='test -s conftest$ac_exeext'
21214
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21215
  (eval $ac_try) 2>&5
21216
  ac_status=$?
21217
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21218
  (exit $ac_status); }; }; then
21219
  ac_cv_lib_m_jn=yes
21220
else
21221
  echo "$as_me: failed program was:" >&5
21222
sed 's/^/| /' conftest.$ac_ext >&5
21223
 
21224
ac_cv_lib_m_jn=no
21225
fi
21226
rm -f conftest.err conftest.$ac_objext \
21227
      conftest$ac_exeext conftest.$ac_ext
21228
LIBS=$ac_check_lib_save_LIBS
21229
fi
21230
echo "$as_me:$LINENO: result: $ac_cv_lib_m_jn" >&5
21231
echo "${ECHO_T}$ac_cv_lib_m_jn" >&6
21232
if test $ac_cv_lib_m_jn = yes; then
21233
 
21234
cat >>confdefs.h <<\_ACEOF
21235
#define HAVE_JN 1
21236
_ACEOF
21237
 
21238
fi
21239
 
21240
echo "$as_me:$LINENO: checking for jnl in -lm" >&5
21241
echo $ECHO_N "checking for jnl in -lm... $ECHO_C" >&6
21242
if test "${ac_cv_lib_m_jnl+set}" = set; then
21243
  echo $ECHO_N "(cached) $ECHO_C" >&6
21244
else
21245
  ac_check_lib_save_LIBS=$LIBS
21246
LIBS="-lm  $LIBS"
21247
if test x$gcc_no_link = xyes; then
21248
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21249
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21250
   { (exit 1); exit 1; }; }
21251
fi
21252
cat >conftest.$ac_ext <<_ACEOF
21253
/* confdefs.h.  */
21254
_ACEOF
21255
cat confdefs.h >>conftest.$ac_ext
21256
cat >>conftest.$ac_ext <<_ACEOF
21257
/* end confdefs.h.  */
21258
 
21259
/* Override any gcc2 internal prototype to avoid an error.  */
21260
#ifdef __cplusplus
21261
extern "C"
21262
#endif
21263
/* We use char because int might match the return type of a gcc2
21264
   builtin and then its argument prototype would still apply.  */
21265
char jnl ();
21266
int
21267
main ()
21268
{
21269
jnl ();
21270
  ;
21271
  return 0;
21272
}
21273
_ACEOF
21274
rm -f conftest.$ac_objext conftest$ac_exeext
21275
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21276
  (eval $ac_link) 2>conftest.er1
21277
  ac_status=$?
21278
  grep -v '^ *+' conftest.er1 >conftest.err
21279
  rm -f conftest.er1
21280
  cat conftest.err >&5
21281
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21282
  (exit $ac_status); } &&
21283
         { ac_try='test -z "$ac_c_werror_flag"
21284
                         || test ! -s conftest.err'
21285
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21286
  (eval $ac_try) 2>&5
21287
  ac_status=$?
21288
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21289
  (exit $ac_status); }; } &&
21290
         { ac_try='test -s conftest$ac_exeext'
21291
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21292
  (eval $ac_try) 2>&5
21293
  ac_status=$?
21294
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21295
  (exit $ac_status); }; }; then
21296
  ac_cv_lib_m_jnl=yes
21297
else
21298
  echo "$as_me: failed program was:" >&5
21299
sed 's/^/| /' conftest.$ac_ext >&5
21300
 
21301
ac_cv_lib_m_jnl=no
21302
fi
21303
rm -f conftest.err conftest.$ac_objext \
21304
      conftest$ac_exeext conftest.$ac_ext
21305
LIBS=$ac_check_lib_save_LIBS
21306
fi
21307
echo "$as_me:$LINENO: result: $ac_cv_lib_m_jnl" >&5
21308
echo "${ECHO_T}$ac_cv_lib_m_jnl" >&6
21309
if test $ac_cv_lib_m_jnl = yes; then
21310
 
21311
cat >>confdefs.h <<\_ACEOF
21312
#define HAVE_JNL 1
21313
_ACEOF
21314
 
21315
fi
21316
 
21317
echo "$as_me:$LINENO: checking for y0f in -lm" >&5
21318
echo $ECHO_N "checking for y0f in -lm... $ECHO_C" >&6
21319
if test "${ac_cv_lib_m_y0f+set}" = set; then
21320
  echo $ECHO_N "(cached) $ECHO_C" >&6
21321
else
21322
  ac_check_lib_save_LIBS=$LIBS
21323
LIBS="-lm  $LIBS"
21324
if test x$gcc_no_link = xyes; then
21325
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21326
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21327
   { (exit 1); exit 1; }; }
21328
fi
21329
cat >conftest.$ac_ext <<_ACEOF
21330
/* confdefs.h.  */
21331
_ACEOF
21332
cat confdefs.h >>conftest.$ac_ext
21333
cat >>conftest.$ac_ext <<_ACEOF
21334
/* end confdefs.h.  */
21335
 
21336
/* Override any gcc2 internal prototype to avoid an error.  */
21337
#ifdef __cplusplus
21338
extern "C"
21339
#endif
21340
/* We use char because int might match the return type of a gcc2
21341
   builtin and then its argument prototype would still apply.  */
21342
char y0f ();
21343
int
21344
main ()
21345
{
21346
y0f ();
21347
  ;
21348
  return 0;
21349
}
21350
_ACEOF
21351
rm -f conftest.$ac_objext conftest$ac_exeext
21352
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21353
  (eval $ac_link) 2>conftest.er1
21354
  ac_status=$?
21355
  grep -v '^ *+' conftest.er1 >conftest.err
21356
  rm -f conftest.er1
21357
  cat conftest.err >&5
21358
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21359
  (exit $ac_status); } &&
21360
         { ac_try='test -z "$ac_c_werror_flag"
21361
                         || test ! -s conftest.err'
21362
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21363
  (eval $ac_try) 2>&5
21364
  ac_status=$?
21365
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21366
  (exit $ac_status); }; } &&
21367
         { ac_try='test -s conftest$ac_exeext'
21368
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21369
  (eval $ac_try) 2>&5
21370
  ac_status=$?
21371
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21372
  (exit $ac_status); }; }; then
21373
  ac_cv_lib_m_y0f=yes
21374
else
21375
  echo "$as_me: failed program was:" >&5
21376
sed 's/^/| /' conftest.$ac_ext >&5
21377
 
21378
ac_cv_lib_m_y0f=no
21379
fi
21380
rm -f conftest.err conftest.$ac_objext \
21381
      conftest$ac_exeext conftest.$ac_ext
21382
LIBS=$ac_check_lib_save_LIBS
21383
fi
21384
echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0f" >&5
21385
echo "${ECHO_T}$ac_cv_lib_m_y0f" >&6
21386
if test $ac_cv_lib_m_y0f = yes; then
21387
 
21388
cat >>confdefs.h <<\_ACEOF
21389
#define HAVE_Y0F 1
21390
_ACEOF
21391
 
21392
fi
21393
 
21394
echo "$as_me:$LINENO: checking for y0 in -lm" >&5
21395
echo $ECHO_N "checking for y0 in -lm... $ECHO_C" >&6
21396
if test "${ac_cv_lib_m_y0+set}" = set; then
21397
  echo $ECHO_N "(cached) $ECHO_C" >&6
21398
else
21399
  ac_check_lib_save_LIBS=$LIBS
21400
LIBS="-lm  $LIBS"
21401
if test x$gcc_no_link = xyes; then
21402
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21403
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21404
   { (exit 1); exit 1; }; }
21405
fi
21406
cat >conftest.$ac_ext <<_ACEOF
21407
/* confdefs.h.  */
21408
_ACEOF
21409
cat confdefs.h >>conftest.$ac_ext
21410
cat >>conftest.$ac_ext <<_ACEOF
21411
/* end confdefs.h.  */
21412
 
21413
/* Override any gcc2 internal prototype to avoid an error.  */
21414
#ifdef __cplusplus
21415
extern "C"
21416
#endif
21417
/* We use char because int might match the return type of a gcc2
21418
   builtin and then its argument prototype would still apply.  */
21419
char y0 ();
21420
int
21421
main ()
21422
{
21423
y0 ();
21424
  ;
21425
  return 0;
21426
}
21427
_ACEOF
21428
rm -f conftest.$ac_objext conftest$ac_exeext
21429
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21430
  (eval $ac_link) 2>conftest.er1
21431
  ac_status=$?
21432
  grep -v '^ *+' conftest.er1 >conftest.err
21433
  rm -f conftest.er1
21434
  cat conftest.err >&5
21435
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21436
  (exit $ac_status); } &&
21437
         { ac_try='test -z "$ac_c_werror_flag"
21438
                         || test ! -s conftest.err'
21439
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21440
  (eval $ac_try) 2>&5
21441
  ac_status=$?
21442
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21443
  (exit $ac_status); }; } &&
21444
         { ac_try='test -s conftest$ac_exeext'
21445
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21446
  (eval $ac_try) 2>&5
21447
  ac_status=$?
21448
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21449
  (exit $ac_status); }; }; then
21450
  ac_cv_lib_m_y0=yes
21451
else
21452
  echo "$as_me: failed program was:" >&5
21453
sed 's/^/| /' conftest.$ac_ext >&5
21454
 
21455
ac_cv_lib_m_y0=no
21456
fi
21457
rm -f conftest.err conftest.$ac_objext \
21458
      conftest$ac_exeext conftest.$ac_ext
21459
LIBS=$ac_check_lib_save_LIBS
21460
fi
21461
echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0" >&5
21462
echo "${ECHO_T}$ac_cv_lib_m_y0" >&6
21463
if test $ac_cv_lib_m_y0 = yes; then
21464
 
21465
cat >>confdefs.h <<\_ACEOF
21466
#define HAVE_Y0 1
21467
_ACEOF
21468
 
21469
fi
21470
 
21471
echo "$as_me:$LINENO: checking for y0l in -lm" >&5
21472
echo $ECHO_N "checking for y0l in -lm... $ECHO_C" >&6
21473
if test "${ac_cv_lib_m_y0l+set}" = set; then
21474
  echo $ECHO_N "(cached) $ECHO_C" >&6
21475
else
21476
  ac_check_lib_save_LIBS=$LIBS
21477
LIBS="-lm  $LIBS"
21478
if test x$gcc_no_link = xyes; then
21479
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21480
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21481
   { (exit 1); exit 1; }; }
21482
fi
21483
cat >conftest.$ac_ext <<_ACEOF
21484
/* confdefs.h.  */
21485
_ACEOF
21486
cat confdefs.h >>conftest.$ac_ext
21487
cat >>conftest.$ac_ext <<_ACEOF
21488
/* end confdefs.h.  */
21489
 
21490
/* Override any gcc2 internal prototype to avoid an error.  */
21491
#ifdef __cplusplus
21492
extern "C"
21493
#endif
21494
/* We use char because int might match the return type of a gcc2
21495
   builtin and then its argument prototype would still apply.  */
21496
char y0l ();
21497
int
21498
main ()
21499
{
21500
y0l ();
21501
  ;
21502
  return 0;
21503
}
21504
_ACEOF
21505
rm -f conftest.$ac_objext conftest$ac_exeext
21506
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21507
  (eval $ac_link) 2>conftest.er1
21508
  ac_status=$?
21509
  grep -v '^ *+' conftest.er1 >conftest.err
21510
  rm -f conftest.er1
21511
  cat conftest.err >&5
21512
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21513
  (exit $ac_status); } &&
21514
         { ac_try='test -z "$ac_c_werror_flag"
21515
                         || test ! -s conftest.err'
21516
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21517
  (eval $ac_try) 2>&5
21518
  ac_status=$?
21519
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21520
  (exit $ac_status); }; } &&
21521
         { ac_try='test -s conftest$ac_exeext'
21522
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21523
  (eval $ac_try) 2>&5
21524
  ac_status=$?
21525
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21526
  (exit $ac_status); }; }; then
21527
  ac_cv_lib_m_y0l=yes
21528
else
21529
  echo "$as_me: failed program was:" >&5
21530
sed 's/^/| /' conftest.$ac_ext >&5
21531
 
21532
ac_cv_lib_m_y0l=no
21533
fi
21534
rm -f conftest.err conftest.$ac_objext \
21535
      conftest$ac_exeext conftest.$ac_ext
21536
LIBS=$ac_check_lib_save_LIBS
21537
fi
21538
echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0l" >&5
21539
echo "${ECHO_T}$ac_cv_lib_m_y0l" >&6
21540
if test $ac_cv_lib_m_y0l = yes; then
21541
 
21542
cat >>confdefs.h <<\_ACEOF
21543
#define HAVE_Y0L 1
21544
_ACEOF
21545
 
21546
fi
21547
 
21548
echo "$as_me:$LINENO: checking for y1f in -lm" >&5
21549
echo $ECHO_N "checking for y1f in -lm... $ECHO_C" >&6
21550
if test "${ac_cv_lib_m_y1f+set}" = set; then
21551
  echo $ECHO_N "(cached) $ECHO_C" >&6
21552
else
21553
  ac_check_lib_save_LIBS=$LIBS
21554
LIBS="-lm  $LIBS"
21555
if test x$gcc_no_link = xyes; then
21556
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21557
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21558
   { (exit 1); exit 1; }; }
21559
fi
21560
cat >conftest.$ac_ext <<_ACEOF
21561
/* confdefs.h.  */
21562
_ACEOF
21563
cat confdefs.h >>conftest.$ac_ext
21564
cat >>conftest.$ac_ext <<_ACEOF
21565
/* end confdefs.h.  */
21566
 
21567
/* Override any gcc2 internal prototype to avoid an error.  */
21568
#ifdef __cplusplus
21569
extern "C"
21570
#endif
21571
/* We use char because int might match the return type of a gcc2
21572
   builtin and then its argument prototype would still apply.  */
21573
char y1f ();
21574
int
21575
main ()
21576
{
21577
y1f ();
21578
  ;
21579
  return 0;
21580
}
21581
_ACEOF
21582
rm -f conftest.$ac_objext conftest$ac_exeext
21583
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21584
  (eval $ac_link) 2>conftest.er1
21585
  ac_status=$?
21586
  grep -v '^ *+' conftest.er1 >conftest.err
21587
  rm -f conftest.er1
21588
  cat conftest.err >&5
21589
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21590
  (exit $ac_status); } &&
21591
         { ac_try='test -z "$ac_c_werror_flag"
21592
                         || test ! -s conftest.err'
21593
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21594
  (eval $ac_try) 2>&5
21595
  ac_status=$?
21596
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21597
  (exit $ac_status); }; } &&
21598
         { ac_try='test -s conftest$ac_exeext'
21599
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21600
  (eval $ac_try) 2>&5
21601
  ac_status=$?
21602
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21603
  (exit $ac_status); }; }; then
21604
  ac_cv_lib_m_y1f=yes
21605
else
21606
  echo "$as_me: failed program was:" >&5
21607
sed 's/^/| /' conftest.$ac_ext >&5
21608
 
21609
ac_cv_lib_m_y1f=no
21610
fi
21611
rm -f conftest.err conftest.$ac_objext \
21612
      conftest$ac_exeext conftest.$ac_ext
21613
LIBS=$ac_check_lib_save_LIBS
21614
fi
21615
echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1f" >&5
21616
echo "${ECHO_T}$ac_cv_lib_m_y1f" >&6
21617
if test $ac_cv_lib_m_y1f = yes; then
21618
 
21619
cat >>confdefs.h <<\_ACEOF
21620
#define HAVE_Y1F 1
21621
_ACEOF
21622
 
21623
fi
21624
 
21625
echo "$as_me:$LINENO: checking for y1 in -lm" >&5
21626
echo $ECHO_N "checking for y1 in -lm... $ECHO_C" >&6
21627
if test "${ac_cv_lib_m_y1+set}" = set; then
21628
  echo $ECHO_N "(cached) $ECHO_C" >&6
21629
else
21630
  ac_check_lib_save_LIBS=$LIBS
21631
LIBS="-lm  $LIBS"
21632
if test x$gcc_no_link = xyes; then
21633
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21634
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21635
   { (exit 1); exit 1; }; }
21636
fi
21637
cat >conftest.$ac_ext <<_ACEOF
21638
/* confdefs.h.  */
21639
_ACEOF
21640
cat confdefs.h >>conftest.$ac_ext
21641
cat >>conftest.$ac_ext <<_ACEOF
21642
/* end confdefs.h.  */
21643
 
21644
/* Override any gcc2 internal prototype to avoid an error.  */
21645
#ifdef __cplusplus
21646
extern "C"
21647
#endif
21648
/* We use char because int might match the return type of a gcc2
21649
   builtin and then its argument prototype would still apply.  */
21650
char y1 ();
21651
int
21652
main ()
21653
{
21654
y1 ();
21655
  ;
21656
  return 0;
21657
}
21658
_ACEOF
21659
rm -f conftest.$ac_objext conftest$ac_exeext
21660
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21661
  (eval $ac_link) 2>conftest.er1
21662
  ac_status=$?
21663
  grep -v '^ *+' conftest.er1 >conftest.err
21664
  rm -f conftest.er1
21665
  cat conftest.err >&5
21666
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21667
  (exit $ac_status); } &&
21668
         { ac_try='test -z "$ac_c_werror_flag"
21669
                         || test ! -s conftest.err'
21670
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21671
  (eval $ac_try) 2>&5
21672
  ac_status=$?
21673
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21674
  (exit $ac_status); }; } &&
21675
         { ac_try='test -s conftest$ac_exeext'
21676
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21677
  (eval $ac_try) 2>&5
21678
  ac_status=$?
21679
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21680
  (exit $ac_status); }; }; then
21681
  ac_cv_lib_m_y1=yes
21682
else
21683
  echo "$as_me: failed program was:" >&5
21684
sed 's/^/| /' conftest.$ac_ext >&5
21685
 
21686
ac_cv_lib_m_y1=no
21687
fi
21688
rm -f conftest.err conftest.$ac_objext \
21689
      conftest$ac_exeext conftest.$ac_ext
21690
LIBS=$ac_check_lib_save_LIBS
21691
fi
21692
echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1" >&5
21693
echo "${ECHO_T}$ac_cv_lib_m_y1" >&6
21694
if test $ac_cv_lib_m_y1 = yes; then
21695
 
21696
cat >>confdefs.h <<\_ACEOF
21697
#define HAVE_Y1 1
21698
_ACEOF
21699
 
21700
fi
21701
 
21702
echo "$as_me:$LINENO: checking for y1l in -lm" >&5
21703
echo $ECHO_N "checking for y1l in -lm... $ECHO_C" >&6
21704
if test "${ac_cv_lib_m_y1l+set}" = set; then
21705
  echo $ECHO_N "(cached) $ECHO_C" >&6
21706
else
21707
  ac_check_lib_save_LIBS=$LIBS
21708
LIBS="-lm  $LIBS"
21709
if test x$gcc_no_link = xyes; then
21710
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21711
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21712
   { (exit 1); exit 1; }; }
21713
fi
21714
cat >conftest.$ac_ext <<_ACEOF
21715
/* confdefs.h.  */
21716
_ACEOF
21717
cat confdefs.h >>conftest.$ac_ext
21718
cat >>conftest.$ac_ext <<_ACEOF
21719
/* end confdefs.h.  */
21720
 
21721
/* Override any gcc2 internal prototype to avoid an error.  */
21722
#ifdef __cplusplus
21723
extern "C"
21724
#endif
21725
/* We use char because int might match the return type of a gcc2
21726
   builtin and then its argument prototype would still apply.  */
21727
char y1l ();
21728
int
21729
main ()
21730
{
21731
y1l ();
21732
  ;
21733
  return 0;
21734
}
21735
_ACEOF
21736
rm -f conftest.$ac_objext conftest$ac_exeext
21737
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21738
  (eval $ac_link) 2>conftest.er1
21739
  ac_status=$?
21740
  grep -v '^ *+' conftest.er1 >conftest.err
21741
  rm -f conftest.er1
21742
  cat conftest.err >&5
21743
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21744
  (exit $ac_status); } &&
21745
         { ac_try='test -z "$ac_c_werror_flag"
21746
                         || test ! -s conftest.err'
21747
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21748
  (eval $ac_try) 2>&5
21749
  ac_status=$?
21750
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21751
  (exit $ac_status); }; } &&
21752
         { ac_try='test -s conftest$ac_exeext'
21753
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21754
  (eval $ac_try) 2>&5
21755
  ac_status=$?
21756
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21757
  (exit $ac_status); }; }; then
21758
  ac_cv_lib_m_y1l=yes
21759
else
21760
  echo "$as_me: failed program was:" >&5
21761
sed 's/^/| /' conftest.$ac_ext >&5
21762
 
21763
ac_cv_lib_m_y1l=no
21764
fi
21765
rm -f conftest.err conftest.$ac_objext \
21766
      conftest$ac_exeext conftest.$ac_ext
21767
LIBS=$ac_check_lib_save_LIBS
21768
fi
21769
echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1l" >&5
21770
echo "${ECHO_T}$ac_cv_lib_m_y1l" >&6
21771
if test $ac_cv_lib_m_y1l = yes; then
21772
 
21773
cat >>confdefs.h <<\_ACEOF
21774
#define HAVE_Y1L 1
21775
_ACEOF
21776
 
21777
fi
21778
 
21779
echo "$as_me:$LINENO: checking for ynf in -lm" >&5
21780
echo $ECHO_N "checking for ynf in -lm... $ECHO_C" >&6
21781
if test "${ac_cv_lib_m_ynf+set}" = set; then
21782
  echo $ECHO_N "(cached) $ECHO_C" >&6
21783
else
21784
  ac_check_lib_save_LIBS=$LIBS
21785
LIBS="-lm  $LIBS"
21786
if test x$gcc_no_link = xyes; then
21787
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21788
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21789
   { (exit 1); exit 1; }; }
21790
fi
21791
cat >conftest.$ac_ext <<_ACEOF
21792
/* confdefs.h.  */
21793
_ACEOF
21794
cat confdefs.h >>conftest.$ac_ext
21795
cat >>conftest.$ac_ext <<_ACEOF
21796
/* end confdefs.h.  */
21797
 
21798
/* Override any gcc2 internal prototype to avoid an error.  */
21799
#ifdef __cplusplus
21800
extern "C"
21801
#endif
21802
/* We use char because int might match the return type of a gcc2
21803
   builtin and then its argument prototype would still apply.  */
21804
char ynf ();
21805
int
21806
main ()
21807
{
21808
ynf ();
21809
  ;
21810
  return 0;
21811
}
21812
_ACEOF
21813
rm -f conftest.$ac_objext conftest$ac_exeext
21814
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21815
  (eval $ac_link) 2>conftest.er1
21816
  ac_status=$?
21817
  grep -v '^ *+' conftest.er1 >conftest.err
21818
  rm -f conftest.er1
21819
  cat conftest.err >&5
21820
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21821
  (exit $ac_status); } &&
21822
         { ac_try='test -z "$ac_c_werror_flag"
21823
                         || test ! -s conftest.err'
21824
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21825
  (eval $ac_try) 2>&5
21826
  ac_status=$?
21827
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21828
  (exit $ac_status); }; } &&
21829
         { ac_try='test -s conftest$ac_exeext'
21830
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21831
  (eval $ac_try) 2>&5
21832
  ac_status=$?
21833
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21834
  (exit $ac_status); }; }; then
21835
  ac_cv_lib_m_ynf=yes
21836
else
21837
  echo "$as_me: failed program was:" >&5
21838
sed 's/^/| /' conftest.$ac_ext >&5
21839
 
21840
ac_cv_lib_m_ynf=no
21841
fi
21842
rm -f conftest.err conftest.$ac_objext \
21843
      conftest$ac_exeext conftest.$ac_ext
21844
LIBS=$ac_check_lib_save_LIBS
21845
fi
21846
echo "$as_me:$LINENO: result: $ac_cv_lib_m_ynf" >&5
21847
echo "${ECHO_T}$ac_cv_lib_m_ynf" >&6
21848
if test $ac_cv_lib_m_ynf = yes; then
21849
 
21850
cat >>confdefs.h <<\_ACEOF
21851
#define HAVE_YNF 1
21852
_ACEOF
21853
 
21854
fi
21855
 
21856
echo "$as_me:$LINENO: checking for yn in -lm" >&5
21857
echo $ECHO_N "checking for yn in -lm... $ECHO_C" >&6
21858
if test "${ac_cv_lib_m_yn+set}" = set; then
21859
  echo $ECHO_N "(cached) $ECHO_C" >&6
21860
else
21861
  ac_check_lib_save_LIBS=$LIBS
21862
LIBS="-lm  $LIBS"
21863
if test x$gcc_no_link = xyes; then
21864
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21865
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21866
   { (exit 1); exit 1; }; }
21867
fi
21868
cat >conftest.$ac_ext <<_ACEOF
21869
/* confdefs.h.  */
21870
_ACEOF
21871
cat confdefs.h >>conftest.$ac_ext
21872
cat >>conftest.$ac_ext <<_ACEOF
21873
/* end confdefs.h.  */
21874
 
21875
/* Override any gcc2 internal prototype to avoid an error.  */
21876
#ifdef __cplusplus
21877
extern "C"
21878
#endif
21879
/* We use char because int might match the return type of a gcc2
21880
   builtin and then its argument prototype would still apply.  */
21881
char yn ();
21882
int
21883
main ()
21884
{
21885
yn ();
21886
  ;
21887
  return 0;
21888
}
21889
_ACEOF
21890
rm -f conftest.$ac_objext conftest$ac_exeext
21891
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21892
  (eval $ac_link) 2>conftest.er1
21893
  ac_status=$?
21894
  grep -v '^ *+' conftest.er1 >conftest.err
21895
  rm -f conftest.er1
21896
  cat conftest.err >&5
21897
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21898
  (exit $ac_status); } &&
21899
         { ac_try='test -z "$ac_c_werror_flag"
21900
                         || test ! -s conftest.err'
21901
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21902
  (eval $ac_try) 2>&5
21903
  ac_status=$?
21904
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21905
  (exit $ac_status); }; } &&
21906
         { ac_try='test -s conftest$ac_exeext'
21907
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21908
  (eval $ac_try) 2>&5
21909
  ac_status=$?
21910
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21911
  (exit $ac_status); }; }; then
21912
  ac_cv_lib_m_yn=yes
21913
else
21914
  echo "$as_me: failed program was:" >&5
21915
sed 's/^/| /' conftest.$ac_ext >&5
21916
 
21917
ac_cv_lib_m_yn=no
21918
fi
21919
rm -f conftest.err conftest.$ac_objext \
21920
      conftest$ac_exeext conftest.$ac_ext
21921
LIBS=$ac_check_lib_save_LIBS
21922
fi
21923
echo "$as_me:$LINENO: result: $ac_cv_lib_m_yn" >&5
21924
echo "${ECHO_T}$ac_cv_lib_m_yn" >&6
21925
if test $ac_cv_lib_m_yn = yes; then
21926
 
21927
cat >>confdefs.h <<\_ACEOF
21928
#define HAVE_YN 1
21929
_ACEOF
21930
 
21931
fi
21932
 
21933
echo "$as_me:$LINENO: checking for ynl in -lm" >&5
21934
echo $ECHO_N "checking for ynl in -lm... $ECHO_C" >&6
21935
if test "${ac_cv_lib_m_ynl+set}" = set; then
21936
  echo $ECHO_N "(cached) $ECHO_C" >&6
21937
else
21938
  ac_check_lib_save_LIBS=$LIBS
21939
LIBS="-lm  $LIBS"
21940
if test x$gcc_no_link = xyes; then
21941
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
21942
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
21943
   { (exit 1); exit 1; }; }
21944
fi
21945
cat >conftest.$ac_ext <<_ACEOF
21946
/* confdefs.h.  */
21947
_ACEOF
21948
cat confdefs.h >>conftest.$ac_ext
21949
cat >>conftest.$ac_ext <<_ACEOF
21950
/* end confdefs.h.  */
21951
 
21952
/* Override any gcc2 internal prototype to avoid an error.  */
21953
#ifdef __cplusplus
21954
extern "C"
21955
#endif
21956
/* We use char because int might match the return type of a gcc2
21957
   builtin and then its argument prototype would still apply.  */
21958
char ynl ();
21959
int
21960
main ()
21961
{
21962
ynl ();
21963
  ;
21964
  return 0;
21965
}
21966
_ACEOF
21967
rm -f conftest.$ac_objext conftest$ac_exeext
21968
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21969
  (eval $ac_link) 2>conftest.er1
21970
  ac_status=$?
21971
  grep -v '^ *+' conftest.er1 >conftest.err
21972
  rm -f conftest.er1
21973
  cat conftest.err >&5
21974
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21975
  (exit $ac_status); } &&
21976
         { ac_try='test -z "$ac_c_werror_flag"
21977
                         || test ! -s conftest.err'
21978
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21979
  (eval $ac_try) 2>&5
21980
  ac_status=$?
21981
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21982
  (exit $ac_status); }; } &&
21983
         { ac_try='test -s conftest$ac_exeext'
21984
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21985
  (eval $ac_try) 2>&5
21986
  ac_status=$?
21987
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21988
  (exit $ac_status); }; }; then
21989
  ac_cv_lib_m_ynl=yes
21990
else
21991
  echo "$as_me: failed program was:" >&5
21992
sed 's/^/| /' conftest.$ac_ext >&5
21993
 
21994
ac_cv_lib_m_ynl=no
21995
fi
21996
rm -f conftest.err conftest.$ac_objext \
21997
      conftest$ac_exeext conftest.$ac_ext
21998
LIBS=$ac_check_lib_save_LIBS
21999
fi
22000
echo "$as_me:$LINENO: result: $ac_cv_lib_m_ynl" >&5
22001
echo "${ECHO_T}$ac_cv_lib_m_ynl" >&6
22002
if test $ac_cv_lib_m_ynl = yes; then
22003
 
22004
cat >>confdefs.h <<\_ACEOF
22005
#define HAVE_YNL 1
22006
_ACEOF
22007
 
22008
fi
22009
 
22010
 
22011
# On AIX, clog is present in libm as __clog
22012
echo "$as_me:$LINENO: checking for __clog in -lm" >&5
22013
echo $ECHO_N "checking for __clog in -lm... $ECHO_C" >&6
22014
if test "${ac_cv_lib_m___clog+set}" = set; then
22015
  echo $ECHO_N "(cached) $ECHO_C" >&6
22016
else
22017
  ac_check_lib_save_LIBS=$LIBS
22018
LIBS="-lm  $LIBS"
22019
if test x$gcc_no_link = xyes; then
22020
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22021
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22022
   { (exit 1); exit 1; }; }
22023
fi
22024
cat >conftest.$ac_ext <<_ACEOF
22025
/* confdefs.h.  */
22026
_ACEOF
22027
cat confdefs.h >>conftest.$ac_ext
22028
cat >>conftest.$ac_ext <<_ACEOF
22029
/* end confdefs.h.  */
22030
 
22031
/* Override any gcc2 internal prototype to avoid an error.  */
22032
#ifdef __cplusplus
22033
extern "C"
22034
#endif
22035
/* We use char because int might match the return type of a gcc2
22036
   builtin and then its argument prototype would still apply.  */
22037
char __clog ();
22038
int
22039
main ()
22040
{
22041
__clog ();
22042
  ;
22043
  return 0;
22044
}
22045
_ACEOF
22046
rm -f conftest.$ac_objext conftest$ac_exeext
22047
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22048
  (eval $ac_link) 2>conftest.er1
22049
  ac_status=$?
22050
  grep -v '^ *+' conftest.er1 >conftest.err
22051
  rm -f conftest.er1
22052
  cat conftest.err >&5
22053
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22054
  (exit $ac_status); } &&
22055
         { ac_try='test -z "$ac_c_werror_flag"
22056
                         || test ! -s conftest.err'
22057
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22058
  (eval $ac_try) 2>&5
22059
  ac_status=$?
22060
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22061
  (exit $ac_status); }; } &&
22062
         { ac_try='test -s conftest$ac_exeext'
22063
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22064
  (eval $ac_try) 2>&5
22065
  ac_status=$?
22066
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22067
  (exit $ac_status); }; }; then
22068
  ac_cv_lib_m___clog=yes
22069
else
22070
  echo "$as_me: failed program was:" >&5
22071
sed 's/^/| /' conftest.$ac_ext >&5
22072
 
22073
ac_cv_lib_m___clog=no
22074
fi
22075
rm -f conftest.err conftest.$ac_objext \
22076
      conftest$ac_exeext conftest.$ac_ext
22077
LIBS=$ac_check_lib_save_LIBS
22078
fi
22079
echo "$as_me:$LINENO: result: $ac_cv_lib_m___clog" >&5
22080
echo "${ECHO_T}$ac_cv_lib_m___clog" >&6
22081
if test $ac_cv_lib_m___clog = yes; then
22082
 
22083
cat >>confdefs.h <<\_ACEOF
22084
#define HAVE_CLOG 1
22085
_ACEOF
22086
 
22087
fi
22088
 
22089
 
22090
# Check for a isfinite macro that works on long doubles.
22091
 
22092
  echo "$as_me:$LINENO: checking whether isfinite is broken" >&5
22093
echo $ECHO_N "checking whether isfinite is broken... $ECHO_C" >&6
22094
if test "${have_broken_isfinite+set}" = set; then
22095
  echo $ECHO_N "(cached) $ECHO_C" >&6
22096
else
22097
 
22098
  libgfor_check_for_broken_isfinite_save_LIBS=$LIBS
22099
  LIBS="$LIBS -lm"
22100
  if test "$cross_compiling" = yes; then
22101
 
22102
case "${target}" in
22103
  hppa*-*-hpux*) have_broken_isfinite=yes ;;
22104
  *) have_broken_isfinite=no ;;
22105
esac
22106
else
22107
  cat >conftest.$ac_ext <<_ACEOF
22108
/* confdefs.h.  */
22109
_ACEOF
22110
cat confdefs.h >>conftest.$ac_ext
22111
cat >>conftest.$ac_ext <<_ACEOF
22112
/* end confdefs.h.  */
22113
 
22114
#ifdef HAVE_MATH_H
22115
#include 
22116
#endif
22117
#include 
22118
int main ()
22119
{
22120
#ifdef isfinite
22121
#ifdef LDBL_MAX
22122
  if (!isfinite(LDBL_MAX)) return 1;
22123
#endif
22124
#ifdef DBL_MAX
22125
  if (!isfinite(DBL_MAX)) return 1;
22126
#endif
22127
#endif
22128
return 0;
22129
}
22130
_ACEOF
22131
rm -f conftest$ac_exeext
22132
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22133
  (eval $ac_link) 2>&5
22134
  ac_status=$?
22135
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22136
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
22137
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22138
  (eval $ac_try) 2>&5
22139
  ac_status=$?
22140
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22141
  (exit $ac_status); }; }; then
22142
  have_broken_isfinite=no
22143
else
22144
  echo "$as_me: program exited with status $ac_status" >&5
22145
echo "$as_me: failed program was:" >&5
22146
sed 's/^/| /' conftest.$ac_ext >&5
22147
 
22148
( exit $ac_status )
22149
have_broken_isfinite=yes
22150
fi
22151
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
22152
fi
22153
  LIBS=$libgfor_check_for_broken_isfinite_save_LIBS
22154
fi
22155
echo "$as_me:$LINENO: result: $have_broken_isfinite" >&5
22156
echo "${ECHO_T}$have_broken_isfinite" >&6
22157
if test x"$have_broken_isfinite" = xyes; then
22158
 
22159
cat >>confdefs.h <<\_ACEOF
22160
#define HAVE_BROKEN_ISFINITE 1
22161
_ACEOF
22162
 
22163
fi
22164
 
22165
# Check for a isnan macro that works on long doubles.
22166
 
22167
  echo "$as_me:$LINENO: checking whether isnan is broken" >&5
22168
echo $ECHO_N "checking whether isnan is broken... $ECHO_C" >&6
22169
if test "${have_broken_isnan+set}" = set; then
22170
  echo $ECHO_N "(cached) $ECHO_C" >&6
22171
else
22172
 
22173
  libgfor_check_for_broken_isnan_save_LIBS=$LIBS
22174
  LIBS="$LIBS -lm"
22175
  if test "$cross_compiling" = yes; then
22176
 
22177
case "${target}" in
22178
  hppa*-*-hpux*) have_broken_isnan=yes ;;
22179
  *) have_broken_isnan=no ;;
22180
esac
22181
else
22182
  cat >conftest.$ac_ext <<_ACEOF
22183
/* confdefs.h.  */
22184
_ACEOF
22185
cat confdefs.h >>conftest.$ac_ext
22186
cat >>conftest.$ac_ext <<_ACEOF
22187
/* end confdefs.h.  */
22188
 
22189
#ifdef HAVE_MATH_H
22190
#include 
22191
#endif
22192
#include 
22193
int main ()
22194
{
22195
#ifdef isnan
22196
#ifdef LDBL_MAX
22197
  {
22198
    long double x;
22199
    x = __builtin_nanl ("");
22200
    if (!isnan(x)) return 1;
22201
    if (isnan(LDBL_MAX)) return 1;
22202
#ifdef NAN
22203
    x = (long double) NAN;
22204
    if (!isnan(x)) return 1;
22205
#endif
22206
  }
22207
#endif
22208
#ifdef DBL_MAX
22209
  {
22210
    double y;
22211
    y = __builtin_nan ("");
22212
    if (!isnan(y)) return 1;
22213
    if (isnan(DBL_MAX)) return 1;
22214
#ifdef NAN
22215
    y = (double) NAN;
22216
    if (!isnan(y)) return 1;
22217
#endif
22218
  }
22219
#endif
22220
#endif
22221
return 0;
22222
}
22223
_ACEOF
22224
rm -f conftest$ac_exeext
22225
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22226
  (eval $ac_link) 2>&5
22227
  ac_status=$?
22228
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22229
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
22230
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22231
  (eval $ac_try) 2>&5
22232
  ac_status=$?
22233
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22234
  (exit $ac_status); }; }; then
22235
  have_broken_isnan=no
22236
else
22237
  echo "$as_me: program exited with status $ac_status" >&5
22238
echo "$as_me: failed program was:" >&5
22239
sed 's/^/| /' conftest.$ac_ext >&5
22240
 
22241
( exit $ac_status )
22242
have_broken_isnan=yes
22243
fi
22244
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
22245
fi
22246
  LIBS=$libgfor_check_for_broken_isnan_save_LIBS
22247
fi
22248
echo "$as_me:$LINENO: result: $have_broken_isnan" >&5
22249
echo "${ECHO_T}$have_broken_isnan" >&6
22250
if test x"$have_broken_isnan" = xyes; then
22251
 
22252
cat >>confdefs.h <<\_ACEOF
22253
#define HAVE_BROKEN_ISNAN 1
22254
_ACEOF
22255
 
22256
fi
22257
 
22258
# Check for a fpclassify macro that works on long doubles.
22259
 
22260
  echo "$as_me:$LINENO: checking whether fpclassify is broken" >&5
22261
echo $ECHO_N "checking whether fpclassify is broken... $ECHO_C" >&6
22262
if test "${have_broken_fpclassify+set}" = set; then
22263
  echo $ECHO_N "(cached) $ECHO_C" >&6
22264
else
22265
 
22266
  libgfor_check_for_broken_fpclassify_save_LIBS=$LIBS
22267
  LIBS="$LIBS -lm"
22268
  if test "$cross_compiling" = yes; then
22269
 
22270
case "${target}" in
22271
  hppa*-*-hpux*) have_broken_fpclassify=yes ;;
22272
  *) have_broken_fpclassify=no ;;
22273
esac
22274
else
22275
  cat >conftest.$ac_ext <<_ACEOF
22276
/* confdefs.h.  */
22277
_ACEOF
22278
cat confdefs.h >>conftest.$ac_ext
22279
cat >>conftest.$ac_ext <<_ACEOF
22280
/* end confdefs.h.  */
22281
 
22282
#ifdef HAVE_MATH_H
22283
#include 
22284
#endif
22285
#include 
22286
int main ()
22287
{
22288
#ifdef fpclassify
22289
#ifdef LDBL_MAX
22290
        if (fpclassify(LDBL_MAX) == FP_NAN
22291
            || fpclassify(LDBL_MAX) == FP_INFINITE) return 1;
22292
#endif
22293
#ifdef DBL_MAX
22294
        if (fpclassify(DBL_MAX) == FP_NAN
22295
            || fpclassify(DBL_MAX) == FP_INFINITE) return 1;
22296
#endif
22297
#endif
22298
return 0;
22299
}
22300
_ACEOF
22301
rm -f conftest$ac_exeext
22302
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22303
  (eval $ac_link) 2>&5
22304
  ac_status=$?
22305
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22306
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
22307
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22308
  (eval $ac_try) 2>&5
22309
  ac_status=$?
22310
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22311
  (exit $ac_status); }; }; then
22312
  have_broken_fpclassify=no
22313
else
22314
  echo "$as_me: program exited with status $ac_status" >&5
22315
echo "$as_me: failed program was:" >&5
22316
sed 's/^/| /' conftest.$ac_ext >&5
22317
 
22318
( exit $ac_status )
22319
have_broken_fpclassify=yes
22320
fi
22321
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
22322
fi
22323
  LIBS=$libgfor_check_for_broken_fpclassify_save_LIBS
22324
fi
22325
echo "$as_me:$LINENO: result: $have_broken_fpclassify" >&5
22326
echo "${ECHO_T}$have_broken_fpclassify" >&6
22327
if test x"$have_broken_fpclassify" = xyes; then
22328
 
22329
cat >>confdefs.h <<\_ACEOF
22330
#define HAVE_BROKEN_FPCLASSIFY 1
22331
_ACEOF
22332
 
22333
fi
22334
 
22335
# Check whether the system has a working stat()
22336
 
22337
  echo "$as_me:$LINENO: checking whether the target stat is reliable" >&5
22338
echo $ECHO_N "checking whether the target stat is reliable... $ECHO_C" >&6
22339
if test "${have_working_stat+set}" = set; then
22340
  echo $ECHO_N "(cached) $ECHO_C" >&6
22341
else
22342
 
22343
  if test "$cross_compiling" = yes; then
22344
 
22345
case "${target}" in
22346
  *mingw*) have_working_stat=no ;;
22347
  *) have_working_stat=yes;;
22348
esac
22349
else
22350
  cat >conftest.$ac_ext <<_ACEOF
22351
/* confdefs.h.  */
22352
_ACEOF
22353
cat confdefs.h >>conftest.$ac_ext
22354
cat >>conftest.$ac_ext <<_ACEOF
22355
/* end confdefs.h.  */
22356
 
22357
#include 
22358
#include 
22359
#include 
22360
#include 
22361
 
22362
int main ()
22363
{
22364
  FILE *f, *g;
22365
  struct stat st1, st2;
22366
 
22367
  f = fopen ("foo", "w");
22368
  g = fopen ("bar", "w");
22369
  if (stat ("foo", &st1) != 0 || stat ("bar", &st2))
22370
    return 1;
22371
  if (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino)
22372
    return 1;
22373
  fclose(f);
22374
  fclose(g);
22375
  return 0;
22376
}
22377
_ACEOF
22378
rm -f conftest$ac_exeext
22379
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22380
  (eval $ac_link) 2>&5
22381
  ac_status=$?
22382
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22383
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
22384
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22385
  (eval $ac_try) 2>&5
22386
  ac_status=$?
22387
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22388
  (exit $ac_status); }; }; then
22389
  have_working_stat=yes
22390
else
22391
  echo "$as_me: program exited with status $ac_status" >&5
22392
echo "$as_me: failed program was:" >&5
22393
sed 's/^/| /' conftest.$ac_ext >&5
22394
 
22395
( exit $ac_status )
22396
have_working_stat=no
22397
fi
22398
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
22399
fi
22400
fi
22401
echo "$as_me:$LINENO: result: $have_working_stat" >&5
22402
echo "${ECHO_T}$have_working_stat" >&6
22403
if test x"$have_working_stat" = xyes; then
22404
 
22405
cat >>confdefs.h <<\_ACEOF
22406
#define HAVE_WORKING_STAT 1
22407
_ACEOF
22408
 
22409
fi
22410
 
22411
# Fallback in case isfinite is not available.
22412
echo "$as_me:$LINENO: checking for finite in -lm" >&5
22413
echo $ECHO_N "checking for finite in -lm... $ECHO_C" >&6
22414
if test "${ac_cv_lib_m_finite+set}" = set; then
22415
  echo $ECHO_N "(cached) $ECHO_C" >&6
22416
else
22417
  ac_check_lib_save_LIBS=$LIBS
22418
LIBS="-lm  $LIBS"
22419
if test x$gcc_no_link = xyes; then
22420
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22421
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22422
   { (exit 1); exit 1; }; }
22423
fi
22424
cat >conftest.$ac_ext <<_ACEOF
22425
/* confdefs.h.  */
22426
_ACEOF
22427
cat confdefs.h >>conftest.$ac_ext
22428
cat >>conftest.$ac_ext <<_ACEOF
22429
/* end confdefs.h.  */
22430
 
22431
/* Override any gcc2 internal prototype to avoid an error.  */
22432
#ifdef __cplusplus
22433
extern "C"
22434
#endif
22435
/* We use char because int might match the return type of a gcc2
22436
   builtin and then its argument prototype would still apply.  */
22437
char finite ();
22438
int
22439
main ()
22440
{
22441
finite ();
22442
  ;
22443
  return 0;
22444
}
22445
_ACEOF
22446
rm -f conftest.$ac_objext conftest$ac_exeext
22447
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22448
  (eval $ac_link) 2>conftest.er1
22449
  ac_status=$?
22450
  grep -v '^ *+' conftest.er1 >conftest.err
22451
  rm -f conftest.er1
22452
  cat conftest.err >&5
22453
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22454
  (exit $ac_status); } &&
22455
         { ac_try='test -z "$ac_c_werror_flag"
22456
                         || test ! -s conftest.err'
22457
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22458
  (eval $ac_try) 2>&5
22459
  ac_status=$?
22460
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22461
  (exit $ac_status); }; } &&
22462
         { ac_try='test -s conftest$ac_exeext'
22463
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22464
  (eval $ac_try) 2>&5
22465
  ac_status=$?
22466
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22467
  (exit $ac_status); }; }; then
22468
  ac_cv_lib_m_finite=yes
22469
else
22470
  echo "$as_me: failed program was:" >&5
22471
sed 's/^/| /' conftest.$ac_ext >&5
22472
 
22473
ac_cv_lib_m_finite=no
22474
fi
22475
rm -f conftest.err conftest.$ac_objext \
22476
      conftest$ac_exeext conftest.$ac_ext
22477
LIBS=$ac_check_lib_save_LIBS
22478
fi
22479
echo "$as_me:$LINENO: result: $ac_cv_lib_m_finite" >&5
22480
echo "${ECHO_T}$ac_cv_lib_m_finite" >&6
22481
if test $ac_cv_lib_m_finite = yes; then
22482
 
22483
cat >>confdefs.h <<\_ACEOF
22484
#define HAVE_FINITE 1
22485
_ACEOF
22486
 
22487
fi
22488
 
22489
 
22490
# Check for GNU libc feenableexcept
22491
echo "$as_me:$LINENO: checking for feenableexcept in -lm" >&5
22492
echo $ECHO_N "checking for feenableexcept in -lm... $ECHO_C" >&6
22493
if test "${ac_cv_lib_m_feenableexcept+set}" = set; then
22494
  echo $ECHO_N "(cached) $ECHO_C" >&6
22495
else
22496
  ac_check_lib_save_LIBS=$LIBS
22497
LIBS="-lm  $LIBS"
22498
if test x$gcc_no_link = xyes; then
22499
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22500
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22501
   { (exit 1); exit 1; }; }
22502
fi
22503
cat >conftest.$ac_ext <<_ACEOF
22504
/* confdefs.h.  */
22505
_ACEOF
22506
cat confdefs.h >>conftest.$ac_ext
22507
cat >>conftest.$ac_ext <<_ACEOF
22508
/* end confdefs.h.  */
22509
 
22510
/* Override any gcc2 internal prototype to avoid an error.  */
22511
#ifdef __cplusplus
22512
extern "C"
22513
#endif
22514
/* We use char because int might match the return type of a gcc2
22515
   builtin and then its argument prototype would still apply.  */
22516
char feenableexcept ();
22517
int
22518
main ()
22519
{
22520
feenableexcept ();
22521
  ;
22522
  return 0;
22523
}
22524
_ACEOF
22525
rm -f conftest.$ac_objext conftest$ac_exeext
22526
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22527
  (eval $ac_link) 2>conftest.er1
22528
  ac_status=$?
22529
  grep -v '^ *+' conftest.er1 >conftest.err
22530
  rm -f conftest.er1
22531
  cat conftest.err >&5
22532
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22533
  (exit $ac_status); } &&
22534
         { ac_try='test -z "$ac_c_werror_flag"
22535
                         || test ! -s conftest.err'
22536
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22537
  (eval $ac_try) 2>&5
22538
  ac_status=$?
22539
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22540
  (exit $ac_status); }; } &&
22541
         { ac_try='test -s conftest$ac_exeext'
22542
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22543
  (eval $ac_try) 2>&5
22544
  ac_status=$?
22545
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22546
  (exit $ac_status); }; }; then
22547
  ac_cv_lib_m_feenableexcept=yes
22548
else
22549
  echo "$as_me: failed program was:" >&5
22550
sed 's/^/| /' conftest.$ac_ext >&5
22551
 
22552
ac_cv_lib_m_feenableexcept=no
22553
fi
22554
rm -f conftest.err conftest.$ac_objext \
22555
      conftest$ac_exeext conftest.$ac_ext
22556
LIBS=$ac_check_lib_save_LIBS
22557
fi
22558
echo "$as_me:$LINENO: result: $ac_cv_lib_m_feenableexcept" >&5
22559
echo "${ECHO_T}$ac_cv_lib_m_feenableexcept" >&6
22560
if test $ac_cv_lib_m_feenableexcept = yes; then
22561
  have_feenableexcept=yes
22562
cat >>confdefs.h <<\_ACEOF
22563
#define HAVE_FEENABLEEXCEPT 1
22564
_ACEOF
22565
 
22566
fi
22567
 
22568
 
22569
# Check for SysV fpsetmask
22570
 
22571
  echo "$as_me:$LINENO: checking whether fpsetmask is present" >&5
22572
echo $ECHO_N "checking whether fpsetmask is present... $ECHO_C" >&6
22573
if test "${have_fpsetmask+set}" = set; then
22574
  echo $ECHO_N "(cached) $ECHO_C" >&6
22575
else
22576
 
22577
    if test x$gcc_no_link = xyes; then
22578
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22579
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22580
   { (exit 1); exit 1; }; }
22581
fi
22582
cat >conftest.$ac_ext <<_ACEOF
22583
/* confdefs.h.  */
22584
_ACEOF
22585
cat confdefs.h >>conftest.$ac_ext
22586
cat >>conftest.$ac_ext <<_ACEOF
22587
/* end confdefs.h.  */
22588
 
22589
#if HAVE_FLOATINGPOINT_H
22590
# include 
22591
#endif /* HAVE_FLOATINGPOINT_H */
22592
#if HAVE_IEEEFP_H
22593
# include 
22594
#endif /* HAVE_IEEEFP_H */
22595
int
22596
main ()
22597
{
22598
fpsetmask(0);
22599
  ;
22600
  return 0;
22601
}
22602
_ACEOF
22603
rm -f conftest.$ac_objext conftest$ac_exeext
22604
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22605
  (eval $ac_link) 2>conftest.er1
22606
  ac_status=$?
22607
  grep -v '^ *+' conftest.er1 >conftest.err
22608
  rm -f conftest.er1
22609
  cat conftest.err >&5
22610
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22611
  (exit $ac_status); } &&
22612
         { ac_try='test -z "$ac_c_werror_flag"
22613
                         || test ! -s conftest.err'
22614
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22615
  (eval $ac_try) 2>&5
22616
  ac_status=$?
22617
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22618
  (exit $ac_status); }; } &&
22619
         { ac_try='test -s conftest$ac_exeext'
22620
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22621
  (eval $ac_try) 2>&5
22622
  ac_status=$?
22623
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22624
  (exit $ac_status); }; }; then
22625
  eval "have_fpsetmask=yes"
22626
else
22627
  echo "$as_me: failed program was:" >&5
22628
sed 's/^/| /' conftest.$ac_ext >&5
22629
 
22630
eval "have_fpsetmask=no"
22631
fi
22632
rm -f conftest.err conftest.$ac_objext \
22633
      conftest$ac_exeext conftest.$ac_ext
22634
 
22635
fi
22636
echo "$as_me:$LINENO: result: $have_fpsetmask" >&5
22637
echo "${ECHO_T}$have_fpsetmask" >&6
22638
  if test x"$have_fpsetmask" = xyes; then
22639
 
22640
cat >>confdefs.h <<\_ACEOF
22641
#define HAVE_FPSETMASK 1
22642
_ACEOF
22643
 
22644
  fi
22645
 
22646
 
22647
# Check for AIX fp_trap and fp_enable
22648
echo "$as_me:$LINENO: checking for fp_trap" >&5
22649
echo $ECHO_N "checking for fp_trap... $ECHO_C" >&6
22650
if test "${ac_cv_func_fp_trap+set}" = set; then
22651
  echo $ECHO_N "(cached) $ECHO_C" >&6
22652
else
22653
  if test x$gcc_no_link = xyes; then
22654
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22655
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22656
   { (exit 1); exit 1; }; }
22657
fi
22658
cat >conftest.$ac_ext <<_ACEOF
22659
/* confdefs.h.  */
22660
_ACEOF
22661
cat confdefs.h >>conftest.$ac_ext
22662
cat >>conftest.$ac_ext <<_ACEOF
22663
/* end confdefs.h.  */
22664
/* Define fp_trap to an innocuous variant, in case  declares fp_trap.
22665
   For example, HP-UX 11i  declares gettimeofday.  */
22666
#define fp_trap innocuous_fp_trap
22667
 
22668
/* System header to define __stub macros and hopefully few prototypes,
22669
    which can conflict with char fp_trap (); below.
22670
    Prefer  to  if __STDC__ is defined, since
22671
     exists even on freestanding compilers.  */
22672
 
22673
#ifdef __STDC__
22674
# include 
22675
#else
22676
# include 
22677
#endif
22678
 
22679
#undef fp_trap
22680
 
22681
/* Override any gcc2 internal prototype to avoid an error.  */
22682
#ifdef __cplusplus
22683
extern "C"
22684
{
22685
#endif
22686
/* We use char because int might match the return type of a gcc2
22687
   builtin and then its argument prototype would still apply.  */
22688
char fp_trap ();
22689
/* The GNU C library defines this for functions which it implements
22690
    to always fail with ENOSYS.  Some functions are actually named
22691
    something starting with __ and the normal name is an alias.  */
22692
#if defined (__stub_fp_trap) || defined (__stub___fp_trap)
22693
choke me
22694
#else
22695
char (*f) () = fp_trap;
22696
#endif
22697
#ifdef __cplusplus
22698
}
22699
#endif
22700
 
22701
int
22702
main ()
22703
{
22704
return f != fp_trap;
22705
  ;
22706
  return 0;
22707
}
22708
_ACEOF
22709
rm -f conftest.$ac_objext conftest$ac_exeext
22710
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22711
  (eval $ac_link) 2>conftest.er1
22712
  ac_status=$?
22713
  grep -v '^ *+' conftest.er1 >conftest.err
22714
  rm -f conftest.er1
22715
  cat conftest.err >&5
22716
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22717
  (exit $ac_status); } &&
22718
         { ac_try='test -z "$ac_c_werror_flag"
22719
                         || test ! -s conftest.err'
22720
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22721
  (eval $ac_try) 2>&5
22722
  ac_status=$?
22723
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22724
  (exit $ac_status); }; } &&
22725
         { ac_try='test -s conftest$ac_exeext'
22726
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22727
  (eval $ac_try) 2>&5
22728
  ac_status=$?
22729
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22730
  (exit $ac_status); }; }; then
22731
  ac_cv_func_fp_trap=yes
22732
else
22733
  echo "$as_me: failed program was:" >&5
22734
sed 's/^/| /' conftest.$ac_ext >&5
22735
 
22736
ac_cv_func_fp_trap=no
22737
fi
22738
rm -f conftest.err conftest.$ac_objext \
22739
      conftest$ac_exeext conftest.$ac_ext
22740
fi
22741
echo "$as_me:$LINENO: result: $ac_cv_func_fp_trap" >&5
22742
echo "${ECHO_T}$ac_cv_func_fp_trap" >&6
22743
if test $ac_cv_func_fp_trap = yes; then
22744
  have_fp_trap=yes
22745
cat >>confdefs.h <<\_ACEOF
22746
#define HAVE_FP_TRAP 1
22747
_ACEOF
22748
 
22749
fi
22750
 
22751
echo "$as_me:$LINENO: checking for fp_enable" >&5
22752
echo $ECHO_N "checking for fp_enable... $ECHO_C" >&6
22753
if test "${ac_cv_func_fp_enable+set}" = set; then
22754
  echo $ECHO_N "(cached) $ECHO_C" >&6
22755
else
22756
  if test x$gcc_no_link = xyes; then
22757
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22758
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22759
   { (exit 1); exit 1; }; }
22760
fi
22761
cat >conftest.$ac_ext <<_ACEOF
22762
/* confdefs.h.  */
22763
_ACEOF
22764
cat confdefs.h >>conftest.$ac_ext
22765
cat >>conftest.$ac_ext <<_ACEOF
22766
/* end confdefs.h.  */
22767
/* Define fp_enable to an innocuous variant, in case  declares fp_enable.
22768
   For example, HP-UX 11i  declares gettimeofday.  */
22769
#define fp_enable innocuous_fp_enable
22770
 
22771
/* System header to define __stub macros and hopefully few prototypes,
22772
    which can conflict with char fp_enable (); below.
22773
    Prefer  to  if __STDC__ is defined, since
22774
     exists even on freestanding compilers.  */
22775
 
22776
#ifdef __STDC__
22777
# include 
22778
#else
22779
# include 
22780
#endif
22781
 
22782
#undef fp_enable
22783
 
22784
/* Override any gcc2 internal prototype to avoid an error.  */
22785
#ifdef __cplusplus
22786
extern "C"
22787
{
22788
#endif
22789
/* We use char because int might match the return type of a gcc2
22790
   builtin and then its argument prototype would still apply.  */
22791
char fp_enable ();
22792
/* The GNU C library defines this for functions which it implements
22793
    to always fail with ENOSYS.  Some functions are actually named
22794
    something starting with __ and the normal name is an alias.  */
22795
#if defined (__stub_fp_enable) || defined (__stub___fp_enable)
22796
choke me
22797
#else
22798
char (*f) () = fp_enable;
22799
#endif
22800
#ifdef __cplusplus
22801
}
22802
#endif
22803
 
22804
int
22805
main ()
22806
{
22807
return f != fp_enable;
22808
  ;
22809
  return 0;
22810
}
22811
_ACEOF
22812
rm -f conftest.$ac_objext conftest$ac_exeext
22813
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
22814
  (eval $ac_link) 2>conftest.er1
22815
  ac_status=$?
22816
  grep -v '^ *+' conftest.er1 >conftest.err
22817
  rm -f conftest.er1
22818
  cat conftest.err >&5
22819
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22820
  (exit $ac_status); } &&
22821
         { ac_try='test -z "$ac_c_werror_flag"
22822
                         || test ! -s conftest.err'
22823
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22824
  (eval $ac_try) 2>&5
22825
  ac_status=$?
22826
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22827
  (exit $ac_status); }; } &&
22828
         { ac_try='test -s conftest$ac_exeext'
22829
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22830
  (eval $ac_try) 2>&5
22831
  ac_status=$?
22832
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22833
  (exit $ac_status); }; }; then
22834
  ac_cv_func_fp_enable=yes
22835
else
22836
  echo "$as_me: failed program was:" >&5
22837
sed 's/^/| /' conftest.$ac_ext >&5
22838
 
22839
ac_cv_func_fp_enable=no
22840
fi
22841
rm -f conftest.err conftest.$ac_objext \
22842
      conftest$ac_exeext conftest.$ac_ext
22843
fi
22844
echo "$as_me:$LINENO: result: $ac_cv_func_fp_enable" >&5
22845
echo "${ECHO_T}$ac_cv_func_fp_enable" >&6
22846
if test $ac_cv_func_fp_enable = yes; then
22847
  have_fp_enable=yes
22848
cat >>confdefs.h <<\_ACEOF
22849
#define HAVE_FP_ENABLE 1
22850
_ACEOF
22851
 
22852
fi
22853
 
22854
 
22855
# Runs configure.host to set up necessary host-dependent shell variables.
22856
# We then display a message about it, and propagate them through the
22857
# build chain.
22858
. ${srcdir}/configure.host
22859
{ echo "$as_me:$LINENO: FPU dependent file will be ${fpu_host}.h" >&5
22860
echo "$as_me: FPU dependent file will be ${fpu_host}.h" >&6;}
22861
FPU_HOST_HEADER=config/${fpu_host}.h
22862
 
22863
 
22864
# The standard autoconf HAVE_STRUCT_TIMEZONE doesn't actually check
22865
# for struct timezone, as you might think.  We also need to check how
22866
# to call gettimeofday if we have it.
22867
echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
22868
echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
22869
if test "${ac_cv_header_time+set}" = set; then
22870
  echo $ECHO_N "(cached) $ECHO_C" >&6
22871
else
22872
  cat >conftest.$ac_ext <<_ACEOF
22873
/* confdefs.h.  */
22874
_ACEOF
22875
cat confdefs.h >>conftest.$ac_ext
22876
cat >>conftest.$ac_ext <<_ACEOF
22877
/* end confdefs.h.  */
22878
#include 
22879
#include 
22880
#include 
22881
 
22882
int
22883
main ()
22884
{
22885
if ((struct tm *) 0)
22886
return 0;
22887
  ;
22888
  return 0;
22889
}
22890
_ACEOF
22891
rm -f conftest.$ac_objext
22892
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
22893
  (eval $ac_compile) 2>conftest.er1
22894
  ac_status=$?
22895
  grep -v '^ *+' conftest.er1 >conftest.err
22896
  rm -f conftest.er1
22897
  cat conftest.err >&5
22898
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22899
  (exit $ac_status); } &&
22900
         { ac_try='test -z "$ac_c_werror_flag"
22901
                         || test ! -s conftest.err'
22902
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22903
  (eval $ac_try) 2>&5
22904
  ac_status=$?
22905
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22906
  (exit $ac_status); }; } &&
22907
         { ac_try='test -s conftest.$ac_objext'
22908
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
22909
  (eval $ac_try) 2>&5
22910
  ac_status=$?
22911
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
22912
  (exit $ac_status); }; }; then
22913
  ac_cv_header_time=yes
22914
else
22915
  echo "$as_me: failed program was:" >&5
22916
sed 's/^/| /' conftest.$ac_ext >&5
22917
 
22918
ac_cv_header_time=no
22919
fi
22920
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
22921
fi
22922
echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
22923
echo "${ECHO_T}$ac_cv_header_time" >&6
22924
if test $ac_cv_header_time = yes; then
22925
 
22926
cat >>confdefs.h <<\_ACEOF
22927
#define TIME_WITH_SYS_TIME 1
22928
_ACEOF
22929
 
22930
fi
22931
 
22932
 
22933
 
22934
for ac_func in gettimeofday
22935
do
22936
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
22937
echo "$as_me:$LINENO: checking for $ac_func" >&5
22938
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
22939
if eval "test \"\${$as_ac_var+set}\" = set"; then
22940
  echo $ECHO_N "(cached) $ECHO_C" >&6
22941
else
22942
  if test x$gcc_no_link = xyes; then
22943
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
22944
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
22945
   { (exit 1); exit 1; }; }
22946
fi
22947
cat >conftest.$ac_ext <<_ACEOF
22948
/* confdefs.h.  */
22949
_ACEOF
22950
cat confdefs.h >>conftest.$ac_ext
22951
cat >>conftest.$ac_ext <<_ACEOF
22952
/* end confdefs.h.  */
22953
/* Define $ac_func to an innocuous variant, in case  declares $ac_func.
22954
   For example, HP-UX 11i  declares gettimeofday.  */
22955
#define $ac_func innocuous_$ac_func
22956
 
22957
/* System header to define __stub macros and hopefully few prototypes,
22958
    which can conflict with char $ac_func (); below.
22959
    Prefer  to  if __STDC__ is defined, since
22960
     exists even on freestanding compilers.  */
22961
 
22962
#ifdef __STDC__
22963
# include 
22964
#else
22965
# include 
22966
#endif
22967
 
22968
#undef $ac_func
22969
 
22970
/* Override any gcc2 internal prototype to avoid an error.  */
22971
#ifdef __cplusplus
22972
extern "C"
22973
{
22974
#endif
22975
/* We use char because int might match the return type of a gcc2
22976
   builtin and then its argument prototype would still apply.  */
22977
char $ac_func ();
22978
/* The GNU C library defines this for functions which it implements
22979
    to always fail with ENOSYS.  Some functions are actually named
22980
    something starting with __ and the normal name is an alias.  */
22981
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
22982
choke me
22983
#else
22984
char (*f) () = $ac_func;
22985
#endif
22986
#ifdef __cplusplus
22987
}
22988
#endif
22989
 
22990
int
22991
main ()
22992
{
22993
return f != $ac_func;
22994
  ;
22995
  return 0;
22996
}
22997
_ACEOF
22998
rm -f conftest.$ac_objext conftest$ac_exeext
22999
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23000
  (eval $ac_link) 2>conftest.er1
23001
  ac_status=$?
23002
  grep -v '^ *+' conftest.er1 >conftest.err
23003
  rm -f conftest.er1
23004
  cat conftest.err >&5
23005
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23006
  (exit $ac_status); } &&
23007
         { ac_try='test -z "$ac_c_werror_flag"
23008
                         || test ! -s conftest.err'
23009
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23010
  (eval $ac_try) 2>&5
23011
  ac_status=$?
23012
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23013
  (exit $ac_status); }; } &&
23014
         { ac_try='test -s conftest$ac_exeext'
23015
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23016
  (eval $ac_try) 2>&5
23017
  ac_status=$?
23018
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23019
  (exit $ac_status); }; }; then
23020
  eval "$as_ac_var=yes"
23021
else
23022
  echo "$as_me: failed program was:" >&5
23023
sed 's/^/| /' conftest.$ac_ext >&5
23024
 
23025
eval "$as_ac_var=no"
23026
fi
23027
rm -f conftest.err conftest.$ac_objext \
23028
      conftest$ac_exeext conftest.$ac_ext
23029
fi
23030
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
23031
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
23032
if test `eval echo '${'$as_ac_var'}'` = yes; then
23033
  cat >>confdefs.h <<_ACEOF
23034
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
23035
_ACEOF
23036
 
23037
fi
23038
done
23039
 
23040
  if test "$ac_cv_func_gettimeofday" = yes; then
23041
    echo "$as_me:$LINENO: checking for struct timezone" >&5
23042
echo $ECHO_N "checking for struct timezone... $ECHO_C" >&6
23043
if test "${gfor_cv_struct_timezone+set}" = set; then
23044
  echo $ECHO_N "(cached) $ECHO_C" >&6
23045
else
23046
  cat >conftest.$ac_ext <<_ACEOF
23047
/* confdefs.h.  */
23048
_ACEOF
23049
cat confdefs.h >>conftest.$ac_ext
23050
cat >>conftest.$ac_ext <<_ACEOF
23051
/* end confdefs.h.  */
23052
#include 
23053
int
23054
main ()
23055
{
23056
struct timezone tz;
23057
  ;
23058
  return 0;
23059
}
23060
_ACEOF
23061
rm -f conftest.$ac_objext
23062
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
23063
  (eval $ac_compile) 2>conftest.er1
23064
  ac_status=$?
23065
  grep -v '^ *+' conftest.er1 >conftest.err
23066
  rm -f conftest.er1
23067
  cat conftest.err >&5
23068
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23069
  (exit $ac_status); } &&
23070
         { ac_try='test -z "$ac_c_werror_flag"
23071
                         || test ! -s conftest.err'
23072
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23073
  (eval $ac_try) 2>&5
23074
  ac_status=$?
23075
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23076
  (exit $ac_status); }; } &&
23077
         { ac_try='test -s conftest.$ac_objext'
23078
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23079
  (eval $ac_try) 2>&5
23080
  ac_status=$?
23081
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23082
  (exit $ac_status); }; }; then
23083
  gfor_cv_struct_timezone=yes
23084
else
23085
  echo "$as_me: failed program was:" >&5
23086
sed 's/^/| /' conftest.$ac_ext >&5
23087
 
23088
gfor_cv_struct_timezone=no
23089
fi
23090
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
23091
fi
23092
echo "$as_me:$LINENO: result: $gfor_cv_struct_timezone" >&5
23093
echo "${ECHO_T}$gfor_cv_struct_timezone" >&6
23094
    if test $gfor_cv_struct_timezone = yes; then
23095
                  if test "$cross_compiling" = yes; then
23096
  gfor_have_struct_timezone=yes
23097
else
23098
  cat >conftest.$ac_ext <<_ACEOF
23099
/* confdefs.h.  */
23100
_ACEOF
23101
cat confdefs.h >>conftest.$ac_ext
23102
cat >>conftest.$ac_ext <<_ACEOF
23103
/* end confdefs.h.  */
23104
 
23105
#ifdef TIME_WITH_SYS_TIME
23106
#include 
23107
#include 
23108
#else
23109
#ifdef HAVE_SYS_TIME_H
23110
#include 
23111
#else
23112
#include 
23113
#endif
23114
#endif
23115
main ()
23116
{
23117
  struct timeval time;
23118
  struct timezone dummy;
23119
  if (gettimeofday (&time, &dummy))
23120
    exit (1);
23121
  else
23122
    exit (0);
23123
}
23124
_ACEOF
23125
rm -f conftest$ac_exeext
23126
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23127
  (eval $ac_link) 2>&5
23128
  ac_status=$?
23129
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23130
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
23131
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23132
  (eval $ac_try) 2>&5
23133
  ac_status=$?
23134
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23135
  (exit $ac_status); }; }; then
23136
  gfor_have_struct_timezone=yes
23137
else
23138
  echo "$as_me: program exited with status $ac_status" >&5
23139
echo "$as_me: failed program was:" >&5
23140
sed 's/^/| /' conftest.$ac_ext >&5
23141
 
23142
( exit $ac_status )
23143
gfor_have_struct_timezone=no
23144
fi
23145
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23146
fi
23147
      if test $gfor_have_struct_timezone = yes; then
23148
 
23149
cat >>confdefs.h <<\_ACEOF
23150
#define HAVE_TIMEZONE 1
23151
_ACEOF
23152
 
23153
      fi
23154
    fi
23155
 
23156
    echo "$as_me:$LINENO: checking whether gettimeofday can accept two arguments" >&5
23157
echo $ECHO_N "checking whether gettimeofday can accept two arguments... $ECHO_C" >&6
23158
if test "${emacs_cv_gettimeofday_two_arguments+set}" = set; then
23159
  echo $ECHO_N "(cached) $ECHO_C" >&6
23160
else
23161
  if test x$gcc_no_link = xyes; then
23162
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23163
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23164
   { (exit 1); exit 1; }; }
23165
fi
23166
cat >conftest.$ac_ext <<_ACEOF
23167
/* confdefs.h.  */
23168
_ACEOF
23169
cat confdefs.h >>conftest.$ac_ext
23170
cat >>conftest.$ac_ext <<_ACEOF
23171
/* end confdefs.h.  */
23172
 
23173
#ifdef TIME_WITH_SYS_TIME
23174
#include 
23175
#include 
23176
#else
23177
#ifdef HAVE_SYS_TIME_H
23178
#include 
23179
#else
23180
#include 
23181
#endif
23182
#endif
23183
 
23184
int
23185
main ()
23186
{
23187
 
23188
      struct timeval time;
23189
#ifdef HAVE_TIMEZONE
23190
      struct timezone dummy;
23191
#define DUMMY &dummy
23192
#else
23193
#define DUMMY NULL
23194
#endif
23195
      gettimeofday (&time, DUMMY);
23196
  ;
23197
  return 0;
23198
}
23199
_ACEOF
23200
rm -f conftest.$ac_objext conftest$ac_exeext
23201
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23202
  (eval $ac_link) 2>conftest.er1
23203
  ac_status=$?
23204
  grep -v '^ *+' conftest.er1 >conftest.err
23205
  rm -f conftest.er1
23206
  cat conftest.err >&5
23207
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23208
  (exit $ac_status); } &&
23209
         { ac_try='test -z "$ac_c_werror_flag"
23210
                         || test ! -s conftest.err'
23211
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23212
  (eval $ac_try) 2>&5
23213
  ac_status=$?
23214
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23215
  (exit $ac_status); }; } &&
23216
         { ac_try='test -s conftest$ac_exeext'
23217
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23218
  (eval $ac_try) 2>&5
23219
  ac_status=$?
23220
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23221
  (exit $ac_status); }; }; then
23222
  emacs_cv_gettimeofday_two_arguments=yes
23223
else
23224
  echo "$as_me: failed program was:" >&5
23225
sed 's/^/| /' conftest.$ac_ext >&5
23226
 
23227
emacs_cv_gettimeofday_two_arguments=no
23228
fi
23229
rm -f conftest.err conftest.$ac_objext \
23230
      conftest$ac_exeext conftest.$ac_ext
23231
fi
23232
echo "$as_me:$LINENO: result: $emacs_cv_gettimeofday_two_arguments" >&5
23233
echo "${ECHO_T}$emacs_cv_gettimeofday_two_arguments" >&6
23234
    if test $emacs_cv_gettimeofday_two_arguments = no; then
23235
 
23236
cat >>confdefs.h <<\_ACEOF
23237
#define GETTIMEOFDAY_ONE_ARGUMENT 1
23238
_ACEOF
23239
 
23240
    fi
23241
  fi
23242
 
23243
# Attempt to assert that the target is of common type in case we don't
23244
# have C99 integer types at all.
23245
 
23246
  echo "$as_me:$LINENO: checking whether the target is ILP32" >&5
23247
echo $ECHO_N "checking whether the target is ILP32... $ECHO_C" >&6
23248
if test "${target_ilp32+set}" = set; then
23249
  echo $ECHO_N "(cached) $ECHO_C" >&6
23250
else
23251
 
23252
  save_CFLAGS="$CFLAGS"
23253
  CFLAGS="-O2"
23254
  if test x$gcc_no_link = xyes; then
23255
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23256
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23257
   { (exit 1); exit 1; }; }
23258
fi
23259
cat >conftest.$ac_ext <<_ACEOF
23260
/* confdefs.h.  */
23261
_ACEOF
23262
cat confdefs.h >>conftest.$ac_ext
23263
cat >>conftest.$ac_ext <<_ACEOF
23264
/* end confdefs.h.  */
23265
 
23266
int
23267
main ()
23268
{
23269
 
23270
if (sizeof(int) == 4 && sizeof(long) == 4 && sizeof(void *) == 4)
23271
  ;
23272
else
23273
  undefined_function ();
23274
 
23275
  ;
23276
  return 0;
23277
}
23278
_ACEOF
23279
rm -f conftest.$ac_objext conftest$ac_exeext
23280
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23281
  (eval $ac_link) 2>conftest.er1
23282
  ac_status=$?
23283
  grep -v '^ *+' conftest.er1 >conftest.err
23284
  rm -f conftest.er1
23285
  cat conftest.err >&5
23286
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23287
  (exit $ac_status); } &&
23288
         { ac_try='test -z "$ac_c_werror_flag"
23289
                         || test ! -s conftest.err'
23290
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23291
  (eval $ac_try) 2>&5
23292
  ac_status=$?
23293
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23294
  (exit $ac_status); }; } &&
23295
         { ac_try='test -s conftest$ac_exeext'
23296
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23297
  (eval $ac_try) 2>&5
23298
  ac_status=$?
23299
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23300
  (exit $ac_status); }; }; then
23301
  target_ilp32=yes
23302
else
23303
  echo "$as_me: failed program was:" >&5
23304
sed 's/^/| /' conftest.$ac_ext >&5
23305
 
23306
target_ilp32=no
23307
fi
23308
rm -f conftest.err conftest.$ac_objext \
23309
      conftest$ac_exeext conftest.$ac_ext
23310
  CFLAGS="$save_CFLAGS"
23311
fi
23312
echo "$as_me:$LINENO: result: $target_ilp32" >&5
23313
echo "${ECHO_T}$target_ilp32" >&6
23314
  if test $target_ilp32 = yes; then
23315
 
23316
cat >>confdefs.h <<\_ACEOF
23317
#define TARGET_ILP32 1
23318
_ACEOF
23319
 
23320
  fi
23321
 
23322
 
23323
# Check out attribute support.
23324
 
23325
  echo "$as_me:$LINENO: checking whether the target supports hidden visibility" >&5
23326
echo $ECHO_N "checking whether the target supports hidden visibility... $ECHO_C" >&6
23327
if test "${have_attribute_visibility+set}" = set; then
23328
  echo $ECHO_N "(cached) $ECHO_C" >&6
23329
else
23330
 
23331
  save_CFLAGS="$CFLAGS"
23332
  CFLAGS="$CFLAGS -Werror"
23333
  cat >conftest.$ac_ext <<_ACEOF
23334
/* confdefs.h.  */
23335
_ACEOF
23336
cat confdefs.h >>conftest.$ac_ext
23337
cat >>conftest.$ac_ext <<_ACEOF
23338
/* end confdefs.h.  */
23339
void __attribute__((visibility("hidden"))) foo(void) { }
23340
int
23341
main ()
23342
{
23343
 
23344
  ;
23345
  return 0;
23346
}
23347
_ACEOF
23348
rm -f conftest.$ac_objext
23349
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
23350
  (eval $ac_compile) 2>conftest.er1
23351
  ac_status=$?
23352
  grep -v '^ *+' conftest.er1 >conftest.err
23353
  rm -f conftest.er1
23354
  cat conftest.err >&5
23355
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23356
  (exit $ac_status); } &&
23357
         { ac_try='test -z "$ac_c_werror_flag"
23358
                         || test ! -s conftest.err'
23359
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23360
  (eval $ac_try) 2>&5
23361
  ac_status=$?
23362
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23363
  (exit $ac_status); }; } &&
23364
         { ac_try='test -s conftest.$ac_objext'
23365
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23366
  (eval $ac_try) 2>&5
23367
  ac_status=$?
23368
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23369
  (exit $ac_status); }; }; then
23370
  have_attribute_visibility=yes
23371
else
23372
  echo "$as_me: failed program was:" >&5
23373
sed 's/^/| /' conftest.$ac_ext >&5
23374
 
23375
have_attribute_visibility=no
23376
fi
23377
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
23378
  CFLAGS="$save_CFLAGS"
23379
fi
23380
echo "$as_me:$LINENO: result: $have_attribute_visibility" >&5
23381
echo "${ECHO_T}$have_attribute_visibility" >&6
23382
  if test $have_attribute_visibility = yes; then
23383
 
23384
cat >>confdefs.h <<\_ACEOF
23385
#define HAVE_ATTRIBUTE_VISIBILITY 1
23386
_ACEOF
23387
 
23388
  fi
23389
 
23390
  echo "$as_me:$LINENO: checking whether the target supports dllexport" >&5
23391
echo $ECHO_N "checking whether the target supports dllexport... $ECHO_C" >&6
23392
if test "${have_attribute_dllexport+set}" = set; then
23393
  echo $ECHO_N "(cached) $ECHO_C" >&6
23394
else
23395
 
23396
  save_CFLAGS="$CFLAGS"
23397
  CFLAGS="$CFLAGS -Werror"
23398
  cat >conftest.$ac_ext <<_ACEOF
23399
/* confdefs.h.  */
23400
_ACEOF
23401
cat confdefs.h >>conftest.$ac_ext
23402
cat >>conftest.$ac_ext <<_ACEOF
23403
/* end confdefs.h.  */
23404
void __attribute__((dllexport)) foo(void) { }
23405
int
23406
main ()
23407
{
23408
 
23409
  ;
23410
  return 0;
23411
}
23412
_ACEOF
23413
rm -f conftest.$ac_objext
23414
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
23415
  (eval $ac_compile) 2>conftest.er1
23416
  ac_status=$?
23417
  grep -v '^ *+' conftest.er1 >conftest.err
23418
  rm -f conftest.er1
23419
  cat conftest.err >&5
23420
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23421
  (exit $ac_status); } &&
23422
         { ac_try='test -z "$ac_c_werror_flag"
23423
                         || test ! -s conftest.err'
23424
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23425
  (eval $ac_try) 2>&5
23426
  ac_status=$?
23427
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23428
  (exit $ac_status); }; } &&
23429
         { ac_try='test -s conftest.$ac_objext'
23430
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23431
  (eval $ac_try) 2>&5
23432
  ac_status=$?
23433
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23434
  (exit $ac_status); }; }; then
23435
  have_attribute_dllexport=yes
23436
else
23437
  echo "$as_me: failed program was:" >&5
23438
sed 's/^/| /' conftest.$ac_ext >&5
23439
 
23440
have_attribute_dllexport=no
23441
fi
23442
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
23443
  CFLAGS="$save_CFLAGS"
23444
fi
23445
echo "$as_me:$LINENO: result: $have_attribute_dllexport" >&5
23446
echo "${ECHO_T}$have_attribute_dllexport" >&6
23447
  if test $have_attribute_dllexport = yes; then
23448
 
23449
cat >>confdefs.h <<\_ACEOF
23450
#define HAVE_ATTRIBUTE_DLLEXPORT 1
23451
_ACEOF
23452
 
23453
  fi
23454
 
23455
  echo "$as_me:$LINENO: checking whether the target supports symbol aliases" >&5
23456
echo $ECHO_N "checking whether the target supports symbol aliases... $ECHO_C" >&6
23457
if test "${have_attribute_alias+set}" = set; then
23458
  echo $ECHO_N "(cached) $ECHO_C" >&6
23459
else
23460
 
23461
  if test x$gcc_no_link = xyes; then
23462
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23463
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23464
   { (exit 1); exit 1; }; }
23465
fi
23466
cat >conftest.$ac_ext <<_ACEOF
23467
/* confdefs.h.  */
23468
_ACEOF
23469
cat confdefs.h >>conftest.$ac_ext
23470
cat >>conftest.$ac_ext <<_ACEOF
23471
/* end confdefs.h.  */
23472
 
23473
#define ULP     STR1(__USER_LABEL_PREFIX__)
23474
#define STR1(x) STR2(x)
23475
#define STR2(x) #x
23476
void foo(void) { }
23477
extern void bar(void) __attribute__((alias(ULP "foo")));
23478
int
23479
main ()
23480
{
23481
bar();
23482
  ;
23483
  return 0;
23484
}
23485
_ACEOF
23486
rm -f conftest.$ac_objext conftest$ac_exeext
23487
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23488
  (eval $ac_link) 2>conftest.er1
23489
  ac_status=$?
23490
  grep -v '^ *+' conftest.er1 >conftest.err
23491
  rm -f conftest.er1
23492
  cat conftest.err >&5
23493
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23494
  (exit $ac_status); } &&
23495
         { ac_try='test -z "$ac_c_werror_flag"
23496
                         || test ! -s conftest.err'
23497
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23498
  (eval $ac_try) 2>&5
23499
  ac_status=$?
23500
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23501
  (exit $ac_status); }; } &&
23502
         { ac_try='test -s conftest$ac_exeext'
23503
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23504
  (eval $ac_try) 2>&5
23505
  ac_status=$?
23506
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23507
  (exit $ac_status); }; }; then
23508
  have_attribute_alias=yes
23509
else
23510
  echo "$as_me: failed program was:" >&5
23511
sed 's/^/| /' conftest.$ac_ext >&5
23512
 
23513
have_attribute_alias=no
23514
fi
23515
rm -f conftest.err conftest.$ac_objext \
23516
      conftest$ac_exeext conftest.$ac_ext
23517
fi
23518
echo "$as_me:$LINENO: result: $have_attribute_alias" >&5
23519
echo "${ECHO_T}$have_attribute_alias" >&6
23520
  if test $have_attribute_alias = yes; then
23521
 
23522
cat >>confdefs.h <<\_ACEOF
23523
#define HAVE_ATTRIBUTE_ALIAS 1
23524
_ACEOF
23525
 
23526
  fi
23527
 
23528
# Check out sync builtins support.
23529
 
23530
  echo "$as_me:$LINENO: checking whether the target supports __sync_fetch_and_add" >&5
23531
echo $ECHO_N "checking whether the target supports __sync_fetch_and_add... $ECHO_C" >&6
23532
if test "${have_sync_fetch_and_add+set}" = set; then
23533
  echo $ECHO_N "(cached) $ECHO_C" >&6
23534
else
23535
 
23536
  if test x$gcc_no_link = xyes; then
23537
  { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
23538
echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
23539
   { (exit 1); exit 1; }; }
23540
fi
23541
cat >conftest.$ac_ext <<_ACEOF
23542
/* confdefs.h.  */
23543
_ACEOF
23544
cat confdefs.h >>conftest.$ac_ext
23545
cat >>conftest.$ac_ext <<_ACEOF
23546
/* end confdefs.h.  */
23547
int foovar = 0;
23548
int
23549
main ()
23550
{
23551
 
23552
if (foovar <= 0) return __sync_fetch_and_add (&foovar, 1);
23553
if (foovar > 10) return __sync_add_and_fetch (&foovar, -1);
23554
  ;
23555
  return 0;
23556
}
23557
_ACEOF
23558
rm -f conftest.$ac_objext conftest$ac_exeext
23559
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23560
  (eval $ac_link) 2>conftest.er1
23561
  ac_status=$?
23562
  grep -v '^ *+' conftest.er1 >conftest.err
23563
  rm -f conftest.er1
23564
  cat conftest.err >&5
23565
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23566
  (exit $ac_status); } &&
23567
         { ac_try='test -z "$ac_c_werror_flag"
23568
                         || test ! -s conftest.err'
23569
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23570
  (eval $ac_try) 2>&5
23571
  ac_status=$?
23572
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23573
  (exit $ac_status); }; } &&
23574
         { ac_try='test -s conftest$ac_exeext'
23575
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23576
  (eval $ac_try) 2>&5
23577
  ac_status=$?
23578
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23579
  (exit $ac_status); }; }; then
23580
  have_sync_fetch_and_add=yes
23581
else
23582
  echo "$as_me: failed program was:" >&5
23583
sed 's/^/| /' conftest.$ac_ext >&5
23584
 
23585
have_sync_fetch_and_add=no
23586
fi
23587
rm -f conftest.err conftest.$ac_objext \
23588
      conftest$ac_exeext conftest.$ac_ext
23589
fi
23590
echo "$as_me:$LINENO: result: $have_sync_fetch_and_add" >&5
23591
echo "${ECHO_T}$have_sync_fetch_and_add" >&6
23592
  if test $have_sync_fetch_and_add = yes; then
23593
 
23594
cat >>confdefs.h <<\_ACEOF
23595
#define HAVE_SYNC_FETCH_AND_ADD 1
23596
_ACEOF
23597
 
23598
  fi
23599
 
23600
# Check out thread support.
23601
 
23602
  echo "$as_me:$LINENO: checking configured target thread model" >&5
23603
echo $ECHO_N "checking configured target thread model... $ECHO_C" >&6
23604
if test "${target_thread_file+set}" = set; then
23605
  echo $ECHO_N "(cached) $ECHO_C" >&6
23606
else
23607
 
23608
target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
23609
fi
23610
echo "$as_me:$LINENO: result: $target_thread_file" >&5
23611
echo "${ECHO_T}$target_thread_file" >&6
23612
 
23613
  if test $target_thread_file != single; then
23614
 
23615
cat >>confdefs.h <<\_ACEOF
23616
#define HAVE_GTHR_DEFAULT 1
23617
_ACEOF
23618
 
23619
  fi
23620
 
23621
# Check out #pragma weak.
23622
 
23623
  echo "$as_me:$LINENO: checking whether pragma weak works" >&5
23624
echo $ECHO_N "checking whether pragma weak works... $ECHO_C" >&6
23625
if test "${have_pragma_weak+set}" = set; then
23626
  echo $ECHO_N "(cached) $ECHO_C" >&6
23627
else
23628
 
23629
  gfor_save_CFLAGS="$CFLAGS"
23630
  CFLAGS="$CFLAGS -Wunknown-pragmas"
23631
  cat >conftest.$ac_ext <<_ACEOF
23632
/* confdefs.h.  */
23633
_ACEOF
23634
cat confdefs.h >>conftest.$ac_ext
23635
cat >>conftest.$ac_ext <<_ACEOF
23636
/* end confdefs.h.  */
23637
void foo (void);
23638
#pragma weak foo
23639
int
23640
main ()
23641
{
23642
if (foo) foo ();
23643
  ;
23644
  return 0;
23645
}
23646
_ACEOF
23647
rm -f conftest.$ac_objext
23648
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
23649
  (eval $ac_compile) 2>conftest.er1
23650
  ac_status=$?
23651
  grep -v '^ *+' conftest.er1 >conftest.err
23652
  rm -f conftest.er1
23653
  cat conftest.err >&5
23654
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23655
  (exit $ac_status); } &&
23656
         { ac_try='test -z "$ac_c_werror_flag"
23657
                         || test ! -s conftest.err'
23658
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23659
  (eval $ac_try) 2>&5
23660
  ac_status=$?
23661
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23662
  (exit $ac_status); }; } &&
23663
         { ac_try='test -s conftest.$ac_objext'
23664
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23665
  (eval $ac_try) 2>&5
23666
  ac_status=$?
23667
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23668
  (exit $ac_status); }; }; then
23669
  have_pragma_weak=yes
23670
else
23671
  echo "$as_me: failed program was:" >&5
23672
sed 's/^/| /' conftest.$ac_ext >&5
23673
 
23674
have_pragma_weak=no
23675
fi
23676
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
23677
fi
23678
echo "$as_me:$LINENO: result: $have_pragma_weak" >&5
23679
echo "${ECHO_T}$have_pragma_weak" >&6
23680
  if test $have_pragma_weak = yes; then
23681
 
23682
cat >>confdefs.h <<\_ACEOF
23683
#define SUPPORTS_WEAK 1
23684
_ACEOF
23685
 
23686
  fi
23687
  case "$host" in
23688
    *-*-darwin* | *-*-hpux* | *-*-cygwin*)
23689
 
23690
cat >>confdefs.h <<\_ACEOF
23691
#define GTHREAD_USE_WEAK 0
23692
_ACEOF
23693
 
23694
      ;;
23695
  esac
23696
 
23697
# Various other checks on target
23698
 
23699
  echo "$as_me:$LINENO: checking whether the target can unlink an open file" >&5
23700
echo $ECHO_N "checking whether the target can unlink an open file... $ECHO_C" >&6
23701
if test "${have_unlink_open_file+set}" = set; then
23702
  echo $ECHO_N "(cached) $ECHO_C" >&6
23703
else
23704
 
23705
  if test "$cross_compiling" = yes; then
23706
 
23707
case "${target}" in
23708
  *mingw*) have_unlink_open_file=no ;;
23709
  *) have_unlink_open_file=yes;;
23710
esac
23711
else
23712
  cat >conftest.$ac_ext <<_ACEOF
23713
/* confdefs.h.  */
23714
_ACEOF
23715
cat confdefs.h >>conftest.$ac_ext
23716
cat >>conftest.$ac_ext <<_ACEOF
23717
/* end confdefs.h.  */
23718
 
23719
#include 
23720
#include 
23721
#include 
23722
#include 
23723
 
23724
int main ()
23725
{
23726
  int fd;
23727
 
23728
  fd = open ("testfile", O_RDWR | O_CREAT, S_IWRITE | S_IREAD);
23729
  if (fd <= 0)
23730
    return 0;
23731
  if (unlink ("testfile") == -1)
23732
    return 1;
23733
  write (fd, "This is a test\n", 15);
23734
  close (fd);
23735
 
23736
  if (open ("testfile", O_RDONLY, S_IWRITE | S_IREAD) == -1 && errno == ENOENT)
23737
    return 0;
23738
  else
23739
    return 1;
23740
}
23741
_ACEOF
23742
rm -f conftest$ac_exeext
23743
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23744
  (eval $ac_link) 2>&5
23745
  ac_status=$?
23746
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23747
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
23748
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23749
  (eval $ac_try) 2>&5
23750
  ac_status=$?
23751
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23752
  (exit $ac_status); }; }; then
23753
  have_unlink_open_file=yes
23754
else
23755
  echo "$as_me: program exited with status $ac_status" >&5
23756
echo "$as_me: failed program was:" >&5
23757
sed 's/^/| /' conftest.$ac_ext >&5
23758
 
23759
( exit $ac_status )
23760
have_unlink_open_file=no
23761
fi
23762
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23763
fi
23764
fi
23765
echo "$as_me:$LINENO: result: $have_unlink_open_file" >&5
23766
echo "${ECHO_T}$have_unlink_open_file" >&6
23767
if test x"$have_unlink_open_file" = xyes; then
23768
 
23769
cat >>confdefs.h <<\_ACEOF
23770
#define HAVE_UNLINK_OPEN_FILE 1
23771
_ACEOF
23772
 
23773
fi
23774
 
23775
# Check whether line terminator is LF or CRLF
23776
 
23777
  echo "$as_me:$LINENO: checking whether the target has CRLF as line terminator" >&5
23778
echo $ECHO_N "checking whether the target has CRLF as line terminator... $ECHO_C" >&6
23779
if test "${have_crlf+set}" = set; then
23780
  echo $ECHO_N "(cached) $ECHO_C" >&6
23781
else
23782
 
23783
  if test "$cross_compiling" = yes; then
23784
 
23785
case "${target}" in
23786
  *mingw*) have_crlf=yes ;;
23787
  *) have_crlf=no;;
23788
esac
23789
else
23790
  cat >conftest.$ac_ext <<_ACEOF
23791
/* confdefs.h.  */
23792
_ACEOF
23793
cat confdefs.h >>conftest.$ac_ext
23794
cat >>conftest.$ac_ext <<_ACEOF
23795
/* end confdefs.h.  */
23796
 
23797
/* This test program should exit with status 0 if system uses a CRLF as
23798
   line terminator, and status 1 otherwise.
23799
   Since it is used to check for mingw systems, and should return 0 in any
23800
   other case, in case of a failure we will not use CRLF.  */
23801
#include 
23802
#include 
23803
#include 
23804
#include 
23805
 
23806
int main ()
23807
{
23808
#ifndef O_BINARY
23809
  exit(1);
23810
#else
23811
  int fd, bytes;
23812
  char buff[5];
23813
 
23814
  fd = open ("foo", O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
23815
  if (fd < 0)
23816
    exit(1);
23817
  if (write (fd, "\n", 1) < 0)
23818
    perror ("write");
23819
 
23820
  close (fd);
23821
 
23822
  if ((fd = open ("foo", O_RDONLY | O_BINARY, S_IRWXU)) < 0)
23823
    exit(1);
23824
  bytes = read (fd, buff, 5);
23825
  if (bytes == 2 && buff[0] == '\r' && buff[1] == '\n')
23826
    exit(0);
23827
  else
23828
    exit(1);
23829
#endif
23830
}
23831
_ACEOF
23832
rm -f conftest$ac_exeext
23833
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
23834
  (eval $ac_link) 2>&5
23835
  ac_status=$?
23836
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23837
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
23838
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
23839
  (eval $ac_try) 2>&5
23840
  ac_status=$?
23841
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
23842
  (exit $ac_status); }; }; then
23843
  have_crlf=yes
23844
else
23845
  echo "$as_me: program exited with status $ac_status" >&5
23846
echo "$as_me: failed program was:" >&5
23847
sed 's/^/| /' conftest.$ac_ext >&5
23848
 
23849
( exit $ac_status )
23850
have_crlf=no
23851
fi
23852
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
23853
fi
23854
fi
23855
echo "$as_me:$LINENO: result: $have_crlf" >&5
23856
echo "${ECHO_T}$have_crlf" >&6
23857
if test x"$have_crlf" = xyes; then
23858
 
23859
cat >>confdefs.h <<\_ACEOF
23860
#define HAVE_CRLF 1
23861
_ACEOF
23862
 
23863
fi
23864
 
23865
cat >confcache <<\_ACEOF
23866
# This file is a shell script that caches the results of configure
23867
# tests run on this system so they can be shared between configure
23868
# scripts and configure runs, see configure's option --config-cache.
23869
# It is not useful on other systems.  If it contains results you don't
23870
# want to keep, you may remove or edit it.
23871
#
23872
# config.status only pays attention to the cache file if you give it
23873
# the --recheck option to rerun configure.
23874
#
23875
# `ac_cv_env_foo' variables (set or unset) will be overridden when
23876
# loading this file, other *unset* `ac_cv_foo' will be assigned the
23877
# following values.
23878
 
23879
_ACEOF
23880
 
23881
# The following way of writing the cache mishandles newlines in values,
23882
# but we know of no workaround that is simple, portable, and efficient.
23883
# So, don't put newlines in cache variables' values.
23884
# Ultrix sh set writes to stderr and can't be redirected directly,
23885
# and sets the high bit in the cache file unless we assign to the vars.
23886
{
23887
  (set) 2>&1 |
23888
    case `(ac_space=' '; set | grep ac_space) 2>&1` in
23889
    *ac_space=\ *)
23890
      # `set' does not quote correctly, so add quotes (double-quote
23891
      # substitution turns \\\\ into \\, and sed turns \\ into \).
23892
      sed -n \
23893
        "s/'/'\\\\''/g;
23894
          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
23895
      ;;
23896
    *)
23897
      # `set' quotes correctly as required by POSIX, so do not add quotes.
23898
      sed -n \
23899
        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
23900
      ;;
23901
    esac;
23902
} |
23903
  sed '
23904
     t clear
23905
     : clear
23906
     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
23907
     t end
23908
     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
23909
     : end' >>confcache
23910
if diff $cache_file confcache >/dev/null 2>&1; then :; else
23911
  if test -w $cache_file; then
23912
    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
23913
    cat confcache >$cache_file
23914
  else
23915
    echo "not updating unwritable cache $cache_file"
23916
  fi
23917
fi
23918
rm -f confcache
23919
 
23920
if test ${multilib} = yes; then
23921
  multilib_arg="--enable-multilib"
23922
else
23923
  multilib_arg=
23924
fi
23925
 
23926
# Write our Makefile.
23927
          ac_config_files="$ac_config_files Makefile"
23928
 
23929
cat >confcache <<\_ACEOF
23930
# This file is a shell script that caches the results of configure
23931
# tests run on this system so they can be shared between configure
23932
# scripts and configure runs, see configure's option --config-cache.
23933
# It is not useful on other systems.  If it contains results you don't
23934
# want to keep, you may remove or edit it.
23935
#
23936
# config.status only pays attention to the cache file if you give it
23937
# the --recheck option to rerun configure.
23938
#
23939
# `ac_cv_env_foo' variables (set or unset) will be overridden when
23940
# loading this file, other *unset* `ac_cv_foo' will be assigned the
23941
# following values.
23942
 
23943
_ACEOF
23944
 
23945
# The following way of writing the cache mishandles newlines in values,
23946
# but we know of no workaround that is simple, portable, and efficient.
23947
# So, don't put newlines in cache variables' values.
23948
# Ultrix sh set writes to stderr and can't be redirected directly,
23949
# and sets the high bit in the cache file unless we assign to the vars.
23950
{
23951
  (set) 2>&1 |
23952
    case `(ac_space=' '; set | grep ac_space) 2>&1` in
23953
    *ac_space=\ *)
23954
      # `set' does not quote correctly, so add quotes (double-quote
23955
      # substitution turns \\\\ into \\, and sed turns \\ into \).
23956
      sed -n \
23957
        "s/'/'\\\\''/g;
23958
          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
23959
      ;;
23960
    *)
23961
      # `set' quotes correctly as required by POSIX, so do not add quotes.
23962
      sed -n \
23963
        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
23964
      ;;
23965
    esac;
23966
} |
23967
  sed '
23968
     t clear
23969
     : clear
23970
     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
23971
     t end
23972
     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
23973
     : end' >>confcache
23974
if diff $cache_file confcache >/dev/null 2>&1; then :; else
23975
  if test -w $cache_file; then
23976
    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
23977
    cat confcache >$cache_file
23978
  else
23979
    echo "not updating unwritable cache $cache_file"
23980
  fi
23981
fi
23982
rm -f confcache
23983
 
23984
test "x$prefix" = xNONE && prefix=$ac_default_prefix
23985
# Let make expand exec_prefix.
23986
test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
23987
 
23988
# VPATH may cause trouble with some makes, so we remove $(srcdir),
23989
# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
23990
# trailing colons and then remove the whole line if VPATH becomes empty
23991
# (actually we leave an empty line to preserve line numbers).
23992
if test "x$srcdir" = x.; then
23993
  ac_vpsub='/^[  ]*VPATH[        ]*=/{
23994
s/:*\$(srcdir):*/:/;
23995
s/:*\${srcdir}:*/:/;
23996
s/:*@srcdir@:*/:/;
23997
s/^\([^=]*=[     ]*\):*/\1/;
23998
s/:*$//;
23999
s/^[^=]*=[       ]*$//;
24000
}'
24001
fi
24002
 
24003
DEFS=-DHAVE_CONFIG_H
24004
 
24005
ac_libobjs=
24006
ac_ltlibobjs=
24007
for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
24008
  # 1. Remove the extension, and $U if already installed.
24009
  ac_i=`echo "$ac_i" |
24010
         sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
24011
  # 2. Add them.
24012
  ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
24013
  ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
24014
done
24015
LIBOBJS=$ac_libobjs
24016
 
24017
LTLIBOBJS=$ac_ltlibobjs
24018
 
24019
 
24020
if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then
24021
  { { echo "$as_me:$LINENO: error: conditional \"MAINTAINER_MODE\" was never defined.
24022
Usually this means the macro was only invoked conditionally." >&5
24023
echo "$as_me: error: conditional \"MAINTAINER_MODE\" was never defined.
24024
Usually this means the macro was only invoked conditionally." >&2;}
24025
   { (exit 1); exit 1; }; }
24026
fi
24027
 
24028
: ${CONFIG_STATUS=./config.status}
24029
ac_clean_files_save=$ac_clean_files
24030
ac_clean_files="$ac_clean_files $CONFIG_STATUS"
24031
{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
24032
echo "$as_me: creating $CONFIG_STATUS" >&6;}
24033
cat >$CONFIG_STATUS <<_ACEOF
24034
#! $SHELL
24035
# Generated by $as_me.
24036
# Run this file to recreate the current configuration.
24037
# Compiler output produced by configure, useful for debugging
24038
# configure, is in config.log if it exists.
24039
 
24040
debug=false
24041
ac_cs_recheck=false
24042
ac_cs_silent=false
24043
SHELL=\${CONFIG_SHELL-$SHELL}
24044
_ACEOF
24045
 
24046
cat >>$CONFIG_STATUS <<\_ACEOF
24047
## --------------------- ##
24048
## M4sh Initialization.  ##
24049
## --------------------- ##
24050
 
24051
# Be Bourne compatible
24052
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
24053
  emulate sh
24054
  NULLCMD=:
24055
  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
24056
  # is contrary to our usage.  Disable this feature.
24057
  alias -g '${1+"$@"}'='"$@"'
24058
elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
24059
  set -o posix
24060
fi
24061
DUALCASE=1; export DUALCASE # for MKS sh
24062
 
24063
# Support unset when possible.
24064
if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
24065
  as_unset=unset
24066
else
24067
  as_unset=false
24068
fi
24069
 
24070
 
24071
# Work around bugs in pre-3.0 UWIN ksh.
24072
$as_unset ENV MAIL MAILPATH
24073
PS1='$ '
24074
PS2='> '
24075
PS4='+ '
24076
 
24077
# NLS nuisances.
24078
for as_var in \
24079
  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
24080
  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
24081
  LC_TELEPHONE LC_TIME
24082
do
24083
  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
24084
    eval $as_var=C; export $as_var
24085
  else
24086
    $as_unset $as_var
24087
  fi
24088
done
24089
 
24090
# Required to use basename.
24091
if expr a : '\(a\)' >/dev/null 2>&1; then
24092
  as_expr=expr
24093
else
24094
  as_expr=false
24095
fi
24096
 
24097
if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
24098
  as_basename=basename
24099
else
24100
  as_basename=false
24101
fi
24102
 
24103
 
24104
# Name of the executable.
24105
as_me=`$as_basename "$0" ||
24106
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
24107
         X"$0" : 'X\(//\)$' \| \
24108
         X"$0" : 'X\(/\)$' \| \
24109
         .     : '\(.\)' 2>/dev/null ||
24110
echo X/"$0" |
24111
    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
24112
          /^X\/\(\/\/\)$/{ s//\1/; q; }
24113
          /^X\/\(\/\).*/{ s//\1/; q; }
24114
          s/.*/./; q'`
24115
 
24116
 
24117
# PATH needs CR, and LINENO needs CR and PATH.
24118
# Avoid depending upon Character Ranges.
24119
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
24120
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
24121
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
24122
as_cr_digits='0123456789'
24123
as_cr_alnum=$as_cr_Letters$as_cr_digits
24124
 
24125
# The user is always right.
24126
if test "${PATH_SEPARATOR+set}" != set; then
24127
  echo "#! /bin/sh" >conf$$.sh
24128
  echo  "exit 0"   >>conf$$.sh
24129
  chmod +x conf$$.sh
24130
  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
24131
    PATH_SEPARATOR=';'
24132
  else
24133
    PATH_SEPARATOR=:
24134
  fi
24135
  rm -f conf$$.sh
24136
fi
24137
 
24138
 
24139
  as_lineno_1=$LINENO
24140
  as_lineno_2=$LINENO
24141
  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
24142
  test "x$as_lineno_1" != "x$as_lineno_2" &&
24143
  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
24144
  # Find who we are.  Look in the path if we contain no path at all
24145
  # relative or not.
24146
  case $0 in
24147
    *[\\/]* ) as_myself=$0 ;;
24148
    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24149
for as_dir in $PATH
24150
do
24151
  IFS=$as_save_IFS
24152
  test -z "$as_dir" && as_dir=.
24153
  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
24154
done
24155
 
24156
       ;;
24157
  esac
24158
  # We did not find ourselves, most probably we were run as `sh COMMAND'
24159
  # in which case we are not to be found in the path.
24160
  if test "x$as_myself" = x; then
24161
    as_myself=$0
24162
  fi
24163
  if test ! -f "$as_myself"; then
24164
    { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
24165
echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
24166
   { (exit 1); exit 1; }; }
24167
  fi
24168
  case $CONFIG_SHELL in
24169
  '')
24170
    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
24171
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
24172
do
24173
  IFS=$as_save_IFS
24174
  test -z "$as_dir" && as_dir=.
24175
  for as_base in sh bash ksh sh5; do
24176
         case $as_dir in
24177
         /*)
24178
           if ("$as_dir/$as_base" -c '
24179
  as_lineno_1=$LINENO
24180
  as_lineno_2=$LINENO
24181
  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
24182
  test "x$as_lineno_1" != "x$as_lineno_2" &&
24183
  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
24184
             $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
24185
             $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
24186
             CONFIG_SHELL=$as_dir/$as_base
24187
             export CONFIG_SHELL
24188
             exec "$CONFIG_SHELL" "$0" ${1+"$@"}
24189
           fi;;
24190
         esac
24191
       done
24192
done
24193
;;
24194
  esac
24195
 
24196
  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
24197
  # uniformly replaced by the line number.  The first 'sed' inserts a
24198
  # line-number line before each line; the second 'sed' does the real
24199
  # work.  The second script uses 'N' to pair each line-number line
24200
  # with the numbered line, and appends trailing '-' during
24201
  # substitution so that $LINENO is not a special case at line end.
24202
  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
24203
  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
24204
  sed '=' <$as_myself |
24205
    sed '
24206
      N
24207
      s,$,-,
24208
      : loop
24209
      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
24210
      t loop
24211
      s,-$,,
24212
      s,^['$as_cr_digits']*\n,,
24213
    ' >$as_me.lineno &&
24214
  chmod +x $as_me.lineno ||
24215
    { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
24216
echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
24217
   { (exit 1); exit 1; }; }
24218
 
24219
  # Don't try to exec as it changes $[0], causing all sort of problems
24220
  # (the dirname of $[0] is not the place where we might find the
24221
  # original and so on.  Autoconf is especially sensible to this).
24222
  . ./$as_me.lineno
24223
  # Exit status is that of the last command.
24224
  exit
24225
}
24226
 
24227
 
24228
case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
24229
  *c*,-n*) ECHO_N= ECHO_C='
24230
' ECHO_T='      ' ;;
24231
  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
24232
  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
24233
esac
24234
 
24235
if expr a : '\(a\)' >/dev/null 2>&1; then
24236
  as_expr=expr
24237
else
24238
  as_expr=false
24239
fi
24240
 
24241
rm -f conf$$ conf$$.exe conf$$.file
24242
echo >conf$$.file
24243
if ln -s conf$$.file conf$$ 2>/dev/null; then
24244
  # We could just check for DJGPP; but this test a) works b) is more generic
24245
  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
24246
  if test -f conf$$.exe; then
24247
    # Don't use ln at all; we don't have any links
24248
    as_ln_s='cp -p'
24249
  else
24250
    as_ln_s='ln -s'
24251
  fi
24252
elif ln conf$$.file conf$$ 2>/dev/null; then
24253
  as_ln_s=ln
24254
else
24255
  as_ln_s='cp -p'
24256
fi
24257
rm -f conf$$ conf$$.exe conf$$.file
24258
 
24259
if mkdir -p . 2>/dev/null; then
24260
  as_mkdir_p=:
24261
else
24262
  test -d ./-p && rmdir ./-p
24263
  as_mkdir_p=false
24264
fi
24265
 
24266
as_executable_p="test -f"
24267
 
24268
# Sed expression to map a string onto a valid CPP name.
24269
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
24270
 
24271
# Sed expression to map a string onto a valid variable name.
24272
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
24273
 
24274
 
24275
# IFS
24276
# We need space, tab and new line, in precisely that order.
24277
as_nl='
24278
'
24279
IFS="   $as_nl"
24280
 
24281
# CDPATH.
24282
$as_unset CDPATH
24283
 
24284
exec 6>&1
24285
 
24286
# Open the log real soon, to keep \$[0] and so on meaningful, and to
24287
# report actual input values of CONFIG_FILES etc. instead of their
24288
# values after options handling.  Logging --version etc. is OK.
24289
exec 5>>config.log
24290
{
24291
  echo
24292
  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
24293
## Running $as_me. ##
24294
_ASBOX
24295
} >&5
24296
cat >&5 <<_CSEOF
24297
 
24298
This file was extended by GNU Fortran Runtime Library $as_me 0.2, which was
24299
generated by GNU Autoconf 2.59.  Invocation command line was
24300
 
24301
  CONFIG_FILES    = $CONFIG_FILES
24302
  CONFIG_HEADERS  = $CONFIG_HEADERS
24303
  CONFIG_LINKS    = $CONFIG_LINKS
24304
  CONFIG_COMMANDS = $CONFIG_COMMANDS
24305
  $ $0 $@
24306
 
24307
_CSEOF
24308
echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
24309
echo >&5
24310
_ACEOF
24311
 
24312
# Files that config.status was made for.
24313
if test -n "$ac_config_files"; then
24314
  echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
24315
fi
24316
 
24317
if test -n "$ac_config_headers"; then
24318
  echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
24319
fi
24320
 
24321
if test -n "$ac_config_links"; then
24322
  echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
24323
fi
24324
 
24325
if test -n "$ac_config_commands"; then
24326
  echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
24327
fi
24328
 
24329
cat >>$CONFIG_STATUS <<\_ACEOF
24330
 
24331
ac_cs_usage="\
24332
\`$as_me' instantiates files from templates according to the
24333
current configuration.
24334
 
24335
Usage: $0 [OPTIONS] [FILE]...
24336
 
24337
  -h, --help       print this help, then exit
24338
  -V, --version    print version number, then exit
24339
  -q, --quiet      do not print progress messages
24340
  -d, --debug      don't remove temporary files
24341
      --recheck    update $as_me by reconfiguring in the same conditions
24342
  --file=FILE[:TEMPLATE]
24343
                   instantiate the configuration file FILE
24344
  --header=FILE[:TEMPLATE]
24345
                   instantiate the configuration header FILE
24346
 
24347
Configuration files:
24348
$config_files
24349
 
24350
Configuration headers:
24351
$config_headers
24352
 
24353
Configuration commands:
24354
$config_commands
24355
 
24356
Report bugs to ."
24357
_ACEOF
24358
 
24359
cat >>$CONFIG_STATUS <<_ACEOF
24360
ac_cs_version="\\
24361
GNU Fortran Runtime Library config.status 0.2
24362
configured by $0, generated by GNU Autoconf 2.59,
24363
  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
24364
 
24365
Copyright (C) 2003 Free Software Foundation, Inc.
24366
This config.status script is free software; the Free Software Foundation
24367
gives unlimited permission to copy, distribute and modify it."
24368
srcdir=$srcdir
24369
INSTALL="$INSTALL"
24370
_ACEOF
24371
 
24372
cat >>$CONFIG_STATUS <<\_ACEOF
24373
# If no file are specified by the user, then we need to provide default
24374
# value.  By we need to know if files were specified by the user.
24375
ac_need_defaults=:
24376
while test $# != 0
24377
do
24378
  case $1 in
24379
  --*=*)
24380
    ac_option=`expr "x$1" : 'x\([^=]*\)='`
24381
    ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
24382
    ac_shift=:
24383
    ;;
24384
  -*)
24385
    ac_option=$1
24386
    ac_optarg=$2
24387
    ac_shift=shift
24388
    ;;
24389
  *) # This is not an option, so the user has probably given explicit
24390
     # arguments.
24391
     ac_option=$1
24392
     ac_need_defaults=false;;
24393
  esac
24394
 
24395
  case $ac_option in
24396
  # Handling of the options.
24397
_ACEOF
24398
cat >>$CONFIG_STATUS <<\_ACEOF
24399
  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
24400
    ac_cs_recheck=: ;;
24401
  --version | --vers* | -V )
24402
    echo "$ac_cs_version"; exit 0 ;;
24403
  --he | --h)
24404
    # Conflict between --help and --header
24405
    { { echo "$as_me:$LINENO: error: ambiguous option: $1
24406
Try \`$0 --help' for more information." >&5
24407
echo "$as_me: error: ambiguous option: $1
24408
Try \`$0 --help' for more information." >&2;}
24409
   { (exit 1); exit 1; }; };;
24410
  --help | --hel | -h )
24411
    echo "$ac_cs_usage"; exit 0 ;;
24412
  --debug | --d* | -d )
24413
    debug=: ;;
24414
  --file | --fil | --fi | --f )
24415
    $ac_shift
24416
    CONFIG_FILES="$CONFIG_FILES $ac_optarg"
24417
    ac_need_defaults=false;;
24418
  --header | --heade | --head | --hea )
24419
    $ac_shift
24420
    CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
24421
    ac_need_defaults=false;;
24422
  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
24423
  | -silent | --silent | --silen | --sile | --sil | --si | --s)
24424
    ac_cs_silent=: ;;
24425
 
24426
  # This is an error.
24427
  -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
24428
Try \`$0 --help' for more information." >&5
24429
echo "$as_me: error: unrecognized option: $1
24430
Try \`$0 --help' for more information." >&2;}
24431
   { (exit 1); exit 1; }; } ;;
24432
 
24433
  *) ac_config_targets="$ac_config_targets $1" ;;
24434
 
24435
  esac
24436
  shift
24437
done
24438
 
24439
ac_configure_extra_args=
24440
 
24441
if $ac_cs_silent; then
24442
  exec 6>/dev/null
24443
  ac_configure_extra_args="$ac_configure_extra_args --silent"
24444
fi
24445
 
24446
_ACEOF
24447
cat >>$CONFIG_STATUS <<_ACEOF
24448
if \$ac_cs_recheck; then
24449
  echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
24450
  exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
24451
fi
24452
 
24453
_ACEOF
24454
 
24455
cat >>$CONFIG_STATUS <<_ACEOF
24456
#
24457
# INIT-COMMANDS section.
24458
#
24459
 
24460
 
24461
srcdir="$srcdir"
24462
host="$host"
24463
target="$target"
24464
with_multisubdir="$with_multisubdir"
24465
with_multisrctop="$with_multisrctop"
24466
with_target_subdir="$with_target_subdir"
24467
ac_configure_args="${multilib_arg} ${ac_configure_args}"
24468
multi_basedir="$multi_basedir"
24469
CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
24470
CC="$CC"
24471
 
24472
GCC="$GCC"
24473
CC="$CC"
24474
acx_cv_header_stdint="$acx_cv_header_stdint"
24475
acx_cv_type_int8_t="$acx_cv_type_int8_t"
24476
acx_cv_type_int16_t="$acx_cv_type_int16_t"
24477
acx_cv_type_int32_t="$acx_cv_type_int32_t"
24478
acx_cv_type_int64_t="$acx_cv_type_int64_t"
24479
acx_cv_type_intptr_t="$acx_cv_type_intptr_t"
24480
ac_cv_type_uintmax_t="$ac_cv_type_uintmax_t"
24481
ac_cv_type_uintptr_t="$ac_cv_type_uintptr_t"
24482
ac_cv_type_uint64_t="$ac_cv_type_uint64_t"
24483
ac_cv_type_u_int64_t="$ac_cv_type_u_int64_t"
24484
ac_cv_type_u_int32_t="$ac_cv_type_u_int32_t"
24485
ac_cv_type_int_least32_t="$ac_cv_type_int_least32_t"
24486
ac_cv_type_int_fast32_t="$ac_cv_type_int_fast32_t"
24487
ac_cv_sizeof_void_p="$ac_cv_sizeof_void_p"
24488
 
24489
 
24490
_ACEOF
24491
 
24492
 
24493
 
24494
cat >>$CONFIG_STATUS <<\_ACEOF
24495
for ac_config_target in $ac_config_targets
24496
do
24497
  case "$ac_config_target" in
24498
  # Handling of arguments.
24499
  "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
24500
  "default-1" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default-1" ;;
24501
  "gstdint.h" ) CONFIG_COMMANDS="$CONFIG_COMMANDS gstdint.h" ;;
24502
  "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
24503
  *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
24504
echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
24505
   { (exit 1); exit 1; }; };;
24506
  esac
24507
done
24508
 
24509
# If the user did not use the arguments to specify the items to instantiate,
24510
# then the envvar interface is used.  Set only those that are not.
24511
# We use the long form for the default assignment because of an extremely
24512
# bizarre bug on SunOS 4.1.3.
24513
if $ac_need_defaults; then
24514
  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
24515
  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
24516
  test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
24517
fi
24518
 
24519
# Have a temporary directory for convenience.  Make it in the build tree
24520
# simply because there is no reason to put it here, and in addition,
24521
# creating and moving files from /tmp can sometimes cause problems.
24522
# Create a temporary directory, and hook for its removal unless debugging.
24523
$debug ||
24524
{
24525
  trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
24526
  trap '{ (exit 1); exit 1; }' 1 2 13 15
24527
}
24528
 
24529
# Create a (secure) tmp directory for tmp files.
24530
 
24531
{
24532
  tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
24533
  test -n "$tmp" && test -d "$tmp"
24534
}  ||
24535
{
24536
  tmp=./confstat$$-$RANDOM
24537
  (umask 077 && mkdir $tmp)
24538
} ||
24539
{
24540
   echo "$me: cannot create a temporary directory in ." >&2
24541
   { (exit 1); exit 1; }
24542
}
24543
 
24544
_ACEOF
24545
 
24546
cat >>$CONFIG_STATUS <<_ACEOF
24547
 
24548
#
24549
# CONFIG_FILES section.
24550
#
24551
 
24552
# No need to generate the scripts if there are no CONFIG_FILES.
24553
# This happens for instance when ./config.status config.h
24554
if test -n "\$CONFIG_FILES"; then
24555
  # Protect against being on the right side of a sed subst in config.status.
24556
  sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
24557
   s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
24558
s,@SHELL@,$SHELL,;t t
24559
s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
24560
s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
24561
s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
24562
s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
24563
s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
24564
s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
24565
s,@exec_prefix@,$exec_prefix,;t t
24566
s,@prefix@,$prefix,;t t
24567
s,@program_transform_name@,$program_transform_name,;t t
24568
s,@bindir@,$bindir,;t t
24569
s,@sbindir@,$sbindir,;t t
24570
s,@libexecdir@,$libexecdir,;t t
24571
s,@datadir@,$datadir,;t t
24572
s,@sysconfdir@,$sysconfdir,;t t
24573
s,@sharedstatedir@,$sharedstatedir,;t t
24574
s,@localstatedir@,$localstatedir,;t t
24575
s,@libdir@,$libdir,;t t
24576
s,@includedir@,$includedir,;t t
24577
s,@oldincludedir@,$oldincludedir,;t t
24578
s,@infodir@,$infodir,;t t
24579
s,@mandir@,$mandir,;t t
24580
s,@build_alias@,$build_alias,;t t
24581
s,@host_alias@,$host_alias,;t t
24582
s,@target_alias@,$target_alias,;t t
24583
s,@DEFS@,$DEFS,;t t
24584
s,@ECHO_C@,$ECHO_C,;t t
24585
s,@ECHO_N@,$ECHO_N,;t t
24586
s,@ECHO_T@,$ECHO_T,;t t
24587
s,@LIBS@,$LIBS,;t t
24588
s,@build@,$build,;t t
24589
s,@build_cpu@,$build_cpu,;t t
24590
s,@build_vendor@,$build_vendor,;t t
24591
s,@build_os@,$build_os,;t t
24592
s,@build_subdir@,$build_subdir,;t t
24593
s,@host_subdir@,$host_subdir,;t t
24594
s,@target_subdir@,$target_subdir,;t t
24595
s,@host@,$host,;t t
24596
s,@host_cpu@,$host_cpu,;t t
24597
s,@host_vendor@,$host_vendor,;t t
24598
s,@host_os@,$host_os,;t t
24599
s,@target@,$target,;t t
24600
s,@target_cpu@,$target_cpu,;t t
24601
s,@target_vendor@,$target_vendor,;t t
24602
s,@target_os@,$target_os,;t t
24603
s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
24604
s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
24605
s,@INSTALL_DATA@,$INSTALL_DATA,;t t
24606
s,@CYGPATH_W@,$CYGPATH_W,;t t
24607
s,@PACKAGE@,$PACKAGE,;t t
24608
s,@VERSION@,$VERSION,;t t
24609
s,@ACLOCAL@,$ACLOCAL,;t t
24610
s,@AUTOCONF@,$AUTOCONF,;t t
24611
s,@AUTOMAKE@,$AUTOMAKE,;t t
24612
s,@AUTOHEADER@,$AUTOHEADER,;t t
24613
s,@MAKEINFO@,$MAKEINFO,;t t
24614
s,@install_sh@,$install_sh,;t t
24615
s,@STRIP@,$STRIP,;t t
24616
s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t
24617
s,@INSTALL_STRIP_PROGRAM@,$INSTALL_STRIP_PROGRAM,;t t
24618
s,@mkdir_p@,$mkdir_p,;t t
24619
s,@AWK@,$AWK,;t t
24620
s,@SET_MAKE@,$SET_MAKE,;t t
24621
s,@am__leading_dot@,$am__leading_dot,;t t
24622
s,@AMTAR@,$AMTAR,;t t
24623
s,@am__tar@,$am__tar,;t t
24624
s,@am__untar@,$am__untar,;t t
24625
s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
24626
s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
24627
s,@MAINT@,$MAINT,;t t
24628
s,@multi_basedir@,$multi_basedir,;t t
24629
s,@toolexecdir@,$toolexecdir,;t t
24630
s,@toolexeclibdir@,$toolexeclibdir,;t t
24631
s,@CC@,$CC,;t t
24632
s,@ac_ct_CC@,$ac_ct_CC,;t t
24633
s,@EXEEXT@,$EXEEXT,;t t
24634
s,@OBJEXT@,$OBJEXT,;t t
24635
s,@AM_FCFLAGS@,$AM_FCFLAGS,;t t
24636
s,@AM_CFLAGS@,$AM_CFLAGS,;t t
24637
s,@AS@,$AS,;t t
24638
s,@ac_ct_AS@,$ac_ct_AS,;t t
24639
s,@AR@,$AR,;t t
24640
s,@ac_ct_AR@,$ac_ct_AR,;t t
24641
s,@RANLIB@,$RANLIB,;t t
24642
s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
24643
s,@LN_S@,$LN_S,;t t
24644
s,@LIBTOOL@,$LIBTOOL,;t t
24645
s,@enable_shared@,$enable_shared,;t t
24646
s,@enable_static@,$enable_static,;t t
24647
s,@FC@,$FC,;t t
24648
s,@FCFLAGS@,$FCFLAGS,;t t
24649
s,@LDFLAGS@,$LDFLAGS,;t t
24650
s,@ac_ct_FC@,$ac_ct_FC,;t t
24651
s,@extra_ldflags_libgfortran@,$extra_ldflags_libgfortran,;t t
24652
s,@CPP@,$CPP,;t t
24653
s,@CPPFLAGS@,$CPPFLAGS,;t t
24654
s,@EGREP@,$EGREP,;t t
24655
s,@FPU_HOST_HEADER@,$FPU_HOST_HEADER,;t t
24656
s,@LIBOBJS@,$LIBOBJS,;t t
24657
s,@LTLIBOBJS@,$LTLIBOBJS,;t t
24658
CEOF
24659
 
24660
_ACEOF
24661
 
24662
  cat >>$CONFIG_STATUS <<\_ACEOF
24663
  # Split the substitutions into bite-sized pieces for seds with
24664
  # small command number limits, like on Digital OSF/1 and HP-UX.
24665
  ac_max_sed_lines=48
24666
  ac_sed_frag=1 # Number of current file.
24667
  ac_beg=1 # First line for current file.
24668
  ac_end=$ac_max_sed_lines # Line after last line for current file.
24669
  ac_more_lines=:
24670
  ac_sed_cmds=
24671
  while $ac_more_lines; do
24672
    if test $ac_beg -gt 1; then
24673
      sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
24674
    else
24675
      sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
24676
    fi
24677
    if test ! -s $tmp/subs.frag; then
24678
      ac_more_lines=false
24679
    else
24680
      # The purpose of the label and of the branching condition is to
24681
      # speed up the sed processing (if there are no `@' at all, there
24682
      # is no need to browse any of the substitutions).
24683
      # These are the two extra sed commands mentioned above.
24684
      (echo ':t
24685
  /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
24686
      if test -z "$ac_sed_cmds"; then
24687
        ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
24688
      else
24689
        ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
24690
      fi
24691
      ac_sed_frag=`expr $ac_sed_frag + 1`
24692
      ac_beg=$ac_end
24693
      ac_end=`expr $ac_end + $ac_max_sed_lines`
24694
    fi
24695
  done
24696
  if test -z "$ac_sed_cmds"; then
24697
    ac_sed_cmds=cat
24698
  fi
24699
fi # test -n "$CONFIG_FILES"
24700
 
24701
_ACEOF
24702
cat >>$CONFIG_STATUS <<\_ACEOF
24703
for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
24704
  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
24705
  case $ac_file in
24706
  - | *:- | *:-:* ) # input from stdin
24707
        cat >$tmp/stdin
24708
        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
24709
        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
24710
  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
24711
        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
24712
  * )   ac_file_in=$ac_file.in ;;
24713
  esac
24714
 
24715
  # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
24716
  ac_dir=`(dirname "$ac_file") 2>/dev/null ||
24717
$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
24718
         X"$ac_file" : 'X\(//\)[^/]' \| \
24719
         X"$ac_file" : 'X\(//\)$' \| \
24720
         X"$ac_file" : 'X\(/\)' \| \
24721
         .     : '\(.\)' 2>/dev/null ||
24722
echo X"$ac_file" |
24723
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
24724
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
24725
          /^X\(\/\/\)$/{ s//\1/; q; }
24726
          /^X\(\/\).*/{ s//\1/; q; }
24727
          s/.*/./; q'`
24728
  { if $as_mkdir_p; then
24729
    mkdir -p "$ac_dir"
24730
  else
24731
    as_dir="$ac_dir"
24732
    as_dirs=
24733
    while test ! -d "$as_dir"; do
24734
      as_dirs="$as_dir $as_dirs"
24735
      as_dir=`(dirname "$as_dir") 2>/dev/null ||
24736
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
24737
         X"$as_dir" : 'X\(//\)[^/]' \| \
24738
         X"$as_dir" : 'X\(//\)$' \| \
24739
         X"$as_dir" : 'X\(/\)' \| \
24740
         .     : '\(.\)' 2>/dev/null ||
24741
echo X"$as_dir" |
24742
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
24743
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
24744
          /^X\(\/\/\)$/{ s//\1/; q; }
24745
          /^X\(\/\).*/{ s//\1/; q; }
24746
          s/.*/./; q'`
24747
    done
24748
    test ! -n "$as_dirs" || mkdir $as_dirs
24749
  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
24750
echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
24751
   { (exit 1); exit 1; }; }; }
24752
 
24753
  ac_builddir=.
24754
 
24755
if test "$ac_dir" != .; then
24756
  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
24757
  # A "../" for each directory in $ac_dir_suffix.
24758
  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
24759
else
24760
  ac_dir_suffix= ac_top_builddir=
24761
fi
24762
 
24763
case $srcdir in
24764
  .)  # No --srcdir option.  We are building in place.
24765
    ac_srcdir=.
24766
    if test -z "$ac_top_builddir"; then
24767
       ac_top_srcdir=.
24768
    else
24769
       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
24770
    fi ;;
24771
  [\\/]* | ?:[\\/]* )  # Absolute path.
24772
    ac_srcdir=$srcdir$ac_dir_suffix;
24773
    ac_top_srcdir=$srcdir ;;
24774
  *) # Relative path.
24775
    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
24776
    ac_top_srcdir=$ac_top_builddir$srcdir ;;
24777
esac
24778
 
24779
# Do not use `cd foo && pwd` to compute absolute paths, because
24780
# the directories may not exist.
24781
case `pwd` in
24782
.) ac_abs_builddir="$ac_dir";;
24783
*)
24784
  case "$ac_dir" in
24785
  .) ac_abs_builddir=`pwd`;;
24786
  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
24787
  *) ac_abs_builddir=`pwd`/"$ac_dir";;
24788
  esac;;
24789
esac
24790
case $ac_abs_builddir in
24791
.) ac_abs_top_builddir=${ac_top_builddir}.;;
24792
*)
24793
  case ${ac_top_builddir}. in
24794
  .) ac_abs_top_builddir=$ac_abs_builddir;;
24795
  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
24796
  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
24797
  esac;;
24798
esac
24799
case $ac_abs_builddir in
24800
.) ac_abs_srcdir=$ac_srcdir;;
24801
*)
24802
  case $ac_srcdir in
24803
  .) ac_abs_srcdir=$ac_abs_builddir;;
24804
  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
24805
  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
24806
  esac;;
24807
esac
24808
case $ac_abs_builddir in
24809
.) ac_abs_top_srcdir=$ac_top_srcdir;;
24810
*)
24811
  case $ac_top_srcdir in
24812
  .) ac_abs_top_srcdir=$ac_abs_builddir;;
24813
  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
24814
  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
24815
  esac;;
24816
esac
24817
 
24818
 
24819
  case $INSTALL in
24820
  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
24821
  *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
24822
  esac
24823
 
24824
  if test x"$ac_file" != x-; then
24825
    { echo "$as_me:$LINENO: creating $ac_file" >&5
24826
echo "$as_me: creating $ac_file" >&6;}
24827
    rm -f "$ac_file"
24828
  fi
24829
  # Let's still pretend it is `configure' which instantiates (i.e., don't
24830
  # use $as_me), people would be surprised to read:
24831
  #    /* config.h.  Generated by config.status.  */
24832
  if test x"$ac_file" = x-; then
24833
    configure_input=
24834
  else
24835
    configure_input="$ac_file.  "
24836
  fi
24837
  configure_input=$configure_input"Generated from `echo $ac_file_in |
24838
                                     sed 's,.*/,,'` by configure."
24839
 
24840
  # First look for the input files in the build tree, otherwise in the
24841
  # src tree.
24842
  ac_file_inputs=`IFS=:
24843
    for f in $ac_file_in; do
24844
      case $f in
24845
      -) echo $tmp/stdin ;;
24846
      [\\/$]*)
24847
         # Absolute (can't be DOS-style, as IFS=:)
24848
         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
24849
echo "$as_me: error: cannot find input file: $f" >&2;}
24850
   { (exit 1); exit 1; }; }
24851
         echo "$f";;
24852
      *) # Relative
24853
         if test -f "$f"; then
24854
           # Build tree
24855
           echo "$f"
24856
         elif test -f "$srcdir/$f"; then
24857
           # Source tree
24858
           echo "$srcdir/$f"
24859
         else
24860
           # /dev/null tree
24861
           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
24862
echo "$as_me: error: cannot find input file: $f" >&2;}
24863
   { (exit 1); exit 1; }; }
24864
         fi;;
24865
      esac
24866
    done` || { (exit 1); exit 1; }
24867
_ACEOF
24868
cat >>$CONFIG_STATUS <<_ACEOF
24869
  sed "$ac_vpsub
24870
$extrasub
24871
_ACEOF
24872
cat >>$CONFIG_STATUS <<\_ACEOF
24873
:t
24874
/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
24875
s,@configure_input@,$configure_input,;t t
24876
s,@srcdir@,$ac_srcdir,;t t
24877
s,@abs_srcdir@,$ac_abs_srcdir,;t t
24878
s,@top_srcdir@,$ac_top_srcdir,;t t
24879
s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
24880
s,@builddir@,$ac_builddir,;t t
24881
s,@abs_builddir@,$ac_abs_builddir,;t t
24882
s,@top_builddir@,$ac_top_builddir,;t t
24883
s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
24884
s,@INSTALL@,$ac_INSTALL,;t t
24885
" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
24886
  rm -f $tmp/stdin
24887
  if test x"$ac_file" != x-; then
24888
    mv $tmp/out $ac_file
24889
  else
24890
    cat $tmp/out
24891
    rm -f $tmp/out
24892
  fi
24893
 
24894
done
24895
_ACEOF
24896
cat >>$CONFIG_STATUS <<\_ACEOF
24897
 
24898
#
24899
# CONFIG_HEADER section.
24900
#
24901
 
24902
# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
24903
# NAME is the cpp macro being defined and VALUE is the value it is being given.
24904
#
24905
# ac_d sets the value in "#define NAME VALUE" lines.
24906
ac_dA='s,^\([    ]*\)#\([        ]*define[       ][      ]*\)'
24907
ac_dB='[         ].*$,\1#\2'
24908
ac_dC=' '
24909
ac_dD=',;t'
24910
# ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
24911
ac_uA='s,^\([    ]*\)#\([        ]*\)undef\([    ][      ]*\)'
24912
ac_uB='$,\1#\2define\3'
24913
ac_uC=' '
24914
ac_uD=',;t'
24915
 
24916
for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue
24917
  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
24918
  case $ac_file in
24919
  - | *:- | *:-:* ) # input from stdin
24920
        cat >$tmp/stdin
24921
        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
24922
        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
24923
  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
24924
        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
24925
  * )   ac_file_in=$ac_file.in ;;
24926
  esac
24927
 
24928
  test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5
24929
echo "$as_me: creating $ac_file" >&6;}
24930
 
24931
  # First look for the input files in the build tree, otherwise in the
24932
  # src tree.
24933
  ac_file_inputs=`IFS=:
24934
    for f in $ac_file_in; do
24935
      case $f in
24936
      -) echo $tmp/stdin ;;
24937
      [\\/$]*)
24938
         # Absolute (can't be DOS-style, as IFS=:)
24939
         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
24940
echo "$as_me: error: cannot find input file: $f" >&2;}
24941
   { (exit 1); exit 1; }; }
24942
         # Do quote $f, to prevent DOS paths from being IFS'd.
24943
         echo "$f";;
24944
      *) # Relative
24945
         if test -f "$f"; then
24946
           # Build tree
24947
           echo "$f"
24948
         elif test -f "$srcdir/$f"; then
24949
           # Source tree
24950
           echo "$srcdir/$f"
24951
         else
24952
           # /dev/null tree
24953
           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
24954
echo "$as_me: error: cannot find input file: $f" >&2;}
24955
   { (exit 1); exit 1; }; }
24956
         fi;;
24957
      esac
24958
    done` || { (exit 1); exit 1; }
24959
  # Remove the trailing spaces.
24960
  sed 's/[       ]*$//' $ac_file_inputs >$tmp/in
24961
 
24962
_ACEOF
24963
 
24964
# Transform confdefs.h into two sed scripts, `conftest.defines' and
24965
# `conftest.undefs', that substitutes the proper values into
24966
# config.h.in to produce config.h.  The first handles `#define'
24967
# templates, and the second `#undef' templates.
24968
# And first: Protect against being on the right side of a sed subst in
24969
# config.status.  Protect against being in an unquoted here document
24970
# in config.status.
24971
rm -f conftest.defines conftest.undefs
24972
# Using a here document instead of a string reduces the quoting nightmare.
24973
# Putting comments in sed scripts is not portable.
24974
#
24975
# `end' is used to avoid that the second main sed command (meant for
24976
# 0-ary CPP macros) applies to n-ary macro definitions.
24977
# See the Autoconf documentation for `clear'.
24978
cat >confdef2sed.sed <<\_ACEOF
24979
s/[\\&,]/\\&/g
24980
s,[\\$`],\\&,g
24981
t clear
24982
: clear
24983
s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
24984
t end
24985
s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
24986
: end
24987
_ACEOF
24988
# If some macros were called several times there might be several times
24989
# the same #defines, which is useless.  Nevertheless, we may not want to
24990
# sort them, since we want the *last* AC-DEFINE to be honored.
24991
uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines
24992
sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs
24993
rm -f confdef2sed.sed
24994
 
24995
# This sed command replaces #undef with comments.  This is necessary, for
24996
# example, in the case of _POSIX_SOURCE, which is predefined and required
24997
# on some systems where configure will not decide to define it.
24998
cat >>conftest.undefs <<\_ACEOF
24999
s,^[     ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
25000
_ACEOF
25001
 
25002
# Break up conftest.defines because some shells have a limit on the size
25003
# of here documents, and old seds have small limits too (100 cmds).
25004
echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
25005
echo '  if grep "^[      ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
25006
echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
25007
echo '  :' >>$CONFIG_STATUS
25008
rm -f conftest.tail
25009
while grep . conftest.defines >/dev/null
25010
do
25011
  # Write a limited-size here document to $tmp/defines.sed.
25012
  echo '  cat >$tmp/defines.sed <>$CONFIG_STATUS
25013
  # Speed up: don't consider the non `#define' lines.
25014
  echo '/^[      ]*#[    ]*define/!b' >>$CONFIG_STATUS
25015
  # Work around the forget-to-reset-the-flag bug.
25016
  echo 't clr' >>$CONFIG_STATUS
25017
  echo ': clr' >>$CONFIG_STATUS
25018
  sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS
25019
  echo 'CEOF
25020
  sed -f $tmp/defines.sed $tmp/in >$tmp/out
25021
  rm -f $tmp/in
25022
  mv $tmp/out $tmp/in
25023
' >>$CONFIG_STATUS
25024
  sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail
25025
  rm -f conftest.defines
25026
  mv conftest.tail conftest.defines
25027
done
25028
rm -f conftest.defines
25029
echo '  fi # grep' >>$CONFIG_STATUS
25030
echo >>$CONFIG_STATUS
25031
 
25032
# Break up conftest.undefs because some shells have a limit on the size
25033
# of here documents, and old seds have small limits too (100 cmds).
25034
echo '  # Handle all the #undef templates' >>$CONFIG_STATUS
25035
rm -f conftest.tail
25036
while grep . conftest.undefs >/dev/null
25037
do
25038
  # Write a limited-size here document to $tmp/undefs.sed.
25039
  echo '  cat >$tmp/undefs.sed <>$CONFIG_STATUS
25040
  # Speed up: don't consider the non `#undef'
25041
  echo '/^[      ]*#[    ]*undef/!b' >>$CONFIG_STATUS
25042
  # Work around the forget-to-reset-the-flag bug.
25043
  echo 't clr' >>$CONFIG_STATUS
25044
  echo ': clr' >>$CONFIG_STATUS
25045
  sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS
25046
  echo 'CEOF
25047
  sed -f $tmp/undefs.sed $tmp/in >$tmp/out
25048
  rm -f $tmp/in
25049
  mv $tmp/out $tmp/in
25050
' >>$CONFIG_STATUS
25051
  sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail
25052
  rm -f conftest.undefs
25053
  mv conftest.tail conftest.undefs
25054
done
25055
rm -f conftest.undefs
25056
 
25057
cat >>$CONFIG_STATUS <<\_ACEOF
25058
  # Let's still pretend it is `configure' which instantiates (i.e., don't
25059
  # use $as_me), people would be surprised to read:
25060
  #    /* config.h.  Generated by config.status.  */
25061
  if test x"$ac_file" = x-; then
25062
    echo "/* Generated by configure.  */" >$tmp/config.h
25063
  else
25064
    echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h
25065
  fi
25066
  cat $tmp/in >>$tmp/config.h
25067
  rm -f $tmp/in
25068
  if test x"$ac_file" != x-; then
25069
    if diff $ac_file $tmp/config.h >/dev/null 2>&1; then
25070
      { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
25071
echo "$as_me: $ac_file is unchanged" >&6;}
25072
    else
25073
      ac_dir=`(dirname "$ac_file") 2>/dev/null ||
25074
$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25075
         X"$ac_file" : 'X\(//\)[^/]' \| \
25076
         X"$ac_file" : 'X\(//\)$' \| \
25077
         X"$ac_file" : 'X\(/\)' \| \
25078
         .     : '\(.\)' 2>/dev/null ||
25079
echo X"$ac_file" |
25080
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25081
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25082
          /^X\(\/\/\)$/{ s//\1/; q; }
25083
          /^X\(\/\).*/{ s//\1/; q; }
25084
          s/.*/./; q'`
25085
      { if $as_mkdir_p; then
25086
    mkdir -p "$ac_dir"
25087
  else
25088
    as_dir="$ac_dir"
25089
    as_dirs=
25090
    while test ! -d "$as_dir"; do
25091
      as_dirs="$as_dir $as_dirs"
25092
      as_dir=`(dirname "$as_dir") 2>/dev/null ||
25093
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25094
         X"$as_dir" : 'X\(//\)[^/]' \| \
25095
         X"$as_dir" : 'X\(//\)$' \| \
25096
         X"$as_dir" : 'X\(/\)' \| \
25097
         .     : '\(.\)' 2>/dev/null ||
25098
echo X"$as_dir" |
25099
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25100
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25101
          /^X\(\/\/\)$/{ s//\1/; q; }
25102
          /^X\(\/\).*/{ s//\1/; q; }
25103
          s/.*/./; q'`
25104
    done
25105
    test ! -n "$as_dirs" || mkdir $as_dirs
25106
  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
25107
echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
25108
   { (exit 1); exit 1; }; }; }
25109
 
25110
      rm -f $ac_file
25111
      mv $tmp/config.h $ac_file
25112
    fi
25113
  else
25114
    cat $tmp/config.h
25115
    rm -f $tmp/config.h
25116
  fi
25117
# Compute $ac_file's index in $config_headers.
25118
_am_stamp_count=1
25119
for _am_header in $config_headers :; do
25120
  case $_am_header in
25121
    $ac_file | $ac_file:* )
25122
      break ;;
25123
    * )
25124
      _am_stamp_count=`expr $_am_stamp_count + 1` ;;
25125
  esac
25126
done
25127
echo "timestamp for $ac_file" >`(dirname $ac_file) 2>/dev/null ||
25128
$as_expr X$ac_file : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25129
         X$ac_file : 'X\(//\)[^/]' \| \
25130
         X$ac_file : 'X\(//\)$' \| \
25131
         X$ac_file : 'X\(/\)' \| \
25132
         .     : '\(.\)' 2>/dev/null ||
25133
echo X$ac_file |
25134
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25135
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25136
          /^X\(\/\/\)$/{ s//\1/; q; }
25137
          /^X\(\/\).*/{ s//\1/; q; }
25138
          s/.*/./; q'`/stamp-h$_am_stamp_count
25139
done
25140
_ACEOF
25141
cat >>$CONFIG_STATUS <<\_ACEOF
25142
 
25143
#
25144
# CONFIG_COMMANDS section.
25145
#
25146
for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue
25147
  ac_dest=`echo "$ac_file" | sed 's,:.*,,'`
25148
  ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`
25149
  ac_dir=`(dirname "$ac_dest") 2>/dev/null ||
25150
$as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25151
         X"$ac_dest" : 'X\(//\)[^/]' \| \
25152
         X"$ac_dest" : 'X\(//\)$' \| \
25153
         X"$ac_dest" : 'X\(/\)' \| \
25154
         .     : '\(.\)' 2>/dev/null ||
25155
echo X"$ac_dest" |
25156
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25157
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25158
          /^X\(\/\/\)$/{ s//\1/; q; }
25159
          /^X\(\/\).*/{ s//\1/; q; }
25160
          s/.*/./; q'`
25161
  { if $as_mkdir_p; then
25162
    mkdir -p "$ac_dir"
25163
  else
25164
    as_dir="$ac_dir"
25165
    as_dirs=
25166
    while test ! -d "$as_dir"; do
25167
      as_dirs="$as_dir $as_dirs"
25168
      as_dir=`(dirname "$as_dir") 2>/dev/null ||
25169
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
25170
         X"$as_dir" : 'X\(//\)[^/]' \| \
25171
         X"$as_dir" : 'X\(//\)$' \| \
25172
         X"$as_dir" : 'X\(/\)' \| \
25173
         .     : '\(.\)' 2>/dev/null ||
25174
echo X"$as_dir" |
25175
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
25176
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
25177
          /^X\(\/\/\)$/{ s//\1/; q; }
25178
          /^X\(\/\).*/{ s//\1/; q; }
25179
          s/.*/./; q'`
25180
    done
25181
    test ! -n "$as_dirs" || mkdir $as_dirs
25182
  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
25183
echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
25184
   { (exit 1); exit 1; }; }; }
25185
 
25186
  ac_builddir=.
25187
 
25188
if test "$ac_dir" != .; then
25189
  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
25190
  # A "../" for each directory in $ac_dir_suffix.
25191
  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
25192
else
25193
  ac_dir_suffix= ac_top_builddir=
25194
fi
25195
 
25196
case $srcdir in
25197
  .)  # No --srcdir option.  We are building in place.
25198
    ac_srcdir=.
25199
    if test -z "$ac_top_builddir"; then
25200
       ac_top_srcdir=.
25201
    else
25202
       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
25203
    fi ;;
25204
  [\\/]* | ?:[\\/]* )  # Absolute path.
25205
    ac_srcdir=$srcdir$ac_dir_suffix;
25206
    ac_top_srcdir=$srcdir ;;
25207
  *) # Relative path.
25208
    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
25209
    ac_top_srcdir=$ac_top_builddir$srcdir ;;
25210
esac
25211
 
25212
# Do not use `cd foo && pwd` to compute absolute paths, because
25213
# the directories may not exist.
25214
case `pwd` in
25215
.) ac_abs_builddir="$ac_dir";;
25216
*)
25217
  case "$ac_dir" in
25218
  .) ac_abs_builddir=`pwd`;;
25219
  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
25220
  *) ac_abs_builddir=`pwd`/"$ac_dir";;
25221
  esac;;
25222
esac
25223
case $ac_abs_builddir in
25224
.) ac_abs_top_builddir=${ac_top_builddir}.;;
25225
*)
25226
  case ${ac_top_builddir}. in
25227
  .) ac_abs_top_builddir=$ac_abs_builddir;;
25228
  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
25229
  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
25230
  esac;;
25231
esac
25232
case $ac_abs_builddir in
25233
.) ac_abs_srcdir=$ac_srcdir;;
25234
*)
25235
  case $ac_srcdir in
25236
  .) ac_abs_srcdir=$ac_abs_builddir;;
25237
  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
25238
  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
25239
  esac;;
25240
esac
25241
case $ac_abs_builddir in
25242
.) ac_abs_top_srcdir=$ac_top_srcdir;;
25243
*)
25244
  case $ac_top_srcdir in
25245
  .) ac_abs_top_srcdir=$ac_abs_builddir;;
25246
  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
25247
  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
25248
  esac;;
25249
esac
25250
 
25251
 
25252
  { echo "$as_me:$LINENO: executing $ac_dest commands" >&5
25253
echo "$as_me: executing $ac_dest commands" >&6;}
25254
  case $ac_dest in
25255
    default-1 )
25256
# Only add multilib support code if we just rebuilt the top-level
25257
# Makefile.
25258
case " $CONFIG_FILES " in
25259
 *" Makefile "*)
25260
   ac_file=Makefile . ${multi_basedir}/config-ml.in
25261
   ;;
25262
esac ;;
25263
    gstdint.h )
25264
if test "$GCC" = yes; then
25265
  echo "/* generated for " `$CC --version | sed 1q` "*/" > tmp-stdint.h
25266
else
25267
  echo "/* generated for $CC */" > tmp-stdint.h
25268
fi
25269
 
25270
sed 's/^ *//' >> tmp-stdint.h <
25271
 
25272
  #ifndef GCC_GENERATED_STDINT_H
25273
  #define GCC_GENERATED_STDINT_H 1
25274
 
25275
  #include 
25276
EOF
25277
 
25278
if test "$acx_cv_header_stdint" != stdint.h; then
25279
  echo "#include " >> tmp-stdint.h
25280
fi
25281
if test "$acx_cv_header_stdint" != stddef.h; then
25282
  echo "#include <$acx_cv_header_stdint>" >> tmp-stdint.h
25283
fi
25284
 
25285
sed 's/^ *//' >> tmp-stdint.h <
25286
  /* glibc uses these symbols as guards to prevent redefinitions.  */
25287
  #ifdef __int8_t_defined
25288
  #define _INT8_T
25289
  #define _INT16_T
25290
  #define _INT32_T
25291
  #endif
25292
  #ifdef __uint32_t_defined
25293
  #define _UINT32_T
25294
  #endif
25295
 
25296
EOF
25297
 
25298
# ----------------- done header, emit basic int types -------------
25299
if test "$acx_cv_header_stdint" = stddef.h; then
25300
  sed 's/^ *//' >> tmp-stdint.h <
25301
 
25302
    #ifndef _UINT8_T
25303
    #define _UINT8_T
25304
    typedef unsigned $acx_cv_type_int8_t uint8_t;
25305
    #endif
25306
 
25307
    #ifndef _UINT16_T
25308
    #define _UINT16_T
25309
    typedef unsigned $acx_cv_type_int16_t uint16_t;
25310
    #endif
25311
 
25312
    #ifndef _UINT32_T
25313
    #define _UINT32_T
25314
    typedef unsigned $acx_cv_type_int32_t uint32_t;
25315
    #endif
25316
 
25317
    #ifndef _INT8_T
25318
    #define _INT8_T
25319
    typedef $acx_cv_type_int8_t int8_t;
25320
    #endif
25321
 
25322
    #ifndef _INT16_T
25323
    #define _INT16_T
25324
    typedef $acx_cv_type_int16_t int16_t;
25325
    #endif
25326
 
25327
    #ifndef _INT32_T
25328
    #define _INT32_T
25329
    typedef $acx_cv_type_int32_t int32_t;
25330
    #endif
25331
EOF
25332
elif test "$ac_cv_type_u_int32_t" = yes; then
25333
  sed 's/^ *//' >> tmp-stdint.h <
25334
 
25335
    /* int8_t int16_t int32_t defined by inet code, we do the u_intXX types */
25336
    #ifndef _INT8_T
25337
    #define _INT8_T
25338
    #endif
25339
    #ifndef _INT16_T
25340
    #define _INT16_T
25341
    #endif
25342
    #ifndef _INT32_T
25343
    #define _INT32_T
25344
    #endif
25345
 
25346
    #ifndef _UINT8_T
25347
    #define _UINT8_T
25348
    typedef u_int8_t uint8_t;
25349
    #endif
25350
 
25351
    #ifndef _UINT16_T
25352
    #define _UINT16_T
25353
    typedef u_int16_t uint16_t;
25354
    #endif
25355
 
25356
    #ifndef _UINT32_T
25357
    #define _UINT32_T
25358
    typedef u_int32_t uint32_t;
25359
    #endif
25360
EOF
25361
else
25362
  sed 's/^ *//' >> tmp-stdint.h <
25363
 
25364
    /* Some systems have guard macros to prevent redefinitions, define them.  */
25365
    #ifndef _INT8_T
25366
    #define _INT8_T
25367
    #endif
25368
    #ifndef _INT16_T
25369
    #define _INT16_T
25370
    #endif
25371
    #ifndef _INT32_T
25372
    #define _INT32_T
25373
    #endif
25374
    #ifndef _UINT8_T
25375
    #define _UINT8_T
25376
    #endif
25377
    #ifndef _UINT16_T
25378
    #define _UINT16_T
25379
    #endif
25380
    #ifndef _UINT32_T
25381
    #define _UINT32_T
25382
    #endif
25383
EOF
25384
fi
25385
 
25386
# ------------- done basic int types, emit int64_t types ------------
25387
if test "$ac_cv_type_uint64_t" = yes; then
25388
  sed 's/^ *//' >> tmp-stdint.h <
25389
 
25390
    /* system headers have good uint64_t and int64_t */
25391
    #ifndef _INT64_T
25392
    #define _INT64_T
25393
    #endif
25394
    #ifndef _UINT64_T
25395
    #define _UINT64_T
25396
    #endif
25397
EOF
25398
elif test "$ac_cv_type_u_int64_t" = yes; then
25399
  sed 's/^ *//' >> tmp-stdint.h <
25400
 
25401
    /* system headers have an u_int64_t (and int64_t) */
25402
    #ifndef _INT64_T
25403
    #define _INT64_T
25404
    #endif
25405
    #ifndef _UINT64_T
25406
    #define _UINT64_T
25407
    typedef u_int64_t uint64_t;
25408
    #endif
25409
EOF
25410
elif test -n "$acx_cv_type_int64_t"; then
25411
  sed 's/^ *//' >> tmp-stdint.h <
25412
 
25413
    /* architecture has a 64-bit type, $acx_cv_type_int64_t */
25414
    #ifndef _INT64_T
25415
    #define _INT64_T
25416
    typedef $acx_cv_type_int64_t int64_t;
25417
    #endif
25418
    #ifndef _UINT64_T
25419
    #define _UINT64_T
25420
    typedef unsigned $acx_cv_type_int64_t uint64_t;
25421
    #endif
25422
EOF
25423
else
25424
  sed 's/^ *//' >> tmp-stdint.h <
25425
 
25426
    /* some common heuristics for int64_t, using compiler-specific tests */
25427
    #if defined __STDC_VERSION__ && (__STDC_VERSION__-0) >= 199901L
25428
    #ifndef _INT64_T
25429
    #define _INT64_T
25430
    typedef long long int64_t;
25431
    #endif
25432
    #ifndef _UINT64_T
25433
    #define _UINT64_T
25434
    typedef unsigned long long uint64_t;
25435
    #endif
25436
 
25437
    #elif defined __GNUC__ && defined (__STDC__) && __STDC__-0
25438
    /* NextStep 2.0 cc is really gcc 1.93 but it defines __GNUC__ = 2 and
25439
       does not implement __extension__.  But that compiler doesn't define
25440
       __GNUC_MINOR__.  */
25441
    # if __GNUC__ < 2 || (__NeXT__ && !__GNUC_MINOR__)
25442
    # define __extension__
25443
    # endif
25444
 
25445
    # ifndef _INT64_T
25446
    # define _INT64_T
25447
    __extension__ typedef long long int64_t;
25448
    # endif
25449
    # ifndef _UINT64_T
25450
    # define _UINT64_T
25451
    __extension__ typedef unsigned long long uint64_t;
25452
    # endif
25453
 
25454
    #elif !defined __STRICT_ANSI__
25455
    # if defined _MSC_VER || defined __WATCOMC__ || defined __BORLANDC__
25456
 
25457
    #  ifndef _INT64_T
25458
    #  define _INT64_T
25459
    typedef __int64 int64_t;
25460
    #  endif
25461
    #  ifndef _UINT64_T
25462
    #  define _UINT64_T
25463
    typedef unsigned __int64 uint64_t;
25464
    #  endif
25465
    # endif /* compiler */
25466
 
25467
    #endif /* ANSI version */
25468
EOF
25469
fi
25470
 
25471
# ------------- done int64_t types, emit intptr types ------------
25472
if test "$ac_cv_type_uintptr_t" != yes; then
25473
  sed 's/^ *//' >> tmp-stdint.h <
25474
 
25475
    /* Define intptr_t based on sizeof(void*) = $ac_cv_sizeof_void_p */
25476
    typedef u$acx_cv_type_intptr_t uintptr_t;
25477
    typedef $acx_cv_type_intptr_t  intptr_t;
25478
EOF
25479
fi
25480
 
25481
# ------------- done intptr types, emit int_least types ------------
25482
if test "$ac_cv_type_int_least32_t" != yes; then
25483
  sed 's/^ *//' >> tmp-stdint.h <
25484
 
25485
    /* Define int_least types */
25486
    typedef int8_t     int_least8_t;
25487
    typedef int16_t    int_least16_t;
25488
    typedef int32_t    int_least32_t;
25489
    #ifdef _INT64_T
25490
    typedef int64_t    int_least64_t;
25491
    #endif
25492
 
25493
    typedef uint8_t    uint_least8_t;
25494
    typedef uint16_t   uint_least16_t;
25495
    typedef uint32_t   uint_least32_t;
25496
    #ifdef _UINT64_T
25497
    typedef uint64_t   uint_least64_t;
25498
    #endif
25499
EOF
25500
fi
25501
 
25502
# ------------- done intptr types, emit int_fast types ------------
25503
if test "$ac_cv_type_int_fast32_t" != yes; then
25504
      sed 's/^ *//' >> tmp-stdint.h <
25505
 
25506
    /* Define int_fast types.  short is often slow */
25507
    typedef int8_t       int_fast8_t;
25508
    typedef int          int_fast16_t;
25509
    typedef int32_t      int_fast32_t;
25510
    #ifdef _INT64_T
25511
    typedef int64_t      int_fast64_t;
25512
    #endif
25513
 
25514
    typedef uint8_t      uint_fast8_t;
25515
    typedef unsigned int uint_fast16_t;
25516
    typedef uint32_t     uint_fast32_t;
25517
    #ifdef _UINT64_T
25518
    typedef uint64_t     uint_fast64_t;
25519
    #endif
25520
EOF
25521
fi
25522
 
25523
if test "$ac_cv_type_uintmax_t" != yes; then
25524
  sed 's/^ *//' >> tmp-stdint.h <
25525
 
25526
    /* Define intmax based on what we found */
25527
    #ifdef _INT64_T
25528
    typedef int64_t       intmax_t;
25529
    #else
25530
    typedef long          intmax_t;
25531
    #endif
25532
    #ifdef _UINT64_T
25533
    typedef uint64_t      uintmax_t;
25534
    #else
25535
    typedef unsigned long uintmax_t;
25536
    #endif
25537
EOF
25538
fi
25539
 
25540
sed 's/^ *//' >> tmp-stdint.h <
25541
 
25542
  #endif /* GCC_GENERATED_STDINT_H */
25543
EOF
25544
 
25545
if test -r gstdint.h && cmp -s tmp-stdint.h gstdint.h; then
25546
  rm -f tmp-stdint.h
25547
else
25548
  mv -f tmp-stdint.h gstdint.h
25549
fi
25550
 
25551
 ;;
25552
  esac
25553
done
25554
_ACEOF
25555
 
25556
cat >>$CONFIG_STATUS <<\_ACEOF
25557
 
25558
{ (exit 0); exit 0; }
25559
_ACEOF
25560
chmod +x $CONFIG_STATUS
25561
ac_clean_files=$ac_clean_files_save
25562
 
25563
 
25564
# configure is writing to config.log, and then calls config.status.
25565
# config.status does its own redirection, appending to config.log.
25566
# Unfortunately, on DOS this fails, as config.log is still kept open
25567
# by configure, so config.status won't be able to write to it; its
25568
# output is simply discarded.  So we exec the FD to /dev/null,
25569
# effectively closing config.log, so it can be properly (re)opened and
25570
# appended to by config.status.  When coming back to configure, we
25571
# need to make the FD available again.
25572
if test "$no_create" != yes; then
25573
  ac_cs_success=:
25574
  ac_config_status_args=
25575
  test "$silent" = yes &&
25576
    ac_config_status_args="$ac_config_status_args --quiet"
25577
  exec 5>/dev/null
25578
  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
25579
  exec 5>>config.log
25580
  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
25581
  # would make configure fail if this is the last instruction.
25582
  $ac_cs_success || { (exit 1); exit 1; }
25583
fi
25584
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.