← Back to branch summary

~vcs-imports/mammoth-replicator/trunk

« back to all changes in this revision

Viewing changes to configure

  • Committer: alvherre
  • Date: 2005-12-16 21:24:52 UTC
  • Revision ID: svn-v4:db760fc0-0f08-0410-9d63-cc6633f64896:trunk:1
Initial import of the REL8_0_3 sources from the Pgsql CVS repository.

Show diffs side-by-side

added added

removed removed

Lines of Context:
configure
 
1
#! /bin/sh
 
2
# Guess values for system-dependent variables and create Makefiles.
 
3
# Generated by GNU Autoconf 2.53 for PostgreSQL 8.0.3.
 
4
#
 
5
# Report bugs to <pgsql-bugs@postgresql.org>.
 
6
#
 
7
# Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002
 
8
# Free Software Foundation, Inc.
 
9
# This configure script is free software; the Free Software Foundation
 
10
# gives unlimited permission to copy, distribute and modify it.
 
11
#
 
12
# Copyright (c) 1996-2005, PostgreSQL Global Development Group
 
13
 
 
14
if expr a : '\(a\)' >/dev/null 2>&1; then
 
15
  as_expr=expr
 
16
else
 
17
  as_expr=false
 
18
fi
 
19
 
 
20
 
 
21
## --------------------- ##
 
22
## M4sh Initialization.  ##
 
23
## --------------------- ##
 
24
 
 
25
# Be Bourne compatible
 
26
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
 
27
  emulate sh
 
28
  NULLCMD=:
 
29
elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
 
30
  set -o posix
 
31
fi
 
32
 
 
33
# NLS nuisances.
 
34
# Support unset when possible.
 
35
if (FOO=FOO; unset FOO) >/dev/null 2>&1; then
 
36
  as_unset=unset
 
37
else
 
38
  as_unset=false
 
39
fi
 
40
 
 
41
(set +x; test -n "`(LANG=C; export LANG) 2>&1`") &&
 
42
    { $as_unset LANG || test "${LANG+set}" != set; } ||
 
43
      { LANG=C; export LANG; }
 
44
(set +x; test -n "`(LC_ALL=C; export LC_ALL) 2>&1`") &&
 
45
    { $as_unset LC_ALL || test "${LC_ALL+set}" != set; } ||
 
46
      { LC_ALL=C; export LC_ALL; }
 
47
(set +x; test -n "`(LC_TIME=C; export LC_TIME) 2>&1`") &&
 
48
    { $as_unset LC_TIME || test "${LC_TIME+set}" != set; } ||
 
49
      { LC_TIME=C; export LC_TIME; }
 
50
(set +x; test -n "`(LC_CTYPE=C; export LC_CTYPE) 2>&1`") &&
 
51
    { $as_unset LC_CTYPE || test "${LC_CTYPE+set}" != set; } ||
 
52
      { LC_CTYPE=C; export LC_CTYPE; }
 
53
(set +x; test -n "`(LANGUAGE=C; export LANGUAGE) 2>&1`") &&
 
54
    { $as_unset LANGUAGE || test "${LANGUAGE+set}" != set; } ||
 
55
      { LANGUAGE=C; export LANGUAGE; }
 
56
(set +x; test -n "`(LC_COLLATE=C; export LC_COLLATE) 2>&1`") &&
 
57
    { $as_unset LC_COLLATE || test "${LC_COLLATE+set}" != set; } ||
 
58
      { LC_COLLATE=C; export LC_COLLATE; }
 
59
(set +x; test -n "`(LC_NUMERIC=C; export LC_NUMERIC) 2>&1`") &&
 
60
    { $as_unset LC_NUMERIC || test "${LC_NUMERIC+set}" != set; } ||
 
61
      { LC_NUMERIC=C; export LC_NUMERIC; }
 
62
(set +x; test -n "`(LC_MESSAGES=C; export LC_MESSAGES) 2>&1`") &&
 
63
    { $as_unset LC_MESSAGES || test "${LC_MESSAGES+set}" != set; } ||
 
64
      { LC_MESSAGES=C; export LC_MESSAGES; }
 
65
 
 
66
 
 
67
# Name of the executable.
 
68
as_me=`(basename "$0") 2>/dev/null ||
 
69
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
 
70
         X"$0" : 'X\(//\)$' \| \
 
71
         X"$0" : 'X\(/\)$' \| \
 
72
         .     : '\(.\)' 2>/dev/null ||
 
73
echo X/"$0" |
 
74
    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
 
75
          /^X\/\(\/\/\)$/{ s//\1/; q; }
 
76
          /^X\/\(\/\).*/{ s//\1/; q; }
 
77
          s/.*/./; q'`
 
78
 
 
79
# PATH needs CR, and LINENO needs CR and PATH.
 
80
# Avoid depending upon Character Ranges.
 
81
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
 
82
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 
83
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
 
84
as_cr_digits='0123456789'
 
85
as_cr_alnum=$as_cr_Letters$as_cr_digits
 
86
 
 
87
# The user is always right.
 
88
if test "${PATH_SEPARATOR+set}" != set; then
 
89
  echo "#! /bin/sh" >conftest.sh
 
90
  echo  "exit 0"   >>conftest.sh
 
91
  chmod +x conftest.sh
 
92
  if (PATH=".;."; conftest.sh) >/dev/null 2>&1; then
 
93
    PATH_SEPARATOR=';'
 
94
  else
 
95
    PATH_SEPARATOR=:
 
96
  fi
 
97
  rm -f conftest.sh
 
98
fi
 
99
 
 
100
 
 
101
  as_lineno_1=$LINENO
 
102
  as_lineno_2=$LINENO
 
103
  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 
104
  test "x$as_lineno_1" != "x$as_lineno_2" &&
 
105
  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 
106
  # Find who we are.  Look in the path if we contain no path at all
 
107
  # relative or not.
 
108
  case $0 in
 
109
    *[\\/]* ) as_myself=$0 ;;
 
110
    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
111
for as_dir in $PATH
 
112
do
 
113
  IFS=$as_save_IFS
 
114
  test -z "$as_dir" && as_dir=.
 
115
  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 
116
done
 
117
 
 
118
       ;;
 
119
  esac
 
120
  # We did not find ourselves, most probably we were run as `sh COMMAND'
 
121
  # in which case we are not to be found in the path.
 
122
  if test "x$as_myself" = x; then
 
123
    as_myself=$0
 
124
  fi
 
125
  if test ! -f "$as_myself"; then
 
126
    { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 
127
   { (exit 1); exit 1; }; }
 
128
  fi
 
129
  case $CONFIG_SHELL in
 
130
  '')
 
131
    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
132
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 
133
do
 
134
  IFS=$as_save_IFS
 
135
  test -z "$as_dir" && as_dir=.
 
136
  for as_base in sh bash ksh sh5; do
 
137
         case $as_dir in
 
138
         /*)
 
139
           if ("$as_dir/$as_base" -c '
 
140
  as_lineno_1=$LINENO
 
141
  as_lineno_2=$LINENO
 
142
  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 
143
  test "x$as_lineno_1" != "x$as_lineno_2" &&
 
144
  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 
145
             CONFIG_SHELL=$as_dir/$as_base
 
146
             export CONFIG_SHELL
 
147
             exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 
148
           fi;;
 
149
         esac
 
150
       done
 
151
done
 
152
;;
 
153
  esac
 
154
 
 
155
  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 
156
  # uniformly replaced by the line number.  The first 'sed' inserts a
 
157
  # line-number line before each line; the second 'sed' does the real
 
158
  # work.  The second script uses 'N' to pair each line-number line
 
159
  # with the numbered line, and appends trailing '-' during
 
160
  # substitution so that $LINENO is not a special case at line end.
 
161
  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 
162
  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 
163
  sed '=' <$as_myself |
 
164
    sed '
 
165
      N
 
166
      s,$,-,
 
167
      : loop
 
168
      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 
169
      t loop
 
170
      s,-$,,
 
171
      s,^['$as_cr_digits']*\n,,
 
172
    ' >$as_me.lineno &&
 
173
  chmod +x $as_me.lineno ||
 
174
    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 
175
   { (exit 1); exit 1; }; }
 
176
 
 
177
  # Don't try to exec as it changes $[0], causing all sort of problems
 
178
  # (the dirname of $[0] is not the place where we might find the
 
179
  # original and so on.  Autoconf is especially sensible to this).
 
180
  . ./$as_me.lineno
 
181
  # Exit status is that of the last command.
 
182
  exit
 
183
}
 
184
 
 
185
 
 
186
case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 
187
  *c*,-n*) ECHO_N= ECHO_C='
 
188
' ECHO_T='      ' ;;
 
189
  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 
190
  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 
191
esac
 
192
 
 
193
if expr a : '\(a\)' >/dev/null 2>&1; then
 
194
  as_expr=expr
 
195
else
 
196
  as_expr=false
 
197
fi
 
198
 
 
199
rm -f conf$$ conf$$.exe conf$$.file
 
200
echo >conf$$.file
 
201
if ln -s conf$$.file conf$$ 2>/dev/null; then
 
202
  # We could just check for DJGPP; but this test a) works b) is more generic
 
203
  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 
204
  if test -f conf$$.exe; then
 
205
    # Don't use ln at all; we don't have any links
 
206
    as_ln_s='cp -p'
 
207
  else
 
208
    as_ln_s='ln -s'
 
209
  fi
 
210
elif ln conf$$.file conf$$ 2>/dev/null; then
 
211
  as_ln_s=ln
 
212
else
 
213
  as_ln_s='cp -p'
 
214
fi
 
215
rm -f conf$$ conf$$.exe conf$$.file
 
216
 
 
217
as_executable_p="test -f"
 
218
 
 
219
# Sed expression to map a string onto a valid CPP name.
 
220
as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"
 
221
 
 
222
# Sed expression to map a string onto a valid variable name.
 
223
as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g"
 
224
 
 
225
 
 
226
# IFS
 
227
# We need space, tab and new line, in precisely that order.
 
228
as_nl='
 
229
'
 
230
IFS="   $as_nl"
 
231
 
 
232
# CDPATH.
 
233
$as_unset CDPATH || test "${CDPATH+set}" != set || { CDPATH=$PATH_SEPARATOR; export CDPATH; }
 
234
 
 
235
 
 
236
# Name of the host.
 
237
# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 
238
# so uname gets run too.
 
239
ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 
240
 
 
241
exec 6>&1
 
242
 
 
243
#
 
244
# Initializations.
 
245
#
 
246
ac_default_prefix=/usr/local
 
247
cross_compiling=no
 
248
subdirs=
 
249
MFLAGS=
 
250
MAKEFLAGS=
 
251
SHELL=${CONFIG_SHELL-/bin/sh}
 
252
 
 
253
# Maximum number of lines to put in a shell here document.
 
254
# This variable seems obsolete.  It should probably be removed, and
 
255
# only ac_max_sed_lines should be used.
 
256
: ${ac_max_here_lines=38}
 
257
 
 
258
# Identity of this package.
 
259
PACKAGE_NAME='PostgreSQL'
 
260
PACKAGE_TARNAME='postgresql'
 
261
PACKAGE_VERSION='8.0.3'
 
262
PACKAGE_STRING='PostgreSQL 8.0.3'
 
263
PACKAGE_BUGREPORT='pgsql-bugs@postgresql.org'
 
264
 
 
265
ac_unique_file="src/backend/access/common/heaptuple.c"
 
266
ac_default_prefix=/usr/local/pgsql
 
267
# Factoring default headers for most tests.
 
268
ac_includes_default="\
 
269
#include <stdio.h>
 
270
#if HAVE_SYS_TYPES_H
 
271
# include <sys/types.h>
 
272
#endif
 
273
#if HAVE_SYS_STAT_H
 
274
# include <sys/stat.h>
 
275
#endif
 
276
#if STDC_HEADERS
 
277
# include <stdlib.h>
 
278
# include <stddef.h>
 
279
#else
 
280
# if HAVE_STDLIB_H
 
281
#  include <stdlib.h>
 
282
# endif
 
283
#endif
 
284
#if HAVE_STRING_H
 
285
# if !STDC_HEADERS && HAVE_MEMORY_H
 
286
#  include <memory.h>
 
287
# endif
 
288
# include <string.h>
 
289
#endif
 
290
#if HAVE_STRINGS_H
 
291
# include <strings.h>
 
292
#endif
 
293
#if HAVE_INTTYPES_H
 
294
# include <inttypes.h>
 
295
#else
 
296
# if HAVE_STDINT_H
 
297
#  include <stdint.h>
 
298
# endif
 
299
#endif
 
300
#if HAVE_UNISTD_H
 
301
# include <unistd.h>
 
302
#endif"
 
303
 
 
304
 
 
305
# Initialize some variables set by options.
 
306
ac_init_help=
 
307
ac_init_version=false
 
308
# The variables have the same names as the options, with
 
309
# dashes changed to underlines.
 
310
cache_file=/dev/null
 
311
exec_prefix=NONE
 
312
no_create=
 
313
no_recursion=
 
314
prefix=NONE
 
315
program_prefix=NONE
 
316
program_suffix=NONE
 
317
program_transform_name=s,x,x,
 
318
silent=
 
319
site=
 
320
srcdir=
 
321
verbose=
 
322
x_includes=NONE
 
323
x_libraries=NONE
 
324
 
 
325
# Installation directory options.
 
326
# These are left unexpanded so users can "make install exec_prefix=/foo"
 
327
# and all the variables that are supposed to be based on exec_prefix
 
328
# by default will actually change.
 
329
# Use braces instead of parens because sh, perl, etc. also accept them.
 
330
bindir='${exec_prefix}/bin'
 
331
sbindir='${exec_prefix}/sbin'
 
332
libexecdir='${exec_prefix}/libexec'
 
333
datadir='${prefix}/share'
 
334
sysconfdir='${prefix}/etc'
 
335
sharedstatedir='${prefix}/com'
 
336
localstatedir='${prefix}/var'
 
337
libdir='${exec_prefix}/lib'
 
338
includedir='${prefix}/include'
 
339
oldincludedir='/usr/include'
 
340
infodir='${prefix}/info'
 
341
mandir='${prefix}/man'
 
342
 
 
343
ac_prev=
 
344
for ac_option
 
345
do
 
346
  # If the previous option needs an argument, assign it.
 
347
  if test -n "$ac_prev"; then
 
348
    eval "$ac_prev=\$ac_option"
 
349
    ac_prev=
 
350
    continue
 
351
  fi
 
352
 
 
353
  ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 
354
 
 
355
  # Accept the important Cygnus configure options, so we can diagnose typos.
 
356
 
 
357
  case $ac_option in
 
358
 
 
359
  -bindir | --bindir | --bindi | --bind | --bin | --bi)
 
360
    ac_prev=bindir ;;
 
361
  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 
362
    bindir=$ac_optarg ;;
 
363
 
 
364
  -build | --build | --buil | --bui | --bu)
 
365
    ac_prev=build_alias ;;
 
366
  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 
367
    build_alias=$ac_optarg ;;
 
368
 
 
369
  -cache-file | --cache-file | --cache-fil | --cache-fi \
 
370
  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 
371
    ac_prev=cache_file ;;
 
372
  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 
373
  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 
374
    cache_file=$ac_optarg ;;
 
375
 
 
376
  --config-cache | -C)
 
377
    cache_file=config.cache ;;
 
378
 
 
379
  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 
380
    ac_prev=datadir ;;
 
381
  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 
382
  | --da=*)
 
383
    datadir=$ac_optarg ;;
 
384
 
 
385
  -disable-* | --disable-*)
 
386
    ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 
387
    # Reject names that are not valid shell variable names.
 
388
    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 
389
      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 
390
   { (exit 1); exit 1; }; }
 
391
    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 
392
    eval "enable_$ac_feature=no" ;;
 
393
 
 
394
  -enable-* | --enable-*)
 
395
    ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 
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
    case $ac_option in
 
402
      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 
403
      *) ac_optarg=yes ;;
 
404
    esac
 
405
    eval "enable_$ac_feature='$ac_optarg'" ;;
 
406
 
 
407
  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 
408
  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 
409
  | --exec | --exe | --ex)
 
410
    ac_prev=exec_prefix ;;
 
411
  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 
412
  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 
413
  | --exec=* | --exe=* | --ex=*)
 
414
    exec_prefix=$ac_optarg ;;
 
415
 
 
416
  -gas | --gas | --ga | --g)
 
417
    # Obsolete; use --with-gas.
 
418
    with_gas=yes ;;
 
419
 
 
420
  -help | --help | --hel | --he | -h)
 
421
    ac_init_help=long ;;
 
422
  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 
423
    ac_init_help=recursive ;;
 
424
  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 
425
    ac_init_help=short ;;
 
426
 
 
427
  -host | --host | --hos | --ho)
 
428
    ac_prev=host_alias ;;
 
429
  -host=* | --host=* | --hos=* | --ho=*)
 
430
    host_alias=$ac_optarg ;;
 
431
 
 
432
  -includedir | --includedir | --includedi | --included | --include \
 
433
  | --includ | --inclu | --incl | --inc)
 
434
    ac_prev=includedir ;;
 
435
  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 
436
  | --includ=* | --inclu=* | --incl=* | --inc=*)
 
437
    includedir=$ac_optarg ;;
 
438
 
 
439
  -infodir | --infodir | --infodi | --infod | --info | --inf)
 
440
    ac_prev=infodir ;;
 
441
  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 
442
    infodir=$ac_optarg ;;
 
443
 
 
444
  -libdir | --libdir | --libdi | --libd)
 
445
    ac_prev=libdir ;;
 
446
  -libdir=* | --libdir=* | --libdi=* | --libd=*)
 
447
    libdir=$ac_optarg ;;
 
448
 
 
449
  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 
450
  | --libexe | --libex | --libe)
 
451
    ac_prev=libexecdir ;;
 
452
  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 
453
  | --libexe=* | --libex=* | --libe=*)
 
454
    libexecdir=$ac_optarg ;;
 
455
 
 
456
  -localstatedir | --localstatedir | --localstatedi | --localstated \
 
457
  | --localstate | --localstat | --localsta | --localst \
 
458
  | --locals | --local | --loca | --loc | --lo)
 
459
    ac_prev=localstatedir ;;
 
460
  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 
461
  | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 
462
  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 
463
    localstatedir=$ac_optarg ;;
 
464
 
 
465
  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 
466
    ac_prev=mandir ;;
 
467
  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 
468
    mandir=$ac_optarg ;;
 
469
 
 
470
  -nfp | --nfp | --nf)
 
471
    # Obsolete; use --without-fp.
 
472
    with_fp=no ;;
 
473
 
 
474
  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 
475
  | --no-cr | --no-c | -n)
 
476
    no_create=yes ;;
 
477
 
 
478
  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 
479
  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 
480
    no_recursion=yes ;;
 
481
 
 
482
  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 
483
  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 
484
  | --oldin | --oldi | --old | --ol | --o)
 
485
    ac_prev=oldincludedir ;;
 
486
  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 
487
  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 
488
  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 
489
    oldincludedir=$ac_optarg ;;
 
490
 
 
491
  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 
492
    ac_prev=prefix ;;
 
493
  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 
494
    prefix=$ac_optarg ;;
 
495
 
 
496
  -program-prefix | --program-prefix | --program-prefi | --program-pref \
 
497
  | --program-pre | --program-pr | --program-p)
 
498
    ac_prev=program_prefix ;;
 
499
  -program-prefix=* | --program-prefix=* | --program-prefi=* \
 
500
  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 
501
    program_prefix=$ac_optarg ;;
 
502
 
 
503
  -program-suffix | --program-suffix | --program-suffi | --program-suff \
 
504
  | --program-suf | --program-su | --program-s)
 
505
    ac_prev=program_suffix ;;
 
506
  -program-suffix=* | --program-suffix=* | --program-suffi=* \
 
507
  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 
508
    program_suffix=$ac_optarg ;;
 
509
 
 
510
  -program-transform-name | --program-transform-name \
 
511
  | --program-transform-nam | --program-transform-na \
 
512
  | --program-transform-n | --program-transform- \
 
513
  | --program-transform | --program-transfor \
 
514
  | --program-transfo | --program-transf \
 
515
  | --program-trans | --program-tran \
 
516
  | --progr-tra | --program-tr | --program-t)
 
517
    ac_prev=program_transform_name ;;
 
518
  -program-transform-name=* | --program-transform-name=* \
 
519
  | --program-transform-nam=* | --program-transform-na=* \
 
520
  | --program-transform-n=* | --program-transform-=* \
 
521
  | --program-transform=* | --program-transfor=* \
 
522
  | --program-transfo=* | --program-transf=* \
 
523
  | --program-trans=* | --program-tran=* \
 
524
  | --progr-tra=* | --program-tr=* | --program-t=*)
 
525
    program_transform_name=$ac_optarg ;;
 
526
 
 
527
  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 
528
  | -silent | --silent | --silen | --sile | --sil)
 
529
    silent=yes ;;
 
530
 
 
531
  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 
532
    ac_prev=sbindir ;;
 
533
  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 
534
  | --sbi=* | --sb=*)
 
535
    sbindir=$ac_optarg ;;
 
536
 
 
537
  -sharedstatedir | --sharedstatedir | --sharedstatedi \
 
538
  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 
539
  | --sharedst | --shareds | --shared | --share | --shar \
 
540
  | --sha | --sh)
 
541
    ac_prev=sharedstatedir ;;
 
542
  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 
543
  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 
544
  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 
545
  | --sha=* | --sh=*)
 
546
    sharedstatedir=$ac_optarg ;;
 
547
 
 
548
  -site | --site | --sit)
 
549
    ac_prev=site ;;
 
550
  -site=* | --site=* | --sit=*)
 
551
    site=$ac_optarg ;;
 
552
 
 
553
  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 
554
    ac_prev=srcdir ;;
 
555
  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 
556
    srcdir=$ac_optarg ;;
 
557
 
 
558
  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 
559
  | --syscon | --sysco | --sysc | --sys | --sy)
 
560
    ac_prev=sysconfdir ;;
 
561
  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 
562
  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 
563
    sysconfdir=$ac_optarg ;;
 
564
 
 
565
  -target | --target | --targe | --targ | --tar | --ta | --t)
 
566
    ac_prev=target_alias ;;
 
567
  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 
568
    target_alias=$ac_optarg ;;
 
569
 
 
570
  -v | -verbose | --verbose | --verbos | --verbo | --verb)
 
571
    verbose=yes ;;
 
572
 
 
573
  -version | --version | --versio | --versi | --vers | -V)
 
574
    ac_init_version=: ;;
 
575
 
 
576
  -with-* | --with-*)
 
577
    ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 
578
    # Reject names that are not valid shell variable names.
 
579
    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 
580
      { echo "$as_me: error: invalid package name: $ac_package" >&2
 
581
   { (exit 1); exit 1; }; }
 
582
    ac_package=`echo $ac_package| sed 's/-/_/g'`
 
583
    case $ac_option in
 
584
      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 
585
      *) ac_optarg=yes ;;
 
586
    esac
 
587
    eval "with_$ac_package='$ac_optarg'" ;;
 
588
 
 
589
  -without-* | --without-*)
 
590
    ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 
591
    # Reject names that are not valid shell variable names.
 
592
    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 
593
      { echo "$as_me: error: invalid package name: $ac_package" >&2
 
594
   { (exit 1); exit 1; }; }
 
595
    ac_package=`echo $ac_package | sed 's/-/_/g'`
 
596
    eval "with_$ac_package=no" ;;
 
597
 
 
598
  --x)
 
599
    # Obsolete; use --with-x.
 
600
    with_x=yes ;;
 
601
 
 
602
  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 
603
  | --x-incl | --x-inc | --x-in | --x-i)
 
604
    ac_prev=x_includes ;;
 
605
  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 
606
  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 
607
    x_includes=$ac_optarg ;;
 
608
 
 
609
  -x-libraries | --x-libraries | --x-librarie | --x-librari \
 
610
  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 
611
    ac_prev=x_libraries ;;
 
612
  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 
613
  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 
614
    x_libraries=$ac_optarg ;;
 
615
 
 
616
  -*) { echo "$as_me: error: unrecognized option: $ac_option
 
617
Try \`$0 --help' for more information." >&2
 
618
   { (exit 1); exit 1; }; }
 
619
    ;;
 
620
 
 
621
  *=*)
 
622
    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 
623
    # Reject names that are not valid shell variable names.
 
624
    expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 
625
      { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 
626
   { (exit 1); exit 1; }; }
 
627
    ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 
628
    eval "$ac_envvar='$ac_optarg'"
 
629
    export $ac_envvar ;;
 
630
 
 
631
  *)
 
632
    # FIXME: should be removed in autoconf 3.0.
 
633
    echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 
634
    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 
635
      echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 
636
    : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 
637
    ;;
 
638
 
 
639
  esac
 
640
done
 
641
 
 
642
if test -n "$ac_prev"; then
 
643
  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 
644
  { echo "$as_me: error: missing argument to $ac_option" >&2
 
645
   { (exit 1); exit 1; }; }
 
646
fi
 
647
 
 
648
# Be sure to have absolute paths.
 
649
for ac_var in exec_prefix prefix
 
650
do
 
651
  eval ac_val=$`echo $ac_var`
 
652
  case $ac_val in
 
653
    [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 
654
    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 
655
   { (exit 1); exit 1; }; };;
 
656
  esac
 
657
done
 
658
 
 
659
# Be sure to have absolute paths.
 
660
for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 
661
              localstatedir libdir includedir oldincludedir infodir mandir
 
662
do
 
663
  eval ac_val=$`echo $ac_var`
 
664
  case $ac_val in
 
665
    [\\/$]* | ?:[\\/]* ) ;;
 
666
    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 
667
   { (exit 1); exit 1; }; };;
 
668
  esac
 
669
done
 
670
 
 
671
# There might be people who depend on the old broken behavior: `$host'
 
672
# used to hold the argument of --host etc.
 
673
# FIXME: To remove some day.
 
674
build=$build_alias
 
675
host=$host_alias
 
676
target=$target_alias
 
677
 
 
678
# FIXME: To remove some day.
 
679
if test "x$host_alias" != x; then
 
680
  if test "x$build_alias" = x; then
 
681
    cross_compiling=maybe
 
682
    echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 
683
    If a cross compiler is detected then cross compile mode will be used." >&2
 
684
  elif test "x$build_alias" != "x$host_alias"; then
 
685
    cross_compiling=yes
 
686
  fi
 
687
fi
 
688
 
 
689
ac_tool_prefix=
 
690
test -n "$host_alias" && ac_tool_prefix=$host_alias-
 
691
 
 
692
test "$silent" = yes && exec 6>/dev/null
 
693
 
 
694
 
 
695
# Find the source files, if location was not specified.
 
696
if test -z "$srcdir"; then
 
697
  ac_srcdir_defaulted=yes
 
698
  # Try the directory containing this script, then its parent.
 
699
  ac_confdir=`(dirname "$0") 2>/dev/null ||
 
700
$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 
701
         X"$0" : 'X\(//\)[^/]' \| \
 
702
         X"$0" : 'X\(//\)$' \| \
 
703
         X"$0" : 'X\(/\)' \| \
 
704
         .     : '\(.\)' 2>/dev/null ||
 
705
echo X"$0" |
 
706
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 
707
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 
708
          /^X\(\/\/\)$/{ s//\1/; q; }
 
709
          /^X\(\/\).*/{ s//\1/; q; }
 
710
          s/.*/./; q'`
 
711
  srcdir=$ac_confdir
 
712
  if test ! -r $srcdir/$ac_unique_file; then
 
713
    srcdir=..
 
714
  fi
 
715
else
 
716
  ac_srcdir_defaulted=no
 
717
fi
 
718
if test ! -r $srcdir/$ac_unique_file; then
 
719
  if test "$ac_srcdir_defaulted" = yes; then
 
720
    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 
721
   { (exit 1); exit 1; }; }
 
722
  else
 
723
    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 
724
   { (exit 1); exit 1; }; }
 
725
  fi
 
726
fi
 
727
srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 
728
ac_env_build_alias_set=${build_alias+set}
 
729
ac_env_build_alias_value=$build_alias
 
730
ac_cv_env_build_alias_set=${build_alias+set}
 
731
ac_cv_env_build_alias_value=$build_alias
 
732
ac_env_host_alias_set=${host_alias+set}
 
733
ac_env_host_alias_value=$host_alias
 
734
ac_cv_env_host_alias_set=${host_alias+set}
 
735
ac_cv_env_host_alias_value=$host_alias
 
736
ac_env_target_alias_set=${target_alias+set}
 
737
ac_env_target_alias_value=$target_alias
 
738
ac_cv_env_target_alias_set=${target_alias+set}
 
739
ac_cv_env_target_alias_value=$target_alias
 
740
ac_env_CC_set=${CC+set}
 
741
ac_env_CC_value=$CC
 
742
ac_cv_env_CC_set=${CC+set}
 
743
ac_cv_env_CC_value=$CC
 
744
ac_env_CFLAGS_set=${CFLAGS+set}
 
745
ac_env_CFLAGS_value=$CFLAGS
 
746
ac_cv_env_CFLAGS_set=${CFLAGS+set}
 
747
ac_cv_env_CFLAGS_value=$CFLAGS
 
748
ac_env_LDFLAGS_set=${LDFLAGS+set}
 
749
ac_env_LDFLAGS_value=$LDFLAGS
 
750
ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 
751
ac_cv_env_LDFLAGS_value=$LDFLAGS
 
752
ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 
753
ac_env_CPPFLAGS_value=$CPPFLAGS
 
754
ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 
755
ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 
756
ac_env_CPP_set=${CPP+set}
 
757
ac_env_CPP_value=$CPP
 
758
ac_cv_env_CPP_set=${CPP+set}
 
759
ac_cv_env_CPP_value=$CPP
 
760
ac_env_LDFLAGS_SL_set=${LDFLAGS_SL+set}
 
761
ac_env_LDFLAGS_SL_value=$LDFLAGS_SL
 
762
ac_cv_env_LDFLAGS_SL_set=${LDFLAGS_SL+set}
 
763
ac_cv_env_LDFLAGS_SL_value=$LDFLAGS_SL
 
764
ac_env_DOCBOOKSTYLE_set=${DOCBOOKSTYLE+set}
 
765
ac_env_DOCBOOKSTYLE_value=$DOCBOOKSTYLE
 
766
ac_cv_env_DOCBOOKSTYLE_set=${DOCBOOKSTYLE+set}
 
767
ac_cv_env_DOCBOOKSTYLE_value=$DOCBOOKSTYLE
 
768
 
 
769
#
 
770
# Report the --help message.
 
771
#
 
772
if test "$ac_init_help" = "long"; then
 
773
  # Omit some internal or obsolete options to make the list less imposing.
 
774
  # This message is too long to be a string in the A/UX 3.1 sh.
 
775
  cat <<_ACEOF
 
776
\`configure' configures PostgreSQL 8.0.3 to adapt to many kinds of systems.
 
777
 
 
778
Usage: $0 [OPTION]... [VAR=VALUE]...
 
779
 
 
780
To assign environment variables (e.g., CC, CFLAGS...), specify them as
 
781
VAR=VALUE.  See below for descriptions of some of the useful variables.
 
782
 
 
783
Defaults for the options are specified in brackets.
 
784
 
 
785
Configuration:
 
786
  -h, --help              display this help and exit
 
787
      --help=short        display options specific to this package
 
788
      --help=recursive    display the short help of all the included packages
 
789
  -V, --version           display version information and exit
 
790
  -q, --quiet, --silent   do not print \`checking...' messages
 
791
      --cache-file=FILE   cache test results in FILE [disabled]
 
792
  -C, --config-cache      alias for \`--cache-file=config.cache'
 
793
  -n, --no-create         do not create output files
 
794
      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 
795
 
 
796
_ACEOF
 
797
 
 
798
  cat <<_ACEOF
 
799
Installation directories:
 
800
  --prefix=PREFIX         install architecture-independent files in PREFIX
 
801
                          [$ac_default_prefix]
 
802
  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 
803
                          [PREFIX]
 
804
 
 
805
By default, \`make install' will install all the files in
 
806
\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 
807
an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 
808
for instance \`--prefix=\$HOME'.
 
809
 
 
810
For better control, use the options below.
 
811
 
 
812
Fine tuning of the installation directories:
 
813
  --bindir=DIR           user executables [EPREFIX/bin]
 
814
  --sbindir=DIR          system admin executables [EPREFIX/sbin]
 
815
  --libexecdir=DIR       program executables [EPREFIX/libexec]
 
816
  --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 
817
  --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 
818
  --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 
819
  --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 
820
  --libdir=DIR           object code libraries [EPREFIX/lib]
 
821
  --includedir=DIR       C header files [PREFIX/include]
 
822
  --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 
823
  --infodir=DIR          info documentation [PREFIX/info]
 
824
  --mandir=DIR           man documentation [PREFIX/man]
 
825
_ACEOF
 
826
 
 
827
  cat <<\_ACEOF
 
828
 
 
829
System types:
 
830
  --build=BUILD     configure for building on BUILD [guessed]
 
831
  --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 
832
_ACEOF
 
833
fi
 
834
 
 
835
if test -n "$ac_init_help"; then
 
836
  case $ac_init_help in
 
837
     short | recursive ) echo "Configuration of PostgreSQL 8.0.3:";;
 
838
   esac
 
839
  cat <<\_ACEOF
 
840
 
 
841
Optional Features:
 
842
  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 
843
  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 
844
  --enable-integer-datetimes  enable 64-bit integer date/time support
 
845
  --enable-nls[=LANGUAGES]  enable Native Language Support
 
846
  --disable-shared        do not build shared libraries
 
847
  --disable-rpath         do not embed shared library search path in executables
 
848
  --disable-spinlocks     do not use spinlocks
 
849
  --enable-debug          build with debugging symbols (-g)
 
850
  --enable-depend         turn on automatic dependency tracking
 
851
  --enable-cassert        enable assertion checks (for debugging)
 
852
  --enable-thread-safety  make client libraries thread-safe
 
853
  --enable-thread-safety-force  force thread-safety in spite of thread test failure
 
854
  --disable-largefile     omit support for large files
 
855
 
 
856
Optional Packages:
 
857
  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 
858
  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 
859
 
 
860
  --with-docdir=DIR       install the documentation in DIR [PREFIX/doc]
 
861
  --without-docdir        do not install the documentation
 
862
  --with-includes=DIRS    look for additional header files in DIRS
 
863
  --with-libraries=DIRS   look for additional libraries in DIRS
 
864
  --with-libs=DIRS        alternative spelling of --with-libraries
 
865
  --with-pgport=PORTNUM   change default port number 5432
 
866
  --with-tcl              build Tcl modules (PL/Tcl)
 
867
  --with-tclconfig=DIR    tclConfig.sh is in DIR
 
868
  --with-perl             build Perl modules (PL/Perl)
 
869
  --with-python           build Python modules (PL/Python)
 
870
  --with-krb4             build with Kerberos 4 support
 
871
  --with-krb5             build with Kerberos 5 support
 
872
  --with-krb-srvnam=NAME  name of the service principal in Kerberos [postgres]
 
873
  --with-pam              build with PAM support
 
874
  --with-rendezvous       build with Rendezvous support
 
875
  --with-openssl          build with OpenSSL support
 
876
  --without-readline      do not use Readline
 
877
  --without-zlib          do not use Zlib
 
878
  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]
 
879
 
 
880
Some influential environment variables:
 
881
  CC          C compiler command
 
882
  CFLAGS      C compiler flags
 
883
  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 
884
              nonstandard directory <lib dir>
 
885
  CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 
886
              headers in a nonstandard directory <include dir>
 
887
  CPP         C preprocessor
 
888
  LDFLAGS_SL
 
889
  DOCBOOKSTYLE
 
890
              location of DocBook stylesheets
 
891
 
 
892
Use these variables to override the choices made by `configure' or to help
 
893
it to find libraries and programs with nonstandard names/locations.
 
894
 
 
895
Report bugs to <pgsql-bugs@postgresql.org>.
 
896
_ACEOF
 
897
fi
 
898
 
 
899
if test "$ac_init_help" = "recursive"; then
 
900
  # If there are subdirs, report their specific --help.
 
901
  ac_popdir=`pwd`
 
902
  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
 
903
    test -d $ac_dir || continue
 
904
    ac_builddir=.
 
905
 
 
906
if test "$ac_dir" != .; then
 
907
  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
 
908
  # A "../" for each directory in $ac_dir_suffix.
 
909
  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
 
910
else
 
911
  ac_dir_suffix= ac_top_builddir=
 
912
fi
 
913
 
 
914
case $srcdir in
 
915
  .)  # No --srcdir option.  We are building in place.
 
916
    ac_srcdir=.
 
917
    if test -z "$ac_top_builddir"; then
 
918
       ac_top_srcdir=.
 
919
    else
 
920
       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
 
921
    fi ;;
 
922
  [\\/]* | ?:[\\/]* )  # Absolute path.
 
923
    ac_srcdir=$srcdir$ac_dir_suffix;
 
924
    ac_top_srcdir=$srcdir ;;
 
925
  *) # Relative path.
 
926
    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
 
927
    ac_top_srcdir=$ac_top_builddir$srcdir ;;
 
928
esac
 
929
# Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be
 
930
# absolute.
 
931
ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd`
 
932
ac_abs_top_builddir=`cd "$ac_dir" && cd $ac_top_builddir && pwd`
 
933
ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd`
 
934
ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd`
 
935
 
 
936
    cd $ac_dir
 
937
    # Check for guested configure; otherwise get Cygnus style configure.
 
938
    if test -f $ac_srcdir/configure.gnu; then
 
939
      echo
 
940
      $SHELL $ac_srcdir/configure.gnu  --help=recursive
 
941
    elif test -f $ac_srcdir/configure; then
 
942
      echo
 
943
      $SHELL $ac_srcdir/configure  --help=recursive
 
944
    elif test -f $ac_srcdir/configure.ac ||
 
945
           test -f $ac_srcdir/configure.in; then
 
946
      echo
 
947
      $ac_configure --help
 
948
    else
 
949
      echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
 
950
    fi
 
951
    cd $ac_popdir
 
952
  done
 
953
fi
 
954
 
 
955
test -n "$ac_init_help" && exit 0
 
956
if $ac_init_version; then
 
957
  cat <<\_ACEOF
 
958
PostgreSQL configure 8.0.3
 
959
generated by GNU Autoconf 2.53
 
960
 
 
961
Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002
 
962
Free Software Foundation, Inc.
 
963
This configure script is free software; the Free Software Foundation
 
964
gives unlimited permission to copy, distribute and modify it.
 
965
 
 
966
Copyright (c) 1996-2005, PostgreSQL Global Development Group
 
967
_ACEOF
 
968
  exit 0
 
969
fi
 
970
exec 5>config.log
 
971
cat >&5 <<_ACEOF
 
972
This file contains any messages produced by compilers while
 
973
running configure, to aid debugging if configure makes a mistake.
 
974
 
 
975
It was created by PostgreSQL $as_me 8.0.3, which was
 
976
generated by GNU Autoconf 2.53.  Invocation command line was
 
977
 
 
978
  $ $0 $@
 
979
 
 
980
_ACEOF
 
981
{
 
982
cat <<_ASUNAME
 
983
## --------- ##
 
984
## Platform. ##
 
985
## --------- ##
 
986
 
 
987
hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
 
988
uname -m = `(uname -m) 2>/dev/null || echo unknown`
 
989
uname -r = `(uname -r) 2>/dev/null || echo unknown`
 
990
uname -s = `(uname -s) 2>/dev/null || echo unknown`
 
991
uname -v = `(uname -v) 2>/dev/null || echo unknown`
 
992
 
 
993
/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
 
994
/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
 
995
 
 
996
/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
 
997
/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
 
998
/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
 
999
hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
 
1000
/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
 
1001
/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
 
1002
/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
 
1003
 
 
1004
_ASUNAME
 
1005
 
 
1006
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
1007
for as_dir in $PATH
 
1008
do
 
1009
  IFS=$as_save_IFS
 
1010
  test -z "$as_dir" && as_dir=.
 
1011
  echo "PATH: $as_dir"
 
1012
done
 
1013
 
 
1014
} >&5
 
1015
 
 
1016
cat >&5 <<_ACEOF
 
1017
 
 
1018
 
 
1019
## ----------- ##
 
1020
## Core tests. ##
 
1021
## ----------- ##
 
1022
 
 
1023
_ACEOF
 
1024
 
 
1025
 
 
1026
# Keep a trace of the command line.
 
1027
# Strip out --no-create and --no-recursion so they do not pile up.
 
1028
# Also quote any args containing shell meta-characters.
 
1029
ac_configure_args=
 
1030
ac_sep=
 
1031
for ac_arg
 
1032
do
 
1033
  case $ac_arg in
 
1034
  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 
1035
  | --no-cr | --no-c | -n ) continue ;;
 
1036
  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 
1037
  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 
1038
    continue ;;
 
1039
  *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
 
1040
    ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
 
1041
  esac
 
1042
  case " $ac_configure_args " in
 
1043
    *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
 
1044
    *) ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
 
1045
       ac_sep=" " ;;
 
1046
  esac
 
1047
  # Get rid of the leading space.
 
1048
done
 
1049
 
 
1050
# When interrupted or exit'd, cleanup temporary files, and complete
 
1051
# config.log.  We remove comments because anyway the quotes in there
 
1052
# would cause problems or look ugly.
 
1053
# WARNING: Be sure not to use single quotes in there, as some shells,
 
1054
# such as our DU 5.0 friend, will then `close' the trap.
 
1055
trap 'exit_status=$?
 
1056
  # Save into config.log some information that might help in debugging.
 
1057
  {
 
1058
    echo
 
1059
    cat <<\_ASBOX
 
1060
## ---------------- ##
 
1061
## Cache variables. ##
 
1062
## ---------------- ##
 
1063
_ASBOX
 
1064
    echo
 
1065
    # The following way of writing the cache mishandles newlines in values,
 
1066
{
 
1067
  (set) 2>&1 |
 
1068
    case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
 
1069
    *ac_space=\ *)
 
1070
      sed -n \
 
1071
        "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
 
1072
          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
 
1073
      ;;
 
1074
    *)
 
1075
      sed -n \
 
1076
        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
 
1077
      ;;
 
1078
    esac;
 
1079
}
 
1080
    echo
 
1081
    if test -s confdefs.h; then
 
1082
      cat <<\_ASBOX
 
1083
## ----------- ##
 
1084
## confdefs.h. ##
 
1085
## ----------- ##
 
1086
_ASBOX
 
1087
      echo
 
1088
      sed "/^$/d" confdefs.h
 
1089
      echo
 
1090
    fi
 
1091
    test "$ac_signal" != 0 &&
 
1092
      echo "$as_me: caught signal $ac_signal"
 
1093
    echo "$as_me: exit $exit_status"
 
1094
  } >&5
 
1095
  rm -f core core.* *.core &&
 
1096
  rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
 
1097
    exit $exit_status
 
1098
     ' 0
 
1099
for ac_signal in 1 2 13 15; do
 
1100
  trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
 
1101
done
 
1102
ac_signal=0
 
1103
 
 
1104
# confdefs.h avoids OS command line length limits that DEFS can exceed.
 
1105
rm -rf conftest* confdefs.h
 
1106
# AIX cpp loses on an empty file, so make sure it contains at least a newline.
 
1107
echo >confdefs.h
 
1108
 
 
1109
# Predefined preprocessor variables.
 
1110
 
 
1111
cat >>confdefs.h <<_ACEOF
 
1112
#define PACKAGE_NAME "$PACKAGE_NAME"
 
1113
_ACEOF
 
1114
 
 
1115
 
 
1116
cat >>confdefs.h <<_ACEOF
 
1117
#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
 
1118
_ACEOF
 
1119
 
 
1120
 
 
1121
cat >>confdefs.h <<_ACEOF
 
1122
#define PACKAGE_VERSION "$PACKAGE_VERSION"
 
1123
_ACEOF
 
1124
 
 
1125
 
 
1126
cat >>confdefs.h <<_ACEOF
 
1127
#define PACKAGE_STRING "$PACKAGE_STRING"
 
1128
_ACEOF
 
1129
 
 
1130
 
 
1131
cat >>confdefs.h <<_ACEOF
 
1132
#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
 
1133
_ACEOF
 
1134
 
 
1135
 
 
1136
# Let the site file select an alternate cache file if it wants to.
 
1137
# Prefer explicitly selected file to automatically selected ones.
 
1138
if test -z "$CONFIG_SITE"; then
 
1139
  if test "x$prefix" != xNONE; then
 
1140
    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
 
1141
  else
 
1142
    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
 
1143
  fi
 
1144
fi
 
1145
for ac_site_file in $CONFIG_SITE; do
 
1146
  if test -r "$ac_site_file"; then
 
1147
    { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
 
1148
echo "$as_me: loading site script $ac_site_file" >&6;}
 
1149
    sed 's/^/| /' "$ac_site_file" >&5
 
1150
    . "$ac_site_file"
 
1151
  fi
 
1152
done
 
1153
 
 
1154
if test -r "$cache_file"; then
 
1155
  # Some versions of bash will fail to source /dev/null (special
 
1156
  # files actually), so we avoid doing that.
 
1157
  if test -f "$cache_file"; then
 
1158
    { echo "$as_me:$LINENO: loading cache $cache_file" >&5
 
1159
echo "$as_me: loading cache $cache_file" >&6;}
 
1160
    case $cache_file in
 
1161
      [\\/]* | ?:[\\/]* ) . $cache_file;;
 
1162
      *)                      . ./$cache_file;;
 
1163
    esac
 
1164
  fi
 
1165
else
 
1166
  { echo "$as_me:$LINENO: creating cache $cache_file" >&5
 
1167
echo "$as_me: creating cache $cache_file" >&6;}
 
1168
  >$cache_file
 
1169
fi
 
1170
 
 
1171
# Check that the precious variables saved in the cache have kept the same
 
1172
# value.
 
1173
ac_cache_corrupted=false
 
1174
for ac_var in `(set) 2>&1 |
 
1175
               sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
 
1176
  eval ac_old_set=\$ac_cv_env_${ac_var}_set
 
1177
  eval ac_new_set=\$ac_env_${ac_var}_set
 
1178
  eval ac_old_val="\$ac_cv_env_${ac_var}_value"
 
1179
  eval ac_new_val="\$ac_env_${ac_var}_value"
 
1180
  case $ac_old_set,$ac_new_set in
 
1181
    set,)
 
1182
      { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
 
1183
echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
 
1184
      ac_cache_corrupted=: ;;
 
1185
    ,set)
 
1186
      { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
 
1187
echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
 
1188
      ac_cache_corrupted=: ;;
 
1189
    ,);;
 
1190
    *)
 
1191
      if test "x$ac_old_val" != "x$ac_new_val"; then
 
1192
        { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
 
1193
echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
 
1194
        { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
 
1195
echo "$as_me:   former value:  $ac_old_val" >&2;}
 
1196
        { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
 
1197
echo "$as_me:   current value: $ac_new_val" >&2;}
 
1198
        ac_cache_corrupted=:
 
1199
      fi;;
 
1200
  esac
 
1201
  # Pass precious variables to config.status.
 
1202
  if test "$ac_new_set" = set; then
 
1203
    case $ac_new_val in
 
1204
    *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
 
1205
      ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
 
1206
    *) ac_arg=$ac_var=$ac_new_val ;;
 
1207
    esac
 
1208
    case " $ac_configure_args " in
 
1209
      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
 
1210
      *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
 
1211
    esac
 
1212
  fi
 
1213
done
 
1214
if $ac_cache_corrupted; then
 
1215
  { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
 
1216
echo "$as_me: error: changes in the environment can compromise the build" >&2;}
 
1217
  { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
 
1218
echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
 
1219
   { (exit 1); exit 1; }; }
 
1220
fi
 
1221
 
 
1222
ac_ext=c
 
1223
ac_cpp='$CPP $CPPFLAGS'
 
1224
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
1225
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
1226
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
1227
 
 
1228
 
 
1229
 
 
1230
 
 
1231
 
 
1232
 
 
1233
 
 
1234
 
 
1235
 
 
1236
 
 
1237
 
 
1238
 
 
1239
 
 
1240
 
 
1241
 
 
1242
 
 
1243
 
 
1244
 
 
1245
 
 
1246
 
 
1247
 
 
1248
 
 
1249
 
 
1250
 
 
1251
 
 
1252
 
 
1253
 
 
1254
 
 
1255
 
 
1256
 
 
1257
ac_aux_dir=
 
1258
for ac_dir in config $srcdir/config; do
 
1259
  if test -f $ac_dir/install-sh; then
 
1260
    ac_aux_dir=$ac_dir
 
1261
    ac_install_sh="$ac_aux_dir/install-sh -c"
 
1262
    break
 
1263
  elif test -f $ac_dir/install.sh; then
 
1264
    ac_aux_dir=$ac_dir
 
1265
    ac_install_sh="$ac_aux_dir/install.sh -c"
 
1266
    break
 
1267
  elif test -f $ac_dir/shtool; then
 
1268
    ac_aux_dir=$ac_dir
 
1269
    ac_install_sh="$ac_aux_dir/shtool install -c"
 
1270
    break
 
1271
  fi
 
1272
done
 
1273
if test -z "$ac_aux_dir"; then
 
1274
  { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in config $srcdir/config" >&5
 
1275
echo "$as_me: error: cannot find install-sh or install.sh in config $srcdir/config" >&2;}
 
1276
   { (exit 1); exit 1; }; }
 
1277
fi
 
1278
ac_config_guess="$SHELL $ac_aux_dir/config.guess"
 
1279
ac_config_sub="$SHELL $ac_aux_dir/config.sub"
 
1280
ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
 
1281
 
 
1282
 
 
1283
configure_args=$ac_configure_args
 
1284
 
 
1285
 
 
1286
 
 
1287
cat >>confdefs.h <<_ACEOF
 
1288
#define PG_VERSION "$PACKAGE_VERSION"
 
1289
_ACEOF
 
1290
 
 
1291
 
 
1292
# Make sure we can run config.sub.
 
1293
$ac_config_sub sun4 >/dev/null 2>&1 ||
 
1294
  { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
 
1295
echo "$as_me: error: cannot run $ac_config_sub" >&2;}
 
1296
   { (exit 1); exit 1; }; }
 
1297
 
 
1298
echo "$as_me:$LINENO: checking build system type" >&5
 
1299
echo $ECHO_N "checking build system type... $ECHO_C" >&6
 
1300
if test "${ac_cv_build+set}" = set; then
 
1301
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
1302
else
 
1303
  ac_cv_build_alias=$build_alias
 
1304
test -z "$ac_cv_build_alias" &&
 
1305
  ac_cv_build_alias=`$ac_config_guess`
 
1306
test -z "$ac_cv_build_alias" &&
 
1307
  { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
 
1308
echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
 
1309
   { (exit 1); exit 1; }; }
 
1310
ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
 
1311
  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
 
1312
echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
 
1313
   { (exit 1); exit 1; }; }
 
1314
 
 
1315
fi
 
1316
echo "$as_me:$LINENO: result: $ac_cv_build" >&5
 
1317
echo "${ECHO_T}$ac_cv_build" >&6
 
1318
build=$ac_cv_build
 
1319
build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 
1320
build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 
1321
build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 
1322
 
 
1323
 
 
1324
echo "$as_me:$LINENO: checking host system type" >&5
 
1325
echo $ECHO_N "checking host system type... $ECHO_C" >&6
 
1326
if test "${ac_cv_host+set}" = set; then
 
1327
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
1328
else
 
1329
  ac_cv_host_alias=$host_alias
 
1330
test -z "$ac_cv_host_alias" &&
 
1331
  ac_cv_host_alias=$ac_cv_build_alias
 
1332
ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
 
1333
  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
 
1334
echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
 
1335
   { (exit 1); exit 1; }; }
 
1336
 
 
1337
fi
 
1338
echo "$as_me:$LINENO: result: $ac_cv_host" >&5
 
1339
echo "${ECHO_T}$ac_cv_host" >&6
 
1340
host=$ac_cv_host
 
1341
host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 
1342
host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 
1343
host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 
1344
 
 
1345
 
 
1346
 
 
1347
template=
 
1348
echo "$as_me:$LINENO: checking which template to use" >&5
 
1349
echo $ECHO_N "checking which template to use... $ECHO_C" >&6
 
1350
 
 
1351
 
 
1352
 
 
1353
 
 
1354
# Check whether --with-template or --without-template was given.
 
1355
if test "${with_template+set}" = set; then
 
1356
  withval="$with_template"
 
1357
 
 
1358
  case $withval in
 
1359
    yes)
 
1360
      { { echo "$as_me:$LINENO: error: argument required for --with-template option" >&5
 
1361
echo "$as_me: error: argument required for --with-template option" >&2;}
 
1362
   { (exit 1); exit 1; }; }
 
1363
      ;;
 
1364
    no)
 
1365
      { { echo "$as_me:$LINENO: error: argument required for --with-template option" >&5
 
1366
echo "$as_me: error: argument required for --with-template option" >&2;}
 
1367
   { (exit 1); exit 1; }; }
 
1368
      ;;
 
1369
    *)
 
1370
 
 
1371
  case $withval in
 
1372
    list)   echo; ls "$srcdir/src/template"; exit;;
 
1373
    *)      if test -f "$srcdir/src/template/$with_template" ; then
 
1374
              template=$withval
 
1375
            else
 
1376
              { { echo "$as_me:$LINENO: error: '$withval' is not a valid template name. Use 'list' for a list." >&5
 
1377
echo "$as_me: error: '$withval' is not a valid template name. Use 'list' for a list." >&2;}
 
1378
   { (exit 1); exit 1; }; }
 
1379
            fi;;
 
1380
  esac
 
1381
 
 
1382
      ;;
 
1383
  esac
 
1384
 
 
1385
else
 
1386
 
 
1387
# --with-template not given
 
1388
 
 
1389
case $host_os in
 
1390
     aix*) template=aix ;;
 
1391
    beos*) template=beos ;;
 
1392
    bsdi*) template=bsdi ;;
 
1393
  cygwin*) template=cygwin ;;
 
1394
  darwin*) template=darwin ;;
 
1395
    dgux*) template=dgux ;;
 
1396
 freebsd*) template=freebsd ;;
 
1397
    hpux*) template=hpux ;;
 
1398
    irix*) template=irix ;;
 
1399
 linux*|gnu*|k*bsd*-gnu)
 
1400
           template=linux ;;
 
1401
   mingw*) template=win32 ;;
 
1402
  netbsd*) template=netbsd ;;
 
1403
nextstep*) template=nextstep ;;
 
1404
 openbsd*) template=openbsd ;;
 
1405
     osf*) template=osf ;;
 
1406
     qnx*) template=qnx4 ;;
 
1407
     sco*) template=sco ;;
 
1408
 solaris*) template=solaris ;;
 
1409
   sunos*) template=sunos4 ;;
 
1410
 sysv4.2*)
 
1411
        case $host_vendor in
 
1412
          univel) template=univel ;;
 
1413
        esac ;;
 
1414
   sysv4*) template=svr4 ;;
 
1415
   sysv5*) template=unixware ;;
 
1416
  ultrix*) template=ultrix4 ;;
 
1417
esac
 
1418
 
 
1419
  if test x"$template" = x"" ; then
 
1420
    { { echo "$as_me:$LINENO: error:
 
1421
*******************************************************************
 
1422
PostgreSQL has apparently not been ported to your platform yet.
 
1423
To try a manual configuration, look into the src/template directory
 
1424
for a similar platform and use the '--with-template=' option.
 
1425
 
 
1426
Please also contact <pgsql-ports@postgresql.org> to see about
 
1427
rectifying this.  Include the above 'checking host system type...'
 
1428
line.
 
1429
*******************************************************************
 
1430
" >&5
 
1431
echo "$as_me: error:
 
1432
*******************************************************************
 
1433
PostgreSQL has apparently not been ported to your platform yet.
 
1434
To try a manual configuration, look into the src/template directory
 
1435
for a similar platform and use the '--with-template=' option.
 
1436
 
 
1437
Please also contact <pgsql-ports@postgresql.org> to see about
 
1438
rectifying this.  Include the above 'checking host system type...'
 
1439
line.
 
1440
*******************************************************************
 
1441
" >&2;}
 
1442
   { (exit 1); exit 1; }; }
 
1443
  fi
 
1444
 
 
1445
 
 
1446
fi;
 
1447
 
 
1448
 
 
1449
echo "$as_me:$LINENO: result: $template" >&5
 
1450
echo "${ECHO_T}$template" >&6
 
1451
 
 
1452
PORTNAME=$template
 
1453
 
 
1454
 
 
1455
# Initialize default assumption that we do not need separate assembly code
 
1456
# for TAS (test-and-set).  This can be overridden by the template file
 
1457
# when it's executed.
 
1458
need_tas=no
 
1459
tas_file=dummy.s
 
1460
 
 
1461
 
 
1462
 
 
1463
##
 
1464
## Command line options
 
1465
##
 
1466
 
 
1467
#
 
1468
# Installation directory for documentation
 
1469
#
 
1470
 
 
1471
 
 
1472
 
 
1473
# Check whether --with-docdir or --without-docdir was given.
 
1474
if test "${with_docdir+set}" = set; then
 
1475
  withval="$with_docdir"
 
1476
 
 
1477
  case $withval in
 
1478
    yes)
 
1479
      { { echo "$as_me:$LINENO: error: option --with-docdir requires an argument" >&5
 
1480
echo "$as_me: error: option --with-docdir requires an argument" >&2;}
 
1481
   { (exit 1); exit 1; }; }
 
1482
      ;;
 
1483
    no)
 
1484
      docdir=
 
1485
      ;;
 
1486
    *)
 
1487
      docdir=$withval
 
1488
      ;;
 
1489
  esac
 
1490
 
 
1491
else
 
1492
  docdir='${prefix}/doc'
 
1493
fi;
 
1494
 
 
1495
 
 
1496
 
 
1497
 
 
1498
#
 
1499
# Add non-standard directories to the include path
 
1500
#
 
1501
 
 
1502
 
 
1503
 
 
1504
# Check whether --with-includes or --without-includes was given.
 
1505
if test "${with_includes+set}" = set; then
 
1506
  withval="$with_includes"
 
1507
 
 
1508
  case $withval in
 
1509
    yes)
 
1510
      { { echo "$as_me:$LINENO: error: argument required for --with-includes option" >&5
 
1511
echo "$as_me: error: argument required for --with-includes option" >&2;}
 
1512
   { (exit 1); exit 1; }; }
 
1513
      ;;
 
1514
    no)
 
1515
      { { echo "$as_me:$LINENO: error: argument required for --with-includes option" >&5
 
1516
echo "$as_me: error: argument required for --with-includes option" >&2;}
 
1517
   { (exit 1); exit 1; }; }
 
1518
      ;;
 
1519
    *)
 
1520
 
 
1521
      ;;
 
1522
  esac
 
1523
 
 
1524
fi;
 
1525
 
 
1526
 
 
1527
 
 
1528
#
 
1529
# Add non-standard directories to the library search path
 
1530
#
 
1531
 
 
1532
 
 
1533
 
 
1534
# Check whether --with-libraries or --without-libraries was given.
 
1535
if test "${with_libraries+set}" = set; then
 
1536
  withval="$with_libraries"
 
1537
 
 
1538
  case $withval in
 
1539
    yes)
 
1540
      { { echo "$as_me:$LINENO: error: argument required for --with-libraries option" >&5
 
1541
echo "$as_me: error: argument required for --with-libraries option" >&2;}
 
1542
   { (exit 1); exit 1; }; }
 
1543
      ;;
 
1544
    no)
 
1545
      { { echo "$as_me:$LINENO: error: argument required for --with-libraries option" >&5
 
1546
echo "$as_me: error: argument required for --with-libraries option" >&2;}
 
1547
   { (exit 1); exit 1; }; }
 
1548
      ;;
 
1549
    *)
 
1550
      LIBRARY_DIRS=$withval
 
1551
      ;;
 
1552
  esac
 
1553
 
 
1554
fi;
 
1555
 
 
1556
 
 
1557
 
 
1558
 
 
1559
 
 
1560
# Check whether --with-libs or --without-libs was given.
 
1561
if test "${with_libs+set}" = set; then
 
1562
  withval="$with_libs"
 
1563
 
 
1564
  case $withval in
 
1565
    yes)
 
1566
      { { echo "$as_me:$LINENO: error: argument required for --with-libs option" >&5
 
1567
echo "$as_me: error: argument required for --with-libs option" >&2;}
 
1568
   { (exit 1); exit 1; }; }
 
1569
      ;;
 
1570
    no)
 
1571
      { { echo "$as_me:$LINENO: error: argument required for --with-libs option" >&5
 
1572
echo "$as_me: error: argument required for --with-libs option" >&2;}
 
1573
   { (exit 1); exit 1; }; }
 
1574
      ;;
 
1575
    *)
 
1576
      LIBRARY_DIRS=$withval
 
1577
      ;;
 
1578
  esac
 
1579
 
 
1580
fi;
 
1581
 
 
1582
 
 
1583
 
 
1584
#
 
1585
# 64-bit integer date/time storage (--enable-integer-datetimes)
 
1586
#
 
1587
echo "$as_me:$LINENO: checking whether to build with 64-bit integer date/time support" >&5
 
1588
echo $ECHO_N "checking whether to build with 64-bit integer date/time support... $ECHO_C" >&6
 
1589
 
 
1590
 
 
1591
# Check whether --enable-integer-datetimes or --disable-integer-datetimes was given.
 
1592
if test "${enable_integer_datetimes+set}" = set; then
 
1593
  enableval="$enable_integer_datetimes"
 
1594
 
 
1595
  case $enableval in
 
1596
    yes)
 
1597
 
 
1598
cat >>confdefs.h <<\_ACEOF
 
1599
#define USE_INTEGER_DATETIMES 1
 
1600
_ACEOF
 
1601
 
 
1602
      ;;
 
1603
    no)
 
1604
      :
 
1605
      ;;
 
1606
    *)
 
1607
      { { echo "$as_me:$LINENO: error: no argument expected for --enable-integer-datetimes option" >&5
 
1608
echo "$as_me: error: no argument expected for --enable-integer-datetimes option" >&2;}
 
1609
   { (exit 1); exit 1; }; }
 
1610
      ;;
 
1611
  esac
 
1612
 
 
1613
else
 
1614
  enable_integer_datetimes=no
 
1615
 
 
1616
fi;
 
1617
 
 
1618
echo "$as_me:$LINENO: result: $enable_integer_datetimes" >&5
 
1619
echo "${ECHO_T}$enable_integer_datetimes" >&6
 
1620
 
 
1621
 
 
1622
#
 
1623
# NLS
 
1624
#
 
1625
echo "$as_me:$LINENO: checking whether NLS is wanted" >&5
 
1626
echo $ECHO_N "checking whether NLS is wanted... $ECHO_C" >&6
 
1627
 
 
1628
 
 
1629
# Check whether --enable-nls or --disable-nls was given.
 
1630
if test "${enable_nls+set}" = set; then
 
1631
  enableval="$enable_nls"
 
1632
 
 
1633
  case $enableval in
 
1634
    yes)
 
1635
      :
 
1636
      ;;
 
1637
    no)
 
1638
      :
 
1639
      ;;
 
1640
    *)
 
1641
      enable_nls=yes
 
1642
WANTED_LANGUAGES=$enableval
 
1643
      ;;
 
1644
  esac
 
1645
 
 
1646
else
 
1647
  enable_nls=no
 
1648
fi;
 
1649
 
 
1650
 
 
1651
if test "$enable_nls" = yes; then
 
1652
 
 
1653
cat >>confdefs.h <<\_ACEOF
 
1654
#define ENABLE_NLS 1
 
1655
_ACEOF
 
1656
 
 
1657
fi
 
1658
 
 
1659
echo "$as_me:$LINENO: result: $enable_nls" >&5
 
1660
echo "${ECHO_T}$enable_nls" >&6
 
1661
 
 
1662
 
 
1663
 
 
1664
#
 
1665
# Default port number (--with-pgport), default 5432
 
1666
#
 
1667
echo "$as_me:$LINENO: checking for default port number" >&5
 
1668
echo $ECHO_N "checking for default port number... $ECHO_C" >&6
 
1669
 
 
1670
 
 
1671
 
 
1672
# Check whether --with-pgport or --without-pgport was given.
 
1673
if test "${with_pgport+set}" = set; then
 
1674
  withval="$with_pgport"
 
1675
 
 
1676
  case $withval in
 
1677
    yes)
 
1678
      { { echo "$as_me:$LINENO: error: argument required for --with-pgport option" >&5
 
1679
echo "$as_me: error: argument required for --with-pgport option" >&2;}
 
1680
   { (exit 1); exit 1; }; }
 
1681
      ;;
 
1682
    no)
 
1683
      { { echo "$as_me:$LINENO: error: argument required for --with-pgport option" >&5
 
1684
echo "$as_me: error: argument required for --with-pgport option" >&2;}
 
1685
   { (exit 1); exit 1; }; }
 
1686
      ;;
 
1687
    *)
 
1688
      default_port=$withval
 
1689
      ;;
 
1690
  esac
 
1691
 
 
1692
else
 
1693
  default_port=5432
 
1694
fi;
 
1695
 
 
1696
echo "$as_me:$LINENO: result: $default_port" >&5
 
1697
echo "${ECHO_T}$default_port" >&6
 
1698
# Need both of these because some places want an integer and some a string
 
1699
 
 
1700
cat >>confdefs.h <<_ACEOF
 
1701
#define DEF_PGPORT ${default_port}
 
1702
_ACEOF
 
1703
 
 
1704
 
 
1705
cat >>confdefs.h <<_ACEOF
 
1706
#define DEF_PGPORT_STR "${default_port}"
 
1707
_ACEOF
 
1708
 
 
1709
 
 
1710
 
 
1711
#
 
1712
# Option to disable shared libraries
 
1713
#
 
1714
 
 
1715
 
 
1716
# Check whether --enable-shared or --disable-shared was given.
 
1717
if test "${enable_shared+set}" = set; then
 
1718
  enableval="$enable_shared"
 
1719
 
 
1720
  case $enableval in
 
1721
    yes)
 
1722
      :
 
1723
      ;;
 
1724
    no)
 
1725
      :
 
1726
      ;;
 
1727
    *)
 
1728
      { { echo "$as_me:$LINENO: error: no argument expected for --enable-shared option" >&5
 
1729
echo "$as_me: error: no argument expected for --enable-shared option" >&2;}
 
1730
   { (exit 1); exit 1; }; }
 
1731
      ;;
 
1732
  esac
 
1733
 
 
1734
else
 
1735
  enable_shared=yes
 
1736
 
 
1737
fi;
 
1738
 
 
1739
 
 
1740
 
 
1741
#
 
1742
# '-rpath'-like feature can be disabled
 
1743
#
 
1744
 
 
1745
 
 
1746
# Check whether --enable-rpath or --disable-rpath was given.
 
1747
if test "${enable_rpath+set}" = set; then
 
1748
  enableval="$enable_rpath"
 
1749
 
 
1750
  case $enableval in
 
1751
    yes)
 
1752
      :
 
1753
      ;;
 
1754
    no)
 
1755
      :
 
1756
      ;;
 
1757
    *)
 
1758
      { { echo "$as_me:$LINENO: error: no argument expected for --enable-rpath option" >&5
 
1759
echo "$as_me: error: no argument expected for --enable-rpath option" >&2;}
 
1760
   { (exit 1); exit 1; }; }
 
1761
      ;;
 
1762
  esac
 
1763
 
 
1764
else
 
1765
  enable_rpath=yes
 
1766
 
 
1767
fi;
 
1768
 
 
1769
 
 
1770
 
 
1771
#
 
1772
# Spinlocks
 
1773
#
 
1774
 
 
1775
 
 
1776
# Check whether --enable-spinlocks or --disable-spinlocks was given.
 
1777
if test "${enable_spinlocks+set}" = set; then
 
1778
  enableval="$enable_spinlocks"
 
1779
 
 
1780
  case $enableval in
 
1781
    yes)
 
1782
      :
 
1783
      ;;
 
1784
    no)
 
1785
      :
 
1786
      ;;
 
1787
    *)
 
1788
      { { echo "$as_me:$LINENO: error: no argument expected for --enable-spinlocks option" >&5
 
1789
echo "$as_me: error: no argument expected for --enable-spinlocks option" >&2;}
 
1790
   { (exit 1); exit 1; }; }
 
1791
      ;;
 
1792
  esac
 
1793
 
 
1794
else
 
1795
  enable_spinlocks=yes
 
1796
 
 
1797
fi;
 
1798
 
 
1799
 
 
1800
#
 
1801
# --enable-debug adds -g to compiler flags
 
1802
#
 
1803
 
 
1804
 
 
1805
# Check whether --enable-debug or --disable-debug was given.
 
1806
if test "${enable_debug+set}" = set; then
 
1807
  enableval="$enable_debug"
 
1808
 
 
1809
  case $enableval in
 
1810
    yes)
 
1811
      :
 
1812
      ;;
 
1813
    no)
 
1814
      :
 
1815
      ;;
 
1816
    *)
 
1817
      { { echo "$as_me:$LINENO: error: no argument expected for --enable-debug option" >&5
 
1818
echo "$as_me: error: no argument expected for --enable-debug option" >&2;}
 
1819
   { (exit 1); exit 1; }; }
 
1820
      ;;
 
1821
  esac
 
1822
 
 
1823
else
 
1824
  enable_debug=no
 
1825
 
 
1826
fi;
 
1827
 
 
1828
 
 
1829
 
 
1830
#
 
1831
# C compiler
 
1832
#
 
1833
 
 
1834
# For historical reasons you can also use --with-CC to specify the C compiler
 
1835
# to use, although the standard way to do this is to set the CC environment
 
1836
# variable.
 
1837
 
 
1838
 
 
1839
 
 
1840
# Check whether --with-CC or --without-CC was given.
 
1841
if test "${with_CC+set}" = set; then
 
1842
  withval="$with_CC"
 
1843
 
 
1844
  case $withval in
 
1845
    yes)
 
1846
      { { echo "$as_me:$LINENO: error: argument required for --with-CC option" >&5
 
1847
echo "$as_me: error: argument required for --with-CC option" >&2;}
 
1848
   { (exit 1); exit 1; }; }
 
1849
      ;;
 
1850
    no)
 
1851
      { { echo "$as_me:$LINENO: error: argument required for --with-CC option" >&5
 
1852
echo "$as_me: error: argument required for --with-CC option" >&2;}
 
1853
   { (exit 1); exit 1; }; }
 
1854
      ;;
 
1855
    *)
 
1856
      CC=$with_CC
 
1857
      ;;
 
1858
  esac
 
1859
 
 
1860
fi;
 
1861
 
 
1862
 
 
1863
case $template in
 
1864
  aix) pgac_cc_list="gcc xlc";;
 
1865
 irix) pgac_cc_list="cc";; # no gcc
 
1866
    *) pgac_cc_list="gcc cc";;
 
1867
esac
 
1868
 
 
1869
ac_ext=c
 
1870
ac_cpp='$CPP $CPPFLAGS'
 
1871
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
1872
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
1873
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
1874
if test -n "$ac_tool_prefix"; then
 
1875
  for ac_prog in $pgac_cc_list
 
1876
  do
 
1877
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
 
1878
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
 
1879
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
1880
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
1881
if test "${ac_cv_prog_CC+set}" = set; then
 
1882
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
1883
else
 
1884
  if test -n "$CC"; then
 
1885
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
1886
else
 
1887
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
1888
for as_dir in $PATH
 
1889
do
 
1890
  IFS=$as_save_IFS
 
1891
  test -z "$as_dir" && as_dir=.
 
1892
  for ac_exec_ext in '' $ac_executable_extensions; do
 
1893
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
1894
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
 
1895
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
1896
    break 2
 
1897
  fi
 
1898
done
 
1899
done
 
1900
 
 
1901
fi
 
1902
fi
 
1903
CC=$ac_cv_prog_CC
 
1904
if test -n "$CC"; then
 
1905
  echo "$as_me:$LINENO: result: $CC" >&5
 
1906
echo "${ECHO_T}$CC" >&6
 
1907
else
 
1908
  echo "$as_me:$LINENO: result: no" >&5
 
1909
echo "${ECHO_T}no" >&6
 
1910
fi
 
1911
 
 
1912
    test -n "$CC" && break
 
1913
  done
 
1914
fi
 
1915
if test -z "$CC"; then
 
1916
  ac_ct_CC=$CC
 
1917
  for ac_prog in $pgac_cc_list
 
1918
do
 
1919
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
1920
set dummy $ac_prog; ac_word=$2
 
1921
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
1922
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
1923
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
 
1924
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
1925
else
 
1926
  if test -n "$ac_ct_CC"; then
 
1927
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 
1928
else
 
1929
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
1930
for as_dir in $PATH
 
1931
do
 
1932
  IFS=$as_save_IFS
 
1933
  test -z "$as_dir" && as_dir=.
 
1934
  for ac_exec_ext in '' $ac_executable_extensions; do
 
1935
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
1936
    ac_cv_prog_ac_ct_CC="$ac_prog"
 
1937
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
1938
    break 2
 
1939
  fi
 
1940
done
 
1941
done
 
1942
 
 
1943
fi
 
1944
fi
 
1945
ac_ct_CC=$ac_cv_prog_ac_ct_CC
 
1946
if test -n "$ac_ct_CC"; then
 
1947
  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
 
1948
echo "${ECHO_T}$ac_ct_CC" >&6
 
1949
else
 
1950
  echo "$as_me:$LINENO: result: no" >&5
 
1951
echo "${ECHO_T}no" >&6
 
1952
fi
 
1953
 
 
1954
  test -n "$ac_ct_CC" && break
 
1955
done
 
1956
 
 
1957
  CC=$ac_ct_CC
 
1958
fi
 
1959
 
 
1960
 
 
1961
test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH" >&5
 
1962
echo "$as_me: error: no acceptable C compiler found in \$PATH" >&2;}
 
1963
   { (exit 1); exit 1; }; }
 
1964
 
 
1965
# Provide some information about the compiler.
 
1966
echo "$as_me:$LINENO:" \
 
1967
     "checking for C compiler version" >&5
 
1968
ac_compiler=`set X $ac_compile; echo $2`
 
1969
{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
 
1970
  (eval $ac_compiler --version </dev/null >&5) 2>&5
 
1971
  ac_status=$?
 
1972
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
1973
  (exit $ac_status); }
 
1974
{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
 
1975
  (eval $ac_compiler -v </dev/null >&5) 2>&5
 
1976
  ac_status=$?
 
1977
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
1978
  (exit $ac_status); }
 
1979
{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
 
1980
  (eval $ac_compiler -V </dev/null >&5) 2>&5
 
1981
  ac_status=$?
 
1982
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
1983
  (exit $ac_status); }
 
1984
 
 
1985
cat >conftest.$ac_ext <<_ACEOF
 
1986
#line $LINENO "configure"
 
1987
#include "confdefs.h"
 
1988
 
 
1989
#ifdef F77_DUMMY_MAIN
 
1990
#  ifdef __cplusplus
 
1991
     extern "C"
 
1992
#  endif
 
1993
   int F77_DUMMY_MAIN() { return 1; }
 
1994
#endif
 
1995
int
 
1996
main ()
 
1997
{
 
1998
 
 
1999
  ;
 
2000
  return 0;
 
2001
}
 
2002
_ACEOF
 
2003
ac_clean_files_save=$ac_clean_files
 
2004
ac_clean_files="$ac_clean_files a.out a.exe"
 
2005
# Try to create an executable without -o first, disregard a.out.
 
2006
# It will help us diagnose broken compilers, and finding out an intuition
 
2007
# of exeext.
 
2008
echo "$as_me:$LINENO: checking for C compiler default output" >&5
 
2009
echo $ECHO_N "checking for C compiler default output... $ECHO_C" >&6
 
2010
ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
 
2011
if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
 
2012
  (eval $ac_link_default) 2>&5
 
2013
  ac_status=$?
 
2014
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2015
  (exit $ac_status); }; then
 
2016
  # Find the output, starting from the most likely.  This scheme is
 
2017
# not robust to junk in `.', hence go to wildcards (a.*) only as a last
 
2018
# resort.
 
2019
 
 
2020
# Be careful to initialize this variable, since it used to be cached.
 
2021
# Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
 
2022
ac_cv_exeext=
 
2023
for ac_file in `ls a_out.exe a.exe conftest.exe 2>/dev/null;
 
2024
                ls a.out conftest 2>/dev/null;
 
2025
                ls a.* conftest.* 2>/dev/null`; do
 
2026
  case $ac_file in
 
2027
    *.$ac_ext | *.o | *.obj | *.xcoff | *.tds | *.d | *.pdb | *.xSYM ) ;;
 
2028
    a.out ) # We found the default executable, but exeext='' is most
 
2029
            # certainly right.
 
2030
            break;;
 
2031
    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
 
2032
          # FIXME: I believe we export ac_cv_exeext for Libtool --akim.
 
2033
          export ac_cv_exeext
 
2034
          break;;
 
2035
    * ) break;;
 
2036
  esac
 
2037
done
 
2038
else
 
2039
  echo "$as_me: failed program was:" >&5
 
2040
cat conftest.$ac_ext >&5
 
2041
{ { echo "$as_me:$LINENO: error: C compiler cannot create executables" >&5
 
2042
echo "$as_me: error: C compiler cannot create executables" >&2;}
 
2043
   { (exit 77); exit 77; }; }
 
2044
fi
 
2045
 
 
2046
ac_exeext=$ac_cv_exeext
 
2047
echo "$as_me:$LINENO: result: $ac_file" >&5
 
2048
echo "${ECHO_T}$ac_file" >&6
 
2049
 
 
2050
# Check the compiler produces executables we can run.  If not, either
 
2051
# the compiler is broken, or we cross compile.
 
2052
echo "$as_me:$LINENO: checking whether the C compiler works" >&5
 
2053
echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
 
2054
# FIXME: These cross compiler hacks should be removed for Autoconf 3.0
 
2055
# If not cross compiling, check that we can run a simple program.
 
2056
if test "$cross_compiling" != yes; then
 
2057
  if { ac_try='./$ac_file'
 
2058
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
2059
  (eval $ac_try) 2>&5
 
2060
  ac_status=$?
 
2061
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2062
  (exit $ac_status); }; }; then
 
2063
    cross_compiling=no
 
2064
  else
 
2065
    if test "$cross_compiling" = maybe; then
 
2066
        cross_compiling=yes
 
2067
    else
 
2068
        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
 
2069
If you meant to cross compile, use \`--host'." >&5
 
2070
echo "$as_me: error: cannot run C compiled programs.
 
2071
If you meant to cross compile, use \`--host'." >&2;}
 
2072
   { (exit 1); exit 1; }; }
 
2073
    fi
 
2074
  fi
 
2075
fi
 
2076
echo "$as_me:$LINENO: result: yes" >&5
 
2077
echo "${ECHO_T}yes" >&6
 
2078
 
 
2079
rm -f a.out a.exe conftest$ac_cv_exeext
 
2080
ac_clean_files=$ac_clean_files_save
 
2081
# Check the compiler produces executables we can run.  If not, either
 
2082
# the compiler is broken, or we cross compile.
 
2083
echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
 
2084
echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
 
2085
echo "$as_me:$LINENO: result: $cross_compiling" >&5
 
2086
echo "${ECHO_T}$cross_compiling" >&6
 
2087
 
 
2088
echo "$as_me:$LINENO: checking for suffix of executables" >&5
 
2089
echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
 
2090
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
2091
  (eval $ac_link) 2>&5
 
2092
  ac_status=$?
 
2093
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2094
  (exit $ac_status); }; then
 
2095
  # If both `conftest.exe' and `conftest' are `present' (well, observable)
 
2096
# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
 
2097
# work properly (i.e., refer to `conftest.exe'), while it won't with
 
2098
# `rm'.
 
2099
for ac_file in `(ls conftest.exe; ls conftest; ls conftest.*) 2>/dev/null`; do
 
2100
  case $ac_file in
 
2101
    *.$ac_ext | *.o | *.obj | *.xcoff | *.tds | *.d | *.pdb ) ;;
 
2102
    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
 
2103
          export ac_cv_exeext
 
2104
          break;;
 
2105
    * ) break;;
 
2106
  esac
 
2107
done
 
2108
else
 
2109
  { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link" >&5
 
2110
echo "$as_me: error: cannot compute suffix of executables: cannot compile and link" >&2;}
 
2111
   { (exit 1); exit 1; }; }
 
2112
fi
 
2113
 
 
2114
rm -f conftest$ac_cv_exeext
 
2115
echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
 
2116
echo "${ECHO_T}$ac_cv_exeext" >&6
 
2117
 
 
2118
rm -f conftest.$ac_ext
 
2119
EXEEXT=$ac_cv_exeext
 
2120
ac_exeext=$EXEEXT
 
2121
echo "$as_me:$LINENO: checking for suffix of object files" >&5
 
2122
echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
 
2123
if test "${ac_cv_objext+set}" = set; then
 
2124
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
2125
else
 
2126
  cat >conftest.$ac_ext <<_ACEOF
 
2127
#line $LINENO "configure"
 
2128
#include "confdefs.h"
 
2129
 
 
2130
#ifdef F77_DUMMY_MAIN
 
2131
#  ifdef __cplusplus
 
2132
     extern "C"
 
2133
#  endif
 
2134
   int F77_DUMMY_MAIN() { return 1; }
 
2135
#endif
 
2136
int
 
2137
main ()
 
2138
{
 
2139
 
 
2140
  ;
 
2141
  return 0;
 
2142
}
 
2143
_ACEOF
 
2144
rm -f conftest.o conftest.obj
 
2145
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
2146
  (eval $ac_compile) 2>&5
 
2147
  ac_status=$?
 
2148
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2149
  (exit $ac_status); }; then
 
2150
  for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
 
2151
  case $ac_file in
 
2152
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb ) ;;
 
2153
    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
 
2154
       break;;
 
2155
  esac
 
2156
done
 
2157
else
 
2158
  echo "$as_me: failed program was:" >&5
 
2159
cat conftest.$ac_ext >&5
 
2160
{ { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile" >&5
 
2161
echo "$as_me: error: cannot compute suffix of object files: cannot compile" >&2;}
 
2162
   { (exit 1); exit 1; }; }
 
2163
fi
 
2164
 
 
2165
rm -f conftest.$ac_cv_objext conftest.$ac_ext
 
2166
fi
 
2167
echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
 
2168
echo "${ECHO_T}$ac_cv_objext" >&6
 
2169
OBJEXT=$ac_cv_objext
 
2170
ac_objext=$OBJEXT
 
2171
echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
 
2172
echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
 
2173
if test "${ac_cv_c_compiler_gnu+set}" = set; then
 
2174
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
2175
else
 
2176
  cat >conftest.$ac_ext <<_ACEOF
 
2177
#line $LINENO "configure"
 
2178
#include "confdefs.h"
 
2179
 
 
2180
#ifdef F77_DUMMY_MAIN
 
2181
#  ifdef __cplusplus
 
2182
     extern "C"
 
2183
#  endif
 
2184
   int F77_DUMMY_MAIN() { return 1; }
 
2185
#endif
 
2186
int
 
2187
main ()
 
2188
{
 
2189
#ifndef __GNUC__
 
2190
       choke me
 
2191
#endif
 
2192
 
 
2193
  ;
 
2194
  return 0;
 
2195
}
 
2196
_ACEOF
 
2197
rm -f conftest.$ac_objext
 
2198
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
2199
  (eval $ac_compile) 2>&5
 
2200
  ac_status=$?
 
2201
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2202
  (exit $ac_status); } &&
 
2203
         { ac_try='test -s conftest.$ac_objext'
 
2204
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
2205
  (eval $ac_try) 2>&5
 
2206
  ac_status=$?
 
2207
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2208
  (exit $ac_status); }; }; then
 
2209
  ac_compiler_gnu=yes
 
2210
else
 
2211
  echo "$as_me: failed program was:" >&5
 
2212
cat conftest.$ac_ext >&5
 
2213
ac_compiler_gnu=no
 
2214
fi
 
2215
rm -f conftest.$ac_objext conftest.$ac_ext
 
2216
ac_cv_c_compiler_gnu=$ac_compiler_gnu
 
2217
 
 
2218
fi
 
2219
echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
 
2220
echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
 
2221
GCC=`test $ac_compiler_gnu = yes && echo yes`
 
2222
ac_test_CFLAGS=${CFLAGS+set}
 
2223
ac_save_CFLAGS=$CFLAGS
 
2224
CFLAGS="-g"
 
2225
echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
 
2226
echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
 
2227
if test "${ac_cv_prog_cc_g+set}" = set; then
 
2228
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
2229
else
 
2230
  cat >conftest.$ac_ext <<_ACEOF
 
2231
#line $LINENO "configure"
 
2232
#include "confdefs.h"
 
2233
 
 
2234
#ifdef F77_DUMMY_MAIN
 
2235
#  ifdef __cplusplus
 
2236
     extern "C"
 
2237
#  endif
 
2238
   int F77_DUMMY_MAIN() { return 1; }
 
2239
#endif
 
2240
int
 
2241
main ()
 
2242
{
 
2243
 
 
2244
  ;
 
2245
  return 0;
 
2246
}
 
2247
_ACEOF
 
2248
rm -f conftest.$ac_objext
 
2249
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
2250
  (eval $ac_compile) 2>&5
 
2251
  ac_status=$?
 
2252
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2253
  (exit $ac_status); } &&
 
2254
         { ac_try='test -s conftest.$ac_objext'
 
2255
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
2256
  (eval $ac_try) 2>&5
 
2257
  ac_status=$?
 
2258
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2259
  (exit $ac_status); }; }; then
 
2260
  ac_cv_prog_cc_g=yes
 
2261
else
 
2262
  echo "$as_me: failed program was:" >&5
 
2263
cat conftest.$ac_ext >&5
 
2264
ac_cv_prog_cc_g=no
 
2265
fi
 
2266
rm -f conftest.$ac_objext conftest.$ac_ext
 
2267
fi
 
2268
echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
 
2269
echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
 
2270
if test "$ac_test_CFLAGS" = set; then
 
2271
  CFLAGS=$ac_save_CFLAGS
 
2272
elif test $ac_cv_prog_cc_g = yes; then
 
2273
  if test "$GCC" = yes; then
 
2274
    CFLAGS="-g -O2"
 
2275
  else
 
2276
    CFLAGS="-g"
 
2277
  fi
 
2278
else
 
2279
  if test "$GCC" = yes; then
 
2280
    CFLAGS="-O2"
 
2281
  else
 
2282
    CFLAGS=
 
2283
  fi
 
2284
fi
 
2285
# Some people use a C++ compiler to compile C.  Since we use `exit',
 
2286
# in C++ we need to declare it.  In case someone uses the same compiler
 
2287
# for both compiling C and C++ we need to have the C++ compiler decide
 
2288
# the declaration of exit, since it's the most demanding environment.
 
2289
cat >conftest.$ac_ext <<_ACEOF
 
2290
#ifndef __cplusplus
 
2291
  choke me
 
2292
#endif
 
2293
_ACEOF
 
2294
rm -f conftest.$ac_objext
 
2295
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
2296
  (eval $ac_compile) 2>&5
 
2297
  ac_status=$?
 
2298
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2299
  (exit $ac_status); } &&
 
2300
         { ac_try='test -s conftest.$ac_objext'
 
2301
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
2302
  (eval $ac_try) 2>&5
 
2303
  ac_status=$?
 
2304
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2305
  (exit $ac_status); }; }; then
 
2306
  for ac_declaration in \
 
2307
   ''\
 
2308
   '#include <stdlib.h>' \
 
2309
   'extern "C" void std::exit (int) throw (); using std::exit;' \
 
2310
   'extern "C" void std::exit (int); using std::exit;' \
 
2311
   'extern "C" void exit (int) throw ();' \
 
2312
   'extern "C" void exit (int);' \
 
2313
   'void exit (int);'
 
2314
do
 
2315
  cat >conftest.$ac_ext <<_ACEOF
 
2316
#line $LINENO "configure"
 
2317
#include "confdefs.h"
 
2318
#include <stdlib.h>
 
2319
$ac_declaration
 
2320
#ifdef F77_DUMMY_MAIN
 
2321
#  ifdef __cplusplus
 
2322
     extern "C"
 
2323
#  endif
 
2324
   int F77_DUMMY_MAIN() { return 1; }
 
2325
#endif
 
2326
int
 
2327
main ()
 
2328
{
 
2329
exit (42);
 
2330
  ;
 
2331
  return 0;
 
2332
}
 
2333
_ACEOF
 
2334
rm -f conftest.$ac_objext
 
2335
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
2336
  (eval $ac_compile) 2>&5
 
2337
  ac_status=$?
 
2338
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2339
  (exit $ac_status); } &&
 
2340
         { ac_try='test -s conftest.$ac_objext'
 
2341
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
2342
  (eval $ac_try) 2>&5
 
2343
  ac_status=$?
 
2344
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2345
  (exit $ac_status); }; }; then
 
2346
  :
 
2347
else
 
2348
  echo "$as_me: failed program was:" >&5
 
2349
cat conftest.$ac_ext >&5
 
2350
continue
 
2351
fi
 
2352
rm -f conftest.$ac_objext conftest.$ac_ext
 
2353
  cat >conftest.$ac_ext <<_ACEOF
 
2354
#line $LINENO "configure"
 
2355
#include "confdefs.h"
 
2356
$ac_declaration
 
2357
#ifdef F77_DUMMY_MAIN
 
2358
#  ifdef __cplusplus
 
2359
     extern "C"
 
2360
#  endif
 
2361
   int F77_DUMMY_MAIN() { return 1; }
 
2362
#endif
 
2363
int
 
2364
main ()
 
2365
{
 
2366
exit (42);
 
2367
  ;
 
2368
  return 0;
 
2369
}
 
2370
_ACEOF
 
2371
rm -f conftest.$ac_objext
 
2372
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
2373
  (eval $ac_compile) 2>&5
 
2374
  ac_status=$?
 
2375
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2376
  (exit $ac_status); } &&
 
2377
         { ac_try='test -s conftest.$ac_objext'
 
2378
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
2379
  (eval $ac_try) 2>&5
 
2380
  ac_status=$?
 
2381
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2382
  (exit $ac_status); }; }; then
 
2383
  break
 
2384
else
 
2385
  echo "$as_me: failed program was:" >&5
 
2386
cat conftest.$ac_ext >&5
 
2387
fi
 
2388
rm -f conftest.$ac_objext conftest.$ac_ext
 
2389
done
 
2390
rm -f conftest*
 
2391
if test -n "$ac_declaration"; then
 
2392
  echo '#ifdef __cplusplus' >>confdefs.h
 
2393
  echo $ac_declaration      >>confdefs.h
 
2394
  echo '#endif'             >>confdefs.h
 
2395
fi
 
2396
 
 
2397
else
 
2398
  echo "$as_me: failed program was:" >&5
 
2399
cat conftest.$ac_ext >&5
 
2400
fi
 
2401
rm -f conftest.$ac_objext conftest.$ac_ext
 
2402
ac_ext=c
 
2403
ac_cpp='$CPP $CPPFLAGS'
 
2404
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
2405
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
2406
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
2407
 
 
2408
 
 
2409
unset CFLAGS
 
2410
 
 
2411
#
 
2412
# Read the template
 
2413
#
 
2414
. "$srcdir/src/template/$template" || exit
 
2415
 
 
2416
# CFLAGS are selected so:
 
2417
# If the user specifies something in the environment, that is used.
 
2418
# else:  If the template file set something, that is used.
 
2419
# else:  If the compiler is GCC, then we use -O2.
 
2420
# else:  If the compiler is something else, then we use -0.
 
2421
 
 
2422
if test "$ac_env_CFLAGS_set" = set; then
 
2423
  CFLAGS=$ac_env_CFLAGS_value
 
2424
elif test "${CFLAGS+set}" = set; then
 
2425
  : # (keep what template set)
 
2426
elif test "$GCC" = yes; then
 
2427
  CFLAGS="-O2"
 
2428
else
 
2429
  # if the user selected debug mode, don't use -O
 
2430
  if test "$enable_debug" != yes; then
 
2431
    CFLAGS="-O"
 
2432
  fi
 
2433
fi
 
2434
 
 
2435
if test "$GCC" = yes; then
 
2436
  CFLAGS="$CFLAGS -Wall -Wmissing-prototypes -Wpointer-arith"
 
2437
 
 
2438
  # Some versions of GCC support some additional useful warning flags.
 
2439
  # Check whether they are supported, and add them to CFLAGS if so.
 
2440
  echo "$as_me:$LINENO: checking if $CC supports -Wdeclaration-after-statement" >&5
 
2441
echo $ECHO_N "checking if $CC supports -Wdeclaration-after-statement... $ECHO_C" >&6
 
2442
pgac_save_CFLAGS=$CFLAGS
 
2443
CFLAGS="$pgac_save_CFLAGS -Wdeclaration-after-statement"
 
2444
cat >conftest.$ac_ext <<_ACEOF
 
2445
#line $LINENO "configure"
 
2446
#include "confdefs.h"
 
2447
 
 
2448
#ifdef F77_DUMMY_MAIN
 
2449
#  ifdef __cplusplus
 
2450
     extern "C"
 
2451
#  endif
 
2452
   int F77_DUMMY_MAIN() { return 1; }
 
2453
#endif
 
2454
int
 
2455
main ()
 
2456
{
 
2457
 
 
2458
  ;
 
2459
  return 0;
 
2460
}
 
2461
_ACEOF
 
2462
rm -f conftest.$ac_objext
 
2463
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
2464
  (eval $ac_compile) 2>&5
 
2465
  ac_status=$?
 
2466
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2467
  (exit $ac_status); } &&
 
2468
         { ac_try='test -s conftest.$ac_objext'
 
2469
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
2470
  (eval $ac_try) 2>&5
 
2471
  ac_status=$?
 
2472
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2473
  (exit $ac_status); }; }; then
 
2474
  echo "$as_me:$LINENO: result: yes" >&5
 
2475
echo "${ECHO_T}yes" >&6
 
2476
else
 
2477
  echo "$as_me: failed program was:" >&5
 
2478
cat conftest.$ac_ext >&5
 
2479
CFLAGS="$pgac_save_CFLAGS"
 
2480
                    echo "$as_me:$LINENO: result: no" >&5
 
2481
echo "${ECHO_T}no" >&6
 
2482
fi
 
2483
rm -f conftest.$ac_objext conftest.$ac_ext
 
2484
 
 
2485
  echo "$as_me:$LINENO: checking if $CC supports -Wold-style-definition" >&5
 
2486
echo $ECHO_N "checking if $CC supports -Wold-style-definition... $ECHO_C" >&6
 
2487
pgac_save_CFLAGS=$CFLAGS
 
2488
CFLAGS="$pgac_save_CFLAGS -Wold-style-definition"
 
2489
cat >conftest.$ac_ext <<_ACEOF
 
2490
#line $LINENO "configure"
 
2491
#include "confdefs.h"
 
2492
 
 
2493
#ifdef F77_DUMMY_MAIN
 
2494
#  ifdef __cplusplus
 
2495
     extern "C"
 
2496
#  endif
 
2497
   int F77_DUMMY_MAIN() { return 1; }
 
2498
#endif
 
2499
int
 
2500
main ()
 
2501
{
 
2502
 
 
2503
  ;
 
2504
  return 0;
 
2505
}
 
2506
_ACEOF
 
2507
rm -f conftest.$ac_objext
 
2508
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
2509
  (eval $ac_compile) 2>&5
 
2510
  ac_status=$?
 
2511
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2512
  (exit $ac_status); } &&
 
2513
         { ac_try='test -s conftest.$ac_objext'
 
2514
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
2515
  (eval $ac_try) 2>&5
 
2516
  ac_status=$?
 
2517
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2518
  (exit $ac_status); }; }; then
 
2519
  echo "$as_me:$LINENO: result: yes" >&5
 
2520
echo "${ECHO_T}yes" >&6
 
2521
else
 
2522
  echo "$as_me: failed program was:" >&5
 
2523
cat conftest.$ac_ext >&5
 
2524
CFLAGS="$pgac_save_CFLAGS"
 
2525
                    echo "$as_me:$LINENO: result: no" >&5
 
2526
echo "${ECHO_T}no" >&6
 
2527
fi
 
2528
rm -f conftest.$ac_objext conftest.$ac_ext
 
2529
 
 
2530
  echo "$as_me:$LINENO: checking if $CC supports -Wendif-labels" >&5
 
2531
echo $ECHO_N "checking if $CC supports -Wendif-labels... $ECHO_C" >&6
 
2532
pgac_save_CFLAGS=$CFLAGS
 
2533
CFLAGS="$pgac_save_CFLAGS -Wendif-labels"
 
2534
cat >conftest.$ac_ext <<_ACEOF
 
2535
#line $LINENO "configure"
 
2536
#include "confdefs.h"
 
2537
 
 
2538
#ifdef F77_DUMMY_MAIN
 
2539
#  ifdef __cplusplus
 
2540
     extern "C"
 
2541
#  endif
 
2542
   int F77_DUMMY_MAIN() { return 1; }
 
2543
#endif
 
2544
int
 
2545
main ()
 
2546
{
 
2547
 
 
2548
  ;
 
2549
  return 0;
 
2550
}
 
2551
_ACEOF
 
2552
rm -f conftest.$ac_objext
 
2553
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
2554
  (eval $ac_compile) 2>&5
 
2555
  ac_status=$?
 
2556
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2557
  (exit $ac_status); } &&
 
2558
         { ac_try='test -s conftest.$ac_objext'
 
2559
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
2560
  (eval $ac_try) 2>&5
 
2561
  ac_status=$?
 
2562
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2563
  (exit $ac_status); }; }; then
 
2564
  echo "$as_me:$LINENO: result: yes" >&5
 
2565
echo "${ECHO_T}yes" >&6
 
2566
else
 
2567
  echo "$as_me: failed program was:" >&5
 
2568
cat conftest.$ac_ext >&5
 
2569
CFLAGS="$pgac_save_CFLAGS"
 
2570
                    echo "$as_me:$LINENO: result: no" >&5
 
2571
echo "${ECHO_T}no" >&6
 
2572
fi
 
2573
rm -f conftest.$ac_objext conftest.$ac_ext
 
2574
 
 
2575
 
 
2576
  # Disable strict-aliasing rules; needed for gcc 3.3+
 
2577
  echo "$as_me:$LINENO: checking if $CC supports -fno-strict-aliasing" >&5
 
2578
echo $ECHO_N "checking if $CC supports -fno-strict-aliasing... $ECHO_C" >&6
 
2579
pgac_save_CFLAGS=$CFLAGS
 
2580
CFLAGS="$pgac_save_CFLAGS -fno-strict-aliasing"
 
2581
cat >conftest.$ac_ext <<_ACEOF
 
2582
#line $LINENO "configure"
 
2583
#include "confdefs.h"
 
2584
 
 
2585
#ifdef F77_DUMMY_MAIN
 
2586
#  ifdef __cplusplus
 
2587
     extern "C"
 
2588
#  endif
 
2589
   int F77_DUMMY_MAIN() { return 1; }
 
2590
#endif
 
2591
int
 
2592
main ()
 
2593
{
 
2594
 
 
2595
  ;
 
2596
  return 0;
 
2597
}
 
2598
_ACEOF
 
2599
rm -f conftest.$ac_objext
 
2600
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
2601
  (eval $ac_compile) 2>&5
 
2602
  ac_status=$?
 
2603
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2604
  (exit $ac_status); } &&
 
2605
         { ac_try='test -s conftest.$ac_objext'
 
2606
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
2607
  (eval $ac_try) 2>&5
 
2608
  ac_status=$?
 
2609
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2610
  (exit $ac_status); }; }; then
 
2611
  echo "$as_me:$LINENO: result: yes" >&5
 
2612
echo "${ECHO_T}yes" >&6
 
2613
else
 
2614
  echo "$as_me: failed program was:" >&5
 
2615
cat conftest.$ac_ext >&5
 
2616
CFLAGS="$pgac_save_CFLAGS"
 
2617
                    echo "$as_me:$LINENO: result: no" >&5
 
2618
echo "${ECHO_T}no" >&6
 
2619
fi
 
2620
rm -f conftest.$ac_objext conftest.$ac_ext
 
2621
 
 
2622
fi
 
2623
 
 
2624
# supply -g if --enable-debug
 
2625
if test "$enable_debug" = yes && test "$ac_cv_prog_cc_g" = yes; then
 
2626
  CFLAGS="$CFLAGS -g"
 
2627
fi
 
2628
 
 
2629
{ echo "$as_me:$LINENO: using CFLAGS=$CFLAGS" >&5
 
2630
echo "$as_me: using CFLAGS=$CFLAGS" >&6;}
 
2631
 
 
2632
# We already have this in Makefile.win32, but configure needs it too
 
2633
if test "$PORTNAME" = "win32"; then
 
2634
  CPPFLAGS="$CPPFLAGS -I$srcdir/src/include/port/win32 -DEXEC_BACKEND"
 
2635
fi
 
2636
 
 
2637
# Check if the compiler still works with the template settings
 
2638
echo "$as_me:$LINENO: checking whether the C compiler still works" >&5
 
2639
echo $ECHO_N "checking whether the C compiler still works... $ECHO_C" >&6
 
2640
 
 
2641
cat >conftest.$ac_ext <<_ACEOF
 
2642
#line $LINENO "configure"
 
2643
#include "confdefs.h"
 
2644
 
 
2645
#ifdef F77_DUMMY_MAIN
 
2646
#  ifdef __cplusplus
 
2647
     extern "C"
 
2648
#  endif
 
2649
   int F77_DUMMY_MAIN() { return 1; }
 
2650
#endif
 
2651
int
 
2652
main ()
 
2653
{
 
2654
return 0;
 
2655
  ;
 
2656
  return 0;
 
2657
}
 
2658
_ACEOF
 
2659
rm -f conftest.$ac_objext conftest$ac_exeext
 
2660
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
2661
  (eval $ac_link) 2>&5
 
2662
  ac_status=$?
 
2663
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2664
  (exit $ac_status); } &&
 
2665
         { ac_try='test -s conftest$ac_exeext'
 
2666
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
2667
  (eval $ac_try) 2>&5
 
2668
  ac_status=$?
 
2669
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2670
  (exit $ac_status); }; }; then
 
2671
  echo "$as_me:$LINENO: result: yes" >&5
 
2672
echo "${ECHO_T}yes" >&6
 
2673
else
 
2674
  echo "$as_me: failed program was:" >&5
 
2675
cat conftest.$ac_ext >&5
 
2676
echo "$as_me:$LINENO: result: no" >&5
 
2677
echo "${ECHO_T}no" >&6
 
2678
   { { echo "$as_me:$LINENO: error: cannot proceed" >&5
 
2679
echo "$as_me: error: cannot proceed" >&2;}
 
2680
   { (exit 1); exit 1; }; }
 
2681
fi
 
2682
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
2683
 
 
2684
# Defend against gcc -ffast-math
 
2685
if test "$GCC" = yes; then
 
2686
cat >conftest.$ac_ext <<_ACEOF
 
2687
#line $LINENO "configure"
 
2688
#include "confdefs.h"
 
2689
 
 
2690
#ifdef F77_DUMMY_MAIN
 
2691
#  ifdef __cplusplus
 
2692
     extern "C"
 
2693
#  endif
 
2694
   int F77_DUMMY_MAIN() { return 1; }
 
2695
#endif
 
2696
int
 
2697
main ()
 
2698
{
 
2699
#ifdef __FAST_MATH__
 
2700
choke me
 
2701
#endif
 
2702
  ;
 
2703
  return 0;
 
2704
}
 
2705
_ACEOF
 
2706
rm -f conftest.$ac_objext
 
2707
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
2708
  (eval $ac_compile) 2>&5
 
2709
  ac_status=$?
 
2710
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2711
  (exit $ac_status); } &&
 
2712
         { ac_try='test -s conftest.$ac_objext'
 
2713
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
2714
  (eval $ac_try) 2>&5
 
2715
  ac_status=$?
 
2716
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2717
  (exit $ac_status); }; }; then
 
2718
  :
 
2719
else
 
2720
  echo "$as_me: failed program was:" >&5
 
2721
cat conftest.$ac_ext >&5
 
2722
{ { echo "$as_me:$LINENO: error: do not put -ffast-math in CFLAGS" >&5
 
2723
echo "$as_me: error: do not put -ffast-math in CFLAGS" >&2;}
 
2724
   { (exit 1); exit 1; }; }
 
2725
fi
 
2726
rm -f conftest.$ac_objext conftest.$ac_ext
 
2727
fi
 
2728
 
 
2729
ac_ext=c
 
2730
ac_cpp='$CPP $CPPFLAGS'
 
2731
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
2732
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
2733
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
2734
echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
 
2735
echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
 
2736
# On Suns, sometimes $CPP names a directory.
 
2737
if test -n "$CPP" && test -d "$CPP"; then
 
2738
  CPP=
 
2739
fi
 
2740
if test -z "$CPP"; then
 
2741
  if test "${ac_cv_prog_CPP+set}" = set; then
 
2742
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
2743
else
 
2744
      # Double quotes because CPP needs to be expanded
 
2745
    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
 
2746
    do
 
2747
      ac_preproc_ok=false
 
2748
for ac_c_preproc_warn_flag in '' yes
 
2749
do
 
2750
  # Use a header file that comes with gcc, so configuring glibc
 
2751
  # with a fresh cross-compiler works.
 
2752
  # On the NeXT, cc -E runs the code through the compiler's parser,
 
2753
  # not just through cpp. "Syntax error" is here to catch this case.
 
2754
  cat >conftest.$ac_ext <<_ACEOF
 
2755
#line $LINENO "configure"
 
2756
#include "confdefs.h"
 
2757
#include <assert.h>
 
2758
                     Syntax error
 
2759
_ACEOF
 
2760
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
2761
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
2762
  ac_status=$?
 
2763
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
2764
  rm -f conftest.er1
 
2765
  cat conftest.err >&5
 
2766
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2767
  (exit $ac_status); } >/dev/null; then
 
2768
  if test -s conftest.err; then
 
2769
    ac_cpp_err=$ac_c_preproc_warn_flag
 
2770
  else
 
2771
    ac_cpp_err=
 
2772
  fi
 
2773
else
 
2774
  ac_cpp_err=yes
 
2775
fi
 
2776
if test -z "$ac_cpp_err"; then
 
2777
  :
 
2778
else
 
2779
  echo "$as_me: failed program was:" >&5
 
2780
  cat conftest.$ac_ext >&5
 
2781
  # Broken: fails on valid input.
 
2782
continue
 
2783
fi
 
2784
rm -f conftest.err conftest.$ac_ext
 
2785
 
 
2786
  # OK, works on sane cases.  Now check whether non-existent headers
 
2787
  # can be detected and how.
 
2788
  cat >conftest.$ac_ext <<_ACEOF
 
2789
#line $LINENO "configure"
 
2790
#include "confdefs.h"
 
2791
#include <ac_nonexistent.h>
 
2792
_ACEOF
 
2793
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
2794
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
2795
  ac_status=$?
 
2796
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
2797
  rm -f conftest.er1
 
2798
  cat conftest.err >&5
 
2799
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2800
  (exit $ac_status); } >/dev/null; then
 
2801
  if test -s conftest.err; then
 
2802
    ac_cpp_err=$ac_c_preproc_warn_flag
 
2803
  else
 
2804
    ac_cpp_err=
 
2805
  fi
 
2806
else
 
2807
  ac_cpp_err=yes
 
2808
fi
 
2809
if test -z "$ac_cpp_err"; then
 
2810
  # Broken: success on invalid input.
 
2811
continue
 
2812
else
 
2813
  echo "$as_me: failed program was:" >&5
 
2814
  cat conftest.$ac_ext >&5
 
2815
  # Passes both tests.
 
2816
ac_preproc_ok=:
 
2817
break
 
2818
fi
 
2819
rm -f conftest.err conftest.$ac_ext
 
2820
 
 
2821
done
 
2822
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
 
2823
rm -f conftest.err conftest.$ac_ext
 
2824
if $ac_preproc_ok; then
 
2825
  break
 
2826
fi
 
2827
 
 
2828
    done
 
2829
    ac_cv_prog_CPP=$CPP
 
2830
 
 
2831
fi
 
2832
  CPP=$ac_cv_prog_CPP
 
2833
else
 
2834
  ac_cv_prog_CPP=$CPP
 
2835
fi
 
2836
echo "$as_me:$LINENO: result: $CPP" >&5
 
2837
echo "${ECHO_T}$CPP" >&6
 
2838
ac_preproc_ok=false
 
2839
for ac_c_preproc_warn_flag in '' yes
 
2840
do
 
2841
  # Use a header file that comes with gcc, so configuring glibc
 
2842
  # with a fresh cross-compiler works.
 
2843
  # On the NeXT, cc -E runs the code through the compiler's parser,
 
2844
  # not just through cpp. "Syntax error" is here to catch this case.
 
2845
  cat >conftest.$ac_ext <<_ACEOF
 
2846
#line $LINENO "configure"
 
2847
#include "confdefs.h"
 
2848
#include <assert.h>
 
2849
                     Syntax error
 
2850
_ACEOF
 
2851
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
2852
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
2853
  ac_status=$?
 
2854
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
2855
  rm -f conftest.er1
 
2856
  cat conftest.err >&5
 
2857
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2858
  (exit $ac_status); } >/dev/null; then
 
2859
  if test -s conftest.err; then
 
2860
    ac_cpp_err=$ac_c_preproc_warn_flag
 
2861
  else
 
2862
    ac_cpp_err=
 
2863
  fi
 
2864
else
 
2865
  ac_cpp_err=yes
 
2866
fi
 
2867
if test -z "$ac_cpp_err"; then
 
2868
  :
 
2869
else
 
2870
  echo "$as_me: failed program was:" >&5
 
2871
  cat conftest.$ac_ext >&5
 
2872
  # Broken: fails on valid input.
 
2873
continue
 
2874
fi
 
2875
rm -f conftest.err conftest.$ac_ext
 
2876
 
 
2877
  # OK, works on sane cases.  Now check whether non-existent headers
 
2878
  # can be detected and how.
 
2879
  cat >conftest.$ac_ext <<_ACEOF
 
2880
#line $LINENO "configure"
 
2881
#include "confdefs.h"
 
2882
#include <ac_nonexistent.h>
 
2883
_ACEOF
 
2884
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
2885
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
2886
  ac_status=$?
 
2887
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
2888
  rm -f conftest.er1
 
2889
  cat conftest.err >&5
 
2890
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
2891
  (exit $ac_status); } >/dev/null; then
 
2892
  if test -s conftest.err; then
 
2893
    ac_cpp_err=$ac_c_preproc_warn_flag
 
2894
  else
 
2895
    ac_cpp_err=
 
2896
  fi
 
2897
else
 
2898
  ac_cpp_err=yes
 
2899
fi
 
2900
if test -z "$ac_cpp_err"; then
 
2901
  # Broken: success on invalid input.
 
2902
continue
 
2903
else
 
2904
  echo "$as_me: failed program was:" >&5
 
2905
  cat conftest.$ac_ext >&5
 
2906
  # Passes both tests.
 
2907
ac_preproc_ok=:
 
2908
break
 
2909
fi
 
2910
rm -f conftest.err conftest.$ac_ext
 
2911
 
 
2912
done
 
2913
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
 
2914
rm -f conftest.err conftest.$ac_ext
 
2915
if $ac_preproc_ok; then
 
2916
  :
 
2917
else
 
2918
  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check" >&5
 
2919
echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check" >&2;}
 
2920
   { (exit 1); exit 1; }; }
 
2921
fi
 
2922
 
 
2923
ac_ext=c
 
2924
ac_cpp='$CPP $CPPFLAGS'
 
2925
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
2926
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
2927
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
2928
 
 
2929
 
 
2930
 
 
2931
# Create compiler version string
 
2932
if test x"$GCC" = x"yes" ; then
 
2933
  cc_string="GCC `${CC} --version | sed q`"
 
2934
else
 
2935
  cc_string=$CC
 
2936
fi
 
2937
 
 
2938
cat >>confdefs.h <<_ACEOF
 
2939
#define PG_VERSION_STR "PostgreSQL $PACKAGE_VERSION on $host, compiled by $cc_string"
 
2940
_ACEOF
 
2941
 
 
2942
 
 
2943
 
 
2944
#
 
2945
# Set up TAS assembly code if needed; the template file has now had its
 
2946
# chance to request this.
 
2947
#
 
2948
ac_config_links="$ac_config_links src/backend/port/tas.s:src/backend/port/tas/${tas_file}"
 
2949
 
 
2950
 
 
2951
if test "$need_tas" = yes ; then
 
2952
  TAS=tas.o
 
2953
else
 
2954
  TAS=""
 
2955
fi
 
2956
 
 
2957
 
 
2958
 
 
2959
#
 
2960
# Automatic dependency tracking
 
2961
#
 
2962
 
 
2963
 
 
2964
# Check whether --enable-depend or --disable-depend was given.
 
2965
if test "${enable_depend+set}" = set; then
 
2966
  enableval="$enable_depend"
 
2967
 
 
2968
  case $enableval in
 
2969
    yes)
 
2970
      autodepend=yes
 
2971
      ;;
 
2972
    no)
 
2973
      :
 
2974
      ;;
 
2975
    *)
 
2976
      { { echo "$as_me:$LINENO: error: no argument expected for --enable-depend option" >&5
 
2977
echo "$as_me: error: no argument expected for --enable-depend option" >&2;}
 
2978
   { (exit 1); exit 1; }; }
 
2979
      ;;
 
2980
  esac
 
2981
 
 
2982
else
 
2983
  enable_depend=no
 
2984
 
 
2985
fi;
 
2986
 
 
2987
 
 
2988
 
 
2989
 
 
2990
#
 
2991
# Enable assert checks
 
2992
#
 
2993
 
 
2994
 
 
2995
# Check whether --enable-cassert or --disable-cassert was given.
 
2996
if test "${enable_cassert+set}" = set; then
 
2997
  enableval="$enable_cassert"
 
2998
 
 
2999
  case $enableval in
 
3000
    yes)
 
3001
 
 
3002
cat >>confdefs.h <<\_ACEOF
 
3003
#define USE_ASSERT_CHECKING 1
 
3004
_ACEOF
 
3005
 
 
3006
      ;;
 
3007
    no)
 
3008
      :
 
3009
      ;;
 
3010
    *)
 
3011
      { { echo "$as_me:$LINENO: error: no argument expected for --enable-cassert option" >&5
 
3012
echo "$as_me: error: no argument expected for --enable-cassert option" >&2;}
 
3013
   { (exit 1); exit 1; }; }
 
3014
      ;;
 
3015
  esac
 
3016
 
 
3017
else
 
3018
  enable_cassert=no
 
3019
 
 
3020
fi;
 
3021
 
 
3022
 
 
3023
 
 
3024
#
 
3025
# Include directories
 
3026
#
 
3027
ac_save_IFS=$IFS
 
3028
IFS="${IFS}${PATH_SEPARATOR}"
 
3029
# SRCH_INC comes from the template file
 
3030
for dir in $with_includes $SRCH_INC; do
 
3031
  if test -d "$dir"; then
 
3032
    INCLUDES="$INCLUDES -I$dir"
 
3033
  else
 
3034
    { echo "$as_me:$LINENO: WARNING: *** Include directory $dir does not exist." >&5
 
3035
echo "$as_me: WARNING: *** Include directory $dir does not exist." >&2;}
 
3036
  fi
 
3037
done
 
3038
IFS=$ac_save_IFS
 
3039
 
 
3040
 
 
3041
 
 
3042
#
 
3043
# Library directories
 
3044
#
 
3045
ac_save_IFS=$IFS
 
3046
IFS="${IFS}${PATH_SEPARATOR}"
 
3047
# LIBRARY_DIRS comes from command line, SRCH_LIB from template file.
 
3048
for dir in $LIBRARY_DIRS $SRCH_LIB; do
 
3049
  if test -d "$dir"; then
 
3050
    LIBDIRS="$LIBDIRS -L$dir"
 
3051
  else
 
3052
    { echo "$as_me:$LINENO: WARNING: *** Library directory $dir does not exist." >&5
 
3053
echo "$as_me: WARNING: *** Library directory $dir does not exist." >&2;}
 
3054
  fi
 
3055
done
 
3056
IFS=$ac_save_IFS
 
3057
 
 
3058
#
 
3059
# Enable thread-safe client libraries
 
3060
#
 
3061
echo "$as_me:$LINENO: checking allow thread-safe client libraries" >&5
 
3062
echo $ECHO_N "checking allow thread-safe client libraries... $ECHO_C" >&6
 
3063
 
 
3064
 
 
3065
# Check whether --enable-thread-safety or --disable-thread-safety was given.
 
3066
if test "${enable_thread_safety+set}" = set; then
 
3067
  enableval="$enable_thread_safety"
 
3068
 
 
3069
  case $enableval in
 
3070
    yes)
 
3071
      :
 
3072
      ;;
 
3073
    no)
 
3074
      :
 
3075
      ;;
 
3076
    *)
 
3077
      { { echo "$as_me:$LINENO: error: no argument expected for --enable-thread-safety option" >&5
 
3078
echo "$as_me: error: no argument expected for --enable-thread-safety option" >&2;}
 
3079
   { (exit 1); exit 1; }; }
 
3080
      ;;
 
3081
  esac
 
3082
 
 
3083
else
 
3084
  enable_thread_safety=no
 
3085
 
 
3086
fi;
 
3087
 
 
3088
 
 
3089
 
 
3090
# Check whether --enable-thread-safety-force or --disable-thread-safety-force was given.
 
3091
if test "${enable_thread_safety_force+set}" = set; then
 
3092
  enableval="$enable_thread_safety_force"
 
3093
 
 
3094
  case $enableval in
 
3095
    yes)
 
3096
      :
 
3097
      ;;
 
3098
    no)
 
3099
      :
 
3100
      ;;
 
3101
    *)
 
3102
      { { echo "$as_me:$LINENO: error: no argument expected for --enable-thread-safety-force option" >&5
 
3103
echo "$as_me: error: no argument expected for --enable-thread-safety-force option" >&2;}
 
3104
   { (exit 1); exit 1; }; }
 
3105
      ;;
 
3106
  esac
 
3107
 
 
3108
else
 
3109
  enable_thread_safety_force=no
 
3110
 
 
3111
fi;
 
3112
 
 
3113
if test "$enable_thread_safety" = yes -o \
 
3114
        "$enable_thread_safety_force" = yes; then
 
3115
  enable_thread_safety="yes"    # for 'force'
 
3116
 
 
3117
cat >>confdefs.h <<\_ACEOF
 
3118
#define ENABLE_THREAD_SAFETY 1
 
3119
_ACEOF
 
3120
 
 
3121
fi
 
3122
echo "$as_me:$LINENO: result: $enable_thread_safety" >&5
 
3123
echo "${ECHO_T}$enable_thread_safety" >&6
 
3124
 
 
3125
 
 
3126
#
 
3127
# Optionally build Tcl modules (PL/Tcl)
 
3128
#
 
3129
echo "$as_me:$LINENO: checking whether to build with Tcl" >&5
 
3130
echo $ECHO_N "checking whether to build with Tcl... $ECHO_C" >&6
 
3131
 
 
3132
 
 
3133
 
 
3134
# Check whether --with-tcl or --without-tcl was given.
 
3135
if test "${with_tcl+set}" = set; then
 
3136
  withval="$with_tcl"
 
3137
 
 
3138
  case $withval in
 
3139
    yes)
 
3140
      :
 
3141
      ;;
 
3142
    no)
 
3143
      :
 
3144
      ;;
 
3145
    *)
 
3146
      { { echo "$as_me:$LINENO: error: no argument expected for --with-tcl option" >&5
 
3147
echo "$as_me: error: no argument expected for --with-tcl option" >&2;}
 
3148
   { (exit 1); exit 1; }; }
 
3149
      ;;
 
3150
  esac
 
3151
 
 
3152
else
 
3153
  with_tcl=no
 
3154
 
 
3155
fi;
 
3156
 
 
3157
echo "$as_me:$LINENO: result: $with_tcl" >&5
 
3158
echo "${ECHO_T}$with_tcl" >&6
 
3159
 
 
3160
 
 
3161
# We see if the path to the Tcl/Tk configuration scripts is specified.
 
3162
# This will override the use of tclsh to find the paths to search.
 
3163
 
 
3164
 
 
3165
 
 
3166
 
 
3167
# Check whether --with-tclconfig or --without-tclconfig was given.
 
3168
if test "${with_tclconfig+set}" = set; then
 
3169
  withval="$with_tclconfig"
 
3170
 
 
3171
  case $withval in
 
3172
    yes)
 
3173
      { { echo "$as_me:$LINENO: error: argument required for --with-tclconfig option" >&5
 
3174
echo "$as_me: error: argument required for --with-tclconfig option" >&2;}
 
3175
   { (exit 1); exit 1; }; }
 
3176
      ;;
 
3177
    no)
 
3178
      { { echo "$as_me:$LINENO: error: argument required for --with-tclconfig option" >&5
 
3179
echo "$as_me: error: argument required for --with-tclconfig option" >&2;}
 
3180
   { (exit 1); exit 1; }; }
 
3181
      ;;
 
3182
    *)
 
3183
 
 
3184
      ;;
 
3185
  esac
 
3186
 
 
3187
fi;
 
3188
 
 
3189
 
 
3190
#
 
3191
# Optionally build Perl modules (PL/Perl)
 
3192
#
 
3193
echo "$as_me:$LINENO: checking whether to build Perl modules" >&5
 
3194
echo $ECHO_N "checking whether to build Perl modules... $ECHO_C" >&6
 
3195
 
 
3196
 
 
3197
 
 
3198
# Check whether --with-perl or --without-perl was given.
 
3199
if test "${with_perl+set}" = set; then
 
3200
  withval="$with_perl"
 
3201
 
 
3202
  case $withval in
 
3203
    yes)
 
3204
      :
 
3205
      ;;
 
3206
    no)
 
3207
      :
 
3208
      ;;
 
3209
    *)
 
3210
      { { echo "$as_me:$LINENO: error: no argument expected for --with-perl option" >&5
 
3211
echo "$as_me: error: no argument expected for --with-perl option" >&2;}
 
3212
   { (exit 1); exit 1; }; }
 
3213
      ;;
 
3214
  esac
 
3215
 
 
3216
else
 
3217
  with_perl=no
 
3218
 
 
3219
fi;
 
3220
 
 
3221
echo "$as_me:$LINENO: result: $with_perl" >&5
 
3222
echo "${ECHO_T}$with_perl" >&6
 
3223
 
 
3224
 
 
3225
#
 
3226
# Optionally build Python modules (PL/Python)
 
3227
#
 
3228
echo "$as_me:$LINENO: checking whether to build Python modules" >&5
 
3229
echo $ECHO_N "checking whether to build Python modules... $ECHO_C" >&6
 
3230
 
 
3231
 
 
3232
 
 
3233
# Check whether --with-python or --without-python was given.
 
3234
if test "${with_python+set}" = set; then
 
3235
  withval="$with_python"
 
3236
 
 
3237
  case $withval in
 
3238
    yes)
 
3239
      :
 
3240
      ;;
 
3241
    no)
 
3242
      :
 
3243
      ;;
 
3244
    *)
 
3245
      { { echo "$as_me:$LINENO: error: no argument expected for --with-python option" >&5
 
3246
echo "$as_me: error: no argument expected for --with-python option" >&2;}
 
3247
   { (exit 1); exit 1; }; }
 
3248
      ;;
 
3249
  esac
 
3250
 
 
3251
else
 
3252
  with_python=no
 
3253
 
 
3254
fi;
 
3255
 
 
3256
echo "$as_me:$LINENO: result: $with_python" >&5
 
3257
echo "${ECHO_T}$with_python" >&6
 
3258
 
 
3259
 
 
3260
#
 
3261
# Kerberos 4
 
3262
#
 
3263
echo "$as_me:$LINENO: checking whether to build with Kerberos 4 support" >&5
 
3264
echo $ECHO_N "checking whether to build with Kerberos 4 support... $ECHO_C" >&6
 
3265
 
 
3266
 
 
3267
 
 
3268
# Check whether --with-krb4 or --without-krb4 was given.
 
3269
if test "${with_krb4+set}" = set; then
 
3270
  withval="$with_krb4"
 
3271
 
 
3272
  case $withval in
 
3273
    yes)
 
3274
 
 
3275
 
 
3276
cat >>confdefs.h <<\_ACEOF
 
3277
#define KRB4 1
 
3278
_ACEOF
 
3279
 
 
3280
  krb_srvtab="/etc/srvtab"
 
3281
 
 
3282
      ;;
 
3283
    no)
 
3284
      :
 
3285
      ;;
 
3286
    *)
 
3287
      { { echo "$as_me:$LINENO: error: no argument expected for --with-krb4 option" >&5
 
3288
echo "$as_me: error: no argument expected for --with-krb4 option" >&2;}
 
3289
   { (exit 1); exit 1; }; }
 
3290
      ;;
 
3291
  esac
 
3292
 
 
3293
else
 
3294
  with_krb4=no
 
3295
 
 
3296
fi;
 
3297
 
 
3298
echo "$as_me:$LINENO: result: $with_krb4" >&5
 
3299
echo "${ECHO_T}$with_krb4" >&6
 
3300
 
 
3301
 
 
3302
 
 
3303
#
 
3304
# Kerberos 5
 
3305
#
 
3306
echo "$as_me:$LINENO: checking whether to build with Kerberos 5 support" >&5
 
3307
echo $ECHO_N "checking whether to build with Kerberos 5 support... $ECHO_C" >&6
 
3308
 
 
3309
 
 
3310
 
 
3311
# Check whether --with-krb5 or --without-krb5 was given.
 
3312
if test "${with_krb5+set}" = set; then
 
3313
  withval="$with_krb5"
 
3314
 
 
3315
  case $withval in
 
3316
    yes)
 
3317
 
 
3318
 
 
3319
cat >>confdefs.h <<\_ACEOF
 
3320
#define KRB5 1
 
3321
_ACEOF
 
3322
 
 
3323
  krb_srvtab="FILE:\$(sysconfdir)/krb5.keytab"
 
3324
 
 
3325
      ;;
 
3326
    no)
 
3327
      :
 
3328
      ;;
 
3329
    *)
 
3330
      { { echo "$as_me:$LINENO: error: no argument expected for --with-krb5 option" >&5
 
3331
echo "$as_me: error: no argument expected for --with-krb5 option" >&2;}
 
3332
   { (exit 1); exit 1; }; }
 
3333
      ;;
 
3334
  esac
 
3335
 
 
3336
else
 
3337
  with_krb5=no
 
3338
 
 
3339
fi;
 
3340
 
 
3341
echo "$as_me:$LINENO: result: $with_krb5" >&5
 
3342
echo "${ECHO_T}$with_krb5" >&6
 
3343
 
 
3344
 
 
3345
 
 
3346
# Using both Kerberos 4 and Kerberos 5 at the same time isn't going to work.
 
3347
if test "$with_krb4" = yes && test "$with_krb5" = yes ; then
 
3348
  { { echo "$as_me:$LINENO: error: Kerberos 4 and Kerberos 5 support cannot be combined" >&5
 
3349
echo "$as_me: error: Kerberos 4 and Kerberos 5 support cannot be combined" >&2;}
 
3350
   { (exit 1); exit 1; }; }
 
3351
fi
 
3352
 
 
3353
 
 
3354
 
 
3355
 
 
3356
#
 
3357
# Kerberos configuration parameters
 
3358
#
 
3359
 
 
3360
 
 
3361
 
 
3362
# Check whether --with-krb-srvnam or --without-krb-srvnam was given.
 
3363
if test "${with_krb_srvnam+set}" = set; then
 
3364
  withval="$with_krb_srvnam"
 
3365
 
 
3366
  case $withval in
 
3367
    yes)
 
3368
      { { echo "$as_me:$LINENO: error: argument required for --with-krb-srvnam option" >&5
 
3369
echo "$as_me: error: argument required for --with-krb-srvnam option" >&2;}
 
3370
   { (exit 1); exit 1; }; }
 
3371
      ;;
 
3372
    no)
 
3373
      { { echo "$as_me:$LINENO: error: argument required for --with-krb-srvnam option" >&5
 
3374
echo "$as_me: error: argument required for --with-krb-srvnam option" >&2;}
 
3375
   { (exit 1); exit 1; }; }
 
3376
      ;;
 
3377
    *)
 
3378
 
 
3379
      ;;
 
3380
  esac
 
3381
 
 
3382
else
 
3383
  with_krb_srvnam="postgres"
 
3384
fi;
 
3385
 
 
3386
 
 
3387
cat >>confdefs.h <<_ACEOF
 
3388
#define PG_KRB_SRVNAM "$with_krb_srvnam"
 
3389
_ACEOF
 
3390
 
 
3391
 
 
3392
 
 
3393
#
 
3394
# PAM
 
3395
#
 
3396
echo "$as_me:$LINENO: checking whether to build with PAM support" >&5
 
3397
echo $ECHO_N "checking whether to build with PAM support... $ECHO_C" >&6
 
3398
 
 
3399
 
 
3400
 
 
3401
# Check whether --with-pam or --without-pam was given.
 
3402
if test "${with_pam+set}" = set; then
 
3403
  withval="$with_pam"
 
3404
 
 
3405
  case $withval in
 
3406
    yes)
 
3407
 
 
3408
cat >>confdefs.h <<\_ACEOF
 
3409
#define USE_PAM 1
 
3410
_ACEOF
 
3411
 
 
3412
      ;;
 
3413
    no)
 
3414
      :
 
3415
      ;;
 
3416
    *)
 
3417
      { { echo "$as_me:$LINENO: error: no argument expected for --with-pam option" >&5
 
3418
echo "$as_me: error: no argument expected for --with-pam option" >&2;}
 
3419
   { (exit 1); exit 1; }; }
 
3420
      ;;
 
3421
  esac
 
3422
 
 
3423
else
 
3424
  with_pam=no
 
3425
 
 
3426
fi;
 
3427
 
 
3428
echo "$as_me:$LINENO: result: $with_pam" >&5
 
3429
echo "${ECHO_T}$with_pam" >&6
 
3430
 
 
3431
 
 
3432
 
 
3433
#
 
3434
# Rendezvous
 
3435
#
 
3436
echo "$as_me:$LINENO: checking whether to build with Rendezvous support" >&5
 
3437
echo $ECHO_N "checking whether to build with Rendezvous support... $ECHO_C" >&6
 
3438
 
 
3439
 
 
3440
 
 
3441
# Check whether --with-rendezvous or --without-rendezvous was given.
 
3442
if test "${with_rendezvous+set}" = set; then
 
3443
  withval="$with_rendezvous"
 
3444
 
 
3445
  case $withval in
 
3446
    yes)
 
3447
 
 
3448
cat >>confdefs.h <<\_ACEOF
 
3449
#define USE_RENDEZVOUS 1
 
3450
_ACEOF
 
3451
 
 
3452
      ;;
 
3453
    no)
 
3454
      :
 
3455
      ;;
 
3456
    *)
 
3457
      { { echo "$as_me:$LINENO: error: no argument expected for --with-rendezvous option" >&5
 
3458
echo "$as_me: error: no argument expected for --with-rendezvous option" >&2;}
 
3459
   { (exit 1); exit 1; }; }
 
3460
      ;;
 
3461
  esac
 
3462
 
 
3463
else
 
3464
  with_rendezvous=no
 
3465
 
 
3466
fi;
 
3467
 
 
3468
echo "$as_me:$LINENO: result: $with_rendezvous" >&5
 
3469
echo "${ECHO_T}$with_rendezvous" >&6
 
3470
 
 
3471
 
 
3472
 
 
3473
#
 
3474
# OpenSSL
 
3475
#
 
3476
echo "$as_me:$LINENO: checking whether to build with OpenSSL support" >&5
 
3477
echo $ECHO_N "checking whether to build with OpenSSL support... $ECHO_C" >&6
 
3478
 
 
3479
 
 
3480
 
 
3481
# Check whether --with-openssl or --without-openssl was given.
 
3482
if test "${with_openssl+set}" = set; then
 
3483
  withval="$with_openssl"
 
3484
 
 
3485
  case $withval in
 
3486
    yes)
 
3487
 
 
3488
cat >>confdefs.h <<\_ACEOF
 
3489
#define USE_SSL 1
 
3490
_ACEOF
 
3491
 
 
3492
      ;;
 
3493
    no)
 
3494
      :
 
3495
      ;;
 
3496
    *)
 
3497
      { { echo "$as_me:$LINENO: error: no argument expected for --with-openssl option" >&5
 
3498
echo "$as_me: error: no argument expected for --with-openssl option" >&2;}
 
3499
   { (exit 1); exit 1; }; }
 
3500
      ;;
 
3501
  esac
 
3502
 
 
3503
else
 
3504
  with_openssl=no
 
3505
 
 
3506
fi;
 
3507
 
 
3508
echo "$as_me:$LINENO: result: $with_openssl" >&5
 
3509
echo "${ECHO_T}$with_openssl" >&6
 
3510
 
 
3511
 
 
3512
 
 
3513
#
 
3514
# Readline
 
3515
#
 
3516
 
 
3517
 
 
3518
 
 
3519
# Check whether --with-readline or --without-readline was given.
 
3520
if test "${with_readline+set}" = set; then
 
3521
  withval="$with_readline"
 
3522
 
 
3523
  case $withval in
 
3524
    yes)
 
3525
      :
 
3526
      ;;
 
3527
    no)
 
3528
      :
 
3529
      ;;
 
3530
    *)
 
3531
      { { echo "$as_me:$LINENO: error: no argument expected for --with-readline option" >&5
 
3532
echo "$as_me: error: no argument expected for --with-readline option" >&2;}
 
3533
   { (exit 1); exit 1; }; }
 
3534
      ;;
 
3535
  esac
 
3536
 
 
3537
else
 
3538
  with_readline=yes
 
3539
 
 
3540
fi;
 
3541
 
 
3542
# readline on MinGW has problems with backslashes in psql and other bugs.
 
3543
# This is particularly a problem with non-US code pages.
 
3544
# Therefore disable its use until we understand the cause. 2004-07-20
 
3545
if test "$PORTNAME" = "win32"; then
 
3546
  if test "$with_readline" = yes; then
 
3547
    { echo "$as_me:$LINENO: WARNING: *** Readline does not work on MinGW --- disabling" >&5
 
3548
echo "$as_me: WARNING: *** Readline does not work on MinGW --- disabling" >&2;}
 
3549
    with_readline=no
 
3550
  fi
 
3551
fi
 
3552
 
 
3553
 
 
3554
#
 
3555
# Zlib
 
3556
#
 
3557
 
 
3558
 
 
3559
 
 
3560
# Check whether --with-zlib or --without-zlib was given.
 
3561
if test "${with_zlib+set}" = set; then
 
3562
  withval="$with_zlib"
 
3563
 
 
3564
  case $withval in
 
3565
    yes)
 
3566
      :
 
3567
      ;;
 
3568
    no)
 
3569
      :
 
3570
      ;;
 
3571
    *)
 
3572
      { { echo "$as_me:$LINENO: error: no argument expected for --with-zlib option" >&5
 
3573
echo "$as_me: error: no argument expected for --with-zlib option" >&2;}
 
3574
   { (exit 1); exit 1; }; }
 
3575
      ;;
 
3576
  esac
 
3577
 
 
3578
else
 
3579
  with_zlib=yes
 
3580
 
 
3581
fi;
 
3582
 
 
3583
 
 
3584
#
 
3585
# Elf
 
3586
#
 
3587
 
 
3588
# Assume system is ELF if it predefines __ELF__ as 1,
 
3589
# otherwise believe host_os based default.
 
3590
case $host_os in
 
3591
    freebsd1*|freebsd2*) elf=no;;
 
3592
    freebsd3*|freebsd4*) elf=yes;;
 
3593
esac
 
3594
 
 
3595
 
 
3596
cat >conftest.$ac_ext <<_ACEOF
 
3597
#line $LINENO "configure"
 
3598
#include "confdefs.h"
 
3599
#if __ELF__
 
3600
  yes
 
3601
#endif
 
3602
 
 
3603
_ACEOF
 
3604
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
 
3605
  egrep "yes" >/dev/null 2>&1; then
 
3606
  ELF_SYS=true
 
3607
else
 
3608
  if test "X$elf" = "Xyes" ; then
 
3609
  ELF_SYS=true
 
3610
else
 
3611
  ELF_SYS=
 
3612
fi
 
3613
fi
 
3614
rm -f conftest*
 
3615
 
 
3616
 
 
3617
 
 
3618
#
 
3619
# Assignments
 
3620
#
 
3621
 
 
3622
CPPFLAGS="$CPPFLAGS $INCLUDES"
 
3623
LDFLAGS="$LDFLAGS $LIBDIRS"
 
3624
 
 
3625
{ echo "$as_me:$LINENO: using CPPFLAGS=$CPPFLAGS" >&5
 
3626
echo "$as_me: using CPPFLAGS=$CPPFLAGS" >&6;}
 
3627
{ echo "$as_me:$LINENO: using LDFLAGS=$LDFLAGS" >&5
 
3628
echo "$as_me: using LDFLAGS=$LDFLAGS" >&6;}
 
3629
 
 
3630
 
 
3631
 
 
3632
for ac_prog in gawk mawk nawk awk
 
3633
do
 
3634
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
3635
set dummy $ac_prog; ac_word=$2
 
3636
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
3637
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
3638
if test "${ac_cv_prog_AWK+set}" = set; then
 
3639
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3640
else
 
3641
  if test -n "$AWK"; then
 
3642
  ac_cv_prog_AWK="$AWK" # Let the user override the test.
 
3643
else
 
3644
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
3645
for as_dir in $PATH
 
3646
do
 
3647
  IFS=$as_save_IFS
 
3648
  test -z "$as_dir" && as_dir=.
 
3649
  for ac_exec_ext in '' $ac_executable_extensions; do
 
3650
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
3651
    ac_cv_prog_AWK="$ac_prog"
 
3652
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
3653
    break 2
 
3654
  fi
 
3655
done
 
3656
done
 
3657
 
 
3658
fi
 
3659
fi
 
3660
AWK=$ac_cv_prog_AWK
 
3661
if test -n "$AWK"; then
 
3662
  echo "$as_me:$LINENO: result: $AWK" >&5
 
3663
echo "${ECHO_T}$AWK" >&6
 
3664
else
 
3665
  echo "$as_me:$LINENO: result: no" >&5
 
3666
echo "${ECHO_T}no" >&6
 
3667
fi
 
3668
 
 
3669
  test -n "$AWK" && break
 
3670
done
 
3671
 
 
3672
echo "$as_me:$LINENO: checking for flex" >&5
 
3673
echo $ECHO_N "checking for flex... $ECHO_C" >&6
 
3674
if test "${pgac_cv_path_flex+set}" = set; then
 
3675
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3676
else
 
3677
  # Let the user override the test
 
3678
if test -n "$FLEX"; then
 
3679
  pgac_cv_path_flex=$FLEX
 
3680
else
 
3681
  pgac_save_IFS=$IFS
 
3682
  IFS=$PATH_SEPARATOR
 
3683
  for pgac_dir in $PATH; do
 
3684
    IFS=$pgac_save_IFS
 
3685
    if test -z "$pgac_dir" || test x"$pgac_dir" = x"."; then
 
3686
      pgac_dir=`pwd`
 
3687
    fi
 
3688
    for pgac_prog in flex lex; do
 
3689
      pgac_candidate="$pgac_dir/$pgac_prog"
 
3690
      if test -f "$pgac_candidate" \
 
3691
        && $pgac_candidate --version </dev/null >/dev/null 2>&1
 
3692
      then
 
3693
        echo '%%'  > conftest.l
 
3694
        if $pgac_candidate -t conftest.l 2>/dev/null | grep FLEX_SCANNER >/dev/null 2>&1; then
 
3695
          if $pgac_candidate --version | grep ' 2\.5\.3$' >/dev/null 2>&1; then
 
3696
            pgac_broken_flex=$pgac_candidate
 
3697
            continue
 
3698
          fi
 
3699
 
 
3700
          pgac_cv_path_flex=$pgac_candidate
 
3701
          break 2
 
3702
        fi
 
3703
      fi
 
3704
    done
 
3705
  done
 
3706
  rm -f conftest.l lex.yy.c
 
3707
  : ${pgac_cv_path_flex=no}
 
3708
fi
 
3709
 
 
3710
fi
 
3711
echo "$as_me:$LINENO: result: $pgac_cv_path_flex" >&5
 
3712
echo "${ECHO_T}$pgac_cv_path_flex" >&6
 
3713
if test x"$pgac_cv_path_flex" = x"no"; then
 
3714
  if test -n "$pgac_broken_flex"; then
 
3715
    { echo "$as_me:$LINENO: WARNING:
 
3716
*** The Flex version 2.5.3 you have at $pgac_broken_flex contains a bug. You
 
3717
*** should get version 2.5.4 or later." >&5
 
3718
echo "$as_me: WARNING:
 
3719
*** The Flex version 2.5.3 you have at $pgac_broken_flex contains a bug. You
 
3720
*** should get version 2.5.4 or later." >&2;}
 
3721
  fi
 
3722
 
 
3723
  { echo "$as_me:$LINENO: WARNING:
 
3724
*** Without Flex you will not be able to build PostgreSQL from CVS or
 
3725
*** change any of the scanner definition files.  You can obtain Flex from
 
3726
*** a GNU mirror site.  (If you are using the official distribution of
 
3727
*** PostgreSQL then you do not need to worry about this because the Flex
 
3728
*** output is pre-generated.)" >&5
 
3729
echo "$as_me: WARNING:
 
3730
*** Without Flex you will not be able to build PostgreSQL from CVS or
 
3731
*** change any of the scanner definition files.  You can obtain Flex from
 
3732
*** a GNU mirror site.  (If you are using the official distribution of
 
3733
*** PostgreSQL then you do not need to worry about this because the Flex
 
3734
*** output is pre-generated.)" >&2;}
 
3735
fi
 
3736
 
 
3737
if test x"$pgac_cv_path_flex" = x"no"; then
 
3738
  FLEX=
 
3739
else
 
3740
  FLEX=$pgac_cv_path_flex
 
3741
fi
 
3742
 
 
3743
 
 
3744
 
 
3745
 
 
3746
echo "$as_me:$LINENO: checking whether ln -s works" >&5
 
3747
echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
 
3748
LN_S=$as_ln_s
 
3749
if test "$LN_S" = "ln -s"; then
 
3750
  echo "$as_me:$LINENO: result: yes" >&5
 
3751
echo "${ECHO_T}yes" >&6
 
3752
else
 
3753
  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
 
3754
echo "${ECHO_T}no, using $LN_S" >&6
 
3755
fi
 
3756
 
 
3757
 
 
3758
# Check whether --with-gnu-ld or --without-gnu-ld was given.
 
3759
if test "${with_gnu_ld+set}" = set; then
 
3760
  withval="$with_gnu_ld"
 
3761
  test "$withval" = no || with_gnu_ld=yes
 
3762
else
 
3763
  with_gnu_ld=no
 
3764
fi;
 
3765
ac_prog=ld
 
3766
if test "$GCC" = yes; then
 
3767
  # Check if gcc -print-prog-name=ld gives a path.
 
3768
  echo "$as_me:$LINENO: checking for ld used by GCC" >&5
 
3769
echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6
 
3770
  case $host in
 
3771
  *-*-mingw*)
 
3772
    # gcc leaves a trailing carriage return which upsets mingw
 
3773
    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
 
3774
  *)
 
3775
    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
 
3776
  esac
 
3777
  case "$ac_prog" in
 
3778
    # Accept absolute paths.
 
3779
    [\\/]* | [A-Za-z]:[\\/]*)
 
3780
      re_direlt='/[^/][^/]*/\.\./'
 
3781
      # Canonicalize the path of ld
 
3782
      ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
 
3783
      while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
 
3784
        ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
 
3785
      done
 
3786
      test -z "$LD" && LD="$ac_prog"
 
3787
      ;;
 
3788
  "")
 
3789
    # If it fails, then pretend we aren't using GCC.
 
3790
    ac_prog=ld
 
3791
    ;;
 
3792
  *)
 
3793
    # If it is relative, then search for the first ld in PATH.
 
3794
    with_gnu_ld=unknown
 
3795
    ;;
 
3796
  esac
 
3797
elif test "$with_gnu_ld" = yes; then
 
3798
  echo "$as_me:$LINENO: checking for GNU ld" >&5
 
3799
echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6
 
3800
else
 
3801
  echo "$as_me:$LINENO: checking for non-GNU ld" >&5
 
3802
echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6
 
3803
fi
 
3804
if test "${ac_cv_path_LD+set}" = set; then
 
3805
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3806
else
 
3807
  if test -z "$LD"; then
 
3808
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
 
3809
  for ac_dir in $PATH; do
 
3810
    test -z "$ac_dir" && ac_dir=.
 
3811
    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
 
3812
      ac_cv_path_LD="$ac_dir/$ac_prog"
 
3813
      # Check to see if the program is GNU ld.  I'd rather use --version,
 
3814
      # but apparently some GNU ld's only accept -v.
 
3815
      # Break only if it was the GNU/non-GNU ld that we prefer.
 
3816
      if "$ac_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
 
3817
        test "$with_gnu_ld" != no && break
 
3818
      else
 
3819
        test "$with_gnu_ld" != yes && break
 
3820
      fi
 
3821
    fi
 
3822
  done
 
3823
  IFS="$ac_save_ifs"
 
3824
else
 
3825
  ac_cv_path_LD="$LD" # Let the user override the test with a path.
 
3826
fi
 
3827
fi
 
3828
 
 
3829
LD="$ac_cv_path_LD"
 
3830
if test -n "$LD"; then
 
3831
  echo "$as_me:$LINENO: result: $LD" >&5
 
3832
echo "${ECHO_T}$LD" >&6
 
3833
else
 
3834
  echo "$as_me:$LINENO: result: no" >&5
 
3835
echo "${ECHO_T}no" >&6
 
3836
fi
 
3837
test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5
 
3838
echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}
 
3839
   { (exit 1); exit 1; }; }
 
3840
echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
 
3841
echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6
 
3842
if test "${ac_cv_prog_gnu_ld+set}" = set; then
 
3843
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3844
else
 
3845
  # I'd rather use --version here, but apparently some GNU ld's only accept -v.
 
3846
if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
 
3847
  ac_cv_prog_gnu_ld=yes
 
3848
else
 
3849
  ac_cv_prog_gnu_ld=no
 
3850
fi
 
3851
fi
 
3852
echo "$as_me:$LINENO: result: $ac_cv_prog_gnu_ld" >&5
 
3853
echo "${ECHO_T}$ac_cv_prog_gnu_ld" >&6
 
3854
with_gnu_ld=$ac_cv_prog_gnu_ld
 
3855
 
 
3856
 
 
3857
 
 
3858
 
 
3859
case $host_os in sysv5*)
 
3860
  echo "$as_me:$LINENO: checking whether ld -R works" >&5
 
3861
echo $ECHO_N "checking whether ld -R works... $ECHO_C" >&6
 
3862
if test "${pgac_cv_prog_ld_R+set}" = set; then
 
3863
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3864
else
 
3865
 
 
3866
    pgac_save_LDFLAGS=$LDFLAGS; LDFLAGS="$LDFLAGS -Wl,-R/usr/lib"
 
3867
    cat >conftest.$ac_ext <<_ACEOF
 
3868
#line $LINENO "configure"
 
3869
#include "confdefs.h"
 
3870
 
 
3871
#ifdef F77_DUMMY_MAIN
 
3872
#  ifdef __cplusplus
 
3873
     extern "C"
 
3874
#  endif
 
3875
   int F77_DUMMY_MAIN() { return 1; }
 
3876
#endif
 
3877
int
 
3878
main ()
 
3879
{
 
3880
 
 
3881
  ;
 
3882
  return 0;
 
3883
}
 
3884
_ACEOF
 
3885
rm -f conftest.$ac_objext conftest$ac_exeext
 
3886
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
3887
  (eval $ac_link) 2>&5
 
3888
  ac_status=$?
 
3889
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3890
  (exit $ac_status); } &&
 
3891
         { ac_try='test -s conftest$ac_exeext'
 
3892
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
3893
  (eval $ac_try) 2>&5
 
3894
  ac_status=$?
 
3895
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3896
  (exit $ac_status); }; }; then
 
3897
  pgac_cv_prog_ld_R=yes
 
3898
else
 
3899
  echo "$as_me: failed program was:" >&5
 
3900
cat conftest.$ac_ext >&5
 
3901
pgac_cv_prog_ld_R=no
 
3902
fi
 
3903
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
3904
    LDFLAGS=$pgac_save_LDFLAGS
 
3905
 
 
3906
fi
 
3907
echo "$as_me:$LINENO: result: $pgac_cv_prog_ld_R" >&5
 
3908
echo "${ECHO_T}$pgac_cv_prog_ld_R" >&6
 
3909
  ld_R_works=$pgac_cv_prog_ld_R
 
3910
 
 
3911
esac
 
3912
if test -n "$ac_tool_prefix"; then
 
3913
  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
 
3914
set dummy ${ac_tool_prefix}ranlib; ac_word=$2
 
3915
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
3916
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
3917
if test "${ac_cv_prog_RANLIB+set}" = set; then
 
3918
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3919
else
 
3920
  if test -n "$RANLIB"; then
 
3921
  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
 
3922
else
 
3923
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
3924
for as_dir in $PATH
 
3925
do
 
3926
  IFS=$as_save_IFS
 
3927
  test -z "$as_dir" && as_dir=.
 
3928
  for ac_exec_ext in '' $ac_executable_extensions; do
 
3929
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
3930
    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
 
3931
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
3932
    break 2
 
3933
  fi
 
3934
done
 
3935
done
 
3936
 
 
3937
fi
 
3938
fi
 
3939
RANLIB=$ac_cv_prog_RANLIB
 
3940
if test -n "$RANLIB"; then
 
3941
  echo "$as_me:$LINENO: result: $RANLIB" >&5
 
3942
echo "${ECHO_T}$RANLIB" >&6
 
3943
else
 
3944
  echo "$as_me:$LINENO: result: no" >&5
 
3945
echo "${ECHO_T}no" >&6
 
3946
fi
 
3947
 
 
3948
fi
 
3949
if test -z "$ac_cv_prog_RANLIB"; then
 
3950
  ac_ct_RANLIB=$RANLIB
 
3951
  # Extract the first word of "ranlib", so it can be a program name with args.
 
3952
set dummy ranlib; ac_word=$2
 
3953
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
3954
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
3955
if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
 
3956
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3957
else
 
3958
  if test -n "$ac_ct_RANLIB"; then
 
3959
  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
 
3960
else
 
3961
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
3962
for as_dir in $PATH
 
3963
do
 
3964
  IFS=$as_save_IFS
 
3965
  test -z "$as_dir" && as_dir=.
 
3966
  for ac_exec_ext in '' $ac_executable_extensions; do
 
3967
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
3968
    ac_cv_prog_ac_ct_RANLIB="ranlib"
 
3969
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
3970
    break 2
 
3971
  fi
 
3972
done
 
3973
done
 
3974
 
 
3975
  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
 
3976
fi
 
3977
fi
 
3978
ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
 
3979
if test -n "$ac_ct_RANLIB"; then
 
3980
  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
 
3981
echo "${ECHO_T}$ac_ct_RANLIB" >&6
 
3982
else
 
3983
  echo "$as_me:$LINENO: result: no" >&5
 
3984
echo "${ECHO_T}no" >&6
 
3985
fi
 
3986
 
 
3987
  RANLIB=$ac_ct_RANLIB
 
3988
else
 
3989
  RANLIB="$ac_cv_prog_RANLIB"
 
3990
fi
 
3991
 
 
3992
for ac_prog in lorder
 
3993
do
 
3994
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
3995
set dummy $ac_prog; ac_word=$2
 
3996
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
3997
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
3998
if test "${ac_cv_prog_LORDER+set}" = set; then
 
3999
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4000
else
 
4001
  if test -n "$LORDER"; then
 
4002
  ac_cv_prog_LORDER="$LORDER" # Let the user override the test.
 
4003
else
 
4004
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
4005
for as_dir in $PATH
 
4006
do
 
4007
  IFS=$as_save_IFS
 
4008
  test -z "$as_dir" && as_dir=.
 
4009
  for ac_exec_ext in '' $ac_executable_extensions; do
 
4010
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
4011
    ac_cv_prog_LORDER="$ac_prog"
 
4012
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
4013
    break 2
 
4014
  fi
 
4015
done
 
4016
done
 
4017
 
 
4018
fi
 
4019
fi
 
4020
LORDER=$ac_cv_prog_LORDER
 
4021
if test -n "$LORDER"; then
 
4022
  echo "$as_me:$LINENO: result: $LORDER" >&5
 
4023
echo "${ECHO_T}$LORDER" >&6
 
4024
else
 
4025
  echo "$as_me:$LINENO: result: no" >&5
 
4026
echo "${ECHO_T}no" >&6
 
4027
fi
 
4028
 
 
4029
  test -n "$LORDER" && break
 
4030
done
 
4031
 
 
4032
# Extract the first word of "tar", so it can be a program name with args.
 
4033
set dummy tar; ac_word=$2
 
4034
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
4035
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
4036
if test "${ac_cv_path_TAR+set}" = set; then
 
4037
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4038
else
 
4039
  case $TAR in
 
4040
  [\\/]* | ?:[\\/]*)
 
4041
  ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
 
4042
  ;;
 
4043
  *)
 
4044
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
4045
for as_dir in $PATH
 
4046
do
 
4047
  IFS=$as_save_IFS
 
4048
  test -z "$as_dir" && as_dir=.
 
4049
  for ac_exec_ext in '' $ac_executable_extensions; do
 
4050
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
4051
    ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
 
4052
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
4053
    break 2
 
4054
  fi
 
4055
done
 
4056
done
 
4057
 
 
4058
  ;;
 
4059
esac
 
4060
fi
 
4061
TAR=$ac_cv_path_TAR
 
4062
 
 
4063
if test -n "$TAR"; then
 
4064
  echo "$as_me:$LINENO: result: $TAR" >&5
 
4065
echo "${ECHO_T}$TAR" >&6
 
4066
else
 
4067
  echo "$as_me:$LINENO: result: no" >&5
 
4068
echo "${ECHO_T}no" >&6
 
4069
fi
 
4070
 
 
4071
 
 
4072
  if test -n "$ac_tool_prefix"; then
 
4073
  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
 
4074
set dummy ${ac_tool_prefix}strip; ac_word=$2
 
4075
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
4076
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
4077
if test "${ac_cv_prog_STRIP+set}" = set; then
 
4078
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4079
else
 
4080
  if test -n "$STRIP"; then
 
4081
  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
 
4082
else
 
4083
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
4084
for as_dir in $PATH
 
4085
do
 
4086
  IFS=$as_save_IFS
 
4087
  test -z "$as_dir" && as_dir=.
 
4088
  for ac_exec_ext in '' $ac_executable_extensions; do
 
4089
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
4090
    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
 
4091
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
4092
    break 2
 
4093
  fi
 
4094
done
 
4095
done
 
4096
 
 
4097
fi
 
4098
fi
 
4099
STRIP=$ac_cv_prog_STRIP
 
4100
if test -n "$STRIP"; then
 
4101
  echo "$as_me:$LINENO: result: $STRIP" >&5
 
4102
echo "${ECHO_T}$STRIP" >&6
 
4103
else
 
4104
  echo "$as_me:$LINENO: result: no" >&5
 
4105
echo "${ECHO_T}no" >&6
 
4106
fi
 
4107
 
 
4108
fi
 
4109
if test -z "$ac_cv_prog_STRIP"; then
 
4110
  ac_ct_STRIP=$STRIP
 
4111
  # Extract the first word of "strip", so it can be a program name with args.
 
4112
set dummy strip; ac_word=$2
 
4113
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
4114
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
4115
if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
 
4116
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4117
else
 
4118
  if test -n "$ac_ct_STRIP"; then
 
4119
  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
 
4120
else
 
4121
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
4122
for as_dir in $PATH
 
4123
do
 
4124
  IFS=$as_save_IFS
 
4125
  test -z "$as_dir" && as_dir=.
 
4126
  for ac_exec_ext in '' $ac_executable_extensions; do
 
4127
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
4128
    ac_cv_prog_ac_ct_STRIP="strip"
 
4129
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
4130
    break 2
 
4131
  fi
 
4132
done
 
4133
done
 
4134
 
 
4135
  test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
 
4136
fi
 
4137
fi
 
4138
ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
 
4139
if test -n "$ac_ct_STRIP"; then
 
4140
  echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
 
4141
echo "${ECHO_T}$ac_ct_STRIP" >&6
 
4142
else
 
4143
  echo "$as_me:$LINENO: result: no" >&5
 
4144
echo "${ECHO_T}no" >&6
 
4145
fi
 
4146
 
 
4147
  STRIP=$ac_ct_STRIP
 
4148
else
 
4149
  STRIP="$ac_cv_prog_STRIP"
 
4150
fi
 
4151
 
 
4152
 
 
4153
  echo "$as_me:$LINENO: checking whether it is possible to strip libraries" >&5
 
4154
echo $ECHO_N "checking whether it is possible to strip libraries... $ECHO_C" >&6
 
4155
  if test x"$STRIP" != x"" && "$STRIP" -V 2>&1 | grep "GNU strip" >/dev/null; then
 
4156
    STRIP_STATIC_LIB="$STRIP -x"
 
4157
    STRIP_SHARED_LIB="$STRIP --strip-unneeded"
 
4158
    echo "$as_me:$LINENO: result: yes" >&5
 
4159
echo "${ECHO_T}yes" >&6
 
4160
  else
 
4161
    STRIP_STATIC_LIB=:
 
4162
    STRIP_SHARED_LIB=:
 
4163
    echo "$as_me:$LINENO: result: no" >&5
 
4164
echo "${ECHO_T}no" >&6
 
4165
  fi
 
4166
 
 
4167
 
 
4168
 
 
4169
 
 
4170
for ac_prog in 'bison -y'
 
4171
do
 
4172
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
4173
set dummy $ac_prog; ac_word=$2
 
4174
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
4175
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
4176
if test "${ac_cv_prog_YACC+set}" = set; then
 
4177
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4178
else
 
4179
  if test -n "$YACC"; then
 
4180
  ac_cv_prog_YACC="$YACC" # Let the user override the test.
 
4181
else
 
4182
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
4183
for as_dir in $PATH
 
4184
do
 
4185
  IFS=$as_save_IFS
 
4186
  test -z "$as_dir" && as_dir=.
 
4187
  for ac_exec_ext in '' $ac_executable_extensions; do
 
4188
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
4189
    ac_cv_prog_YACC="$ac_prog"
 
4190
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
4191
    break 2
 
4192
  fi
 
4193
done
 
4194
done
 
4195
 
 
4196
fi
 
4197
fi
 
4198
YACC=$ac_cv_prog_YACC
 
4199
if test -n "$YACC"; then
 
4200
  echo "$as_me:$LINENO: result: $YACC" >&5
 
4201
echo "${ECHO_T}$YACC" >&6
 
4202
else
 
4203
  echo "$as_me:$LINENO: result: no" >&5
 
4204
echo "${ECHO_T}no" >&6
 
4205
fi
 
4206
 
 
4207
  test -n "$YACC" && break
 
4208
done
 
4209
 
 
4210
 
 
4211
if test "$YACC"; then
 
4212
  if $YACC --version | sed q | $AWK '{ if ($4 < 1.875) exit 0; else exit 1;}'; then
 
4213
    { echo "$as_me:$LINENO: WARNING:
 
4214
*** If you are going to modify the grammar files or build from CVS, the installed
 
4215
*** version of Bison is too old.  Bison version 1.875 or later is required." >&5
 
4216
echo "$as_me: WARNING:
 
4217
*** If you are going to modify the grammar files or build from CVS, the installed
 
4218
*** version of Bison is too old.  Bison version 1.875 or later is required." >&2;}
 
4219
  fi
 
4220
fi
 
4221
 
 
4222
if test -z "$YACC"; then
 
4223
  { echo "$as_me:$LINENO: WARNING:
 
4224
*** Without Bison you will not be able to build PostgreSQL from CVS or
 
4225
*** change any of the parser definition files.  You can obtain Bison from
 
4226
*** a GNU mirror site.  (If you are using the official distribution of
 
4227
*** PostgreSQL then you do not need to worry about this because the Bison
 
4228
*** output is pre-generated.)  To use a different yacc program (possible,
 
4229
*** but not recommended), set the environment variable YACC before running
 
4230
*** 'configure'." >&5
 
4231
echo "$as_me: WARNING:
 
4232
*** Without Bison you will not be able to build PostgreSQL from CVS or
 
4233
*** change any of the parser definition files.  You can obtain Bison from
 
4234
*** a GNU mirror site.  (If you are using the official distribution of
 
4235
*** PostgreSQL then you do not need to worry about this because the Bison
 
4236
*** output is pre-generated.)  To use a different yacc program (possible,
 
4237
*** but not recommended), set the environment variable YACC before running
 
4238
*** 'configure'." >&2;}
 
4239
fi
 
4240
 
 
4241
 
 
4242
# Extract the first word of "perl", so it can be a program name with args.
 
4243
set dummy perl; ac_word=$2
 
4244
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
4245
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
4246
if test "${ac_cv_path_PERL+set}" = set; then
 
4247
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4248
else
 
4249
  case $PERL in
 
4250
  [\\/]* | ?:[\\/]*)
 
4251
  ac_cv_path_PERL="$PERL" # Let the user override the test with a path.
 
4252
  ;;
 
4253
  *)
 
4254
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
4255
for as_dir in $PATH
 
4256
do
 
4257
  IFS=$as_save_IFS
 
4258
  test -z "$as_dir" && as_dir=.
 
4259
  for ac_exec_ext in '' $ac_executable_extensions; do
 
4260
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
4261
    ac_cv_path_PERL="$as_dir/$ac_word$ac_exec_ext"
 
4262
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
4263
    break 2
 
4264
  fi
 
4265
done
 
4266
done
 
4267
 
 
4268
  ;;
 
4269
esac
 
4270
fi
 
4271
PERL=$ac_cv_path_PERL
 
4272
 
 
4273
if test -n "$PERL"; then
 
4274
  echo "$as_me:$LINENO: result: $PERL" >&5
 
4275
echo "${ECHO_T}$PERL" >&6
 
4276
else
 
4277
  echo "$as_me:$LINENO: result: no" >&5
 
4278
echo "${ECHO_T}no" >&6
 
4279
fi
 
4280
 
 
4281
if test "$with_perl" = yes; then
 
4282
 
 
4283
echo "$as_me:$LINENO: checking for Perl archlibexp" >&5
 
4284
echo $ECHO_N "checking for Perl archlibexp... $ECHO_C" >&6
 
4285
perl_archlibexp=`$PERL -MConfig -e 'print $Config{archlibexp}'`
 
4286
echo "$as_me:$LINENO: result: $perl_archlibexp" >&5
 
4287
echo "${ECHO_T}$perl_archlibexp" >&6
 
4288
echo "$as_me:$LINENO: checking for Perl privlibexp" >&5
 
4289
echo $ECHO_N "checking for Perl privlibexp... $ECHO_C" >&6
 
4290
perl_privlibexp=`$PERL -MConfig -e 'print $Config{privlibexp}'`
 
4291
echo "$as_me:$LINENO: result: $perl_privlibexp" >&5
 
4292
echo "${ECHO_T}$perl_privlibexp" >&6
 
4293
echo "$as_me:$LINENO: checking for Perl useshrplib" >&5
 
4294
echo $ECHO_N "checking for Perl useshrplib... $ECHO_C" >&6
 
4295
perl_useshrplib=`$PERL -MConfig -e 'print $Config{useshrplib}'`
 
4296
echo "$as_me:$LINENO: result: $perl_useshrplib" >&5
 
4297
echo "${ECHO_T}$perl_useshrplib" >&6
 
4298
 
 
4299
echo "$as_me:$LINENO: checking for flags to link embedded Perl" >&5
 
4300
echo $ECHO_N "checking for flags to link embedded Perl... $ECHO_C" >&6
 
4301
pgac_tmp1=`$PERL -MExtUtils::Embed -e ldopts`
 
4302
pgac_tmp2=`$PERL -MConfig -e 'print $Config{ccdlflags}'`
 
4303
perl_embed_ldflags=`echo X"$pgac_tmp1" | sed "s/^X//;s%$pgac_tmp2%%"`
 
4304
echo "$as_me:$LINENO: result: $perl_embed_ldflags" >&5
 
4305
echo "${ECHO_T}$perl_embed_ldflags" >&6
 
4306
fi
 
4307
 
 
4308
if test "$with_python" = yes; then
 
4309
  # Extract the first word of "python", so it can be a program name with args.
 
4310
set dummy python; ac_word=$2
 
4311
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
4312
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
4313
if test "${ac_cv_path_PYTHON+set}" = set; then
 
4314
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4315
else
 
4316
  case $PYTHON in
 
4317
  [\\/]* | ?:[\\/]*)
 
4318
  ac_cv_path_PYTHON="$PYTHON" # Let the user override the test with a path.
 
4319
  ;;
 
4320
  *)
 
4321
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
4322
for as_dir in $PATH
 
4323
do
 
4324
  IFS=$as_save_IFS
 
4325
  test -z "$as_dir" && as_dir=.
 
4326
  for ac_exec_ext in '' $ac_executable_extensions; do
 
4327
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
4328
    ac_cv_path_PYTHON="$as_dir/$ac_word$ac_exec_ext"
 
4329
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
4330
    break 2
 
4331
  fi
 
4332
done
 
4333
done
 
4334
 
 
4335
  ;;
 
4336
esac
 
4337
fi
 
4338
PYTHON=$ac_cv_path_PYTHON
 
4339
 
 
4340
if test -n "$PYTHON"; then
 
4341
  echo "$as_me:$LINENO: result: $PYTHON" >&5
 
4342
echo "${ECHO_T}$PYTHON" >&6
 
4343
else
 
4344
  echo "$as_me:$LINENO: result: no" >&5
 
4345
echo "${ECHO_T}no" >&6
 
4346
fi
 
4347
 
 
4348
if test x"$PYTHON" = x""; then
 
4349
  { { echo "$as_me:$LINENO: error: Python not found" >&5
 
4350
echo "$as_me: error: Python not found" >&2;}
 
4351
   { (exit 1); exit 1; }; }
 
4352
fi
 
4353
 
 
4354
 
 
4355
echo "$as_me:$LINENO: checking for Python distutils module" >&5
 
4356
echo $ECHO_N "checking for Python distutils module... $ECHO_C" >&6
 
4357
if "${PYTHON}" 2>&- -c 'import distutils'
 
4358
then
 
4359
    echo "$as_me:$LINENO: result: yes" >&5
 
4360
echo "${ECHO_T}yes" >&6
 
4361
else
 
4362
    echo "$as_me:$LINENO: result: no" >&5
 
4363
echo "${ECHO_T}no" >&6
 
4364
    { { echo "$as_me:$LINENO: error: distutils module not found" >&5
 
4365
echo "$as_me: error: distutils module not found" >&2;}
 
4366
   { (exit 1); exit 1; }; }
 
4367
fi
 
4368
echo "$as_me:$LINENO: checking Python configuration directory" >&5
 
4369
echo $ECHO_N "checking Python configuration directory... $ECHO_C" >&6
 
4370
python_version=`${PYTHON} -c "import sys; print sys.version[:3]"`
 
4371
python_configdir=`${PYTHON} -c "from distutils.sysconfig import get_python_lib as f; import os; print os.path.join(f(plat_specific=1,standard_lib=1),'config')"`
 
4372
python_includespec=`${PYTHON} -c "import distutils.sysconfig; print '-I'+distutils.sysconfig.get_python_inc()"`
 
4373
 
 
4374
# This should be enough of a message.
 
4375
echo "$as_me:$LINENO: result: $python_configdir" >&5
 
4376
echo "${ECHO_T}$python_configdir" >&6
 
4377
 
 
4378
 
 
4379
echo "$as_me:$LINENO: checking how to link an embedded Python application" >&5
 
4380
echo $ECHO_N "checking how to link an embedded Python application... $ECHO_C" >&6
 
4381
 
 
4382
python_libdir=`${PYTHON} -c "import distutils.sysconfig,string; print string.join(filter(None,distutils.sysconfig.get_config_vars('LIBDIR')))"`
 
4383
python_ldlibrary=`${PYTHON} -c "import distutils.sysconfig,string; print string.join(filter(None,distutils.sysconfig.get_config_vars('LDLIBRARY')))"`
 
4384
python_so=`${PYTHON} -c "import distutils.sysconfig,string; print string.join(filter(None,distutils.sysconfig.get_config_vars('SO')))"`
 
4385
ldlibrary=`echo "${python_ldlibrary}" | sed "s/${python_so}$//"`
 
4386
 
 
4387
if test x"${python_libdir}" != x"" -a x"${python_ldlibrary}" != x"" -a x"${python_ldlibrary}" != x"${ldlibrary}"
 
4388
then
 
4389
        # New way: use the official shared library
 
4390
        ldlibrary=`echo "${ldlibrary}" | sed "s/^lib//"`
 
4391
        python_libspec="-L${python_libdir} -l${ldlibrary}"
 
4392
else
 
4393
        # Old way: use libpython from python_configdir
 
4394
        python_libdir="${python_configdir}"
 
4395
        python_libspec="-L${python_libdir} -lpython${python_version}"
 
4396
fi
 
4397
 
 
4398
python_additional_libs=`${PYTHON} -c "import distutils.sysconfig,string; print string.join(filter(None,distutils.sysconfig.get_config_vars('LIBS','LIBC','LIBM','LOCALMODLIBS','BASEMODLIBS')))"`
 
4399
 
 
4400
echo "$as_me:$LINENO: result: ${python_libspec} ${python_additional_libs}" >&5
 
4401
echo "${ECHO_T}${python_libspec} ${python_additional_libs}" >&6
 
4402
 
 
4403
 
 
4404
fi
 
4405
 
 
4406
 
 
4407
##
 
4408
## Libraries
 
4409
##
 
4410
 
 
4411
if test "$PORTNAME" != "aix" -a "$PORTNAME" != "alpha"
 
4412
then
 
4413
 
 
4414
echo "$as_me:$LINENO: checking for main in -lbsd" >&5
 
4415
echo $ECHO_N "checking for main in -lbsd... $ECHO_C" >&6
 
4416
if test "${ac_cv_lib_bsd_main+set}" = set; then
 
4417
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4418
else
 
4419
  ac_check_lib_save_LIBS=$LIBS
 
4420
LIBS="-lbsd  $LIBS"
 
4421
cat >conftest.$ac_ext <<_ACEOF
 
4422
#line $LINENO "configure"
 
4423
#include "confdefs.h"
 
4424
 
 
4425
 
 
4426
#ifdef F77_DUMMY_MAIN
 
4427
#  ifdef __cplusplus
 
4428
     extern "C"
 
4429
#  endif
 
4430
   int F77_DUMMY_MAIN() { return 1; }
 
4431
#endif
 
4432
int
 
4433
main ()
 
4434
{
 
4435
main ();
 
4436
  ;
 
4437
  return 0;
 
4438
}
 
4439
_ACEOF
 
4440
rm -f conftest.$ac_objext conftest$ac_exeext
 
4441
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
4442
  (eval $ac_link) 2>&5
 
4443
  ac_status=$?
 
4444
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4445
  (exit $ac_status); } &&
 
4446
         { ac_try='test -s conftest$ac_exeext'
 
4447
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
4448
  (eval $ac_try) 2>&5
 
4449
  ac_status=$?
 
4450
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4451
  (exit $ac_status); }; }; then
 
4452
  ac_cv_lib_bsd_main=yes
 
4453
else
 
4454
  echo "$as_me: failed program was:" >&5
 
4455
cat conftest.$ac_ext >&5
 
4456
ac_cv_lib_bsd_main=no
 
4457
fi
 
4458
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
4459
LIBS=$ac_check_lib_save_LIBS
 
4460
fi
 
4461
echo "$as_me:$LINENO: result: $ac_cv_lib_bsd_main" >&5
 
4462
echo "${ECHO_T}$ac_cv_lib_bsd_main" >&6
 
4463
if test $ac_cv_lib_bsd_main = yes; then
 
4464
  cat >>confdefs.h <<_ACEOF
 
4465
#define HAVE_LIBBSD 1
 
4466
_ACEOF
 
4467
 
 
4468
  LIBS="-lbsd $LIBS"
 
4469
 
 
4470
fi
 
4471
 
 
4472
fi
 
4473
 
 
4474
echo "$as_me:$LINENO: checking for setproctitle in -lutil" >&5
 
4475
echo $ECHO_N "checking for setproctitle in -lutil... $ECHO_C" >&6
 
4476
if test "${ac_cv_lib_util_setproctitle+set}" = set; then
 
4477
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4478
else
 
4479
  ac_check_lib_save_LIBS=$LIBS
 
4480
LIBS="-lutil  $LIBS"
 
4481
cat >conftest.$ac_ext <<_ACEOF
 
4482
#line $LINENO "configure"
 
4483
#include "confdefs.h"
 
4484
 
 
4485
/* Override any gcc2 internal prototype to avoid an error.  */
 
4486
#ifdef __cplusplus
 
4487
extern "C"
 
4488
#endif
 
4489
/* We use char because int might match the return type of a gcc2
 
4490
   builtin and then its argument prototype would still apply.  */
 
4491
char setproctitle ();
 
4492
#ifdef F77_DUMMY_MAIN
 
4493
#  ifdef __cplusplus
 
4494
     extern "C"
 
4495
#  endif
 
4496
   int F77_DUMMY_MAIN() { return 1; }
 
4497
#endif
 
4498
int
 
4499
main ()
 
4500
{
 
4501
setproctitle ();
 
4502
  ;
 
4503
  return 0;
 
4504
}
 
4505
_ACEOF
 
4506
rm -f conftest.$ac_objext conftest$ac_exeext
 
4507
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
4508
  (eval $ac_link) 2>&5
 
4509
  ac_status=$?
 
4510
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4511
  (exit $ac_status); } &&
 
4512
         { ac_try='test -s conftest$ac_exeext'
 
4513
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
4514
  (eval $ac_try) 2>&5
 
4515
  ac_status=$?
 
4516
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4517
  (exit $ac_status); }; }; then
 
4518
  ac_cv_lib_util_setproctitle=yes
 
4519
else
 
4520
  echo "$as_me: failed program was:" >&5
 
4521
cat conftest.$ac_ext >&5
 
4522
ac_cv_lib_util_setproctitle=no
 
4523
fi
 
4524
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
4525
LIBS=$ac_check_lib_save_LIBS
 
4526
fi
 
4527
echo "$as_me:$LINENO: result: $ac_cv_lib_util_setproctitle" >&5
 
4528
echo "${ECHO_T}$ac_cv_lib_util_setproctitle" >&6
 
4529
if test $ac_cv_lib_util_setproctitle = yes; then
 
4530
  cat >>confdefs.h <<_ACEOF
 
4531
#define HAVE_LIBUTIL 1
 
4532
_ACEOF
 
4533
 
 
4534
  LIBS="-lutil $LIBS"
 
4535
 
 
4536
fi
 
4537
 
 
4538
 
 
4539
echo "$as_me:$LINENO: checking for main in -lm" >&5
 
4540
echo $ECHO_N "checking for main in -lm... $ECHO_C" >&6
 
4541
if test "${ac_cv_lib_m_main+set}" = set; then
 
4542
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4543
else
 
4544
  ac_check_lib_save_LIBS=$LIBS
 
4545
LIBS="-lm  $LIBS"
 
4546
cat >conftest.$ac_ext <<_ACEOF
 
4547
#line $LINENO "configure"
 
4548
#include "confdefs.h"
 
4549
 
 
4550
 
 
4551
#ifdef F77_DUMMY_MAIN
 
4552
#  ifdef __cplusplus
 
4553
     extern "C"
 
4554
#  endif
 
4555
   int F77_DUMMY_MAIN() { return 1; }
 
4556
#endif
 
4557
int
 
4558
main ()
 
4559
{
 
4560
main ();
 
4561
  ;
 
4562
  return 0;
 
4563
}
 
4564
_ACEOF
 
4565
rm -f conftest.$ac_objext conftest$ac_exeext
 
4566
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
4567
  (eval $ac_link) 2>&5
 
4568
  ac_status=$?
 
4569
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4570
  (exit $ac_status); } &&
 
4571
         { ac_try='test -s conftest$ac_exeext'
 
4572
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
4573
  (eval $ac_try) 2>&5
 
4574
  ac_status=$?
 
4575
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4576
  (exit $ac_status); }; }; then
 
4577
  ac_cv_lib_m_main=yes
 
4578
else
 
4579
  echo "$as_me: failed program was:" >&5
 
4580
cat conftest.$ac_ext >&5
 
4581
ac_cv_lib_m_main=no
 
4582
fi
 
4583
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
4584
LIBS=$ac_check_lib_save_LIBS
 
4585
fi
 
4586
echo "$as_me:$LINENO: result: $ac_cv_lib_m_main" >&5
 
4587
echo "${ECHO_T}$ac_cv_lib_m_main" >&6
 
4588
if test $ac_cv_lib_m_main = yes; then
 
4589
  cat >>confdefs.h <<_ACEOF
 
4590
#define HAVE_LIBM 1
 
4591
_ACEOF
 
4592
 
 
4593
  LIBS="-lm $LIBS"
 
4594
 
 
4595
fi
 
4596
 
 
4597
 
 
4598
echo "$as_me:$LINENO: checking for main in -ldl" >&5
 
4599
echo $ECHO_N "checking for main in -ldl... $ECHO_C" >&6
 
4600
if test "${ac_cv_lib_dl_main+set}" = set; then
 
4601
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4602
else
 
4603
  ac_check_lib_save_LIBS=$LIBS
 
4604
LIBS="-ldl  $LIBS"
 
4605
cat >conftest.$ac_ext <<_ACEOF
 
4606
#line $LINENO "configure"
 
4607
#include "confdefs.h"
 
4608
 
 
4609
 
 
4610
#ifdef F77_DUMMY_MAIN
 
4611
#  ifdef __cplusplus
 
4612
     extern "C"
 
4613
#  endif
 
4614
   int F77_DUMMY_MAIN() { return 1; }
 
4615
#endif
 
4616
int
 
4617
main ()
 
4618
{
 
4619
main ();
 
4620
  ;
 
4621
  return 0;
 
4622
}
 
4623
_ACEOF
 
4624
rm -f conftest.$ac_objext conftest$ac_exeext
 
4625
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
4626
  (eval $ac_link) 2>&5
 
4627
  ac_status=$?
 
4628
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4629
  (exit $ac_status); } &&
 
4630
         { ac_try='test -s conftest$ac_exeext'
 
4631
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
4632
  (eval $ac_try) 2>&5
 
4633
  ac_status=$?
 
4634
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4635
  (exit $ac_status); }; }; then
 
4636
  ac_cv_lib_dl_main=yes
 
4637
else
 
4638
  echo "$as_me: failed program was:" >&5
 
4639
cat conftest.$ac_ext >&5
 
4640
ac_cv_lib_dl_main=no
 
4641
fi
 
4642
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
4643
LIBS=$ac_check_lib_save_LIBS
 
4644
fi
 
4645
echo "$as_me:$LINENO: result: $ac_cv_lib_dl_main" >&5
 
4646
echo "${ECHO_T}$ac_cv_lib_dl_main" >&6
 
4647
if test $ac_cv_lib_dl_main = yes; then
 
4648
  cat >>confdefs.h <<_ACEOF
 
4649
#define HAVE_LIBDL 1
 
4650
_ACEOF
 
4651
 
 
4652
  LIBS="-ldl $LIBS"
 
4653
 
 
4654
fi
 
4655
 
 
4656
 
 
4657
echo "$as_me:$LINENO: checking for main in -lnsl" >&5
 
4658
echo $ECHO_N "checking for main in -lnsl... $ECHO_C" >&6
 
4659
if test "${ac_cv_lib_nsl_main+set}" = set; then
 
4660
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4661
else
 
4662
  ac_check_lib_save_LIBS=$LIBS
 
4663
LIBS="-lnsl  $LIBS"
 
4664
cat >conftest.$ac_ext <<_ACEOF
 
4665
#line $LINENO "configure"
 
4666
#include "confdefs.h"
 
4667
 
 
4668
 
 
4669
#ifdef F77_DUMMY_MAIN
 
4670
#  ifdef __cplusplus
 
4671
     extern "C"
 
4672
#  endif
 
4673
   int F77_DUMMY_MAIN() { return 1; }
 
4674
#endif
 
4675
int
 
4676
main ()
 
4677
{
 
4678
main ();
 
4679
  ;
 
4680
  return 0;
 
4681
}
 
4682
_ACEOF
 
4683
rm -f conftest.$ac_objext conftest$ac_exeext
 
4684
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
4685
  (eval $ac_link) 2>&5
 
4686
  ac_status=$?
 
4687
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4688
  (exit $ac_status); } &&
 
4689
         { ac_try='test -s conftest$ac_exeext'
 
4690
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
4691
  (eval $ac_try) 2>&5
 
4692
  ac_status=$?
 
4693
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4694
  (exit $ac_status); }; }; then
 
4695
  ac_cv_lib_nsl_main=yes
 
4696
else
 
4697
  echo "$as_me: failed program was:" >&5
 
4698
cat conftest.$ac_ext >&5
 
4699
ac_cv_lib_nsl_main=no
 
4700
fi
 
4701
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
4702
LIBS=$ac_check_lib_save_LIBS
 
4703
fi
 
4704
echo "$as_me:$LINENO: result: $ac_cv_lib_nsl_main" >&5
 
4705
echo "${ECHO_T}$ac_cv_lib_nsl_main" >&6
 
4706
if test $ac_cv_lib_nsl_main = yes; then
 
4707
  cat >>confdefs.h <<_ACEOF
 
4708
#define HAVE_LIBNSL 1
 
4709
_ACEOF
 
4710
 
 
4711
  LIBS="-lnsl $LIBS"
 
4712
 
 
4713
fi
 
4714
 
 
4715
 
 
4716
echo "$as_me:$LINENO: checking for main in -lsocket" >&5
 
4717
echo $ECHO_N "checking for main in -lsocket... $ECHO_C" >&6
 
4718
if test "${ac_cv_lib_socket_main+set}" = set; then
 
4719
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4720
else
 
4721
  ac_check_lib_save_LIBS=$LIBS
 
4722
LIBS="-lsocket  $LIBS"
 
4723
cat >conftest.$ac_ext <<_ACEOF
 
4724
#line $LINENO "configure"
 
4725
#include "confdefs.h"
 
4726
 
 
4727
 
 
4728
#ifdef F77_DUMMY_MAIN
 
4729
#  ifdef __cplusplus
 
4730
     extern "C"
 
4731
#  endif
 
4732
   int F77_DUMMY_MAIN() { return 1; }
 
4733
#endif
 
4734
int
 
4735
main ()
 
4736
{
 
4737
main ();
 
4738
  ;
 
4739
  return 0;
 
4740
}
 
4741
_ACEOF
 
4742
rm -f conftest.$ac_objext conftest$ac_exeext
 
4743
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
4744
  (eval $ac_link) 2>&5
 
4745
  ac_status=$?
 
4746
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4747
  (exit $ac_status); } &&
 
4748
         { ac_try='test -s conftest$ac_exeext'
 
4749
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
4750
  (eval $ac_try) 2>&5
 
4751
  ac_status=$?
 
4752
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4753
  (exit $ac_status); }; }; then
 
4754
  ac_cv_lib_socket_main=yes
 
4755
else
 
4756
  echo "$as_me: failed program was:" >&5
 
4757
cat conftest.$ac_ext >&5
 
4758
ac_cv_lib_socket_main=no
 
4759
fi
 
4760
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
4761
LIBS=$ac_check_lib_save_LIBS
 
4762
fi
 
4763
echo "$as_me:$LINENO: result: $ac_cv_lib_socket_main" >&5
 
4764
echo "${ECHO_T}$ac_cv_lib_socket_main" >&6
 
4765
if test $ac_cv_lib_socket_main = yes; then
 
4766
  cat >>confdefs.h <<_ACEOF
 
4767
#define HAVE_LIBSOCKET 1
 
4768
_ACEOF
 
4769
 
 
4770
  LIBS="-lsocket $LIBS"
 
4771
 
 
4772
fi
 
4773
 
 
4774
 
 
4775
echo "$as_me:$LINENO: checking for main in -lipc" >&5
 
4776
echo $ECHO_N "checking for main in -lipc... $ECHO_C" >&6
 
4777
if test "${ac_cv_lib_ipc_main+set}" = set; then
 
4778
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4779
else
 
4780
  ac_check_lib_save_LIBS=$LIBS
 
4781
LIBS="-lipc  $LIBS"
 
4782
cat >conftest.$ac_ext <<_ACEOF
 
4783
#line $LINENO "configure"
 
4784
#include "confdefs.h"
 
4785
 
 
4786
 
 
4787
#ifdef F77_DUMMY_MAIN
 
4788
#  ifdef __cplusplus
 
4789
     extern "C"
 
4790
#  endif
 
4791
   int F77_DUMMY_MAIN() { return 1; }
 
4792
#endif
 
4793
int
 
4794
main ()
 
4795
{
 
4796
main ();
 
4797
  ;
 
4798
  return 0;
 
4799
}
 
4800
_ACEOF
 
4801
rm -f conftest.$ac_objext conftest$ac_exeext
 
4802
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
4803
  (eval $ac_link) 2>&5
 
4804
  ac_status=$?
 
4805
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4806
  (exit $ac_status); } &&
 
4807
         { ac_try='test -s conftest$ac_exeext'
 
4808
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
4809
  (eval $ac_try) 2>&5
 
4810
  ac_status=$?
 
4811
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4812
  (exit $ac_status); }; }; then
 
4813
  ac_cv_lib_ipc_main=yes
 
4814
else
 
4815
  echo "$as_me: failed program was:" >&5
 
4816
cat conftest.$ac_ext >&5
 
4817
ac_cv_lib_ipc_main=no
 
4818
fi
 
4819
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
4820
LIBS=$ac_check_lib_save_LIBS
 
4821
fi
 
4822
echo "$as_me:$LINENO: result: $ac_cv_lib_ipc_main" >&5
 
4823
echo "${ECHO_T}$ac_cv_lib_ipc_main" >&6
 
4824
if test $ac_cv_lib_ipc_main = yes; then
 
4825
  cat >>confdefs.h <<_ACEOF
 
4826
#define HAVE_LIBIPC 1
 
4827
_ACEOF
 
4828
 
 
4829
  LIBS="-lipc $LIBS"
 
4830
 
 
4831
fi
 
4832
 
 
4833
 
 
4834
echo "$as_me:$LINENO: checking for main in -lIPC" >&5
 
4835
echo $ECHO_N "checking for main in -lIPC... $ECHO_C" >&6
 
4836
if test "${ac_cv_lib_IPC_main+set}" = set; then
 
4837
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4838
else
 
4839
  ac_check_lib_save_LIBS=$LIBS
 
4840
LIBS="-lIPC  $LIBS"
 
4841
cat >conftest.$ac_ext <<_ACEOF
 
4842
#line $LINENO "configure"
 
4843
#include "confdefs.h"
 
4844
 
 
4845
 
 
4846
#ifdef F77_DUMMY_MAIN
 
4847
#  ifdef __cplusplus
 
4848
     extern "C"
 
4849
#  endif
 
4850
   int F77_DUMMY_MAIN() { return 1; }
 
4851
#endif
 
4852
int
 
4853
main ()
 
4854
{
 
4855
main ();
 
4856
  ;
 
4857
  return 0;
 
4858
}
 
4859
_ACEOF
 
4860
rm -f conftest.$ac_objext conftest$ac_exeext
 
4861
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
4862
  (eval $ac_link) 2>&5
 
4863
  ac_status=$?
 
4864
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4865
  (exit $ac_status); } &&
 
4866
         { ac_try='test -s conftest$ac_exeext'
 
4867
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
4868
  (eval $ac_try) 2>&5
 
4869
  ac_status=$?
 
4870
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4871
  (exit $ac_status); }; }; then
 
4872
  ac_cv_lib_IPC_main=yes
 
4873
else
 
4874
  echo "$as_me: failed program was:" >&5
 
4875
cat conftest.$ac_ext >&5
 
4876
ac_cv_lib_IPC_main=no
 
4877
fi
 
4878
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
4879
LIBS=$ac_check_lib_save_LIBS
 
4880
fi
 
4881
echo "$as_me:$LINENO: result: $ac_cv_lib_IPC_main" >&5
 
4882
echo "${ECHO_T}$ac_cv_lib_IPC_main" >&6
 
4883
if test $ac_cv_lib_IPC_main = yes; then
 
4884
  cat >>confdefs.h <<_ACEOF
 
4885
#define HAVE_LIBIPC 1
 
4886
_ACEOF
 
4887
 
 
4888
  LIBS="-lIPC $LIBS"
 
4889
 
 
4890
fi
 
4891
 
 
4892
 
 
4893
echo "$as_me:$LINENO: checking for main in -llc" >&5
 
4894
echo $ECHO_N "checking for main in -llc... $ECHO_C" >&6
 
4895
if test "${ac_cv_lib_lc_main+set}" = set; then
 
4896
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4897
else
 
4898
  ac_check_lib_save_LIBS=$LIBS
 
4899
LIBS="-llc  $LIBS"
 
4900
cat >conftest.$ac_ext <<_ACEOF
 
4901
#line $LINENO "configure"
 
4902
#include "confdefs.h"
 
4903
 
 
4904
 
 
4905
#ifdef F77_DUMMY_MAIN
 
4906
#  ifdef __cplusplus
 
4907
     extern "C"
 
4908
#  endif
 
4909
   int F77_DUMMY_MAIN() { return 1; }
 
4910
#endif
 
4911
int
 
4912
main ()
 
4913
{
 
4914
main ();
 
4915
  ;
 
4916
  return 0;
 
4917
}
 
4918
_ACEOF
 
4919
rm -f conftest.$ac_objext conftest$ac_exeext
 
4920
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
4921
  (eval $ac_link) 2>&5
 
4922
  ac_status=$?
 
4923
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4924
  (exit $ac_status); } &&
 
4925
         { ac_try='test -s conftest$ac_exeext'
 
4926
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
4927
  (eval $ac_try) 2>&5
 
4928
  ac_status=$?
 
4929
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4930
  (exit $ac_status); }; }; then
 
4931
  ac_cv_lib_lc_main=yes
 
4932
else
 
4933
  echo "$as_me: failed program was:" >&5
 
4934
cat conftest.$ac_ext >&5
 
4935
ac_cv_lib_lc_main=no
 
4936
fi
 
4937
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
4938
LIBS=$ac_check_lib_save_LIBS
 
4939
fi
 
4940
echo "$as_me:$LINENO: result: $ac_cv_lib_lc_main" >&5
 
4941
echo "${ECHO_T}$ac_cv_lib_lc_main" >&6
 
4942
if test $ac_cv_lib_lc_main = yes; then
 
4943
  cat >>confdefs.h <<_ACEOF
 
4944
#define HAVE_LIBLC 1
 
4945
_ACEOF
 
4946
 
 
4947
  LIBS="-llc $LIBS"
 
4948
 
 
4949
fi
 
4950
 
 
4951
 
 
4952
echo "$as_me:$LINENO: checking for main in -ldld" >&5
 
4953
echo $ECHO_N "checking for main in -ldld... $ECHO_C" >&6
 
4954
if test "${ac_cv_lib_dld_main+set}" = set; then
 
4955
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4956
else
 
4957
  ac_check_lib_save_LIBS=$LIBS
 
4958
LIBS="-ldld  $LIBS"
 
4959
cat >conftest.$ac_ext <<_ACEOF
 
4960
#line $LINENO "configure"
 
4961
#include "confdefs.h"
 
4962
 
 
4963
 
 
4964
#ifdef F77_DUMMY_MAIN
 
4965
#  ifdef __cplusplus
 
4966
     extern "C"
 
4967
#  endif
 
4968
   int F77_DUMMY_MAIN() { return 1; }
 
4969
#endif
 
4970
int
 
4971
main ()
 
4972
{
 
4973
main ();
 
4974
  ;
 
4975
  return 0;
 
4976
}
 
4977
_ACEOF
 
4978
rm -f conftest.$ac_objext conftest$ac_exeext
 
4979
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
4980
  (eval $ac_link) 2>&5
 
4981
  ac_status=$?
 
4982
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4983
  (exit $ac_status); } &&
 
4984
         { ac_try='test -s conftest$ac_exeext'
 
4985
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
4986
  (eval $ac_try) 2>&5
 
4987
  ac_status=$?
 
4988
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
4989
  (exit $ac_status); }; }; then
 
4990
  ac_cv_lib_dld_main=yes
 
4991
else
 
4992
  echo "$as_me: failed program was:" >&5
 
4993
cat conftest.$ac_ext >&5
 
4994
ac_cv_lib_dld_main=no
 
4995
fi
 
4996
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
4997
LIBS=$ac_check_lib_save_LIBS
 
4998
fi
 
4999
echo "$as_me:$LINENO: result: $ac_cv_lib_dld_main" >&5
 
5000
echo "${ECHO_T}$ac_cv_lib_dld_main" >&6
 
5001
if test $ac_cv_lib_dld_main = yes; then
 
5002
  cat >>confdefs.h <<_ACEOF
 
5003
#define HAVE_LIBDLD 1
 
5004
_ACEOF
 
5005
 
 
5006
  LIBS="-ldld $LIBS"
 
5007
 
 
5008
fi
 
5009
 
 
5010
 
 
5011
echo "$as_me:$LINENO: checking for main in -lld" >&5
 
5012
echo $ECHO_N "checking for main in -lld... $ECHO_C" >&6
 
5013
if test "${ac_cv_lib_ld_main+set}" = set; then
 
5014
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5015
else
 
5016
  ac_check_lib_save_LIBS=$LIBS
 
5017
LIBS="-lld  $LIBS"
 
5018
cat >conftest.$ac_ext <<_ACEOF
 
5019
#line $LINENO "configure"
 
5020
#include "confdefs.h"
 
5021
 
 
5022
 
 
5023
#ifdef F77_DUMMY_MAIN
 
5024
#  ifdef __cplusplus
 
5025
     extern "C"
 
5026
#  endif
 
5027
   int F77_DUMMY_MAIN() { return 1; }
 
5028
#endif
 
5029
int
 
5030
main ()
 
5031
{
 
5032
main ();
 
5033
  ;
 
5034
  return 0;
 
5035
}
 
5036
_ACEOF
 
5037
rm -f conftest.$ac_objext conftest$ac_exeext
 
5038
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
5039
  (eval $ac_link) 2>&5
 
5040
  ac_status=$?
 
5041
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5042
  (exit $ac_status); } &&
 
5043
         { ac_try='test -s conftest$ac_exeext'
 
5044
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
5045
  (eval $ac_try) 2>&5
 
5046
  ac_status=$?
 
5047
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5048
  (exit $ac_status); }; }; then
 
5049
  ac_cv_lib_ld_main=yes
 
5050
else
 
5051
  echo "$as_me: failed program was:" >&5
 
5052
cat conftest.$ac_ext >&5
 
5053
ac_cv_lib_ld_main=no
 
5054
fi
 
5055
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
5056
LIBS=$ac_check_lib_save_LIBS
 
5057
fi
 
5058
echo "$as_me:$LINENO: result: $ac_cv_lib_ld_main" >&5
 
5059
echo "${ECHO_T}$ac_cv_lib_ld_main" >&6
 
5060
if test $ac_cv_lib_ld_main = yes; then
 
5061
  cat >>confdefs.h <<_ACEOF
 
5062
#define HAVE_LIBLD 1
 
5063
_ACEOF
 
5064
 
 
5065
  LIBS="-lld $LIBS"
 
5066
 
 
5067
fi
 
5068
 
 
5069
 
 
5070
echo "$as_me:$LINENO: checking for main in -lcompat" >&5
 
5071
echo $ECHO_N "checking for main in -lcompat... $ECHO_C" >&6
 
5072
if test "${ac_cv_lib_compat_main+set}" = set; then
 
5073
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5074
else
 
5075
  ac_check_lib_save_LIBS=$LIBS
 
5076
LIBS="-lcompat  $LIBS"
 
5077
cat >conftest.$ac_ext <<_ACEOF
 
5078
#line $LINENO "configure"
 
5079
#include "confdefs.h"
 
5080
 
 
5081
 
 
5082
#ifdef F77_DUMMY_MAIN
 
5083
#  ifdef __cplusplus
 
5084
     extern "C"
 
5085
#  endif
 
5086
   int F77_DUMMY_MAIN() { return 1; }
 
5087
#endif
 
5088
int
 
5089
main ()
 
5090
{
 
5091
main ();
 
5092
  ;
 
5093
  return 0;
 
5094
}
 
5095
_ACEOF
 
5096
rm -f conftest.$ac_objext conftest$ac_exeext
 
5097
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
5098
  (eval $ac_link) 2>&5
 
5099
  ac_status=$?
 
5100
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5101
  (exit $ac_status); } &&
 
5102
         { ac_try='test -s conftest$ac_exeext'
 
5103
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
5104
  (eval $ac_try) 2>&5
 
5105
  ac_status=$?
 
5106
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5107
  (exit $ac_status); }; }; then
 
5108
  ac_cv_lib_compat_main=yes
 
5109
else
 
5110
  echo "$as_me: failed program was:" >&5
 
5111
cat conftest.$ac_ext >&5
 
5112
ac_cv_lib_compat_main=no
 
5113
fi
 
5114
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
5115
LIBS=$ac_check_lib_save_LIBS
 
5116
fi
 
5117
echo "$as_me:$LINENO: result: $ac_cv_lib_compat_main" >&5
 
5118
echo "${ECHO_T}$ac_cv_lib_compat_main" >&6
 
5119
if test $ac_cv_lib_compat_main = yes; then
 
5120
  cat >>confdefs.h <<_ACEOF
 
5121
#define HAVE_LIBCOMPAT 1
 
5122
_ACEOF
 
5123
 
 
5124
  LIBS="-lcompat $LIBS"
 
5125
 
 
5126
fi
 
5127
 
 
5128
 
 
5129
echo "$as_me:$LINENO: checking for main in -lBSD" >&5
 
5130
echo $ECHO_N "checking for main in -lBSD... $ECHO_C" >&6
 
5131
if test "${ac_cv_lib_BSD_main+set}" = set; then
 
5132
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5133
else
 
5134
  ac_check_lib_save_LIBS=$LIBS
 
5135
LIBS="-lBSD  $LIBS"
 
5136
cat >conftest.$ac_ext <<_ACEOF
 
5137
#line $LINENO "configure"
 
5138
#include "confdefs.h"
 
5139
 
 
5140
 
 
5141
#ifdef F77_DUMMY_MAIN
 
5142
#  ifdef __cplusplus
 
5143
     extern "C"
 
5144
#  endif
 
5145
   int F77_DUMMY_MAIN() { return 1; }
 
5146
#endif
 
5147
int
 
5148
main ()
 
5149
{
 
5150
main ();
 
5151
  ;
 
5152
  return 0;
 
5153
}
 
5154
_ACEOF
 
5155
rm -f conftest.$ac_objext conftest$ac_exeext
 
5156
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
5157
  (eval $ac_link) 2>&5
 
5158
  ac_status=$?
 
5159
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5160
  (exit $ac_status); } &&
 
5161
         { ac_try='test -s conftest$ac_exeext'
 
5162
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
5163
  (eval $ac_try) 2>&5
 
5164
  ac_status=$?
 
5165
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5166
  (exit $ac_status); }; }; then
 
5167
  ac_cv_lib_BSD_main=yes
 
5168
else
 
5169
  echo "$as_me: failed program was:" >&5
 
5170
cat conftest.$ac_ext >&5
 
5171
ac_cv_lib_BSD_main=no
 
5172
fi
 
5173
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
5174
LIBS=$ac_check_lib_save_LIBS
 
5175
fi
 
5176
echo "$as_me:$LINENO: result: $ac_cv_lib_BSD_main" >&5
 
5177
echo "${ECHO_T}$ac_cv_lib_BSD_main" >&6
 
5178
if test $ac_cv_lib_BSD_main = yes; then
 
5179
  cat >>confdefs.h <<_ACEOF
 
5180
#define HAVE_LIBBSD 1
 
5181
_ACEOF
 
5182
 
 
5183
  LIBS="-lBSD $LIBS"
 
5184
 
 
5185
fi
 
5186
 
 
5187
 
 
5188
echo "$as_me:$LINENO: checking for main in -lgen" >&5
 
5189
echo $ECHO_N "checking for main in -lgen... $ECHO_C" >&6
 
5190
if test "${ac_cv_lib_gen_main+set}" = set; then
 
5191
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5192
else
 
5193
  ac_check_lib_save_LIBS=$LIBS
 
5194
LIBS="-lgen  $LIBS"
 
5195
cat >conftest.$ac_ext <<_ACEOF
 
5196
#line $LINENO "configure"
 
5197
#include "confdefs.h"
 
5198
 
 
5199
 
 
5200
#ifdef F77_DUMMY_MAIN
 
5201
#  ifdef __cplusplus
 
5202
     extern "C"
 
5203
#  endif
 
5204
   int F77_DUMMY_MAIN() { return 1; }
 
5205
#endif
 
5206
int
 
5207
main ()
 
5208
{
 
5209
main ();
 
5210
  ;
 
5211
  return 0;
 
5212
}
 
5213
_ACEOF
 
5214
rm -f conftest.$ac_objext conftest$ac_exeext
 
5215
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
5216
  (eval $ac_link) 2>&5
 
5217
  ac_status=$?
 
5218
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5219
  (exit $ac_status); } &&
 
5220
         { ac_try='test -s conftest$ac_exeext'
 
5221
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
5222
  (eval $ac_try) 2>&5
 
5223
  ac_status=$?
 
5224
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5225
  (exit $ac_status); }; }; then
 
5226
  ac_cv_lib_gen_main=yes
 
5227
else
 
5228
  echo "$as_me: failed program was:" >&5
 
5229
cat conftest.$ac_ext >&5
 
5230
ac_cv_lib_gen_main=no
 
5231
fi
 
5232
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
5233
LIBS=$ac_check_lib_save_LIBS
 
5234
fi
 
5235
echo "$as_me:$LINENO: result: $ac_cv_lib_gen_main" >&5
 
5236
echo "${ECHO_T}$ac_cv_lib_gen_main" >&6
 
5237
if test $ac_cv_lib_gen_main = yes; then
 
5238
  cat >>confdefs.h <<_ACEOF
 
5239
#define HAVE_LIBGEN 1
 
5240
_ACEOF
 
5241
 
 
5242
  LIBS="-lgen $LIBS"
 
5243
 
 
5244
fi
 
5245
 
 
5246
 
 
5247
echo "$as_me:$LINENO: checking for main in -lPW" >&5
 
5248
echo $ECHO_N "checking for main in -lPW... $ECHO_C" >&6
 
5249
if test "${ac_cv_lib_PW_main+set}" = set; then
 
5250
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5251
else
 
5252
  ac_check_lib_save_LIBS=$LIBS
 
5253
LIBS="-lPW  $LIBS"
 
5254
cat >conftest.$ac_ext <<_ACEOF
 
5255
#line $LINENO "configure"
 
5256
#include "confdefs.h"
 
5257
 
 
5258
 
 
5259
#ifdef F77_DUMMY_MAIN
 
5260
#  ifdef __cplusplus
 
5261
     extern "C"
 
5262
#  endif
 
5263
   int F77_DUMMY_MAIN() { return 1; }
 
5264
#endif
 
5265
int
 
5266
main ()
 
5267
{
 
5268
main ();
 
5269
  ;
 
5270
  return 0;
 
5271
}
 
5272
_ACEOF
 
5273
rm -f conftest.$ac_objext conftest$ac_exeext
 
5274
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
5275
  (eval $ac_link) 2>&5
 
5276
  ac_status=$?
 
5277
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5278
  (exit $ac_status); } &&
 
5279
         { ac_try='test -s conftest$ac_exeext'
 
5280
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
5281
  (eval $ac_try) 2>&5
 
5282
  ac_status=$?
 
5283
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5284
  (exit $ac_status); }; }; then
 
5285
  ac_cv_lib_PW_main=yes
 
5286
else
 
5287
  echo "$as_me: failed program was:" >&5
 
5288
cat conftest.$ac_ext >&5
 
5289
ac_cv_lib_PW_main=no
 
5290
fi
 
5291
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
5292
LIBS=$ac_check_lib_save_LIBS
 
5293
fi
 
5294
echo "$as_me:$LINENO: result: $ac_cv_lib_PW_main" >&5
 
5295
echo "${ECHO_T}$ac_cv_lib_PW_main" >&6
 
5296
if test $ac_cv_lib_PW_main = yes; then
 
5297
  cat >>confdefs.h <<_ACEOF
 
5298
#define HAVE_LIBPW 1
 
5299
_ACEOF
 
5300
 
 
5301
  LIBS="-lPW $LIBS"
 
5302
 
 
5303
fi
 
5304
 
 
5305
 
 
5306
echo "$as_me:$LINENO: checking for main in -lresolv" >&5
 
5307
echo $ECHO_N "checking for main in -lresolv... $ECHO_C" >&6
 
5308
if test "${ac_cv_lib_resolv_main+set}" = set; then
 
5309
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5310
else
 
5311
  ac_check_lib_save_LIBS=$LIBS
 
5312
LIBS="-lresolv  $LIBS"
 
5313
cat >conftest.$ac_ext <<_ACEOF
 
5314
#line $LINENO "configure"
 
5315
#include "confdefs.h"
 
5316
 
 
5317
 
 
5318
#ifdef F77_DUMMY_MAIN
 
5319
#  ifdef __cplusplus
 
5320
     extern "C"
 
5321
#  endif
 
5322
   int F77_DUMMY_MAIN() { return 1; }
 
5323
#endif
 
5324
int
 
5325
main ()
 
5326
{
 
5327
main ();
 
5328
  ;
 
5329
  return 0;
 
5330
}
 
5331
_ACEOF
 
5332
rm -f conftest.$ac_objext conftest$ac_exeext
 
5333
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
5334
  (eval $ac_link) 2>&5
 
5335
  ac_status=$?
 
5336
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5337
  (exit $ac_status); } &&
 
5338
         { ac_try='test -s conftest$ac_exeext'
 
5339
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
5340
  (eval $ac_try) 2>&5
 
5341
  ac_status=$?
 
5342
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5343
  (exit $ac_status); }; }; then
 
5344
  ac_cv_lib_resolv_main=yes
 
5345
else
 
5346
  echo "$as_me: failed program was:" >&5
 
5347
cat conftest.$ac_ext >&5
 
5348
ac_cv_lib_resolv_main=no
 
5349
fi
 
5350
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
5351
LIBS=$ac_check_lib_save_LIBS
 
5352
fi
 
5353
echo "$as_me:$LINENO: result: $ac_cv_lib_resolv_main" >&5
 
5354
echo "${ECHO_T}$ac_cv_lib_resolv_main" >&6
 
5355
if test $ac_cv_lib_resolv_main = yes; then
 
5356
  cat >>confdefs.h <<_ACEOF
 
5357
#define HAVE_LIBRESOLV 1
 
5358
_ACEOF
 
5359
 
 
5360
  LIBS="-lresolv $LIBS"
 
5361
 
 
5362
fi
 
5363
 
 
5364
echo "$as_me:$LINENO: checking for library containing getopt_long" >&5
 
5365
echo $ECHO_N "checking for library containing getopt_long... $ECHO_C" >&6
 
5366
if test "${ac_cv_search_getopt_long+set}" = set; then
 
5367
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5368
else
 
5369
  ac_func_search_save_LIBS=$LIBS
 
5370
ac_cv_search_getopt_long=no
 
5371
cat >conftest.$ac_ext <<_ACEOF
 
5372
#line $LINENO "configure"
 
5373
#include "confdefs.h"
 
5374
 
 
5375
/* Override any gcc2 internal prototype to avoid an error.  */
 
5376
#ifdef __cplusplus
 
5377
extern "C"
 
5378
#endif
 
5379
/* We use char because int might match the return type of a gcc2
 
5380
   builtin and then its argument prototype would still apply.  */
 
5381
char getopt_long ();
 
5382
#ifdef F77_DUMMY_MAIN
 
5383
#  ifdef __cplusplus
 
5384
     extern "C"
 
5385
#  endif
 
5386
   int F77_DUMMY_MAIN() { return 1; }
 
5387
#endif
 
5388
int
 
5389
main ()
 
5390
{
 
5391
getopt_long ();
 
5392
  ;
 
5393
  return 0;
 
5394
}
 
5395
_ACEOF
 
5396
rm -f conftest.$ac_objext conftest$ac_exeext
 
5397
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
5398
  (eval $ac_link) 2>&5
 
5399
  ac_status=$?
 
5400
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5401
  (exit $ac_status); } &&
 
5402
         { ac_try='test -s conftest$ac_exeext'
 
5403
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
5404
  (eval $ac_try) 2>&5
 
5405
  ac_status=$?
 
5406
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5407
  (exit $ac_status); }; }; then
 
5408
  ac_cv_search_getopt_long="none required"
 
5409
else
 
5410
  echo "$as_me: failed program was:" >&5
 
5411
cat conftest.$ac_ext >&5
 
5412
fi
 
5413
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
5414
if test "$ac_cv_search_getopt_long" = no; then
 
5415
  for ac_lib in getopt gnugetopt; do
 
5416
    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
 
5417
    cat >conftest.$ac_ext <<_ACEOF
 
5418
#line $LINENO "configure"
 
5419
#include "confdefs.h"
 
5420
 
 
5421
/* Override any gcc2 internal prototype to avoid an error.  */
 
5422
#ifdef __cplusplus
 
5423
extern "C"
 
5424
#endif
 
5425
/* We use char because int might match the return type of a gcc2
 
5426
   builtin and then its argument prototype would still apply.  */
 
5427
char getopt_long ();
 
5428
#ifdef F77_DUMMY_MAIN
 
5429
#  ifdef __cplusplus
 
5430
     extern "C"
 
5431
#  endif
 
5432
   int F77_DUMMY_MAIN() { return 1; }
 
5433
#endif
 
5434
int
 
5435
main ()
 
5436
{
 
5437
getopt_long ();
 
5438
  ;
 
5439
  return 0;
 
5440
}
 
5441
_ACEOF
 
5442
rm -f conftest.$ac_objext conftest$ac_exeext
 
5443
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
5444
  (eval $ac_link) 2>&5
 
5445
  ac_status=$?
 
5446
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5447
  (exit $ac_status); } &&
 
5448
         { ac_try='test -s conftest$ac_exeext'
 
5449
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
5450
  (eval $ac_try) 2>&5
 
5451
  ac_status=$?
 
5452
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5453
  (exit $ac_status); }; }; then
 
5454
  ac_cv_search_getopt_long="-l$ac_lib"
 
5455
break
 
5456
else
 
5457
  echo "$as_me: failed program was:" >&5
 
5458
cat conftest.$ac_ext >&5
 
5459
fi
 
5460
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
5461
  done
 
5462
fi
 
5463
LIBS=$ac_func_search_save_LIBS
 
5464
fi
 
5465
echo "$as_me:$LINENO: result: $ac_cv_search_getopt_long" >&5
 
5466
echo "${ECHO_T}$ac_cv_search_getopt_long" >&6
 
5467
if test "$ac_cv_search_getopt_long" != no; then
 
5468
  test "$ac_cv_search_getopt_long" = "none required" || LIBS="$ac_cv_search_getopt_long $LIBS"
 
5469
 
 
5470
fi
 
5471
 
 
5472
# QNX:
 
5473
 
 
5474
echo "$as_me:$LINENO: checking for main in -lunix" >&5
 
5475
echo $ECHO_N "checking for main in -lunix... $ECHO_C" >&6
 
5476
if test "${ac_cv_lib_unix_main+set}" = set; then
 
5477
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5478
else
 
5479
  ac_check_lib_save_LIBS=$LIBS
 
5480
LIBS="-lunix  $LIBS"
 
5481
cat >conftest.$ac_ext <<_ACEOF
 
5482
#line $LINENO "configure"
 
5483
#include "confdefs.h"
 
5484
 
 
5485
 
 
5486
#ifdef F77_DUMMY_MAIN
 
5487
#  ifdef __cplusplus
 
5488
     extern "C"
 
5489
#  endif
 
5490
   int F77_DUMMY_MAIN() { return 1; }
 
5491
#endif
 
5492
int
 
5493
main ()
 
5494
{
 
5495
main ();
 
5496
  ;
 
5497
  return 0;
 
5498
}
 
5499
_ACEOF
 
5500
rm -f conftest.$ac_objext conftest$ac_exeext
 
5501
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
5502
  (eval $ac_link) 2>&5
 
5503
  ac_status=$?
 
5504
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5505
  (exit $ac_status); } &&
 
5506
         { ac_try='test -s conftest$ac_exeext'
 
5507
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
5508
  (eval $ac_try) 2>&5
 
5509
  ac_status=$?
 
5510
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5511
  (exit $ac_status); }; }; then
 
5512
  ac_cv_lib_unix_main=yes
 
5513
else
 
5514
  echo "$as_me: failed program was:" >&5
 
5515
cat conftest.$ac_ext >&5
 
5516
ac_cv_lib_unix_main=no
 
5517
fi
 
5518
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
5519
LIBS=$ac_check_lib_save_LIBS
 
5520
fi
 
5521
echo "$as_me:$LINENO: result: $ac_cv_lib_unix_main" >&5
 
5522
echo "${ECHO_T}$ac_cv_lib_unix_main" >&6
 
5523
if test $ac_cv_lib_unix_main = yes; then
 
5524
  cat >>confdefs.h <<_ACEOF
 
5525
#define HAVE_LIBUNIX 1
 
5526
_ACEOF
 
5527
 
 
5528
  LIBS="-lunix $LIBS"
 
5529
 
 
5530
fi
 
5531
 
 
5532
echo "$as_me:$LINENO: checking for library containing crypt" >&5
 
5533
echo $ECHO_N "checking for library containing crypt... $ECHO_C" >&6
 
5534
if test "${ac_cv_search_crypt+set}" = set; then
 
5535
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5536
else
 
5537
  ac_func_search_save_LIBS=$LIBS
 
5538
ac_cv_search_crypt=no
 
5539
cat >conftest.$ac_ext <<_ACEOF
 
5540
#line $LINENO "configure"
 
5541
#include "confdefs.h"
 
5542
 
 
5543
/* Override any gcc2 internal prototype to avoid an error.  */
 
5544
#ifdef __cplusplus
 
5545
extern "C"
 
5546
#endif
 
5547
/* We use char because int might match the return type of a gcc2
 
5548
   builtin and then its argument prototype would still apply.  */
 
5549
char crypt ();
 
5550
#ifdef F77_DUMMY_MAIN
 
5551
#  ifdef __cplusplus
 
5552
     extern "C"
 
5553
#  endif
 
5554
   int F77_DUMMY_MAIN() { return 1; }
 
5555
#endif
 
5556
int
 
5557
main ()
 
5558
{
 
5559
crypt ();
 
5560
  ;
 
5561
  return 0;
 
5562
}
 
5563
_ACEOF
 
5564
rm -f conftest.$ac_objext conftest$ac_exeext
 
5565
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
5566
  (eval $ac_link) 2>&5
 
5567
  ac_status=$?
 
5568
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5569
  (exit $ac_status); } &&
 
5570
         { ac_try='test -s conftest$ac_exeext'
 
5571
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
5572
  (eval $ac_try) 2>&5
 
5573
  ac_status=$?
 
5574
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5575
  (exit $ac_status); }; }; then
 
5576
  ac_cv_search_crypt="none required"
 
5577
else
 
5578
  echo "$as_me: failed program was:" >&5
 
5579
cat conftest.$ac_ext >&5
 
5580
fi
 
5581
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
5582
if test "$ac_cv_search_crypt" = no; then
 
5583
  for ac_lib in crypt; do
 
5584
    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
 
5585
    cat >conftest.$ac_ext <<_ACEOF
 
5586
#line $LINENO "configure"
 
5587
#include "confdefs.h"
 
5588
 
 
5589
/* Override any gcc2 internal prototype to avoid an error.  */
 
5590
#ifdef __cplusplus
 
5591
extern "C"
 
5592
#endif
 
5593
/* We use char because int might match the return type of a gcc2
 
5594
   builtin and then its argument prototype would still apply.  */
 
5595
char crypt ();
 
5596
#ifdef F77_DUMMY_MAIN
 
5597
#  ifdef __cplusplus
 
5598
     extern "C"
 
5599
#  endif
 
5600
   int F77_DUMMY_MAIN() { return 1; }
 
5601
#endif
 
5602
int
 
5603
main ()
 
5604
{
 
5605
crypt ();
 
5606
  ;
 
5607
  return 0;
 
5608
}
 
5609
_ACEOF
 
5610
rm -f conftest.$ac_objext conftest$ac_exeext
 
5611
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
5612
  (eval $ac_link) 2>&5
 
5613
  ac_status=$?
 
5614
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5615
  (exit $ac_status); } &&
 
5616
         { ac_try='test -s conftest$ac_exeext'
 
5617
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
5618
  (eval $ac_try) 2>&5
 
5619
  ac_status=$?
 
5620
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5621
  (exit $ac_status); }; }; then
 
5622
  ac_cv_search_crypt="-l$ac_lib"
 
5623
break
 
5624
else
 
5625
  echo "$as_me: failed program was:" >&5
 
5626
cat conftest.$ac_ext >&5
 
5627
fi
 
5628
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
5629
  done
 
5630
fi
 
5631
LIBS=$ac_func_search_save_LIBS
 
5632
fi
 
5633
echo "$as_me:$LINENO: result: $ac_cv_search_crypt" >&5
 
5634
echo "${ECHO_T}$ac_cv_search_crypt" >&6
 
5635
if test "$ac_cv_search_crypt" != no; then
 
5636
  test "$ac_cv_search_crypt" = "none required" || LIBS="$ac_cv_search_crypt $LIBS"
 
5637
 
 
5638
fi
 
5639
 
 
5640
# BeOS:
 
5641
if test "$PORTNAME" = "beos"
 
5642
then
 
5643
 
 
5644
echo "$as_me:$LINENO: checking for __inet_ntoa in -lbind" >&5
 
5645
echo $ECHO_N "checking for __inet_ntoa in -lbind... $ECHO_C" >&6
 
5646
if test "${ac_cv_lib_bind___inet_ntoa+set}" = set; then
 
5647
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5648
else
 
5649
  ac_check_lib_save_LIBS=$LIBS
 
5650
LIBS="-lbind  $LIBS"
 
5651
cat >conftest.$ac_ext <<_ACEOF
 
5652
#line $LINENO "configure"
 
5653
#include "confdefs.h"
 
5654
 
 
5655
/* Override any gcc2 internal prototype to avoid an error.  */
 
5656
#ifdef __cplusplus
 
5657
extern "C"
 
5658
#endif
 
5659
/* We use char because int might match the return type of a gcc2
 
5660
   builtin and then its argument prototype would still apply.  */
 
5661
char __inet_ntoa ();
 
5662
#ifdef F77_DUMMY_MAIN
 
5663
#  ifdef __cplusplus
 
5664
     extern "C"
 
5665
#  endif
 
5666
   int F77_DUMMY_MAIN() { return 1; }
 
5667
#endif
 
5668
int
 
5669
main ()
 
5670
{
 
5671
__inet_ntoa ();
 
5672
  ;
 
5673
  return 0;
 
5674
}
 
5675
_ACEOF
 
5676
rm -f conftest.$ac_objext conftest$ac_exeext
 
5677
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
5678
  (eval $ac_link) 2>&5
 
5679
  ac_status=$?
 
5680
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5681
  (exit $ac_status); } &&
 
5682
         { ac_try='test -s conftest$ac_exeext'
 
5683
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
5684
  (eval $ac_try) 2>&5
 
5685
  ac_status=$?
 
5686
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5687
  (exit $ac_status); }; }; then
 
5688
  ac_cv_lib_bind___inet_ntoa=yes
 
5689
else
 
5690
  echo "$as_me: failed program was:" >&5
 
5691
cat conftest.$ac_ext >&5
 
5692
ac_cv_lib_bind___inet_ntoa=no
 
5693
fi
 
5694
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
5695
LIBS=$ac_check_lib_save_LIBS
 
5696
fi
 
5697
echo "$as_me:$LINENO: result: $ac_cv_lib_bind___inet_ntoa" >&5
 
5698
echo "${ECHO_T}$ac_cv_lib_bind___inet_ntoa" >&6
 
5699
if test $ac_cv_lib_bind___inet_ntoa = yes; then
 
5700
  cat >>confdefs.h <<_ACEOF
 
5701
#define HAVE_LIBBIND 1
 
5702
_ACEOF
 
5703
 
 
5704
  LIBS="-lbind $LIBS"
 
5705
 
 
5706
fi
 
5707
 
 
5708
fi
 
5709
# Solaris:
 
5710
echo "$as_me:$LINENO: checking for library containing fdatasync" >&5
 
5711
echo $ECHO_N "checking for library containing fdatasync... $ECHO_C" >&6
 
5712
if test "${ac_cv_search_fdatasync+set}" = set; then
 
5713
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5714
else
 
5715
  ac_func_search_save_LIBS=$LIBS
 
5716
ac_cv_search_fdatasync=no
 
5717
cat >conftest.$ac_ext <<_ACEOF
 
5718
#line $LINENO "configure"
 
5719
#include "confdefs.h"
 
5720
 
 
5721
/* Override any gcc2 internal prototype to avoid an error.  */
 
5722
#ifdef __cplusplus
 
5723
extern "C"
 
5724
#endif
 
5725
/* We use char because int might match the return type of a gcc2
 
5726
   builtin and then its argument prototype would still apply.  */
 
5727
char fdatasync ();
 
5728
#ifdef F77_DUMMY_MAIN
 
5729
#  ifdef __cplusplus
 
5730
     extern "C"
 
5731
#  endif
 
5732
   int F77_DUMMY_MAIN() { return 1; }
 
5733
#endif
 
5734
int
 
5735
main ()
 
5736
{
 
5737
fdatasync ();
 
5738
  ;
 
5739
  return 0;
 
5740
}
 
5741
_ACEOF
 
5742
rm -f conftest.$ac_objext conftest$ac_exeext
 
5743
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
5744
  (eval $ac_link) 2>&5
 
5745
  ac_status=$?
 
5746
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5747
  (exit $ac_status); } &&
 
5748
         { ac_try='test -s conftest$ac_exeext'
 
5749
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
5750
  (eval $ac_try) 2>&5
 
5751
  ac_status=$?
 
5752
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5753
  (exit $ac_status); }; }; then
 
5754
  ac_cv_search_fdatasync="none required"
 
5755
else
 
5756
  echo "$as_me: failed program was:" >&5
 
5757
cat conftest.$ac_ext >&5
 
5758
fi
 
5759
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
5760
if test "$ac_cv_search_fdatasync" = no; then
 
5761
  for ac_lib in rt posix4; do
 
5762
    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
 
5763
    cat >conftest.$ac_ext <<_ACEOF
 
5764
#line $LINENO "configure"
 
5765
#include "confdefs.h"
 
5766
 
 
5767
/* Override any gcc2 internal prototype to avoid an error.  */
 
5768
#ifdef __cplusplus
 
5769
extern "C"
 
5770
#endif
 
5771
/* We use char because int might match the return type of a gcc2
 
5772
   builtin and then its argument prototype would still apply.  */
 
5773
char fdatasync ();
 
5774
#ifdef F77_DUMMY_MAIN
 
5775
#  ifdef __cplusplus
 
5776
     extern "C"
 
5777
#  endif
 
5778
   int F77_DUMMY_MAIN() { return 1; }
 
5779
#endif
 
5780
int
 
5781
main ()
 
5782
{
 
5783
fdatasync ();
 
5784
  ;
 
5785
  return 0;
 
5786
}
 
5787
_ACEOF
 
5788
rm -f conftest.$ac_objext conftest$ac_exeext
 
5789
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
5790
  (eval $ac_link) 2>&5
 
5791
  ac_status=$?
 
5792
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5793
  (exit $ac_status); } &&
 
5794
         { ac_try='test -s conftest$ac_exeext'
 
5795
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
5796
  (eval $ac_try) 2>&5
 
5797
  ac_status=$?
 
5798
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5799
  (exit $ac_status); }; }; then
 
5800
  ac_cv_search_fdatasync="-l$ac_lib"
 
5801
break
 
5802
else
 
5803
  echo "$as_me: failed program was:" >&5
 
5804
cat conftest.$ac_ext >&5
 
5805
fi
 
5806
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
5807
  done
 
5808
fi
 
5809
LIBS=$ac_func_search_save_LIBS
 
5810
fi
 
5811
echo "$as_me:$LINENO: result: $ac_cv_search_fdatasync" >&5
 
5812
echo "${ECHO_T}$ac_cv_search_fdatasync" >&6
 
5813
if test "$ac_cv_search_fdatasync" != no; then
 
5814
  test "$ac_cv_search_fdatasync" = "none required" || LIBS="$ac_cv_search_fdatasync $LIBS"
 
5815
 
 
5816
fi
 
5817
 
 
5818
# Cygwin:
 
5819
 
 
5820
echo "$as_me:$LINENO: checking for shmget in -lcygipc" >&5
 
5821
echo $ECHO_N "checking for shmget in -lcygipc... $ECHO_C" >&6
 
5822
if test "${ac_cv_lib_cygipc_shmget+set}" = set; then
 
5823
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5824
else
 
5825
  ac_check_lib_save_LIBS=$LIBS
 
5826
LIBS="-lcygipc  $LIBS"
 
5827
cat >conftest.$ac_ext <<_ACEOF
 
5828
#line $LINENO "configure"
 
5829
#include "confdefs.h"
 
5830
 
 
5831
/* Override any gcc2 internal prototype to avoid an error.  */
 
5832
#ifdef __cplusplus
 
5833
extern "C"
 
5834
#endif
 
5835
/* We use char because int might match the return type of a gcc2
 
5836
   builtin and then its argument prototype would still apply.  */
 
5837
char shmget ();
 
5838
#ifdef F77_DUMMY_MAIN
 
5839
#  ifdef __cplusplus
 
5840
     extern "C"
 
5841
#  endif
 
5842
   int F77_DUMMY_MAIN() { return 1; }
 
5843
#endif
 
5844
int
 
5845
main ()
 
5846
{
 
5847
shmget ();
 
5848
  ;
 
5849
  return 0;
 
5850
}
 
5851
_ACEOF
 
5852
rm -f conftest.$ac_objext conftest$ac_exeext
 
5853
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
5854
  (eval $ac_link) 2>&5
 
5855
  ac_status=$?
 
5856
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5857
  (exit $ac_status); } &&
 
5858
         { ac_try='test -s conftest$ac_exeext'
 
5859
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
5860
  (eval $ac_try) 2>&5
 
5861
  ac_status=$?
 
5862
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5863
  (exit $ac_status); }; }; then
 
5864
  ac_cv_lib_cygipc_shmget=yes
 
5865
else
 
5866
  echo "$as_me: failed program was:" >&5
 
5867
cat conftest.$ac_ext >&5
 
5868
ac_cv_lib_cygipc_shmget=no
 
5869
fi
 
5870
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
5871
LIBS=$ac_check_lib_save_LIBS
 
5872
fi
 
5873
echo "$as_me:$LINENO: result: $ac_cv_lib_cygipc_shmget" >&5
 
5874
echo "${ECHO_T}$ac_cv_lib_cygipc_shmget" >&6
 
5875
if test $ac_cv_lib_cygipc_shmget = yes; then
 
5876
  cat >>confdefs.h <<_ACEOF
 
5877
#define HAVE_LIBCYGIPC 1
 
5878
_ACEOF
 
5879
 
 
5880
  LIBS="-lcygipc $LIBS"
 
5881
 
 
5882
fi
 
5883
 
 
5884
# WIN32:
 
5885
if test "$PORTNAME" = "win32"
 
5886
then
 
5887
 
 
5888
echo "$as_me:$LINENO: checking for main in -lwsock32" >&5
 
5889
echo $ECHO_N "checking for main in -lwsock32... $ECHO_C" >&6
 
5890
if test "${ac_cv_lib_wsock32_main+set}" = set; then
 
5891
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5892
else
 
5893
  ac_check_lib_save_LIBS=$LIBS
 
5894
LIBS="-lwsock32  $LIBS"
 
5895
cat >conftest.$ac_ext <<_ACEOF
 
5896
#line $LINENO "configure"
 
5897
#include "confdefs.h"
 
5898
 
 
5899
 
 
5900
#ifdef F77_DUMMY_MAIN
 
5901
#  ifdef __cplusplus
 
5902
     extern "C"
 
5903
#  endif
 
5904
   int F77_DUMMY_MAIN() { return 1; }
 
5905
#endif
 
5906
int
 
5907
main ()
 
5908
{
 
5909
main ();
 
5910
  ;
 
5911
  return 0;
 
5912
}
 
5913
_ACEOF
 
5914
rm -f conftest.$ac_objext conftest$ac_exeext
 
5915
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
5916
  (eval $ac_link) 2>&5
 
5917
  ac_status=$?
 
5918
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5919
  (exit $ac_status); } &&
 
5920
         { ac_try='test -s conftest$ac_exeext'
 
5921
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
5922
  (eval $ac_try) 2>&5
 
5923
  ac_status=$?
 
5924
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5925
  (exit $ac_status); }; }; then
 
5926
  ac_cv_lib_wsock32_main=yes
 
5927
else
 
5928
  echo "$as_me: failed program was:" >&5
 
5929
cat conftest.$ac_ext >&5
 
5930
ac_cv_lib_wsock32_main=no
 
5931
fi
 
5932
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
5933
LIBS=$ac_check_lib_save_LIBS
 
5934
fi
 
5935
echo "$as_me:$LINENO: result: $ac_cv_lib_wsock32_main" >&5
 
5936
echo "${ECHO_T}$ac_cv_lib_wsock32_main" >&6
 
5937
if test $ac_cv_lib_wsock32_main = yes; then
 
5938
  cat >>confdefs.h <<_ACEOF
 
5939
#define HAVE_LIBWSOCK32 1
 
5940
_ACEOF
 
5941
 
 
5942
  LIBS="-lwsock32 $LIBS"
 
5943
 
 
5944
fi
 
5945
 
 
5946
fi
 
5947
 
 
5948
if test "$with_readline" = yes; then
 
5949
 
 
5950
echo "$as_me:$LINENO: checking for readline" >&5
 
5951
echo $ECHO_N "checking for readline... $ECHO_C" >&6
 
5952
 
 
5953
if test "${pgac_cv_check_readline+set}" = set; then
 
5954
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5955
else
 
5956
  pgac_cv_check_readline=no
 
5957
pgac_save_LIBS=$LIBS
 
5958
for pgac_rllib in -lreadline -ledit ; do
 
5959
  for pgac_lib in "" " -ltermcap" " -lncurses" " -lcurses" ; do
 
5960
    LIBS="${pgac_rllib}${pgac_lib} $pgac_save_LIBS"
 
5961
    cat >conftest.$ac_ext <<_ACEOF
 
5962
#line $LINENO "configure"
 
5963
#include "confdefs.h"
 
5964
 
 
5965
/* Override any gcc2 internal prototype to avoid an error.  */
 
5966
#ifdef __cplusplus
 
5967
extern "C"
 
5968
#endif
 
5969
/* We use char because int might match the return type of a gcc2
 
5970
   builtin and then its argument prototype would still apply.  */
 
5971
char readline ();
 
5972
#ifdef F77_DUMMY_MAIN
 
5973
#  ifdef __cplusplus
 
5974
     extern "C"
 
5975
#  endif
 
5976
   int F77_DUMMY_MAIN() { return 1; }
 
5977
#endif
 
5978
int
 
5979
main ()
 
5980
{
 
5981
readline ();
 
5982
  ;
 
5983
  return 0;
 
5984
}
 
5985
_ACEOF
 
5986
rm -f conftest.$ac_objext conftest$ac_exeext
 
5987
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
5988
  (eval $ac_link) 2>&5
 
5989
  ac_status=$?
 
5990
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5991
  (exit $ac_status); } &&
 
5992
         { ac_try='test -s conftest$ac_exeext'
 
5993
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
5994
  (eval $ac_try) 2>&5
 
5995
  ac_status=$?
 
5996
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5997
  (exit $ac_status); }; }; then
 
5998
 
 
5999
      # Older NetBSD, OpenBSD, and Irix have a broken linker that does not
 
6000
      # recognize dependent libraries; assume curses is needed if we didn't
 
6001
      # find any dependency.
 
6002
      case $host_os in
 
6003
        netbsd* | openbsd* | irix*)
 
6004
          if test x"$pgac_lib" = x"" ; then
 
6005
            pgac_lib=" -lcurses"
 
6006
          fi ;;
 
6007
      esac
 
6008
 
 
6009
      pgac_cv_check_readline="${pgac_rllib}${pgac_lib}"
 
6010
      break 2
 
6011
 
 
6012
else
 
6013
  echo "$as_me: failed program was:" >&5
 
6014
cat conftest.$ac_ext >&5
 
6015
fi
 
6016
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
6017
  done
 
6018
done
 
6019
LIBS=$pgac_save_LIBS
 
6020
 
 
6021
fi
 
6022
 
 
6023
if test "$pgac_cv_check_readline" != no ; then
 
6024
 
 
6025
cat >>confdefs.h <<\_ACEOF
 
6026
#define HAVE_LIBREADLINE 1
 
6027
_ACEOF
 
6028
 
 
6029
  LIBS="$pgac_cv_check_readline $LIBS"
 
6030
  echo "$as_me:$LINENO: result: yes ($pgac_cv_check_readline)" >&5
 
6031
echo "${ECHO_T}yes ($pgac_cv_check_readline)" >&6
 
6032
else
 
6033
  echo "$as_me:$LINENO: result: no" >&5
 
6034
echo "${ECHO_T}no" >&6
 
6035
fi
 
6036
  if test x"$pgac_cv_check_readline" = x"no"; then
 
6037
    { { echo "$as_me:$LINENO: error: readline library not found
 
6038
If you have readline already installed, see config.log for details on the
 
6039
failure.  It is possible the compiler isn't looking in the proper directory.
 
6040
Use --without-readline to disable readline support." >&5
 
6041
echo "$as_me: error: readline library not found
 
6042
If you have readline already installed, see config.log for details on the
 
6043
failure.  It is possible the compiler isn't looking in the proper directory.
 
6044
Use --without-readline to disable readline support." >&2;}
 
6045
   { (exit 1); exit 1; }; }
 
6046
  fi
 
6047
fi
 
6048
 
 
6049
if test "$with_zlib" = yes; then
 
6050
 
 
6051
echo "$as_me:$LINENO: checking for inflate in -lz" >&5
 
6052
echo $ECHO_N "checking for inflate in -lz... $ECHO_C" >&6
 
6053
if test "${ac_cv_lib_z_inflate+set}" = set; then
 
6054
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
6055
else
 
6056
  ac_check_lib_save_LIBS=$LIBS
 
6057
LIBS="-lz  $LIBS"
 
6058
cat >conftest.$ac_ext <<_ACEOF
 
6059
#line $LINENO "configure"
 
6060
#include "confdefs.h"
 
6061
 
 
6062
/* Override any gcc2 internal prototype to avoid an error.  */
 
6063
#ifdef __cplusplus
 
6064
extern "C"
 
6065
#endif
 
6066
/* We use char because int might match the return type of a gcc2
 
6067
   builtin and then its argument prototype would still apply.  */
 
6068
char inflate ();
 
6069
#ifdef F77_DUMMY_MAIN
 
6070
#  ifdef __cplusplus
 
6071
     extern "C"
 
6072
#  endif
 
6073
   int F77_DUMMY_MAIN() { return 1; }
 
6074
#endif
 
6075
int
 
6076
main ()
 
6077
{
 
6078
inflate ();
 
6079
  ;
 
6080
  return 0;
 
6081
}
 
6082
_ACEOF
 
6083
rm -f conftest.$ac_objext conftest$ac_exeext
 
6084
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
6085
  (eval $ac_link) 2>&5
 
6086
  ac_status=$?
 
6087
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6088
  (exit $ac_status); } &&
 
6089
         { ac_try='test -s conftest$ac_exeext'
 
6090
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6091
  (eval $ac_try) 2>&5
 
6092
  ac_status=$?
 
6093
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6094
  (exit $ac_status); }; }; then
 
6095
  ac_cv_lib_z_inflate=yes
 
6096
else
 
6097
  echo "$as_me: failed program was:" >&5
 
6098
cat conftest.$ac_ext >&5
 
6099
ac_cv_lib_z_inflate=no
 
6100
fi
 
6101
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
6102
LIBS=$ac_check_lib_save_LIBS
 
6103
fi
 
6104
echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflate" >&5
 
6105
echo "${ECHO_T}$ac_cv_lib_z_inflate" >&6
 
6106
if test $ac_cv_lib_z_inflate = yes; then
 
6107
  cat >>confdefs.h <<_ACEOF
 
6108
#define HAVE_LIBZ 1
 
6109
_ACEOF
 
6110
 
 
6111
  LIBS="-lz $LIBS"
 
6112
 
 
6113
else
 
6114
  { { echo "$as_me:$LINENO: error: zlib library not found
 
6115
If you have zlib already installed, see config.log for details on the
 
6116
failure.  It is possible the compiler isn't looking in the proper directory.
 
6117
Use --without-zlib to disable zlib support." >&5
 
6118
echo "$as_me: error: zlib library not found
 
6119
If you have zlib already installed, see config.log for details on the
 
6120
failure.  It is possible the compiler isn't looking in the proper directory.
 
6121
Use --without-zlib to disable zlib support." >&2;}
 
6122
   { (exit 1); exit 1; }; }
 
6123
fi
 
6124
 
 
6125
fi
 
6126
 
 
6127
if test "$enable_spinlocks" = yes; then
 
6128
 
 
6129
cat >>confdefs.h <<\_ACEOF
 
6130
#define HAVE_SPINLOCKS 1
 
6131
_ACEOF
 
6132
 
 
6133
else
 
6134
  { echo "$as_me:$LINENO: WARNING:
 
6135
*** Not using spinlocks will cause poor performance." >&5
 
6136
echo "$as_me: WARNING:
 
6137
*** Not using spinlocks will cause poor performance." >&2;}
 
6138
fi
 
6139
 
 
6140
if test "$with_krb4" = yes ; then
 
6141
 
 
6142
echo "$as_me:$LINENO: checking for des_encrypt in -ldes" >&5
 
6143
echo $ECHO_N "checking for des_encrypt in -ldes... $ECHO_C" >&6
 
6144
if test "${ac_cv_lib_des_des_encrypt+set}" = set; then
 
6145
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
6146
else
 
6147
  ac_check_lib_save_LIBS=$LIBS
 
6148
LIBS="-ldes  $LIBS"
 
6149
cat >conftest.$ac_ext <<_ACEOF
 
6150
#line $LINENO "configure"
 
6151
#include "confdefs.h"
 
6152
 
 
6153
/* Override any gcc2 internal prototype to avoid an error.  */
 
6154
#ifdef __cplusplus
 
6155
extern "C"
 
6156
#endif
 
6157
/* We use char because int might match the return type of a gcc2
 
6158
   builtin and then its argument prototype would still apply.  */
 
6159
char des_encrypt ();
 
6160
#ifdef F77_DUMMY_MAIN
 
6161
#  ifdef __cplusplus
 
6162
     extern "C"
 
6163
#  endif
 
6164
   int F77_DUMMY_MAIN() { return 1; }
 
6165
#endif
 
6166
int
 
6167
main ()
 
6168
{
 
6169
des_encrypt ();
 
6170
  ;
 
6171
  return 0;
 
6172
}
 
6173
_ACEOF
 
6174
rm -f conftest.$ac_objext conftest$ac_exeext
 
6175
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
6176
  (eval $ac_link) 2>&5
 
6177
  ac_status=$?
 
6178
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6179
  (exit $ac_status); } &&
 
6180
         { ac_try='test -s conftest$ac_exeext'
 
6181
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6182
  (eval $ac_try) 2>&5
 
6183
  ac_status=$?
 
6184
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6185
  (exit $ac_status); }; }; then
 
6186
  ac_cv_lib_des_des_encrypt=yes
 
6187
else
 
6188
  echo "$as_me: failed program was:" >&5
 
6189
cat conftest.$ac_ext >&5
 
6190
ac_cv_lib_des_des_encrypt=no
 
6191
fi
 
6192
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
6193
LIBS=$ac_check_lib_save_LIBS
 
6194
fi
 
6195
echo "$as_me:$LINENO: result: $ac_cv_lib_des_des_encrypt" >&5
 
6196
echo "${ECHO_T}$ac_cv_lib_des_des_encrypt" >&6
 
6197
if test $ac_cv_lib_des_des_encrypt = yes; then
 
6198
  cat >>confdefs.h <<_ACEOF
 
6199
#define HAVE_LIBDES 1
 
6200
_ACEOF
 
6201
 
 
6202
  LIBS="-ldes $LIBS"
 
6203
 
 
6204
else
 
6205
  { { echo "$as_me:$LINENO: error: library 'des' is required for Kerberos 4" >&5
 
6206
echo "$as_me: error: library 'des' is required for Kerberos 4" >&2;}
 
6207
   { (exit 1); exit 1; }; }
 
6208
fi
 
6209
 
 
6210
 
 
6211
echo "$as_me:$LINENO: checking for krb_sendauth in -lkrb" >&5
 
6212
echo $ECHO_N "checking for krb_sendauth in -lkrb... $ECHO_C" >&6
 
6213
if test "${ac_cv_lib_krb_krb_sendauth+set}" = set; then
 
6214
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
6215
else
 
6216
  ac_check_lib_save_LIBS=$LIBS
 
6217
LIBS="-lkrb  $LIBS"
 
6218
cat >conftest.$ac_ext <<_ACEOF
 
6219
#line $LINENO "configure"
 
6220
#include "confdefs.h"
 
6221
 
 
6222
/* Override any gcc2 internal prototype to avoid an error.  */
 
6223
#ifdef __cplusplus
 
6224
extern "C"
 
6225
#endif
 
6226
/* We use char because int might match the return type of a gcc2
 
6227
   builtin and then its argument prototype would still apply.  */
 
6228
char krb_sendauth ();
 
6229
#ifdef F77_DUMMY_MAIN
 
6230
#  ifdef __cplusplus
 
6231
     extern "C"
 
6232
#  endif
 
6233
   int F77_DUMMY_MAIN() { return 1; }
 
6234
#endif
 
6235
int
 
6236
main ()
 
6237
{
 
6238
krb_sendauth ();
 
6239
  ;
 
6240
  return 0;
 
6241
}
 
6242
_ACEOF
 
6243
rm -f conftest.$ac_objext conftest$ac_exeext
 
6244
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
6245
  (eval $ac_link) 2>&5
 
6246
  ac_status=$?
 
6247
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6248
  (exit $ac_status); } &&
 
6249
         { ac_try='test -s conftest$ac_exeext'
 
6250
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6251
  (eval $ac_try) 2>&5
 
6252
  ac_status=$?
 
6253
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6254
  (exit $ac_status); }; }; then
 
6255
  ac_cv_lib_krb_krb_sendauth=yes
 
6256
else
 
6257
  echo "$as_me: failed program was:" >&5
 
6258
cat conftest.$ac_ext >&5
 
6259
ac_cv_lib_krb_krb_sendauth=no
 
6260
fi
 
6261
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
6262
LIBS=$ac_check_lib_save_LIBS
 
6263
fi
 
6264
echo "$as_me:$LINENO: result: $ac_cv_lib_krb_krb_sendauth" >&5
 
6265
echo "${ECHO_T}$ac_cv_lib_krb_krb_sendauth" >&6
 
6266
if test $ac_cv_lib_krb_krb_sendauth = yes; then
 
6267
  cat >>confdefs.h <<_ACEOF
 
6268
#define HAVE_LIBKRB 1
 
6269
_ACEOF
 
6270
 
 
6271
  LIBS="-lkrb $LIBS"
 
6272
 
 
6273
else
 
6274
  { { echo "$as_me:$LINENO: error: library 'krb' is required for Kerberos 4" >&5
 
6275
echo "$as_me: error: library 'krb' is required for Kerberos 4" >&2;}
 
6276
   { (exit 1); exit 1; }; }
 
6277
fi
 
6278
 
 
6279
 
 
6280
for ac_func in gethostname
 
6281
do
 
6282
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
 
6283
echo "$as_me:$LINENO: checking for $ac_func" >&5
 
6284
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
 
6285
if eval "test \"\${$as_ac_var+set}\" = set"; then
 
6286
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
6287
else
 
6288
  cat >conftest.$ac_ext <<_ACEOF
 
6289
#line $LINENO "configure"
 
6290
#include "confdefs.h"
 
6291
/* System header to define __stub macros and hopefully few prototypes,
 
6292
    which can conflict with char $ac_func (); below.  */
 
6293
#include <assert.h>
 
6294
/* Override any gcc2 internal prototype to avoid an error.  */
 
6295
#ifdef __cplusplus
 
6296
extern "C"
 
6297
#endif
 
6298
/* We use char because int might match the return type of a gcc2
 
6299
   builtin and then its argument prototype would still apply.  */
 
6300
char $ac_func ();
 
6301
char (*f) ();
 
6302
 
 
6303
#ifdef F77_DUMMY_MAIN
 
6304
#  ifdef __cplusplus
 
6305
     extern "C"
 
6306
#  endif
 
6307
   int F77_DUMMY_MAIN() { return 1; }
 
6308
#endif
 
6309
int
 
6310
main ()
 
6311
{
 
6312
/* The GNU C library defines this for functions which it implements
 
6313
    to always fail with ENOSYS.  Some functions are actually named
 
6314
    something starting with __ and the normal name is an alias.  */
 
6315
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
 
6316
choke me
 
6317
#else
 
6318
f = $ac_func;
 
6319
#endif
 
6320
 
 
6321
  ;
 
6322
  return 0;
 
6323
}
 
6324
_ACEOF
 
6325
rm -f conftest.$ac_objext conftest$ac_exeext
 
6326
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
6327
  (eval $ac_link) 2>&5
 
6328
  ac_status=$?
 
6329
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6330
  (exit $ac_status); } &&
 
6331
         { ac_try='test -s conftest$ac_exeext'
 
6332
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6333
  (eval $ac_try) 2>&5
 
6334
  ac_status=$?
 
6335
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6336
  (exit $ac_status); }; }; then
 
6337
  eval "$as_ac_var=yes"
 
6338
else
 
6339
  echo "$as_me: failed program was:" >&5
 
6340
cat conftest.$ac_ext >&5
 
6341
eval "$as_ac_var=no"
 
6342
fi
 
6343
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
6344
fi
 
6345
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
 
6346
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
 
6347
if test `eval echo '${'$as_ac_var'}'` = yes; then
 
6348
  cat >>confdefs.h <<_ACEOF
 
6349
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
 
6350
_ACEOF
 
6351
 
 
6352
else
 
6353
  LIBOBJS="$LIBOBJS $ac_func.$ac_objext"
 
6354
fi
 
6355
done
 
6356
 
 
6357
 
 
6358
fi
 
6359
 
 
6360
if test "$with_krb5" = yes ; then
 
6361
  if test "$PORTNAME" != "win32"; then
 
6362
     echo "$as_me:$LINENO: checking for library containing com_err" >&5
 
6363
echo $ECHO_N "checking for library containing com_err... $ECHO_C" >&6
 
6364
if test "${ac_cv_search_com_err+set}" = set; then
 
6365
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
6366
else
 
6367
  ac_func_search_save_LIBS=$LIBS
 
6368
ac_cv_search_com_err=no
 
6369
cat >conftest.$ac_ext <<_ACEOF
 
6370
#line $LINENO "configure"
 
6371
#include "confdefs.h"
 
6372
 
 
6373
/* Override any gcc2 internal prototype to avoid an error.  */
 
6374
#ifdef __cplusplus
 
6375
extern "C"
 
6376
#endif
 
6377
/* We use char because int might match the return type of a gcc2
 
6378
   builtin and then its argument prototype would still apply.  */
 
6379
char com_err ();
 
6380
#ifdef F77_DUMMY_MAIN
 
6381
#  ifdef __cplusplus
 
6382
     extern "C"
 
6383
#  endif
 
6384
   int F77_DUMMY_MAIN() { return 1; }
 
6385
#endif
 
6386
int
 
6387
main ()
 
6388
{
 
6389
com_err ();
 
6390
  ;
 
6391
  return 0;
 
6392
}
 
6393
_ACEOF
 
6394
rm -f conftest.$ac_objext conftest$ac_exeext
 
6395
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
6396
  (eval $ac_link) 2>&5
 
6397
  ac_status=$?
 
6398
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6399
  (exit $ac_status); } &&
 
6400
         { ac_try='test -s conftest$ac_exeext'
 
6401
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6402
  (eval $ac_try) 2>&5
 
6403
  ac_status=$?
 
6404
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6405
  (exit $ac_status); }; }; then
 
6406
  ac_cv_search_com_err="none required"
 
6407
else
 
6408
  echo "$as_me: failed program was:" >&5
 
6409
cat conftest.$ac_ext >&5
 
6410
fi
 
6411
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
6412
if test "$ac_cv_search_com_err" = no; then
 
6413
  for ac_lib in krb5 'krb5 -ldes -lasn1 -lroken' com_err; do
 
6414
    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
 
6415
    cat >conftest.$ac_ext <<_ACEOF
 
6416
#line $LINENO "configure"
 
6417
#include "confdefs.h"
 
6418
 
 
6419
/* Override any gcc2 internal prototype to avoid an error.  */
 
6420
#ifdef __cplusplus
 
6421
extern "C"
 
6422
#endif
 
6423
/* We use char because int might match the return type of a gcc2
 
6424
   builtin and then its argument prototype would still apply.  */
 
6425
char com_err ();
 
6426
#ifdef F77_DUMMY_MAIN
 
6427
#  ifdef __cplusplus
 
6428
     extern "C"
 
6429
#  endif
 
6430
   int F77_DUMMY_MAIN() { return 1; }
 
6431
#endif
 
6432
int
 
6433
main ()
 
6434
{
 
6435
com_err ();
 
6436
  ;
 
6437
  return 0;
 
6438
}
 
6439
_ACEOF
 
6440
rm -f conftest.$ac_objext conftest$ac_exeext
 
6441
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
6442
  (eval $ac_link) 2>&5
 
6443
  ac_status=$?
 
6444
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6445
  (exit $ac_status); } &&
 
6446
         { ac_try='test -s conftest$ac_exeext'
 
6447
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6448
  (eval $ac_try) 2>&5
 
6449
  ac_status=$?
 
6450
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6451
  (exit $ac_status); }; }; then
 
6452
  ac_cv_search_com_err="-l$ac_lib"
 
6453
break
 
6454
else
 
6455
  echo "$as_me: failed program was:" >&5
 
6456
cat conftest.$ac_ext >&5
 
6457
fi
 
6458
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
6459
  done
 
6460
fi
 
6461
LIBS=$ac_func_search_save_LIBS
 
6462
fi
 
6463
echo "$as_me:$LINENO: result: $ac_cv_search_com_err" >&5
 
6464
echo "${ECHO_T}$ac_cv_search_com_err" >&6
 
6465
if test "$ac_cv_search_com_err" != no; then
 
6466
  test "$ac_cv_search_com_err" = "none required" || LIBS="$ac_cv_search_com_err $LIBS"
 
6467
 
 
6468
else
 
6469
  { { echo "$as_me:$LINENO: error: could not find function 'com_err' required for Kerberos 5" >&5
 
6470
echo "$as_me: error: could not find function 'com_err' required for Kerberos 5" >&2;}
 
6471
   { (exit 1); exit 1; }; }
 
6472
fi
 
6473
 
 
6474
     echo "$as_me:$LINENO: checking for library containing krb5_encrypt" >&5
 
6475
echo $ECHO_N "checking for library containing krb5_encrypt... $ECHO_C" >&6
 
6476
if test "${ac_cv_search_krb5_encrypt+set}" = set; then
 
6477
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
6478
else
 
6479
  ac_func_search_save_LIBS=$LIBS
 
6480
ac_cv_search_krb5_encrypt=no
 
6481
cat >conftest.$ac_ext <<_ACEOF
 
6482
#line $LINENO "configure"
 
6483
#include "confdefs.h"
 
6484
 
 
6485
/* Override any gcc2 internal prototype to avoid an error.  */
 
6486
#ifdef __cplusplus
 
6487
extern "C"
 
6488
#endif
 
6489
/* We use char because int might match the return type of a gcc2
 
6490
   builtin and then its argument prototype would still apply.  */
 
6491
char krb5_encrypt ();
 
6492
#ifdef F77_DUMMY_MAIN
 
6493
#  ifdef __cplusplus
 
6494
     extern "C"
 
6495
#  endif
 
6496
   int F77_DUMMY_MAIN() { return 1; }
 
6497
#endif
 
6498
int
 
6499
main ()
 
6500
{
 
6501
krb5_encrypt ();
 
6502
  ;
 
6503
  return 0;
 
6504
}
 
6505
_ACEOF
 
6506
rm -f conftest.$ac_objext conftest$ac_exeext
 
6507
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
6508
  (eval $ac_link) 2>&5
 
6509
  ac_status=$?
 
6510
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6511
  (exit $ac_status); } &&
 
6512
         { ac_try='test -s conftest$ac_exeext'
 
6513
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6514
  (eval $ac_try) 2>&5
 
6515
  ac_status=$?
 
6516
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6517
  (exit $ac_status); }; }; then
 
6518
  ac_cv_search_krb5_encrypt="none required"
 
6519
else
 
6520
  echo "$as_me: failed program was:" >&5
 
6521
cat conftest.$ac_ext >&5
 
6522
fi
 
6523
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
6524
if test "$ac_cv_search_krb5_encrypt" = no; then
 
6525
  for ac_lib in krb5 'krb5 -ldes -lasn1 -lroken' crypto k5crypto; do
 
6526
    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
 
6527
    cat >conftest.$ac_ext <<_ACEOF
 
6528
#line $LINENO "configure"
 
6529
#include "confdefs.h"
 
6530
 
 
6531
/* Override any gcc2 internal prototype to avoid an error.  */
 
6532
#ifdef __cplusplus
 
6533
extern "C"
 
6534
#endif
 
6535
/* We use char because int might match the return type of a gcc2
 
6536
   builtin and then its argument prototype would still apply.  */
 
6537
char krb5_encrypt ();
 
6538
#ifdef F77_DUMMY_MAIN
 
6539
#  ifdef __cplusplus
 
6540
     extern "C"
 
6541
#  endif
 
6542
   int F77_DUMMY_MAIN() { return 1; }
 
6543
#endif
 
6544
int
 
6545
main ()
 
6546
{
 
6547
krb5_encrypt ();
 
6548
  ;
 
6549
  return 0;
 
6550
}
 
6551
_ACEOF
 
6552
rm -f conftest.$ac_objext conftest$ac_exeext
 
6553
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
6554
  (eval $ac_link) 2>&5
 
6555
  ac_status=$?
 
6556
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6557
  (exit $ac_status); } &&
 
6558
         { ac_try='test -s conftest$ac_exeext'
 
6559
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6560
  (eval $ac_try) 2>&5
 
6561
  ac_status=$?
 
6562
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6563
  (exit $ac_status); }; }; then
 
6564
  ac_cv_search_krb5_encrypt="-l$ac_lib"
 
6565
break
 
6566
else
 
6567
  echo "$as_me: failed program was:" >&5
 
6568
cat conftest.$ac_ext >&5
 
6569
fi
 
6570
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
6571
  done
 
6572
fi
 
6573
LIBS=$ac_func_search_save_LIBS
 
6574
fi
 
6575
echo "$as_me:$LINENO: result: $ac_cv_search_krb5_encrypt" >&5
 
6576
echo "${ECHO_T}$ac_cv_search_krb5_encrypt" >&6
 
6577
if test "$ac_cv_search_krb5_encrypt" != no; then
 
6578
  test "$ac_cv_search_krb5_encrypt" = "none required" || LIBS="$ac_cv_search_krb5_encrypt $LIBS"
 
6579
 
 
6580
else
 
6581
  { { echo "$as_me:$LINENO: error: could not find function 'krb5_encrypt' required for Kerberos 5" >&5
 
6582
echo "$as_me: error: could not find function 'krb5_encrypt' required for Kerberos 5" >&2;}
 
6583
   { (exit 1); exit 1; }; }
 
6584
fi
 
6585
 
 
6586
     echo "$as_me:$LINENO: checking for library containing krb5_sendauth" >&5
 
6587
echo $ECHO_N "checking for library containing krb5_sendauth... $ECHO_C" >&6
 
6588
if test "${ac_cv_search_krb5_sendauth+set}" = set; then
 
6589
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
6590
else
 
6591
  ac_func_search_save_LIBS=$LIBS
 
6592
ac_cv_search_krb5_sendauth=no
 
6593
cat >conftest.$ac_ext <<_ACEOF
 
6594
#line $LINENO "configure"
 
6595
#include "confdefs.h"
 
6596
 
 
6597
/* Override any gcc2 internal prototype to avoid an error.  */
 
6598
#ifdef __cplusplus
 
6599
extern "C"
 
6600
#endif
 
6601
/* We use char because int might match the return type of a gcc2
 
6602
   builtin and then its argument prototype would still apply.  */
 
6603
char krb5_sendauth ();
 
6604
#ifdef F77_DUMMY_MAIN
 
6605
#  ifdef __cplusplus
 
6606
     extern "C"
 
6607
#  endif
 
6608
   int F77_DUMMY_MAIN() { return 1; }
 
6609
#endif
 
6610
int
 
6611
main ()
 
6612
{
 
6613
krb5_sendauth ();
 
6614
  ;
 
6615
  return 0;
 
6616
}
 
6617
_ACEOF
 
6618
rm -f conftest.$ac_objext conftest$ac_exeext
 
6619
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
6620
  (eval $ac_link) 2>&5
 
6621
  ac_status=$?
 
6622
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6623
  (exit $ac_status); } &&
 
6624
         { ac_try='test -s conftest$ac_exeext'
 
6625
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6626
  (eval $ac_try) 2>&5
 
6627
  ac_status=$?
 
6628
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6629
  (exit $ac_status); }; }; then
 
6630
  ac_cv_search_krb5_sendauth="none required"
 
6631
else
 
6632
  echo "$as_me: failed program was:" >&5
 
6633
cat conftest.$ac_ext >&5
 
6634
fi
 
6635
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
6636
if test "$ac_cv_search_krb5_sendauth" = no; then
 
6637
  for ac_lib in krb5 'krb5 -ldes -lasn1 -lroken'; do
 
6638
    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
 
6639
    cat >conftest.$ac_ext <<_ACEOF
 
6640
#line $LINENO "configure"
 
6641
#include "confdefs.h"
 
6642
 
 
6643
/* Override any gcc2 internal prototype to avoid an error.  */
 
6644
#ifdef __cplusplus
 
6645
extern "C"
 
6646
#endif
 
6647
/* We use char because int might match the return type of a gcc2
 
6648
   builtin and then its argument prototype would still apply.  */
 
6649
char krb5_sendauth ();
 
6650
#ifdef F77_DUMMY_MAIN
 
6651
#  ifdef __cplusplus
 
6652
     extern "C"
 
6653
#  endif
 
6654
   int F77_DUMMY_MAIN() { return 1; }
 
6655
#endif
 
6656
int
 
6657
main ()
 
6658
{
 
6659
krb5_sendauth ();
 
6660
  ;
 
6661
  return 0;
 
6662
}
 
6663
_ACEOF
 
6664
rm -f conftest.$ac_objext conftest$ac_exeext
 
6665
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
6666
  (eval $ac_link) 2>&5
 
6667
  ac_status=$?
 
6668
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6669
  (exit $ac_status); } &&
 
6670
         { ac_try='test -s conftest$ac_exeext'
 
6671
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6672
  (eval $ac_try) 2>&5
 
6673
  ac_status=$?
 
6674
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6675
  (exit $ac_status); }; }; then
 
6676
  ac_cv_search_krb5_sendauth="-l$ac_lib"
 
6677
break
 
6678
else
 
6679
  echo "$as_me: failed program was:" >&5
 
6680
cat conftest.$ac_ext >&5
 
6681
fi
 
6682
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
6683
  done
 
6684
fi
 
6685
LIBS=$ac_func_search_save_LIBS
 
6686
fi
 
6687
echo "$as_me:$LINENO: result: $ac_cv_search_krb5_sendauth" >&5
 
6688
echo "${ECHO_T}$ac_cv_search_krb5_sendauth" >&6
 
6689
if test "$ac_cv_search_krb5_sendauth" != no; then
 
6690
  test "$ac_cv_search_krb5_sendauth" = "none required" || LIBS="$ac_cv_search_krb5_sendauth $LIBS"
 
6691
 
 
6692
else
 
6693
  { { echo "$as_me:$LINENO: error: could not find function 'krb5_sendauth' required for Kerberos 5" >&5
 
6694
echo "$as_me: error: could not find function 'krb5_sendauth' required for Kerberos 5" >&2;}
 
6695
   { (exit 1); exit 1; }; }
 
6696
fi
 
6697
 
 
6698
  else
 
6699
     echo "$as_me:$LINENO: checking for library containing com_err" >&5
 
6700
echo $ECHO_N "checking for library containing com_err... $ECHO_C" >&6
 
6701
if test "${ac_cv_search_com_err+set}" = set; then
 
6702
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
6703
else
 
6704
  ac_func_search_save_LIBS=$LIBS
 
6705
ac_cv_search_com_err=no
 
6706
cat >conftest.$ac_ext <<_ACEOF
 
6707
#line $LINENO "configure"
 
6708
#include "confdefs.h"
 
6709
 
 
6710
/* Override any gcc2 internal prototype to avoid an error.  */
 
6711
#ifdef __cplusplus
 
6712
extern "C"
 
6713
#endif
 
6714
/* We use char because int might match the return type of a gcc2
 
6715
   builtin and then its argument prototype would still apply.  */
 
6716
char com_err ();
 
6717
#ifdef F77_DUMMY_MAIN
 
6718
#  ifdef __cplusplus
 
6719
     extern "C"
 
6720
#  endif
 
6721
   int F77_DUMMY_MAIN() { return 1; }
 
6722
#endif
 
6723
int
 
6724
main ()
 
6725
{
 
6726
com_err ();
 
6727
  ;
 
6728
  return 0;
 
6729
}
 
6730
_ACEOF
 
6731
rm -f conftest.$ac_objext conftest$ac_exeext
 
6732
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
6733
  (eval $ac_link) 2>&5
 
6734
  ac_status=$?
 
6735
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6736
  (exit $ac_status); } &&
 
6737
         { ac_try='test -s conftest$ac_exeext'
 
6738
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6739
  (eval $ac_try) 2>&5
 
6740
  ac_status=$?
 
6741
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6742
  (exit $ac_status); }; }; then
 
6743
  ac_cv_search_com_err="none required"
 
6744
else
 
6745
  echo "$as_me: failed program was:" >&5
 
6746
cat conftest.$ac_ext >&5
 
6747
fi
 
6748
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
6749
if test "$ac_cv_search_com_err" = no; then
 
6750
  for ac_lib in 'comerr32 -lkrb5_32'; do
 
6751
    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
 
6752
    cat >conftest.$ac_ext <<_ACEOF
 
6753
#line $LINENO "configure"
 
6754
#include "confdefs.h"
 
6755
 
 
6756
/* Override any gcc2 internal prototype to avoid an error.  */
 
6757
#ifdef __cplusplus
 
6758
extern "C"
 
6759
#endif
 
6760
/* We use char because int might match the return type of a gcc2
 
6761
   builtin and then its argument prototype would still apply.  */
 
6762
char com_err ();
 
6763
#ifdef F77_DUMMY_MAIN
 
6764
#  ifdef __cplusplus
 
6765
     extern "C"
 
6766
#  endif
 
6767
   int F77_DUMMY_MAIN() { return 1; }
 
6768
#endif
 
6769
int
 
6770
main ()
 
6771
{
 
6772
com_err ();
 
6773
  ;
 
6774
  return 0;
 
6775
}
 
6776
_ACEOF
 
6777
rm -f conftest.$ac_objext conftest$ac_exeext
 
6778
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
6779
  (eval $ac_link) 2>&5
 
6780
  ac_status=$?
 
6781
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6782
  (exit $ac_status); } &&
 
6783
         { ac_try='test -s conftest$ac_exeext'
 
6784
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6785
  (eval $ac_try) 2>&5
 
6786
  ac_status=$?
 
6787
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6788
  (exit $ac_status); }; }; then
 
6789
  ac_cv_search_com_err="-l$ac_lib"
 
6790
break
 
6791
else
 
6792
  echo "$as_me: failed program was:" >&5
 
6793
cat conftest.$ac_ext >&5
 
6794
fi
 
6795
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
6796
  done
 
6797
fi
 
6798
LIBS=$ac_func_search_save_LIBS
 
6799
fi
 
6800
echo "$as_me:$LINENO: result: $ac_cv_search_com_err" >&5
 
6801
echo "${ECHO_T}$ac_cv_search_com_err" >&6
 
6802
if test "$ac_cv_search_com_err" != no; then
 
6803
  test "$ac_cv_search_com_err" = "none required" || LIBS="$ac_cv_search_com_err $LIBS"
 
6804
 
 
6805
else
 
6806
  { { echo "$as_me:$LINENO: error: could not find function 'com_err' required for Kerberos 5" >&5
 
6807
echo "$as_me: error: could not find function 'com_err' required for Kerberos 5" >&2;}
 
6808
   { (exit 1); exit 1; }; }
 
6809
fi
 
6810
 
 
6811
  fi
 
6812
fi
 
6813
 
 
6814
if test "$with_openssl" = yes ; then
 
6815
    if test "$PORTNAME" != "win32"; then
 
6816
 
 
6817
echo "$as_me:$LINENO: checking for CRYPTO_new_ex_data in -lcrypto" >&5
 
6818
echo $ECHO_N "checking for CRYPTO_new_ex_data in -lcrypto... $ECHO_C" >&6
 
6819
if test "${ac_cv_lib_crypto_CRYPTO_new_ex_data+set}" = set; then
 
6820
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
6821
else
 
6822
  ac_check_lib_save_LIBS=$LIBS
 
6823
LIBS="-lcrypto  $LIBS"
 
6824
cat >conftest.$ac_ext <<_ACEOF
 
6825
#line $LINENO "configure"
 
6826
#include "confdefs.h"
 
6827
 
 
6828
/* Override any gcc2 internal prototype to avoid an error.  */
 
6829
#ifdef __cplusplus
 
6830
extern "C"
 
6831
#endif
 
6832
/* We use char because int might match the return type of a gcc2
 
6833
   builtin and then its argument prototype would still apply.  */
 
6834
char CRYPTO_new_ex_data ();
 
6835
#ifdef F77_DUMMY_MAIN
 
6836
#  ifdef __cplusplus
 
6837
     extern "C"
 
6838
#  endif
 
6839
   int F77_DUMMY_MAIN() { return 1; }
 
6840
#endif
 
6841
int
 
6842
main ()
 
6843
{
 
6844
CRYPTO_new_ex_data ();
 
6845
  ;
 
6846
  return 0;
 
6847
}
 
6848
_ACEOF
 
6849
rm -f conftest.$ac_objext conftest$ac_exeext
 
6850
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
6851
  (eval $ac_link) 2>&5
 
6852
  ac_status=$?
 
6853
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6854
  (exit $ac_status); } &&
 
6855
         { ac_try='test -s conftest$ac_exeext'
 
6856
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6857
  (eval $ac_try) 2>&5
 
6858
  ac_status=$?
 
6859
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6860
  (exit $ac_status); }; }; then
 
6861
  ac_cv_lib_crypto_CRYPTO_new_ex_data=yes
 
6862
else
 
6863
  echo "$as_me: failed program was:" >&5
 
6864
cat conftest.$ac_ext >&5
 
6865
ac_cv_lib_crypto_CRYPTO_new_ex_data=no
 
6866
fi
 
6867
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
6868
LIBS=$ac_check_lib_save_LIBS
 
6869
fi
 
6870
echo "$as_me:$LINENO: result: $ac_cv_lib_crypto_CRYPTO_new_ex_data" >&5
 
6871
echo "${ECHO_T}$ac_cv_lib_crypto_CRYPTO_new_ex_data" >&6
 
6872
if test $ac_cv_lib_crypto_CRYPTO_new_ex_data = yes; then
 
6873
  cat >>confdefs.h <<_ACEOF
 
6874
#define HAVE_LIBCRYPTO 1
 
6875
_ACEOF
 
6876
 
 
6877
  LIBS="-lcrypto $LIBS"
 
6878
 
 
6879
else
 
6880
  { { echo "$as_me:$LINENO: error: library 'crypto' is required for OpenSSL" >&5
 
6881
echo "$as_me: error: library 'crypto' is required for OpenSSL" >&2;}
 
6882
   { (exit 1); exit 1; }; }
 
6883
fi
 
6884
 
 
6885
 
 
6886
echo "$as_me:$LINENO: checking for SSL_library_init in -lssl" >&5
 
6887
echo $ECHO_N "checking for SSL_library_init in -lssl... $ECHO_C" >&6
 
6888
if test "${ac_cv_lib_ssl_SSL_library_init+set}" = set; then
 
6889
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
6890
else
 
6891
  ac_check_lib_save_LIBS=$LIBS
 
6892
LIBS="-lssl  $LIBS"
 
6893
cat >conftest.$ac_ext <<_ACEOF
 
6894
#line $LINENO "configure"
 
6895
#include "confdefs.h"
 
6896
 
 
6897
/* Override any gcc2 internal prototype to avoid an error.  */
 
6898
#ifdef __cplusplus
 
6899
extern "C"
 
6900
#endif
 
6901
/* We use char because int might match the return type of a gcc2
 
6902
   builtin and then its argument prototype would still apply.  */
 
6903
char SSL_library_init ();
 
6904
#ifdef F77_DUMMY_MAIN
 
6905
#  ifdef __cplusplus
 
6906
     extern "C"
 
6907
#  endif
 
6908
   int F77_DUMMY_MAIN() { return 1; }
 
6909
#endif
 
6910
int
 
6911
main ()
 
6912
{
 
6913
SSL_library_init ();
 
6914
  ;
 
6915
  return 0;
 
6916
}
 
6917
_ACEOF
 
6918
rm -f conftest.$ac_objext conftest$ac_exeext
 
6919
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
6920
  (eval $ac_link) 2>&5
 
6921
  ac_status=$?
 
6922
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6923
  (exit $ac_status); } &&
 
6924
         { ac_try='test -s conftest$ac_exeext'
 
6925
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6926
  (eval $ac_try) 2>&5
 
6927
  ac_status=$?
 
6928
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6929
  (exit $ac_status); }; }; then
 
6930
  ac_cv_lib_ssl_SSL_library_init=yes
 
6931
else
 
6932
  echo "$as_me: failed program was:" >&5
 
6933
cat conftest.$ac_ext >&5
 
6934
ac_cv_lib_ssl_SSL_library_init=no
 
6935
fi
 
6936
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
6937
LIBS=$ac_check_lib_save_LIBS
 
6938
fi
 
6939
echo "$as_me:$LINENO: result: $ac_cv_lib_ssl_SSL_library_init" >&5
 
6940
echo "${ECHO_T}$ac_cv_lib_ssl_SSL_library_init" >&6
 
6941
if test $ac_cv_lib_ssl_SSL_library_init = yes; then
 
6942
  cat >>confdefs.h <<_ACEOF
 
6943
#define HAVE_LIBSSL 1
 
6944
_ACEOF
 
6945
 
 
6946
  LIBS="-lssl $LIBS"
 
6947
 
 
6948
else
 
6949
  { { echo "$as_me:$LINENO: error: library 'ssl' is required for OpenSSL" >&5
 
6950
echo "$as_me: error: library 'ssl' is required for OpenSSL" >&2;}
 
6951
   { (exit 1); exit 1; }; }
 
6952
fi
 
6953
 
 
6954
  else
 
6955
 
 
6956
echo "$as_me:$LINENO: checking for CRYPTO_new_ex_data in -leay32" >&5
 
6957
echo $ECHO_N "checking for CRYPTO_new_ex_data in -leay32... $ECHO_C" >&6
 
6958
if test "${ac_cv_lib_eay32_CRYPTO_new_ex_data+set}" = set; then
 
6959
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
6960
else
 
6961
  ac_check_lib_save_LIBS=$LIBS
 
6962
LIBS="-leay32  $LIBS"
 
6963
cat >conftest.$ac_ext <<_ACEOF
 
6964
#line $LINENO "configure"
 
6965
#include "confdefs.h"
 
6966
 
 
6967
/* Override any gcc2 internal prototype to avoid an error.  */
 
6968
#ifdef __cplusplus
 
6969
extern "C"
 
6970
#endif
 
6971
/* We use char because int might match the return type of a gcc2
 
6972
   builtin and then its argument prototype would still apply.  */
 
6973
char CRYPTO_new_ex_data ();
 
6974
#ifdef F77_DUMMY_MAIN
 
6975
#  ifdef __cplusplus
 
6976
     extern "C"
 
6977
#  endif
 
6978
   int F77_DUMMY_MAIN() { return 1; }
 
6979
#endif
 
6980
int
 
6981
main ()
 
6982
{
 
6983
CRYPTO_new_ex_data ();
 
6984
  ;
 
6985
  return 0;
 
6986
}
 
6987
_ACEOF
 
6988
rm -f conftest.$ac_objext conftest$ac_exeext
 
6989
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
6990
  (eval $ac_link) 2>&5
 
6991
  ac_status=$?
 
6992
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6993
  (exit $ac_status); } &&
 
6994
         { ac_try='test -s conftest$ac_exeext'
 
6995
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6996
  (eval $ac_try) 2>&5
 
6997
  ac_status=$?
 
6998
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6999
  (exit $ac_status); }; }; then
 
7000
  ac_cv_lib_eay32_CRYPTO_new_ex_data=yes
 
7001
else
 
7002
  echo "$as_me: failed program was:" >&5
 
7003
cat conftest.$ac_ext >&5
 
7004
ac_cv_lib_eay32_CRYPTO_new_ex_data=no
 
7005
fi
 
7006
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
7007
LIBS=$ac_check_lib_save_LIBS
 
7008
fi
 
7009
echo "$as_me:$LINENO: result: $ac_cv_lib_eay32_CRYPTO_new_ex_data" >&5
 
7010
echo "${ECHO_T}$ac_cv_lib_eay32_CRYPTO_new_ex_data" >&6
 
7011
if test $ac_cv_lib_eay32_CRYPTO_new_ex_data = yes; then
 
7012
  cat >>confdefs.h <<_ACEOF
 
7013
#define HAVE_LIBEAY32 1
 
7014
_ACEOF
 
7015
 
 
7016
  LIBS="-leay32 $LIBS"
 
7017
 
 
7018
else
 
7019
  { { echo "$as_me:$LINENO: error: library 'eay32' is required for OpenSSL" >&5
 
7020
echo "$as_me: error: library 'eay32' is required for OpenSSL" >&2;}
 
7021
   { (exit 1); exit 1; }; }
 
7022
fi
 
7023
 
 
7024
 
 
7025
echo "$as_me:$LINENO: checking for SSL_library_init in -lssleay32" >&5
 
7026
echo $ECHO_N "checking for SSL_library_init in -lssleay32... $ECHO_C" >&6
 
7027
if test "${ac_cv_lib_ssleay32_SSL_library_init+set}" = set; then
 
7028
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7029
else
 
7030
  ac_check_lib_save_LIBS=$LIBS
 
7031
LIBS="-lssleay32  $LIBS"
 
7032
cat >conftest.$ac_ext <<_ACEOF
 
7033
#line $LINENO "configure"
 
7034
#include "confdefs.h"
 
7035
 
 
7036
/* Override any gcc2 internal prototype to avoid an error.  */
 
7037
#ifdef __cplusplus
 
7038
extern "C"
 
7039
#endif
 
7040
/* We use char because int might match the return type of a gcc2
 
7041
   builtin and then its argument prototype would still apply.  */
 
7042
char SSL_library_init ();
 
7043
#ifdef F77_DUMMY_MAIN
 
7044
#  ifdef __cplusplus
 
7045
     extern "C"
 
7046
#  endif
 
7047
   int F77_DUMMY_MAIN() { return 1; }
 
7048
#endif
 
7049
int
 
7050
main ()
 
7051
{
 
7052
SSL_library_init ();
 
7053
  ;
 
7054
  return 0;
 
7055
}
 
7056
_ACEOF
 
7057
rm -f conftest.$ac_objext conftest$ac_exeext
 
7058
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
7059
  (eval $ac_link) 2>&5
 
7060
  ac_status=$?
 
7061
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7062
  (exit $ac_status); } &&
 
7063
         { ac_try='test -s conftest$ac_exeext'
 
7064
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
7065
  (eval $ac_try) 2>&5
 
7066
  ac_status=$?
 
7067
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7068
  (exit $ac_status); }; }; then
 
7069
  ac_cv_lib_ssleay32_SSL_library_init=yes
 
7070
else
 
7071
  echo "$as_me: failed program was:" >&5
 
7072
cat conftest.$ac_ext >&5
 
7073
ac_cv_lib_ssleay32_SSL_library_init=no
 
7074
fi
 
7075
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
7076
LIBS=$ac_check_lib_save_LIBS
 
7077
fi
 
7078
echo "$as_me:$LINENO: result: $ac_cv_lib_ssleay32_SSL_library_init" >&5
 
7079
echo "${ECHO_T}$ac_cv_lib_ssleay32_SSL_library_init" >&6
 
7080
if test $ac_cv_lib_ssleay32_SSL_library_init = yes; then
 
7081
  cat >>confdefs.h <<_ACEOF
 
7082
#define HAVE_LIBSSLEAY32 1
 
7083
_ACEOF
 
7084
 
 
7085
  LIBS="-lssleay32 $LIBS"
 
7086
 
 
7087
else
 
7088
  { { echo "$as_me:$LINENO: error: library 'ssleay32' is required for OpenSSL" >&5
 
7089
echo "$as_me: error: library 'ssleay32' is required for OpenSSL" >&2;}
 
7090
   { (exit 1); exit 1; }; }
 
7091
fi
 
7092
 
 
7093
  fi
 
7094
fi
 
7095
 
 
7096
if test "$with_pam" = yes ; then
 
7097
 
 
7098
echo "$as_me:$LINENO: checking for pam_start in -lpam" >&5
 
7099
echo $ECHO_N "checking for pam_start in -lpam... $ECHO_C" >&6
 
7100
if test "${ac_cv_lib_pam_pam_start+set}" = set; then
 
7101
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7102
else
 
7103
  ac_check_lib_save_LIBS=$LIBS
 
7104
LIBS="-lpam  $LIBS"
 
7105
cat >conftest.$ac_ext <<_ACEOF
 
7106
#line $LINENO "configure"
 
7107
#include "confdefs.h"
 
7108
 
 
7109
/* Override any gcc2 internal prototype to avoid an error.  */
 
7110
#ifdef __cplusplus
 
7111
extern "C"
 
7112
#endif
 
7113
/* We use char because int might match the return type of a gcc2
 
7114
   builtin and then its argument prototype would still apply.  */
 
7115
char pam_start ();
 
7116
#ifdef F77_DUMMY_MAIN
 
7117
#  ifdef __cplusplus
 
7118
     extern "C"
 
7119
#  endif
 
7120
   int F77_DUMMY_MAIN() { return 1; }
 
7121
#endif
 
7122
int
 
7123
main ()
 
7124
{
 
7125
pam_start ();
 
7126
  ;
 
7127
  return 0;
 
7128
}
 
7129
_ACEOF
 
7130
rm -f conftest.$ac_objext conftest$ac_exeext
 
7131
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
7132
  (eval $ac_link) 2>&5
 
7133
  ac_status=$?
 
7134
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7135
  (exit $ac_status); } &&
 
7136
         { ac_try='test -s conftest$ac_exeext'
 
7137
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
7138
  (eval $ac_try) 2>&5
 
7139
  ac_status=$?
 
7140
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7141
  (exit $ac_status); }; }; then
 
7142
  ac_cv_lib_pam_pam_start=yes
 
7143
else
 
7144
  echo "$as_me: failed program was:" >&5
 
7145
cat conftest.$ac_ext >&5
 
7146
ac_cv_lib_pam_pam_start=no
 
7147
fi
 
7148
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
7149
LIBS=$ac_check_lib_save_LIBS
 
7150
fi
 
7151
echo "$as_me:$LINENO: result: $ac_cv_lib_pam_pam_start" >&5
 
7152
echo "${ECHO_T}$ac_cv_lib_pam_pam_start" >&6
 
7153
if test $ac_cv_lib_pam_pam_start = yes; then
 
7154
  cat >>confdefs.h <<_ACEOF
 
7155
#define HAVE_LIBPAM 1
 
7156
_ACEOF
 
7157
 
 
7158
  LIBS="-lpam $LIBS"
 
7159
 
 
7160
else
 
7161
  { { echo "$as_me:$LINENO: error: library 'pam' is required for PAM" >&5
 
7162
echo "$as_me: error: library 'pam' is required for PAM" >&2;}
 
7163
   { (exit 1); exit 1; }; }
 
7164
fi
 
7165
 
 
7166
fi
 
7167
 
 
7168
 
 
7169
##
 
7170
## Header files
 
7171
##
 
7172
 
 
7173
echo "$as_me:$LINENO: checking for ANSI C header files" >&5
 
7174
echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
 
7175
if test "${ac_cv_header_stdc+set}" = set; then
 
7176
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7177
else
 
7178
  cat >conftest.$ac_ext <<_ACEOF
 
7179
#line $LINENO "configure"
 
7180
#include "confdefs.h"
 
7181
#include <stdlib.h>
 
7182
#include <stdarg.h>
 
7183
#include <string.h>
 
7184
#include <float.h>
 
7185
 
 
7186
_ACEOF
 
7187
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
7188
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
7189
  ac_status=$?
 
7190
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
7191
  rm -f conftest.er1
 
7192
  cat conftest.err >&5
 
7193
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7194
  (exit $ac_status); } >/dev/null; then
 
7195
  if test -s conftest.err; then
 
7196
    ac_cpp_err=$ac_c_preproc_warn_flag
 
7197
  else
 
7198
    ac_cpp_err=
 
7199
  fi
 
7200
else
 
7201
  ac_cpp_err=yes
 
7202
fi
 
7203
if test -z "$ac_cpp_err"; then
 
7204
  ac_cv_header_stdc=yes
 
7205
else
 
7206
  echo "$as_me: failed program was:" >&5
 
7207
  cat conftest.$ac_ext >&5
 
7208
  ac_cv_header_stdc=no
 
7209
fi
 
7210
rm -f conftest.err conftest.$ac_ext
 
7211
 
 
7212
if test $ac_cv_header_stdc = yes; then
 
7213
  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
 
7214
  cat >conftest.$ac_ext <<_ACEOF
 
7215
#line $LINENO "configure"
 
7216
#include "confdefs.h"
 
7217
#include <string.h>
 
7218
 
 
7219
_ACEOF
 
7220
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
 
7221
  egrep "memchr" >/dev/null 2>&1; then
 
7222
  :
 
7223
else
 
7224
  ac_cv_header_stdc=no
 
7225
fi
 
7226
rm -f conftest*
 
7227
 
 
7228
fi
 
7229
 
 
7230
if test $ac_cv_header_stdc = yes; then
 
7231
  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
 
7232
  cat >conftest.$ac_ext <<_ACEOF
 
7233
#line $LINENO "configure"
 
7234
#include "confdefs.h"
 
7235
#include <stdlib.h>
 
7236
 
 
7237
_ACEOF
 
7238
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
 
7239
  egrep "free" >/dev/null 2>&1; then
 
7240
  :
 
7241
else
 
7242
  ac_cv_header_stdc=no
 
7243
fi
 
7244
rm -f conftest*
 
7245
 
 
7246
fi
 
7247
 
 
7248
if test $ac_cv_header_stdc = yes; then
 
7249
  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
 
7250
  if test "$cross_compiling" = yes; then
 
7251
  :
 
7252
else
 
7253
  cat >conftest.$ac_ext <<_ACEOF
 
7254
#line $LINENO "configure"
 
7255
#include "confdefs.h"
 
7256
#include <ctype.h>
 
7257
#if ((' ' & 0x0FF) == 0x020)
 
7258
# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
 
7259
# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
 
7260
#else
 
7261
# define ISLOWER(c) (('a' <= (c) && (c) <= 'i') \
 
7262
                     || ('j' <= (c) && (c) <= 'r') \
 
7263
                     || ('s' <= (c) && (c) <= 'z'))
 
7264
# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
 
7265
#endif
 
7266
 
 
7267
#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
 
7268
int
 
7269
main ()
 
7270
{
 
7271
  int i;
 
7272
  for (i = 0; i < 256; i++)
 
7273
    if (XOR (islower (i), ISLOWER (i))
 
7274
        || toupper (i) != TOUPPER (i))
 
7275
      exit(2);
 
7276
  exit (0);
 
7277
}
 
7278
_ACEOF
 
7279
rm -f conftest$ac_exeext
 
7280
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
7281
  (eval $ac_link) 2>&5
 
7282
  ac_status=$?
 
7283
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7284
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
7285
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
7286
  (eval $ac_try) 2>&5
 
7287
  ac_status=$?
 
7288
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7289
  (exit $ac_status); }; }; then
 
7290
  :
 
7291
else
 
7292
  echo "$as_me: program exited with status $ac_status" >&5
 
7293
echo "$as_me: failed program was:" >&5
 
7294
cat conftest.$ac_ext >&5
 
7295
( exit $ac_status )
 
7296
ac_cv_header_stdc=no
 
7297
fi
 
7298
rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 
7299
fi
 
7300
fi
 
7301
fi
 
7302
echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
 
7303
echo "${ECHO_T}$ac_cv_header_stdc" >&6
 
7304
if test $ac_cv_header_stdc = yes; then
 
7305
 
 
7306
cat >>confdefs.h <<\_ACEOF
 
7307
#define STDC_HEADERS 1
 
7308
_ACEOF
 
7309
 
 
7310
fi
 
7311
 
 
7312
# On IRIX 5.3, sys/types and inttypes.h are conflicting.
 
7313
 
 
7314
 
 
7315
 
 
7316
 
 
7317
 
 
7318
 
 
7319
 
 
7320
 
 
7321
 
 
7322
for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
 
7323
                  inttypes.h stdint.h unistd.h
 
7324
do
 
7325
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
7326
echo "$as_me:$LINENO: checking for $ac_header" >&5
 
7327
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
7328
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
7329
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7330
else
 
7331
  cat >conftest.$ac_ext <<_ACEOF
 
7332
#line $LINENO "configure"
 
7333
#include "confdefs.h"
 
7334
$ac_includes_default
 
7335
 
 
7336
#include <$ac_header>
 
7337
_ACEOF
 
7338
rm -f conftest.$ac_objext
 
7339
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
7340
  (eval $ac_compile) 2>&5
 
7341
  ac_status=$?
 
7342
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7343
  (exit $ac_status); } &&
 
7344
         { ac_try='test -s conftest.$ac_objext'
 
7345
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
7346
  (eval $ac_try) 2>&5
 
7347
  ac_status=$?
 
7348
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7349
  (exit $ac_status); }; }; then
 
7350
  eval "$as_ac_Header=yes"
 
7351
else
 
7352
  echo "$as_me: failed program was:" >&5
 
7353
cat conftest.$ac_ext >&5
 
7354
eval "$as_ac_Header=no"
 
7355
fi
 
7356
rm -f conftest.$ac_objext conftest.$ac_ext
 
7357
fi
 
7358
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
7359
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
7360
if test `eval echo '${'$as_ac_Header'}'` = yes; then
 
7361
  cat >>confdefs.h <<_ACEOF
 
7362
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
7363
_ACEOF
 
7364
 
 
7365
fi
 
7366
 
 
7367
done
 
7368
 
 
7369
 
 
7370
 
 
7371
 
 
7372
 
 
7373
 
 
7374
 
 
7375
 
 
7376
 
 
7377
 
 
7378
 
 
7379
 
 
7380
 
 
7381
 
 
7382
 
 
7383
 
 
7384
 
 
7385
 
 
7386
 
 
7387
 
 
7388
 
 
7389
 
 
7390
 
 
7391
 
 
7392
 
 
7393
 
 
7394
 
 
7395
for ac_header in crypt.h dld.h endian.h fp_class.h getopt.h ieeefp.h langinfo.h poll.h pwd.h sys/ipc.h sys/poll.h sys/pstat.h sys/select.h sys/sem.h sys/socket.h sys/shm.h sys/time.h sys/un.h termios.h utime.h wchar.h wctype.h kernel/OS.h kernel/image.h SupportDefs.h
 
7396
do
 
7397
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
7398
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
7399
  echo "$as_me:$LINENO: checking for $ac_header" >&5
 
7400
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
7401
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
7402
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7403
fi
 
7404
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
7405
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
7406
else
 
7407
  # Is the header compilable?
 
7408
echo "$as_me:$LINENO: checking $ac_header usability" >&5
 
7409
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
 
7410
cat >conftest.$ac_ext <<_ACEOF
 
7411
#line $LINENO "configure"
 
7412
#include "confdefs.h"
 
7413
$ac_includes_default
 
7414
#include <$ac_header>
 
7415
_ACEOF
 
7416
rm -f conftest.$ac_objext
 
7417
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
7418
  (eval $ac_compile) 2>&5
 
7419
  ac_status=$?
 
7420
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7421
  (exit $ac_status); } &&
 
7422
         { ac_try='test -s conftest.$ac_objext'
 
7423
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
7424
  (eval $ac_try) 2>&5
 
7425
  ac_status=$?
 
7426
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7427
  (exit $ac_status); }; }; then
 
7428
  ac_header_compiler=yes
 
7429
else
 
7430
  echo "$as_me: failed program was:" >&5
 
7431
cat conftest.$ac_ext >&5
 
7432
ac_header_compiler=no
 
7433
fi
 
7434
rm -f conftest.$ac_objext conftest.$ac_ext
 
7435
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
7436
echo "${ECHO_T}$ac_header_compiler" >&6
 
7437
 
 
7438
# Is the header present?
 
7439
echo "$as_me:$LINENO: checking $ac_header presence" >&5
 
7440
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
 
7441
cat >conftest.$ac_ext <<_ACEOF
 
7442
#line $LINENO "configure"
 
7443
#include "confdefs.h"
 
7444
#include <$ac_header>
 
7445
_ACEOF
 
7446
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
7447
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
7448
  ac_status=$?
 
7449
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
7450
  rm -f conftest.er1
 
7451
  cat conftest.err >&5
 
7452
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7453
  (exit $ac_status); } >/dev/null; then
 
7454
  if test -s conftest.err; then
 
7455
    ac_cpp_err=$ac_c_preproc_warn_flag
 
7456
  else
 
7457
    ac_cpp_err=
 
7458
  fi
 
7459
else
 
7460
  ac_cpp_err=yes
 
7461
fi
 
7462
if test -z "$ac_cpp_err"; then
 
7463
  ac_header_preproc=yes
 
7464
else
 
7465
  echo "$as_me: failed program was:" >&5
 
7466
  cat conftest.$ac_ext >&5
 
7467
  ac_header_preproc=no
 
7468
fi
 
7469
rm -f conftest.err conftest.$ac_ext
 
7470
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
7471
echo "${ECHO_T}$ac_header_preproc" >&6
 
7472
 
 
7473
# So?  What about this header?
 
7474
case $ac_header_compiler:$ac_header_preproc in
 
7475
  yes:no )
 
7476
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
 
7477
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
7478
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
7479
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
7480
  no:yes )
 
7481
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
 
7482
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
 
7483
    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
 
7484
echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
 
7485
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
7486
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
7487
esac
 
7488
echo "$as_me:$LINENO: checking for $ac_header" >&5
 
7489
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
7490
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
7491
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7492
else
 
7493
  eval "$as_ac_Header=$ac_header_preproc"
 
7494
fi
 
7495
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
7496
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
7497
 
 
7498
fi
 
7499
if test `eval echo '${'$as_ac_Header'}'` = yes; then
 
7500
  cat >>confdefs.h <<_ACEOF
 
7501
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
7502
_ACEOF
 
7503
 
 
7504
fi
 
7505
 
 
7506
done
 
7507
 
 
7508
 
 
7509
# At least on IRIX, cpp test for netinet/tcp.h will fail unless
 
7510
# netinet/in.h is included first.
 
7511
 
 
7512
for ac_header in netinet/in.h
 
7513
do
 
7514
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
7515
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
7516
  echo "$as_me:$LINENO: checking for $ac_header" >&5
 
7517
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
7518
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
7519
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7520
fi
 
7521
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
7522
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
7523
else
 
7524
  # Is the header compilable?
 
7525
echo "$as_me:$LINENO: checking $ac_header usability" >&5
 
7526
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
 
7527
cat >conftest.$ac_ext <<_ACEOF
 
7528
#line $LINENO "configure"
 
7529
#include "confdefs.h"
 
7530
$ac_includes_default
 
7531
#include <$ac_header>
 
7532
_ACEOF
 
7533
rm -f conftest.$ac_objext
 
7534
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
7535
  (eval $ac_compile) 2>&5
 
7536
  ac_status=$?
 
7537
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7538
  (exit $ac_status); } &&
 
7539
         { ac_try='test -s conftest.$ac_objext'
 
7540
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
7541
  (eval $ac_try) 2>&5
 
7542
  ac_status=$?
 
7543
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7544
  (exit $ac_status); }; }; then
 
7545
  ac_header_compiler=yes
 
7546
else
 
7547
  echo "$as_me: failed program was:" >&5
 
7548
cat conftest.$ac_ext >&5
 
7549
ac_header_compiler=no
 
7550
fi
 
7551
rm -f conftest.$ac_objext conftest.$ac_ext
 
7552
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
7553
echo "${ECHO_T}$ac_header_compiler" >&6
 
7554
 
 
7555
# Is the header present?
 
7556
echo "$as_me:$LINENO: checking $ac_header presence" >&5
 
7557
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
 
7558
cat >conftest.$ac_ext <<_ACEOF
 
7559
#line $LINENO "configure"
 
7560
#include "confdefs.h"
 
7561
#include <$ac_header>
 
7562
_ACEOF
 
7563
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
7564
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
7565
  ac_status=$?
 
7566
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
7567
  rm -f conftest.er1
 
7568
  cat conftest.err >&5
 
7569
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7570
  (exit $ac_status); } >/dev/null; then
 
7571
  if test -s conftest.err; then
 
7572
    ac_cpp_err=$ac_c_preproc_warn_flag
 
7573
  else
 
7574
    ac_cpp_err=
 
7575
  fi
 
7576
else
 
7577
  ac_cpp_err=yes
 
7578
fi
 
7579
if test -z "$ac_cpp_err"; then
 
7580
  ac_header_preproc=yes
 
7581
else
 
7582
  echo "$as_me: failed program was:" >&5
 
7583
  cat conftest.$ac_ext >&5
 
7584
  ac_header_preproc=no
 
7585
fi
 
7586
rm -f conftest.err conftest.$ac_ext
 
7587
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
7588
echo "${ECHO_T}$ac_header_preproc" >&6
 
7589
 
 
7590
# So?  What about this header?
 
7591
case $ac_header_compiler:$ac_header_preproc in
 
7592
  yes:no )
 
7593
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
 
7594
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
7595
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
7596
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
7597
  no:yes )
 
7598
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
 
7599
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
 
7600
    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
 
7601
echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
 
7602
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
7603
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
7604
esac
 
7605
echo "$as_me:$LINENO: checking for $ac_header" >&5
 
7606
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
7607
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
7608
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7609
else
 
7610
  eval "$as_ac_Header=$ac_header_preproc"
 
7611
fi
 
7612
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
7613
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
7614
 
 
7615
fi
 
7616
if test `eval echo '${'$as_ac_Header'}'` = yes; then
 
7617
  cat >>confdefs.h <<_ACEOF
 
7618
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
7619
_ACEOF
 
7620
 
 
7621
fi
 
7622
 
 
7623
done
 
7624
 
 
7625
 
 
7626
for ac_header in netinet/tcp.h
 
7627
do
 
7628
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
7629
echo "$as_me:$LINENO: checking for $ac_header" >&5
 
7630
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
7631
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
7632
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7633
else
 
7634
  cat >conftest.$ac_ext <<_ACEOF
 
7635
#line $LINENO "configure"
 
7636
#include "confdefs.h"
 
7637
$ac_includes_default
 
7638
#ifdef HAVE_NETINET_IN_H
 
7639
#include <netinet/in.h>
 
7640
#endif
 
7641
 
 
7642
 
 
7643
#include <$ac_header>
 
7644
_ACEOF
 
7645
rm -f conftest.$ac_objext
 
7646
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
7647
  (eval $ac_compile) 2>&5
 
7648
  ac_status=$?
 
7649
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7650
  (exit $ac_status); } &&
 
7651
         { ac_try='test -s conftest.$ac_objext'
 
7652
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
7653
  (eval $ac_try) 2>&5
 
7654
  ac_status=$?
 
7655
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7656
  (exit $ac_status); }; }; then
 
7657
  eval "$as_ac_Header=yes"
 
7658
else
 
7659
  echo "$as_me: failed program was:" >&5
 
7660
cat conftest.$ac_ext >&5
 
7661
eval "$as_ac_Header=no"
 
7662
fi
 
7663
rm -f conftest.$ac_objext conftest.$ac_ext
 
7664
fi
 
7665
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
7666
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
7667
if test `eval echo '${'$as_ac_Header'}'` = yes; then
 
7668
  cat >>confdefs.h <<_ACEOF
 
7669
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
7670
_ACEOF
 
7671
 
 
7672
fi
 
7673
 
 
7674
done
 
7675
 
 
7676
 
 
7677
if expr x"$pgac_cv_check_readline" : 'x-lreadline' >/dev/null ; then
 
7678
 
 
7679
for ac_header in readline/readline.h
 
7680
do
 
7681
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
7682
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
7683
  echo "$as_me:$LINENO: checking for $ac_header" >&5
 
7684
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
7685
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
7686
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7687
fi
 
7688
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
7689
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
7690
else
 
7691
  # Is the header compilable?
 
7692
echo "$as_me:$LINENO: checking $ac_header usability" >&5
 
7693
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
 
7694
cat >conftest.$ac_ext <<_ACEOF
 
7695
#line $LINENO "configure"
 
7696
#include "confdefs.h"
 
7697
$ac_includes_default
 
7698
#include <$ac_header>
 
7699
_ACEOF
 
7700
rm -f conftest.$ac_objext
 
7701
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
7702
  (eval $ac_compile) 2>&5
 
7703
  ac_status=$?
 
7704
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7705
  (exit $ac_status); } &&
 
7706
         { ac_try='test -s conftest.$ac_objext'
 
7707
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
7708
  (eval $ac_try) 2>&5
 
7709
  ac_status=$?
 
7710
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7711
  (exit $ac_status); }; }; then
 
7712
  ac_header_compiler=yes
 
7713
else
 
7714
  echo "$as_me: failed program was:" >&5
 
7715
cat conftest.$ac_ext >&5
 
7716
ac_header_compiler=no
 
7717
fi
 
7718
rm -f conftest.$ac_objext conftest.$ac_ext
 
7719
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
7720
echo "${ECHO_T}$ac_header_compiler" >&6
 
7721
 
 
7722
# Is the header present?
 
7723
echo "$as_me:$LINENO: checking $ac_header presence" >&5
 
7724
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
 
7725
cat >conftest.$ac_ext <<_ACEOF
 
7726
#line $LINENO "configure"
 
7727
#include "confdefs.h"
 
7728
#include <$ac_header>
 
7729
_ACEOF
 
7730
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
7731
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
7732
  ac_status=$?
 
7733
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
7734
  rm -f conftest.er1
 
7735
  cat conftest.err >&5
 
7736
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7737
  (exit $ac_status); } >/dev/null; then
 
7738
  if test -s conftest.err; then
 
7739
    ac_cpp_err=$ac_c_preproc_warn_flag
 
7740
  else
 
7741
    ac_cpp_err=
 
7742
  fi
 
7743
else
 
7744
  ac_cpp_err=yes
 
7745
fi
 
7746
if test -z "$ac_cpp_err"; then
 
7747
  ac_header_preproc=yes
 
7748
else
 
7749
  echo "$as_me: failed program was:" >&5
 
7750
  cat conftest.$ac_ext >&5
 
7751
  ac_header_preproc=no
 
7752
fi
 
7753
rm -f conftest.err conftest.$ac_ext
 
7754
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
7755
echo "${ECHO_T}$ac_header_preproc" >&6
 
7756
 
 
7757
# So?  What about this header?
 
7758
case $ac_header_compiler:$ac_header_preproc in
 
7759
  yes:no )
 
7760
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
 
7761
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
7762
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
7763
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
7764
  no:yes )
 
7765
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
 
7766
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
 
7767
    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
 
7768
echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
 
7769
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
7770
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
7771
esac
 
7772
echo "$as_me:$LINENO: checking for $ac_header" >&5
 
7773
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
7774
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
7775
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7776
else
 
7777
  eval "$as_ac_Header=$ac_header_preproc"
 
7778
fi
 
7779
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
7780
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
7781
 
 
7782
fi
 
7783
if test `eval echo '${'$as_ac_Header'}'` = yes; then
 
7784
  cat >>confdefs.h <<_ACEOF
 
7785
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
7786
_ACEOF
 
7787
 
 
7788
else
 
7789
 
 
7790
for ac_header in readline.h
 
7791
do
 
7792
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
7793
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
7794
  echo "$as_me:$LINENO: checking for $ac_header" >&5
 
7795
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
7796
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
7797
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7798
fi
 
7799
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
7800
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
7801
else
 
7802
  # Is the header compilable?
 
7803
echo "$as_me:$LINENO: checking $ac_header usability" >&5
 
7804
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
 
7805
cat >conftest.$ac_ext <<_ACEOF
 
7806
#line $LINENO "configure"
 
7807
#include "confdefs.h"
 
7808
$ac_includes_default
 
7809
#include <$ac_header>
 
7810
_ACEOF
 
7811
rm -f conftest.$ac_objext
 
7812
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
7813
  (eval $ac_compile) 2>&5
 
7814
  ac_status=$?
 
7815
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7816
  (exit $ac_status); } &&
 
7817
         { ac_try='test -s conftest.$ac_objext'
 
7818
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
7819
  (eval $ac_try) 2>&5
 
7820
  ac_status=$?
 
7821
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7822
  (exit $ac_status); }; }; then
 
7823
  ac_header_compiler=yes
 
7824
else
 
7825
  echo "$as_me: failed program was:" >&5
 
7826
cat conftest.$ac_ext >&5
 
7827
ac_header_compiler=no
 
7828
fi
 
7829
rm -f conftest.$ac_objext conftest.$ac_ext
 
7830
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
7831
echo "${ECHO_T}$ac_header_compiler" >&6
 
7832
 
 
7833
# Is the header present?
 
7834
echo "$as_me:$LINENO: checking $ac_header presence" >&5
 
7835
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
 
7836
cat >conftest.$ac_ext <<_ACEOF
 
7837
#line $LINENO "configure"
 
7838
#include "confdefs.h"
 
7839
#include <$ac_header>
 
7840
_ACEOF
 
7841
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
7842
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
7843
  ac_status=$?
 
7844
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
7845
  rm -f conftest.er1
 
7846
  cat conftest.err >&5
 
7847
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7848
  (exit $ac_status); } >/dev/null; then
 
7849
  if test -s conftest.err; then
 
7850
    ac_cpp_err=$ac_c_preproc_warn_flag
 
7851
  else
 
7852
    ac_cpp_err=
 
7853
  fi
 
7854
else
 
7855
  ac_cpp_err=yes
 
7856
fi
 
7857
if test -z "$ac_cpp_err"; then
 
7858
  ac_header_preproc=yes
 
7859
else
 
7860
  echo "$as_me: failed program was:" >&5
 
7861
  cat conftest.$ac_ext >&5
 
7862
  ac_header_preproc=no
 
7863
fi
 
7864
rm -f conftest.err conftest.$ac_ext
 
7865
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
7866
echo "${ECHO_T}$ac_header_preproc" >&6
 
7867
 
 
7868
# So?  What about this header?
 
7869
case $ac_header_compiler:$ac_header_preproc in
 
7870
  yes:no )
 
7871
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
 
7872
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
7873
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
7874
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
7875
  no:yes )
 
7876
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
 
7877
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
 
7878
    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
 
7879
echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
 
7880
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
7881
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
7882
esac
 
7883
echo "$as_me:$LINENO: checking for $ac_header" >&5
 
7884
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
7885
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
7886
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7887
else
 
7888
  eval "$as_ac_Header=$ac_header_preproc"
 
7889
fi
 
7890
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
7891
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
7892
 
 
7893
fi
 
7894
if test `eval echo '${'$as_ac_Header'}'` = yes; then
 
7895
  cat >>confdefs.h <<_ACEOF
 
7896
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
7897
_ACEOF
 
7898
 
 
7899
else
 
7900
  { { echo "$as_me:$LINENO: error: readline header not found
 
7901
If you have readline already installed, see config.log for details on the
 
7902
failure.  It is possible the compiler isn't looking in the proper directory.
 
7903
Use --without-readline to disable readline support." >&5
 
7904
echo "$as_me: error: readline header not found
 
7905
If you have readline already installed, see config.log for details on the
 
7906
failure.  It is possible the compiler isn't looking in the proper directory.
 
7907
Use --without-readline to disable readline support." >&2;}
 
7908
   { (exit 1); exit 1; }; }
 
7909
fi
 
7910
 
 
7911
done
 
7912
 
 
7913
fi
 
7914
 
 
7915
done
 
7916
 
 
7917
 
 
7918
for ac_header in readline/history.h
 
7919
do
 
7920
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
7921
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
7922
  echo "$as_me:$LINENO: checking for $ac_header" >&5
 
7923
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
7924
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
7925
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7926
fi
 
7927
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
7928
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
7929
else
 
7930
  # Is the header compilable?
 
7931
echo "$as_me:$LINENO: checking $ac_header usability" >&5
 
7932
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
 
7933
cat >conftest.$ac_ext <<_ACEOF
 
7934
#line $LINENO "configure"
 
7935
#include "confdefs.h"
 
7936
$ac_includes_default
 
7937
#include <$ac_header>
 
7938
_ACEOF
 
7939
rm -f conftest.$ac_objext
 
7940
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
7941
  (eval $ac_compile) 2>&5
 
7942
  ac_status=$?
 
7943
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7944
  (exit $ac_status); } &&
 
7945
         { ac_try='test -s conftest.$ac_objext'
 
7946
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
7947
  (eval $ac_try) 2>&5
 
7948
  ac_status=$?
 
7949
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7950
  (exit $ac_status); }; }; then
 
7951
  ac_header_compiler=yes
 
7952
else
 
7953
  echo "$as_me: failed program was:" >&5
 
7954
cat conftest.$ac_ext >&5
 
7955
ac_header_compiler=no
 
7956
fi
 
7957
rm -f conftest.$ac_objext conftest.$ac_ext
 
7958
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
7959
echo "${ECHO_T}$ac_header_compiler" >&6
 
7960
 
 
7961
# Is the header present?
 
7962
echo "$as_me:$LINENO: checking $ac_header presence" >&5
 
7963
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
 
7964
cat >conftest.$ac_ext <<_ACEOF
 
7965
#line $LINENO "configure"
 
7966
#include "confdefs.h"
 
7967
#include <$ac_header>
 
7968
_ACEOF
 
7969
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
7970
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
7971
  ac_status=$?
 
7972
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
7973
  rm -f conftest.er1
 
7974
  cat conftest.err >&5
 
7975
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7976
  (exit $ac_status); } >/dev/null; then
 
7977
  if test -s conftest.err; then
 
7978
    ac_cpp_err=$ac_c_preproc_warn_flag
 
7979
  else
 
7980
    ac_cpp_err=
 
7981
  fi
 
7982
else
 
7983
  ac_cpp_err=yes
 
7984
fi
 
7985
if test -z "$ac_cpp_err"; then
 
7986
  ac_header_preproc=yes
 
7987
else
 
7988
  echo "$as_me: failed program was:" >&5
 
7989
  cat conftest.$ac_ext >&5
 
7990
  ac_header_preproc=no
 
7991
fi
 
7992
rm -f conftest.err conftest.$ac_ext
 
7993
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
7994
echo "${ECHO_T}$ac_header_preproc" >&6
 
7995
 
 
7996
# So?  What about this header?
 
7997
case $ac_header_compiler:$ac_header_preproc in
 
7998
  yes:no )
 
7999
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
 
8000
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
8001
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
8002
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
8003
  no:yes )
 
8004
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
 
8005
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
 
8006
    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
 
8007
echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
 
8008
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
8009
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
8010
esac
 
8011
echo "$as_me:$LINENO: checking for $ac_header" >&5
 
8012
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
8013
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8014
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
8015
else
 
8016
  eval "$as_ac_Header=$ac_header_preproc"
 
8017
fi
 
8018
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
8019
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
8020
 
 
8021
fi
 
8022
if test `eval echo '${'$as_ac_Header'}'` = yes; then
 
8023
  cat >>confdefs.h <<_ACEOF
 
8024
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
8025
_ACEOF
 
8026
 
 
8027
else
 
8028
 
 
8029
for ac_header in history.h
 
8030
do
 
8031
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
8032
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8033
  echo "$as_me:$LINENO: checking for $ac_header" >&5
 
8034
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
8035
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8036
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
8037
fi
 
8038
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
8039
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
8040
else
 
8041
  # Is the header compilable?
 
8042
echo "$as_me:$LINENO: checking $ac_header usability" >&5
 
8043
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
 
8044
cat >conftest.$ac_ext <<_ACEOF
 
8045
#line $LINENO "configure"
 
8046
#include "confdefs.h"
 
8047
$ac_includes_default
 
8048
#include <$ac_header>
 
8049
_ACEOF
 
8050
rm -f conftest.$ac_objext
 
8051
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
8052
  (eval $ac_compile) 2>&5
 
8053
  ac_status=$?
 
8054
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8055
  (exit $ac_status); } &&
 
8056
         { ac_try='test -s conftest.$ac_objext'
 
8057
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
8058
  (eval $ac_try) 2>&5
 
8059
  ac_status=$?
 
8060
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8061
  (exit $ac_status); }; }; then
 
8062
  ac_header_compiler=yes
 
8063
else
 
8064
  echo "$as_me: failed program was:" >&5
 
8065
cat conftest.$ac_ext >&5
 
8066
ac_header_compiler=no
 
8067
fi
 
8068
rm -f conftest.$ac_objext conftest.$ac_ext
 
8069
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
8070
echo "${ECHO_T}$ac_header_compiler" >&6
 
8071
 
 
8072
# Is the header present?
 
8073
echo "$as_me:$LINENO: checking $ac_header presence" >&5
 
8074
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
 
8075
cat >conftest.$ac_ext <<_ACEOF
 
8076
#line $LINENO "configure"
 
8077
#include "confdefs.h"
 
8078
#include <$ac_header>
 
8079
_ACEOF
 
8080
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
8081
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
8082
  ac_status=$?
 
8083
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
8084
  rm -f conftest.er1
 
8085
  cat conftest.err >&5
 
8086
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8087
  (exit $ac_status); } >/dev/null; then
 
8088
  if test -s conftest.err; then
 
8089
    ac_cpp_err=$ac_c_preproc_warn_flag
 
8090
  else
 
8091
    ac_cpp_err=
 
8092
  fi
 
8093
else
 
8094
  ac_cpp_err=yes
 
8095
fi
 
8096
if test -z "$ac_cpp_err"; then
 
8097
  ac_header_preproc=yes
 
8098
else
 
8099
  echo "$as_me: failed program was:" >&5
 
8100
  cat conftest.$ac_ext >&5
 
8101
  ac_header_preproc=no
 
8102
fi
 
8103
rm -f conftest.err conftest.$ac_ext
 
8104
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
8105
echo "${ECHO_T}$ac_header_preproc" >&6
 
8106
 
 
8107
# So?  What about this header?
 
8108
case $ac_header_compiler:$ac_header_preproc in
 
8109
  yes:no )
 
8110
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
 
8111
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
8112
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
8113
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
8114
  no:yes )
 
8115
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
 
8116
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
 
8117
    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
 
8118
echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
 
8119
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
8120
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
8121
esac
 
8122
echo "$as_me:$LINENO: checking for $ac_header" >&5
 
8123
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
8124
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8125
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
8126
else
 
8127
  eval "$as_ac_Header=$ac_header_preproc"
 
8128
fi
 
8129
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
8130
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
8131
 
 
8132
fi
 
8133
if test `eval echo '${'$as_ac_Header'}'` = yes; then
 
8134
  cat >>confdefs.h <<_ACEOF
 
8135
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
8136
_ACEOF
 
8137
 
 
8138
else
 
8139
  { { echo "$as_me:$LINENO: error: history header not found
 
8140
If you have readline already installed, see config.log for details on the
 
8141
failure.  It is possible the compiler isn't looking in the proper directory.
 
8142
Use --without-readline to disable readline support." >&5
 
8143
echo "$as_me: error: history header not found
 
8144
If you have readline already installed, see config.log for details on the
 
8145
failure.  It is possible the compiler isn't looking in the proper directory.
 
8146
Use --without-readline to disable readline support." >&2;}
 
8147
   { (exit 1); exit 1; }; }
 
8148
fi
 
8149
 
 
8150
done
 
8151
 
 
8152
fi
 
8153
 
 
8154
done
 
8155
 
 
8156
fi
 
8157
 
 
8158
if expr x"$pgac_cv_check_readline" : 'x-ledit' >/dev/null ; then
 
8159
# Some installations of libedit usurp /usr/include/readline/, which seems
 
8160
# bad practice, since in combined installations readline will have its headers
 
8161
# there.  We might have to resort to AC_EGREP checks to make sure we found
 
8162
# the proper header...
 
8163
 
 
8164
for ac_header in editline/readline.h
 
8165
do
 
8166
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
8167
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8168
  echo "$as_me:$LINENO: checking for $ac_header" >&5
 
8169
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
8170
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8171
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
8172
fi
 
8173
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
8174
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
8175
else
 
8176
  # Is the header compilable?
 
8177
echo "$as_me:$LINENO: checking $ac_header usability" >&5
 
8178
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
 
8179
cat >conftest.$ac_ext <<_ACEOF
 
8180
#line $LINENO "configure"
 
8181
#include "confdefs.h"
 
8182
$ac_includes_default
 
8183
#include <$ac_header>
 
8184
_ACEOF
 
8185
rm -f conftest.$ac_objext
 
8186
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
8187
  (eval $ac_compile) 2>&5
 
8188
  ac_status=$?
 
8189
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8190
  (exit $ac_status); } &&
 
8191
         { ac_try='test -s conftest.$ac_objext'
 
8192
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
8193
  (eval $ac_try) 2>&5
 
8194
  ac_status=$?
 
8195
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8196
  (exit $ac_status); }; }; then
 
8197
  ac_header_compiler=yes
 
8198
else
 
8199
  echo "$as_me: failed program was:" >&5
 
8200
cat conftest.$ac_ext >&5
 
8201
ac_header_compiler=no
 
8202
fi
 
8203
rm -f conftest.$ac_objext conftest.$ac_ext
 
8204
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
8205
echo "${ECHO_T}$ac_header_compiler" >&6
 
8206
 
 
8207
# Is the header present?
 
8208
echo "$as_me:$LINENO: checking $ac_header presence" >&5
 
8209
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
 
8210
cat >conftest.$ac_ext <<_ACEOF
 
8211
#line $LINENO "configure"
 
8212
#include "confdefs.h"
 
8213
#include <$ac_header>
 
8214
_ACEOF
 
8215
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
8216
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
8217
  ac_status=$?
 
8218
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
8219
  rm -f conftest.er1
 
8220
  cat conftest.err >&5
 
8221
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8222
  (exit $ac_status); } >/dev/null; then
 
8223
  if test -s conftest.err; then
 
8224
    ac_cpp_err=$ac_c_preproc_warn_flag
 
8225
  else
 
8226
    ac_cpp_err=
 
8227
  fi
 
8228
else
 
8229
  ac_cpp_err=yes
 
8230
fi
 
8231
if test -z "$ac_cpp_err"; then
 
8232
  ac_header_preproc=yes
 
8233
else
 
8234
  echo "$as_me: failed program was:" >&5
 
8235
  cat conftest.$ac_ext >&5
 
8236
  ac_header_preproc=no
 
8237
fi
 
8238
rm -f conftest.err conftest.$ac_ext
 
8239
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
8240
echo "${ECHO_T}$ac_header_preproc" >&6
 
8241
 
 
8242
# So?  What about this header?
 
8243
case $ac_header_compiler:$ac_header_preproc in
 
8244
  yes:no )
 
8245
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
 
8246
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
8247
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
8248
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
8249
  no:yes )
 
8250
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
 
8251
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
 
8252
    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
 
8253
echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
 
8254
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
8255
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
8256
esac
 
8257
echo "$as_me:$LINENO: checking for $ac_header" >&5
 
8258
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
8259
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8260
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
8261
else
 
8262
  eval "$as_ac_Header=$ac_header_preproc"
 
8263
fi
 
8264
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
8265
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
8266
 
 
8267
fi
 
8268
if test `eval echo '${'$as_ac_Header'}'` = yes; then
 
8269
  cat >>confdefs.h <<_ACEOF
 
8270
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
8271
_ACEOF
 
8272
 
 
8273
else
 
8274
 
 
8275
for ac_header in readline.h
 
8276
do
 
8277
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
8278
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8279
  echo "$as_me:$LINENO: checking for $ac_header" >&5
 
8280
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
8281
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8282
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
8283
fi
 
8284
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
8285
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
8286
else
 
8287
  # Is the header compilable?
 
8288
echo "$as_me:$LINENO: checking $ac_header usability" >&5
 
8289
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
 
8290
cat >conftest.$ac_ext <<_ACEOF
 
8291
#line $LINENO "configure"
 
8292
#include "confdefs.h"
 
8293
$ac_includes_default
 
8294
#include <$ac_header>
 
8295
_ACEOF
 
8296
rm -f conftest.$ac_objext
 
8297
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
8298
  (eval $ac_compile) 2>&5
 
8299
  ac_status=$?
 
8300
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8301
  (exit $ac_status); } &&
 
8302
         { ac_try='test -s conftest.$ac_objext'
 
8303
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
8304
  (eval $ac_try) 2>&5
 
8305
  ac_status=$?
 
8306
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8307
  (exit $ac_status); }; }; then
 
8308
  ac_header_compiler=yes
 
8309
else
 
8310
  echo "$as_me: failed program was:" >&5
 
8311
cat conftest.$ac_ext >&5
 
8312
ac_header_compiler=no
 
8313
fi
 
8314
rm -f conftest.$ac_objext conftest.$ac_ext
 
8315
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
8316
echo "${ECHO_T}$ac_header_compiler" >&6
 
8317
 
 
8318
# Is the header present?
 
8319
echo "$as_me:$LINENO: checking $ac_header presence" >&5
 
8320
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
 
8321
cat >conftest.$ac_ext <<_ACEOF
 
8322
#line $LINENO "configure"
 
8323
#include "confdefs.h"
 
8324
#include <$ac_header>
 
8325
_ACEOF
 
8326
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
8327
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
8328
  ac_status=$?
 
8329
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
8330
  rm -f conftest.er1
 
8331
  cat conftest.err >&5
 
8332
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8333
  (exit $ac_status); } >/dev/null; then
 
8334
  if test -s conftest.err; then
 
8335
    ac_cpp_err=$ac_c_preproc_warn_flag
 
8336
  else
 
8337
    ac_cpp_err=
 
8338
  fi
 
8339
else
 
8340
  ac_cpp_err=yes
 
8341
fi
 
8342
if test -z "$ac_cpp_err"; then
 
8343
  ac_header_preproc=yes
 
8344
else
 
8345
  echo "$as_me: failed program was:" >&5
 
8346
  cat conftest.$ac_ext >&5
 
8347
  ac_header_preproc=no
 
8348
fi
 
8349
rm -f conftest.err conftest.$ac_ext
 
8350
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
8351
echo "${ECHO_T}$ac_header_preproc" >&6
 
8352
 
 
8353
# So?  What about this header?
 
8354
case $ac_header_compiler:$ac_header_preproc in
 
8355
  yes:no )
 
8356
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
 
8357
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
8358
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
8359
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
8360
  no:yes )
 
8361
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
 
8362
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
 
8363
    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
 
8364
echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
 
8365
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
8366
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
8367
esac
 
8368
echo "$as_me:$LINENO: checking for $ac_header" >&5
 
8369
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
8370
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8371
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
8372
else
 
8373
  eval "$as_ac_Header=$ac_header_preproc"
 
8374
fi
 
8375
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
8376
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
8377
 
 
8378
fi
 
8379
if test `eval echo '${'$as_ac_Header'}'` = yes; then
 
8380
  cat >>confdefs.h <<_ACEOF
 
8381
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
8382
_ACEOF
 
8383
 
 
8384
else
 
8385
 
 
8386
for ac_header in readline/readline.h
 
8387
do
 
8388
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
8389
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8390
  echo "$as_me:$LINENO: checking for $ac_header" >&5
 
8391
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
8392
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8393
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
8394
fi
 
8395
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
8396
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
8397
else
 
8398
  # Is the header compilable?
 
8399
echo "$as_me:$LINENO: checking $ac_header usability" >&5
 
8400
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
 
8401
cat >conftest.$ac_ext <<_ACEOF
 
8402
#line $LINENO "configure"
 
8403
#include "confdefs.h"
 
8404
$ac_includes_default
 
8405
#include <$ac_header>
 
8406
_ACEOF
 
8407
rm -f conftest.$ac_objext
 
8408
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
8409
  (eval $ac_compile) 2>&5
 
8410
  ac_status=$?
 
8411
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8412
  (exit $ac_status); } &&
 
8413
         { ac_try='test -s conftest.$ac_objext'
 
8414
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
8415
  (eval $ac_try) 2>&5
 
8416
  ac_status=$?
 
8417
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8418
  (exit $ac_status); }; }; then
 
8419
  ac_header_compiler=yes
 
8420
else
 
8421
  echo "$as_me: failed program was:" >&5
 
8422
cat conftest.$ac_ext >&5
 
8423
ac_header_compiler=no
 
8424
fi
 
8425
rm -f conftest.$ac_objext conftest.$ac_ext
 
8426
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
8427
echo "${ECHO_T}$ac_header_compiler" >&6
 
8428
 
 
8429
# Is the header present?
 
8430
echo "$as_me:$LINENO: checking $ac_header presence" >&5
 
8431
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
 
8432
cat >conftest.$ac_ext <<_ACEOF
 
8433
#line $LINENO "configure"
 
8434
#include "confdefs.h"
 
8435
#include <$ac_header>
 
8436
_ACEOF
 
8437
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
8438
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
8439
  ac_status=$?
 
8440
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
8441
  rm -f conftest.er1
 
8442
  cat conftest.err >&5
 
8443
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8444
  (exit $ac_status); } >/dev/null; then
 
8445
  if test -s conftest.err; then
 
8446
    ac_cpp_err=$ac_c_preproc_warn_flag
 
8447
  else
 
8448
    ac_cpp_err=
 
8449
  fi
 
8450
else
 
8451
  ac_cpp_err=yes
 
8452
fi
 
8453
if test -z "$ac_cpp_err"; then
 
8454
  ac_header_preproc=yes
 
8455
else
 
8456
  echo "$as_me: failed program was:" >&5
 
8457
  cat conftest.$ac_ext >&5
 
8458
  ac_header_preproc=no
 
8459
fi
 
8460
rm -f conftest.err conftest.$ac_ext
 
8461
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
8462
echo "${ECHO_T}$ac_header_preproc" >&6
 
8463
 
 
8464
# So?  What about this header?
 
8465
case $ac_header_compiler:$ac_header_preproc in
 
8466
  yes:no )
 
8467
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
 
8468
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
8469
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
8470
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
8471
  no:yes )
 
8472
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
 
8473
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
 
8474
    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
 
8475
echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
 
8476
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
8477
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
8478
esac
 
8479
echo "$as_me:$LINENO: checking for $ac_header" >&5
 
8480
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
8481
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8482
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
8483
else
 
8484
  eval "$as_ac_Header=$ac_header_preproc"
 
8485
fi
 
8486
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
8487
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
8488
 
 
8489
fi
 
8490
if test `eval echo '${'$as_ac_Header'}'` = yes; then
 
8491
  cat >>confdefs.h <<_ACEOF
 
8492
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
8493
_ACEOF
 
8494
 
 
8495
else
 
8496
  { { echo "$as_me:$LINENO: error: readline header not found
 
8497
If you have libedit already installed, see config.log for details on the
 
8498
failure.  It is possible the compiler isn't looking in the proper directory.
 
8499
Use --without-readline to disable libedit support." >&5
 
8500
echo "$as_me: error: readline header not found
 
8501
If you have libedit already installed, see config.log for details on the
 
8502
failure.  It is possible the compiler isn't looking in the proper directory.
 
8503
Use --without-readline to disable libedit support." >&2;}
 
8504
   { (exit 1); exit 1; }; }
 
8505
fi
 
8506
 
 
8507
done
 
8508
 
 
8509
fi
 
8510
 
 
8511
done
 
8512
 
 
8513
fi
 
8514
 
 
8515
done
 
8516
 
 
8517
 
 
8518
for ac_header in editline/history.h
 
8519
do
 
8520
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
8521
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8522
  echo "$as_me:$LINENO: checking for $ac_header" >&5
 
8523
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
8524
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8525
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
8526
fi
 
8527
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
8528
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
8529
else
 
8530
  # Is the header compilable?
 
8531
echo "$as_me:$LINENO: checking $ac_header usability" >&5
 
8532
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
 
8533
cat >conftest.$ac_ext <<_ACEOF
 
8534
#line $LINENO "configure"
 
8535
#include "confdefs.h"
 
8536
$ac_includes_default
 
8537
#include <$ac_header>
 
8538
_ACEOF
 
8539
rm -f conftest.$ac_objext
 
8540
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
8541
  (eval $ac_compile) 2>&5
 
8542
  ac_status=$?
 
8543
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8544
  (exit $ac_status); } &&
 
8545
         { ac_try='test -s conftest.$ac_objext'
 
8546
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
8547
  (eval $ac_try) 2>&5
 
8548
  ac_status=$?
 
8549
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8550
  (exit $ac_status); }; }; then
 
8551
  ac_header_compiler=yes
 
8552
else
 
8553
  echo "$as_me: failed program was:" >&5
 
8554
cat conftest.$ac_ext >&5
 
8555
ac_header_compiler=no
 
8556
fi
 
8557
rm -f conftest.$ac_objext conftest.$ac_ext
 
8558
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
8559
echo "${ECHO_T}$ac_header_compiler" >&6
 
8560
 
 
8561
# Is the header present?
 
8562
echo "$as_me:$LINENO: checking $ac_header presence" >&5
 
8563
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
 
8564
cat >conftest.$ac_ext <<_ACEOF
 
8565
#line $LINENO "configure"
 
8566
#include "confdefs.h"
 
8567
#include <$ac_header>
 
8568
_ACEOF
 
8569
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
8570
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
8571
  ac_status=$?
 
8572
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
8573
  rm -f conftest.er1
 
8574
  cat conftest.err >&5
 
8575
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8576
  (exit $ac_status); } >/dev/null; then
 
8577
  if test -s conftest.err; then
 
8578
    ac_cpp_err=$ac_c_preproc_warn_flag
 
8579
  else
 
8580
    ac_cpp_err=
 
8581
  fi
 
8582
else
 
8583
  ac_cpp_err=yes
 
8584
fi
 
8585
if test -z "$ac_cpp_err"; then
 
8586
  ac_header_preproc=yes
 
8587
else
 
8588
  echo "$as_me: failed program was:" >&5
 
8589
  cat conftest.$ac_ext >&5
 
8590
  ac_header_preproc=no
 
8591
fi
 
8592
rm -f conftest.err conftest.$ac_ext
 
8593
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
8594
echo "${ECHO_T}$ac_header_preproc" >&6
 
8595
 
 
8596
# So?  What about this header?
 
8597
case $ac_header_compiler:$ac_header_preproc in
 
8598
  yes:no )
 
8599
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
 
8600
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
8601
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
8602
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
8603
  no:yes )
 
8604
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
 
8605
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
 
8606
    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
 
8607
echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
 
8608
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
8609
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
8610
esac
 
8611
echo "$as_me:$LINENO: checking for $ac_header" >&5
 
8612
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
8613
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8614
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
8615
else
 
8616
  eval "$as_ac_Header=$ac_header_preproc"
 
8617
fi
 
8618
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
8619
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
8620
 
 
8621
fi
 
8622
if test `eval echo '${'$as_ac_Header'}'` = yes; then
 
8623
  cat >>confdefs.h <<_ACEOF
 
8624
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
8625
_ACEOF
 
8626
 
 
8627
else
 
8628
 
 
8629
for ac_header in history.h
 
8630
do
 
8631
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
8632
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8633
  echo "$as_me:$LINENO: checking for $ac_header" >&5
 
8634
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
8635
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8636
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
8637
fi
 
8638
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
8639
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
8640
else
 
8641
  # Is the header compilable?
 
8642
echo "$as_me:$LINENO: checking $ac_header usability" >&5
 
8643
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
 
8644
cat >conftest.$ac_ext <<_ACEOF
 
8645
#line $LINENO "configure"
 
8646
#include "confdefs.h"
 
8647
$ac_includes_default
 
8648
#include <$ac_header>
 
8649
_ACEOF
 
8650
rm -f conftest.$ac_objext
 
8651
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
8652
  (eval $ac_compile) 2>&5
 
8653
  ac_status=$?
 
8654
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8655
  (exit $ac_status); } &&
 
8656
         { ac_try='test -s conftest.$ac_objext'
 
8657
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
8658
  (eval $ac_try) 2>&5
 
8659
  ac_status=$?
 
8660
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8661
  (exit $ac_status); }; }; then
 
8662
  ac_header_compiler=yes
 
8663
else
 
8664
  echo "$as_me: failed program was:" >&5
 
8665
cat conftest.$ac_ext >&5
 
8666
ac_header_compiler=no
 
8667
fi
 
8668
rm -f conftest.$ac_objext conftest.$ac_ext
 
8669
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
8670
echo "${ECHO_T}$ac_header_compiler" >&6
 
8671
 
 
8672
# Is the header present?
 
8673
echo "$as_me:$LINENO: checking $ac_header presence" >&5
 
8674
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
 
8675
cat >conftest.$ac_ext <<_ACEOF
 
8676
#line $LINENO "configure"
 
8677
#include "confdefs.h"
 
8678
#include <$ac_header>
 
8679
_ACEOF
 
8680
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
8681
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
8682
  ac_status=$?
 
8683
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
8684
  rm -f conftest.er1
 
8685
  cat conftest.err >&5
 
8686
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8687
  (exit $ac_status); } >/dev/null; then
 
8688
  if test -s conftest.err; then
 
8689
    ac_cpp_err=$ac_c_preproc_warn_flag
 
8690
  else
 
8691
    ac_cpp_err=
 
8692
  fi
 
8693
else
 
8694
  ac_cpp_err=yes
 
8695
fi
 
8696
if test -z "$ac_cpp_err"; then
 
8697
  ac_header_preproc=yes
 
8698
else
 
8699
  echo "$as_me: failed program was:" >&5
 
8700
  cat conftest.$ac_ext >&5
 
8701
  ac_header_preproc=no
 
8702
fi
 
8703
rm -f conftest.err conftest.$ac_ext
 
8704
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
8705
echo "${ECHO_T}$ac_header_preproc" >&6
 
8706
 
 
8707
# So?  What about this header?
 
8708
case $ac_header_compiler:$ac_header_preproc in
 
8709
  yes:no )
 
8710
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
 
8711
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
8712
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
8713
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
8714
  no:yes )
 
8715
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
 
8716
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
 
8717
    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
 
8718
echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
 
8719
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
8720
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
8721
esac
 
8722
echo "$as_me:$LINENO: checking for $ac_header" >&5
 
8723
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
8724
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8725
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
8726
else
 
8727
  eval "$as_ac_Header=$ac_header_preproc"
 
8728
fi
 
8729
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
8730
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
8731
 
 
8732
fi
 
8733
if test `eval echo '${'$as_ac_Header'}'` = yes; then
 
8734
  cat >>confdefs.h <<_ACEOF
 
8735
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
8736
_ACEOF
 
8737
 
 
8738
else
 
8739
 
 
8740
for ac_header in readline/history.h
 
8741
do
 
8742
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
8743
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8744
  echo "$as_me:$LINENO: checking for $ac_header" >&5
 
8745
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
8746
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8747
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
8748
fi
 
8749
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
8750
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
8751
else
 
8752
  # Is the header compilable?
 
8753
echo "$as_me:$LINENO: checking $ac_header usability" >&5
 
8754
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
 
8755
cat >conftest.$ac_ext <<_ACEOF
 
8756
#line $LINENO "configure"
 
8757
#include "confdefs.h"
 
8758
$ac_includes_default
 
8759
#include <$ac_header>
 
8760
_ACEOF
 
8761
rm -f conftest.$ac_objext
 
8762
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
8763
  (eval $ac_compile) 2>&5
 
8764
  ac_status=$?
 
8765
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8766
  (exit $ac_status); } &&
 
8767
         { ac_try='test -s conftest.$ac_objext'
 
8768
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
8769
  (eval $ac_try) 2>&5
 
8770
  ac_status=$?
 
8771
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8772
  (exit $ac_status); }; }; then
 
8773
  ac_header_compiler=yes
 
8774
else
 
8775
  echo "$as_me: failed program was:" >&5
 
8776
cat conftest.$ac_ext >&5
 
8777
ac_header_compiler=no
 
8778
fi
 
8779
rm -f conftest.$ac_objext conftest.$ac_ext
 
8780
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
8781
echo "${ECHO_T}$ac_header_compiler" >&6
 
8782
 
 
8783
# Is the header present?
 
8784
echo "$as_me:$LINENO: checking $ac_header presence" >&5
 
8785
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
 
8786
cat >conftest.$ac_ext <<_ACEOF
 
8787
#line $LINENO "configure"
 
8788
#include "confdefs.h"
 
8789
#include <$ac_header>
 
8790
_ACEOF
 
8791
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
8792
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
8793
  ac_status=$?
 
8794
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
8795
  rm -f conftest.er1
 
8796
  cat conftest.err >&5
 
8797
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8798
  (exit $ac_status); } >/dev/null; then
 
8799
  if test -s conftest.err; then
 
8800
    ac_cpp_err=$ac_c_preproc_warn_flag
 
8801
  else
 
8802
    ac_cpp_err=
 
8803
  fi
 
8804
else
 
8805
  ac_cpp_err=yes
 
8806
fi
 
8807
if test -z "$ac_cpp_err"; then
 
8808
  ac_header_preproc=yes
 
8809
else
 
8810
  echo "$as_me: failed program was:" >&5
 
8811
  cat conftest.$ac_ext >&5
 
8812
  ac_header_preproc=no
 
8813
fi
 
8814
rm -f conftest.err conftest.$ac_ext
 
8815
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
8816
echo "${ECHO_T}$ac_header_preproc" >&6
 
8817
 
 
8818
# So?  What about this header?
 
8819
case $ac_header_compiler:$ac_header_preproc in
 
8820
  yes:no )
 
8821
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
 
8822
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
8823
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
8824
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
8825
  no:yes )
 
8826
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
 
8827
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
 
8828
    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
 
8829
echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
 
8830
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
8831
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
8832
esac
 
8833
echo "$as_me:$LINENO: checking for $ac_header" >&5
 
8834
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
8835
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
8836
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
8837
else
 
8838
  eval "$as_ac_Header=$ac_header_preproc"
 
8839
fi
 
8840
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
8841
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
8842
 
 
8843
fi
 
8844
if test `eval echo '${'$as_ac_Header'}'` = yes; then
 
8845
  cat >>confdefs.h <<_ACEOF
 
8846
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
8847
_ACEOF
 
8848
 
 
8849
else
 
8850
  { { echo "$as_me:$LINENO: error: history header not found
 
8851
If you have libedit already installed, see config.log for details on the
 
8852
failure.  It is possible the compiler isn't looking in the proper directory.
 
8853
Use --without-readline to disable libedit support." >&5
 
8854
echo "$as_me: error: history header not found
 
8855
If you have libedit already installed, see config.log for details on the
 
8856
failure.  It is possible the compiler isn't looking in the proper directory.
 
8857
Use --without-readline to disable libedit support." >&2;}
 
8858
   { (exit 1); exit 1; }; }
 
8859
fi
 
8860
 
 
8861
done
 
8862
 
 
8863
fi
 
8864
 
 
8865
done
 
8866
 
 
8867
fi
 
8868
 
 
8869
done
 
8870
 
 
8871
fi
 
8872
 
 
8873
if test "$with_zlib" = yes; then
 
8874
  if test "${ac_cv_header_zlib_h+set}" = set; then
 
8875
  echo "$as_me:$LINENO: checking for zlib.h" >&5
 
8876
echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
 
8877
if test "${ac_cv_header_zlib_h+set}" = set; then
 
8878
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
8879
fi
 
8880
echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
 
8881
echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
 
8882
else
 
8883
  # Is the header compilable?
 
8884
echo "$as_me:$LINENO: checking zlib.h usability" >&5
 
8885
echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
 
8886
cat >conftest.$ac_ext <<_ACEOF
 
8887
#line $LINENO "configure"
 
8888
#include "confdefs.h"
 
8889
$ac_includes_default
 
8890
#include <zlib.h>
 
8891
_ACEOF
 
8892
rm -f conftest.$ac_objext
 
8893
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
8894
  (eval $ac_compile) 2>&5
 
8895
  ac_status=$?
 
8896
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8897
  (exit $ac_status); } &&
 
8898
         { ac_try='test -s conftest.$ac_objext'
 
8899
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
8900
  (eval $ac_try) 2>&5
 
8901
  ac_status=$?
 
8902
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8903
  (exit $ac_status); }; }; then
 
8904
  ac_header_compiler=yes
 
8905
else
 
8906
  echo "$as_me: failed program was:" >&5
 
8907
cat conftest.$ac_ext >&5
 
8908
ac_header_compiler=no
 
8909
fi
 
8910
rm -f conftest.$ac_objext conftest.$ac_ext
 
8911
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
8912
echo "${ECHO_T}$ac_header_compiler" >&6
 
8913
 
 
8914
# Is the header present?
 
8915
echo "$as_me:$LINENO: checking zlib.h presence" >&5
 
8916
echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
 
8917
cat >conftest.$ac_ext <<_ACEOF
 
8918
#line $LINENO "configure"
 
8919
#include "confdefs.h"
 
8920
#include <zlib.h>
 
8921
_ACEOF
 
8922
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
8923
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
8924
  ac_status=$?
 
8925
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
8926
  rm -f conftest.er1
 
8927
  cat conftest.err >&5
 
8928
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8929
  (exit $ac_status); } >/dev/null; then
 
8930
  if test -s conftest.err; then
 
8931
    ac_cpp_err=$ac_c_preproc_warn_flag
 
8932
  else
 
8933
    ac_cpp_err=
 
8934
  fi
 
8935
else
 
8936
  ac_cpp_err=yes
 
8937
fi
 
8938
if test -z "$ac_cpp_err"; then
 
8939
  ac_header_preproc=yes
 
8940
else
 
8941
  echo "$as_me: failed program was:" >&5
 
8942
  cat conftest.$ac_ext >&5
 
8943
  ac_header_preproc=no
 
8944
fi
 
8945
rm -f conftest.err conftest.$ac_ext
 
8946
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
8947
echo "${ECHO_T}$ac_header_preproc" >&6
 
8948
 
 
8949
# So?  What about this header?
 
8950
case $ac_header_compiler:$ac_header_preproc in
 
8951
  yes:no )
 
8952
    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
 
8953
echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
8954
    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
 
8955
echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;};;
 
8956
  no:yes )
 
8957
    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
 
8958
echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
 
8959
    { echo "$as_me:$LINENO: WARNING: zlib.h: check for missing prerequisite headers?" >&5
 
8960
echo "$as_me: WARNING: zlib.h: check for missing prerequisite headers?" >&2;}
 
8961
    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
 
8962
echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;};;
 
8963
esac
 
8964
echo "$as_me:$LINENO: checking for zlib.h" >&5
 
8965
echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
 
8966
if test "${ac_cv_header_zlib_h+set}" = set; then
 
8967
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
8968
else
 
8969
  ac_cv_header_zlib_h=$ac_header_preproc
 
8970
fi
 
8971
echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
 
8972
echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
 
8973
 
 
8974
fi
 
8975
if test $ac_cv_header_zlib_h = yes; then
 
8976
  :
 
8977
else
 
8978
  { { echo "$as_me:$LINENO: error: zlib header not found
 
8979
If you have zlib already installed, see config.log for details on the
 
8980
failure.  It is possible the compiler isn't looking in the proper directory.
 
8981
Use --without-zlib to disable zlib support." >&5
 
8982
echo "$as_me: error: zlib header not found
 
8983
If you have zlib already installed, see config.log for details on the
 
8984
failure.  It is possible the compiler isn't looking in the proper directory.
 
8985
Use --without-zlib to disable zlib support." >&2;}
 
8986
   { (exit 1); exit 1; }; }
 
8987
fi
 
8988
 
 
8989
 
 
8990
fi
 
8991
 
 
8992
if test "$with_krb4" = yes ; then
 
8993
  if test "${ac_cv_header_krb_h+set}" = set; then
 
8994
  echo "$as_me:$LINENO: checking for krb.h" >&5
 
8995
echo $ECHO_N "checking for krb.h... $ECHO_C" >&6
 
8996
if test "${ac_cv_header_krb_h+set}" = set; then
 
8997
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
8998
fi
 
8999
echo "$as_me:$LINENO: result: $ac_cv_header_krb_h" >&5
 
9000
echo "${ECHO_T}$ac_cv_header_krb_h" >&6
 
9001
else
 
9002
  # Is the header compilable?
 
9003
echo "$as_me:$LINENO: checking krb.h usability" >&5
 
9004
echo $ECHO_N "checking krb.h usability... $ECHO_C" >&6
 
9005
cat >conftest.$ac_ext <<_ACEOF
 
9006
#line $LINENO "configure"
 
9007
#include "confdefs.h"
 
9008
$ac_includes_default
 
9009
#include <krb.h>
 
9010
_ACEOF
 
9011
rm -f conftest.$ac_objext
 
9012
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
9013
  (eval $ac_compile) 2>&5
 
9014
  ac_status=$?
 
9015
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9016
  (exit $ac_status); } &&
 
9017
         { ac_try='test -s conftest.$ac_objext'
 
9018
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9019
  (eval $ac_try) 2>&5
 
9020
  ac_status=$?
 
9021
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9022
  (exit $ac_status); }; }; then
 
9023
  ac_header_compiler=yes
 
9024
else
 
9025
  echo "$as_me: failed program was:" >&5
 
9026
cat conftest.$ac_ext >&5
 
9027
ac_header_compiler=no
 
9028
fi
 
9029
rm -f conftest.$ac_objext conftest.$ac_ext
 
9030
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
9031
echo "${ECHO_T}$ac_header_compiler" >&6
 
9032
 
 
9033
# Is the header present?
 
9034
echo "$as_me:$LINENO: checking krb.h presence" >&5
 
9035
echo $ECHO_N "checking krb.h presence... $ECHO_C" >&6
 
9036
cat >conftest.$ac_ext <<_ACEOF
 
9037
#line $LINENO "configure"
 
9038
#include "confdefs.h"
 
9039
#include <krb.h>
 
9040
_ACEOF
 
9041
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
9042
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
9043
  ac_status=$?
 
9044
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
9045
  rm -f conftest.er1
 
9046
  cat conftest.err >&5
 
9047
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9048
  (exit $ac_status); } >/dev/null; then
 
9049
  if test -s conftest.err; then
 
9050
    ac_cpp_err=$ac_c_preproc_warn_flag
 
9051
  else
 
9052
    ac_cpp_err=
 
9053
  fi
 
9054
else
 
9055
  ac_cpp_err=yes
 
9056
fi
 
9057
if test -z "$ac_cpp_err"; then
 
9058
  ac_header_preproc=yes
 
9059
else
 
9060
  echo "$as_me: failed program was:" >&5
 
9061
  cat conftest.$ac_ext >&5
 
9062
  ac_header_preproc=no
 
9063
fi
 
9064
rm -f conftest.err conftest.$ac_ext
 
9065
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
9066
echo "${ECHO_T}$ac_header_preproc" >&6
 
9067
 
 
9068
# So?  What about this header?
 
9069
case $ac_header_compiler:$ac_header_preproc in
 
9070
  yes:no )
 
9071
    { echo "$as_me:$LINENO: WARNING: krb.h: accepted by the compiler, rejected by the preprocessor!" >&5
 
9072
echo "$as_me: WARNING: krb.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
9073
    { echo "$as_me:$LINENO: WARNING: krb.h: proceeding with the preprocessor's result" >&5
 
9074
echo "$as_me: WARNING: krb.h: proceeding with the preprocessor's result" >&2;};;
 
9075
  no:yes )
 
9076
    { echo "$as_me:$LINENO: WARNING: krb.h: present but cannot be compiled" >&5
 
9077
echo "$as_me: WARNING: krb.h: present but cannot be compiled" >&2;}
 
9078
    { echo "$as_me:$LINENO: WARNING: krb.h: check for missing prerequisite headers?" >&5
 
9079
echo "$as_me: WARNING: krb.h: check for missing prerequisite headers?" >&2;}
 
9080
    { echo "$as_me:$LINENO: WARNING: krb.h: proceeding with the preprocessor's result" >&5
 
9081
echo "$as_me: WARNING: krb.h: proceeding with the preprocessor's result" >&2;};;
 
9082
esac
 
9083
echo "$as_me:$LINENO: checking for krb.h" >&5
 
9084
echo $ECHO_N "checking for krb.h... $ECHO_C" >&6
 
9085
if test "${ac_cv_header_krb_h+set}" = set; then
 
9086
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9087
else
 
9088
  ac_cv_header_krb_h=$ac_header_preproc
 
9089
fi
 
9090
echo "$as_me:$LINENO: result: $ac_cv_header_krb_h" >&5
 
9091
echo "${ECHO_T}$ac_cv_header_krb_h" >&6
 
9092
 
 
9093
fi
 
9094
if test $ac_cv_header_krb_h = yes; then
 
9095
  :
 
9096
else
 
9097
  { { echo "$as_me:$LINENO: error: header file <krb.h> is required for Kerberos 4" >&5
 
9098
echo "$as_me: error: header file <krb.h> is required for Kerberos 4" >&2;}
 
9099
   { (exit 1); exit 1; }; }
 
9100
fi
 
9101
 
 
9102
 
 
9103
fi
 
9104
 
 
9105
if test "$with_krb5" = yes ; then
 
9106
  if test "${ac_cv_header_krb5_h+set}" = set; then
 
9107
  echo "$as_me:$LINENO: checking for krb5.h" >&5
 
9108
echo $ECHO_N "checking for krb5.h... $ECHO_C" >&6
 
9109
if test "${ac_cv_header_krb5_h+set}" = set; then
 
9110
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9111
fi
 
9112
echo "$as_me:$LINENO: result: $ac_cv_header_krb5_h" >&5
 
9113
echo "${ECHO_T}$ac_cv_header_krb5_h" >&6
 
9114
else
 
9115
  # Is the header compilable?
 
9116
echo "$as_me:$LINENO: checking krb5.h usability" >&5
 
9117
echo $ECHO_N "checking krb5.h usability... $ECHO_C" >&6
 
9118
cat >conftest.$ac_ext <<_ACEOF
 
9119
#line $LINENO "configure"
 
9120
#include "confdefs.h"
 
9121
$ac_includes_default
 
9122
#include <krb5.h>
 
9123
_ACEOF
 
9124
rm -f conftest.$ac_objext
 
9125
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
9126
  (eval $ac_compile) 2>&5
 
9127
  ac_status=$?
 
9128
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9129
  (exit $ac_status); } &&
 
9130
         { ac_try='test -s conftest.$ac_objext'
 
9131
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9132
  (eval $ac_try) 2>&5
 
9133
  ac_status=$?
 
9134
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9135
  (exit $ac_status); }; }; then
 
9136
  ac_header_compiler=yes
 
9137
else
 
9138
  echo "$as_me: failed program was:" >&5
 
9139
cat conftest.$ac_ext >&5
 
9140
ac_header_compiler=no
 
9141
fi
 
9142
rm -f conftest.$ac_objext conftest.$ac_ext
 
9143
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
9144
echo "${ECHO_T}$ac_header_compiler" >&6
 
9145
 
 
9146
# Is the header present?
 
9147
echo "$as_me:$LINENO: checking krb5.h presence" >&5
 
9148
echo $ECHO_N "checking krb5.h presence... $ECHO_C" >&6
 
9149
cat >conftest.$ac_ext <<_ACEOF
 
9150
#line $LINENO "configure"
 
9151
#include "confdefs.h"
 
9152
#include <krb5.h>
 
9153
_ACEOF
 
9154
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
9155
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
9156
  ac_status=$?
 
9157
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
9158
  rm -f conftest.er1
 
9159
  cat conftest.err >&5
 
9160
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9161
  (exit $ac_status); } >/dev/null; then
 
9162
  if test -s conftest.err; then
 
9163
    ac_cpp_err=$ac_c_preproc_warn_flag
 
9164
  else
 
9165
    ac_cpp_err=
 
9166
  fi
 
9167
else
 
9168
  ac_cpp_err=yes
 
9169
fi
 
9170
if test -z "$ac_cpp_err"; then
 
9171
  ac_header_preproc=yes
 
9172
else
 
9173
  echo "$as_me: failed program was:" >&5
 
9174
  cat conftest.$ac_ext >&5
 
9175
  ac_header_preproc=no
 
9176
fi
 
9177
rm -f conftest.err conftest.$ac_ext
 
9178
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
9179
echo "${ECHO_T}$ac_header_preproc" >&6
 
9180
 
 
9181
# So?  What about this header?
 
9182
case $ac_header_compiler:$ac_header_preproc in
 
9183
  yes:no )
 
9184
    { echo "$as_me:$LINENO: WARNING: krb5.h: accepted by the compiler, rejected by the preprocessor!" >&5
 
9185
echo "$as_me: WARNING: krb5.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
9186
    { echo "$as_me:$LINENO: WARNING: krb5.h: proceeding with the preprocessor's result" >&5
 
9187
echo "$as_me: WARNING: krb5.h: proceeding with the preprocessor's result" >&2;};;
 
9188
  no:yes )
 
9189
    { echo "$as_me:$LINENO: WARNING: krb5.h: present but cannot be compiled" >&5
 
9190
echo "$as_me: WARNING: krb5.h: present but cannot be compiled" >&2;}
 
9191
    { echo "$as_me:$LINENO: WARNING: krb5.h: check for missing prerequisite headers?" >&5
 
9192
echo "$as_me: WARNING: krb5.h: check for missing prerequisite headers?" >&2;}
 
9193
    { echo "$as_me:$LINENO: WARNING: krb5.h: proceeding with the preprocessor's result" >&5
 
9194
echo "$as_me: WARNING: krb5.h: proceeding with the preprocessor's result" >&2;};;
 
9195
esac
 
9196
echo "$as_me:$LINENO: checking for krb5.h" >&5
 
9197
echo $ECHO_N "checking for krb5.h... $ECHO_C" >&6
 
9198
if test "${ac_cv_header_krb5_h+set}" = set; then
 
9199
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9200
else
 
9201
  ac_cv_header_krb5_h=$ac_header_preproc
 
9202
fi
 
9203
echo "$as_me:$LINENO: result: $ac_cv_header_krb5_h" >&5
 
9204
echo "${ECHO_T}$ac_cv_header_krb5_h" >&6
 
9205
 
 
9206
fi
 
9207
if test $ac_cv_header_krb5_h = yes; then
 
9208
  :
 
9209
else
 
9210
  { { echo "$as_me:$LINENO: error: header file <krb5.h> is required for Kerberos 5" >&5
 
9211
echo "$as_me: error: header file <krb5.h> is required for Kerberos 5" >&2;}
 
9212
   { (exit 1); exit 1; }; }
 
9213
fi
 
9214
 
 
9215
 
 
9216
fi
 
9217
 
 
9218
if test "$with_openssl" = yes ; then
 
9219
  if test "${ac_cv_header_openssl_ssl_h+set}" = set; then
 
9220
  echo "$as_me:$LINENO: checking for openssl/ssl.h" >&5
 
9221
echo $ECHO_N "checking for openssl/ssl.h... $ECHO_C" >&6
 
9222
if test "${ac_cv_header_openssl_ssl_h+set}" = set; then
 
9223
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9224
fi
 
9225
echo "$as_me:$LINENO: result: $ac_cv_header_openssl_ssl_h" >&5
 
9226
echo "${ECHO_T}$ac_cv_header_openssl_ssl_h" >&6
 
9227
else
 
9228
  # Is the header compilable?
 
9229
echo "$as_me:$LINENO: checking openssl/ssl.h usability" >&5
 
9230
echo $ECHO_N "checking openssl/ssl.h usability... $ECHO_C" >&6
 
9231
cat >conftest.$ac_ext <<_ACEOF
 
9232
#line $LINENO "configure"
 
9233
#include "confdefs.h"
 
9234
$ac_includes_default
 
9235
#include <openssl/ssl.h>
 
9236
_ACEOF
 
9237
rm -f conftest.$ac_objext
 
9238
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
9239
  (eval $ac_compile) 2>&5
 
9240
  ac_status=$?
 
9241
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9242
  (exit $ac_status); } &&
 
9243
         { ac_try='test -s conftest.$ac_objext'
 
9244
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9245
  (eval $ac_try) 2>&5
 
9246
  ac_status=$?
 
9247
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9248
  (exit $ac_status); }; }; then
 
9249
  ac_header_compiler=yes
 
9250
else
 
9251
  echo "$as_me: failed program was:" >&5
 
9252
cat conftest.$ac_ext >&5
 
9253
ac_header_compiler=no
 
9254
fi
 
9255
rm -f conftest.$ac_objext conftest.$ac_ext
 
9256
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
9257
echo "${ECHO_T}$ac_header_compiler" >&6
 
9258
 
 
9259
# Is the header present?
 
9260
echo "$as_me:$LINENO: checking openssl/ssl.h presence" >&5
 
9261
echo $ECHO_N "checking openssl/ssl.h presence... $ECHO_C" >&6
 
9262
cat >conftest.$ac_ext <<_ACEOF
 
9263
#line $LINENO "configure"
 
9264
#include "confdefs.h"
 
9265
#include <openssl/ssl.h>
 
9266
_ACEOF
 
9267
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
9268
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
9269
  ac_status=$?
 
9270
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
9271
  rm -f conftest.er1
 
9272
  cat conftest.err >&5
 
9273
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9274
  (exit $ac_status); } >/dev/null; then
 
9275
  if test -s conftest.err; then
 
9276
    ac_cpp_err=$ac_c_preproc_warn_flag
 
9277
  else
 
9278
    ac_cpp_err=
 
9279
  fi
 
9280
else
 
9281
  ac_cpp_err=yes
 
9282
fi
 
9283
if test -z "$ac_cpp_err"; then
 
9284
  ac_header_preproc=yes
 
9285
else
 
9286
  echo "$as_me: failed program was:" >&5
 
9287
  cat conftest.$ac_ext >&5
 
9288
  ac_header_preproc=no
 
9289
fi
 
9290
rm -f conftest.err conftest.$ac_ext
 
9291
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
9292
echo "${ECHO_T}$ac_header_preproc" >&6
 
9293
 
 
9294
# So?  What about this header?
 
9295
case $ac_header_compiler:$ac_header_preproc in
 
9296
  yes:no )
 
9297
    { echo "$as_me:$LINENO: WARNING: openssl/ssl.h: accepted by the compiler, rejected by the preprocessor!" >&5
 
9298
echo "$as_me: WARNING: openssl/ssl.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
9299
    { echo "$as_me:$LINENO: WARNING: openssl/ssl.h: proceeding with the preprocessor's result" >&5
 
9300
echo "$as_me: WARNING: openssl/ssl.h: proceeding with the preprocessor's result" >&2;};;
 
9301
  no:yes )
 
9302
    { echo "$as_me:$LINENO: WARNING: openssl/ssl.h: present but cannot be compiled" >&5
 
9303
echo "$as_me: WARNING: openssl/ssl.h: present but cannot be compiled" >&2;}
 
9304
    { echo "$as_me:$LINENO: WARNING: openssl/ssl.h: check for missing prerequisite headers?" >&5
 
9305
echo "$as_me: WARNING: openssl/ssl.h: check for missing prerequisite headers?" >&2;}
 
9306
    { echo "$as_me:$LINENO: WARNING: openssl/ssl.h: proceeding with the preprocessor's result" >&5
 
9307
echo "$as_me: WARNING: openssl/ssl.h: proceeding with the preprocessor's result" >&2;};;
 
9308
esac
 
9309
echo "$as_me:$LINENO: checking for openssl/ssl.h" >&5
 
9310
echo $ECHO_N "checking for openssl/ssl.h... $ECHO_C" >&6
 
9311
if test "${ac_cv_header_openssl_ssl_h+set}" = set; then
 
9312
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9313
else
 
9314
  ac_cv_header_openssl_ssl_h=$ac_header_preproc
 
9315
fi
 
9316
echo "$as_me:$LINENO: result: $ac_cv_header_openssl_ssl_h" >&5
 
9317
echo "${ECHO_T}$ac_cv_header_openssl_ssl_h" >&6
 
9318
 
 
9319
fi
 
9320
if test $ac_cv_header_openssl_ssl_h = yes; then
 
9321
  :
 
9322
else
 
9323
  { { echo "$as_me:$LINENO: error: header file <openssl/ssl.h> is required for OpenSSL" >&5
 
9324
echo "$as_me: error: header file <openssl/ssl.h> is required for OpenSSL" >&2;}
 
9325
   { (exit 1); exit 1; }; }
 
9326
fi
 
9327
 
 
9328
 
 
9329
  if test "${ac_cv_header_openssl_err_h+set}" = set; then
 
9330
  echo "$as_me:$LINENO: checking for openssl/err.h" >&5
 
9331
echo $ECHO_N "checking for openssl/err.h... $ECHO_C" >&6
 
9332
if test "${ac_cv_header_openssl_err_h+set}" = set; then
 
9333
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9334
fi
 
9335
echo "$as_me:$LINENO: result: $ac_cv_header_openssl_err_h" >&5
 
9336
echo "${ECHO_T}$ac_cv_header_openssl_err_h" >&6
 
9337
else
 
9338
  # Is the header compilable?
 
9339
echo "$as_me:$LINENO: checking openssl/err.h usability" >&5
 
9340
echo $ECHO_N "checking openssl/err.h usability... $ECHO_C" >&6
 
9341
cat >conftest.$ac_ext <<_ACEOF
 
9342
#line $LINENO "configure"
 
9343
#include "confdefs.h"
 
9344
$ac_includes_default
 
9345
#include <openssl/err.h>
 
9346
_ACEOF
 
9347
rm -f conftest.$ac_objext
 
9348
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
9349
  (eval $ac_compile) 2>&5
 
9350
  ac_status=$?
 
9351
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9352
  (exit $ac_status); } &&
 
9353
         { ac_try='test -s conftest.$ac_objext'
 
9354
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9355
  (eval $ac_try) 2>&5
 
9356
  ac_status=$?
 
9357
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9358
  (exit $ac_status); }; }; then
 
9359
  ac_header_compiler=yes
 
9360
else
 
9361
  echo "$as_me: failed program was:" >&5
 
9362
cat conftest.$ac_ext >&5
 
9363
ac_header_compiler=no
 
9364
fi
 
9365
rm -f conftest.$ac_objext conftest.$ac_ext
 
9366
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
9367
echo "${ECHO_T}$ac_header_compiler" >&6
 
9368
 
 
9369
# Is the header present?
 
9370
echo "$as_me:$LINENO: checking openssl/err.h presence" >&5
 
9371
echo $ECHO_N "checking openssl/err.h presence... $ECHO_C" >&6
 
9372
cat >conftest.$ac_ext <<_ACEOF
 
9373
#line $LINENO "configure"
 
9374
#include "confdefs.h"
 
9375
#include <openssl/err.h>
 
9376
_ACEOF
 
9377
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
9378
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
9379
  ac_status=$?
 
9380
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
9381
  rm -f conftest.er1
 
9382
  cat conftest.err >&5
 
9383
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9384
  (exit $ac_status); } >/dev/null; then
 
9385
  if test -s conftest.err; then
 
9386
    ac_cpp_err=$ac_c_preproc_warn_flag
 
9387
  else
 
9388
    ac_cpp_err=
 
9389
  fi
 
9390
else
 
9391
  ac_cpp_err=yes
 
9392
fi
 
9393
if test -z "$ac_cpp_err"; then
 
9394
  ac_header_preproc=yes
 
9395
else
 
9396
  echo "$as_me: failed program was:" >&5
 
9397
  cat conftest.$ac_ext >&5
 
9398
  ac_header_preproc=no
 
9399
fi
 
9400
rm -f conftest.err conftest.$ac_ext
 
9401
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
9402
echo "${ECHO_T}$ac_header_preproc" >&6
 
9403
 
 
9404
# So?  What about this header?
 
9405
case $ac_header_compiler:$ac_header_preproc in
 
9406
  yes:no )
 
9407
    { echo "$as_me:$LINENO: WARNING: openssl/err.h: accepted by the compiler, rejected by the preprocessor!" >&5
 
9408
echo "$as_me: WARNING: openssl/err.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
9409
    { echo "$as_me:$LINENO: WARNING: openssl/err.h: proceeding with the preprocessor's result" >&5
 
9410
echo "$as_me: WARNING: openssl/err.h: proceeding with the preprocessor's result" >&2;};;
 
9411
  no:yes )
 
9412
    { echo "$as_me:$LINENO: WARNING: openssl/err.h: present but cannot be compiled" >&5
 
9413
echo "$as_me: WARNING: openssl/err.h: present but cannot be compiled" >&2;}
 
9414
    { echo "$as_me:$LINENO: WARNING: openssl/err.h: check for missing prerequisite headers?" >&5
 
9415
echo "$as_me: WARNING: openssl/err.h: check for missing prerequisite headers?" >&2;}
 
9416
    { echo "$as_me:$LINENO: WARNING: openssl/err.h: proceeding with the preprocessor's result" >&5
 
9417
echo "$as_me: WARNING: openssl/err.h: proceeding with the preprocessor's result" >&2;};;
 
9418
esac
 
9419
echo "$as_me:$LINENO: checking for openssl/err.h" >&5
 
9420
echo $ECHO_N "checking for openssl/err.h... $ECHO_C" >&6
 
9421
if test "${ac_cv_header_openssl_err_h+set}" = set; then
 
9422
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9423
else
 
9424
  ac_cv_header_openssl_err_h=$ac_header_preproc
 
9425
fi
 
9426
echo "$as_me:$LINENO: result: $ac_cv_header_openssl_err_h" >&5
 
9427
echo "${ECHO_T}$ac_cv_header_openssl_err_h" >&6
 
9428
 
 
9429
fi
 
9430
if test $ac_cv_header_openssl_err_h = yes; then
 
9431
  :
 
9432
else
 
9433
  { { echo "$as_me:$LINENO: error: header file <openssl/err.h> is required for OpenSSL" >&5
 
9434
echo "$as_me: error: header file <openssl/err.h> is required for OpenSSL" >&2;}
 
9435
   { (exit 1); exit 1; }; }
 
9436
fi
 
9437
 
 
9438
 
 
9439
fi
 
9440
 
 
9441
if test "$with_pam" = yes ; then
 
9442
 
 
9443
for ac_header in security/pam_appl.h
 
9444
do
 
9445
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
9446
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
9447
  echo "$as_me:$LINENO: checking for $ac_header" >&5
 
9448
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
9449
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
9450
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9451
fi
 
9452
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
9453
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
9454
else
 
9455
  # Is the header compilable?
 
9456
echo "$as_me:$LINENO: checking $ac_header usability" >&5
 
9457
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
 
9458
cat >conftest.$ac_ext <<_ACEOF
 
9459
#line $LINENO "configure"
 
9460
#include "confdefs.h"
 
9461
$ac_includes_default
 
9462
#include <$ac_header>
 
9463
_ACEOF
 
9464
rm -f conftest.$ac_objext
 
9465
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
9466
  (eval $ac_compile) 2>&5
 
9467
  ac_status=$?
 
9468
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9469
  (exit $ac_status); } &&
 
9470
         { ac_try='test -s conftest.$ac_objext'
 
9471
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9472
  (eval $ac_try) 2>&5
 
9473
  ac_status=$?
 
9474
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9475
  (exit $ac_status); }; }; then
 
9476
  ac_header_compiler=yes
 
9477
else
 
9478
  echo "$as_me: failed program was:" >&5
 
9479
cat conftest.$ac_ext >&5
 
9480
ac_header_compiler=no
 
9481
fi
 
9482
rm -f conftest.$ac_objext conftest.$ac_ext
 
9483
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
9484
echo "${ECHO_T}$ac_header_compiler" >&6
 
9485
 
 
9486
# Is the header present?
 
9487
echo "$as_me:$LINENO: checking $ac_header presence" >&5
 
9488
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
 
9489
cat >conftest.$ac_ext <<_ACEOF
 
9490
#line $LINENO "configure"
 
9491
#include "confdefs.h"
 
9492
#include <$ac_header>
 
9493
_ACEOF
 
9494
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
9495
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
9496
  ac_status=$?
 
9497
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
9498
  rm -f conftest.er1
 
9499
  cat conftest.err >&5
 
9500
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9501
  (exit $ac_status); } >/dev/null; then
 
9502
  if test -s conftest.err; then
 
9503
    ac_cpp_err=$ac_c_preproc_warn_flag
 
9504
  else
 
9505
    ac_cpp_err=
 
9506
  fi
 
9507
else
 
9508
  ac_cpp_err=yes
 
9509
fi
 
9510
if test -z "$ac_cpp_err"; then
 
9511
  ac_header_preproc=yes
 
9512
else
 
9513
  echo "$as_me: failed program was:" >&5
 
9514
  cat conftest.$ac_ext >&5
 
9515
  ac_header_preproc=no
 
9516
fi
 
9517
rm -f conftest.err conftest.$ac_ext
 
9518
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
9519
echo "${ECHO_T}$ac_header_preproc" >&6
 
9520
 
 
9521
# So?  What about this header?
 
9522
case $ac_header_compiler:$ac_header_preproc in
 
9523
  yes:no )
 
9524
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
 
9525
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
9526
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
9527
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
9528
  no:yes )
 
9529
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
 
9530
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
 
9531
    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
 
9532
echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
 
9533
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
9534
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
9535
esac
 
9536
echo "$as_me:$LINENO: checking for $ac_header" >&5
 
9537
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
9538
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
9539
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9540
else
 
9541
  eval "$as_ac_Header=$ac_header_preproc"
 
9542
fi
 
9543
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
9544
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
9545
 
 
9546
fi
 
9547
if test `eval echo '${'$as_ac_Header'}'` = yes; then
 
9548
  cat >>confdefs.h <<_ACEOF
 
9549
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
9550
_ACEOF
 
9551
 
 
9552
else
 
9553
 
 
9554
for ac_header in pam/pam_appl.h
 
9555
do
 
9556
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
9557
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
9558
  echo "$as_me:$LINENO: checking for $ac_header" >&5
 
9559
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
9560
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
9561
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9562
fi
 
9563
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
9564
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
9565
else
 
9566
  # Is the header compilable?
 
9567
echo "$as_me:$LINENO: checking $ac_header usability" >&5
 
9568
echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
 
9569
cat >conftest.$ac_ext <<_ACEOF
 
9570
#line $LINENO "configure"
 
9571
#include "confdefs.h"
 
9572
$ac_includes_default
 
9573
#include <$ac_header>
 
9574
_ACEOF
 
9575
rm -f conftest.$ac_objext
 
9576
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
9577
  (eval $ac_compile) 2>&5
 
9578
  ac_status=$?
 
9579
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9580
  (exit $ac_status); } &&
 
9581
         { ac_try='test -s conftest.$ac_objext'
 
9582
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9583
  (eval $ac_try) 2>&5
 
9584
  ac_status=$?
 
9585
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9586
  (exit $ac_status); }; }; then
 
9587
  ac_header_compiler=yes
 
9588
else
 
9589
  echo "$as_me: failed program was:" >&5
 
9590
cat conftest.$ac_ext >&5
 
9591
ac_header_compiler=no
 
9592
fi
 
9593
rm -f conftest.$ac_objext conftest.$ac_ext
 
9594
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
9595
echo "${ECHO_T}$ac_header_compiler" >&6
 
9596
 
 
9597
# Is the header present?
 
9598
echo "$as_me:$LINENO: checking $ac_header presence" >&5
 
9599
echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
 
9600
cat >conftest.$ac_ext <<_ACEOF
 
9601
#line $LINENO "configure"
 
9602
#include "confdefs.h"
 
9603
#include <$ac_header>
 
9604
_ACEOF
 
9605
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
9606
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
9607
  ac_status=$?
 
9608
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
9609
  rm -f conftest.er1
 
9610
  cat conftest.err >&5
 
9611
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9612
  (exit $ac_status); } >/dev/null; then
 
9613
  if test -s conftest.err; then
 
9614
    ac_cpp_err=$ac_c_preproc_warn_flag
 
9615
  else
 
9616
    ac_cpp_err=
 
9617
  fi
 
9618
else
 
9619
  ac_cpp_err=yes
 
9620
fi
 
9621
if test -z "$ac_cpp_err"; then
 
9622
  ac_header_preproc=yes
 
9623
else
 
9624
  echo "$as_me: failed program was:" >&5
 
9625
  cat conftest.$ac_ext >&5
 
9626
  ac_header_preproc=no
 
9627
fi
 
9628
rm -f conftest.err conftest.$ac_ext
 
9629
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
9630
echo "${ECHO_T}$ac_header_preproc" >&6
 
9631
 
 
9632
# So?  What about this header?
 
9633
case $ac_header_compiler:$ac_header_preproc in
 
9634
  yes:no )
 
9635
    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
 
9636
echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
9637
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
9638
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
9639
  no:yes )
 
9640
    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
 
9641
echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
 
9642
    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
 
9643
echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
 
9644
    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
9645
echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
 
9646
esac
 
9647
echo "$as_me:$LINENO: checking for $ac_header" >&5
 
9648
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
9649
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
9650
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9651
else
 
9652
  eval "$as_ac_Header=$ac_header_preproc"
 
9653
fi
 
9654
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
9655
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
9656
 
 
9657
fi
 
9658
if test `eval echo '${'$as_ac_Header'}'` = yes; then
 
9659
  cat >>confdefs.h <<_ACEOF
 
9660
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
9661
_ACEOF
 
9662
 
 
9663
else
 
9664
  { { echo "$as_me:$LINENO: error: header file <security/pam_appl.h> or <pam/pam_appl.h> is required for PAM." >&5
 
9665
echo "$as_me: error: header file <security/pam_appl.h> or <pam/pam_appl.h> is required for PAM." >&2;}
 
9666
   { (exit 1); exit 1; }; }
 
9667
fi
 
9668
 
 
9669
done
 
9670
 
 
9671
fi
 
9672
 
 
9673
done
 
9674
 
 
9675
fi
 
9676
 
 
9677
if test "$with_rendezvous" = yes ; then
 
9678
  if test "${ac_cv_header_DNSServiceDiscovery_DNSServiceDiscovery_h+set}" = set; then
 
9679
  echo "$as_me:$LINENO: checking for DNSServiceDiscovery/DNSServiceDiscovery.h" >&5
 
9680
echo $ECHO_N "checking for DNSServiceDiscovery/DNSServiceDiscovery.h... $ECHO_C" >&6
 
9681
if test "${ac_cv_header_DNSServiceDiscovery_DNSServiceDiscovery_h+set}" = set; then
 
9682
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9683
fi
 
9684
echo "$as_me:$LINENO: result: $ac_cv_header_DNSServiceDiscovery_DNSServiceDiscovery_h" >&5
 
9685
echo "${ECHO_T}$ac_cv_header_DNSServiceDiscovery_DNSServiceDiscovery_h" >&6
 
9686
else
 
9687
  # Is the header compilable?
 
9688
echo "$as_me:$LINENO: checking DNSServiceDiscovery/DNSServiceDiscovery.h usability" >&5
 
9689
echo $ECHO_N "checking DNSServiceDiscovery/DNSServiceDiscovery.h usability... $ECHO_C" >&6
 
9690
cat >conftest.$ac_ext <<_ACEOF
 
9691
#line $LINENO "configure"
 
9692
#include "confdefs.h"
 
9693
$ac_includes_default
 
9694
#include <DNSServiceDiscovery/DNSServiceDiscovery.h>
 
9695
_ACEOF
 
9696
rm -f conftest.$ac_objext
 
9697
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
9698
  (eval $ac_compile) 2>&5
 
9699
  ac_status=$?
 
9700
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9701
  (exit $ac_status); } &&
 
9702
         { ac_try='test -s conftest.$ac_objext'
 
9703
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9704
  (eval $ac_try) 2>&5
 
9705
  ac_status=$?
 
9706
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9707
  (exit $ac_status); }; }; then
 
9708
  ac_header_compiler=yes
 
9709
else
 
9710
  echo "$as_me: failed program was:" >&5
 
9711
cat conftest.$ac_ext >&5
 
9712
ac_header_compiler=no
 
9713
fi
 
9714
rm -f conftest.$ac_objext conftest.$ac_ext
 
9715
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
9716
echo "${ECHO_T}$ac_header_compiler" >&6
 
9717
 
 
9718
# Is the header present?
 
9719
echo "$as_me:$LINENO: checking DNSServiceDiscovery/DNSServiceDiscovery.h presence" >&5
 
9720
echo $ECHO_N "checking DNSServiceDiscovery/DNSServiceDiscovery.h presence... $ECHO_C" >&6
 
9721
cat >conftest.$ac_ext <<_ACEOF
 
9722
#line $LINENO "configure"
 
9723
#include "confdefs.h"
 
9724
#include <DNSServiceDiscovery/DNSServiceDiscovery.h>
 
9725
_ACEOF
 
9726
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
9727
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
9728
  ac_status=$?
 
9729
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
9730
  rm -f conftest.er1
 
9731
  cat conftest.err >&5
 
9732
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9733
  (exit $ac_status); } >/dev/null; then
 
9734
  if test -s conftest.err; then
 
9735
    ac_cpp_err=$ac_c_preproc_warn_flag
 
9736
  else
 
9737
    ac_cpp_err=
 
9738
  fi
 
9739
else
 
9740
  ac_cpp_err=yes
 
9741
fi
 
9742
if test -z "$ac_cpp_err"; then
 
9743
  ac_header_preproc=yes
 
9744
else
 
9745
  echo "$as_me: failed program was:" >&5
 
9746
  cat conftest.$ac_ext >&5
 
9747
  ac_header_preproc=no
 
9748
fi
 
9749
rm -f conftest.err conftest.$ac_ext
 
9750
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
9751
echo "${ECHO_T}$ac_header_preproc" >&6
 
9752
 
 
9753
# So?  What about this header?
 
9754
case $ac_header_compiler:$ac_header_preproc in
 
9755
  yes:no )
 
9756
    { echo "$as_me:$LINENO: WARNING: DNSServiceDiscovery/DNSServiceDiscovery.h: accepted by the compiler, rejected by the preprocessor!" >&5
 
9757
echo "$as_me: WARNING: DNSServiceDiscovery/DNSServiceDiscovery.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
9758
    { echo "$as_me:$LINENO: WARNING: DNSServiceDiscovery/DNSServiceDiscovery.h: proceeding with the preprocessor's result" >&5
 
9759
echo "$as_me: WARNING: DNSServiceDiscovery/DNSServiceDiscovery.h: proceeding with the preprocessor's result" >&2;};;
 
9760
  no:yes )
 
9761
    { echo "$as_me:$LINENO: WARNING: DNSServiceDiscovery/DNSServiceDiscovery.h: present but cannot be compiled" >&5
 
9762
echo "$as_me: WARNING: DNSServiceDiscovery/DNSServiceDiscovery.h: present but cannot be compiled" >&2;}
 
9763
    { echo "$as_me:$LINENO: WARNING: DNSServiceDiscovery/DNSServiceDiscovery.h: check for missing prerequisite headers?" >&5
 
9764
echo "$as_me: WARNING: DNSServiceDiscovery/DNSServiceDiscovery.h: check for missing prerequisite headers?" >&2;}
 
9765
    { echo "$as_me:$LINENO: WARNING: DNSServiceDiscovery/DNSServiceDiscovery.h: proceeding with the preprocessor's result" >&5
 
9766
echo "$as_me: WARNING: DNSServiceDiscovery/DNSServiceDiscovery.h: proceeding with the preprocessor's result" >&2;};;
 
9767
esac
 
9768
echo "$as_me:$LINENO: checking for DNSServiceDiscovery/DNSServiceDiscovery.h" >&5
 
9769
echo $ECHO_N "checking for DNSServiceDiscovery/DNSServiceDiscovery.h... $ECHO_C" >&6
 
9770
if test "${ac_cv_header_DNSServiceDiscovery_DNSServiceDiscovery_h+set}" = set; then
 
9771
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9772
else
 
9773
  ac_cv_header_DNSServiceDiscovery_DNSServiceDiscovery_h=$ac_header_preproc
 
9774
fi
 
9775
echo "$as_me:$LINENO: result: $ac_cv_header_DNSServiceDiscovery_DNSServiceDiscovery_h" >&5
 
9776
echo "${ECHO_T}$ac_cv_header_DNSServiceDiscovery_DNSServiceDiscovery_h" >&6
 
9777
 
 
9778
fi
 
9779
if test $ac_cv_header_DNSServiceDiscovery_DNSServiceDiscovery_h = yes; then
 
9780
  :
 
9781
else
 
9782
  { { echo "$as_me:$LINENO: error: header file <DNSServiceDiscovery/DNSServiceDiscovery.h> is required for Rendezvous" >&5
 
9783
echo "$as_me: error: header file <DNSServiceDiscovery/DNSServiceDiscovery.h> is required for Rendezvous" >&2;}
 
9784
   { (exit 1); exit 1; }; }
 
9785
fi
 
9786
 
 
9787
 
 
9788
fi
 
9789
 
 
9790
 
 
9791
##
 
9792
## Types, structures, compiler characteristics
 
9793
##
 
9794
 
 
9795
 
 
9796
echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
 
9797
echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
 
9798
if test "${ac_cv_c_const+set}" = set; then
 
9799
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9800
else
 
9801
  cat >conftest.$ac_ext <<_ACEOF
 
9802
#line $LINENO "configure"
 
9803
#include "confdefs.h"
 
9804
 
 
9805
#ifdef F77_DUMMY_MAIN
 
9806
#  ifdef __cplusplus
 
9807
     extern "C"
 
9808
#  endif
 
9809
   int F77_DUMMY_MAIN() { return 1; }
 
9810
#endif
 
9811
int
 
9812
main ()
 
9813
{
 
9814
/* FIXME: Include the comments suggested by Paul. */
 
9815
#ifndef __cplusplus
 
9816
  /* Ultrix mips cc rejects this.  */
 
9817
  typedef int charset[2];
 
9818
  const charset x;
 
9819
  /* SunOS 4.1.1 cc rejects this.  */
 
9820
  char const *const *ccp;
 
9821
  char **p;
 
9822
  /* NEC SVR4.0.2 mips cc rejects this.  */
 
9823
  struct point {int x, y;};
 
9824
  static struct point const zero = {0,0};
 
9825
  /* AIX XL C 1.02.0.0 rejects this.
 
9826
     It does not let you subtract one const X* pointer from another in
 
9827
     an arm of an if-expression whose if-part is not a constant
 
9828
     expression */
 
9829
  const char *g = "string";
 
9830
  ccp = &g + (g ? g-g : 0);
 
9831
  /* HPUX 7.0 cc rejects these. */
 
9832
  ++ccp;
 
9833
  p = (char**) ccp;
 
9834
  ccp = (char const *const *) p;
 
9835
  { /* SCO 3.2v4 cc rejects this.  */
 
9836
    char *t;
 
9837
    char const *s = 0 ? (char *) 0 : (char const *) 0;
 
9838
 
 
9839
    *t++ = 0;
 
9840
  }
 
9841
  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
 
9842
    int x[] = {25, 17};
 
9843
    const int *foo = &x[0];
 
9844
    ++foo;
 
9845
  }
 
9846
  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
 
9847
    typedef const int *iptr;
 
9848
    iptr p = 0;
 
9849
    ++p;
 
9850
  }
 
9851
  { /* AIX XL C 1.02.0.0 rejects this saying
 
9852
       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
 
9853
    struct s { int j; const int *ap[3]; };
 
9854
    struct s *b; b->j = 5;
 
9855
  }
 
9856
  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
 
9857
    const int foo = 10;
 
9858
  }
 
9859
#endif
 
9860
 
 
9861
  ;
 
9862
  return 0;
 
9863
}
 
9864
_ACEOF
 
9865
rm -f conftest.$ac_objext
 
9866
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
9867
  (eval $ac_compile) 2>&5
 
9868
  ac_status=$?
 
9869
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9870
  (exit $ac_status); } &&
 
9871
         { ac_try='test -s conftest.$ac_objext'
 
9872
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9873
  (eval $ac_try) 2>&5
 
9874
  ac_status=$?
 
9875
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9876
  (exit $ac_status); }; }; then
 
9877
  ac_cv_c_const=yes
 
9878
else
 
9879
  echo "$as_me: failed program was:" >&5
 
9880
cat conftest.$ac_ext >&5
 
9881
ac_cv_c_const=no
 
9882
fi
 
9883
rm -f conftest.$ac_objext conftest.$ac_ext
 
9884
fi
 
9885
echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
 
9886
echo "${ECHO_T}$ac_cv_c_const" >&6
 
9887
if test $ac_cv_c_const = no; then
 
9888
 
 
9889
cat >>confdefs.h <<\_ACEOF
 
9890
#define const
 
9891
_ACEOF
 
9892
 
 
9893
fi
 
9894
 
 
9895
echo "$as_me:$LINENO: checking for inline" >&5
 
9896
echo $ECHO_N "checking for inline... $ECHO_C" >&6
 
9897
if test "${ac_cv_c_inline+set}" = set; then
 
9898
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9899
else
 
9900
  ac_cv_c_inline=no
 
9901
for ac_kw in inline __inline__ __inline; do
 
9902
  cat >conftest.$ac_ext <<_ACEOF
 
9903
#line $LINENO "configure"
 
9904
#include "confdefs.h"
 
9905
#ifndef __cplusplus
 
9906
typedef int foo_t;
 
9907
static $ac_kw foo_t static_foo () {return 0; }
 
9908
$ac_kw int foo () {return 0; }
 
9909
#endif
 
9910
 
 
9911
_ACEOF
 
9912
rm -f conftest.$ac_objext
 
9913
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
9914
  (eval $ac_compile) 2>&5
 
9915
  ac_status=$?
 
9916
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9917
  (exit $ac_status); } &&
 
9918
         { ac_try='test -s conftest.$ac_objext'
 
9919
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9920
  (eval $ac_try) 2>&5
 
9921
  ac_status=$?
 
9922
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9923
  (exit $ac_status); }; }; then
 
9924
  ac_cv_c_inline=$ac_kw; break
 
9925
else
 
9926
  echo "$as_me: failed program was:" >&5
 
9927
cat conftest.$ac_ext >&5
 
9928
fi
 
9929
rm -f conftest.$ac_objext conftest.$ac_ext
 
9930
done
 
9931
 
 
9932
fi
 
9933
echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
 
9934
echo "${ECHO_T}$ac_cv_c_inline" >&6
 
9935
case $ac_cv_c_inline in
 
9936
  inline | yes) ;;
 
9937
  no)
 
9938
cat >>confdefs.h <<\_ACEOF
 
9939
#define inline
 
9940
_ACEOF
 
9941
 ;;
 
9942
  *)  cat >>confdefs.h <<_ACEOF
 
9943
#define inline $ac_cv_c_inline
 
9944
_ACEOF
 
9945
 ;;
 
9946
esac
 
9947
 
 
9948
echo "$as_me:$LINENO: checking for preprocessor stringizing operator" >&5
 
9949
echo $ECHO_N "checking for preprocessor stringizing operator... $ECHO_C" >&6
 
9950
if test "${ac_cv_c_stringize+set}" = set; then
 
9951
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9952
else
 
9953
  cat >conftest.$ac_ext <<_ACEOF
 
9954
#line $LINENO "configure"
 
9955
#include "confdefs.h"
 
9956
#define x(y) #y
 
9957
 
 
9958
char *s = x(teststring);
 
9959
_ACEOF
 
9960
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
 
9961
  egrep "#teststring" >/dev/null 2>&1; then
 
9962
  ac_cv_c_stringize=no
 
9963
else
 
9964
  ac_cv_c_stringize=yes
 
9965
fi
 
9966
rm -f conftest*
 
9967
 
 
9968
fi
 
9969
echo "$as_me:$LINENO: result: $ac_cv_c_stringize" >&5
 
9970
echo "${ECHO_T}$ac_cv_c_stringize" >&6
 
9971
if test $ac_cv_c_stringize = yes; then
 
9972
 
 
9973
cat >>confdefs.h <<\_ACEOF
 
9974
#define HAVE_STRINGIZE 1
 
9975
_ACEOF
 
9976
 
 
9977
fi
 
9978
 
 
9979
echo "$as_me:$LINENO: checking for signed types" >&5
 
9980
echo $ECHO_N "checking for signed types... $ECHO_C" >&6
 
9981
if test "${pgac_cv_c_signed+set}" = set; then
 
9982
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9983
else
 
9984
  cat >conftest.$ac_ext <<_ACEOF
 
9985
#line $LINENO "configure"
 
9986
#include "confdefs.h"
 
9987
 
 
9988
#ifdef F77_DUMMY_MAIN
 
9989
#  ifdef __cplusplus
 
9990
     extern "C"
 
9991
#  endif
 
9992
   int F77_DUMMY_MAIN() { return 1; }
 
9993
#endif
 
9994
int
 
9995
main ()
 
9996
{
 
9997
signed char c; signed short s; signed int i;
 
9998
  ;
 
9999
  return 0;
 
10000
}
 
10001
_ACEOF
 
10002
rm -f conftest.$ac_objext
 
10003
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
10004
  (eval $ac_compile) 2>&5
 
10005
  ac_status=$?
 
10006
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10007
  (exit $ac_status); } &&
 
10008
         { ac_try='test -s conftest.$ac_objext'
 
10009
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
10010
  (eval $ac_try) 2>&5
 
10011
  ac_status=$?
 
10012
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10013
  (exit $ac_status); }; }; then
 
10014
  pgac_cv_c_signed=yes
 
10015
else
 
10016
  echo "$as_me: failed program was:" >&5
 
10017
cat conftest.$ac_ext >&5
 
10018
pgac_cv_c_signed=no
 
10019
fi
 
10020
rm -f conftest.$ac_objext conftest.$ac_ext
 
10021
fi
 
10022
echo "$as_me:$LINENO: result: $pgac_cv_c_signed" >&5
 
10023
echo "${ECHO_T}$pgac_cv_c_signed" >&6
 
10024
if test x"$pgac_cv_c_signed" = xno ; then
 
10025
 
 
10026
cat >>confdefs.h <<\_ACEOF
 
10027
#define signed
 
10028
_ACEOF
 
10029
 
 
10030
fi
 
10031
echo "$as_me:$LINENO: checking for working volatile" >&5
 
10032
echo $ECHO_N "checking for working volatile... $ECHO_C" >&6
 
10033
if test "${ac_cv_c_volatile+set}" = set; then
 
10034
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
10035
else
 
10036
  cat >conftest.$ac_ext <<_ACEOF
 
10037
#line $LINENO "configure"
 
10038
#include "confdefs.h"
 
10039
 
 
10040
#ifdef F77_DUMMY_MAIN
 
10041
#  ifdef __cplusplus
 
10042
     extern "C"
 
10043
#  endif
 
10044
   int F77_DUMMY_MAIN() { return 1; }
 
10045
#endif
 
10046
int
 
10047
main ()
 
10048
{
 
10049
 
 
10050
volatile int x;
 
10051
int * volatile y;
 
10052
  ;
 
10053
  return 0;
 
10054
}
 
10055
_ACEOF
 
10056
rm -f conftest.$ac_objext
 
10057
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
10058
  (eval $ac_compile) 2>&5
 
10059
  ac_status=$?
 
10060
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10061
  (exit $ac_status); } &&
 
10062
         { ac_try='test -s conftest.$ac_objext'
 
10063
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
10064
  (eval $ac_try) 2>&5
 
10065
  ac_status=$?
 
10066
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10067
  (exit $ac_status); }; }; then
 
10068
  ac_cv_c_volatile=yes
 
10069
else
 
10070
  echo "$as_me: failed program was:" >&5
 
10071
cat conftest.$ac_ext >&5
 
10072
ac_cv_c_volatile=no
 
10073
fi
 
10074
rm -f conftest.$ac_objext conftest.$ac_ext
 
10075
fi
 
10076
echo "$as_me:$LINENO: result: $ac_cv_c_volatile" >&5
 
10077
echo "${ECHO_T}$ac_cv_c_volatile" >&6
 
10078
if test $ac_cv_c_volatile = no; then
 
10079
 
 
10080
cat >>confdefs.h <<\_ACEOF
 
10081
#define volatile
 
10082
_ACEOF
 
10083
 
 
10084
fi
 
10085
 
 
10086
echo "$as_me:$LINENO: checking for __func__" >&5
 
10087
echo $ECHO_N "checking for __func__... $ECHO_C" >&6
 
10088
if test "${pgac_cv_funcname_func_support+set}" = set; then
 
10089
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
10090
else
 
10091
  cat >conftest.$ac_ext <<_ACEOF
 
10092
#line $LINENO "configure"
 
10093
#include "confdefs.h"
 
10094
#include <stdio.h>
 
10095
#ifdef F77_DUMMY_MAIN
 
10096
#  ifdef __cplusplus
 
10097
     extern "C"
 
10098
#  endif
 
10099
   int F77_DUMMY_MAIN() { return 1; }
 
10100
#endif
 
10101
int
 
10102
main ()
 
10103
{
 
10104
printf("%s\n", __func__);
 
10105
  ;
 
10106
  return 0;
 
10107
}
 
10108
_ACEOF
 
10109
rm -f conftest.$ac_objext
 
10110
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
10111
  (eval $ac_compile) 2>&5
 
10112
  ac_status=$?
 
10113
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10114
  (exit $ac_status); } &&
 
10115
         { ac_try='test -s conftest.$ac_objext'
 
10116
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
10117
  (eval $ac_try) 2>&5
 
10118
  ac_status=$?
 
10119
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10120
  (exit $ac_status); }; }; then
 
10121
  pgac_cv_funcname_func_support=yes
 
10122
else
 
10123
  echo "$as_me: failed program was:" >&5
 
10124
cat conftest.$ac_ext >&5
 
10125
pgac_cv_funcname_func_support=no
 
10126
fi
 
10127
rm -f conftest.$ac_objext conftest.$ac_ext
 
10128
fi
 
10129
echo "$as_me:$LINENO: result: $pgac_cv_funcname_func_support" >&5
 
10130
echo "${ECHO_T}$pgac_cv_funcname_func_support" >&6
 
10131
if test x"$pgac_cv_funcname_func_support" = xyes ; then
 
10132
 
 
10133
cat >>confdefs.h <<\_ACEOF
 
10134
#define HAVE_FUNCNAME__FUNC 1
 
10135
_ACEOF
 
10136
 
 
10137
else
 
10138
echo "$as_me:$LINENO: checking for __FUNCTION__" >&5
 
10139
echo $ECHO_N "checking for __FUNCTION__... $ECHO_C" >&6
 
10140
if test "${pgac_cv_funcname_function_support+set}" = set; then
 
10141
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
10142
else
 
10143
  cat >conftest.$ac_ext <<_ACEOF
 
10144
#line $LINENO "configure"
 
10145
#include "confdefs.h"
 
10146
#include <stdio.h>
 
10147
#ifdef F77_DUMMY_MAIN
 
10148
#  ifdef __cplusplus
 
10149
     extern "C"
 
10150
#  endif
 
10151
   int F77_DUMMY_MAIN() { return 1; }
 
10152
#endif
 
10153
int
 
10154
main ()
 
10155
{
 
10156
printf("%s\n", __FUNCTION__);
 
10157
  ;
 
10158
  return 0;
 
10159
}
 
10160
_ACEOF
 
10161
rm -f conftest.$ac_objext
 
10162
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
10163
  (eval $ac_compile) 2>&5
 
10164
  ac_status=$?
 
10165
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10166
  (exit $ac_status); } &&
 
10167
         { ac_try='test -s conftest.$ac_objext'
 
10168
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
10169
  (eval $ac_try) 2>&5
 
10170
  ac_status=$?
 
10171
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10172
  (exit $ac_status); }; }; then
 
10173
  pgac_cv_funcname_function_support=yes
 
10174
else
 
10175
  echo "$as_me: failed program was:" >&5
 
10176
cat conftest.$ac_ext >&5
 
10177
pgac_cv_funcname_function_support=no
 
10178
fi
 
10179
rm -f conftest.$ac_objext conftest.$ac_ext
 
10180
fi
 
10181
echo "$as_me:$LINENO: result: $pgac_cv_funcname_function_support" >&5
 
10182
echo "${ECHO_T}$pgac_cv_funcname_function_support" >&6
 
10183
if test x"$pgac_cv_funcname_function_support" = xyes ; then
 
10184
 
 
10185
cat >>confdefs.h <<\_ACEOF
 
10186
#define HAVE_FUNCNAME__FUNCTION 1
 
10187
_ACEOF
 
10188
 
 
10189
fi
 
10190
fi
 
10191
echo "$as_me:$LINENO: checking whether struct tm is in sys/time.h or time.h" >&5
 
10192
echo $ECHO_N "checking whether struct tm is in sys/time.h or time.h... $ECHO_C" >&6
 
10193
if test "${ac_cv_struct_tm+set}" = set; then
 
10194
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
10195
else
 
10196
  cat >conftest.$ac_ext <<_ACEOF
 
10197
#line $LINENO "configure"
 
10198
#include "confdefs.h"
 
10199
#include <sys/types.h>
 
10200
#include <time.h>
 
10201
 
 
10202
#ifdef F77_DUMMY_MAIN
 
10203
#  ifdef __cplusplus
 
10204
     extern "C"
 
10205
#  endif
 
10206
   int F77_DUMMY_MAIN() { return 1; }
 
10207
#endif
 
10208
int
 
10209
main ()
 
10210
{
 
10211
struct tm *tp; tp->tm_sec;
 
10212
  ;
 
10213
  return 0;
 
10214
}
 
10215
_ACEOF
 
10216
rm -f conftest.$ac_objext
 
10217
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
10218
  (eval $ac_compile) 2>&5
 
10219
  ac_status=$?
 
10220
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10221
  (exit $ac_status); } &&
 
10222
         { ac_try='test -s conftest.$ac_objext'
 
10223
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
10224
  (eval $ac_try) 2>&5
 
10225
  ac_status=$?
 
10226
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10227
  (exit $ac_status); }; }; then
 
10228
  ac_cv_struct_tm=time.h
 
10229
else
 
10230
  echo "$as_me: failed program was:" >&5
 
10231
cat conftest.$ac_ext >&5
 
10232
ac_cv_struct_tm=sys/time.h
 
10233
fi
 
10234
rm -f conftest.$ac_objext conftest.$ac_ext
 
10235
fi
 
10236
echo "$as_me:$LINENO: result: $ac_cv_struct_tm" >&5
 
10237
echo "${ECHO_T}$ac_cv_struct_tm" >&6
 
10238
if test $ac_cv_struct_tm = sys/time.h; then
 
10239
 
 
10240
cat >>confdefs.h <<\_ACEOF
 
10241
#define TM_IN_SYS_TIME 1
 
10242
_ACEOF
 
10243
 
 
10244
fi
 
10245
 
 
10246
echo "$as_me:$LINENO: checking for struct tm.tm_zone" >&5
 
10247
echo $ECHO_N "checking for struct tm.tm_zone... $ECHO_C" >&6
 
10248
if test "${ac_cv_member_struct_tm_tm_zone+set}" = set; then
 
10249
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
10250
else
 
10251
  cat >conftest.$ac_ext <<_ACEOF
 
10252
#line $LINENO "configure"
 
10253
#include "confdefs.h"
 
10254
#include <sys/types.h>
 
10255
#include <$ac_cv_struct_tm>
 
10256
 
 
10257
 
 
10258
#ifdef F77_DUMMY_MAIN
 
10259
#  ifdef __cplusplus
 
10260
     extern "C"
 
10261
#  endif
 
10262
   int F77_DUMMY_MAIN() { return 1; }
 
10263
#endif
 
10264
int
 
10265
main ()
 
10266
{
 
10267
static struct tm ac_aggr;
 
10268
if (ac_aggr.tm_zone)
 
10269
return 0;
 
10270
  ;
 
10271
  return 0;
 
10272
}
 
10273
_ACEOF
 
10274
rm -f conftest.$ac_objext
 
10275
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
10276
  (eval $ac_compile) 2>&5
 
10277
  ac_status=$?
 
10278
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10279
  (exit $ac_status); } &&
 
10280
         { ac_try='test -s conftest.$ac_objext'
 
10281
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
10282
  (eval $ac_try) 2>&5
 
10283
  ac_status=$?
 
10284
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10285
  (exit $ac_status); }; }; then
 
10286
  ac_cv_member_struct_tm_tm_zone=yes
 
10287
else
 
10288
  echo "$as_me: failed program was:" >&5
 
10289
cat conftest.$ac_ext >&5
 
10290
ac_cv_member_struct_tm_tm_zone=no
 
10291
fi
 
10292
rm -f conftest.$ac_objext conftest.$ac_ext
 
10293
fi
 
10294
echo "$as_me:$LINENO: result: $ac_cv_member_struct_tm_tm_zone" >&5
 
10295
echo "${ECHO_T}$ac_cv_member_struct_tm_tm_zone" >&6
 
10296
if test $ac_cv_member_struct_tm_tm_zone = yes; then
 
10297
 
 
10298
cat >>confdefs.h <<_ACEOF
 
10299
#define HAVE_STRUCT_TM_TM_ZONE 1
 
10300
_ACEOF
 
10301
 
 
10302
 
 
10303
fi
 
10304
 
 
10305
if test "$ac_cv_member_struct_tm_tm_zone" = yes; then
 
10306
 
 
10307
cat >>confdefs.h <<\_ACEOF
 
10308
#define HAVE_TM_ZONE 1
 
10309
_ACEOF
 
10310
 
 
10311
fi
 
10312
echo "$as_me:$LINENO: checking for tzname" >&5
 
10313
echo $ECHO_N "checking for tzname... $ECHO_C" >&6
 
10314
if test "${ac_cv_var_tzname+set}" = set; then
 
10315
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
10316
else
 
10317
  cat >conftest.$ac_ext <<_ACEOF
 
10318
#line $LINENO "configure"
 
10319
#include "confdefs.h"
 
10320
#include <time.h>
 
10321
#ifndef tzname /* For SGI.  */
 
10322
extern char *tzname[]; /* RS6000 and others reject char **tzname.  */
 
10323
#endif
 
10324
 
 
10325
#ifdef F77_DUMMY_MAIN
 
10326
#  ifdef __cplusplus
 
10327
     extern "C"
 
10328
#  endif
 
10329
   int F77_DUMMY_MAIN() { return 1; }
 
10330
#endif
 
10331
int
 
10332
main ()
 
10333
{
 
10334
atoi(*tzname);
 
10335
  ;
 
10336
  return 0;
 
10337
}
 
10338
_ACEOF
 
10339
rm -f conftest.$ac_objext conftest$ac_exeext
 
10340
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
10341
  (eval $ac_link) 2>&5
 
10342
  ac_status=$?
 
10343
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10344
  (exit $ac_status); } &&
 
10345
         { ac_try='test -s conftest$ac_exeext'
 
10346
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
10347
  (eval $ac_try) 2>&5
 
10348
  ac_status=$?
 
10349
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10350
  (exit $ac_status); }; }; then
 
10351
  ac_cv_var_tzname=yes
 
10352
else
 
10353
  echo "$as_me: failed program was:" >&5
 
10354
cat conftest.$ac_ext >&5
 
10355
ac_cv_var_tzname=no
 
10356
fi
 
10357
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
10358
fi
 
10359
echo "$as_me:$LINENO: result: $ac_cv_var_tzname" >&5
 
10360
echo "${ECHO_T}$ac_cv_var_tzname" >&6
 
10361
if test $ac_cv_var_tzname = yes; then
 
10362
 
 
10363
cat >>confdefs.h <<\_ACEOF
 
10364
#define HAVE_TZNAME 1
 
10365
_ACEOF
 
10366
 
 
10367
fi
 
10368
 
 
10369
echo "$as_me:$LINENO: checking for union semun" >&5
 
10370
echo $ECHO_N "checking for union semun... $ECHO_C" >&6
 
10371
if test "${ac_cv_type_union_semun+set}" = set; then
 
10372
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
10373
else
 
10374
  cat >conftest.$ac_ext <<_ACEOF
 
10375
#line $LINENO "configure"
 
10376
#include "confdefs.h"
 
10377
#include <sys/types.h>
 
10378
#include <sys/ipc.h>
 
10379
#include <sys/sem.h>
 
10380
 
 
10381
#ifdef F77_DUMMY_MAIN
 
10382
#  ifdef __cplusplus
 
10383
     extern "C"
 
10384
#  endif
 
10385
   int F77_DUMMY_MAIN() { return 1; }
 
10386
#endif
 
10387
int
 
10388
main ()
 
10389
{
 
10390
if ((union semun *) 0)
 
10391
  return 0;
 
10392
if (sizeof (union semun))
 
10393
  return 0;
 
10394
  ;
 
10395
  return 0;
 
10396
}
 
10397
_ACEOF
 
10398
rm -f conftest.$ac_objext
 
10399
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
10400
  (eval $ac_compile) 2>&5
 
10401
  ac_status=$?
 
10402
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10403
  (exit $ac_status); } &&
 
10404
         { ac_try='test -s conftest.$ac_objext'
 
10405
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
10406
  (eval $ac_try) 2>&5
 
10407
  ac_status=$?
 
10408
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10409
  (exit $ac_status); }; }; then
 
10410
  ac_cv_type_union_semun=yes
 
10411
else
 
10412
  echo "$as_me: failed program was:" >&5
 
10413
cat conftest.$ac_ext >&5
 
10414
ac_cv_type_union_semun=no
 
10415
fi
 
10416
rm -f conftest.$ac_objext conftest.$ac_ext
 
10417
fi
 
10418
echo "$as_me:$LINENO: result: $ac_cv_type_union_semun" >&5
 
10419
echo "${ECHO_T}$ac_cv_type_union_semun" >&6
 
10420
if test $ac_cv_type_union_semun = yes; then
 
10421
 
 
10422
cat >>confdefs.h <<_ACEOF
 
10423
#define HAVE_UNION_SEMUN 1
 
10424
_ACEOF
 
10425
 
 
10426
 
 
10427
fi
 
10428
 
 
10429
echo "$as_me:$LINENO: checking for struct sockaddr_un" >&5
 
10430
echo $ECHO_N "checking for struct sockaddr_un... $ECHO_C" >&6
 
10431
if test "${ac_cv_type_struct_sockaddr_un+set}" = set; then
 
10432
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
10433
else
 
10434
  cat >conftest.$ac_ext <<_ACEOF
 
10435
#line $LINENO "configure"
 
10436
#include "confdefs.h"
 
10437
#include <sys/types.h>
 
10438
#ifdef HAVE_SYS_UN_H
 
10439
#include <sys/un.h>
 
10440
#endif
 
10441
 
 
10442
 
 
10443
#ifdef F77_DUMMY_MAIN
 
10444
#  ifdef __cplusplus
 
10445
     extern "C"
 
10446
#  endif
 
10447
   int F77_DUMMY_MAIN() { return 1; }
 
10448
#endif
 
10449
int
 
10450
main ()
 
10451
{
 
10452
if ((struct sockaddr_un *) 0)
 
10453
  return 0;
 
10454
if (sizeof (struct sockaddr_un))
 
10455
  return 0;
 
10456
  ;
 
10457
  return 0;
 
10458
}
 
10459
_ACEOF
 
10460
rm -f conftest.$ac_objext
 
10461
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
10462
  (eval $ac_compile) 2>&5
 
10463
  ac_status=$?
 
10464
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10465
  (exit $ac_status); } &&
 
10466
         { ac_try='test -s conftest.$ac_objext'
 
10467
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
10468
  (eval $ac_try) 2>&5
 
10469
  ac_status=$?
 
10470
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10471
  (exit $ac_status); }; }; then
 
10472
  ac_cv_type_struct_sockaddr_un=yes
 
10473
else
 
10474
  echo "$as_me: failed program was:" >&5
 
10475
cat conftest.$ac_ext >&5
 
10476
ac_cv_type_struct_sockaddr_un=no
 
10477
fi
 
10478
rm -f conftest.$ac_objext conftest.$ac_ext
 
10479
fi
 
10480
echo "$as_me:$LINENO: result: $ac_cv_type_struct_sockaddr_un" >&5
 
10481
echo "${ECHO_T}$ac_cv_type_struct_sockaddr_un" >&6
 
10482
if test $ac_cv_type_struct_sockaddr_un = yes; then
 
10483
 
 
10484
cat >>confdefs.h <<_ACEOF
 
10485
#define HAVE_STRUCT_SOCKADDR_UN 1
 
10486
_ACEOF
 
10487
 
 
10488
 
 
10489
cat >>confdefs.h <<\_ACEOF
 
10490
#define HAVE_UNIX_SOCKETS 1
 
10491
_ACEOF
 
10492
 
 
10493
fi
 
10494
 
 
10495
echo "$as_me:$LINENO: checking for struct sockaddr_storage" >&5
 
10496
echo $ECHO_N "checking for struct sockaddr_storage... $ECHO_C" >&6
 
10497
if test "${ac_cv_type_struct_sockaddr_storage+set}" = set; then
 
10498
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
10499
else
 
10500
  cat >conftest.$ac_ext <<_ACEOF
 
10501
#line $LINENO "configure"
 
10502
#include "confdefs.h"
 
10503
#include <sys/types.h>
 
10504
#ifdef HAVE_SYS_SOCKET_H
 
10505
#include <sys/socket.h>
 
10506
#endif
 
10507
 
 
10508
 
 
10509
#ifdef F77_DUMMY_MAIN
 
10510
#  ifdef __cplusplus
 
10511
     extern "C"
 
10512
#  endif
 
10513
   int F77_DUMMY_MAIN() { return 1; }
 
10514
#endif
 
10515
int
 
10516
main ()
 
10517
{
 
10518
if ((struct sockaddr_storage *) 0)
 
10519
  return 0;
 
10520
if (sizeof (struct sockaddr_storage))
 
10521
  return 0;
 
10522
  ;
 
10523
  return 0;
 
10524
}
 
10525
_ACEOF
 
10526
rm -f conftest.$ac_objext
 
10527
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
10528
  (eval $ac_compile) 2>&5
 
10529
  ac_status=$?
 
10530
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10531
  (exit $ac_status); } &&
 
10532
         { ac_try='test -s conftest.$ac_objext'
 
10533
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
10534
  (eval $ac_try) 2>&5
 
10535
  ac_status=$?
 
10536
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10537
  (exit $ac_status); }; }; then
 
10538
  ac_cv_type_struct_sockaddr_storage=yes
 
10539
else
 
10540
  echo "$as_me: failed program was:" >&5
 
10541
cat conftest.$ac_ext >&5
 
10542
ac_cv_type_struct_sockaddr_storage=no
 
10543
fi
 
10544
rm -f conftest.$ac_objext conftest.$ac_ext
 
10545
fi
 
10546
echo "$as_me:$LINENO: result: $ac_cv_type_struct_sockaddr_storage" >&5
 
10547
echo "${ECHO_T}$ac_cv_type_struct_sockaddr_storage" >&6
 
10548
if test $ac_cv_type_struct_sockaddr_storage = yes; then
 
10549
 
 
10550
cat >>confdefs.h <<_ACEOF
 
10551
#define HAVE_STRUCT_SOCKADDR_STORAGE 1
 
10552
_ACEOF
 
10553
 
 
10554
 
 
10555
fi
 
10556
 
 
10557
echo "$as_me:$LINENO: checking for struct sockaddr_storage.ss_family" >&5
 
10558
echo $ECHO_N "checking for struct sockaddr_storage.ss_family... $ECHO_C" >&6
 
10559
if test "${ac_cv_member_struct_sockaddr_storage_ss_family+set}" = set; then
 
10560
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
10561
else
 
10562
  cat >conftest.$ac_ext <<_ACEOF
 
10563
#line $LINENO "configure"
 
10564
#include "confdefs.h"
 
10565
#include <sys/types.h>
 
10566
#ifdef HAVE_SYS_SOCKET_H
 
10567
#include <sys/socket.h>
 
10568
#endif
 
10569
 
 
10570
 
 
10571
#ifdef F77_DUMMY_MAIN
 
10572
#  ifdef __cplusplus
 
10573
     extern "C"
 
10574
#  endif
 
10575
   int F77_DUMMY_MAIN() { return 1; }
 
10576
#endif
 
10577
int
 
10578
main ()
 
10579
{
 
10580
static struct sockaddr_storage ac_aggr;
 
10581
if (ac_aggr.ss_family)
 
10582
return 0;
 
10583
  ;
 
10584
  return 0;
 
10585
}
 
10586
_ACEOF
 
10587
rm -f conftest.$ac_objext
 
10588
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
10589
  (eval $ac_compile) 2>&5
 
10590
  ac_status=$?
 
10591
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10592
  (exit $ac_status); } &&
 
10593
         { ac_try='test -s conftest.$ac_objext'
 
10594
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
10595
  (eval $ac_try) 2>&5
 
10596
  ac_status=$?
 
10597
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10598
  (exit $ac_status); }; }; then
 
10599
  ac_cv_member_struct_sockaddr_storage_ss_family=yes
 
10600
else
 
10601
  echo "$as_me: failed program was:" >&5
 
10602
cat conftest.$ac_ext >&5
 
10603
ac_cv_member_struct_sockaddr_storage_ss_family=no
 
10604
fi
 
10605
rm -f conftest.$ac_objext conftest.$ac_ext
 
10606
fi
 
10607
echo "$as_me:$LINENO: result: $ac_cv_member_struct_sockaddr_storage_ss_family" >&5
 
10608
echo "${ECHO_T}$ac_cv_member_struct_sockaddr_storage_ss_family" >&6
 
10609
if test $ac_cv_member_struct_sockaddr_storage_ss_family = yes; then
 
10610
 
 
10611
cat >>confdefs.h <<_ACEOF
 
10612
#define HAVE_STRUCT_SOCKADDR_STORAGE_SS_FAMILY 1
 
10613
_ACEOF
 
10614
 
 
10615
 
 
10616
fi
 
10617
echo "$as_me:$LINENO: checking for struct sockaddr_storage.__ss_family" >&5
 
10618
echo $ECHO_N "checking for struct sockaddr_storage.__ss_family... $ECHO_C" >&6
 
10619
if test "${ac_cv_member_struct_sockaddr_storage___ss_family+set}" = set; then
 
10620
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
10621
else
 
10622
  cat >conftest.$ac_ext <<_ACEOF
 
10623
#line $LINENO "configure"
 
10624
#include "confdefs.h"
 
10625
#include <sys/types.h>
 
10626
#ifdef HAVE_SYS_SOCKET_H
 
10627
#include <sys/socket.h>
 
10628
#endif
 
10629
 
 
10630
 
 
10631
#ifdef F77_DUMMY_MAIN
 
10632
#  ifdef __cplusplus
 
10633
     extern "C"
 
10634
#  endif
 
10635
   int F77_DUMMY_MAIN() { return 1; }
 
10636
#endif
 
10637
int
 
10638
main ()
 
10639
{
 
10640
static struct sockaddr_storage ac_aggr;
 
10641
if (ac_aggr.__ss_family)
 
10642
return 0;
 
10643
  ;
 
10644
  return 0;
 
10645
}
 
10646
_ACEOF
 
10647
rm -f conftest.$ac_objext
 
10648
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
10649
  (eval $ac_compile) 2>&5
 
10650
  ac_status=$?
 
10651
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10652
  (exit $ac_status); } &&
 
10653
         { ac_try='test -s conftest.$ac_objext'
 
10654
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
10655
  (eval $ac_try) 2>&5
 
10656
  ac_status=$?
 
10657
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10658
  (exit $ac_status); }; }; then
 
10659
  ac_cv_member_struct_sockaddr_storage___ss_family=yes
 
10660
else
 
10661
  echo "$as_me: failed program was:" >&5
 
10662
cat conftest.$ac_ext >&5
 
10663
ac_cv_member_struct_sockaddr_storage___ss_family=no
 
10664
fi
 
10665
rm -f conftest.$ac_objext conftest.$ac_ext
 
10666
fi
 
10667
echo "$as_me:$LINENO: result: $ac_cv_member_struct_sockaddr_storage___ss_family" >&5
 
10668
echo "${ECHO_T}$ac_cv_member_struct_sockaddr_storage___ss_family" >&6
 
10669
if test $ac_cv_member_struct_sockaddr_storage___ss_family = yes; then
 
10670
 
 
10671
cat >>confdefs.h <<_ACEOF
 
10672
#define HAVE_STRUCT_SOCKADDR_STORAGE___SS_FAMILY 1
 
10673
_ACEOF
 
10674
 
 
10675
 
 
10676
fi
 
10677
echo "$as_me:$LINENO: checking for struct sockaddr_storage.ss_len" >&5
 
10678
echo $ECHO_N "checking for struct sockaddr_storage.ss_len... $ECHO_C" >&6
 
10679
if test "${ac_cv_member_struct_sockaddr_storage_ss_len+set}" = set; then
 
10680
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
10681
else
 
10682
  cat >conftest.$ac_ext <<_ACEOF
 
10683
#line $LINENO "configure"
 
10684
#include "confdefs.h"
 
10685
#include <sys/types.h>
 
10686
#ifdef HAVE_SYS_SOCKET_H
 
10687
#include <sys/socket.h>
 
10688
#endif
 
10689
 
 
10690
 
 
10691
#ifdef F77_DUMMY_MAIN
 
10692
#  ifdef __cplusplus
 
10693
     extern "C"
 
10694
#  endif
 
10695
   int F77_DUMMY_MAIN() { return 1; }
 
10696
#endif
 
10697
int
 
10698
main ()
 
10699
{
 
10700
static struct sockaddr_storage ac_aggr;
 
10701
if (ac_aggr.ss_len)
 
10702
return 0;
 
10703
  ;
 
10704
  return 0;
 
10705
}
 
10706
_ACEOF
 
10707
rm -f conftest.$ac_objext
 
10708
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
10709
  (eval $ac_compile) 2>&5
 
10710
  ac_status=$?
 
10711
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10712
  (exit $ac_status); } &&
 
10713
         { ac_try='test -s conftest.$ac_objext'
 
10714
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
10715
  (eval $ac_try) 2>&5
 
10716
  ac_status=$?
 
10717
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10718
  (exit $ac_status); }; }; then
 
10719
  ac_cv_member_struct_sockaddr_storage_ss_len=yes
 
10720
else
 
10721
  echo "$as_me: failed program was:" >&5
 
10722
cat conftest.$ac_ext >&5
 
10723
ac_cv_member_struct_sockaddr_storage_ss_len=no
 
10724
fi
 
10725
rm -f conftest.$ac_objext conftest.$ac_ext
 
10726
fi
 
10727
echo "$as_me:$LINENO: result: $ac_cv_member_struct_sockaddr_storage_ss_len" >&5
 
10728
echo "${ECHO_T}$ac_cv_member_struct_sockaddr_storage_ss_len" >&6
 
10729
if test $ac_cv_member_struct_sockaddr_storage_ss_len = yes; then
 
10730
 
 
10731
cat >>confdefs.h <<_ACEOF
 
10732
#define HAVE_STRUCT_SOCKADDR_STORAGE_SS_LEN 1
 
10733
_ACEOF
 
10734
 
 
10735
 
 
10736
fi
 
10737
echo "$as_me:$LINENO: checking for struct sockaddr_storage.__ss_len" >&5
 
10738
echo $ECHO_N "checking for struct sockaddr_storage.__ss_len... $ECHO_C" >&6
 
10739
if test "${ac_cv_member_struct_sockaddr_storage___ss_len+set}" = set; then
 
10740
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
10741
else
 
10742
  cat >conftest.$ac_ext <<_ACEOF
 
10743
#line $LINENO "configure"
 
10744
#include "confdefs.h"
 
10745
#include <sys/types.h>
 
10746
#ifdef HAVE_SYS_SOCKET_H
 
10747
#include <sys/socket.h>
 
10748
#endif
 
10749
 
 
10750
 
 
10751
#ifdef F77_DUMMY_MAIN
 
10752
#  ifdef __cplusplus
 
10753
     extern "C"
 
10754
#  endif
 
10755
   int F77_DUMMY_MAIN() { return 1; }
 
10756
#endif
 
10757
int
 
10758
main ()
 
10759
{
 
10760
static struct sockaddr_storage ac_aggr;
 
10761
if (ac_aggr.__ss_len)
 
10762
return 0;
 
10763
  ;
 
10764
  return 0;
 
10765
}
 
10766
_ACEOF
 
10767
rm -f conftest.$ac_objext
 
10768
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
10769
  (eval $ac_compile) 2>&5
 
10770
  ac_status=$?
 
10771
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10772
  (exit $ac_status); } &&
 
10773
         { ac_try='test -s conftest.$ac_objext'
 
10774
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
10775
  (eval $ac_try) 2>&5
 
10776
  ac_status=$?
 
10777
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10778
  (exit $ac_status); }; }; then
 
10779
  ac_cv_member_struct_sockaddr_storage___ss_len=yes
 
10780
else
 
10781
  echo "$as_me: failed program was:" >&5
 
10782
cat conftest.$ac_ext >&5
 
10783
ac_cv_member_struct_sockaddr_storage___ss_len=no
 
10784
fi
 
10785
rm -f conftest.$ac_objext conftest.$ac_ext
 
10786
fi
 
10787
echo "$as_me:$LINENO: result: $ac_cv_member_struct_sockaddr_storage___ss_len" >&5
 
10788
echo "${ECHO_T}$ac_cv_member_struct_sockaddr_storage___ss_len" >&6
 
10789
if test $ac_cv_member_struct_sockaddr_storage___ss_len = yes; then
 
10790
 
 
10791
cat >>confdefs.h <<_ACEOF
 
10792
#define HAVE_STRUCT_SOCKADDR_STORAGE___SS_LEN 1
 
10793
_ACEOF
 
10794
 
 
10795
 
 
10796
fi
 
10797
echo "$as_me:$LINENO: checking for struct sockaddr.sa_len" >&5
 
10798
echo $ECHO_N "checking for struct sockaddr.sa_len... $ECHO_C" >&6
 
10799
if test "${ac_cv_member_struct_sockaddr_sa_len+set}" = set; then
 
10800
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
10801
else
 
10802
  cat >conftest.$ac_ext <<_ACEOF
 
10803
#line $LINENO "configure"
 
10804
#include "confdefs.h"
 
10805
#include <sys/types.h>
 
10806
#ifdef HAVE_SYS_SOCKET_H
 
10807
#include <sys/socket.h>
 
10808
#endif
 
10809
 
 
10810
 
 
10811
#ifdef F77_DUMMY_MAIN
 
10812
#  ifdef __cplusplus
 
10813
     extern "C"
 
10814
#  endif
 
10815
   int F77_DUMMY_MAIN() { return 1; }
 
10816
#endif
 
10817
int
 
10818
main ()
 
10819
{
 
10820
static struct sockaddr ac_aggr;
 
10821
if (ac_aggr.sa_len)
 
10822
return 0;
 
10823
  ;
 
10824
  return 0;
 
10825
}
 
10826
_ACEOF
 
10827
rm -f conftest.$ac_objext
 
10828
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
10829
  (eval $ac_compile) 2>&5
 
10830
  ac_status=$?
 
10831
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10832
  (exit $ac_status); } &&
 
10833
         { ac_try='test -s conftest.$ac_objext'
 
10834
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
10835
  (eval $ac_try) 2>&5
 
10836
  ac_status=$?
 
10837
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10838
  (exit $ac_status); }; }; then
 
10839
  ac_cv_member_struct_sockaddr_sa_len=yes
 
10840
else
 
10841
  echo "$as_me: failed program was:" >&5
 
10842
cat conftest.$ac_ext >&5
 
10843
ac_cv_member_struct_sockaddr_sa_len=no
 
10844
fi
 
10845
rm -f conftest.$ac_objext conftest.$ac_ext
 
10846
fi
 
10847
echo "$as_me:$LINENO: result: $ac_cv_member_struct_sockaddr_sa_len" >&5
 
10848
echo "${ECHO_T}$ac_cv_member_struct_sockaddr_sa_len" >&6
 
10849
if test $ac_cv_member_struct_sockaddr_sa_len = yes; then
 
10850
 
 
10851
cat >>confdefs.h <<_ACEOF
 
10852
#define HAVE_STRUCT_SOCKADDR_SA_LEN 1
 
10853
_ACEOF
 
10854
 
 
10855
 
 
10856
fi
 
10857
 
 
10858
echo "$as_me:$LINENO: checking for struct addrinfo" >&5
 
10859
echo $ECHO_N "checking for struct addrinfo... $ECHO_C" >&6
 
10860
if test "${ac_cv_type_struct_addrinfo+set}" = set; then
 
10861
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
10862
else
 
10863
  cat >conftest.$ac_ext <<_ACEOF
 
10864
#line $LINENO "configure"
 
10865
#include "confdefs.h"
 
10866
#include <sys/types.h>
 
10867
#include <sys/socket.h>
 
10868
#include <netdb.h>
 
10869
 
 
10870
 
 
10871
#ifdef F77_DUMMY_MAIN
 
10872
#  ifdef __cplusplus
 
10873
     extern "C"
 
10874
#  endif
 
10875
   int F77_DUMMY_MAIN() { return 1; }
 
10876
#endif
 
10877
int
 
10878
main ()
 
10879
{
 
10880
if ((struct addrinfo *) 0)
 
10881
  return 0;
 
10882
if (sizeof (struct addrinfo))
 
10883
  return 0;
 
10884
  ;
 
10885
  return 0;
 
10886
}
 
10887
_ACEOF
 
10888
rm -f conftest.$ac_objext
 
10889
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
10890
  (eval $ac_compile) 2>&5
 
10891
  ac_status=$?
 
10892
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10893
  (exit $ac_status); } &&
 
10894
         { ac_try='test -s conftest.$ac_objext'
 
10895
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
10896
  (eval $ac_try) 2>&5
 
10897
  ac_status=$?
 
10898
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10899
  (exit $ac_status); }; }; then
 
10900
  ac_cv_type_struct_addrinfo=yes
 
10901
else
 
10902
  echo "$as_me: failed program was:" >&5
 
10903
cat conftest.$ac_ext >&5
 
10904
ac_cv_type_struct_addrinfo=no
 
10905
fi
 
10906
rm -f conftest.$ac_objext conftest.$ac_ext
 
10907
fi
 
10908
echo "$as_me:$LINENO: result: $ac_cv_type_struct_addrinfo" >&5
 
10909
echo "${ECHO_T}$ac_cv_type_struct_addrinfo" >&6
 
10910
if test $ac_cv_type_struct_addrinfo = yes; then
 
10911
 
 
10912
cat >>confdefs.h <<_ACEOF
 
10913
#define HAVE_STRUCT_ADDRINFO 1
 
10914
_ACEOF
 
10915
 
 
10916
 
 
10917
fi
 
10918
 
 
10919
 
 
10920
echo "$as_me:$LINENO: checking for struct cmsgcred" >&5
 
10921
echo $ECHO_N "checking for struct cmsgcred... $ECHO_C" >&6
 
10922
if test "${ac_cv_type_struct_cmsgcred+set}" = set; then
 
10923
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
10924
else
 
10925
  cat >conftest.$ac_ext <<_ACEOF
 
10926
#line $LINENO "configure"
 
10927
#include "confdefs.h"
 
10928
#include <sys/param.h>
 
10929
#include <sys/types.h>
 
10930
#include <sys/socket.h>
 
10931
#include <sys/ucred.h>
 
10932
 
 
10933
#ifdef F77_DUMMY_MAIN
 
10934
#  ifdef __cplusplus
 
10935
     extern "C"
 
10936
#  endif
 
10937
   int F77_DUMMY_MAIN() { return 1; }
 
10938
#endif
 
10939
int
 
10940
main ()
 
10941
{
 
10942
if ((struct cmsgcred *) 0)
 
10943
  return 0;
 
10944
if (sizeof (struct cmsgcred))
 
10945
  return 0;
 
10946
  ;
 
10947
  return 0;
 
10948
}
 
10949
_ACEOF
 
10950
rm -f conftest.$ac_objext
 
10951
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
10952
  (eval $ac_compile) 2>&5
 
10953
  ac_status=$?
 
10954
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10955
  (exit $ac_status); } &&
 
10956
         { ac_try='test -s conftest.$ac_objext'
 
10957
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
10958
  (eval $ac_try) 2>&5
 
10959
  ac_status=$?
 
10960
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10961
  (exit $ac_status); }; }; then
 
10962
  ac_cv_type_struct_cmsgcred=yes
 
10963
else
 
10964
  echo "$as_me: failed program was:" >&5
 
10965
cat conftest.$ac_ext >&5
 
10966
ac_cv_type_struct_cmsgcred=no
 
10967
fi
 
10968
rm -f conftest.$ac_objext conftest.$ac_ext
 
10969
fi
 
10970
echo "$as_me:$LINENO: result: $ac_cv_type_struct_cmsgcred" >&5
 
10971
echo "${ECHO_T}$ac_cv_type_struct_cmsgcred" >&6
 
10972
if test $ac_cv_type_struct_cmsgcred = yes; then
 
10973
 
 
10974
cat >>confdefs.h <<_ACEOF
 
10975
#define HAVE_STRUCT_CMSGCRED 1
 
10976
_ACEOF
 
10977
 
 
10978
 
 
10979
fi
 
10980
echo "$as_me:$LINENO: checking for struct fcred" >&5
 
10981
echo $ECHO_N "checking for struct fcred... $ECHO_C" >&6
 
10982
if test "${ac_cv_type_struct_fcred+set}" = set; then
 
10983
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
10984
else
 
10985
  cat >conftest.$ac_ext <<_ACEOF
 
10986
#line $LINENO "configure"
 
10987
#include "confdefs.h"
 
10988
#include <sys/param.h>
 
10989
#include <sys/types.h>
 
10990
#include <sys/socket.h>
 
10991
#include <sys/ucred.h>
 
10992
 
 
10993
#ifdef F77_DUMMY_MAIN
 
10994
#  ifdef __cplusplus
 
10995
     extern "C"
 
10996
#  endif
 
10997
   int F77_DUMMY_MAIN() { return 1; }
 
10998
#endif
 
10999
int
 
11000
main ()
 
11001
{
 
11002
if ((struct fcred *) 0)
 
11003
  return 0;
 
11004
if (sizeof (struct fcred))
 
11005
  return 0;
 
11006
  ;
 
11007
  return 0;
 
11008
}
 
11009
_ACEOF
 
11010
rm -f conftest.$ac_objext
 
11011
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
11012
  (eval $ac_compile) 2>&5
 
11013
  ac_status=$?
 
11014
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11015
  (exit $ac_status); } &&
 
11016
         { ac_try='test -s conftest.$ac_objext'
 
11017
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
11018
  (eval $ac_try) 2>&5
 
11019
  ac_status=$?
 
11020
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11021
  (exit $ac_status); }; }; then
 
11022
  ac_cv_type_struct_fcred=yes
 
11023
else
 
11024
  echo "$as_me: failed program was:" >&5
 
11025
cat conftest.$ac_ext >&5
 
11026
ac_cv_type_struct_fcred=no
 
11027
fi
 
11028
rm -f conftest.$ac_objext conftest.$ac_ext
 
11029
fi
 
11030
echo "$as_me:$LINENO: result: $ac_cv_type_struct_fcred" >&5
 
11031
echo "${ECHO_T}$ac_cv_type_struct_fcred" >&6
 
11032
if test $ac_cv_type_struct_fcred = yes; then
 
11033
 
 
11034
cat >>confdefs.h <<_ACEOF
 
11035
#define HAVE_STRUCT_FCRED 1
 
11036
_ACEOF
 
11037
 
 
11038
 
 
11039
fi
 
11040
echo "$as_me:$LINENO: checking for struct sockcred" >&5
 
11041
echo $ECHO_N "checking for struct sockcred... $ECHO_C" >&6
 
11042
if test "${ac_cv_type_struct_sockcred+set}" = set; then
 
11043
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
11044
else
 
11045
  cat >conftest.$ac_ext <<_ACEOF
 
11046
#line $LINENO "configure"
 
11047
#include "confdefs.h"
 
11048
#include <sys/param.h>
 
11049
#include <sys/types.h>
 
11050
#include <sys/socket.h>
 
11051
#include <sys/ucred.h>
 
11052
 
 
11053
#ifdef F77_DUMMY_MAIN
 
11054
#  ifdef __cplusplus
 
11055
     extern "C"
 
11056
#  endif
 
11057
   int F77_DUMMY_MAIN() { return 1; }
 
11058
#endif
 
11059
int
 
11060
main ()
 
11061
{
 
11062
if ((struct sockcred *) 0)
 
11063
  return 0;
 
11064
if (sizeof (struct sockcred))
 
11065
  return 0;
 
11066
  ;
 
11067
  return 0;
 
11068
}
 
11069
_ACEOF
 
11070
rm -f conftest.$ac_objext
 
11071
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
11072
  (eval $ac_compile) 2>&5
 
11073
  ac_status=$?
 
11074
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11075
  (exit $ac_status); } &&
 
11076
         { ac_try='test -s conftest.$ac_objext'
 
11077
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
11078
  (eval $ac_try) 2>&5
 
11079
  ac_status=$?
 
11080
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11081
  (exit $ac_status); }; }; then
 
11082
  ac_cv_type_struct_sockcred=yes
 
11083
else
 
11084
  echo "$as_me: failed program was:" >&5
 
11085
cat conftest.$ac_ext >&5
 
11086
ac_cv_type_struct_sockcred=no
 
11087
fi
 
11088
rm -f conftest.$ac_objext conftest.$ac_ext
 
11089
fi
 
11090
echo "$as_me:$LINENO: result: $ac_cv_type_struct_sockcred" >&5
 
11091
echo "${ECHO_T}$ac_cv_type_struct_sockcred" >&6
 
11092
if test $ac_cv_type_struct_sockcred = yes; then
 
11093
 
 
11094
cat >>confdefs.h <<_ACEOF
 
11095
#define HAVE_STRUCT_SOCKCRED 1
 
11096
_ACEOF
 
11097
 
 
11098
 
 
11099
fi
 
11100
 
 
11101
 
 
11102
echo "$as_me:$LINENO: checking for struct option" >&5
 
11103
echo $ECHO_N "checking for struct option... $ECHO_C" >&6
 
11104
if test "${ac_cv_type_struct_option+set}" = set; then
 
11105
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
11106
else
 
11107
  cat >conftest.$ac_ext <<_ACEOF
 
11108
#line $LINENO "configure"
 
11109
#include "confdefs.h"
 
11110
#ifdef HAVE_GETOPT_H
 
11111
#include <getopt.h>
 
11112
#endif
 
11113
 
 
11114
#ifdef F77_DUMMY_MAIN
 
11115
#  ifdef __cplusplus
 
11116
     extern "C"
 
11117
#  endif
 
11118
   int F77_DUMMY_MAIN() { return 1; }
 
11119
#endif
 
11120
int
 
11121
main ()
 
11122
{
 
11123
if ((struct option *) 0)
 
11124
  return 0;
 
11125
if (sizeof (struct option))
 
11126
  return 0;
 
11127
  ;
 
11128
  return 0;
 
11129
}
 
11130
_ACEOF
 
11131
rm -f conftest.$ac_objext
 
11132
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
11133
  (eval $ac_compile) 2>&5
 
11134
  ac_status=$?
 
11135
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11136
  (exit $ac_status); } &&
 
11137
         { ac_try='test -s conftest.$ac_objext'
 
11138
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
11139
  (eval $ac_try) 2>&5
 
11140
  ac_status=$?
 
11141
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11142
  (exit $ac_status); }; }; then
 
11143
  ac_cv_type_struct_option=yes
 
11144
else
 
11145
  echo "$as_me: failed program was:" >&5
 
11146
cat conftest.$ac_ext >&5
 
11147
ac_cv_type_struct_option=no
 
11148
fi
 
11149
rm -f conftest.$ac_objext conftest.$ac_ext
 
11150
fi
 
11151
echo "$as_me:$LINENO: result: $ac_cv_type_struct_option" >&5
 
11152
echo "${ECHO_T}$ac_cv_type_struct_option" >&6
 
11153
if test $ac_cv_type_struct_option = yes; then
 
11154
 
 
11155
cat >>confdefs.h <<_ACEOF
 
11156
#define HAVE_STRUCT_OPTION 1
 
11157
_ACEOF
 
11158
 
 
11159
 
 
11160
fi
 
11161
 
 
11162
 
 
11163
if test "$with_zlib" = yes; then
 
11164
  # Check that <zlib.h> defines z_streamp (versions before about 1.0.4
 
11165
  # did not).  While we could work around the lack of z_streamp, it
 
11166
  # seems unwise to encourage people to use such old zlib versions...
 
11167
  echo "$as_me:$LINENO: checking for z_streamp" >&5
 
11168
echo $ECHO_N "checking for z_streamp... $ECHO_C" >&6
 
11169
if test "${ac_cv_type_z_streamp+set}" = set; then
 
11170
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
11171
else
 
11172
  cat >conftest.$ac_ext <<_ACEOF
 
11173
#line $LINENO "configure"
 
11174
#include "confdefs.h"
 
11175
#include <zlib.h>
 
11176
 
 
11177
#ifdef F77_DUMMY_MAIN
 
11178
#  ifdef __cplusplus
 
11179
     extern "C"
 
11180
#  endif
 
11181
   int F77_DUMMY_MAIN() { return 1; }
 
11182
#endif
 
11183
int
 
11184
main ()
 
11185
{
 
11186
if ((z_streamp *) 0)
 
11187
  return 0;
 
11188
if (sizeof (z_streamp))
 
11189
  return 0;
 
11190
  ;
 
11191
  return 0;
 
11192
}
 
11193
_ACEOF
 
11194
rm -f conftest.$ac_objext
 
11195
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
11196
  (eval $ac_compile) 2>&5
 
11197
  ac_status=$?
 
11198
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11199
  (exit $ac_status); } &&
 
11200
         { ac_try='test -s conftest.$ac_objext'
 
11201
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
11202
  (eval $ac_try) 2>&5
 
11203
  ac_status=$?
 
11204
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11205
  (exit $ac_status); }; }; then
 
11206
  ac_cv_type_z_streamp=yes
 
11207
else
 
11208
  echo "$as_me: failed program was:" >&5
 
11209
cat conftest.$ac_ext >&5
 
11210
ac_cv_type_z_streamp=no
 
11211
fi
 
11212
rm -f conftest.$ac_objext conftest.$ac_ext
 
11213
fi
 
11214
echo "$as_me:$LINENO: result: $ac_cv_type_z_streamp" >&5
 
11215
echo "${ECHO_T}$ac_cv_type_z_streamp" >&6
 
11216
if test $ac_cv_type_z_streamp = yes; then
 
11217
  :
 
11218
else
 
11219
  { { echo "$as_me:$LINENO: error: zlib version is too old
 
11220
Use --without-zlib to disable zlib support." >&5
 
11221
echo "$as_me: error: zlib version is too old
 
11222
Use --without-zlib to disable zlib support." >&2;}
 
11223
   { (exit 1); exit 1; }; }
 
11224
fi
 
11225
 
 
11226
fi
 
11227
 
 
11228
if test "$with_krb5" = yes; then
 
11229
# Check for differences between MIT and Heimdal (KTH) releases
 
11230
  echo "$as_me:$LINENO: checking for krb5_ticket.enc_part2" >&5
 
11231
echo $ECHO_N "checking for krb5_ticket.enc_part2... $ECHO_C" >&6
 
11232
if test "${ac_cv_member_krb5_ticket_enc_part2+set}" = set; then
 
11233
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
11234
else
 
11235
  cat >conftest.$ac_ext <<_ACEOF
 
11236
#line $LINENO "configure"
 
11237
#include "confdefs.h"
 
11238
#include <krb5.h>
 
11239
 
 
11240
#ifdef F77_DUMMY_MAIN
 
11241
#  ifdef __cplusplus
 
11242
     extern "C"
 
11243
#  endif
 
11244
   int F77_DUMMY_MAIN() { return 1; }
 
11245
#endif
 
11246
int
 
11247
main ()
 
11248
{
 
11249
static krb5_ticket ac_aggr;
 
11250
if (ac_aggr.enc_part2)
 
11251
return 0;
 
11252
  ;
 
11253
  return 0;
 
11254
}
 
11255
_ACEOF
 
11256
rm -f conftest.$ac_objext
 
11257
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
11258
  (eval $ac_compile) 2>&5
 
11259
  ac_status=$?
 
11260
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11261
  (exit $ac_status); } &&
 
11262
         { ac_try='test -s conftest.$ac_objext'
 
11263
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
11264
  (eval $ac_try) 2>&5
 
11265
  ac_status=$?
 
11266
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11267
  (exit $ac_status); }; }; then
 
11268
  ac_cv_member_krb5_ticket_enc_part2=yes
 
11269
else
 
11270
  echo "$as_me: failed program was:" >&5
 
11271
cat conftest.$ac_ext >&5
 
11272
ac_cv_member_krb5_ticket_enc_part2=no
 
11273
fi
 
11274
rm -f conftest.$ac_objext conftest.$ac_ext
 
11275
fi
 
11276
echo "$as_me:$LINENO: result: $ac_cv_member_krb5_ticket_enc_part2" >&5
 
11277
echo "${ECHO_T}$ac_cv_member_krb5_ticket_enc_part2" >&6
 
11278
if test $ac_cv_member_krb5_ticket_enc_part2 = yes; then
 
11279
 
 
11280
cat >>confdefs.h <<_ACEOF
 
11281
#define HAVE_KRB5_TICKET_ENC_PART2 1
 
11282
_ACEOF
 
11283
 
 
11284
 
 
11285
else
 
11286
  echo "$as_me:$LINENO: checking for krb5_ticket.client" >&5
 
11287
echo $ECHO_N "checking for krb5_ticket.client... $ECHO_C" >&6
 
11288
if test "${ac_cv_member_krb5_ticket_client+set}" = set; then
 
11289
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
11290
else
 
11291
  cat >conftest.$ac_ext <<_ACEOF
 
11292
#line $LINENO "configure"
 
11293
#include "confdefs.h"
 
11294
#include <krb5.h>
 
11295
 
 
11296
#ifdef F77_DUMMY_MAIN
 
11297
#  ifdef __cplusplus
 
11298
     extern "C"
 
11299
#  endif
 
11300
   int F77_DUMMY_MAIN() { return 1; }
 
11301
#endif
 
11302
int
 
11303
main ()
 
11304
{
 
11305
static krb5_ticket ac_aggr;
 
11306
if (ac_aggr.client)
 
11307
return 0;
 
11308
  ;
 
11309
  return 0;
 
11310
}
 
11311
_ACEOF
 
11312
rm -f conftest.$ac_objext
 
11313
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
11314
  (eval $ac_compile) 2>&5
 
11315
  ac_status=$?
 
11316
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11317
  (exit $ac_status); } &&
 
11318
         { ac_try='test -s conftest.$ac_objext'
 
11319
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
11320
  (eval $ac_try) 2>&5
 
11321
  ac_status=$?
 
11322
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11323
  (exit $ac_status); }; }; then
 
11324
  ac_cv_member_krb5_ticket_client=yes
 
11325
else
 
11326
  echo "$as_me: failed program was:" >&5
 
11327
cat conftest.$ac_ext >&5
 
11328
ac_cv_member_krb5_ticket_client=no
 
11329
fi
 
11330
rm -f conftest.$ac_objext conftest.$ac_ext
 
11331
fi
 
11332
echo "$as_me:$LINENO: result: $ac_cv_member_krb5_ticket_client" >&5
 
11333
echo "${ECHO_T}$ac_cv_member_krb5_ticket_client" >&6
 
11334
if test $ac_cv_member_krb5_ticket_client = yes; then
 
11335
 
 
11336
cat >>confdefs.h <<_ACEOF
 
11337
#define HAVE_KRB5_TICKET_CLIENT 1
 
11338
_ACEOF
 
11339
 
 
11340
 
 
11341
else
 
11342
  { { echo "$as_me:$LINENO: error: could not determine how to get client name from Kerberos 5 ticket" >&5
 
11343
echo "$as_me: error: could not determine how to get client name from Kerberos 5 ticket" >&2;}
 
11344
   { (exit 1); exit 1; }; }
 
11345
fi
 
11346
 
 
11347
fi
 
11348
 
 
11349
  echo "$as_me:$LINENO: checking for krb5_error.text.data" >&5
 
11350
echo $ECHO_N "checking for krb5_error.text.data... $ECHO_C" >&6
 
11351
if test "${ac_cv_member_krb5_error_text_data+set}" = set; then
 
11352
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
11353
else
 
11354
  cat >conftest.$ac_ext <<_ACEOF
 
11355
#line $LINENO "configure"
 
11356
#include "confdefs.h"
 
11357
#include <krb5.h>
 
11358
 
 
11359
#ifdef F77_DUMMY_MAIN
 
11360
#  ifdef __cplusplus
 
11361
     extern "C"
 
11362
#  endif
 
11363
   int F77_DUMMY_MAIN() { return 1; }
 
11364
#endif
 
11365
int
 
11366
main ()
 
11367
{
 
11368
static krb5_error ac_aggr;
 
11369
if (ac_aggr.text.data)
 
11370
return 0;
 
11371
  ;
 
11372
  return 0;
 
11373
}
 
11374
_ACEOF
 
11375
rm -f conftest.$ac_objext
 
11376
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
11377
  (eval $ac_compile) 2>&5
 
11378
  ac_status=$?
 
11379
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11380
  (exit $ac_status); } &&
 
11381
         { ac_try='test -s conftest.$ac_objext'
 
11382
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
11383
  (eval $ac_try) 2>&5
 
11384
  ac_status=$?
 
11385
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11386
  (exit $ac_status); }; }; then
 
11387
  ac_cv_member_krb5_error_text_data=yes
 
11388
else
 
11389
  echo "$as_me: failed program was:" >&5
 
11390
cat conftest.$ac_ext >&5
 
11391
ac_cv_member_krb5_error_text_data=no
 
11392
fi
 
11393
rm -f conftest.$ac_objext conftest.$ac_ext
 
11394
fi
 
11395
echo "$as_me:$LINENO: result: $ac_cv_member_krb5_error_text_data" >&5
 
11396
echo "${ECHO_T}$ac_cv_member_krb5_error_text_data" >&6
 
11397
if test $ac_cv_member_krb5_error_text_data = yes; then
 
11398
 
 
11399
cat >>confdefs.h <<_ACEOF
 
11400
#define HAVE_KRB5_ERROR_TEXT_DATA 1
 
11401
_ACEOF
 
11402
 
 
11403
 
 
11404
else
 
11405
  echo "$as_me:$LINENO: checking for krb5_error.e_data" >&5
 
11406
echo $ECHO_N "checking for krb5_error.e_data... $ECHO_C" >&6
 
11407
if test "${ac_cv_member_krb5_error_e_data+set}" = set; then
 
11408
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
11409
else
 
11410
  cat >conftest.$ac_ext <<_ACEOF
 
11411
#line $LINENO "configure"
 
11412
#include "confdefs.h"
 
11413
#include <krb5.h>
 
11414
 
 
11415
#ifdef F77_DUMMY_MAIN
 
11416
#  ifdef __cplusplus
 
11417
     extern "C"
 
11418
#  endif
 
11419
   int F77_DUMMY_MAIN() { return 1; }
 
11420
#endif
 
11421
int
 
11422
main ()
 
11423
{
 
11424
static krb5_error ac_aggr;
 
11425
if (ac_aggr.e_data)
 
11426
return 0;
 
11427
  ;
 
11428
  return 0;
 
11429
}
 
11430
_ACEOF
 
11431
rm -f conftest.$ac_objext
 
11432
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
11433
  (eval $ac_compile) 2>&5
 
11434
  ac_status=$?
 
11435
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11436
  (exit $ac_status); } &&
 
11437
         { ac_try='test -s conftest.$ac_objext'
 
11438
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
11439
  (eval $ac_try) 2>&5
 
11440
  ac_status=$?
 
11441
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11442
  (exit $ac_status); }; }; then
 
11443
  ac_cv_member_krb5_error_e_data=yes
 
11444
else
 
11445
  echo "$as_me: failed program was:" >&5
 
11446
cat conftest.$ac_ext >&5
 
11447
ac_cv_member_krb5_error_e_data=no
 
11448
fi
 
11449
rm -f conftest.$ac_objext conftest.$ac_ext
 
11450
fi
 
11451
echo "$as_me:$LINENO: result: $ac_cv_member_krb5_error_e_data" >&5
 
11452
echo "${ECHO_T}$ac_cv_member_krb5_error_e_data" >&6
 
11453
if test $ac_cv_member_krb5_error_e_data = yes; then
 
11454
 
 
11455
cat >>confdefs.h <<_ACEOF
 
11456
#define HAVE_KRB5_ERROR_E_DATA 1
 
11457
_ACEOF
 
11458
 
 
11459
 
 
11460
else
 
11461
  { { echo "$as_me:$LINENO: error: could not determine how to extract Kerberos 5 error messages" >&5
 
11462
echo "$as_me: error: could not determine how to extract Kerberos 5 error messages" >&2;}
 
11463
   { (exit 1); exit 1; }; }
 
11464
fi
 
11465
 
 
11466
fi
 
11467
 
 
11468
fi
 
11469
 
 
11470
##
 
11471
## Functions, global variables
 
11472
##
 
11473
 
 
11474
echo "$as_me:$LINENO: checking for int timezone" >&5
 
11475
echo $ECHO_N "checking for int timezone... $ECHO_C" >&6
 
11476
if test "${pgac_cv_var_int_timezone+set}" = set; then
 
11477
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
11478
else
 
11479
  cat >conftest.$ac_ext <<_ACEOF
 
11480
#line $LINENO "configure"
 
11481
#include "confdefs.h"
 
11482
#include <time.h>
 
11483
int res;
 
11484
#ifdef F77_DUMMY_MAIN
 
11485
#  ifdef __cplusplus
 
11486
     extern "C"
 
11487
#  endif
 
11488
   int F77_DUMMY_MAIN() { return 1; }
 
11489
#endif
 
11490
int
 
11491
main ()
 
11492
{
 
11493
#ifndef __CYGWIN__
 
11494
res = timezone / 60;
 
11495
#else
 
11496
res = _timezone / 60;
 
11497
#endif
 
11498
  ;
 
11499
  return 0;
 
11500
}
 
11501
_ACEOF
 
11502
rm -f conftest.$ac_objext conftest$ac_exeext
 
11503
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
11504
  (eval $ac_link) 2>&5
 
11505
  ac_status=$?
 
11506
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11507
  (exit $ac_status); } &&
 
11508
         { ac_try='test -s conftest$ac_exeext'
 
11509
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
11510
  (eval $ac_try) 2>&5
 
11511
  ac_status=$?
 
11512
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11513
  (exit $ac_status); }; }; then
 
11514
  pgac_cv_var_int_timezone=yes
 
11515
else
 
11516
  echo "$as_me: failed program was:" >&5
 
11517
cat conftest.$ac_ext >&5
 
11518
pgac_cv_var_int_timezone=no
 
11519
fi
 
11520
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
11521
fi
 
11522
echo "$as_me:$LINENO: result: $pgac_cv_var_int_timezone" >&5
 
11523
echo "${ECHO_T}$pgac_cv_var_int_timezone" >&6
 
11524
if test x"$pgac_cv_var_int_timezone" = xyes ; then
 
11525
 
 
11526
cat >>confdefs.h <<\_ACEOF
 
11527
#define HAVE_INT_TIMEZONE
 
11528
_ACEOF
 
11529
 
 
11530
fi
 
11531
echo "$as_me:$LINENO: checking types of arguments for accept()" >&5
 
11532
echo $ECHO_N "checking types of arguments for accept()... $ECHO_C" >&6
 
11533
 if test "${ac_cv_func_accept_return+set}" = set; then
 
11534
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
11535
else
 
11536
   if test "${ac_cv_func_accept_arg1+set}" = set; then
 
11537
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
11538
else
 
11539
    if test "${ac_cv_func_accept_arg2+set}" = set; then
 
11540
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
11541
else
 
11542
     if test "${ac_cv_func_accept_arg3+set}" = set; then
 
11543
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
11544
else
 
11545
      for ac_cv_func_accept_return in 'int' 'unsigned int PASCAL'; do
 
11546
      for ac_cv_func_accept_arg1 in 'int' 'unsigned int'; do
 
11547
       for ac_cv_func_accept_arg2 in 'struct sockaddr *' 'const struct sockaddr *' 'void *'; do
 
11548
        for ac_cv_func_accept_arg3 in 'int' 'size_t' 'socklen_t' 'unsigned int' 'void'; do
 
11549
         cat >conftest.$ac_ext <<_ACEOF
 
11550
#line $LINENO "configure"
 
11551
#include "confdefs.h"
 
11552
#ifdef HAVE_SYS_TYPES_H
 
11553
#include <sys/types.h>
 
11554
#endif
 
11555
#ifdef HAVE_SYS_SOCKET_H
 
11556
#include <sys/socket.h>
 
11557
#endif
 
11558
extern $ac_cv_func_accept_return accept ($ac_cv_func_accept_arg1, $ac_cv_func_accept_arg2, $ac_cv_func_accept_arg3 *);
 
11559
#ifdef F77_DUMMY_MAIN
 
11560
#  ifdef __cplusplus
 
11561
     extern "C"
 
11562
#  endif
 
11563
   int F77_DUMMY_MAIN() { return 1; }
 
11564
#endif
 
11565
int
 
11566
main ()
 
11567
{
 
11568
 
 
11569
  ;
 
11570
  return 0;
 
11571
}
 
11572
_ACEOF
 
11573
rm -f conftest.$ac_objext
 
11574
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
11575
  (eval $ac_compile) 2>&5
 
11576
  ac_status=$?
 
11577
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11578
  (exit $ac_status); } &&
 
11579
         { ac_try='test -s conftest.$ac_objext'
 
11580
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
11581
  (eval $ac_try) 2>&5
 
11582
  ac_status=$?
 
11583
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11584
  (exit $ac_status); }; }; then
 
11585
  ac_not_found=no; break 4
 
11586
else
 
11587
  echo "$as_me: failed program was:" >&5
 
11588
cat conftest.$ac_ext >&5
 
11589
ac_not_found=yes
 
11590
fi
 
11591
rm -f conftest.$ac_objext conftest.$ac_ext
 
11592
       done
 
11593
      done
 
11594
     done
 
11595
    done
 
11596
    if test "$ac_not_found" = yes; then
 
11597
      { { echo "$as_me:$LINENO: error: could not determine argument types" >&5
 
11598
echo "$as_me: error: could not determine argument types" >&2;}
 
11599
   { (exit 1); exit 1; }; }
 
11600
    fi
 
11601
    if test "$ac_cv_func_accept_arg3" = "void"; then
 
11602
      ac_cv_func_accept_arg3=int
 
11603
    fi
 
11604
 
 
11605
fi
 
11606
 
 
11607
fi
 
11608
 
 
11609
fi
 
11610
 
 
11611
fi
 
11612
 echo "$as_me:$LINENO: result: $ac_cv_func_accept_return, $ac_cv_func_accept_arg1, $ac_cv_func_accept_arg2, $ac_cv_func_accept_arg3 *" >&5
 
11613
echo "${ECHO_T}$ac_cv_func_accept_return, $ac_cv_func_accept_arg1, $ac_cv_func_accept_arg2, $ac_cv_func_accept_arg3 *" >&6
 
11614
 
 
11615
cat >>confdefs.h <<_ACEOF
 
11616
#define ACCEPT_TYPE_RETURN $ac_cv_func_accept_return
 
11617
_ACEOF
 
11618
 
 
11619
 
 
11620
cat >>confdefs.h <<_ACEOF
 
11621
#define ACCEPT_TYPE_ARG1 $ac_cv_func_accept_arg1
 
11622
_ACEOF
 
11623
 
 
11624
 
 
11625
cat >>confdefs.h <<_ACEOF
 
11626
#define ACCEPT_TYPE_ARG2 $ac_cv_func_accept_arg2
 
11627
_ACEOF
 
11628
 
 
11629
 
 
11630
cat >>confdefs.h <<_ACEOF
 
11631
#define ACCEPT_TYPE_ARG3 $ac_cv_func_accept_arg3
 
11632
_ACEOF
 
11633
 
 
11634
 
 
11635
echo "$as_me:$LINENO: checking whether gettimeofday takes only one argument" >&5
 
11636
echo $ECHO_N "checking whether gettimeofday takes only one argument... $ECHO_C" >&6
 
11637
if test "${pgac_cv_func_gettimeofday_1arg+set}" = set; then
 
11638
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
11639
else
 
11640
  cat >conftest.$ac_ext <<_ACEOF
 
11641
#line $LINENO "configure"
 
11642
#include "confdefs.h"
 
11643
#include <sys/time.h>
 
11644
#ifdef F77_DUMMY_MAIN
 
11645
#  ifdef __cplusplus
 
11646
     extern "C"
 
11647
#  endif
 
11648
   int F77_DUMMY_MAIN() { return 1; }
 
11649
#endif
 
11650
int
 
11651
main ()
 
11652
{
 
11653
struct timeval *tp;
 
11654
struct timezone *tzp;
 
11655
gettimeofday(tp,tzp);
 
11656
  ;
 
11657
  return 0;
 
11658
}
 
11659
_ACEOF
 
11660
rm -f conftest.$ac_objext
 
11661
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
11662
  (eval $ac_compile) 2>&5
 
11663
  ac_status=$?
 
11664
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11665
  (exit $ac_status); } &&
 
11666
         { ac_try='test -s conftest.$ac_objext'
 
11667
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
11668
  (eval $ac_try) 2>&5
 
11669
  ac_status=$?
 
11670
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11671
  (exit $ac_status); }; }; then
 
11672
  pgac_cv_func_gettimeofday_1arg=no
 
11673
else
 
11674
  echo "$as_me: failed program was:" >&5
 
11675
cat conftest.$ac_ext >&5
 
11676
pgac_cv_func_gettimeofday_1arg=yes
 
11677
fi
 
11678
rm -f conftest.$ac_objext conftest.$ac_ext
 
11679
fi
 
11680
echo "$as_me:$LINENO: result: $pgac_cv_func_gettimeofday_1arg" >&5
 
11681
echo "${ECHO_T}$pgac_cv_func_gettimeofday_1arg" >&6
 
11682
if test x"$pgac_cv_func_gettimeofday_1arg" = xyes ; then
 
11683
 
 
11684
cat >>confdefs.h <<\_ACEOF
 
11685
#define GETTIMEOFDAY_1ARG
 
11686
_ACEOF
 
11687
 
 
11688
fi
 
11689
 
 
11690
 
 
11691
 
 
11692
# SunOS doesn't handle negative byte comparisons properly with +/- return
 
11693
echo "$as_me:$LINENO: checking for working memcmp" >&5
 
11694
echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
 
11695
if test "${ac_cv_func_memcmp_working+set}" = set; then
 
11696
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
11697
else
 
11698
  if test "$cross_compiling" = yes; then
 
11699
  ac_cv_func_memcmp_working=no
 
11700
else
 
11701
  cat >conftest.$ac_ext <<_ACEOF
 
11702
#line $LINENO "configure"
 
11703
#include "confdefs.h"
 
11704
 
 
11705
#ifdef F77_DUMMY_MAIN
 
11706
#  ifdef __cplusplus
 
11707
     extern "C"
 
11708
#  endif
 
11709
   int F77_DUMMY_MAIN() { return 1; }
 
11710
#endif
 
11711
int
 
11712
main ()
 
11713
{
 
11714
 
 
11715
  /* Some versions of memcmp are not 8-bit clean.  */
 
11716
  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
 
11717
  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
 
11718
    exit (1);
 
11719
 
 
11720
  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
 
11721
     or more and with at least one buffer not starting on a 4-byte boundary.
 
11722
     William Lewis provided this test program.   */
 
11723
  {
 
11724
    char foo[21];
 
11725
    char bar[21];
 
11726
    int i;
 
11727
    for (i = 0; i < 4; i++)
 
11728
      {
 
11729
        char *a = foo + i;
 
11730
        char *b = bar + i;
 
11731
        strcpy (a, "--------01111111");
 
11732
        strcpy (b, "--------10000000");
 
11733
        if (memcmp (a, b, 16) >= 0)
 
11734
          exit (1);
 
11735
      }
 
11736
    exit (0);
 
11737
  }
 
11738
 
 
11739
  ;
 
11740
  return 0;
 
11741
}
 
11742
_ACEOF
 
11743
rm -f conftest$ac_exeext
 
11744
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
11745
  (eval $ac_link) 2>&5
 
11746
  ac_status=$?
 
11747
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11748
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
11749
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
11750
  (eval $ac_try) 2>&5
 
11751
  ac_status=$?
 
11752
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11753
  (exit $ac_status); }; }; then
 
11754
  ac_cv_func_memcmp_working=yes
 
11755
else
 
11756
  echo "$as_me: program exited with status $ac_status" >&5
 
11757
echo "$as_me: failed program was:" >&5
 
11758
cat conftest.$ac_ext >&5
 
11759
( exit $ac_status )
 
11760
ac_cv_func_memcmp_working=no
 
11761
fi
 
11762
rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 
11763
fi
 
11764
fi
 
11765
echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
 
11766
echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
 
11767
test $ac_cv_func_memcmp_working = no && LIBOBJS="$LIBOBJS memcmp.$ac_objext"
 
11768
 
 
11769
 
 
11770
 
 
11771
 
 
11772
 
 
11773
 
 
11774
 
 
11775
 
 
11776
 
 
11777
 
 
11778
 
 
11779
 
 
11780
 
 
11781
 
 
11782
 
 
11783
 
 
11784
 
 
11785
 
 
11786
 
 
11787
 
 
11788
 
 
11789
for ac_func in cbrt dlopen fcvt fdatasync getpeereid memmove poll pstat readlink setproctitle setsid sigprocmask symlink sysconf towlower utime utimes waitpid wcstombs
 
11790
do
 
11791
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
 
11792
echo "$as_me:$LINENO: checking for $ac_func" >&5
 
11793
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
 
11794
if eval "test \"\${$as_ac_var+set}\" = set"; then
 
11795
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
11796
else
 
11797
  cat >conftest.$ac_ext <<_ACEOF
 
11798
#line $LINENO "configure"
 
11799
#include "confdefs.h"
 
11800
/* System header to define __stub macros and hopefully few prototypes,
 
11801
    which can conflict with char $ac_func (); below.  */
 
11802
#include <assert.h>
 
11803
/* Override any gcc2 internal prototype to avoid an error.  */
 
11804
#ifdef __cplusplus
 
11805
extern "C"
 
11806
#endif
 
11807
/* We use char because int might match the return type of a gcc2
 
11808
   builtin and then its argument prototype would still apply.  */
 
11809
char $ac_func ();
 
11810
char (*f) ();
 
11811
 
 
11812
#ifdef F77_DUMMY_MAIN
 
11813
#  ifdef __cplusplus
 
11814
     extern "C"
 
11815
#  endif
 
11816
   int F77_DUMMY_MAIN() { return 1; }
 
11817
#endif
 
11818
int
 
11819
main ()
 
11820
{
 
11821
/* The GNU C library defines this for functions which it implements
 
11822
    to always fail with ENOSYS.  Some functions are actually named
 
11823
    something starting with __ and the normal name is an alias.  */
 
11824
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
 
11825
choke me
 
11826
#else
 
11827
f = $ac_func;
 
11828
#endif
 
11829
 
 
11830
  ;
 
11831
  return 0;
 
11832
}
 
11833
_ACEOF
 
11834
rm -f conftest.$ac_objext conftest$ac_exeext
 
11835
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
11836
  (eval $ac_link) 2>&5
 
11837
  ac_status=$?
 
11838
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11839
  (exit $ac_status); } &&
 
11840
         { ac_try='test -s conftest$ac_exeext'
 
11841
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
11842
  (eval $ac_try) 2>&5
 
11843
  ac_status=$?
 
11844
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11845
  (exit $ac_status); }; }; then
 
11846
  eval "$as_ac_var=yes"
 
11847
else
 
11848
  echo "$as_me: failed program was:" >&5
 
11849
cat conftest.$ac_ext >&5
 
11850
eval "$as_ac_var=no"
 
11851
fi
 
11852
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
11853
fi
 
11854
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
 
11855
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
 
11856
if test `eval echo '${'$as_ac_var'}'` = yes; then
 
11857
  cat >>confdefs.h <<_ACEOF
 
11858
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
 
11859
_ACEOF
 
11860
 
 
11861
fi
 
11862
done
 
11863
 
 
11864
 
 
11865
echo "$as_me:$LINENO: checking whether fdatasync is declared" >&5
 
11866
echo $ECHO_N "checking whether fdatasync is declared... $ECHO_C" >&6
 
11867
if test "${ac_cv_have_decl_fdatasync+set}" = set; then
 
11868
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
11869
else
 
11870
  cat >conftest.$ac_ext <<_ACEOF
 
11871
#line $LINENO "configure"
 
11872
#include "confdefs.h"
 
11873
#include <unistd.h>
 
11874
 
 
11875
#ifdef F77_DUMMY_MAIN
 
11876
#  ifdef __cplusplus
 
11877
     extern "C"
 
11878
#  endif
 
11879
   int F77_DUMMY_MAIN() { return 1; }
 
11880
#endif
 
11881
int
 
11882
main ()
 
11883
{
 
11884
#ifndef fdatasync
 
11885
  char *p = (char *) fdatasync;
 
11886
#endif
 
11887
 
 
11888
  ;
 
11889
  return 0;
 
11890
}
 
11891
_ACEOF
 
11892
rm -f conftest.$ac_objext
 
11893
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
11894
  (eval $ac_compile) 2>&5
 
11895
  ac_status=$?
 
11896
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11897
  (exit $ac_status); } &&
 
11898
         { ac_try='test -s conftest.$ac_objext'
 
11899
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
11900
  (eval $ac_try) 2>&5
 
11901
  ac_status=$?
 
11902
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11903
  (exit $ac_status); }; }; then
 
11904
  ac_cv_have_decl_fdatasync=yes
 
11905
else
 
11906
  echo "$as_me: failed program was:" >&5
 
11907
cat conftest.$ac_ext >&5
 
11908
ac_cv_have_decl_fdatasync=no
 
11909
fi
 
11910
rm -f conftest.$ac_objext conftest.$ac_ext
 
11911
fi
 
11912
echo "$as_me:$LINENO: result: $ac_cv_have_decl_fdatasync" >&5
 
11913
echo "${ECHO_T}$ac_cv_have_decl_fdatasync" >&6
 
11914
if test $ac_cv_have_decl_fdatasync = yes; then
 
11915
 
 
11916
cat >>confdefs.h <<_ACEOF
 
11917
#define HAVE_DECL_FDATASYNC 1
 
11918
_ACEOF
 
11919
 
 
11920
 
 
11921
else
 
11922
  cat >>confdefs.h <<_ACEOF
 
11923
#define HAVE_DECL_FDATASYNC 0
 
11924
_ACEOF
 
11925
 
 
11926
 
 
11927
fi
 
11928
 
 
11929
 
 
11930
 
 
11931
HAVE_IPV6=no
 
11932
echo "$as_me:$LINENO: checking for struct sockaddr_in6" >&5
 
11933
echo $ECHO_N "checking for struct sockaddr_in6... $ECHO_C" >&6
 
11934
if test "${ac_cv_type_struct_sockaddr_in6+set}" = set; then
 
11935
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
11936
else
 
11937
  cat >conftest.$ac_ext <<_ACEOF
 
11938
#line $LINENO "configure"
 
11939
#include "confdefs.h"
 
11940
$ac_includes_default
 
11941
#include <netinet/in.h>
 
11942
 
 
11943
#ifdef F77_DUMMY_MAIN
 
11944
#  ifdef __cplusplus
 
11945
     extern "C"
 
11946
#  endif
 
11947
   int F77_DUMMY_MAIN() { return 1; }
 
11948
#endif
 
11949
int
 
11950
main ()
 
11951
{
 
11952
if ((struct sockaddr_in6 *) 0)
 
11953
  return 0;
 
11954
if (sizeof (struct sockaddr_in6))
 
11955
  return 0;
 
11956
  ;
 
11957
  return 0;
 
11958
}
 
11959
_ACEOF
 
11960
rm -f conftest.$ac_objext
 
11961
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
11962
  (eval $ac_compile) 2>&5
 
11963
  ac_status=$?
 
11964
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11965
  (exit $ac_status); } &&
 
11966
         { ac_try='test -s conftest.$ac_objext'
 
11967
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
11968
  (eval $ac_try) 2>&5
 
11969
  ac_status=$?
 
11970
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11971
  (exit $ac_status); }; }; then
 
11972
  ac_cv_type_struct_sockaddr_in6=yes
 
11973
else
 
11974
  echo "$as_me: failed program was:" >&5
 
11975
cat conftest.$ac_ext >&5
 
11976
ac_cv_type_struct_sockaddr_in6=no
 
11977
fi
 
11978
rm -f conftest.$ac_objext conftest.$ac_ext
 
11979
fi
 
11980
echo "$as_me:$LINENO: result: $ac_cv_type_struct_sockaddr_in6" >&5
 
11981
echo "${ECHO_T}$ac_cv_type_struct_sockaddr_in6" >&6
 
11982
if test $ac_cv_type_struct_sockaddr_in6 = yes; then
 
11983
  echo "$as_me:$LINENO: checking for inet_ntop" >&5
 
11984
echo $ECHO_N "checking for inet_ntop... $ECHO_C" >&6
 
11985
if test "${ac_cv_func_inet_ntop+set}" = set; then
 
11986
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
11987
else
 
11988
  cat >conftest.$ac_ext <<_ACEOF
 
11989
#line $LINENO "configure"
 
11990
#include "confdefs.h"
 
11991
/* System header to define __stub macros and hopefully few prototypes,
 
11992
    which can conflict with char inet_ntop (); below.  */
 
11993
#include <assert.h>
 
11994
/* Override any gcc2 internal prototype to avoid an error.  */
 
11995
#ifdef __cplusplus
 
11996
extern "C"
 
11997
#endif
 
11998
/* We use char because int might match the return type of a gcc2
 
11999
   builtin and then its argument prototype would still apply.  */
 
12000
char inet_ntop ();
 
12001
char (*f) ();
 
12002
 
 
12003
#ifdef F77_DUMMY_MAIN
 
12004
#  ifdef __cplusplus
 
12005
     extern "C"
 
12006
#  endif
 
12007
   int F77_DUMMY_MAIN() { return 1; }
 
12008
#endif
 
12009
int
 
12010
main ()
 
12011
{
 
12012
/* The GNU C library defines this for functions which it implements
 
12013
    to always fail with ENOSYS.  Some functions are actually named
 
12014
    something starting with __ and the normal name is an alias.  */
 
12015
#if defined (__stub_inet_ntop) || defined (__stub___inet_ntop)
 
12016
choke me
 
12017
#else
 
12018
f = inet_ntop;
 
12019
#endif
 
12020
 
 
12021
  ;
 
12022
  return 0;
 
12023
}
 
12024
_ACEOF
 
12025
rm -f conftest.$ac_objext conftest$ac_exeext
 
12026
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
12027
  (eval $ac_link) 2>&5
 
12028
  ac_status=$?
 
12029
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12030
  (exit $ac_status); } &&
 
12031
         { ac_try='test -s conftest$ac_exeext'
 
12032
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
12033
  (eval $ac_try) 2>&5
 
12034
  ac_status=$?
 
12035
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12036
  (exit $ac_status); }; }; then
 
12037
  ac_cv_func_inet_ntop=yes
 
12038
else
 
12039
  echo "$as_me: failed program was:" >&5
 
12040
cat conftest.$ac_ext >&5
 
12041
ac_cv_func_inet_ntop=no
 
12042
fi
 
12043
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
12044
fi
 
12045
echo "$as_me:$LINENO: result: $ac_cv_func_inet_ntop" >&5
 
12046
echo "${ECHO_T}$ac_cv_func_inet_ntop" >&6
 
12047
if test $ac_cv_func_inet_ntop = yes; then
 
12048
 
 
12049
cat >>confdefs.h <<\_ACEOF
 
12050
#define HAVE_IPV6 1
 
12051
_ACEOF
 
12052
 
 
12053
                                                          HAVE_IPV6=yes
 
12054
fi
 
12055
 
 
12056
fi
 
12057
 
 
12058
 
 
12059
 
 
12060
echo "$as_me:$LINENO: checking for PS_STRINGS" >&5
 
12061
echo $ECHO_N "checking for PS_STRINGS... $ECHO_C" >&6
 
12062
if test "${pgac_cv_var_PS_STRINGS+set}" = set; then
 
12063
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
12064
else
 
12065
  cat >conftest.$ac_ext <<_ACEOF
 
12066
#line $LINENO "configure"
 
12067
#include "confdefs.h"
 
12068
#include <machine/vmparam.h>
 
12069
#include <sys/exec.h>
 
12070
 
 
12071
#ifdef F77_DUMMY_MAIN
 
12072
#  ifdef __cplusplus
 
12073
     extern "C"
 
12074
#  endif
 
12075
   int F77_DUMMY_MAIN() { return 1; }
 
12076
#endif
 
12077
int
 
12078
main ()
 
12079
{
 
12080
PS_STRINGS->ps_nargvstr = 1;
 
12081
PS_STRINGS->ps_argvstr = "foo";
 
12082
  ;
 
12083
  return 0;
 
12084
}
 
12085
_ACEOF
 
12086
rm -f conftest.$ac_objext conftest$ac_exeext
 
12087
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
12088
  (eval $ac_link) 2>&5
 
12089
  ac_status=$?
 
12090
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12091
  (exit $ac_status); } &&
 
12092
         { ac_try='test -s conftest$ac_exeext'
 
12093
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
12094
  (eval $ac_try) 2>&5
 
12095
  ac_status=$?
 
12096
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12097
  (exit $ac_status); }; }; then
 
12098
  pgac_cv_var_PS_STRINGS=yes
 
12099
else
 
12100
  echo "$as_me: failed program was:" >&5
 
12101
cat conftest.$ac_ext >&5
 
12102
pgac_cv_var_PS_STRINGS=no
 
12103
fi
 
12104
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
12105
fi
 
12106
echo "$as_me:$LINENO: result: $pgac_cv_var_PS_STRINGS" >&5
 
12107
echo "${ECHO_T}$pgac_cv_var_PS_STRINGS" >&6
 
12108
if test "$pgac_cv_var_PS_STRINGS" = yes ; then
 
12109
 
 
12110
cat >>confdefs.h <<\_ACEOF
 
12111
#define HAVE_PS_STRINGS
 
12112
_ACEOF
 
12113
 
 
12114
fi
 
12115
 
 
12116
 
 
12117
# We use our snprintf.c emulation if either snprintf() or vsnprintf()
 
12118
# is missing.  Yes, there are machines that have only one.  We may
 
12119
# also decide to use snprintf.c if snprintf() is present but does not
 
12120
# have working "long long int" support -- see below.
 
12121
 
 
12122
pgac_need_repl_snprintf=no
 
12123
 
 
12124
for ac_func in snprintf
 
12125
do
 
12126
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
 
12127
echo "$as_me:$LINENO: checking for $ac_func" >&5
 
12128
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
 
12129
if eval "test \"\${$as_ac_var+set}\" = set"; then
 
12130
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
12131
else
 
12132
  cat >conftest.$ac_ext <<_ACEOF
 
12133
#line $LINENO "configure"
 
12134
#include "confdefs.h"
 
12135
/* System header to define __stub macros and hopefully few prototypes,
 
12136
    which can conflict with char $ac_func (); below.  */
 
12137
#include <assert.h>
 
12138
/* Override any gcc2 internal prototype to avoid an error.  */
 
12139
#ifdef __cplusplus
 
12140
extern "C"
 
12141
#endif
 
12142
/* We use char because int might match the return type of a gcc2
 
12143
   builtin and then its argument prototype would still apply.  */
 
12144
char $ac_func ();
 
12145
char (*f) ();
 
12146
 
 
12147
#ifdef F77_DUMMY_MAIN
 
12148
#  ifdef __cplusplus
 
12149
     extern "C"
 
12150
#  endif
 
12151
   int F77_DUMMY_MAIN() { return 1; }
 
12152
#endif
 
12153
int
 
12154
main ()
 
12155
{
 
12156
/* The GNU C library defines this for functions which it implements
 
12157
    to always fail with ENOSYS.  Some functions are actually named
 
12158
    something starting with __ and the normal name is an alias.  */
 
12159
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
 
12160
choke me
 
12161
#else
 
12162
f = $ac_func;
 
12163
#endif
 
12164
 
 
12165
  ;
 
12166
  return 0;
 
12167
}
 
12168
_ACEOF
 
12169
rm -f conftest.$ac_objext conftest$ac_exeext
 
12170
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
12171
  (eval $ac_link) 2>&5
 
12172
  ac_status=$?
 
12173
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12174
  (exit $ac_status); } &&
 
12175
         { ac_try='test -s conftest$ac_exeext'
 
12176
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
12177
  (eval $ac_try) 2>&5
 
12178
  ac_status=$?
 
12179
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12180
  (exit $ac_status); }; }; then
 
12181
  eval "$as_ac_var=yes"
 
12182
else
 
12183
  echo "$as_me: failed program was:" >&5
 
12184
cat conftest.$ac_ext >&5
 
12185
eval "$as_ac_var=no"
 
12186
fi
 
12187
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
12188
fi
 
12189
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
 
12190
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
 
12191
if test `eval echo '${'$as_ac_var'}'` = yes; then
 
12192
  cat >>confdefs.h <<_ACEOF
 
12193
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
 
12194
_ACEOF
 
12195
 
 
12196
else
 
12197
  pgac_need_repl_snprintf=yes
 
12198
fi
 
12199
done
 
12200
 
 
12201
 
 
12202
for ac_func in vsnprintf
 
12203
do
 
12204
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
 
12205
echo "$as_me:$LINENO: checking for $ac_func" >&5
 
12206
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
 
12207
if eval "test \"\${$as_ac_var+set}\" = set"; then
 
12208
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
12209
else
 
12210
  cat >conftest.$ac_ext <<_ACEOF
 
12211
#line $LINENO "configure"
 
12212
#include "confdefs.h"
 
12213
/* System header to define __stub macros and hopefully few prototypes,
 
12214
    which can conflict with char $ac_func (); below.  */
 
12215
#include <assert.h>
 
12216
/* Override any gcc2 internal prototype to avoid an error.  */
 
12217
#ifdef __cplusplus
 
12218
extern "C"
 
12219
#endif
 
12220
/* We use char because int might match the return type of a gcc2
 
12221
   builtin and then its argument prototype would still apply.  */
 
12222
char $ac_func ();
 
12223
char (*f) ();
 
12224
 
 
12225
#ifdef F77_DUMMY_MAIN
 
12226
#  ifdef __cplusplus
 
12227
     extern "C"
 
12228
#  endif
 
12229
   int F77_DUMMY_MAIN() { return 1; }
 
12230
#endif
 
12231
int
 
12232
main ()
 
12233
{
 
12234
/* The GNU C library defines this for functions which it implements
 
12235
    to always fail with ENOSYS.  Some functions are actually named
 
12236
    something starting with __ and the normal name is an alias.  */
 
12237
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
 
12238
choke me
 
12239
#else
 
12240
f = $ac_func;
 
12241
#endif
 
12242
 
 
12243
  ;
 
12244
  return 0;
 
12245
}
 
12246
_ACEOF
 
12247
rm -f conftest.$ac_objext conftest$ac_exeext
 
12248
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
12249
  (eval $ac_link) 2>&5
 
12250
  ac_status=$?
 
12251
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12252
  (exit $ac_status); } &&
 
12253
         { ac_try='test -s conftest$ac_exeext'
 
12254
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
12255
  (eval $ac_try) 2>&5
 
12256
  ac_status=$?
 
12257
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12258
  (exit $ac_status); }; }; then
 
12259
  eval "$as_ac_var=yes"
 
12260
else
 
12261
  echo "$as_me: failed program was:" >&5
 
12262
cat conftest.$ac_ext >&5
 
12263
eval "$as_ac_var=no"
 
12264
fi
 
12265
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
12266
fi
 
12267
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
 
12268
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
 
12269
if test `eval echo '${'$as_ac_var'}'` = yes; then
 
12270
  cat >>confdefs.h <<_ACEOF
 
12271
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
 
12272
_ACEOF
 
12273
 
 
12274
else
 
12275
  pgac_need_repl_snprintf=yes
 
12276
fi
 
12277
done
 
12278
 
 
12279
 
 
12280
 
 
12281
# Check whether <stdio.h> declares snprintf() and vsnprintf(); if not,
 
12282
# include/c.h will provide declarations.  Note this is a separate test
 
12283
# from whether the functions exist in the C library --- there are
 
12284
# systems that have the functions but don't bother to declare them :-(
 
12285
 
 
12286
echo "$as_me:$LINENO: checking whether snprintf is declared" >&5
 
12287
echo $ECHO_N "checking whether snprintf is declared... $ECHO_C" >&6
 
12288
if test "${ac_cv_have_decl_snprintf+set}" = set; then
 
12289
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
12290
else
 
12291
  cat >conftest.$ac_ext <<_ACEOF
 
12292
#line $LINENO "configure"
 
12293
#include "confdefs.h"
 
12294
$ac_includes_default
 
12295
#ifdef F77_DUMMY_MAIN
 
12296
#  ifdef __cplusplus
 
12297
     extern "C"
 
12298
#  endif
 
12299
   int F77_DUMMY_MAIN() { return 1; }
 
12300
#endif
 
12301
int
 
12302
main ()
 
12303
{
 
12304
#ifndef snprintf
 
12305
  char *p = (char *) snprintf;
 
12306
#endif
 
12307
 
 
12308
  ;
 
12309
  return 0;
 
12310
}
 
12311
_ACEOF
 
12312
rm -f conftest.$ac_objext
 
12313
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
12314
  (eval $ac_compile) 2>&5
 
12315
  ac_status=$?
 
12316
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12317
  (exit $ac_status); } &&
 
12318
         { ac_try='test -s conftest.$ac_objext'
 
12319
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
12320
  (eval $ac_try) 2>&5
 
12321
  ac_status=$?
 
12322
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12323
  (exit $ac_status); }; }; then
 
12324
  ac_cv_have_decl_snprintf=yes
 
12325
else
 
12326
  echo "$as_me: failed program was:" >&5
 
12327
cat conftest.$ac_ext >&5
 
12328
ac_cv_have_decl_snprintf=no
 
12329
fi
 
12330
rm -f conftest.$ac_objext conftest.$ac_ext
 
12331
fi
 
12332
echo "$as_me:$LINENO: result: $ac_cv_have_decl_snprintf" >&5
 
12333
echo "${ECHO_T}$ac_cv_have_decl_snprintf" >&6
 
12334
if test $ac_cv_have_decl_snprintf = yes; then
 
12335
 
 
12336
cat >>confdefs.h <<_ACEOF
 
12337
#define HAVE_DECL_SNPRINTF 1
 
12338
_ACEOF
 
12339
 
 
12340
 
 
12341
else
 
12342
  cat >>confdefs.h <<_ACEOF
 
12343
#define HAVE_DECL_SNPRINTF 0
 
12344
_ACEOF
 
12345
 
 
12346
 
 
12347
fi
 
12348
echo "$as_me:$LINENO: checking whether vsnprintf is declared" >&5
 
12349
echo $ECHO_N "checking whether vsnprintf is declared... $ECHO_C" >&6
 
12350
if test "${ac_cv_have_decl_vsnprintf+set}" = set; then
 
12351
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
12352
else
 
12353
  cat >conftest.$ac_ext <<_ACEOF
 
12354
#line $LINENO "configure"
 
12355
#include "confdefs.h"
 
12356
$ac_includes_default
 
12357
#ifdef F77_DUMMY_MAIN
 
12358
#  ifdef __cplusplus
 
12359
     extern "C"
 
12360
#  endif
 
12361
   int F77_DUMMY_MAIN() { return 1; }
 
12362
#endif
 
12363
int
 
12364
main ()
 
12365
{
 
12366
#ifndef vsnprintf
 
12367
  char *p = (char *) vsnprintf;
 
12368
#endif
 
12369
 
 
12370
  ;
 
12371
  return 0;
 
12372
}
 
12373
_ACEOF
 
12374
rm -f conftest.$ac_objext
 
12375
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
12376
  (eval $ac_compile) 2>&5
 
12377
  ac_status=$?
 
12378
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12379
  (exit $ac_status); } &&
 
12380
         { ac_try='test -s conftest.$ac_objext'
 
12381
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
12382
  (eval $ac_try) 2>&5
 
12383
  ac_status=$?
 
12384
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12385
  (exit $ac_status); }; }; then
 
12386
  ac_cv_have_decl_vsnprintf=yes
 
12387
else
 
12388
  echo "$as_me: failed program was:" >&5
 
12389
cat conftest.$ac_ext >&5
 
12390
ac_cv_have_decl_vsnprintf=no
 
12391
fi
 
12392
rm -f conftest.$ac_objext conftest.$ac_ext
 
12393
fi
 
12394
echo "$as_me:$LINENO: result: $ac_cv_have_decl_vsnprintf" >&5
 
12395
echo "${ECHO_T}$ac_cv_have_decl_vsnprintf" >&6
 
12396
if test $ac_cv_have_decl_vsnprintf = yes; then
 
12397
 
 
12398
cat >>confdefs.h <<_ACEOF
 
12399
#define HAVE_DECL_VSNPRINTF 1
 
12400
_ACEOF
 
12401
 
 
12402
 
 
12403
else
 
12404
  cat >>confdefs.h <<_ACEOF
 
12405
#define HAVE_DECL_VSNPRINTF 0
 
12406
_ACEOF
 
12407
 
 
12408
 
 
12409
fi
 
12410
 
 
12411
 
 
12412
 
 
12413
 
 
12414
# do this one the hard way in case isinf() is a macro
 
12415
echo "$as_me:$LINENO: checking for isinf" >&5
 
12416
echo $ECHO_N "checking for isinf... $ECHO_C" >&6
 
12417
if test "${ac_cv_func_isinf+set}" = set; then
 
12418
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
12419
else
 
12420
  cat >conftest.$ac_ext <<_ACEOF
 
12421
#line $LINENO "configure"
 
12422
#include "confdefs.h"
 
12423
#include <math.h>
 
12424
 
 
12425
#ifdef F77_DUMMY_MAIN
 
12426
#  ifdef __cplusplus
 
12427
     extern "C"
 
12428
#  endif
 
12429
   int F77_DUMMY_MAIN() { return 1; }
 
12430
#endif
 
12431
int
 
12432
main ()
 
12433
{
 
12434
double x = 0.0; int res = isinf(x);
 
12435
  ;
 
12436
  return 0;
 
12437
}
 
12438
_ACEOF
 
12439
rm -f conftest.$ac_objext conftest$ac_exeext
 
12440
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
12441
  (eval $ac_link) 2>&5
 
12442
  ac_status=$?
 
12443
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12444
  (exit $ac_status); } &&
 
12445
         { ac_try='test -s conftest$ac_exeext'
 
12446
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
12447
  (eval $ac_try) 2>&5
 
12448
  ac_status=$?
 
12449
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12450
  (exit $ac_status); }; }; then
 
12451
  ac_cv_func_isinf=yes
 
12452
else
 
12453
  echo "$as_me: failed program was:" >&5
 
12454
cat conftest.$ac_ext >&5
 
12455
ac_cv_func_isinf=no
 
12456
fi
 
12457
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
12458
fi
 
12459
echo "$as_me:$LINENO: result: $ac_cv_func_isinf" >&5
 
12460
echo "${ECHO_T}$ac_cv_func_isinf" >&6
 
12461
 
 
12462
if test $ac_cv_func_isinf = yes ; then
 
12463
 
 
12464
cat >>confdefs.h <<\_ACEOF
 
12465
#define HAVE_ISINF 1
 
12466
_ACEOF
 
12467
 
 
12468
else
 
12469
  LIBOBJS="$LIBOBJS isinf.$ac_objext"
 
12470
  # Look for a way to implement a substitute for isinf()
 
12471
 
 
12472
 
 
12473
 
 
12474
 
 
12475
for ac_func in fpclass fp_class fp_class_d class
 
12476
do
 
12477
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
 
12478
echo "$as_me:$LINENO: checking for $ac_func" >&5
 
12479
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
 
12480
if eval "test \"\${$as_ac_var+set}\" = set"; then
 
12481
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
12482
else
 
12483
  cat >conftest.$ac_ext <<_ACEOF
 
12484
#line $LINENO "configure"
 
12485
#include "confdefs.h"
 
12486
/* System header to define __stub macros and hopefully few prototypes,
 
12487
    which can conflict with char $ac_func (); below.  */
 
12488
#include <assert.h>
 
12489
/* Override any gcc2 internal prototype to avoid an error.  */
 
12490
#ifdef __cplusplus
 
12491
extern "C"
 
12492
#endif
 
12493
/* We use char because int might match the return type of a gcc2
 
12494
   builtin and then its argument prototype would still apply.  */
 
12495
char $ac_func ();
 
12496
char (*f) ();
 
12497
 
 
12498
#ifdef F77_DUMMY_MAIN
 
12499
#  ifdef __cplusplus
 
12500
     extern "C"
 
12501
#  endif
 
12502
   int F77_DUMMY_MAIN() { return 1; }
 
12503
#endif
 
12504
int
 
12505
main ()
 
12506
{
 
12507
/* The GNU C library defines this for functions which it implements
 
12508
    to always fail with ENOSYS.  Some functions are actually named
 
12509
    something starting with __ and the normal name is an alias.  */
 
12510
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
 
12511
choke me
 
12512
#else
 
12513
f = $ac_func;
 
12514
#endif
 
12515
 
 
12516
  ;
 
12517
  return 0;
 
12518
}
 
12519
_ACEOF
 
12520
rm -f conftest.$ac_objext conftest$ac_exeext
 
12521
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
12522
  (eval $ac_link) 2>&5
 
12523
  ac_status=$?
 
12524
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12525
  (exit $ac_status); } &&
 
12526
         { ac_try='test -s conftest$ac_exeext'
 
12527
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
12528
  (eval $ac_try) 2>&5
 
12529
  ac_status=$?
 
12530
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12531
  (exit $ac_status); }; }; then
 
12532
  eval "$as_ac_var=yes"
 
12533
else
 
12534
  echo "$as_me: failed program was:" >&5
 
12535
cat conftest.$ac_ext >&5
 
12536
eval "$as_ac_var=no"
 
12537
fi
 
12538
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
12539
fi
 
12540
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
 
12541
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
 
12542
if test `eval echo '${'$as_ac_var'}'` = yes; then
 
12543
  cat >>confdefs.h <<_ACEOF
 
12544
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
 
12545
_ACEOF
 
12546
 break
 
12547
fi
 
12548
done
 
12549
 
 
12550
fi
 
12551
 
 
12552
 
 
12553
 
 
12554
 
 
12555
 
 
12556
 
 
12557
 
 
12558
 
 
12559
 
 
12560
 
 
12561
 
 
12562
 
 
12563
 
 
12564
 
 
12565
for ac_func in crypt fseeko getopt getrusage inet_aton random rint srandom strdup strerror strtol strtoul unsetenv
 
12566
do
 
12567
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
 
12568
echo "$as_me:$LINENO: checking for $ac_func" >&5
 
12569
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
 
12570
if eval "test \"\${$as_ac_var+set}\" = set"; then
 
12571
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
12572
else
 
12573
  cat >conftest.$ac_ext <<_ACEOF
 
12574
#line $LINENO "configure"
 
12575
#include "confdefs.h"
 
12576
/* System header to define __stub macros and hopefully few prototypes,
 
12577
    which can conflict with char $ac_func (); below.  */
 
12578
#include <assert.h>
 
12579
/* Override any gcc2 internal prototype to avoid an error.  */
 
12580
#ifdef __cplusplus
 
12581
extern "C"
 
12582
#endif
 
12583
/* We use char because int might match the return type of a gcc2
 
12584
   builtin and then its argument prototype would still apply.  */
 
12585
char $ac_func ();
 
12586
char (*f) ();
 
12587
 
 
12588
#ifdef F77_DUMMY_MAIN
 
12589
#  ifdef __cplusplus
 
12590
     extern "C"
 
12591
#  endif
 
12592
   int F77_DUMMY_MAIN() { return 1; }
 
12593
#endif
 
12594
int
 
12595
main ()
 
12596
{
 
12597
/* The GNU C library defines this for functions which it implements
 
12598
    to always fail with ENOSYS.  Some functions are actually named
 
12599
    something starting with __ and the normal name is an alias.  */
 
12600
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
 
12601
choke me
 
12602
#else
 
12603
f = $ac_func;
 
12604
#endif
 
12605
 
 
12606
  ;
 
12607
  return 0;
 
12608
}
 
12609
_ACEOF
 
12610
rm -f conftest.$ac_objext conftest$ac_exeext
 
12611
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
12612
  (eval $ac_link) 2>&5
 
12613
  ac_status=$?
 
12614
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12615
  (exit $ac_status); } &&
 
12616
         { ac_try='test -s conftest$ac_exeext'
 
12617
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
12618
  (eval $ac_try) 2>&5
 
12619
  ac_status=$?
 
12620
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12621
  (exit $ac_status); }; }; then
 
12622
  eval "$as_ac_var=yes"
 
12623
else
 
12624
  echo "$as_me: failed program was:" >&5
 
12625
cat conftest.$ac_ext >&5
 
12626
eval "$as_ac_var=no"
 
12627
fi
 
12628
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
12629
fi
 
12630
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
 
12631
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
 
12632
if test `eval echo '${'$as_ac_var'}'` = yes; then
 
12633
  cat >>confdefs.h <<_ACEOF
 
12634
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
 
12635
_ACEOF
 
12636
 
 
12637
else
 
12638
  LIBOBJS="$LIBOBJS $ac_func.$ac_objext"
 
12639
fi
 
12640
done
 
12641
 
 
12642
 
 
12643
 
 
12644
# system's version of getaddrinfo(), if any, may be used only if we found
 
12645
# a definition for struct addrinfo; see notes in src/include/getaddrinfo.h
 
12646
if test x"$ac_cv_type_struct_addrinfo" = xyes ; then
 
12647
 
 
12648
for ac_func in getaddrinfo
 
12649
do
 
12650
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
 
12651
echo "$as_me:$LINENO: checking for $ac_func" >&5
 
12652
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
 
12653
if eval "test \"\${$as_ac_var+set}\" = set"; then
 
12654
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
12655
else
 
12656
  cat >conftest.$ac_ext <<_ACEOF
 
12657
#line $LINENO "configure"
 
12658
#include "confdefs.h"
 
12659
/* System header to define __stub macros and hopefully few prototypes,
 
12660
    which can conflict with char $ac_func (); below.  */
 
12661
#include <assert.h>
 
12662
/* Override any gcc2 internal prototype to avoid an error.  */
 
12663
#ifdef __cplusplus
 
12664
extern "C"
 
12665
#endif
 
12666
/* We use char because int might match the return type of a gcc2
 
12667
   builtin and then its argument prototype would still apply.  */
 
12668
char $ac_func ();
 
12669
char (*f) ();
 
12670
 
 
12671
#ifdef F77_DUMMY_MAIN
 
12672
#  ifdef __cplusplus
 
12673
     extern "C"
 
12674
#  endif
 
12675
   int F77_DUMMY_MAIN() { return 1; }
 
12676
#endif
 
12677
int
 
12678
main ()
 
12679
{
 
12680
/* The GNU C library defines this for functions which it implements
 
12681
    to always fail with ENOSYS.  Some functions are actually named
 
12682
    something starting with __ and the normal name is an alias.  */
 
12683
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
 
12684
choke me
 
12685
#else
 
12686
f = $ac_func;
 
12687
#endif
 
12688
 
 
12689
  ;
 
12690
  return 0;
 
12691
}
 
12692
_ACEOF
 
12693
rm -f conftest.$ac_objext conftest$ac_exeext
 
12694
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
12695
  (eval $ac_link) 2>&5
 
12696
  ac_status=$?
 
12697
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12698
  (exit $ac_status); } &&
 
12699
         { ac_try='test -s conftest$ac_exeext'
 
12700
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
12701
  (eval $ac_try) 2>&5
 
12702
  ac_status=$?
 
12703
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12704
  (exit $ac_status); }; }; then
 
12705
  eval "$as_ac_var=yes"
 
12706
else
 
12707
  echo "$as_me: failed program was:" >&5
 
12708
cat conftest.$ac_ext >&5
 
12709
eval "$as_ac_var=no"
 
12710
fi
 
12711
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
12712
fi
 
12713
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
 
12714
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
 
12715
if test `eval echo '${'$as_ac_var'}'` = yes; then
 
12716
  cat >>confdefs.h <<_ACEOF
 
12717
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
 
12718
_ACEOF
 
12719
 
 
12720
else
 
12721
  LIBOBJS="$LIBOBJS $ac_func.$ac_objext"
 
12722
fi
 
12723
done
 
12724
 
 
12725
 
 
12726
else
 
12727
  LIBOBJS="$LIBOBJS getaddrinfo.$ac_objext"
 
12728
fi
 
12729
 
 
12730
# similarly, use system's getopt_long() only if system provides struct option.
 
12731
if test x"$ac_cv_type_struct_option" = xyes ; then
 
12732
 
 
12733
for ac_func in getopt_long
 
12734
do
 
12735
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
 
12736
echo "$as_me:$LINENO: checking for $ac_func" >&5
 
12737
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
 
12738
if eval "test \"\${$as_ac_var+set}\" = set"; then
 
12739
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
12740
else
 
12741
  cat >conftest.$ac_ext <<_ACEOF
 
12742
#line $LINENO "configure"
 
12743
#include "confdefs.h"
 
12744
/* System header to define __stub macros and hopefully few prototypes,
 
12745
    which can conflict with char $ac_func (); below.  */
 
12746
#include <assert.h>
 
12747
/* Override any gcc2 internal prototype to avoid an error.  */
 
12748
#ifdef __cplusplus
 
12749
extern "C"
 
12750
#endif
 
12751
/* We use char because int might match the return type of a gcc2
 
12752
   builtin and then its argument prototype would still apply.  */
 
12753
char $ac_func ();
 
12754
char (*f) ();
 
12755
 
 
12756
#ifdef F77_DUMMY_MAIN
 
12757
#  ifdef __cplusplus
 
12758
     extern "C"
 
12759
#  endif
 
12760
   int F77_DUMMY_MAIN() { return 1; }
 
12761
#endif
 
12762
int
 
12763
main ()
 
12764
{
 
12765
/* The GNU C library defines this for functions which it implements
 
12766
    to always fail with ENOSYS.  Some functions are actually named
 
12767
    something starting with __ and the normal name is an alias.  */
 
12768
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
 
12769
choke me
 
12770
#else
 
12771
f = $ac_func;
 
12772
#endif
 
12773
 
 
12774
  ;
 
12775
  return 0;
 
12776
}
 
12777
_ACEOF
 
12778
rm -f conftest.$ac_objext conftest$ac_exeext
 
12779
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
12780
  (eval $ac_link) 2>&5
 
12781
  ac_status=$?
 
12782
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12783
  (exit $ac_status); } &&
 
12784
         { ac_try='test -s conftest$ac_exeext'
 
12785
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
12786
  (eval $ac_try) 2>&5
 
12787
  ac_status=$?
 
12788
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12789
  (exit $ac_status); }; }; then
 
12790
  eval "$as_ac_var=yes"
 
12791
else
 
12792
  echo "$as_me: failed program was:" >&5
 
12793
cat conftest.$ac_ext >&5
 
12794
eval "$as_ac_var=no"
 
12795
fi
 
12796
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
12797
fi
 
12798
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
 
12799
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
 
12800
if test `eval echo '${'$as_ac_var'}'` = yes; then
 
12801
  cat >>confdefs.h <<_ACEOF
 
12802
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
 
12803
_ACEOF
 
12804
 
 
12805
else
 
12806
  LIBOBJS="$LIBOBJS $ac_func.$ac_objext"
 
12807
fi
 
12808
done
 
12809
 
 
12810
 
 
12811
else
 
12812
  LIBOBJS="$LIBOBJS getopt_long.$ac_objext"
 
12813
fi
 
12814
 
 
12815
# BSD/OS & NetBSD use a custom fseeko/ftello built on fsetpos/fgetpos
 
12816
# We override the previous test that said fseeko/ftello didn't exist
 
12817
# OS tests are also done in include/c.h and port/fseeko.c
 
12818
case $host_os in bsdi*|netbsd*)
 
12819
ac_cv_func_fseeko=yes
 
12820
esac
 
12821
 
 
12822
# Solaris has a very slow qsort in certain cases, so we replace it.
 
12823
if test "$PORTNAME" = "solaris"; then
 
12824
LIBOBJS="$LIBOBJS qsort.$ac_objext"
 
12825
fi
 
12826
 
 
12827
# Win32 support
 
12828
if test "$PORTNAME" = "win32"; then
 
12829
LIBOBJS="$LIBOBJS copydir.$ac_objext"
 
12830
LIBOBJS="$LIBOBJS gettimeofday.$ac_objext"
 
12831
LIBOBJS="$LIBOBJS kill.$ac_objext"
 
12832
LIBOBJS="$LIBOBJS open.$ac_objext"
 
12833
LIBOBJS="$LIBOBJS rand.$ac_objext"
 
12834
 
 
12835
cat >>confdefs.h <<\_ACEOF
 
12836
#define HAVE_SYMLINK 1
 
12837
_ACEOF
 
12838
 
 
12839
fi
 
12840
 
 
12841
if test "$with_readline" = yes; then
 
12842
  echo "$as_me:$LINENO: checking for rl_completion_append_character" >&5
 
12843
echo $ECHO_N "checking for rl_completion_append_character... $ECHO_C" >&6
 
12844
cat >conftest.$ac_ext <<_ACEOF
 
12845
#line $LINENO "configure"
 
12846
#include "confdefs.h"
 
12847
#include <stdio.h>
 
12848
#ifdef HAVE_READLINE_READLINE_H
 
12849
# include <readline/readline.h>
 
12850
#elif defined(HAVE_READLINE_H)
 
12851
# include <readline.h>
 
12852
#endif
 
12853
 
 
12854
#ifdef F77_DUMMY_MAIN
 
12855
#  ifdef __cplusplus
 
12856
     extern "C"
 
12857
#  endif
 
12858
   int F77_DUMMY_MAIN() { return 1; }
 
12859
#endif
 
12860
int
 
12861
main ()
 
12862
{
 
12863
rl_completion_append_character = 'x';
 
12864
  ;
 
12865
  return 0;
 
12866
}
 
12867
_ACEOF
 
12868
rm -f conftest.$ac_objext conftest$ac_exeext
 
12869
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
12870
  (eval $ac_link) 2>&5
 
12871
  ac_status=$?
 
12872
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12873
  (exit $ac_status); } &&
 
12874
         { ac_try='test -s conftest$ac_exeext'
 
12875
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
12876
  (eval $ac_try) 2>&5
 
12877
  ac_status=$?
 
12878
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12879
  (exit $ac_status); }; }; then
 
12880
  echo "$as_me:$LINENO: result: yes" >&5
 
12881
echo "${ECHO_T}yes" >&6
 
12882
 
 
12883
cat >>confdefs.h <<\_ACEOF
 
12884
#define HAVE_RL_COMPLETION_APPEND_CHARACTER 1
 
12885
_ACEOF
 
12886
 
 
12887
else
 
12888
  echo "$as_me: failed program was:" >&5
 
12889
cat conftest.$ac_ext >&5
 
12890
echo "$as_me:$LINENO: result: no" >&5
 
12891
echo "${ECHO_T}no" >&6
 
12892
fi
 
12893
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
12894
 
 
12895
 
 
12896
for ac_func in rl_completion_matches rl_filename_completion_function
 
12897
do
 
12898
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
 
12899
echo "$as_me:$LINENO: checking for $ac_func" >&5
 
12900
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
 
12901
if eval "test \"\${$as_ac_var+set}\" = set"; then
 
12902
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
12903
else
 
12904
  cat >conftest.$ac_ext <<_ACEOF
 
12905
#line $LINENO "configure"
 
12906
#include "confdefs.h"
 
12907
/* System header to define __stub macros and hopefully few prototypes,
 
12908
    which can conflict with char $ac_func (); below.  */
 
12909
#include <assert.h>
 
12910
/* Override any gcc2 internal prototype to avoid an error.  */
 
12911
#ifdef __cplusplus
 
12912
extern "C"
 
12913
#endif
 
12914
/* We use char because int might match the return type of a gcc2
 
12915
   builtin and then its argument prototype would still apply.  */
 
12916
char $ac_func ();
 
12917
char (*f) ();
 
12918
 
 
12919
#ifdef F77_DUMMY_MAIN
 
12920
#  ifdef __cplusplus
 
12921
     extern "C"
 
12922
#  endif
 
12923
   int F77_DUMMY_MAIN() { return 1; }
 
12924
#endif
 
12925
int
 
12926
main ()
 
12927
{
 
12928
/* The GNU C library defines this for functions which it implements
 
12929
    to always fail with ENOSYS.  Some functions are actually named
 
12930
    something starting with __ and the normal name is an alias.  */
 
12931
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
 
12932
choke me
 
12933
#else
 
12934
f = $ac_func;
 
12935
#endif
 
12936
 
 
12937
  ;
 
12938
  return 0;
 
12939
}
 
12940
_ACEOF
 
12941
rm -f conftest.$ac_objext conftest$ac_exeext
 
12942
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
12943
  (eval $ac_link) 2>&5
 
12944
  ac_status=$?
 
12945
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12946
  (exit $ac_status); } &&
 
12947
         { ac_try='test -s conftest$ac_exeext'
 
12948
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
12949
  (eval $ac_try) 2>&5
 
12950
  ac_status=$?
 
12951
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
12952
  (exit $ac_status); }; }; then
 
12953
  eval "$as_ac_var=yes"
 
12954
else
 
12955
  echo "$as_me: failed program was:" >&5
 
12956
cat conftest.$ac_ext >&5
 
12957
eval "$as_ac_var=no"
 
12958
fi
 
12959
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
12960
fi
 
12961
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
 
12962
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
 
12963
if test `eval echo '${'$as_ac_var'}'` = yes; then
 
12964
  cat >>confdefs.h <<_ACEOF
 
12965
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
 
12966
_ACEOF
 
12967
 
 
12968
fi
 
12969
done
 
12970
 
 
12971
 
 
12972
for ac_func in replace_history_entry
 
12973
do
 
12974
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
 
12975
echo "$as_me:$LINENO: checking for $ac_func" >&5
 
12976
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
 
12977
if eval "test \"\${$as_ac_var+set}\" = set"; then
 
12978
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
12979
else
 
12980
  cat >conftest.$ac_ext <<_ACEOF
 
12981
#line $LINENO "configure"
 
12982
#include "confdefs.h"
 
12983
/* System header to define __stub macros and hopefully few prototypes,
 
12984
    which can conflict with char $ac_func (); below.  */
 
12985
#include <assert.h>
 
12986
/* Override any gcc2 internal prototype to avoid an error.  */
 
12987
#ifdef __cplusplus
 
12988
extern "C"
 
12989
#endif
 
12990
/* We use char because int might match the return type of a gcc2
 
12991
   builtin and then its argument prototype would still apply.  */
 
12992
char $ac_func ();
 
12993
char (*f) ();
 
12994
 
 
12995
#ifdef F77_DUMMY_MAIN
 
12996
#  ifdef __cplusplus
 
12997
     extern "C"
 
12998
#  endif
 
12999
   int F77_DUMMY_MAIN() { return 1; }
 
13000
#endif
 
13001
int
 
13002
main ()
 
13003
{
 
13004
/* The GNU C library defines this for functions which it implements
 
13005
    to always fail with ENOSYS.  Some functions are actually named
 
13006
    something starting with __ and the normal name is an alias.  */
 
13007
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
 
13008
choke me
 
13009
#else
 
13010
f = $ac_func;
 
13011
#endif
 
13012
 
 
13013
  ;
 
13014
  return 0;
 
13015
}
 
13016
_ACEOF
 
13017
rm -f conftest.$ac_objext conftest$ac_exeext
 
13018
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
13019
  (eval $ac_link) 2>&5
 
13020
  ac_status=$?
 
13021
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13022
  (exit $ac_status); } &&
 
13023
         { ac_try='test -s conftest$ac_exeext'
 
13024
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
13025
  (eval $ac_try) 2>&5
 
13026
  ac_status=$?
 
13027
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13028
  (exit $ac_status); }; }; then
 
13029
  eval "$as_ac_var=yes"
 
13030
else
 
13031
  echo "$as_me: failed program was:" >&5
 
13032
cat conftest.$ac_ext >&5
 
13033
eval "$as_ac_var=no"
 
13034
fi
 
13035
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
13036
fi
 
13037
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
 
13038
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
 
13039
if test `eval echo '${'$as_ac_var'}'` = yes; then
 
13040
  cat >>confdefs.h <<_ACEOF
 
13041
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
 
13042
_ACEOF
 
13043
 
 
13044
fi
 
13045
done
 
13046
 
 
13047
fi
 
13048
 
 
13049
 
 
13050
echo "$as_me:$LINENO: checking for finite" >&5
 
13051
echo $ECHO_N "checking for finite... $ECHO_C" >&6
 
13052
cat >conftest.$ac_ext <<_ACEOF
 
13053
#line $LINENO "configure"
 
13054
#include "confdefs.h"
 
13055
#include <math.h>
 
13056
#ifdef F77_DUMMY_MAIN
 
13057
#  ifdef __cplusplus
 
13058
     extern "C"
 
13059
#  endif
 
13060
   int F77_DUMMY_MAIN() { return 1; }
 
13061
#endif
 
13062
int
 
13063
main ()
 
13064
{
 
13065
int dummy=finite(1.0);
 
13066
  ;
 
13067
  return 0;
 
13068
}
 
13069
_ACEOF
 
13070
rm -f conftest.$ac_objext conftest$ac_exeext
 
13071
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
13072
  (eval $ac_link) 2>&5
 
13073
  ac_status=$?
 
13074
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13075
  (exit $ac_status); } &&
 
13076
         { ac_try='test -s conftest$ac_exeext'
 
13077
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
13078
  (eval $ac_try) 2>&5
 
13079
  ac_status=$?
 
13080
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13081
  (exit $ac_status); }; }; then
 
13082
 
 
13083
cat >>confdefs.h <<\_ACEOF
 
13084
#define HAVE_FINITE 1
 
13085
_ACEOF
 
13086
 
 
13087
echo "$as_me:$LINENO: result: yes" >&5
 
13088
echo "${ECHO_T}yes" >&6
 
13089
else
 
13090
  echo "$as_me: failed program was:" >&5
 
13091
cat conftest.$ac_ext >&5
 
13092
echo "$as_me:$LINENO: result: no" >&5
 
13093
echo "${ECHO_T}no" >&6
 
13094
fi
 
13095
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
13096
 
 
13097
echo "$as_me:$LINENO: checking for sigsetjmp" >&5
 
13098
echo $ECHO_N "checking for sigsetjmp... $ECHO_C" >&6
 
13099
cat >conftest.$ac_ext <<_ACEOF
 
13100
#line $LINENO "configure"
 
13101
#include "confdefs.h"
 
13102
#include <setjmp.h>
 
13103
#ifdef F77_DUMMY_MAIN
 
13104
#  ifdef __cplusplus
 
13105
     extern "C"
 
13106
#  endif
 
13107
   int F77_DUMMY_MAIN() { return 1; }
 
13108
#endif
 
13109
int
 
13110
main ()
 
13111
{
 
13112
sigjmp_buf x; sigsetjmp(x, 1);
 
13113
  ;
 
13114
  return 0;
 
13115
}
 
13116
_ACEOF
 
13117
rm -f conftest.$ac_objext conftest$ac_exeext
 
13118
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
13119
  (eval $ac_link) 2>&5
 
13120
  ac_status=$?
 
13121
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13122
  (exit $ac_status); } &&
 
13123
         { ac_try='test -s conftest$ac_exeext'
 
13124
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
13125
  (eval $ac_try) 2>&5
 
13126
  ac_status=$?
 
13127
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13128
  (exit $ac_status); }; }; then
 
13129
 
 
13130
cat >>confdefs.h <<\_ACEOF
 
13131
#define HAVE_SIGSETJMP 1
 
13132
_ACEOF
 
13133
 
 
13134
echo "$as_me:$LINENO: result: yes" >&5
 
13135
echo "${ECHO_T}yes" >&6
 
13136
else
 
13137
  echo "$as_me: failed program was:" >&5
 
13138
cat conftest.$ac_ext >&5
 
13139
echo "$as_me:$LINENO: result: no" >&5
 
13140
echo "${ECHO_T}no" >&6
 
13141
fi
 
13142
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
13143
 
 
13144
echo "$as_me:$LINENO: checking for syslog" >&5
 
13145
echo $ECHO_N "checking for syslog... $ECHO_C" >&6
 
13146
if test "${ac_cv_func_syslog+set}" = set; then
 
13147
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
13148
else
 
13149
  cat >conftest.$ac_ext <<_ACEOF
 
13150
#line $LINENO "configure"
 
13151
#include "confdefs.h"
 
13152
/* System header to define __stub macros and hopefully few prototypes,
 
13153
    which can conflict with char syslog (); below.  */
 
13154
#include <assert.h>
 
13155
/* Override any gcc2 internal prototype to avoid an error.  */
 
13156
#ifdef __cplusplus
 
13157
extern "C"
 
13158
#endif
 
13159
/* We use char because int might match the return type of a gcc2
 
13160
   builtin and then its argument prototype would still apply.  */
 
13161
char syslog ();
 
13162
char (*f) ();
 
13163
 
 
13164
#ifdef F77_DUMMY_MAIN
 
13165
#  ifdef __cplusplus
 
13166
     extern "C"
 
13167
#  endif
 
13168
   int F77_DUMMY_MAIN() { return 1; }
 
13169
#endif
 
13170
int
 
13171
main ()
 
13172
{
 
13173
/* The GNU C library defines this for functions which it implements
 
13174
    to always fail with ENOSYS.  Some functions are actually named
 
13175
    something starting with __ and the normal name is an alias.  */
 
13176
#if defined (__stub_syslog) || defined (__stub___syslog)
 
13177
choke me
 
13178
#else
 
13179
f = syslog;
 
13180
#endif
 
13181
 
 
13182
  ;
 
13183
  return 0;
 
13184
}
 
13185
_ACEOF
 
13186
rm -f conftest.$ac_objext conftest$ac_exeext
 
13187
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
13188
  (eval $ac_link) 2>&5
 
13189
  ac_status=$?
 
13190
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13191
  (exit $ac_status); } &&
 
13192
         { ac_try='test -s conftest$ac_exeext'
 
13193
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
13194
  (eval $ac_try) 2>&5
 
13195
  ac_status=$?
 
13196
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13197
  (exit $ac_status); }; }; then
 
13198
  ac_cv_func_syslog=yes
 
13199
else
 
13200
  echo "$as_me: failed program was:" >&5
 
13201
cat conftest.$ac_ext >&5
 
13202
ac_cv_func_syslog=no
 
13203
fi
 
13204
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
13205
fi
 
13206
echo "$as_me:$LINENO: result: $ac_cv_func_syslog" >&5
 
13207
echo "${ECHO_T}$ac_cv_func_syslog" >&6
 
13208
if test $ac_cv_func_syslog = yes; then
 
13209
  if test "${ac_cv_header_syslog_h+set}" = set; then
 
13210
  echo "$as_me:$LINENO: checking for syslog.h" >&5
 
13211
echo $ECHO_N "checking for syslog.h... $ECHO_C" >&6
 
13212
if test "${ac_cv_header_syslog_h+set}" = set; then
 
13213
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
13214
fi
 
13215
echo "$as_me:$LINENO: result: $ac_cv_header_syslog_h" >&5
 
13216
echo "${ECHO_T}$ac_cv_header_syslog_h" >&6
 
13217
else
 
13218
  # Is the header compilable?
 
13219
echo "$as_me:$LINENO: checking syslog.h usability" >&5
 
13220
echo $ECHO_N "checking syslog.h usability... $ECHO_C" >&6
 
13221
cat >conftest.$ac_ext <<_ACEOF
 
13222
#line $LINENO "configure"
 
13223
#include "confdefs.h"
 
13224
$ac_includes_default
 
13225
#include <syslog.h>
 
13226
_ACEOF
 
13227
rm -f conftest.$ac_objext
 
13228
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
13229
  (eval $ac_compile) 2>&5
 
13230
  ac_status=$?
 
13231
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13232
  (exit $ac_status); } &&
 
13233
         { ac_try='test -s conftest.$ac_objext'
 
13234
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
13235
  (eval $ac_try) 2>&5
 
13236
  ac_status=$?
 
13237
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13238
  (exit $ac_status); }; }; then
 
13239
  ac_header_compiler=yes
 
13240
else
 
13241
  echo "$as_me: failed program was:" >&5
 
13242
cat conftest.$ac_ext >&5
 
13243
ac_header_compiler=no
 
13244
fi
 
13245
rm -f conftest.$ac_objext conftest.$ac_ext
 
13246
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
13247
echo "${ECHO_T}$ac_header_compiler" >&6
 
13248
 
 
13249
# Is the header present?
 
13250
echo "$as_me:$LINENO: checking syslog.h presence" >&5
 
13251
echo $ECHO_N "checking syslog.h presence... $ECHO_C" >&6
 
13252
cat >conftest.$ac_ext <<_ACEOF
 
13253
#line $LINENO "configure"
 
13254
#include "confdefs.h"
 
13255
#include <syslog.h>
 
13256
_ACEOF
 
13257
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
13258
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
13259
  ac_status=$?
 
13260
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
13261
  rm -f conftest.er1
 
13262
  cat conftest.err >&5
 
13263
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13264
  (exit $ac_status); } >/dev/null; then
 
13265
  if test -s conftest.err; then
 
13266
    ac_cpp_err=$ac_c_preproc_warn_flag
 
13267
  else
 
13268
    ac_cpp_err=
 
13269
  fi
 
13270
else
 
13271
  ac_cpp_err=yes
 
13272
fi
 
13273
if test -z "$ac_cpp_err"; then
 
13274
  ac_header_preproc=yes
 
13275
else
 
13276
  echo "$as_me: failed program was:" >&5
 
13277
  cat conftest.$ac_ext >&5
 
13278
  ac_header_preproc=no
 
13279
fi
 
13280
rm -f conftest.err conftest.$ac_ext
 
13281
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
13282
echo "${ECHO_T}$ac_header_preproc" >&6
 
13283
 
 
13284
# So?  What about this header?
 
13285
case $ac_header_compiler:$ac_header_preproc in
 
13286
  yes:no )
 
13287
    { echo "$as_me:$LINENO: WARNING: syslog.h: accepted by the compiler, rejected by the preprocessor!" >&5
 
13288
echo "$as_me: WARNING: syslog.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
13289
    { echo "$as_me:$LINENO: WARNING: syslog.h: proceeding with the preprocessor's result" >&5
 
13290
echo "$as_me: WARNING: syslog.h: proceeding with the preprocessor's result" >&2;};;
 
13291
  no:yes )
 
13292
    { echo "$as_me:$LINENO: WARNING: syslog.h: present but cannot be compiled" >&5
 
13293
echo "$as_me: WARNING: syslog.h: present but cannot be compiled" >&2;}
 
13294
    { echo "$as_me:$LINENO: WARNING: syslog.h: check for missing prerequisite headers?" >&5
 
13295
echo "$as_me: WARNING: syslog.h: check for missing prerequisite headers?" >&2;}
 
13296
    { echo "$as_me:$LINENO: WARNING: syslog.h: proceeding with the preprocessor's result" >&5
 
13297
echo "$as_me: WARNING: syslog.h: proceeding with the preprocessor's result" >&2;};;
 
13298
esac
 
13299
echo "$as_me:$LINENO: checking for syslog.h" >&5
 
13300
echo $ECHO_N "checking for syslog.h... $ECHO_C" >&6
 
13301
if test "${ac_cv_header_syslog_h+set}" = set; then
 
13302
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
13303
else
 
13304
  ac_cv_header_syslog_h=$ac_header_preproc
 
13305
fi
 
13306
echo "$as_me:$LINENO: result: $ac_cv_header_syslog_h" >&5
 
13307
echo "${ECHO_T}$ac_cv_header_syslog_h" >&6
 
13308
 
 
13309
fi
 
13310
if test $ac_cv_header_syslog_h = yes; then
 
13311
 
 
13312
cat >>confdefs.h <<\_ACEOF
 
13313
#define HAVE_SYSLOG 1
 
13314
_ACEOF
 
13315
 
 
13316
fi
 
13317
 
 
13318
 
 
13319
fi
 
13320
 
 
13321
 
 
13322
echo "$as_me:$LINENO: checking for optreset" >&5
 
13323
echo $ECHO_N "checking for optreset... $ECHO_C" >&6
 
13324
if test "${pgac_cv_var_int_optreset+set}" = set; then
 
13325
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
13326
else
 
13327
  cat >conftest.$ac_ext <<_ACEOF
 
13328
#line $LINENO "configure"
 
13329
#include "confdefs.h"
 
13330
#include <unistd.h>
 
13331
#ifdef F77_DUMMY_MAIN
 
13332
#  ifdef __cplusplus
 
13333
     extern "C"
 
13334
#  endif
 
13335
   int F77_DUMMY_MAIN() { return 1; }
 
13336
#endif
 
13337
int
 
13338
main ()
 
13339
{
 
13340
extern int optreset; optreset = 1;
 
13341
  ;
 
13342
  return 0;
 
13343
}
 
13344
_ACEOF
 
13345
rm -f conftest.$ac_objext conftest$ac_exeext
 
13346
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
13347
  (eval $ac_link) 2>&5
 
13348
  ac_status=$?
 
13349
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13350
  (exit $ac_status); } &&
 
13351
         { ac_try='test -s conftest$ac_exeext'
 
13352
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
13353
  (eval $ac_try) 2>&5
 
13354
  ac_status=$?
 
13355
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13356
  (exit $ac_status); }; }; then
 
13357
  pgac_cv_var_int_optreset=yes
 
13358
else
 
13359
  echo "$as_me: failed program was:" >&5
 
13360
cat conftest.$ac_ext >&5
 
13361
pgac_cv_var_int_optreset=no
 
13362
fi
 
13363
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
13364
fi
 
13365
echo "$as_me:$LINENO: result: $pgac_cv_var_int_optreset" >&5
 
13366
echo "${ECHO_T}$pgac_cv_var_int_optreset" >&6
 
13367
if test x"$pgac_cv_var_int_optreset" = x"yes"; then
 
13368
 
 
13369
cat >>confdefs.h <<\_ACEOF
 
13370
#define HAVE_INT_OPTRESET 1
 
13371
_ACEOF
 
13372
 
 
13373
fi
 
13374
 
 
13375
 
 
13376
 
 
13377
for ac_func in strtoll strtoq
 
13378
do
 
13379
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
 
13380
echo "$as_me:$LINENO: checking for $ac_func" >&5
 
13381
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
 
13382
if eval "test \"\${$as_ac_var+set}\" = set"; then
 
13383
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
13384
else
 
13385
  cat >conftest.$ac_ext <<_ACEOF
 
13386
#line $LINENO "configure"
 
13387
#include "confdefs.h"
 
13388
/* System header to define __stub macros and hopefully few prototypes,
 
13389
    which can conflict with char $ac_func (); below.  */
 
13390
#include <assert.h>
 
13391
/* Override any gcc2 internal prototype to avoid an error.  */
 
13392
#ifdef __cplusplus
 
13393
extern "C"
 
13394
#endif
 
13395
/* We use char because int might match the return type of a gcc2
 
13396
   builtin and then its argument prototype would still apply.  */
 
13397
char $ac_func ();
 
13398
char (*f) ();
 
13399
 
 
13400
#ifdef F77_DUMMY_MAIN
 
13401
#  ifdef __cplusplus
 
13402
     extern "C"
 
13403
#  endif
 
13404
   int F77_DUMMY_MAIN() { return 1; }
 
13405
#endif
 
13406
int
 
13407
main ()
 
13408
{
 
13409
/* The GNU C library defines this for functions which it implements
 
13410
    to always fail with ENOSYS.  Some functions are actually named
 
13411
    something starting with __ and the normal name is an alias.  */
 
13412
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
 
13413
choke me
 
13414
#else
 
13415
f = $ac_func;
 
13416
#endif
 
13417
 
 
13418
  ;
 
13419
  return 0;
 
13420
}
 
13421
_ACEOF
 
13422
rm -f conftest.$ac_objext conftest$ac_exeext
 
13423
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
13424
  (eval $ac_link) 2>&5
 
13425
  ac_status=$?
 
13426
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13427
  (exit $ac_status); } &&
 
13428
         { ac_try='test -s conftest$ac_exeext'
 
13429
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
13430
  (eval $ac_try) 2>&5
 
13431
  ac_status=$?
 
13432
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13433
  (exit $ac_status); }; }; then
 
13434
  eval "$as_ac_var=yes"
 
13435
else
 
13436
  echo "$as_me: failed program was:" >&5
 
13437
cat conftest.$ac_ext >&5
 
13438
eval "$as_ac_var=no"
 
13439
fi
 
13440
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
13441
fi
 
13442
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
 
13443
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
 
13444
if test `eval echo '${'$as_ac_var'}'` = yes; then
 
13445
  cat >>confdefs.h <<_ACEOF
 
13446
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
 
13447
_ACEOF
 
13448
 break
 
13449
fi
 
13450
done
 
13451
 
 
13452
 
 
13453
 
 
13454
for ac_func in strtoull strtouq
 
13455
do
 
13456
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
 
13457
echo "$as_me:$LINENO: checking for $ac_func" >&5
 
13458
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
 
13459
if eval "test \"\${$as_ac_var+set}\" = set"; then
 
13460
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
13461
else
 
13462
  cat >conftest.$ac_ext <<_ACEOF
 
13463
#line $LINENO "configure"
 
13464
#include "confdefs.h"
 
13465
/* System header to define __stub macros and hopefully few prototypes,
 
13466
    which can conflict with char $ac_func (); below.  */
 
13467
#include <assert.h>
 
13468
/* Override any gcc2 internal prototype to avoid an error.  */
 
13469
#ifdef __cplusplus
 
13470
extern "C"
 
13471
#endif
 
13472
/* We use char because int might match the return type of a gcc2
 
13473
   builtin and then its argument prototype would still apply.  */
 
13474
char $ac_func ();
 
13475
char (*f) ();
 
13476
 
 
13477
#ifdef F77_DUMMY_MAIN
 
13478
#  ifdef __cplusplus
 
13479
     extern "C"
 
13480
#  endif
 
13481
   int F77_DUMMY_MAIN() { return 1; }
 
13482
#endif
 
13483
int
 
13484
main ()
 
13485
{
 
13486
/* The GNU C library defines this for functions which it implements
 
13487
    to always fail with ENOSYS.  Some functions are actually named
 
13488
    something starting with __ and the normal name is an alias.  */
 
13489
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
 
13490
choke me
 
13491
#else
 
13492
f = $ac_func;
 
13493
#endif
 
13494
 
 
13495
  ;
 
13496
  return 0;
 
13497
}
 
13498
_ACEOF
 
13499
rm -f conftest.$ac_objext conftest$ac_exeext
 
13500
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
13501
  (eval $ac_link) 2>&5
 
13502
  ac_status=$?
 
13503
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13504
  (exit $ac_status); } &&
 
13505
         { ac_try='test -s conftest$ac_exeext'
 
13506
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
13507
  (eval $ac_try) 2>&5
 
13508
  ac_status=$?
 
13509
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13510
  (exit $ac_status); }; }; then
 
13511
  eval "$as_ac_var=yes"
 
13512
else
 
13513
  echo "$as_me: failed program was:" >&5
 
13514
cat conftest.$ac_ext >&5
 
13515
eval "$as_ac_var=no"
 
13516
fi
 
13517
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
13518
fi
 
13519
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
 
13520
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
 
13521
if test `eval echo '${'$as_ac_var'}'` = yes; then
 
13522
  cat >>confdefs.h <<_ACEOF
 
13523
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
 
13524
_ACEOF
 
13525
 break
 
13526
fi
 
13527
done
 
13528
 
 
13529
 
 
13530
# Check for one of atexit() or on_exit()
 
13531
 
 
13532
for ac_func in atexit
 
13533
do
 
13534
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
 
13535
echo "$as_me:$LINENO: checking for $ac_func" >&5
 
13536
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
 
13537
if eval "test \"\${$as_ac_var+set}\" = set"; then
 
13538
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
13539
else
 
13540
  cat >conftest.$ac_ext <<_ACEOF
 
13541
#line $LINENO "configure"
 
13542
#include "confdefs.h"
 
13543
/* System header to define __stub macros and hopefully few prototypes,
 
13544
    which can conflict with char $ac_func (); below.  */
 
13545
#include <assert.h>
 
13546
/* Override any gcc2 internal prototype to avoid an error.  */
 
13547
#ifdef __cplusplus
 
13548
extern "C"
 
13549
#endif
 
13550
/* We use char because int might match the return type of a gcc2
 
13551
   builtin and then its argument prototype would still apply.  */
 
13552
char $ac_func ();
 
13553
char (*f) ();
 
13554
 
 
13555
#ifdef F77_DUMMY_MAIN
 
13556
#  ifdef __cplusplus
 
13557
     extern "C"
 
13558
#  endif
 
13559
   int F77_DUMMY_MAIN() { return 1; }
 
13560
#endif
 
13561
int
 
13562
main ()
 
13563
{
 
13564
/* The GNU C library defines this for functions which it implements
 
13565
    to always fail with ENOSYS.  Some functions are actually named
 
13566
    something starting with __ and the normal name is an alias.  */
 
13567
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
 
13568
choke me
 
13569
#else
 
13570
f = $ac_func;
 
13571
#endif
 
13572
 
 
13573
  ;
 
13574
  return 0;
 
13575
}
 
13576
_ACEOF
 
13577
rm -f conftest.$ac_objext conftest$ac_exeext
 
13578
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
13579
  (eval $ac_link) 2>&5
 
13580
  ac_status=$?
 
13581
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13582
  (exit $ac_status); } &&
 
13583
         { ac_try='test -s conftest$ac_exeext'
 
13584
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
13585
  (eval $ac_try) 2>&5
 
13586
  ac_status=$?
 
13587
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13588
  (exit $ac_status); }; }; then
 
13589
  eval "$as_ac_var=yes"
 
13590
else
 
13591
  echo "$as_me: failed program was:" >&5
 
13592
cat conftest.$ac_ext >&5
 
13593
eval "$as_ac_var=no"
 
13594
fi
 
13595
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
13596
fi
 
13597
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
 
13598
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
 
13599
if test `eval echo '${'$as_ac_var'}'` = yes; then
 
13600
  cat >>confdefs.h <<_ACEOF
 
13601
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
 
13602
_ACEOF
 
13603
 
 
13604
else
 
13605
 
 
13606
for ac_func in on_exit
 
13607
do
 
13608
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
 
13609
echo "$as_me:$LINENO: checking for $ac_func" >&5
 
13610
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
 
13611
if eval "test \"\${$as_ac_var+set}\" = set"; then
 
13612
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
13613
else
 
13614
  cat >conftest.$ac_ext <<_ACEOF
 
13615
#line $LINENO "configure"
 
13616
#include "confdefs.h"
 
13617
/* System header to define __stub macros and hopefully few prototypes,
 
13618
    which can conflict with char $ac_func (); below.  */
 
13619
#include <assert.h>
 
13620
/* Override any gcc2 internal prototype to avoid an error.  */
 
13621
#ifdef __cplusplus
 
13622
extern "C"
 
13623
#endif
 
13624
/* We use char because int might match the return type of a gcc2
 
13625
   builtin and then its argument prototype would still apply.  */
 
13626
char $ac_func ();
 
13627
char (*f) ();
 
13628
 
 
13629
#ifdef F77_DUMMY_MAIN
 
13630
#  ifdef __cplusplus
 
13631
     extern "C"
 
13632
#  endif
 
13633
   int F77_DUMMY_MAIN() { return 1; }
 
13634
#endif
 
13635
int
 
13636
main ()
 
13637
{
 
13638
/* The GNU C library defines this for functions which it implements
 
13639
    to always fail with ENOSYS.  Some functions are actually named
 
13640
    something starting with __ and the normal name is an alias.  */
 
13641
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
 
13642
choke me
 
13643
#else
 
13644
f = $ac_func;
 
13645
#endif
 
13646
 
 
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>&5
 
13654
  ac_status=$?
 
13655
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13656
  (exit $ac_status); } &&
 
13657
         { ac_try='test -s conftest$ac_exeext'
 
13658
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
13659
  (eval $ac_try) 2>&5
 
13660
  ac_status=$?
 
13661
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13662
  (exit $ac_status); }; }; then
 
13663
  eval "$as_ac_var=yes"
 
13664
else
 
13665
  echo "$as_me: failed program was:" >&5
 
13666
cat conftest.$ac_ext >&5
 
13667
eval "$as_ac_var=no"
 
13668
fi
 
13669
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
13670
fi
 
13671
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
 
13672
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
 
13673
if test `eval echo '${'$as_ac_var'}'` = yes; then
 
13674
  cat >>confdefs.h <<_ACEOF
 
13675
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
 
13676
_ACEOF
 
13677
 
 
13678
else
 
13679
  { { echo "$as_me:$LINENO: error: neither atexit() nor on_exit() found" >&5
 
13680
echo "$as_me: error: neither atexit() nor on_exit() found" >&2;}
 
13681
   { (exit 1); exit 1; }; }
 
13682
fi
 
13683
done
 
13684
 
 
13685
fi
 
13686
done
 
13687
 
 
13688
 
 
13689
echo "$as_me:$LINENO: checking for _LARGEFILE_SOURCE value needed for large files" >&5
 
13690
echo $ECHO_N "checking for _LARGEFILE_SOURCE value needed for large files... $ECHO_C" >&6
 
13691
if test "${ac_cv_sys_largefile_source+set}" = set; then
 
13692
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
13693
else
 
13694
  while :; do
 
13695
  ac_cv_sys_largefile_source=no
 
13696
  cat >conftest.$ac_ext <<_ACEOF
 
13697
#line $LINENO "configure"
 
13698
#include "confdefs.h"
 
13699
#include <stdio.h>
 
13700
#ifdef F77_DUMMY_MAIN
 
13701
#  ifdef __cplusplus
 
13702
     extern "C"
 
13703
#  endif
 
13704
   int F77_DUMMY_MAIN() { return 1; }
 
13705
#endif
 
13706
int
 
13707
main ()
 
13708
{
 
13709
return !fseeko;
 
13710
  ;
 
13711
  return 0;
 
13712
}
 
13713
_ACEOF
 
13714
rm -f conftest.$ac_objext
 
13715
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
13716
  (eval $ac_compile) 2>&5
 
13717
  ac_status=$?
 
13718
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13719
  (exit $ac_status); } &&
 
13720
         { ac_try='test -s conftest.$ac_objext'
 
13721
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
13722
  (eval $ac_try) 2>&5
 
13723
  ac_status=$?
 
13724
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13725
  (exit $ac_status); }; }; then
 
13726
  break
 
13727
else
 
13728
  echo "$as_me: failed program was:" >&5
 
13729
cat conftest.$ac_ext >&5
 
13730
fi
 
13731
rm -f conftest.$ac_objext conftest.$ac_ext
 
13732
  cat >conftest.$ac_ext <<_ACEOF
 
13733
#line $LINENO "configure"
 
13734
#include "confdefs.h"
 
13735
#define _LARGEFILE_SOURCE 1
 
13736
#include <stdio.h>
 
13737
#ifdef F77_DUMMY_MAIN
 
13738
#  ifdef __cplusplus
 
13739
     extern "C"
 
13740
#  endif
 
13741
   int F77_DUMMY_MAIN() { return 1; }
 
13742
#endif
 
13743
int
 
13744
main ()
 
13745
{
 
13746
return !fseeko;
 
13747
  ;
 
13748
  return 0;
 
13749
}
 
13750
_ACEOF
 
13751
rm -f conftest.$ac_objext
 
13752
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
13753
  (eval $ac_compile) 2>&5
 
13754
  ac_status=$?
 
13755
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13756
  (exit $ac_status); } &&
 
13757
         { ac_try='test -s conftest.$ac_objext'
 
13758
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
13759
  (eval $ac_try) 2>&5
 
13760
  ac_status=$?
 
13761
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13762
  (exit $ac_status); }; }; then
 
13763
  ac_cv_sys_largefile_source=1; break
 
13764
else
 
13765
  echo "$as_me: failed program was:" >&5
 
13766
cat conftest.$ac_ext >&5
 
13767
fi
 
13768
rm -f conftest.$ac_objext conftest.$ac_ext
 
13769
  break
 
13770
done
 
13771
fi
 
13772
echo "$as_me:$LINENO: result: $ac_cv_sys_largefile_source" >&5
 
13773
echo "${ECHO_T}$ac_cv_sys_largefile_source" >&6
 
13774
if test "$ac_cv_sys_largefile_source" != no; then
 
13775
 
 
13776
cat >>confdefs.h <<_ACEOF
 
13777
#define _LARGEFILE_SOURCE $ac_cv_sys_largefile_source
 
13778
_ACEOF
 
13779
 
 
13780
fi
 
13781
rm -f conftest*
 
13782
 
 
13783
# We used to try defining _XOPEN_SOURCE=500 too, to work around a bug
 
13784
# in glibc 2.1.3, but that breaks too many other things.
 
13785
# If you want fseeko and ftello with glibc, upgrade to a fixed glibc.
 
13786
echo "$as_me:$LINENO: checking for fseeko" >&5
 
13787
echo $ECHO_N "checking for fseeko... $ECHO_C" >&6
 
13788
if test "${ac_cv_func_fseeko+set}" = set; then
 
13789
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
13790
else
 
13791
  cat >conftest.$ac_ext <<_ACEOF
 
13792
#line $LINENO "configure"
 
13793
#include "confdefs.h"
 
13794
#include <stdio.h>
 
13795
#ifdef F77_DUMMY_MAIN
 
13796
#  ifdef __cplusplus
 
13797
     extern "C"
 
13798
#  endif
 
13799
   int F77_DUMMY_MAIN() { return 1; }
 
13800
#endif
 
13801
int
 
13802
main ()
 
13803
{
 
13804
return fseeko && fseeko (stdin, 0, 0);
 
13805
  ;
 
13806
  return 0;
 
13807
}
 
13808
_ACEOF
 
13809
rm -f conftest.$ac_objext conftest$ac_exeext
 
13810
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
13811
  (eval $ac_link) 2>&5
 
13812
  ac_status=$?
 
13813
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13814
  (exit $ac_status); } &&
 
13815
         { ac_try='test -s conftest$ac_exeext'
 
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); }; }; then
 
13821
  ac_cv_func_fseeko=yes
 
13822
else
 
13823
  echo "$as_me: failed program was:" >&5
 
13824
cat conftest.$ac_ext >&5
 
13825
ac_cv_func_fseeko=no
 
13826
fi
 
13827
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
13828
fi
 
13829
echo "$as_me:$LINENO: result: $ac_cv_func_fseeko" >&5
 
13830
echo "${ECHO_T}$ac_cv_func_fseeko" >&6
 
13831
if test $ac_cv_func_fseeko = yes; then
 
13832
 
 
13833
cat >>confdefs.h <<\_ACEOF
 
13834
#define HAVE_FSEEKO 1
 
13835
_ACEOF
 
13836
 
 
13837
fi
 
13838
 
 
13839
 
 
13840
#
 
13841
# Pthreads
 
13842
#
 
13843
# For each platform, we need to know about any special compile and link
 
13844
# libraries, and whether the normal C function names are thread-safe.
 
13845
# See the comment at the top of src/port/thread.c for more information.
 
13846
#
 
13847
if test "$enable_thread_safety" = yes; then
 
13848
 
 
13849
 
 
13850
 
 
13851
 
 
13852
ac_ext=c
 
13853
ac_cpp='$CPP $CPPFLAGS'
 
13854
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
13855
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
13856
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
13857
 
 
13858
acx_pthread_ok=no
 
13859
 
 
13860
# We used to check for pthread.h first, but this fails if pthread.h
 
13861
# requires special compiler flags (e.g. on True64 or Sequent).
 
13862
# It gets checked for in the link test anyway.
 
13863
 
 
13864
# First of all, check if the user has set any of the PTHREAD_LIBS,
 
13865
# etcetera environment variables, and if threads linking works using
 
13866
# them:
 
13867
if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then
 
13868
        save_CFLAGS="$CFLAGS"
 
13869
        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
 
13870
        save_LIBS="$LIBS"
 
13871
        LIBS="$PTHREAD_LIBS $LIBS"
 
13872
        echo "$as_me:$LINENO: checking for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS" >&5
 
13873
echo $ECHO_N "checking for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS... $ECHO_C" >&6
 
13874
        cat >conftest.$ac_ext <<_ACEOF
 
13875
#line $LINENO "configure"
 
13876
#include "confdefs.h"
 
13877
 
 
13878
/* Override any gcc2 internal prototype to avoid an error.  */
 
13879
#ifdef __cplusplus
 
13880
extern "C"
 
13881
#endif
 
13882
/* We use char because int might match the return type of a gcc2
 
13883
   builtin and then its argument prototype would still apply.  */
 
13884
char pthread_join ();
 
13885
#ifdef F77_DUMMY_MAIN
 
13886
#  ifdef __cplusplus
 
13887
     extern "C"
 
13888
#  endif
 
13889
   int F77_DUMMY_MAIN() { return 1; }
 
13890
#endif
 
13891
int
 
13892
main ()
 
13893
{
 
13894
pthread_join ();
 
13895
  ;
 
13896
  return 0;
 
13897
}
 
13898
_ACEOF
 
13899
rm -f conftest.$ac_objext conftest$ac_exeext
 
13900
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
13901
  (eval $ac_link) 2>&5
 
13902
  ac_status=$?
 
13903
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13904
  (exit $ac_status); } &&
 
13905
         { ac_try='test -s conftest$ac_exeext'
 
13906
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
13907
  (eval $ac_try) 2>&5
 
13908
  ac_status=$?
 
13909
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
13910
  (exit $ac_status); }; }; then
 
13911
  acx_pthread_ok=yes
 
13912
else
 
13913
  echo "$as_me: failed program was:" >&5
 
13914
cat conftest.$ac_ext >&5
 
13915
fi
 
13916
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
13917
        echo "$as_me:$LINENO: result: $acx_pthread_ok" >&5
 
13918
echo "${ECHO_T}$acx_pthread_ok" >&6
 
13919
        if test x"$acx_pthread_ok" = xno; then
 
13920
                PTHREAD_LIBS=""
 
13921
                PTHREAD_CFLAGS=""
 
13922
        fi
 
13923
        LIBS="$save_LIBS"
 
13924
        CFLAGS="$save_CFLAGS"
 
13925
fi
 
13926
 
 
13927
# We must check for the threads library under a number of different
 
13928
# names; the ordering is very important because some systems
 
13929
# (e.g. DEC) have both -lpthread and -lpthreads, where one of the
 
13930
# libraries is broken (non-POSIX).
 
13931
 
 
13932
# Create a list of thread flags to try.  Items starting with a "-" are
 
13933
# C compiler flags, and other items are library names, except for "none"
 
13934
# which indicates that we try without any flags at all, and "pthread-config"
 
13935
# which is a program returning the flags for the Pth emulation library.
 
13936
 
 
13937
acx_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config"
 
13938
 
 
13939
# The ordering *is* (sometimes) important.  Some notes on the
 
13940
# individual items follow:
 
13941
 
 
13942
# pthreads: AIX (must check this before -lpthread)
 
13943
# none: in case threads are in libc; should be tried before -Kthread and
 
13944
#       other compiler flags to prevent continual compiler warnings
 
13945
# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)
 
13946
# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
 
13947
# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
 
13948
# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads)
 
13949
# -pthreads: Solaris/gcc
 
13950
# -mthreads: Mingw32/gcc, Lynx/gcc
 
13951
# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
 
13952
#      doesn't hurt to check since this sometimes defines pthreads too;
 
13953
#      also defines -D_REENTRANT)
 
13954
# pthread: Linux, etcetera
 
13955
# --thread-safe: KAI C++
 
13956
# pthread-config: use pthread-config program (for GNU Pth library)
 
13957
 
 
13958
case "${host_cpu}-${host_os}" in
 
13959
        *solaris*)
 
13960
 
 
13961
        # On Solaris (at least, for some versions), libc contains stubbed
 
13962
        # (non-functional) versions of the pthreads routines, so link-based
 
13963
        # tests will erroneously succeed.  (We need to link with -pthread or
 
13964
        # -lpthread.)  (The stubs are missing pthread_cleanup_push, or rather
 
13965
        # a function called by this macro, so we could check for that, but
 
13966
        # who knows whether they'll stub that too in a future libc.)  So,
 
13967
        # we'll just look for -pthreads and -lpthread first:
 
13968
 
 
13969
        acx_pthread_flags="-pthread -pthreads pthread -mt $acx_pthread_flags"
 
13970
        ;;
 
13971
esac
 
13972
 
 
13973
if test x"$acx_pthread_ok" = xno; then
 
13974
for flag in $acx_pthread_flags; do
 
13975
 
 
13976
        tryPTHREAD_CFLAGS=""
 
13977
        tryPTHREAD_LIBS=""
 
13978
        case $flag in
 
13979
                none)
 
13980
                echo "$as_me:$LINENO: checking whether pthreads work without any flags" >&5
 
13981
echo $ECHO_N "checking whether pthreads work without any flags... $ECHO_C" >&6
 
13982
                ;;
 
13983
 
 
13984
                -*)
 
13985
                echo "$as_me:$LINENO: checking whether pthreads work with $flag" >&5
 
13986
echo $ECHO_N "checking whether pthreads work with $flag... $ECHO_C" >&6
 
13987
                tryPTHREAD_CFLAGS="$flag"
 
13988
                ;;
 
13989
 
 
13990
                pthread-config)
 
13991
                # skip this if we already have flags defined, for PostgreSQL
 
13992
                if test x"$PTHREAD_CFLAGS" != x -o x"$PTHREAD_LIBS" != x; then continue; fi
 
13993
                # Extract the first word of "pthread-config", so it can be a program name with args.
 
13994
set dummy pthread-config; ac_word=$2
 
13995
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
13996
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
13997
if test "${ac_cv_prog_acx_pthread_config+set}" = set; then
 
13998
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
13999
else
 
14000
  if test -n "$acx_pthread_config"; then
 
14001
  ac_cv_prog_acx_pthread_config="$acx_pthread_config" # Let the user override the test.
 
14002
else
 
14003
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
14004
for as_dir in $PATH
 
14005
do
 
14006
  IFS=$as_save_IFS
 
14007
  test -z "$as_dir" && as_dir=.
 
14008
  for ac_exec_ext in '' $ac_executable_extensions; do
 
14009
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
14010
    ac_cv_prog_acx_pthread_config="yes"
 
14011
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
14012
    break 2
 
14013
  fi
 
14014
done
 
14015
done
 
14016
 
 
14017
  test -z "$ac_cv_prog_acx_pthread_config" && ac_cv_prog_acx_pthread_config="no"
 
14018
fi
 
14019
fi
 
14020
acx_pthread_config=$ac_cv_prog_acx_pthread_config
 
14021
if test -n "$acx_pthread_config"; then
 
14022
  echo "$as_me:$LINENO: result: $acx_pthread_config" >&5
 
14023
echo "${ECHO_T}$acx_pthread_config" >&6
 
14024
else
 
14025
  echo "$as_me:$LINENO: result: no" >&5
 
14026
echo "${ECHO_T}no" >&6
 
14027
fi
 
14028
 
 
14029
                if test x"$acx_pthread_config" = xno; then continue; fi
 
14030
                tryPTHREAD_CFLAGS="`pthread-config --cflags`"
 
14031
                tryPTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"
 
14032
                ;;
 
14033
 
 
14034
                *)
 
14035
                echo "$as_me:$LINENO: checking for the pthreads library -l$flag" >&5
 
14036
echo $ECHO_N "checking for the pthreads library -l$flag... $ECHO_C" >&6
 
14037
                tryPTHREAD_LIBS="-l$flag"
 
14038
                ;;
 
14039
        esac
 
14040
 
 
14041
        save_LIBS="$LIBS"
 
14042
        save_CFLAGS="$CFLAGS"
 
14043
        LIBS="$tryPTHREAD_LIBS $PTHREAD_LIBS $LIBS"
 
14044
        CFLAGS="$CFLAGS $PTHREAD_CFLAGS $tryPTHREAD_CFLAGS"
 
14045
 
 
14046
        # Check for various functions.  We must include pthread.h,
 
14047
        # since some functions may be macros.  (On the Sequent, we
 
14048
        # need a special flag -Kthread to make this header compile.)
 
14049
        # We check for pthread_join because it is in -lpthread on IRIX
 
14050
        # while pthread_create is in libc.  We check for pthread_attr_init
 
14051
        # due to DEC craziness with -lpthreads.  We check for
 
14052
        # pthread_cleanup_push because it is one of the few pthread
 
14053
        # functions on Solaris that doesn't have a non-functional libc stub.
 
14054
        # We try pthread_create on general principles.
 
14055
        cat >conftest.$ac_ext <<_ACEOF
 
14056
#line $LINENO "configure"
 
14057
#include "confdefs.h"
 
14058
#include <pthread.h>
 
14059
#ifdef F77_DUMMY_MAIN
 
14060
#  ifdef __cplusplus
 
14061
     extern "C"
 
14062
#  endif
 
14063
   int F77_DUMMY_MAIN() { return 1; }
 
14064
#endif
 
14065
int
 
14066
main ()
 
14067
{
 
14068
pthread_t th; pthread_join(th, 0);
 
14069
                     pthread_attr_init(0); pthread_cleanup_push(0, 0);
 
14070
                     pthread_create(0,0,0,0); pthread_cleanup_pop(0);
 
14071
  ;
 
14072
  return 0;
 
14073
}
 
14074
_ACEOF
 
14075
rm -f conftest.$ac_objext conftest$ac_exeext
 
14076
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
14077
  (eval $ac_link) 2>&5
 
14078
  ac_status=$?
 
14079
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14080
  (exit $ac_status); } &&
 
14081
         { ac_try='test -s conftest$ac_exeext'
 
14082
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
14083
  (eval $ac_try) 2>&5
 
14084
  ac_status=$?
 
14085
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14086
  (exit $ac_status); }; }; then
 
14087
  acx_pthread_ok=yes
 
14088
else
 
14089
  echo "$as_me: failed program was:" >&5
 
14090
cat conftest.$ac_ext >&5
 
14091
acx_pthread_ok=no
 
14092
fi
 
14093
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
14094
 
 
14095
        if test "x$acx_pthread_ok" = xyes; then
 
14096
            # Don't use options that are ignored by the compiler.
 
14097
            # We find them by checking stderror.
 
14098
            cat >conftest.$ac_ext <<_ACEOF
 
14099
int
 
14100
main (int argc, char **argv)
 
14101
{
 
14102
  (void) argc;
 
14103
  (void) argv;
 
14104
  return 0;
 
14105
}
 
14106
_ACEOF
 
14107
            rm -f conftest.$ac_objext conftest$ac_exeext
 
14108
            if test "`(eval $ac_link 2>&1 1>&5)`" = ""; then
 
14109
                # we continue with more flags because Linux needs -lpthread
 
14110
                # for libpq builds on PostgreSQL.  The test above only
 
14111
                # tests for building binaries, not shared libraries.
 
14112
                PTHREAD_LIBS=" $tryPTHREAD_LIBS $PTHREAD_LIBS"
 
14113
                PTHREAD_CFLAGS="$PTHREAD_CFLAGS $tryPTHREAD_CFLAGS"
 
14114
            else   acx_pthread_ok=no
 
14115
            fi
 
14116
        fi
 
14117
 
 
14118
        LIBS="$save_LIBS"
 
14119
        CFLAGS="$save_CFLAGS"
 
14120
 
 
14121
        echo "$as_me:$LINENO: result: $acx_pthread_ok" >&5
 
14122
echo "${ECHO_T}$acx_pthread_ok" >&6
 
14123
done
 
14124
fi
 
14125
 
 
14126
# Various other checks:
 
14127
if test "x$acx_pthread_ok" = xyes; then
 
14128
        save_LIBS="$LIBS"
 
14129
        LIBS="$PTHREAD_LIBS $LIBS"
 
14130
        save_CFLAGS="$CFLAGS"
 
14131
        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
 
14132
 
 
14133
        # Detect AIX lossage: threads are created detached by default
 
14134
        # and the JOINABLE attribute has a nonstandard name (UNDETACHED).
 
14135
        echo "$as_me:$LINENO: checking for joinable pthread attribute" >&5
 
14136
echo $ECHO_N "checking for joinable pthread attribute... $ECHO_C" >&6
 
14137
        cat >conftest.$ac_ext <<_ACEOF
 
14138
#line $LINENO "configure"
 
14139
#include "confdefs.h"
 
14140
#include <pthread.h>
 
14141
#ifdef F77_DUMMY_MAIN
 
14142
#  ifdef __cplusplus
 
14143
     extern "C"
 
14144
#  endif
 
14145
   int F77_DUMMY_MAIN() { return 1; }
 
14146
#endif
 
14147
int
 
14148
main ()
 
14149
{
 
14150
int attr=PTHREAD_CREATE_JOINABLE;
 
14151
  ;
 
14152
  return 0;
 
14153
}
 
14154
_ACEOF
 
14155
rm -f conftest.$ac_objext conftest$ac_exeext
 
14156
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
14157
  (eval $ac_link) 2>&5
 
14158
  ac_status=$?
 
14159
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14160
  (exit $ac_status); } &&
 
14161
         { ac_try='test -s conftest$ac_exeext'
 
14162
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
14163
  (eval $ac_try) 2>&5
 
14164
  ac_status=$?
 
14165
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14166
  (exit $ac_status); }; }; then
 
14167
  ok=PTHREAD_CREATE_JOINABLE
 
14168
else
 
14169
  echo "$as_me: failed program was:" >&5
 
14170
cat conftest.$ac_ext >&5
 
14171
ok=unknown
 
14172
fi
 
14173
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
14174
        if test x"$ok" = xunknown; then
 
14175
                cat >conftest.$ac_ext <<_ACEOF
 
14176
#line $LINENO "configure"
 
14177
#include "confdefs.h"
 
14178
#include <pthread.h>
 
14179
#ifdef F77_DUMMY_MAIN
 
14180
#  ifdef __cplusplus
 
14181
     extern "C"
 
14182
#  endif
 
14183
   int F77_DUMMY_MAIN() { return 1; }
 
14184
#endif
 
14185
int
 
14186
main ()
 
14187
{
 
14188
int attr=PTHREAD_CREATE_UNDETACHED;
 
14189
  ;
 
14190
  return 0;
 
14191
}
 
14192
_ACEOF
 
14193
rm -f conftest.$ac_objext conftest$ac_exeext
 
14194
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
14195
  (eval $ac_link) 2>&5
 
14196
  ac_status=$?
 
14197
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14198
  (exit $ac_status); } &&
 
14199
         { ac_try='test -s conftest$ac_exeext'
 
14200
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
14201
  (eval $ac_try) 2>&5
 
14202
  ac_status=$?
 
14203
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14204
  (exit $ac_status); }; }; then
 
14205
  ok=PTHREAD_CREATE_UNDETACHED
 
14206
else
 
14207
  echo "$as_me: failed program was:" >&5
 
14208
cat conftest.$ac_ext >&5
 
14209
ok=unknown
 
14210
fi
 
14211
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
14212
        fi
 
14213
        if test x"$ok" != xPTHREAD_CREATE_JOINABLE; then
 
14214
 
 
14215
cat >>confdefs.h <<\_ACEOF
 
14216
#define PTHREAD_CREATE_JOINABLE $ok
 
14217
_ACEOF
 
14218
 
 
14219
        fi
 
14220
        echo "$as_me:$LINENO: result: ${ok}" >&5
 
14221
echo "${ECHO_T}${ok}" >&6
 
14222
        if test x"$ok" = xunknown; then
 
14223
                { echo "$as_me:$LINENO: WARNING: we do not know how to create joinable pthreads" >&5
 
14224
echo "$as_me: WARNING: we do not know how to create joinable pthreads" >&2;}
 
14225
        fi
 
14226
 
 
14227
        echo "$as_me:$LINENO: checking if more special flags are required for pthreads" >&5
 
14228
echo $ECHO_N "checking if more special flags are required for pthreads... $ECHO_C" >&6
 
14229
        flag=no
 
14230
# We always add these in PostgreSQL
 
14231
#       case "${host_cpu}-${host_os}" in
 
14232
#               *-aix* | *-freebsd* | *-darwin*) flag="-D_THREAD_SAFE";;
 
14233
#               *solaris* | *-osf* | *-hpux*) flag="-D_REENTRANT";;
 
14234
#       esac
 
14235
        echo "$as_me:$LINENO: result: ${flag}" >&5
 
14236
echo "${ECHO_T}${flag}" >&6
 
14237
        if test "x$flag" != xno; then
 
14238
                PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS"
 
14239
        fi
 
14240
 
 
14241
        LIBS="$save_LIBS"
 
14242
        CFLAGS="$save_CFLAGS"
 
14243
 
 
14244
# Supporting cc_r would require a special CC in all places that
 
14245
# use libpq, and that is ugly, so we don't do it.  Users can still
 
14246
# define their compiler as cc_r to do thread builds of everything.
 
14247
        # More AIX lossage: must compile with cc_r
 
14248
        # Extract the first word of "cc_r", so it can be a program name with args.
 
14249
set dummy cc_r; ac_word=$2
 
14250
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
14251
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
14252
if test "${ac_cv_prog_PTHREAD_CC+set}" = set; then
 
14253
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
14254
else
 
14255
  if test -n "$PTHREAD_CC"; then
 
14256
  ac_cv_prog_PTHREAD_CC="$PTHREAD_CC" # Let the user override the test.
 
14257
else
 
14258
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
14259
for as_dir in $PATH
 
14260
do
 
14261
  IFS=$as_save_IFS
 
14262
  test -z "$as_dir" && as_dir=.
 
14263
  for ac_exec_ext in '' $ac_executable_extensions; do
 
14264
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
14265
    ac_cv_prog_PTHREAD_CC="cc_r"
 
14266
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
14267
    break 2
 
14268
  fi
 
14269
done
 
14270
done
 
14271
 
 
14272
  test -z "$ac_cv_prog_PTHREAD_CC" && ac_cv_prog_PTHREAD_CC="${CC}"
 
14273
fi
 
14274
fi
 
14275
PTHREAD_CC=$ac_cv_prog_PTHREAD_CC
 
14276
if test -n "$PTHREAD_CC"; then
 
14277
  echo "$as_me:$LINENO: result: $PTHREAD_CC" >&5
 
14278
echo "${ECHO_T}$PTHREAD_CC" >&6
 
14279
else
 
14280
  echo "$as_me:$LINENO: result: no" >&5
 
14281
echo "${ECHO_T}no" >&6
 
14282
fi
 
14283
 
 
14284
else
 
14285
        PTHREAD_CC="$CC"
 
14286
fi
 
14287
 
 
14288
 
 
14289
 
 
14290
 
 
14291
 
 
14292
# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
 
14293
if test x"$acx_pthread_ok" = xyes; then
 
14294
 
 
14295
cat >>confdefs.h <<\_ACEOF
 
14296
#define HAVE_PTHREAD 1
 
14297
_ACEOF
 
14298
 
 
14299
        :
 
14300
else
 
14301
        acx_pthread_ok=no
 
14302
 
 
14303
fi
 
14304
ac_ext=c
 
14305
ac_cpp='$CPP $CPPFLAGS'
 
14306
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
14307
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
14308
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
14309
 
 
14310
        # set thread flags
 
14311
 
 
14312
# Some platforms use these, so just defineed them.  They can't hurt if they
 
14313
# are not supported.
 
14314
PTHREAD_CFLAGS="$PTHREAD_CFLAGS -D_REENTRANT -D_THREAD_SAFE -D_POSIX_PTHREAD_SEMANTICS"
 
14315
 
 
14316
 
 
14317
# At this point, we don't want to muck with the compiler name for threading.
 
14318
# Let's see who fails, perhaps AIX.  2004-04-23
 
14319
if test "$PTHREAD_CC" != "$CC"; then
 
14320
{ { echo "$as_me:$LINENO: error:
 
14321
PostgreSQL does not support platforms that require a special
 
14322
compiler binary for thread-safety.
 
14323
" >&5
 
14324
echo "$as_me: error:
 
14325
PostgreSQL does not support platforms that require a special
 
14326
compiler binary for thread-safety.
 
14327
" >&2;}
 
14328
   { (exit 1); exit 1; }; }
 
14329
fi
 
14330
 
 
14331
if test "$THREAD_SUPPORT" = no; then
 
14332
{ { echo "$as_me:$LINENO: error:
 
14333
Cannot enable threads on your platform.
 
14334
Your platform is known to not support thread-safe programs.
 
14335
For details, compile and run src/bin/pg_thread_test.
 
14336
" >&5
 
14337
echo "$as_me: error:
 
14338
Cannot enable threads on your platform.
 
14339
Your platform is known to not support thread-safe programs.
 
14340
For details, compile and run src/bin/pg_thread_test.
 
14341
" >&2;}
 
14342
   { (exit 1); exit 1; }; }
 
14343
fi
 
14344
 
 
14345
# Check for *_r functions
 
14346
_CFLAGS="$CFLAGS"
 
14347
_LIBS="$LIBS"
 
14348
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
 
14349
LIBS="$LIBS $PTHREAD_LIBS"
 
14350
 
 
14351
if test "${ac_cv_header_pthread_h+set}" = set; then
 
14352
  echo "$as_me:$LINENO: checking for pthread.h" >&5
 
14353
echo $ECHO_N "checking for pthread.h... $ECHO_C" >&6
 
14354
if test "${ac_cv_header_pthread_h+set}" = set; then
 
14355
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
14356
fi
 
14357
echo "$as_me:$LINENO: result: $ac_cv_header_pthread_h" >&5
 
14358
echo "${ECHO_T}$ac_cv_header_pthread_h" >&6
 
14359
else
 
14360
  # Is the header compilable?
 
14361
echo "$as_me:$LINENO: checking pthread.h usability" >&5
 
14362
echo $ECHO_N "checking pthread.h usability... $ECHO_C" >&6
 
14363
cat >conftest.$ac_ext <<_ACEOF
 
14364
#line $LINENO "configure"
 
14365
#include "confdefs.h"
 
14366
$ac_includes_default
 
14367
#include <pthread.h>
 
14368
_ACEOF
 
14369
rm -f conftest.$ac_objext
 
14370
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
14371
  (eval $ac_compile) 2>&5
 
14372
  ac_status=$?
 
14373
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14374
  (exit $ac_status); } &&
 
14375
         { ac_try='test -s conftest.$ac_objext'
 
14376
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
14377
  (eval $ac_try) 2>&5
 
14378
  ac_status=$?
 
14379
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14380
  (exit $ac_status); }; }; then
 
14381
  ac_header_compiler=yes
 
14382
else
 
14383
  echo "$as_me: failed program was:" >&5
 
14384
cat conftest.$ac_ext >&5
 
14385
ac_header_compiler=no
 
14386
fi
 
14387
rm -f conftest.$ac_objext conftest.$ac_ext
 
14388
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
14389
echo "${ECHO_T}$ac_header_compiler" >&6
 
14390
 
 
14391
# Is the header present?
 
14392
echo "$as_me:$LINENO: checking pthread.h presence" >&5
 
14393
echo $ECHO_N "checking pthread.h presence... $ECHO_C" >&6
 
14394
cat >conftest.$ac_ext <<_ACEOF
 
14395
#line $LINENO "configure"
 
14396
#include "confdefs.h"
 
14397
#include <pthread.h>
 
14398
_ACEOF
 
14399
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
14400
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
14401
  ac_status=$?
 
14402
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
14403
  rm -f conftest.er1
 
14404
  cat conftest.err >&5
 
14405
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14406
  (exit $ac_status); } >/dev/null; then
 
14407
  if test -s conftest.err; then
 
14408
    ac_cpp_err=$ac_c_preproc_warn_flag
 
14409
  else
 
14410
    ac_cpp_err=
 
14411
  fi
 
14412
else
 
14413
  ac_cpp_err=yes
 
14414
fi
 
14415
if test -z "$ac_cpp_err"; then
 
14416
  ac_header_preproc=yes
 
14417
else
 
14418
  echo "$as_me: failed program was:" >&5
 
14419
  cat conftest.$ac_ext >&5
 
14420
  ac_header_preproc=no
 
14421
fi
 
14422
rm -f conftest.err conftest.$ac_ext
 
14423
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
14424
echo "${ECHO_T}$ac_header_preproc" >&6
 
14425
 
 
14426
# So?  What about this header?
 
14427
case $ac_header_compiler:$ac_header_preproc in
 
14428
  yes:no )
 
14429
    { echo "$as_me:$LINENO: WARNING: pthread.h: accepted by the compiler, rejected by the preprocessor!" >&5
 
14430
echo "$as_me: WARNING: pthread.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
14431
    { echo "$as_me:$LINENO: WARNING: pthread.h: proceeding with the preprocessor's result" >&5
 
14432
echo "$as_me: WARNING: pthread.h: proceeding with the preprocessor's result" >&2;};;
 
14433
  no:yes )
 
14434
    { echo "$as_me:$LINENO: WARNING: pthread.h: present but cannot be compiled" >&5
 
14435
echo "$as_me: WARNING: pthread.h: present but cannot be compiled" >&2;}
 
14436
    { echo "$as_me:$LINENO: WARNING: pthread.h: check for missing prerequisite headers?" >&5
 
14437
echo "$as_me: WARNING: pthread.h: check for missing prerequisite headers?" >&2;}
 
14438
    { echo "$as_me:$LINENO: WARNING: pthread.h: proceeding with the preprocessor's result" >&5
 
14439
echo "$as_me: WARNING: pthread.h: proceeding with the preprocessor's result" >&2;};;
 
14440
esac
 
14441
echo "$as_me:$LINENO: checking for pthread.h" >&5
 
14442
echo $ECHO_N "checking for pthread.h... $ECHO_C" >&6
 
14443
if test "${ac_cv_header_pthread_h+set}" = set; then
 
14444
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
14445
else
 
14446
  ac_cv_header_pthread_h=$ac_header_preproc
 
14447
fi
 
14448
echo "$as_me:$LINENO: result: $ac_cv_header_pthread_h" >&5
 
14449
echo "${ECHO_T}$ac_cv_header_pthread_h" >&6
 
14450
 
 
14451
fi
 
14452
if test $ac_cv_header_pthread_h = yes; then
 
14453
  :
 
14454
else
 
14455
  { { echo "$as_me:$LINENO: error: pthread.h not found, required for --enable-thread-safety" >&5
 
14456
echo "$as_me: error: pthread.h not found, required for --enable-thread-safety" >&2;}
 
14457
   { (exit 1); exit 1; }; }
 
14458
fi
 
14459
 
 
14460
 
 
14461
 
 
14462
 
 
14463
 
 
14464
 
 
14465
for ac_func in strerror_r getpwuid_r gethostbyname_r
 
14466
do
 
14467
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
 
14468
echo "$as_me:$LINENO: checking for $ac_func" >&5
 
14469
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
 
14470
if eval "test \"\${$as_ac_var+set}\" = set"; then
 
14471
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
14472
else
 
14473
  cat >conftest.$ac_ext <<_ACEOF
 
14474
#line $LINENO "configure"
 
14475
#include "confdefs.h"
 
14476
/* System header to define __stub macros and hopefully few prototypes,
 
14477
    which can conflict with char $ac_func (); below.  */
 
14478
#include <assert.h>
 
14479
/* Override any gcc2 internal prototype to avoid an error.  */
 
14480
#ifdef __cplusplus
 
14481
extern "C"
 
14482
#endif
 
14483
/* We use char because int might match the return type of a gcc2
 
14484
   builtin and then its argument prototype would still apply.  */
 
14485
char $ac_func ();
 
14486
char (*f) ();
 
14487
 
 
14488
#ifdef F77_DUMMY_MAIN
 
14489
#  ifdef __cplusplus
 
14490
     extern "C"
 
14491
#  endif
 
14492
   int F77_DUMMY_MAIN() { return 1; }
 
14493
#endif
 
14494
int
 
14495
main ()
 
14496
{
 
14497
/* The GNU C library defines this for functions which it implements
 
14498
    to always fail with ENOSYS.  Some functions are actually named
 
14499
    something starting with __ and the normal name is an alias.  */
 
14500
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
 
14501
choke me
 
14502
#else
 
14503
f = $ac_func;
 
14504
#endif
 
14505
 
 
14506
  ;
 
14507
  return 0;
 
14508
}
 
14509
_ACEOF
 
14510
rm -f conftest.$ac_objext conftest$ac_exeext
 
14511
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
14512
  (eval $ac_link) 2>&5
 
14513
  ac_status=$?
 
14514
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14515
  (exit $ac_status); } &&
 
14516
         { ac_try='test -s conftest$ac_exeext'
 
14517
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
14518
  (eval $ac_try) 2>&5
 
14519
  ac_status=$?
 
14520
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14521
  (exit $ac_status); }; }; then
 
14522
  eval "$as_ac_var=yes"
 
14523
else
 
14524
  echo "$as_me: failed program was:" >&5
 
14525
cat conftest.$ac_ext >&5
 
14526
eval "$as_ac_var=no"
 
14527
fi
 
14528
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
14529
fi
 
14530
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
 
14531
echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
 
14532
if test `eval echo '${'$as_ac_var'}'` = yes; then
 
14533
  cat >>confdefs.h <<_ACEOF
 
14534
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
 
14535
_ACEOF
 
14536
 
 
14537
fi
 
14538
done
 
14539
 
 
14540
 
 
14541
# Do test here with the proper thread flags
 
14542
echo "$as_me:$LINENO: checking whether getpwuid_r takes a fifth argument" >&5
 
14543
echo $ECHO_N "checking whether getpwuid_r takes a fifth argument... $ECHO_C" >&6
 
14544
if test "${pgac_func_getpwuid_r_5arg+set}" = set; then
 
14545
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
14546
else
 
14547
  cat >conftest.$ac_ext <<_ACEOF
 
14548
#line $LINENO "configure"
 
14549
#include "confdefs.h"
 
14550
#include <sys/types.h>
 
14551
#include <pwd.h>
 
14552
#ifdef F77_DUMMY_MAIN
 
14553
#  ifdef __cplusplus
 
14554
     extern "C"
 
14555
#  endif
 
14556
   int F77_DUMMY_MAIN() { return 1; }
 
14557
#endif
 
14558
int
 
14559
main ()
 
14560
{
 
14561
uid_t uid;
 
14562
struct passwd *space;
 
14563
char *buf;
 
14564
size_t bufsize;
 
14565
struct passwd **result;
 
14566
getpwuid_r(uid, space, buf, bufsize, result);
 
14567
  ;
 
14568
  return 0;
 
14569
}
 
14570
_ACEOF
 
14571
rm -f conftest.$ac_objext
 
14572
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
14573
  (eval $ac_compile) 2>&5
 
14574
  ac_status=$?
 
14575
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14576
  (exit $ac_status); } &&
 
14577
         { ac_try='test -s conftest.$ac_objext'
 
14578
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
14579
  (eval $ac_try) 2>&5
 
14580
  ac_status=$?
 
14581
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14582
  (exit $ac_status); }; }; then
 
14583
  pgac_func_getpwuid_r_5arg=yes
 
14584
else
 
14585
  echo "$as_me: failed program was:" >&5
 
14586
cat conftest.$ac_ext >&5
 
14587
pgac_func_getpwuid_r_5arg=no
 
14588
fi
 
14589
rm -f conftest.$ac_objext conftest.$ac_ext
 
14590
fi
 
14591
echo "$as_me:$LINENO: result: $pgac_func_getpwuid_r_5arg" >&5
 
14592
echo "${ECHO_T}$pgac_func_getpwuid_r_5arg" >&6
 
14593
if test x"$pgac_func_getpwuid_r_5arg" = xyes ; then
 
14594
 
 
14595
cat >>confdefs.h <<\_ACEOF
 
14596
#define GETPWUID_R_5ARG
 
14597
_ACEOF
 
14598
 
 
14599
fi
 
14600
 
 
14601
echo "$as_me:$LINENO: checking whether strerror_r returns int" >&5
 
14602
echo $ECHO_N "checking whether strerror_r returns int... $ECHO_C" >&6
 
14603
if test "${pgac_func_strerror_r_int+set}" = set; then
 
14604
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
14605
else
 
14606
  cat >conftest.$ac_ext <<_ACEOF
 
14607
#line $LINENO "configure"
 
14608
#include "confdefs.h"
 
14609
#include <string.h>
 
14610
#ifdef F77_DUMMY_MAIN
 
14611
#  ifdef __cplusplus
 
14612
     extern "C"
 
14613
#  endif
 
14614
   int F77_DUMMY_MAIN() { return 1; }
 
14615
#endif
 
14616
int
 
14617
main ()
 
14618
{
 
14619
#ifndef _AIX
 
14620
int strerror_r(int, char *, size_t);
 
14621
#else
 
14622
/* Older AIX has 'int' for the third argument so we don't test the args. */
 
14623
int strerror_r();
 
14624
#endif
 
14625
  ;
 
14626
  return 0;
 
14627
}
 
14628
_ACEOF
 
14629
rm -f conftest.$ac_objext
 
14630
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
14631
  (eval $ac_compile) 2>&5
 
14632
  ac_status=$?
 
14633
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14634
  (exit $ac_status); } &&
 
14635
         { ac_try='test -s conftest.$ac_objext'
 
14636
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
14637
  (eval $ac_try) 2>&5
 
14638
  ac_status=$?
 
14639
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14640
  (exit $ac_status); }; }; then
 
14641
  pgac_func_strerror_r_int=yes
 
14642
else
 
14643
  echo "$as_me: failed program was:" >&5
 
14644
cat conftest.$ac_ext >&5
 
14645
pgac_func_strerror_r_int=no
 
14646
fi
 
14647
rm -f conftest.$ac_objext conftest.$ac_ext
 
14648
fi
 
14649
echo "$as_me:$LINENO: result: $pgac_func_strerror_r_int" >&5
 
14650
echo "${ECHO_T}$pgac_func_strerror_r_int" >&6
 
14651
if test x"$pgac_func_strerror_r_int" = xyes ; then
 
14652
 
 
14653
cat >>confdefs.h <<\_ACEOF
 
14654
#define STRERROR_R_INT
 
14655
_ACEOF
 
14656
 
 
14657
fi
 
14658
 
 
14659
 
 
14660
CFLAGS="$_CFLAGS"
 
14661
LIBS="$_LIBS"
 
14662
 
 
14663
else
 
14664
# do not use values from template file
 
14665
PTHREAD_CFLAGS=
 
14666
PTHREAD_LIBS=
 
14667
fi
 
14668
 
 
14669
 
 
14670
 
 
14671
 
 
14672
 
 
14673
# This test makes sure that run tests work at all.  Sometimes a shared
 
14674
# library is found by the linker, but the runtime linker can't find it.
 
14675
# This check should come after all modifications of compiler or linker
 
14676
# variables, and before any other run tests.
 
14677
echo "$as_me:$LINENO: checking test program" >&5
 
14678
echo $ECHO_N "checking test program... $ECHO_C" >&6
 
14679
if test "$cross_compiling" = yes; then
 
14680
  echo "$as_me:$LINENO: result: cross-compiling" >&5
 
14681
echo "${ECHO_T}cross-compiling" >&6
 
14682
else
 
14683
  cat >conftest.$ac_ext <<_ACEOF
 
14684
#line $LINENO "configure"
 
14685
#include "confdefs.h"
 
14686
int main() { return 0; }
 
14687
_ACEOF
 
14688
rm -f conftest$ac_exeext
 
14689
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
14690
  (eval $ac_link) 2>&5
 
14691
  ac_status=$?
 
14692
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14693
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
14694
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
14695
  (eval $ac_try) 2>&5
 
14696
  ac_status=$?
 
14697
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14698
  (exit $ac_status); }; }; then
 
14699
  echo "$as_me:$LINENO: result: ok" >&5
 
14700
echo "${ECHO_T}ok" >&6
 
14701
else
 
14702
  echo "$as_me: program exited with status $ac_status" >&5
 
14703
echo "$as_me: failed program was:" >&5
 
14704
cat conftest.$ac_ext >&5
 
14705
( exit $ac_status )
 
14706
echo "$as_me:$LINENO: result: failed" >&5
 
14707
echo "${ECHO_T}failed" >&6
 
14708
{ { echo "$as_me:$LINENO: error:
 
14709
*** Could not execute a simple test program.  This may be a problem
 
14710
*** related to locating shared libraries.  Check the file 'config.log'
 
14711
*** for the exact reason." >&5
 
14712
echo "$as_me: error:
 
14713
*** Could not execute a simple test program.  This may be a problem
 
14714
*** related to locating shared libraries.  Check the file 'config.log'
 
14715
*** for the exact reason." >&2;}
 
14716
   { (exit 1); exit 1; }; }
 
14717
fi
 
14718
rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 
14719
fi
 
14720
 
 
14721
 
 
14722
 
 
14723
echo "$as_me:$LINENO: checking whether long int is 64 bits" >&5
 
14724
echo $ECHO_N "checking whether long int is 64 bits... $ECHO_C" >&6
 
14725
if test "${pgac_cv_type_long_int_64+set}" = set; then
 
14726
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
14727
else
 
14728
  if test "$cross_compiling" = yes; then
 
14729
  # If cross-compiling, check the size reported by the compiler and
 
14730
# trust that the arithmetic works.
 
14731
cat >conftest.$ac_ext <<_ACEOF
 
14732
#line $LINENO "configure"
 
14733
#include "confdefs.h"
 
14734
 
 
14735
#ifdef F77_DUMMY_MAIN
 
14736
#  ifdef __cplusplus
 
14737
     extern "C"
 
14738
#  endif
 
14739
   int F77_DUMMY_MAIN() { return 1; }
 
14740
#endif
 
14741
int
 
14742
main ()
 
14743
{
 
14744
static int test_array [1 - 2 * !(sizeof(long int) == 8)];
 
14745
test_array [0] = 0
 
14746
 
 
14747
  ;
 
14748
  return 0;
 
14749
}
 
14750
_ACEOF
 
14751
rm -f conftest.$ac_objext
 
14752
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
14753
  (eval $ac_compile) 2>&5
 
14754
  ac_status=$?
 
14755
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14756
  (exit $ac_status); } &&
 
14757
         { ac_try='test -s conftest.$ac_objext'
 
14758
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
14759
  (eval $ac_try) 2>&5
 
14760
  ac_status=$?
 
14761
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14762
  (exit $ac_status); }; }; then
 
14763
  pgac_cv_type_long_int_64=yes
 
14764
else
 
14765
  echo "$as_me: failed program was:" >&5
 
14766
cat conftest.$ac_ext >&5
 
14767
pgac_cv_type_long_int_64=no
 
14768
fi
 
14769
rm -f conftest.$ac_objext conftest.$ac_ext
 
14770
else
 
14771
  cat >conftest.$ac_ext <<_ACEOF
 
14772
#line $LINENO "configure"
 
14773
#include "confdefs.h"
 
14774
typedef long int ac_int64;
 
14775
 
 
14776
/*
 
14777
 * These are globals to discourage the compiler from folding all the
 
14778
 * arithmetic tests down to compile-time constants.
 
14779
 */
 
14780
ac_int64 a = 20000001;
 
14781
ac_int64 b = 40000005;
 
14782
 
 
14783
int does_int64_work()
 
14784
{
 
14785
  ac_int64 c,d;
 
14786
 
 
14787
  if (sizeof(ac_int64) != 8)
 
14788
    return 0;                   /* definitely not the right size */
 
14789
 
 
14790
  /* Do perfunctory checks to see if 64-bit arithmetic seems to work */
 
14791
  c = a * b;
 
14792
  d = (c + b) / b;
 
14793
  if (d != a+1)
 
14794
    return 0;
 
14795
  return 1;
 
14796
}
 
14797
main() {
 
14798
  exit(! does_int64_work());
 
14799
}
 
14800
_ACEOF
 
14801
rm -f conftest$ac_exeext
 
14802
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
14803
  (eval $ac_link) 2>&5
 
14804
  ac_status=$?
 
14805
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14806
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
14807
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
14808
  (eval $ac_try) 2>&5
 
14809
  ac_status=$?
 
14810
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14811
  (exit $ac_status); }; }; then
 
14812
  pgac_cv_type_long_int_64=yes
 
14813
else
 
14814
  echo "$as_me: program exited with status $ac_status" >&5
 
14815
echo "$as_me: failed program was:" >&5
 
14816
cat conftest.$ac_ext >&5
 
14817
( exit $ac_status )
 
14818
pgac_cv_type_long_int_64=no
 
14819
fi
 
14820
rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 
14821
fi
 
14822
fi
 
14823
echo "$as_me:$LINENO: result: $pgac_cv_type_long_int_64" >&5
 
14824
echo "${ECHO_T}$pgac_cv_type_long_int_64" >&6
 
14825
 
 
14826
HAVE_LONG_INT_64=$pgac_cv_type_long_int_64
 
14827
if test x"$pgac_cv_type_long_int_64" = xyes ; then
 
14828
 
 
14829
cat >>confdefs.h <<\_ACEOF
 
14830
#define HAVE_LONG_INT_64
 
14831
_ACEOF
 
14832
 
 
14833
fi
 
14834
 
 
14835
 
 
14836
if test x"$HAVE_LONG_INT_64" = x"no" ; then
 
14837
  echo "$as_me:$LINENO: checking whether long long int is 64 bits" >&5
 
14838
echo $ECHO_N "checking whether long long int is 64 bits... $ECHO_C" >&6
 
14839
if test "${pgac_cv_type_long_long_int_64+set}" = set; then
 
14840
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
14841
else
 
14842
  if test "$cross_compiling" = yes; then
 
14843
  # If cross-compiling, check the size reported by the compiler and
 
14844
# trust that the arithmetic works.
 
14845
cat >conftest.$ac_ext <<_ACEOF
 
14846
#line $LINENO "configure"
 
14847
#include "confdefs.h"
 
14848
 
 
14849
#ifdef F77_DUMMY_MAIN
 
14850
#  ifdef __cplusplus
 
14851
     extern "C"
 
14852
#  endif
 
14853
   int F77_DUMMY_MAIN() { return 1; }
 
14854
#endif
 
14855
int
 
14856
main ()
 
14857
{
 
14858
static int test_array [1 - 2 * !(sizeof(long long int) == 8)];
 
14859
test_array [0] = 0
 
14860
 
 
14861
  ;
 
14862
  return 0;
 
14863
}
 
14864
_ACEOF
 
14865
rm -f conftest.$ac_objext
 
14866
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
14867
  (eval $ac_compile) 2>&5
 
14868
  ac_status=$?
 
14869
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14870
  (exit $ac_status); } &&
 
14871
         { ac_try='test -s conftest.$ac_objext'
 
14872
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
14873
  (eval $ac_try) 2>&5
 
14874
  ac_status=$?
 
14875
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14876
  (exit $ac_status); }; }; then
 
14877
  pgac_cv_type_long_long_int_64=yes
 
14878
else
 
14879
  echo "$as_me: failed program was:" >&5
 
14880
cat conftest.$ac_ext >&5
 
14881
pgac_cv_type_long_long_int_64=no
 
14882
fi
 
14883
rm -f conftest.$ac_objext conftest.$ac_ext
 
14884
else
 
14885
  cat >conftest.$ac_ext <<_ACEOF
 
14886
#line $LINENO "configure"
 
14887
#include "confdefs.h"
 
14888
typedef long long int ac_int64;
 
14889
 
 
14890
/*
 
14891
 * These are globals to discourage the compiler from folding all the
 
14892
 * arithmetic tests down to compile-time constants.
 
14893
 */
 
14894
ac_int64 a = 20000001;
 
14895
ac_int64 b = 40000005;
 
14896
 
 
14897
int does_int64_work()
 
14898
{
 
14899
  ac_int64 c,d;
 
14900
 
 
14901
  if (sizeof(ac_int64) != 8)
 
14902
    return 0;                   /* definitely not the right size */
 
14903
 
 
14904
  /* Do perfunctory checks to see if 64-bit arithmetic seems to work */
 
14905
  c = a * b;
 
14906
  d = (c + b) / b;
 
14907
  if (d != a+1)
 
14908
    return 0;
 
14909
  return 1;
 
14910
}
 
14911
main() {
 
14912
  exit(! does_int64_work());
 
14913
}
 
14914
_ACEOF
 
14915
rm -f conftest$ac_exeext
 
14916
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
14917
  (eval $ac_link) 2>&5
 
14918
  ac_status=$?
 
14919
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14920
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
14921
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
14922
  (eval $ac_try) 2>&5
 
14923
  ac_status=$?
 
14924
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14925
  (exit $ac_status); }; }; then
 
14926
  pgac_cv_type_long_long_int_64=yes
 
14927
else
 
14928
  echo "$as_me: program exited with status $ac_status" >&5
 
14929
echo "$as_me: failed program was:" >&5
 
14930
cat conftest.$ac_ext >&5
 
14931
( exit $ac_status )
 
14932
pgac_cv_type_long_long_int_64=no
 
14933
fi
 
14934
rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 
14935
fi
 
14936
fi
 
14937
echo "$as_me:$LINENO: result: $pgac_cv_type_long_long_int_64" >&5
 
14938
echo "${ECHO_T}$pgac_cv_type_long_long_int_64" >&6
 
14939
 
 
14940
HAVE_LONG_LONG_INT_64=$pgac_cv_type_long_long_int_64
 
14941
if test x"$pgac_cv_type_long_long_int_64" = xyes ; then
 
14942
 
 
14943
cat >>confdefs.h <<\_ACEOF
 
14944
#define HAVE_LONG_LONG_INT_64
 
14945
_ACEOF
 
14946
 
 
14947
fi
 
14948
 
 
14949
fi
 
14950
 
 
14951
 
 
14952
 
 
14953
if test x"$HAVE_LONG_LONG_INT_64" = xyes ; then
 
14954
  cat >conftest.$ac_ext <<_ACEOF
 
14955
#line $LINENO "configure"
 
14956
#include "confdefs.h"
 
14957
 
 
14958
#define INT64CONST(x)  x##LL
 
14959
long long int foo = INT64CONST(0x1234567890123456);
 
14960
 
 
14961
#ifdef F77_DUMMY_MAIN
 
14962
#  ifdef __cplusplus
 
14963
     extern "C"
 
14964
#  endif
 
14965
   int F77_DUMMY_MAIN() { return 1; }
 
14966
#endif
 
14967
int
 
14968
main ()
 
14969
{
 
14970
 
 
14971
  ;
 
14972
  return 0;
 
14973
}
 
14974
_ACEOF
 
14975
rm -f conftest.$ac_objext
 
14976
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
14977
  (eval $ac_compile) 2>&5
 
14978
  ac_status=$?
 
14979
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14980
  (exit $ac_status); } &&
 
14981
         { ac_try='test -s conftest.$ac_objext'
 
14982
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
14983
  (eval $ac_try) 2>&5
 
14984
  ac_status=$?
 
14985
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
14986
  (exit $ac_status); }; }; then
 
14987
 
 
14988
cat >>confdefs.h <<\_ACEOF
 
14989
#define HAVE_LL_CONSTANTS 1
 
14990
_ACEOF
 
14991
 
 
14992
else
 
14993
  echo "$as_me: failed program was:" >&5
 
14994
cat conftest.$ac_ext >&5
 
14995
fi
 
14996
rm -f conftest.$ac_objext conftest.$ac_ext
 
14997
fi
 
14998
 
 
14999
 
 
15000
# If we found "long int" is 64 bits, assume snprintf handles it.  If
 
15001
# we found we need to use "long long int", better check.  We cope with
 
15002
# snprintfs that use %lld, %qd, or %I64d as the format.  If none of these
 
15003
# work, fall back to our own snprintf emulation (which we know uses %lld).
 
15004
 
 
15005
if test "$HAVE_LONG_LONG_INT_64" = yes ; then
 
15006
  if test $pgac_need_repl_snprintf = no; then
 
15007
    echo "$as_me:$LINENO: checking snprintf format for long long int" >&5
 
15008
echo $ECHO_N "checking snprintf format for long long int... $ECHO_C" >&6
 
15009
if test "${pgac_cv_snprintf_long_long_int_format+set}" = set; then
 
15010
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
15011
else
 
15012
  for pgac_format in '%lld' '%qd' '%I64d'; do
 
15013
if test "$cross_compiling" = yes; then
 
15014
  pgac_cv_snprintf_long_long_int_format=cross; break
 
15015
else
 
15016
  cat >conftest.$ac_ext <<_ACEOF
 
15017
#line $LINENO "configure"
 
15018
#include "confdefs.h"
 
15019
#include <stdio.h>
 
15020
typedef long long int ac_int64;
 
15021
#define INT64_FORMAT "$pgac_format"
 
15022
 
 
15023
ac_int64 a = 20000001;
 
15024
ac_int64 b = 40000005;
 
15025
 
 
15026
int does_int64_snprintf_work()
 
15027
{
 
15028
  ac_int64 c;
 
15029
  char buf[100];
 
15030
 
 
15031
  if (sizeof(ac_int64) != 8)
 
15032
    return 0;                   /* doesn't look like the right size */
 
15033
 
 
15034
  c = a * b;
 
15035
  snprintf(buf, 100, INT64_FORMAT, c);
 
15036
  if (strcmp(buf, "800000140000005") != 0)
 
15037
    return 0;                   /* either multiply or snprintf is busted */
 
15038
  return 1;
 
15039
}
 
15040
main() {
 
15041
  exit(! does_int64_snprintf_work());
 
15042
}
 
15043
_ACEOF
 
15044
rm -f conftest$ac_exeext
 
15045
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
15046
  (eval $ac_link) 2>&5
 
15047
  ac_status=$?
 
15048
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15049
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
15050
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
15051
  (eval $ac_try) 2>&5
 
15052
  ac_status=$?
 
15053
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15054
  (exit $ac_status); }; }; then
 
15055
  pgac_cv_snprintf_long_long_int_format=$pgac_format; break
 
15056
else
 
15057
  echo "$as_me: program exited with status $ac_status" >&5
 
15058
echo "$as_me: failed program was:" >&5
 
15059
cat conftest.$ac_ext >&5
 
15060
fi
 
15061
rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 
15062
fi
 
15063
done
 
15064
fi
 
15065
 
 
15066
LONG_LONG_INT_FORMAT=''
 
15067
 
 
15068
case $pgac_cv_snprintf_long_long_int_format in
 
15069
  cross) echo "$as_me:$LINENO: result: cannot test (not on host machine)" >&5
 
15070
echo "${ECHO_T}cannot test (not on host machine)" >&6;;
 
15071
  ?*)    echo "$as_me:$LINENO: result: $pgac_cv_snprintf_long_long_int_format" >&5
 
15072
echo "${ECHO_T}$pgac_cv_snprintf_long_long_int_format" >&6
 
15073
         LONG_LONG_INT_FORMAT=$pgac_cv_snprintf_long_long_int_format;;
 
15074
  *)     echo "$as_me:$LINENO: result: none" >&5
 
15075
echo "${ECHO_T}none" >&6;;
 
15076
esac
 
15077
    if test "$LONG_LONG_INT_FORMAT" = ""; then
 
15078
      # Force usage of our own snprintf, since system snprintf is broken
 
15079
      pgac_need_repl_snprintf=yes
 
15080
      LONG_LONG_INT_FORMAT='%lld'
 
15081
    fi
 
15082
  else
 
15083
    # Here if we previously decided we needed to use our own snprintf
 
15084
    LONG_LONG_INT_FORMAT='%lld'
 
15085
  fi
 
15086
  LONG_LONG_UINT_FORMAT=`echo "$LONG_LONG_INT_FORMAT" | sed 's/d$/u/'`
 
15087
  INT64_FORMAT="\"$LONG_LONG_INT_FORMAT\""
 
15088
  UINT64_FORMAT="\"$LONG_LONG_UINT_FORMAT\""
 
15089
else
 
15090
  # Here if we are not using 'long long int' at all
 
15091
  INT64_FORMAT='"%ld"'
 
15092
  UINT64_FORMAT='"%lu"'
 
15093
fi
 
15094
 
 
15095
 
 
15096
cat >>confdefs.h <<_ACEOF
 
15097
#define INT64_FORMAT $INT64_FORMAT
 
15098
_ACEOF
 
15099
 
 
15100
 
 
15101
 
 
15102
cat >>confdefs.h <<_ACEOF
 
15103
#define UINT64_FORMAT $UINT64_FORMAT
 
15104
_ACEOF
 
15105
 
 
15106
 
 
15107
if test $pgac_need_repl_snprintf = yes; then
 
15108
  LIBOBJS="$LIBOBJS snprintf.$ac_objext"
 
15109
fi
 
15110
 
 
15111
# Need a #define for the size of Datum (unsigned long)
 
15112
echo "$as_me:$LINENO: checking for unsigned long" >&5
 
15113
echo $ECHO_N "checking for unsigned long... $ECHO_C" >&6
 
15114
if test "${ac_cv_type_unsigned_long+set}" = set; then
 
15115
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
15116
else
 
15117
  cat >conftest.$ac_ext <<_ACEOF
 
15118
#line $LINENO "configure"
 
15119
#include "confdefs.h"
 
15120
$ac_includes_default
 
15121
#ifdef F77_DUMMY_MAIN
 
15122
#  ifdef __cplusplus
 
15123
     extern "C"
 
15124
#  endif
 
15125
   int F77_DUMMY_MAIN() { return 1; }
 
15126
#endif
 
15127
int
 
15128
main ()
 
15129
{
 
15130
if ((unsigned long *) 0)
 
15131
  return 0;
 
15132
if (sizeof (unsigned long))
 
15133
  return 0;
 
15134
  ;
 
15135
  return 0;
 
15136
}
 
15137
_ACEOF
 
15138
rm -f conftest.$ac_objext
 
15139
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
15140
  (eval $ac_compile) 2>&5
 
15141
  ac_status=$?
 
15142
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15143
  (exit $ac_status); } &&
 
15144
         { ac_try='test -s conftest.$ac_objext'
 
15145
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
15146
  (eval $ac_try) 2>&5
 
15147
  ac_status=$?
 
15148
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15149
  (exit $ac_status); }; }; then
 
15150
  ac_cv_type_unsigned_long=yes
 
15151
else
 
15152
  echo "$as_me: failed program was:" >&5
 
15153
cat conftest.$ac_ext >&5
 
15154
ac_cv_type_unsigned_long=no
 
15155
fi
 
15156
rm -f conftest.$ac_objext conftest.$ac_ext
 
15157
fi
 
15158
echo "$as_me:$LINENO: result: $ac_cv_type_unsigned_long" >&5
 
15159
echo "${ECHO_T}$ac_cv_type_unsigned_long" >&6
 
15160
 
 
15161
echo "$as_me:$LINENO: checking size of unsigned long" >&5
 
15162
echo $ECHO_N "checking size of unsigned long... $ECHO_C" >&6
 
15163
if test "${ac_cv_sizeof_unsigned_long+set}" = set; then
 
15164
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
15165
else
 
15166
  if test "$ac_cv_type_unsigned_long" = yes; then
 
15167
  # The cast to unsigned long works around a bug in the HP C Compiler
 
15168
  # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
 
15169
  # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
 
15170
  # This bug is HP SR number 8606223364.
 
15171
  if test "$cross_compiling" = yes; then
 
15172
  # Depending upon the size, compute the lo and hi bounds.
 
15173
cat >conftest.$ac_ext <<_ACEOF
 
15174
#line $LINENO "configure"
 
15175
#include "confdefs.h"
 
15176
$ac_includes_default
 
15177
#ifdef F77_DUMMY_MAIN
 
15178
#  ifdef __cplusplus
 
15179
     extern "C"
 
15180
#  endif
 
15181
   int F77_DUMMY_MAIN() { return 1; }
 
15182
#endif
 
15183
int
 
15184
main ()
 
15185
{
 
15186
static int test_array [1 - 2 * !(((long) (sizeof (unsigned long))) >= 0)];
 
15187
test_array [0] = 0
 
15188
 
 
15189
  ;
 
15190
  return 0;
 
15191
}
 
15192
_ACEOF
 
15193
rm -f conftest.$ac_objext
 
15194
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
15195
  (eval $ac_compile) 2>&5
 
15196
  ac_status=$?
 
15197
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15198
  (exit $ac_status); } &&
 
15199
         { ac_try='test -s conftest.$ac_objext'
 
15200
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
15201
  (eval $ac_try) 2>&5
 
15202
  ac_status=$?
 
15203
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15204
  (exit $ac_status); }; }; then
 
15205
  ac_lo=0 ac_mid=0
 
15206
  while :; do
 
15207
    cat >conftest.$ac_ext <<_ACEOF
 
15208
#line $LINENO "configure"
 
15209
#include "confdefs.h"
 
15210
$ac_includes_default
 
15211
#ifdef F77_DUMMY_MAIN
 
15212
#  ifdef __cplusplus
 
15213
     extern "C"
 
15214
#  endif
 
15215
   int F77_DUMMY_MAIN() { return 1; }
 
15216
#endif
 
15217
int
 
15218
main ()
 
15219
{
 
15220
static int test_array [1 - 2 * !(((long) (sizeof (unsigned long))) <= $ac_mid)];
 
15221
test_array [0] = 0
 
15222
 
 
15223
  ;
 
15224
  return 0;
 
15225
}
 
15226
_ACEOF
 
15227
rm -f conftest.$ac_objext
 
15228
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
15229
  (eval $ac_compile) 2>&5
 
15230
  ac_status=$?
 
15231
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15232
  (exit $ac_status); } &&
 
15233
         { ac_try='test -s conftest.$ac_objext'
 
15234
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
15235
  (eval $ac_try) 2>&5
 
15236
  ac_status=$?
 
15237
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15238
  (exit $ac_status); }; }; then
 
15239
  ac_hi=$ac_mid; break
 
15240
else
 
15241
  echo "$as_me: failed program was:" >&5
 
15242
cat conftest.$ac_ext >&5
 
15243
ac_lo=`expr $ac_mid + 1`
 
15244
                    if test $ac_lo -le $ac_mid; then
 
15245
                      ac_lo= ac_hi=
 
15246
                      break
 
15247
                    fi
 
15248
                    ac_mid=`expr 2 '*' $ac_mid + 1`
 
15249
fi
 
15250
rm -f conftest.$ac_objext conftest.$ac_ext
 
15251
  done
 
15252
else
 
15253
  echo "$as_me: failed program was:" >&5
 
15254
cat conftest.$ac_ext >&5
 
15255
cat >conftest.$ac_ext <<_ACEOF
 
15256
#line $LINENO "configure"
 
15257
#include "confdefs.h"
 
15258
$ac_includes_default
 
15259
#ifdef F77_DUMMY_MAIN
 
15260
#  ifdef __cplusplus
 
15261
     extern "C"
 
15262
#  endif
 
15263
   int F77_DUMMY_MAIN() { return 1; }
 
15264
#endif
 
15265
int
 
15266
main ()
 
15267
{
 
15268
static int test_array [1 - 2 * !(((long) (sizeof (unsigned long))) < 0)];
 
15269
test_array [0] = 0
 
15270
 
 
15271
  ;
 
15272
  return 0;
 
15273
}
 
15274
_ACEOF
 
15275
rm -f conftest.$ac_objext
 
15276
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
15277
  (eval $ac_compile) 2>&5
 
15278
  ac_status=$?
 
15279
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15280
  (exit $ac_status); } &&
 
15281
         { ac_try='test -s conftest.$ac_objext'
 
15282
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
15283
  (eval $ac_try) 2>&5
 
15284
  ac_status=$?
 
15285
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15286
  (exit $ac_status); }; }; then
 
15287
  ac_hi=-1 ac_mid=-1
 
15288
  while :; do
 
15289
    cat >conftest.$ac_ext <<_ACEOF
 
15290
#line $LINENO "configure"
 
15291
#include "confdefs.h"
 
15292
$ac_includes_default
 
15293
#ifdef F77_DUMMY_MAIN
 
15294
#  ifdef __cplusplus
 
15295
     extern "C"
 
15296
#  endif
 
15297
   int F77_DUMMY_MAIN() { return 1; }
 
15298
#endif
 
15299
int
 
15300
main ()
 
15301
{
 
15302
static int test_array [1 - 2 * !(((long) (sizeof (unsigned long))) >= $ac_mid)];
 
15303
test_array [0] = 0
 
15304
 
 
15305
  ;
 
15306
  return 0;
 
15307
}
 
15308
_ACEOF
 
15309
rm -f conftest.$ac_objext
 
15310
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
15311
  (eval $ac_compile) 2>&5
 
15312
  ac_status=$?
 
15313
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15314
  (exit $ac_status); } &&
 
15315
         { ac_try='test -s conftest.$ac_objext'
 
15316
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
15317
  (eval $ac_try) 2>&5
 
15318
  ac_status=$?
 
15319
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15320
  (exit $ac_status); }; }; then
 
15321
  ac_lo=$ac_mid; break
 
15322
else
 
15323
  echo "$as_me: failed program was:" >&5
 
15324
cat conftest.$ac_ext >&5
 
15325
ac_hi=`expr '(' $ac_mid ')' - 1`
 
15326
                       if test $ac_mid -le $ac_hi; then
 
15327
                         ac_lo= ac_hi=
 
15328
                         break
 
15329
                       fi
 
15330
                       ac_mid=`expr 2 '*' $ac_mid`
 
15331
fi
 
15332
rm -f conftest.$ac_objext conftest.$ac_ext
 
15333
  done
 
15334
else
 
15335
  echo "$as_me: failed program was:" >&5
 
15336
cat conftest.$ac_ext >&5
 
15337
ac_lo= ac_hi=
 
15338
fi
 
15339
rm -f conftest.$ac_objext conftest.$ac_ext
 
15340
fi
 
15341
rm -f conftest.$ac_objext conftest.$ac_ext
 
15342
# Binary search between lo and hi bounds.
 
15343
while test "x$ac_lo" != "x$ac_hi"; do
 
15344
  ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
 
15345
  cat >conftest.$ac_ext <<_ACEOF
 
15346
#line $LINENO "configure"
 
15347
#include "confdefs.h"
 
15348
$ac_includes_default
 
15349
#ifdef F77_DUMMY_MAIN
 
15350
#  ifdef __cplusplus
 
15351
     extern "C"
 
15352
#  endif
 
15353
   int F77_DUMMY_MAIN() { return 1; }
 
15354
#endif
 
15355
int
 
15356
main ()
 
15357
{
 
15358
static int test_array [1 - 2 * !(((long) (sizeof (unsigned long))) <= $ac_mid)];
 
15359
test_array [0] = 0
 
15360
 
 
15361
  ;
 
15362
  return 0;
 
15363
}
 
15364
_ACEOF
 
15365
rm -f conftest.$ac_objext
 
15366
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
15367
  (eval $ac_compile) 2>&5
 
15368
  ac_status=$?
 
15369
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15370
  (exit $ac_status); } &&
 
15371
         { ac_try='test -s conftest.$ac_objext'
 
15372
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
15373
  (eval $ac_try) 2>&5
 
15374
  ac_status=$?
 
15375
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15376
  (exit $ac_status); }; }; then
 
15377
  ac_hi=$ac_mid
 
15378
else
 
15379
  echo "$as_me: failed program was:" >&5
 
15380
cat conftest.$ac_ext >&5
 
15381
ac_lo=`expr '(' $ac_mid ')' + 1`
 
15382
fi
 
15383
rm -f conftest.$ac_objext conftest.$ac_ext
 
15384
done
 
15385
case $ac_lo in
 
15386
?*) ac_cv_sizeof_unsigned_long=$ac_lo;;
 
15387
'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (unsigned long), 77" >&5
 
15388
echo "$as_me: error: cannot compute sizeof (unsigned long), 77" >&2;}
 
15389
   { (exit 1); exit 1; }; } ;;
 
15390
esac
 
15391
else
 
15392
  if test "$cross_compiling" = yes; then
 
15393
  { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling" >&5
 
15394
echo "$as_me: error: cannot run test program while cross compiling" >&2;}
 
15395
   { (exit 1); exit 1; }; }
 
15396
else
 
15397
  cat >conftest.$ac_ext <<_ACEOF
 
15398
#line $LINENO "configure"
 
15399
#include "confdefs.h"
 
15400
$ac_includes_default
 
15401
long longval () { return (long) (sizeof (unsigned long)); }
 
15402
unsigned long ulongval () { return (long) (sizeof (unsigned long)); }
 
15403
#include <stdio.h>
 
15404
#include <stdlib.h>
 
15405
#ifdef F77_DUMMY_MAIN
 
15406
#  ifdef __cplusplus
 
15407
     extern "C"
 
15408
#  endif
 
15409
   int F77_DUMMY_MAIN() { return 1; }
 
15410
#endif
 
15411
int
 
15412
main ()
 
15413
{
 
15414
 
 
15415
  FILE *f = fopen ("conftest.val", "w");
 
15416
  if (! f)
 
15417
    exit (1);
 
15418
  if (((long) (sizeof (unsigned long))) < 0)
 
15419
    {
 
15420
      long i = longval ();
 
15421
      if (i != ((long) (sizeof (unsigned long))))
 
15422
        exit (1);
 
15423
      fprintf (f, "%ld\n", i);
 
15424
    }
 
15425
  else
 
15426
    {
 
15427
      unsigned long i = ulongval ();
 
15428
      if (i != ((long) (sizeof (unsigned long))))
 
15429
        exit (1);
 
15430
      fprintf (f, "%lu\n", i);
 
15431
    }
 
15432
  exit (ferror (f) || fclose (f) != 0);
 
15433
 
 
15434
  ;
 
15435
  return 0;
 
15436
}
 
15437
_ACEOF
 
15438
rm -f conftest$ac_exeext
 
15439
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
15440
  (eval $ac_link) 2>&5
 
15441
  ac_status=$?
 
15442
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15443
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
15444
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
15445
  (eval $ac_try) 2>&5
 
15446
  ac_status=$?
 
15447
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15448
  (exit $ac_status); }; }; then
 
15449
  ac_cv_sizeof_unsigned_long=`cat conftest.val`
 
15450
else
 
15451
  echo "$as_me: program exited with status $ac_status" >&5
 
15452
echo "$as_me: failed program was:" >&5
 
15453
cat conftest.$ac_ext >&5
 
15454
( exit $ac_status )
 
15455
{ { echo "$as_me:$LINENO: error: cannot compute sizeof (unsigned long), 77" >&5
 
15456
echo "$as_me: error: cannot compute sizeof (unsigned long), 77" >&2;}
 
15457
   { (exit 1); exit 1; }; }
 
15458
fi
 
15459
rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 
15460
fi
 
15461
fi
 
15462
rm -f conftest.val
 
15463
else
 
15464
  ac_cv_sizeof_unsigned_long=0
 
15465
fi
 
15466
fi
 
15467
echo "$as_me:$LINENO: result: $ac_cv_sizeof_unsigned_long" >&5
 
15468
echo "${ECHO_T}$ac_cv_sizeof_unsigned_long" >&6
 
15469
cat >>confdefs.h <<_ACEOF
 
15470
#define SIZEOF_UNSIGNED_LONG $ac_cv_sizeof_unsigned_long
 
15471
_ACEOF
 
15472
 
 
15473
 
 
15474
 
 
15475
# Determine memory alignment requirements for the basic C data types.
 
15476
 
 
15477
echo "$as_me:$LINENO: checking for short" >&5
 
15478
echo $ECHO_N "checking for short... $ECHO_C" >&6
 
15479
if test "${ac_cv_type_short+set}" = set; then
 
15480
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
15481
else
 
15482
  cat >conftest.$ac_ext <<_ACEOF
 
15483
#line $LINENO "configure"
 
15484
#include "confdefs.h"
 
15485
$ac_includes_default
 
15486
#ifdef F77_DUMMY_MAIN
 
15487
#  ifdef __cplusplus
 
15488
     extern "C"
 
15489
#  endif
 
15490
   int F77_DUMMY_MAIN() { return 1; }
 
15491
#endif
 
15492
int
 
15493
main ()
 
15494
{
 
15495
if ((short *) 0)
 
15496
  return 0;
 
15497
if (sizeof (short))
 
15498
  return 0;
 
15499
  ;
 
15500
  return 0;
 
15501
}
 
15502
_ACEOF
 
15503
rm -f conftest.$ac_objext
 
15504
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
15505
  (eval $ac_compile) 2>&5
 
15506
  ac_status=$?
 
15507
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15508
  (exit $ac_status); } &&
 
15509
         { ac_try='test -s conftest.$ac_objext'
 
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); }; }; then
 
15515
  ac_cv_type_short=yes
 
15516
else
 
15517
  echo "$as_me: failed program was:" >&5
 
15518
cat conftest.$ac_ext >&5
 
15519
ac_cv_type_short=no
 
15520
fi
 
15521
rm -f conftest.$ac_objext conftest.$ac_ext
 
15522
fi
 
15523
echo "$as_me:$LINENO: result: $ac_cv_type_short" >&5
 
15524
echo "${ECHO_T}$ac_cv_type_short" >&6
 
15525
 
 
15526
echo "$as_me:$LINENO: checking alignment of short" >&5
 
15527
echo $ECHO_N "checking alignment of short... $ECHO_C" >&6
 
15528
if test "${pgac_cv_alignof_short+set}" = set; then
 
15529
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
15530
else
 
15531
  if test "$ac_cv_type_short" = yes; then
 
15532
  if test "$cross_compiling" = yes; then
 
15533
  # Depending upon the size, compute the lo and hi bounds.
 
15534
cat >conftest.$ac_ext <<_ACEOF
 
15535
#line $LINENO "configure"
 
15536
#include "confdefs.h"
 
15537
$ac_includes_default
 
15538
struct { char filler; short field; } pgac_struct;
 
15539
#ifdef F77_DUMMY_MAIN
 
15540
#  ifdef __cplusplus
 
15541
     extern "C"
 
15542
#  endif
 
15543
   int F77_DUMMY_MAIN() { return 1; }
 
15544
#endif
 
15545
int
 
15546
main ()
 
15547
{
 
15548
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) >= 0)];
 
15549
test_array [0] = 0
 
15550
 
 
15551
  ;
 
15552
  return 0;
 
15553
}
 
15554
_ACEOF
 
15555
rm -f conftest.$ac_objext
 
15556
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
15557
  (eval $ac_compile) 2>&5
 
15558
  ac_status=$?
 
15559
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15560
  (exit $ac_status); } &&
 
15561
         { ac_try='test -s conftest.$ac_objext'
 
15562
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
15563
  (eval $ac_try) 2>&5
 
15564
  ac_status=$?
 
15565
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15566
  (exit $ac_status); }; }; then
 
15567
  ac_lo=0 ac_mid=0
 
15568
  while :; do
 
15569
    cat >conftest.$ac_ext <<_ACEOF
 
15570
#line $LINENO "configure"
 
15571
#include "confdefs.h"
 
15572
$ac_includes_default
 
15573
struct { char filler; short field; } pgac_struct;
 
15574
#ifdef F77_DUMMY_MAIN
 
15575
#  ifdef __cplusplus
 
15576
     extern "C"
 
15577
#  endif
 
15578
   int F77_DUMMY_MAIN() { return 1; }
 
15579
#endif
 
15580
int
 
15581
main ()
 
15582
{
 
15583
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) <= $ac_mid)];
 
15584
test_array [0] = 0
 
15585
 
 
15586
  ;
 
15587
  return 0;
 
15588
}
 
15589
_ACEOF
 
15590
rm -f conftest.$ac_objext
 
15591
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
15592
  (eval $ac_compile) 2>&5
 
15593
  ac_status=$?
 
15594
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15595
  (exit $ac_status); } &&
 
15596
         { ac_try='test -s conftest.$ac_objext'
 
15597
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
15598
  (eval $ac_try) 2>&5
 
15599
  ac_status=$?
 
15600
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15601
  (exit $ac_status); }; }; then
 
15602
  ac_hi=$ac_mid; break
 
15603
else
 
15604
  echo "$as_me: failed program was:" >&5
 
15605
cat conftest.$ac_ext >&5
 
15606
ac_lo=`expr $ac_mid + 1`
 
15607
                    if test $ac_lo -le $ac_mid; then
 
15608
                      ac_lo= ac_hi=
 
15609
                      break
 
15610
                    fi
 
15611
                    ac_mid=`expr 2 '*' $ac_mid + 1`
 
15612
fi
 
15613
rm -f conftest.$ac_objext conftest.$ac_ext
 
15614
  done
 
15615
else
 
15616
  echo "$as_me: failed program was:" >&5
 
15617
cat conftest.$ac_ext >&5
 
15618
cat >conftest.$ac_ext <<_ACEOF
 
15619
#line $LINENO "configure"
 
15620
#include "confdefs.h"
 
15621
$ac_includes_default
 
15622
struct { char filler; short field; } pgac_struct;
 
15623
#ifdef F77_DUMMY_MAIN
 
15624
#  ifdef __cplusplus
 
15625
     extern "C"
 
15626
#  endif
 
15627
   int F77_DUMMY_MAIN() { return 1; }
 
15628
#endif
 
15629
int
 
15630
main ()
 
15631
{
 
15632
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) < 0)];
 
15633
test_array [0] = 0
 
15634
 
 
15635
  ;
 
15636
  return 0;
 
15637
}
 
15638
_ACEOF
 
15639
rm -f conftest.$ac_objext
 
15640
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
15641
  (eval $ac_compile) 2>&5
 
15642
  ac_status=$?
 
15643
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15644
  (exit $ac_status); } &&
 
15645
         { ac_try='test -s conftest.$ac_objext'
 
15646
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
15647
  (eval $ac_try) 2>&5
 
15648
  ac_status=$?
 
15649
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15650
  (exit $ac_status); }; }; then
 
15651
  ac_hi=-1 ac_mid=-1
 
15652
  while :; do
 
15653
    cat >conftest.$ac_ext <<_ACEOF
 
15654
#line $LINENO "configure"
 
15655
#include "confdefs.h"
 
15656
$ac_includes_default
 
15657
struct { char filler; short field; } pgac_struct;
 
15658
#ifdef F77_DUMMY_MAIN
 
15659
#  ifdef __cplusplus
 
15660
     extern "C"
 
15661
#  endif
 
15662
   int F77_DUMMY_MAIN() { return 1; }
 
15663
#endif
 
15664
int
 
15665
main ()
 
15666
{
 
15667
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) >= $ac_mid)];
 
15668
test_array [0] = 0
 
15669
 
 
15670
  ;
 
15671
  return 0;
 
15672
}
 
15673
_ACEOF
 
15674
rm -f conftest.$ac_objext
 
15675
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
15676
  (eval $ac_compile) 2>&5
 
15677
  ac_status=$?
 
15678
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15679
  (exit $ac_status); } &&
 
15680
         { ac_try='test -s conftest.$ac_objext'
 
15681
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
15682
  (eval $ac_try) 2>&5
 
15683
  ac_status=$?
 
15684
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15685
  (exit $ac_status); }; }; then
 
15686
  ac_lo=$ac_mid; break
 
15687
else
 
15688
  echo "$as_me: failed program was:" >&5
 
15689
cat conftest.$ac_ext >&5
 
15690
ac_hi=`expr '(' $ac_mid ')' - 1`
 
15691
                       if test $ac_mid -le $ac_hi; then
 
15692
                         ac_lo= ac_hi=
 
15693
                         break
 
15694
                       fi
 
15695
                       ac_mid=`expr 2 '*' $ac_mid`
 
15696
fi
 
15697
rm -f conftest.$ac_objext conftest.$ac_ext
 
15698
  done
 
15699
else
 
15700
  echo "$as_me: failed program was:" >&5
 
15701
cat conftest.$ac_ext >&5
 
15702
ac_lo= ac_hi=
 
15703
fi
 
15704
rm -f conftest.$ac_objext conftest.$ac_ext
 
15705
fi
 
15706
rm -f conftest.$ac_objext conftest.$ac_ext
 
15707
# Binary search between lo and hi bounds.
 
15708
while test "x$ac_lo" != "x$ac_hi"; do
 
15709
  ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
 
15710
  cat >conftest.$ac_ext <<_ACEOF
 
15711
#line $LINENO "configure"
 
15712
#include "confdefs.h"
 
15713
$ac_includes_default
 
15714
struct { char filler; short field; } pgac_struct;
 
15715
#ifdef F77_DUMMY_MAIN
 
15716
#  ifdef __cplusplus
 
15717
     extern "C"
 
15718
#  endif
 
15719
   int F77_DUMMY_MAIN() { return 1; }
 
15720
#endif
 
15721
int
 
15722
main ()
 
15723
{
 
15724
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) <= $ac_mid)];
 
15725
test_array [0] = 0
 
15726
 
 
15727
  ;
 
15728
  return 0;
 
15729
}
 
15730
_ACEOF
 
15731
rm -f conftest.$ac_objext
 
15732
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
15733
  (eval $ac_compile) 2>&5
 
15734
  ac_status=$?
 
15735
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15736
  (exit $ac_status); } &&
 
15737
         { ac_try='test -s conftest.$ac_objext'
 
15738
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
15739
  (eval $ac_try) 2>&5
 
15740
  ac_status=$?
 
15741
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15742
  (exit $ac_status); }; }; then
 
15743
  ac_hi=$ac_mid
 
15744
else
 
15745
  echo "$as_me: failed program was:" >&5
 
15746
cat conftest.$ac_ext >&5
 
15747
ac_lo=`expr '(' $ac_mid ')' + 1`
 
15748
fi
 
15749
rm -f conftest.$ac_objext conftest.$ac_ext
 
15750
done
 
15751
case $ac_lo in
 
15752
?*) pgac_cv_alignof_short=$ac_lo;;
 
15753
'') { { echo "$as_me:$LINENO: error: cannot compute alignment of short, 77" >&5
 
15754
echo "$as_me: error: cannot compute alignment of short, 77" >&2;}
 
15755
   { (exit 1); exit 1; }; } ;;
 
15756
esac
 
15757
else
 
15758
  if test "$cross_compiling" = yes; then
 
15759
  { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling" >&5
 
15760
echo "$as_me: error: cannot run test program while cross compiling" >&2;}
 
15761
   { (exit 1); exit 1; }; }
 
15762
else
 
15763
  cat >conftest.$ac_ext <<_ACEOF
 
15764
#line $LINENO "configure"
 
15765
#include "confdefs.h"
 
15766
$ac_includes_default
 
15767
struct { char filler; short field; } pgac_struct;
 
15768
long longval () { return ((char*) & pgac_struct.field) - ((char*) & pgac_struct); }
 
15769
unsigned long ulongval () { return ((char*) & pgac_struct.field) - ((char*) & pgac_struct); }
 
15770
#include <stdio.h>
 
15771
#include <stdlib.h>
 
15772
#ifdef F77_DUMMY_MAIN
 
15773
#  ifdef __cplusplus
 
15774
     extern "C"
 
15775
#  endif
 
15776
   int F77_DUMMY_MAIN() { return 1; }
 
15777
#endif
 
15778
int
 
15779
main ()
 
15780
{
 
15781
 
 
15782
  FILE *f = fopen ("conftest.val", "w");
 
15783
  if (! f)
 
15784
    exit (1);
 
15785
  if ((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) < 0)
 
15786
    {
 
15787
      long i = longval ();
 
15788
      if (i != (((char*) & pgac_struct.field) - ((char*) & pgac_struct)))
 
15789
        exit (1);
 
15790
      fprintf (f, "%ld\n", i);
 
15791
    }
 
15792
  else
 
15793
    {
 
15794
      unsigned long i = ulongval ();
 
15795
      if (i != (((char*) & pgac_struct.field) - ((char*) & pgac_struct)))
 
15796
        exit (1);
 
15797
      fprintf (f, "%lu\n", i);
 
15798
    }
 
15799
  exit (ferror (f) || fclose (f) != 0);
 
15800
 
 
15801
  ;
 
15802
  return 0;
 
15803
}
 
15804
_ACEOF
 
15805
rm -f conftest$ac_exeext
 
15806
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
15807
  (eval $ac_link) 2>&5
 
15808
  ac_status=$?
 
15809
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15810
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
15811
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
15812
  (eval $ac_try) 2>&5
 
15813
  ac_status=$?
 
15814
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15815
  (exit $ac_status); }; }; then
 
15816
  pgac_cv_alignof_short=`cat conftest.val`
 
15817
else
 
15818
  echo "$as_me: program exited with status $ac_status" >&5
 
15819
echo "$as_me: failed program was:" >&5
 
15820
cat conftest.$ac_ext >&5
 
15821
( exit $ac_status )
 
15822
{ { echo "$as_me:$LINENO: error: cannot compute alignment of short, 77" >&5
 
15823
echo "$as_me: error: cannot compute alignment of short, 77" >&2;}
 
15824
   { (exit 1); exit 1; }; }
 
15825
fi
 
15826
rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 
15827
fi
 
15828
fi
 
15829
rm -f conftest.val
 
15830
else
 
15831
  pgac_cv_alignof_short=0
 
15832
fi
 
15833
fi
 
15834
echo "$as_me:$LINENO: result: $pgac_cv_alignof_short" >&5
 
15835
echo "${ECHO_T}$pgac_cv_alignof_short" >&6
 
15836
cat >>confdefs.h <<_ACEOF
 
15837
#define ALIGNOF_SHORT $pgac_cv_alignof_short
 
15838
_ACEOF
 
15839
 
 
15840
 
 
15841
echo "$as_me:$LINENO: checking for int" >&5
 
15842
echo $ECHO_N "checking for int... $ECHO_C" >&6
 
15843
if test "${ac_cv_type_int+set}" = set; then
 
15844
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
15845
else
 
15846
  cat >conftest.$ac_ext <<_ACEOF
 
15847
#line $LINENO "configure"
 
15848
#include "confdefs.h"
 
15849
$ac_includes_default
 
15850
#ifdef F77_DUMMY_MAIN
 
15851
#  ifdef __cplusplus
 
15852
     extern "C"
 
15853
#  endif
 
15854
   int F77_DUMMY_MAIN() { return 1; }
 
15855
#endif
 
15856
int
 
15857
main ()
 
15858
{
 
15859
if ((int *) 0)
 
15860
  return 0;
 
15861
if (sizeof (int))
 
15862
  return 0;
 
15863
  ;
 
15864
  return 0;
 
15865
}
 
15866
_ACEOF
 
15867
rm -f conftest.$ac_objext
 
15868
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
15869
  (eval $ac_compile) 2>&5
 
15870
  ac_status=$?
 
15871
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15872
  (exit $ac_status); } &&
 
15873
         { ac_try='test -s conftest.$ac_objext'
 
15874
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
15875
  (eval $ac_try) 2>&5
 
15876
  ac_status=$?
 
15877
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15878
  (exit $ac_status); }; }; then
 
15879
  ac_cv_type_int=yes
 
15880
else
 
15881
  echo "$as_me: failed program was:" >&5
 
15882
cat conftest.$ac_ext >&5
 
15883
ac_cv_type_int=no
 
15884
fi
 
15885
rm -f conftest.$ac_objext conftest.$ac_ext
 
15886
fi
 
15887
echo "$as_me:$LINENO: result: $ac_cv_type_int" >&5
 
15888
echo "${ECHO_T}$ac_cv_type_int" >&6
 
15889
 
 
15890
echo "$as_me:$LINENO: checking alignment of int" >&5
 
15891
echo $ECHO_N "checking alignment of int... $ECHO_C" >&6
 
15892
if test "${pgac_cv_alignof_int+set}" = set; then
 
15893
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
15894
else
 
15895
  if test "$ac_cv_type_int" = yes; then
 
15896
  if test "$cross_compiling" = yes; then
 
15897
  # Depending upon the size, compute the lo and hi bounds.
 
15898
cat >conftest.$ac_ext <<_ACEOF
 
15899
#line $LINENO "configure"
 
15900
#include "confdefs.h"
 
15901
$ac_includes_default
 
15902
struct { char filler; int field; } pgac_struct;
 
15903
#ifdef F77_DUMMY_MAIN
 
15904
#  ifdef __cplusplus
 
15905
     extern "C"
 
15906
#  endif
 
15907
   int F77_DUMMY_MAIN() { return 1; }
 
15908
#endif
 
15909
int
 
15910
main ()
 
15911
{
 
15912
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) >= 0)];
 
15913
test_array [0] = 0
 
15914
 
 
15915
  ;
 
15916
  return 0;
 
15917
}
 
15918
_ACEOF
 
15919
rm -f conftest.$ac_objext
 
15920
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
15921
  (eval $ac_compile) 2>&5
 
15922
  ac_status=$?
 
15923
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15924
  (exit $ac_status); } &&
 
15925
         { ac_try='test -s conftest.$ac_objext'
 
15926
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
15927
  (eval $ac_try) 2>&5
 
15928
  ac_status=$?
 
15929
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15930
  (exit $ac_status); }; }; then
 
15931
  ac_lo=0 ac_mid=0
 
15932
  while :; do
 
15933
    cat >conftest.$ac_ext <<_ACEOF
 
15934
#line $LINENO "configure"
 
15935
#include "confdefs.h"
 
15936
$ac_includes_default
 
15937
struct { char filler; int field; } pgac_struct;
 
15938
#ifdef F77_DUMMY_MAIN
 
15939
#  ifdef __cplusplus
 
15940
     extern "C"
 
15941
#  endif
 
15942
   int F77_DUMMY_MAIN() { return 1; }
 
15943
#endif
 
15944
int
 
15945
main ()
 
15946
{
 
15947
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) <= $ac_mid)];
 
15948
test_array [0] = 0
 
15949
 
 
15950
  ;
 
15951
  return 0;
 
15952
}
 
15953
_ACEOF
 
15954
rm -f conftest.$ac_objext
 
15955
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
15956
  (eval $ac_compile) 2>&5
 
15957
  ac_status=$?
 
15958
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15959
  (exit $ac_status); } &&
 
15960
         { ac_try='test -s conftest.$ac_objext'
 
15961
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
15962
  (eval $ac_try) 2>&5
 
15963
  ac_status=$?
 
15964
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
15965
  (exit $ac_status); }; }; then
 
15966
  ac_hi=$ac_mid; break
 
15967
else
 
15968
  echo "$as_me: failed program was:" >&5
 
15969
cat conftest.$ac_ext >&5
 
15970
ac_lo=`expr $ac_mid + 1`
 
15971
                    if test $ac_lo -le $ac_mid; then
 
15972
                      ac_lo= ac_hi=
 
15973
                      break
 
15974
                    fi
 
15975
                    ac_mid=`expr 2 '*' $ac_mid + 1`
 
15976
fi
 
15977
rm -f conftest.$ac_objext conftest.$ac_ext
 
15978
  done
 
15979
else
 
15980
  echo "$as_me: failed program was:" >&5
 
15981
cat conftest.$ac_ext >&5
 
15982
cat >conftest.$ac_ext <<_ACEOF
 
15983
#line $LINENO "configure"
 
15984
#include "confdefs.h"
 
15985
$ac_includes_default
 
15986
struct { char filler; int field; } pgac_struct;
 
15987
#ifdef F77_DUMMY_MAIN
 
15988
#  ifdef __cplusplus
 
15989
     extern "C"
 
15990
#  endif
 
15991
   int F77_DUMMY_MAIN() { return 1; }
 
15992
#endif
 
15993
int
 
15994
main ()
 
15995
{
 
15996
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) < 0)];
 
15997
test_array [0] = 0
 
15998
 
 
15999
  ;
 
16000
  return 0;
 
16001
}
 
16002
_ACEOF
 
16003
rm -f conftest.$ac_objext
 
16004
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
16005
  (eval $ac_compile) 2>&5
 
16006
  ac_status=$?
 
16007
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16008
  (exit $ac_status); } &&
 
16009
         { ac_try='test -s conftest.$ac_objext'
 
16010
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
16011
  (eval $ac_try) 2>&5
 
16012
  ac_status=$?
 
16013
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16014
  (exit $ac_status); }; }; then
 
16015
  ac_hi=-1 ac_mid=-1
 
16016
  while :; do
 
16017
    cat >conftest.$ac_ext <<_ACEOF
 
16018
#line $LINENO "configure"
 
16019
#include "confdefs.h"
 
16020
$ac_includes_default
 
16021
struct { char filler; int field; } pgac_struct;
 
16022
#ifdef F77_DUMMY_MAIN
 
16023
#  ifdef __cplusplus
 
16024
     extern "C"
 
16025
#  endif
 
16026
   int F77_DUMMY_MAIN() { return 1; }
 
16027
#endif
 
16028
int
 
16029
main ()
 
16030
{
 
16031
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) >= $ac_mid)];
 
16032
test_array [0] = 0
 
16033
 
 
16034
  ;
 
16035
  return 0;
 
16036
}
 
16037
_ACEOF
 
16038
rm -f conftest.$ac_objext
 
16039
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
16040
  (eval $ac_compile) 2>&5
 
16041
  ac_status=$?
 
16042
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16043
  (exit $ac_status); } &&
 
16044
         { ac_try='test -s conftest.$ac_objext'
 
16045
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
16046
  (eval $ac_try) 2>&5
 
16047
  ac_status=$?
 
16048
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16049
  (exit $ac_status); }; }; then
 
16050
  ac_lo=$ac_mid; break
 
16051
else
 
16052
  echo "$as_me: failed program was:" >&5
 
16053
cat conftest.$ac_ext >&5
 
16054
ac_hi=`expr '(' $ac_mid ')' - 1`
 
16055
                       if test $ac_mid -le $ac_hi; then
 
16056
                         ac_lo= ac_hi=
 
16057
                         break
 
16058
                       fi
 
16059
                       ac_mid=`expr 2 '*' $ac_mid`
 
16060
fi
 
16061
rm -f conftest.$ac_objext conftest.$ac_ext
 
16062
  done
 
16063
else
 
16064
  echo "$as_me: failed program was:" >&5
 
16065
cat conftest.$ac_ext >&5
 
16066
ac_lo= ac_hi=
 
16067
fi
 
16068
rm -f conftest.$ac_objext conftest.$ac_ext
 
16069
fi
 
16070
rm -f conftest.$ac_objext conftest.$ac_ext
 
16071
# Binary search between lo and hi bounds.
 
16072
while test "x$ac_lo" != "x$ac_hi"; do
 
16073
  ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
 
16074
  cat >conftest.$ac_ext <<_ACEOF
 
16075
#line $LINENO "configure"
 
16076
#include "confdefs.h"
 
16077
$ac_includes_default
 
16078
struct { char filler; int field; } pgac_struct;
 
16079
#ifdef F77_DUMMY_MAIN
 
16080
#  ifdef __cplusplus
 
16081
     extern "C"
 
16082
#  endif
 
16083
   int F77_DUMMY_MAIN() { return 1; }
 
16084
#endif
 
16085
int
 
16086
main ()
 
16087
{
 
16088
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) <= $ac_mid)];
 
16089
test_array [0] = 0
 
16090
 
 
16091
  ;
 
16092
  return 0;
 
16093
}
 
16094
_ACEOF
 
16095
rm -f conftest.$ac_objext
 
16096
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
16097
  (eval $ac_compile) 2>&5
 
16098
  ac_status=$?
 
16099
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16100
  (exit $ac_status); } &&
 
16101
         { ac_try='test -s conftest.$ac_objext'
 
16102
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
16103
  (eval $ac_try) 2>&5
 
16104
  ac_status=$?
 
16105
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16106
  (exit $ac_status); }; }; then
 
16107
  ac_hi=$ac_mid
 
16108
else
 
16109
  echo "$as_me: failed program was:" >&5
 
16110
cat conftest.$ac_ext >&5
 
16111
ac_lo=`expr '(' $ac_mid ')' + 1`
 
16112
fi
 
16113
rm -f conftest.$ac_objext conftest.$ac_ext
 
16114
done
 
16115
case $ac_lo in
 
16116
?*) pgac_cv_alignof_int=$ac_lo;;
 
16117
'') { { echo "$as_me:$LINENO: error: cannot compute alignment of int, 77" >&5
 
16118
echo "$as_me: error: cannot compute alignment of int, 77" >&2;}
 
16119
   { (exit 1); exit 1; }; } ;;
 
16120
esac
 
16121
else
 
16122
  if test "$cross_compiling" = yes; then
 
16123
  { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling" >&5
 
16124
echo "$as_me: error: cannot run test program while cross compiling" >&2;}
 
16125
   { (exit 1); exit 1; }; }
 
16126
else
 
16127
  cat >conftest.$ac_ext <<_ACEOF
 
16128
#line $LINENO "configure"
 
16129
#include "confdefs.h"
 
16130
$ac_includes_default
 
16131
struct { char filler; int field; } pgac_struct;
 
16132
long longval () { return ((char*) & pgac_struct.field) - ((char*) & pgac_struct); }
 
16133
unsigned long ulongval () { return ((char*) & pgac_struct.field) - ((char*) & pgac_struct); }
 
16134
#include <stdio.h>
 
16135
#include <stdlib.h>
 
16136
#ifdef F77_DUMMY_MAIN
 
16137
#  ifdef __cplusplus
 
16138
     extern "C"
 
16139
#  endif
 
16140
   int F77_DUMMY_MAIN() { return 1; }
 
16141
#endif
 
16142
int
 
16143
main ()
 
16144
{
 
16145
 
 
16146
  FILE *f = fopen ("conftest.val", "w");
 
16147
  if (! f)
 
16148
    exit (1);
 
16149
  if ((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) < 0)
 
16150
    {
 
16151
      long i = longval ();
 
16152
      if (i != (((char*) & pgac_struct.field) - ((char*) & pgac_struct)))
 
16153
        exit (1);
 
16154
      fprintf (f, "%ld\n", i);
 
16155
    }
 
16156
  else
 
16157
    {
 
16158
      unsigned long i = ulongval ();
 
16159
      if (i != (((char*) & pgac_struct.field) - ((char*) & pgac_struct)))
 
16160
        exit (1);
 
16161
      fprintf (f, "%lu\n", i);
 
16162
    }
 
16163
  exit (ferror (f) || fclose (f) != 0);
 
16164
 
 
16165
  ;
 
16166
  return 0;
 
16167
}
 
16168
_ACEOF
 
16169
rm -f conftest$ac_exeext
 
16170
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
16171
  (eval $ac_link) 2>&5
 
16172
  ac_status=$?
 
16173
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16174
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
16175
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
16176
  (eval $ac_try) 2>&5
 
16177
  ac_status=$?
 
16178
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16179
  (exit $ac_status); }; }; then
 
16180
  pgac_cv_alignof_int=`cat conftest.val`
 
16181
else
 
16182
  echo "$as_me: program exited with status $ac_status" >&5
 
16183
echo "$as_me: failed program was:" >&5
 
16184
cat conftest.$ac_ext >&5
 
16185
( exit $ac_status )
 
16186
{ { echo "$as_me:$LINENO: error: cannot compute alignment of int, 77" >&5
 
16187
echo "$as_me: error: cannot compute alignment of int, 77" >&2;}
 
16188
   { (exit 1); exit 1; }; }
 
16189
fi
 
16190
rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 
16191
fi
 
16192
fi
 
16193
rm -f conftest.val
 
16194
else
 
16195
  pgac_cv_alignof_int=0
 
16196
fi
 
16197
fi
 
16198
echo "$as_me:$LINENO: result: $pgac_cv_alignof_int" >&5
 
16199
echo "${ECHO_T}$pgac_cv_alignof_int" >&6
 
16200
cat >>confdefs.h <<_ACEOF
 
16201
#define ALIGNOF_INT $pgac_cv_alignof_int
 
16202
_ACEOF
 
16203
 
 
16204
 
 
16205
echo "$as_me:$LINENO: checking for long" >&5
 
16206
echo $ECHO_N "checking for long... $ECHO_C" >&6
 
16207
if test "${ac_cv_type_long+set}" = set; then
 
16208
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
16209
else
 
16210
  cat >conftest.$ac_ext <<_ACEOF
 
16211
#line $LINENO "configure"
 
16212
#include "confdefs.h"
 
16213
$ac_includes_default
 
16214
#ifdef F77_DUMMY_MAIN
 
16215
#  ifdef __cplusplus
 
16216
     extern "C"
 
16217
#  endif
 
16218
   int F77_DUMMY_MAIN() { return 1; }
 
16219
#endif
 
16220
int
 
16221
main ()
 
16222
{
 
16223
if ((long *) 0)
 
16224
  return 0;
 
16225
if (sizeof (long))
 
16226
  return 0;
 
16227
  ;
 
16228
  return 0;
 
16229
}
 
16230
_ACEOF
 
16231
rm -f conftest.$ac_objext
 
16232
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
16233
  (eval $ac_compile) 2>&5
 
16234
  ac_status=$?
 
16235
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16236
  (exit $ac_status); } &&
 
16237
         { ac_try='test -s conftest.$ac_objext'
 
16238
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
16239
  (eval $ac_try) 2>&5
 
16240
  ac_status=$?
 
16241
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16242
  (exit $ac_status); }; }; then
 
16243
  ac_cv_type_long=yes
 
16244
else
 
16245
  echo "$as_me: failed program was:" >&5
 
16246
cat conftest.$ac_ext >&5
 
16247
ac_cv_type_long=no
 
16248
fi
 
16249
rm -f conftest.$ac_objext conftest.$ac_ext
 
16250
fi
 
16251
echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5
 
16252
echo "${ECHO_T}$ac_cv_type_long" >&6
 
16253
 
 
16254
echo "$as_me:$LINENO: checking alignment of long" >&5
 
16255
echo $ECHO_N "checking alignment of long... $ECHO_C" >&6
 
16256
if test "${pgac_cv_alignof_long+set}" = set; then
 
16257
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
16258
else
 
16259
  if test "$ac_cv_type_long" = yes; then
 
16260
  if test "$cross_compiling" = yes; then
 
16261
  # Depending upon the size, compute the lo and hi bounds.
 
16262
cat >conftest.$ac_ext <<_ACEOF
 
16263
#line $LINENO "configure"
 
16264
#include "confdefs.h"
 
16265
$ac_includes_default
 
16266
struct { char filler; long field; } pgac_struct;
 
16267
#ifdef F77_DUMMY_MAIN
 
16268
#  ifdef __cplusplus
 
16269
     extern "C"
 
16270
#  endif
 
16271
   int F77_DUMMY_MAIN() { return 1; }
 
16272
#endif
 
16273
int
 
16274
main ()
 
16275
{
 
16276
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) >= 0)];
 
16277
test_array [0] = 0
 
16278
 
 
16279
  ;
 
16280
  return 0;
 
16281
}
 
16282
_ACEOF
 
16283
rm -f conftest.$ac_objext
 
16284
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
16285
  (eval $ac_compile) 2>&5
 
16286
  ac_status=$?
 
16287
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16288
  (exit $ac_status); } &&
 
16289
         { ac_try='test -s conftest.$ac_objext'
 
16290
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
16291
  (eval $ac_try) 2>&5
 
16292
  ac_status=$?
 
16293
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16294
  (exit $ac_status); }; }; then
 
16295
  ac_lo=0 ac_mid=0
 
16296
  while :; do
 
16297
    cat >conftest.$ac_ext <<_ACEOF
 
16298
#line $LINENO "configure"
 
16299
#include "confdefs.h"
 
16300
$ac_includes_default
 
16301
struct { char filler; long field; } pgac_struct;
 
16302
#ifdef F77_DUMMY_MAIN
 
16303
#  ifdef __cplusplus
 
16304
     extern "C"
 
16305
#  endif
 
16306
   int F77_DUMMY_MAIN() { return 1; }
 
16307
#endif
 
16308
int
 
16309
main ()
 
16310
{
 
16311
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) <= $ac_mid)];
 
16312
test_array [0] = 0
 
16313
 
 
16314
  ;
 
16315
  return 0;
 
16316
}
 
16317
_ACEOF
 
16318
rm -f conftest.$ac_objext
 
16319
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
16320
  (eval $ac_compile) 2>&5
 
16321
  ac_status=$?
 
16322
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16323
  (exit $ac_status); } &&
 
16324
         { ac_try='test -s conftest.$ac_objext'
 
16325
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
16326
  (eval $ac_try) 2>&5
 
16327
  ac_status=$?
 
16328
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16329
  (exit $ac_status); }; }; then
 
16330
  ac_hi=$ac_mid; break
 
16331
else
 
16332
  echo "$as_me: failed program was:" >&5
 
16333
cat conftest.$ac_ext >&5
 
16334
ac_lo=`expr $ac_mid + 1`
 
16335
                    if test $ac_lo -le $ac_mid; then
 
16336
                      ac_lo= ac_hi=
 
16337
                      break
 
16338
                    fi
 
16339
                    ac_mid=`expr 2 '*' $ac_mid + 1`
 
16340
fi
 
16341
rm -f conftest.$ac_objext conftest.$ac_ext
 
16342
  done
 
16343
else
 
16344
  echo "$as_me: failed program was:" >&5
 
16345
cat conftest.$ac_ext >&5
 
16346
cat >conftest.$ac_ext <<_ACEOF
 
16347
#line $LINENO "configure"
 
16348
#include "confdefs.h"
 
16349
$ac_includes_default
 
16350
struct { char filler; long field; } pgac_struct;
 
16351
#ifdef F77_DUMMY_MAIN
 
16352
#  ifdef __cplusplus
 
16353
     extern "C"
 
16354
#  endif
 
16355
   int F77_DUMMY_MAIN() { return 1; }
 
16356
#endif
 
16357
int
 
16358
main ()
 
16359
{
 
16360
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) < 0)];
 
16361
test_array [0] = 0
 
16362
 
 
16363
  ;
 
16364
  return 0;
 
16365
}
 
16366
_ACEOF
 
16367
rm -f conftest.$ac_objext
 
16368
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
16369
  (eval $ac_compile) 2>&5
 
16370
  ac_status=$?
 
16371
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16372
  (exit $ac_status); } &&
 
16373
         { ac_try='test -s conftest.$ac_objext'
 
16374
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
16375
  (eval $ac_try) 2>&5
 
16376
  ac_status=$?
 
16377
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16378
  (exit $ac_status); }; }; then
 
16379
  ac_hi=-1 ac_mid=-1
 
16380
  while :; do
 
16381
    cat >conftest.$ac_ext <<_ACEOF
 
16382
#line $LINENO "configure"
 
16383
#include "confdefs.h"
 
16384
$ac_includes_default
 
16385
struct { char filler; long field; } pgac_struct;
 
16386
#ifdef F77_DUMMY_MAIN
 
16387
#  ifdef __cplusplus
 
16388
     extern "C"
 
16389
#  endif
 
16390
   int F77_DUMMY_MAIN() { return 1; }
 
16391
#endif
 
16392
int
 
16393
main ()
 
16394
{
 
16395
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) >= $ac_mid)];
 
16396
test_array [0] = 0
 
16397
 
 
16398
  ;
 
16399
  return 0;
 
16400
}
 
16401
_ACEOF
 
16402
rm -f conftest.$ac_objext
 
16403
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
16404
  (eval $ac_compile) 2>&5
 
16405
  ac_status=$?
 
16406
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16407
  (exit $ac_status); } &&
 
16408
         { ac_try='test -s conftest.$ac_objext'
 
16409
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
16410
  (eval $ac_try) 2>&5
 
16411
  ac_status=$?
 
16412
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16413
  (exit $ac_status); }; }; then
 
16414
  ac_lo=$ac_mid; break
 
16415
else
 
16416
  echo "$as_me: failed program was:" >&5
 
16417
cat conftest.$ac_ext >&5
 
16418
ac_hi=`expr '(' $ac_mid ')' - 1`
 
16419
                       if test $ac_mid -le $ac_hi; then
 
16420
                         ac_lo= ac_hi=
 
16421
                         break
 
16422
                       fi
 
16423
                       ac_mid=`expr 2 '*' $ac_mid`
 
16424
fi
 
16425
rm -f conftest.$ac_objext conftest.$ac_ext
 
16426
  done
 
16427
else
 
16428
  echo "$as_me: failed program was:" >&5
 
16429
cat conftest.$ac_ext >&5
 
16430
ac_lo= ac_hi=
 
16431
fi
 
16432
rm -f conftest.$ac_objext conftest.$ac_ext
 
16433
fi
 
16434
rm -f conftest.$ac_objext conftest.$ac_ext
 
16435
# Binary search between lo and hi bounds.
 
16436
while test "x$ac_lo" != "x$ac_hi"; do
 
16437
  ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
 
16438
  cat >conftest.$ac_ext <<_ACEOF
 
16439
#line $LINENO "configure"
 
16440
#include "confdefs.h"
 
16441
$ac_includes_default
 
16442
struct { char filler; long field; } pgac_struct;
 
16443
#ifdef F77_DUMMY_MAIN
 
16444
#  ifdef __cplusplus
 
16445
     extern "C"
 
16446
#  endif
 
16447
   int F77_DUMMY_MAIN() { return 1; }
 
16448
#endif
 
16449
int
 
16450
main ()
 
16451
{
 
16452
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) <= $ac_mid)];
 
16453
test_array [0] = 0
 
16454
 
 
16455
  ;
 
16456
  return 0;
 
16457
}
 
16458
_ACEOF
 
16459
rm -f conftest.$ac_objext
 
16460
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
16461
  (eval $ac_compile) 2>&5
 
16462
  ac_status=$?
 
16463
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16464
  (exit $ac_status); } &&
 
16465
         { ac_try='test -s conftest.$ac_objext'
 
16466
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
16467
  (eval $ac_try) 2>&5
 
16468
  ac_status=$?
 
16469
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16470
  (exit $ac_status); }; }; then
 
16471
  ac_hi=$ac_mid
 
16472
else
 
16473
  echo "$as_me: failed program was:" >&5
 
16474
cat conftest.$ac_ext >&5
 
16475
ac_lo=`expr '(' $ac_mid ')' + 1`
 
16476
fi
 
16477
rm -f conftest.$ac_objext conftest.$ac_ext
 
16478
done
 
16479
case $ac_lo in
 
16480
?*) pgac_cv_alignof_long=$ac_lo;;
 
16481
'') { { echo "$as_me:$LINENO: error: cannot compute alignment of long, 77" >&5
 
16482
echo "$as_me: error: cannot compute alignment of long, 77" >&2;}
 
16483
   { (exit 1); exit 1; }; } ;;
 
16484
esac
 
16485
else
 
16486
  if test "$cross_compiling" = yes; then
 
16487
  { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling" >&5
 
16488
echo "$as_me: error: cannot run test program while cross compiling" >&2;}
 
16489
   { (exit 1); exit 1; }; }
 
16490
else
 
16491
  cat >conftest.$ac_ext <<_ACEOF
 
16492
#line $LINENO "configure"
 
16493
#include "confdefs.h"
 
16494
$ac_includes_default
 
16495
struct { char filler; long field; } pgac_struct;
 
16496
long longval () { return ((char*) & pgac_struct.field) - ((char*) & pgac_struct); }
 
16497
unsigned long ulongval () { return ((char*) & pgac_struct.field) - ((char*) & pgac_struct); }
 
16498
#include <stdio.h>
 
16499
#include <stdlib.h>
 
16500
#ifdef F77_DUMMY_MAIN
 
16501
#  ifdef __cplusplus
 
16502
     extern "C"
 
16503
#  endif
 
16504
   int F77_DUMMY_MAIN() { return 1; }
 
16505
#endif
 
16506
int
 
16507
main ()
 
16508
{
 
16509
 
 
16510
  FILE *f = fopen ("conftest.val", "w");
 
16511
  if (! f)
 
16512
    exit (1);
 
16513
  if ((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) < 0)
 
16514
    {
 
16515
      long i = longval ();
 
16516
      if (i != (((char*) & pgac_struct.field) - ((char*) & pgac_struct)))
 
16517
        exit (1);
 
16518
      fprintf (f, "%ld\n", i);
 
16519
    }
 
16520
  else
 
16521
    {
 
16522
      unsigned long i = ulongval ();
 
16523
      if (i != (((char*) & pgac_struct.field) - ((char*) & pgac_struct)))
 
16524
        exit (1);
 
16525
      fprintf (f, "%lu\n", i);
 
16526
    }
 
16527
  exit (ferror (f) || fclose (f) != 0);
 
16528
 
 
16529
  ;
 
16530
  return 0;
 
16531
}
 
16532
_ACEOF
 
16533
rm -f conftest$ac_exeext
 
16534
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
16535
  (eval $ac_link) 2>&5
 
16536
  ac_status=$?
 
16537
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16538
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
16539
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
16540
  (eval $ac_try) 2>&5
 
16541
  ac_status=$?
 
16542
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16543
  (exit $ac_status); }; }; then
 
16544
  pgac_cv_alignof_long=`cat conftest.val`
 
16545
else
 
16546
  echo "$as_me: program exited with status $ac_status" >&5
 
16547
echo "$as_me: failed program was:" >&5
 
16548
cat conftest.$ac_ext >&5
 
16549
( exit $ac_status )
 
16550
{ { echo "$as_me:$LINENO: error: cannot compute alignment of long, 77" >&5
 
16551
echo "$as_me: error: cannot compute alignment of long, 77" >&2;}
 
16552
   { (exit 1); exit 1; }; }
 
16553
fi
 
16554
rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 
16555
fi
 
16556
fi
 
16557
rm -f conftest.val
 
16558
else
 
16559
  pgac_cv_alignof_long=0
 
16560
fi
 
16561
fi
 
16562
echo "$as_me:$LINENO: result: $pgac_cv_alignof_long" >&5
 
16563
echo "${ECHO_T}$pgac_cv_alignof_long" >&6
 
16564
cat >>confdefs.h <<_ACEOF
 
16565
#define ALIGNOF_LONG $pgac_cv_alignof_long
 
16566
_ACEOF
 
16567
 
 
16568
 
 
16569
if test x"$HAVE_LONG_LONG_INT_64" = x"yes" ; then
 
16570
  echo "$as_me:$LINENO: checking for long long int" >&5
 
16571
echo $ECHO_N "checking for long long int... $ECHO_C" >&6
 
16572
if test "${ac_cv_type_long_long_int+set}" = set; then
 
16573
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
16574
else
 
16575
  cat >conftest.$ac_ext <<_ACEOF
 
16576
#line $LINENO "configure"
 
16577
#include "confdefs.h"
 
16578
$ac_includes_default
 
16579
#ifdef F77_DUMMY_MAIN
 
16580
#  ifdef __cplusplus
 
16581
     extern "C"
 
16582
#  endif
 
16583
   int F77_DUMMY_MAIN() { return 1; }
 
16584
#endif
 
16585
int
 
16586
main ()
 
16587
{
 
16588
if ((long long int *) 0)
 
16589
  return 0;
 
16590
if (sizeof (long long int))
 
16591
  return 0;
 
16592
  ;
 
16593
  return 0;
 
16594
}
 
16595
_ACEOF
 
16596
rm -f conftest.$ac_objext
 
16597
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
16598
  (eval $ac_compile) 2>&5
 
16599
  ac_status=$?
 
16600
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16601
  (exit $ac_status); } &&
 
16602
         { ac_try='test -s conftest.$ac_objext'
 
16603
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
16604
  (eval $ac_try) 2>&5
 
16605
  ac_status=$?
 
16606
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16607
  (exit $ac_status); }; }; then
 
16608
  ac_cv_type_long_long_int=yes
 
16609
else
 
16610
  echo "$as_me: failed program was:" >&5
 
16611
cat conftest.$ac_ext >&5
 
16612
ac_cv_type_long_long_int=no
 
16613
fi
 
16614
rm -f conftest.$ac_objext conftest.$ac_ext
 
16615
fi
 
16616
echo "$as_me:$LINENO: result: $ac_cv_type_long_long_int" >&5
 
16617
echo "${ECHO_T}$ac_cv_type_long_long_int" >&6
 
16618
 
 
16619
echo "$as_me:$LINENO: checking alignment of long long int" >&5
 
16620
echo $ECHO_N "checking alignment of long long int... $ECHO_C" >&6
 
16621
if test "${pgac_cv_alignof_long_long_int+set}" = set; then
 
16622
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
16623
else
 
16624
  if test "$ac_cv_type_long_long_int" = yes; then
 
16625
  if test "$cross_compiling" = yes; then
 
16626
  # Depending upon the size, compute the lo and hi bounds.
 
16627
cat >conftest.$ac_ext <<_ACEOF
 
16628
#line $LINENO "configure"
 
16629
#include "confdefs.h"
 
16630
$ac_includes_default
 
16631
struct { char filler; long long int field; } pgac_struct;
 
16632
#ifdef F77_DUMMY_MAIN
 
16633
#  ifdef __cplusplus
 
16634
     extern "C"
 
16635
#  endif
 
16636
   int F77_DUMMY_MAIN() { return 1; }
 
16637
#endif
 
16638
int
 
16639
main ()
 
16640
{
 
16641
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) >= 0)];
 
16642
test_array [0] = 0
 
16643
 
 
16644
  ;
 
16645
  return 0;
 
16646
}
 
16647
_ACEOF
 
16648
rm -f conftest.$ac_objext
 
16649
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
16650
  (eval $ac_compile) 2>&5
 
16651
  ac_status=$?
 
16652
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16653
  (exit $ac_status); } &&
 
16654
         { ac_try='test -s conftest.$ac_objext'
 
16655
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
16656
  (eval $ac_try) 2>&5
 
16657
  ac_status=$?
 
16658
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16659
  (exit $ac_status); }; }; then
 
16660
  ac_lo=0 ac_mid=0
 
16661
  while :; do
 
16662
    cat >conftest.$ac_ext <<_ACEOF
 
16663
#line $LINENO "configure"
 
16664
#include "confdefs.h"
 
16665
$ac_includes_default
 
16666
struct { char filler; long long int field; } pgac_struct;
 
16667
#ifdef F77_DUMMY_MAIN
 
16668
#  ifdef __cplusplus
 
16669
     extern "C"
 
16670
#  endif
 
16671
   int F77_DUMMY_MAIN() { return 1; }
 
16672
#endif
 
16673
int
 
16674
main ()
 
16675
{
 
16676
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) <= $ac_mid)];
 
16677
test_array [0] = 0
 
16678
 
 
16679
  ;
 
16680
  return 0;
 
16681
}
 
16682
_ACEOF
 
16683
rm -f conftest.$ac_objext
 
16684
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
16685
  (eval $ac_compile) 2>&5
 
16686
  ac_status=$?
 
16687
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16688
  (exit $ac_status); } &&
 
16689
         { ac_try='test -s conftest.$ac_objext'
 
16690
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
16691
  (eval $ac_try) 2>&5
 
16692
  ac_status=$?
 
16693
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16694
  (exit $ac_status); }; }; then
 
16695
  ac_hi=$ac_mid; break
 
16696
else
 
16697
  echo "$as_me: failed program was:" >&5
 
16698
cat conftest.$ac_ext >&5
 
16699
ac_lo=`expr $ac_mid + 1`
 
16700
                    if test $ac_lo -le $ac_mid; then
 
16701
                      ac_lo= ac_hi=
 
16702
                      break
 
16703
                    fi
 
16704
                    ac_mid=`expr 2 '*' $ac_mid + 1`
 
16705
fi
 
16706
rm -f conftest.$ac_objext conftest.$ac_ext
 
16707
  done
 
16708
else
 
16709
  echo "$as_me: failed program was:" >&5
 
16710
cat conftest.$ac_ext >&5
 
16711
cat >conftest.$ac_ext <<_ACEOF
 
16712
#line $LINENO "configure"
 
16713
#include "confdefs.h"
 
16714
$ac_includes_default
 
16715
struct { char filler; long long int field; } pgac_struct;
 
16716
#ifdef F77_DUMMY_MAIN
 
16717
#  ifdef __cplusplus
 
16718
     extern "C"
 
16719
#  endif
 
16720
   int F77_DUMMY_MAIN() { return 1; }
 
16721
#endif
 
16722
int
 
16723
main ()
 
16724
{
 
16725
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) < 0)];
 
16726
test_array [0] = 0
 
16727
 
 
16728
  ;
 
16729
  return 0;
 
16730
}
 
16731
_ACEOF
 
16732
rm -f conftest.$ac_objext
 
16733
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
16734
  (eval $ac_compile) 2>&5
 
16735
  ac_status=$?
 
16736
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16737
  (exit $ac_status); } &&
 
16738
         { ac_try='test -s conftest.$ac_objext'
 
16739
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
16740
  (eval $ac_try) 2>&5
 
16741
  ac_status=$?
 
16742
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16743
  (exit $ac_status); }; }; then
 
16744
  ac_hi=-1 ac_mid=-1
 
16745
  while :; do
 
16746
    cat >conftest.$ac_ext <<_ACEOF
 
16747
#line $LINENO "configure"
 
16748
#include "confdefs.h"
 
16749
$ac_includes_default
 
16750
struct { char filler; long long int field; } pgac_struct;
 
16751
#ifdef F77_DUMMY_MAIN
 
16752
#  ifdef __cplusplus
 
16753
     extern "C"
 
16754
#  endif
 
16755
   int F77_DUMMY_MAIN() { return 1; }
 
16756
#endif
 
16757
int
 
16758
main ()
 
16759
{
 
16760
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) >= $ac_mid)];
 
16761
test_array [0] = 0
 
16762
 
 
16763
  ;
 
16764
  return 0;
 
16765
}
 
16766
_ACEOF
 
16767
rm -f conftest.$ac_objext
 
16768
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
16769
  (eval $ac_compile) 2>&5
 
16770
  ac_status=$?
 
16771
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16772
  (exit $ac_status); } &&
 
16773
         { ac_try='test -s conftest.$ac_objext'
 
16774
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
16775
  (eval $ac_try) 2>&5
 
16776
  ac_status=$?
 
16777
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16778
  (exit $ac_status); }; }; then
 
16779
  ac_lo=$ac_mid; break
 
16780
else
 
16781
  echo "$as_me: failed program was:" >&5
 
16782
cat conftest.$ac_ext >&5
 
16783
ac_hi=`expr '(' $ac_mid ')' - 1`
 
16784
                       if test $ac_mid -le $ac_hi; then
 
16785
                         ac_lo= ac_hi=
 
16786
                         break
 
16787
                       fi
 
16788
                       ac_mid=`expr 2 '*' $ac_mid`
 
16789
fi
 
16790
rm -f conftest.$ac_objext conftest.$ac_ext
 
16791
  done
 
16792
else
 
16793
  echo "$as_me: failed program was:" >&5
 
16794
cat conftest.$ac_ext >&5
 
16795
ac_lo= ac_hi=
 
16796
fi
 
16797
rm -f conftest.$ac_objext conftest.$ac_ext
 
16798
fi
 
16799
rm -f conftest.$ac_objext conftest.$ac_ext
 
16800
# Binary search between lo and hi bounds.
 
16801
while test "x$ac_lo" != "x$ac_hi"; do
 
16802
  ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
 
16803
  cat >conftest.$ac_ext <<_ACEOF
 
16804
#line $LINENO "configure"
 
16805
#include "confdefs.h"
 
16806
$ac_includes_default
 
16807
struct { char filler; long long int field; } pgac_struct;
 
16808
#ifdef F77_DUMMY_MAIN
 
16809
#  ifdef __cplusplus
 
16810
     extern "C"
 
16811
#  endif
 
16812
   int F77_DUMMY_MAIN() { return 1; }
 
16813
#endif
 
16814
int
 
16815
main ()
 
16816
{
 
16817
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) <= $ac_mid)];
 
16818
test_array [0] = 0
 
16819
 
 
16820
  ;
 
16821
  return 0;
 
16822
}
 
16823
_ACEOF
 
16824
rm -f conftest.$ac_objext
 
16825
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
16826
  (eval $ac_compile) 2>&5
 
16827
  ac_status=$?
 
16828
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16829
  (exit $ac_status); } &&
 
16830
         { ac_try='test -s conftest.$ac_objext'
 
16831
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
16832
  (eval $ac_try) 2>&5
 
16833
  ac_status=$?
 
16834
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16835
  (exit $ac_status); }; }; then
 
16836
  ac_hi=$ac_mid
 
16837
else
 
16838
  echo "$as_me: failed program was:" >&5
 
16839
cat conftest.$ac_ext >&5
 
16840
ac_lo=`expr '(' $ac_mid ')' + 1`
 
16841
fi
 
16842
rm -f conftest.$ac_objext conftest.$ac_ext
 
16843
done
 
16844
case $ac_lo in
 
16845
?*) pgac_cv_alignof_long_long_int=$ac_lo;;
 
16846
'') { { echo "$as_me:$LINENO: error: cannot compute alignment of long long int, 77" >&5
 
16847
echo "$as_me: error: cannot compute alignment of long long int, 77" >&2;}
 
16848
   { (exit 1); exit 1; }; } ;;
 
16849
esac
 
16850
else
 
16851
  if test "$cross_compiling" = yes; then
 
16852
  { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling" >&5
 
16853
echo "$as_me: error: cannot run test program while cross compiling" >&2;}
 
16854
   { (exit 1); exit 1; }; }
 
16855
else
 
16856
  cat >conftest.$ac_ext <<_ACEOF
 
16857
#line $LINENO "configure"
 
16858
#include "confdefs.h"
 
16859
$ac_includes_default
 
16860
struct { char filler; long long int field; } pgac_struct;
 
16861
long longval () { return ((char*) & pgac_struct.field) - ((char*) & pgac_struct); }
 
16862
unsigned long ulongval () { return ((char*) & pgac_struct.field) - ((char*) & pgac_struct); }
 
16863
#include <stdio.h>
 
16864
#include <stdlib.h>
 
16865
#ifdef F77_DUMMY_MAIN
 
16866
#  ifdef __cplusplus
 
16867
     extern "C"
 
16868
#  endif
 
16869
   int F77_DUMMY_MAIN() { return 1; }
 
16870
#endif
 
16871
int
 
16872
main ()
 
16873
{
 
16874
 
 
16875
  FILE *f = fopen ("conftest.val", "w");
 
16876
  if (! f)
 
16877
    exit (1);
 
16878
  if ((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) < 0)
 
16879
    {
 
16880
      long i = longval ();
 
16881
      if (i != (((char*) & pgac_struct.field) - ((char*) & pgac_struct)))
 
16882
        exit (1);
 
16883
      fprintf (f, "%ld\n", i);
 
16884
    }
 
16885
  else
 
16886
    {
 
16887
      unsigned long i = ulongval ();
 
16888
      if (i != (((char*) & pgac_struct.field) - ((char*) & pgac_struct)))
 
16889
        exit (1);
 
16890
      fprintf (f, "%lu\n", i);
 
16891
    }
 
16892
  exit (ferror (f) || fclose (f) != 0);
 
16893
 
 
16894
  ;
 
16895
  return 0;
 
16896
}
 
16897
_ACEOF
 
16898
rm -f conftest$ac_exeext
 
16899
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
16900
  (eval $ac_link) 2>&5
 
16901
  ac_status=$?
 
16902
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16903
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
16904
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
16905
  (eval $ac_try) 2>&5
 
16906
  ac_status=$?
 
16907
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16908
  (exit $ac_status); }; }; then
 
16909
  pgac_cv_alignof_long_long_int=`cat conftest.val`
 
16910
else
 
16911
  echo "$as_me: program exited with status $ac_status" >&5
 
16912
echo "$as_me: failed program was:" >&5
 
16913
cat conftest.$ac_ext >&5
 
16914
( exit $ac_status )
 
16915
{ { echo "$as_me:$LINENO: error: cannot compute alignment of long long int, 77" >&5
 
16916
echo "$as_me: error: cannot compute alignment of long long int, 77" >&2;}
 
16917
   { (exit 1); exit 1; }; }
 
16918
fi
 
16919
rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 
16920
fi
 
16921
fi
 
16922
rm -f conftest.val
 
16923
else
 
16924
  pgac_cv_alignof_long_long_int=0
 
16925
fi
 
16926
fi
 
16927
echo "$as_me:$LINENO: result: $pgac_cv_alignof_long_long_int" >&5
 
16928
echo "${ECHO_T}$pgac_cv_alignof_long_long_int" >&6
 
16929
cat >>confdefs.h <<_ACEOF
 
16930
#define ALIGNOF_LONG_LONG_INT $pgac_cv_alignof_long_long_int
 
16931
_ACEOF
 
16932
 
 
16933
 
 
16934
fi
 
16935
echo "$as_me:$LINENO: checking for double" >&5
 
16936
echo $ECHO_N "checking for double... $ECHO_C" >&6
 
16937
if test "${ac_cv_type_double+set}" = set; then
 
16938
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
16939
else
 
16940
  cat >conftest.$ac_ext <<_ACEOF
 
16941
#line $LINENO "configure"
 
16942
#include "confdefs.h"
 
16943
$ac_includes_default
 
16944
#ifdef F77_DUMMY_MAIN
 
16945
#  ifdef __cplusplus
 
16946
     extern "C"
 
16947
#  endif
 
16948
   int F77_DUMMY_MAIN() { return 1; }
 
16949
#endif
 
16950
int
 
16951
main ()
 
16952
{
 
16953
if ((double *) 0)
 
16954
  return 0;
 
16955
if (sizeof (double))
 
16956
  return 0;
 
16957
  ;
 
16958
  return 0;
 
16959
}
 
16960
_ACEOF
 
16961
rm -f conftest.$ac_objext
 
16962
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
16963
  (eval $ac_compile) 2>&5
 
16964
  ac_status=$?
 
16965
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16966
  (exit $ac_status); } &&
 
16967
         { ac_try='test -s conftest.$ac_objext'
 
16968
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
16969
  (eval $ac_try) 2>&5
 
16970
  ac_status=$?
 
16971
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
16972
  (exit $ac_status); }; }; then
 
16973
  ac_cv_type_double=yes
 
16974
else
 
16975
  echo "$as_me: failed program was:" >&5
 
16976
cat conftest.$ac_ext >&5
 
16977
ac_cv_type_double=no
 
16978
fi
 
16979
rm -f conftest.$ac_objext conftest.$ac_ext
 
16980
fi
 
16981
echo "$as_me:$LINENO: result: $ac_cv_type_double" >&5
 
16982
echo "${ECHO_T}$ac_cv_type_double" >&6
 
16983
 
 
16984
echo "$as_me:$LINENO: checking alignment of double" >&5
 
16985
echo $ECHO_N "checking alignment of double... $ECHO_C" >&6
 
16986
if test "${pgac_cv_alignof_double+set}" = set; then
 
16987
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
16988
else
 
16989
  if test "$ac_cv_type_double" = yes; then
 
16990
  if test "$cross_compiling" = yes; then
 
16991
  # Depending upon the size, compute the lo and hi bounds.
 
16992
cat >conftest.$ac_ext <<_ACEOF
 
16993
#line $LINENO "configure"
 
16994
#include "confdefs.h"
 
16995
$ac_includes_default
 
16996
struct { char filler; double field; } pgac_struct;
 
16997
#ifdef F77_DUMMY_MAIN
 
16998
#  ifdef __cplusplus
 
16999
     extern "C"
 
17000
#  endif
 
17001
   int F77_DUMMY_MAIN() { return 1; }
 
17002
#endif
 
17003
int
 
17004
main ()
 
17005
{
 
17006
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) >= 0)];
 
17007
test_array [0] = 0
 
17008
 
 
17009
  ;
 
17010
  return 0;
 
17011
}
 
17012
_ACEOF
 
17013
rm -f conftest.$ac_objext
 
17014
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
17015
  (eval $ac_compile) 2>&5
 
17016
  ac_status=$?
 
17017
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17018
  (exit $ac_status); } &&
 
17019
         { ac_try='test -s conftest.$ac_objext'
 
17020
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
17021
  (eval $ac_try) 2>&5
 
17022
  ac_status=$?
 
17023
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17024
  (exit $ac_status); }; }; then
 
17025
  ac_lo=0 ac_mid=0
 
17026
  while :; do
 
17027
    cat >conftest.$ac_ext <<_ACEOF
 
17028
#line $LINENO "configure"
 
17029
#include "confdefs.h"
 
17030
$ac_includes_default
 
17031
struct { char filler; double field; } pgac_struct;
 
17032
#ifdef F77_DUMMY_MAIN
 
17033
#  ifdef __cplusplus
 
17034
     extern "C"
 
17035
#  endif
 
17036
   int F77_DUMMY_MAIN() { return 1; }
 
17037
#endif
 
17038
int
 
17039
main ()
 
17040
{
 
17041
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) <= $ac_mid)];
 
17042
test_array [0] = 0
 
17043
 
 
17044
  ;
 
17045
  return 0;
 
17046
}
 
17047
_ACEOF
 
17048
rm -f conftest.$ac_objext
 
17049
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
17050
  (eval $ac_compile) 2>&5
 
17051
  ac_status=$?
 
17052
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17053
  (exit $ac_status); } &&
 
17054
         { ac_try='test -s conftest.$ac_objext'
 
17055
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
17056
  (eval $ac_try) 2>&5
 
17057
  ac_status=$?
 
17058
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17059
  (exit $ac_status); }; }; then
 
17060
  ac_hi=$ac_mid; break
 
17061
else
 
17062
  echo "$as_me: failed program was:" >&5
 
17063
cat conftest.$ac_ext >&5
 
17064
ac_lo=`expr $ac_mid + 1`
 
17065
                    if test $ac_lo -le $ac_mid; then
 
17066
                      ac_lo= ac_hi=
 
17067
                      break
 
17068
                    fi
 
17069
                    ac_mid=`expr 2 '*' $ac_mid + 1`
 
17070
fi
 
17071
rm -f conftest.$ac_objext conftest.$ac_ext
 
17072
  done
 
17073
else
 
17074
  echo "$as_me: failed program was:" >&5
 
17075
cat conftest.$ac_ext >&5
 
17076
cat >conftest.$ac_ext <<_ACEOF
 
17077
#line $LINENO "configure"
 
17078
#include "confdefs.h"
 
17079
$ac_includes_default
 
17080
struct { char filler; double field; } pgac_struct;
 
17081
#ifdef F77_DUMMY_MAIN
 
17082
#  ifdef __cplusplus
 
17083
     extern "C"
 
17084
#  endif
 
17085
   int F77_DUMMY_MAIN() { return 1; }
 
17086
#endif
 
17087
int
 
17088
main ()
 
17089
{
 
17090
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) < 0)];
 
17091
test_array [0] = 0
 
17092
 
 
17093
  ;
 
17094
  return 0;
 
17095
}
 
17096
_ACEOF
 
17097
rm -f conftest.$ac_objext
 
17098
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
17099
  (eval $ac_compile) 2>&5
 
17100
  ac_status=$?
 
17101
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17102
  (exit $ac_status); } &&
 
17103
         { ac_try='test -s conftest.$ac_objext'
 
17104
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
17105
  (eval $ac_try) 2>&5
 
17106
  ac_status=$?
 
17107
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17108
  (exit $ac_status); }; }; then
 
17109
  ac_hi=-1 ac_mid=-1
 
17110
  while :; do
 
17111
    cat >conftest.$ac_ext <<_ACEOF
 
17112
#line $LINENO "configure"
 
17113
#include "confdefs.h"
 
17114
$ac_includes_default
 
17115
struct { char filler; double field; } pgac_struct;
 
17116
#ifdef F77_DUMMY_MAIN
 
17117
#  ifdef __cplusplus
 
17118
     extern "C"
 
17119
#  endif
 
17120
   int F77_DUMMY_MAIN() { return 1; }
 
17121
#endif
 
17122
int
 
17123
main ()
 
17124
{
 
17125
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) >= $ac_mid)];
 
17126
test_array [0] = 0
 
17127
 
 
17128
  ;
 
17129
  return 0;
 
17130
}
 
17131
_ACEOF
 
17132
rm -f conftest.$ac_objext
 
17133
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
17134
  (eval $ac_compile) 2>&5
 
17135
  ac_status=$?
 
17136
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17137
  (exit $ac_status); } &&
 
17138
         { ac_try='test -s conftest.$ac_objext'
 
17139
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
17140
  (eval $ac_try) 2>&5
 
17141
  ac_status=$?
 
17142
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17143
  (exit $ac_status); }; }; then
 
17144
  ac_lo=$ac_mid; break
 
17145
else
 
17146
  echo "$as_me: failed program was:" >&5
 
17147
cat conftest.$ac_ext >&5
 
17148
ac_hi=`expr '(' $ac_mid ')' - 1`
 
17149
                       if test $ac_mid -le $ac_hi; then
 
17150
                         ac_lo= ac_hi=
 
17151
                         break
 
17152
                       fi
 
17153
                       ac_mid=`expr 2 '*' $ac_mid`
 
17154
fi
 
17155
rm -f conftest.$ac_objext conftest.$ac_ext
 
17156
  done
 
17157
else
 
17158
  echo "$as_me: failed program was:" >&5
 
17159
cat conftest.$ac_ext >&5
 
17160
ac_lo= ac_hi=
 
17161
fi
 
17162
rm -f conftest.$ac_objext conftest.$ac_ext
 
17163
fi
 
17164
rm -f conftest.$ac_objext conftest.$ac_ext
 
17165
# Binary search between lo and hi bounds.
 
17166
while test "x$ac_lo" != "x$ac_hi"; do
 
17167
  ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
 
17168
  cat >conftest.$ac_ext <<_ACEOF
 
17169
#line $LINENO "configure"
 
17170
#include "confdefs.h"
 
17171
$ac_includes_default
 
17172
struct { char filler; double field; } pgac_struct;
 
17173
#ifdef F77_DUMMY_MAIN
 
17174
#  ifdef __cplusplus
 
17175
     extern "C"
 
17176
#  endif
 
17177
   int F77_DUMMY_MAIN() { return 1; }
 
17178
#endif
 
17179
int
 
17180
main ()
 
17181
{
 
17182
static int test_array [1 - 2 * !((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) <= $ac_mid)];
 
17183
test_array [0] = 0
 
17184
 
 
17185
  ;
 
17186
  return 0;
 
17187
}
 
17188
_ACEOF
 
17189
rm -f conftest.$ac_objext
 
17190
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
17191
  (eval $ac_compile) 2>&5
 
17192
  ac_status=$?
 
17193
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17194
  (exit $ac_status); } &&
 
17195
         { ac_try='test -s conftest.$ac_objext'
 
17196
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
17197
  (eval $ac_try) 2>&5
 
17198
  ac_status=$?
 
17199
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17200
  (exit $ac_status); }; }; then
 
17201
  ac_hi=$ac_mid
 
17202
else
 
17203
  echo "$as_me: failed program was:" >&5
 
17204
cat conftest.$ac_ext >&5
 
17205
ac_lo=`expr '(' $ac_mid ')' + 1`
 
17206
fi
 
17207
rm -f conftest.$ac_objext conftest.$ac_ext
 
17208
done
 
17209
case $ac_lo in
 
17210
?*) pgac_cv_alignof_double=$ac_lo;;
 
17211
'') { { echo "$as_me:$LINENO: error: cannot compute alignment of double, 77" >&5
 
17212
echo "$as_me: error: cannot compute alignment of double, 77" >&2;}
 
17213
   { (exit 1); exit 1; }; } ;;
 
17214
esac
 
17215
else
 
17216
  if test "$cross_compiling" = yes; then
 
17217
  { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling" >&5
 
17218
echo "$as_me: error: cannot run test program while cross compiling" >&2;}
 
17219
   { (exit 1); exit 1; }; }
 
17220
else
 
17221
  cat >conftest.$ac_ext <<_ACEOF
 
17222
#line $LINENO "configure"
 
17223
#include "confdefs.h"
 
17224
$ac_includes_default
 
17225
struct { char filler; double field; } pgac_struct;
 
17226
long longval () { return ((char*) & pgac_struct.field) - ((char*) & pgac_struct); }
 
17227
unsigned long ulongval () { return ((char*) & pgac_struct.field) - ((char*) & pgac_struct); }
 
17228
#include <stdio.h>
 
17229
#include <stdlib.h>
 
17230
#ifdef F77_DUMMY_MAIN
 
17231
#  ifdef __cplusplus
 
17232
     extern "C"
 
17233
#  endif
 
17234
   int F77_DUMMY_MAIN() { return 1; }
 
17235
#endif
 
17236
int
 
17237
main ()
 
17238
{
 
17239
 
 
17240
  FILE *f = fopen ("conftest.val", "w");
 
17241
  if (! f)
 
17242
    exit (1);
 
17243
  if ((((char*) & pgac_struct.field) - ((char*) & pgac_struct)) < 0)
 
17244
    {
 
17245
      long i = longval ();
 
17246
      if (i != (((char*) & pgac_struct.field) - ((char*) & pgac_struct)))
 
17247
        exit (1);
 
17248
      fprintf (f, "%ld\n", i);
 
17249
    }
 
17250
  else
 
17251
    {
 
17252
      unsigned long i = ulongval ();
 
17253
      if (i != (((char*) & pgac_struct.field) - ((char*) & pgac_struct)))
 
17254
        exit (1);
 
17255
      fprintf (f, "%lu\n", i);
 
17256
    }
 
17257
  exit (ferror (f) || fclose (f) != 0);
 
17258
 
 
17259
  ;
 
17260
  return 0;
 
17261
}
 
17262
_ACEOF
 
17263
rm -f conftest$ac_exeext
 
17264
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
17265
  (eval $ac_link) 2>&5
 
17266
  ac_status=$?
 
17267
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17268
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
17269
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
17270
  (eval $ac_try) 2>&5
 
17271
  ac_status=$?
 
17272
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17273
  (exit $ac_status); }; }; then
 
17274
  pgac_cv_alignof_double=`cat conftest.val`
 
17275
else
 
17276
  echo "$as_me: program exited with status $ac_status" >&5
 
17277
echo "$as_me: failed program was:" >&5
 
17278
cat conftest.$ac_ext >&5
 
17279
( exit $ac_status )
 
17280
{ { echo "$as_me:$LINENO: error: cannot compute alignment of double, 77" >&5
 
17281
echo "$as_me: error: cannot compute alignment of double, 77" >&2;}
 
17282
   { (exit 1); exit 1; }; }
 
17283
fi
 
17284
rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 
17285
fi
 
17286
fi
 
17287
rm -f conftest.val
 
17288
else
 
17289
  pgac_cv_alignof_double=0
 
17290
fi
 
17291
fi
 
17292
echo "$as_me:$LINENO: result: $pgac_cv_alignof_double" >&5
 
17293
echo "${ECHO_T}$pgac_cv_alignof_double" >&6
 
17294
cat >>confdefs.h <<_ACEOF
 
17295
#define ALIGNOF_DOUBLE $pgac_cv_alignof_double
 
17296
_ACEOF
 
17297
 
 
17298
 
 
17299
 
 
17300
# Compute maximum alignment of any basic type.
 
17301
# We assume long's alignment is at least as strong as char, short, or int;
 
17302
# but we must check long long (if it exists) and double.
 
17303
 
 
17304
MAX_ALIGNOF=$pgac_cv_alignof_long
 
17305
if test $MAX_ALIGNOF -lt $pgac_cv_alignof_double ; then
 
17306
  MAX_ALIGNOF=$pgac_cv_alignof_double
 
17307
fi
 
17308
if test x"$HAVE_LONG_LONG_INT_64" = xyes && test $MAX_ALIGNOF -lt $pgac_cv_alignof_long_long_int ; then
 
17309
  MAX_ALIGNOF="$pgac_cv_alignof_long_long_int"
 
17310
fi
 
17311
 
 
17312
cat >>confdefs.h <<_ACEOF
 
17313
#define MAXIMUM_ALIGNOF $MAX_ALIGNOF
 
17314
_ACEOF
 
17315
 
 
17316
 
 
17317
 
 
17318
# Some platforms predefine the types int8, int16, etc.  Only check
 
17319
# a (hopefully) representative subset.
 
17320
echo "$as_me:$LINENO: checking for int8" >&5
 
17321
echo $ECHO_N "checking for int8... $ECHO_C" >&6
 
17322
if test "${ac_cv_type_int8+set}" = set; then
 
17323
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
17324
else
 
17325
  cat >conftest.$ac_ext <<_ACEOF
 
17326
#line $LINENO "configure"
 
17327
#include "confdefs.h"
 
17328
#include <stdio.h>
 
17329
#ifdef HAVE_SUPPORTDEFS_H
 
17330
#include <SupportDefs.h>
 
17331
#endif
 
17332
 
 
17333
#ifdef F77_DUMMY_MAIN
 
17334
#  ifdef __cplusplus
 
17335
     extern "C"
 
17336
#  endif
 
17337
   int F77_DUMMY_MAIN() { return 1; }
 
17338
#endif
 
17339
int
 
17340
main ()
 
17341
{
 
17342
if ((int8 *) 0)
 
17343
  return 0;
 
17344
if (sizeof (int8))
 
17345
  return 0;
 
17346
  ;
 
17347
  return 0;
 
17348
}
 
17349
_ACEOF
 
17350
rm -f conftest.$ac_objext
 
17351
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
17352
  (eval $ac_compile) 2>&5
 
17353
  ac_status=$?
 
17354
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17355
  (exit $ac_status); } &&
 
17356
         { ac_try='test -s conftest.$ac_objext'
 
17357
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
17358
  (eval $ac_try) 2>&5
 
17359
  ac_status=$?
 
17360
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17361
  (exit $ac_status); }; }; then
 
17362
  ac_cv_type_int8=yes
 
17363
else
 
17364
  echo "$as_me: failed program was:" >&5
 
17365
cat conftest.$ac_ext >&5
 
17366
ac_cv_type_int8=no
 
17367
fi
 
17368
rm -f conftest.$ac_objext conftest.$ac_ext
 
17369
fi
 
17370
echo "$as_me:$LINENO: result: $ac_cv_type_int8" >&5
 
17371
echo "${ECHO_T}$ac_cv_type_int8" >&6
 
17372
if test $ac_cv_type_int8 = yes; then
 
17373
 
 
17374
cat >>confdefs.h <<_ACEOF
 
17375
#define HAVE_INT8 1
 
17376
_ACEOF
 
17377
 
 
17378
 
 
17379
fi
 
17380
echo "$as_me:$LINENO: checking for uint8" >&5
 
17381
echo $ECHO_N "checking for uint8... $ECHO_C" >&6
 
17382
if test "${ac_cv_type_uint8+set}" = set; then
 
17383
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
17384
else
 
17385
  cat >conftest.$ac_ext <<_ACEOF
 
17386
#line $LINENO "configure"
 
17387
#include "confdefs.h"
 
17388
#include <stdio.h>
 
17389
#ifdef HAVE_SUPPORTDEFS_H
 
17390
#include <SupportDefs.h>
 
17391
#endif
 
17392
 
 
17393
#ifdef F77_DUMMY_MAIN
 
17394
#  ifdef __cplusplus
 
17395
     extern "C"
 
17396
#  endif
 
17397
   int F77_DUMMY_MAIN() { return 1; }
 
17398
#endif
 
17399
int
 
17400
main ()
 
17401
{
 
17402
if ((uint8 *) 0)
 
17403
  return 0;
 
17404
if (sizeof (uint8))
 
17405
  return 0;
 
17406
  ;
 
17407
  return 0;
 
17408
}
 
17409
_ACEOF
 
17410
rm -f conftest.$ac_objext
 
17411
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
17412
  (eval $ac_compile) 2>&5
 
17413
  ac_status=$?
 
17414
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17415
  (exit $ac_status); } &&
 
17416
         { ac_try='test -s conftest.$ac_objext'
 
17417
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
17418
  (eval $ac_try) 2>&5
 
17419
  ac_status=$?
 
17420
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17421
  (exit $ac_status); }; }; then
 
17422
  ac_cv_type_uint8=yes
 
17423
else
 
17424
  echo "$as_me: failed program was:" >&5
 
17425
cat conftest.$ac_ext >&5
 
17426
ac_cv_type_uint8=no
 
17427
fi
 
17428
rm -f conftest.$ac_objext conftest.$ac_ext
 
17429
fi
 
17430
echo "$as_me:$LINENO: result: $ac_cv_type_uint8" >&5
 
17431
echo "${ECHO_T}$ac_cv_type_uint8" >&6
 
17432
if test $ac_cv_type_uint8 = yes; then
 
17433
 
 
17434
cat >>confdefs.h <<_ACEOF
 
17435
#define HAVE_UINT8 1
 
17436
_ACEOF
 
17437
 
 
17438
 
 
17439
fi
 
17440
echo "$as_me:$LINENO: checking for int64" >&5
 
17441
echo $ECHO_N "checking for int64... $ECHO_C" >&6
 
17442
if test "${ac_cv_type_int64+set}" = set; then
 
17443
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
17444
else
 
17445
  cat >conftest.$ac_ext <<_ACEOF
 
17446
#line $LINENO "configure"
 
17447
#include "confdefs.h"
 
17448
#include <stdio.h>
 
17449
#ifdef HAVE_SUPPORTDEFS_H
 
17450
#include <SupportDefs.h>
 
17451
#endif
 
17452
 
 
17453
#ifdef F77_DUMMY_MAIN
 
17454
#  ifdef __cplusplus
 
17455
     extern "C"
 
17456
#  endif
 
17457
   int F77_DUMMY_MAIN() { return 1; }
 
17458
#endif
 
17459
int
 
17460
main ()
 
17461
{
 
17462
if ((int64 *) 0)
 
17463
  return 0;
 
17464
if (sizeof (int64))
 
17465
  return 0;
 
17466
  ;
 
17467
  return 0;
 
17468
}
 
17469
_ACEOF
 
17470
rm -f conftest.$ac_objext
 
17471
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
17472
  (eval $ac_compile) 2>&5
 
17473
  ac_status=$?
 
17474
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17475
  (exit $ac_status); } &&
 
17476
         { ac_try='test -s conftest.$ac_objext'
 
17477
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
17478
  (eval $ac_try) 2>&5
 
17479
  ac_status=$?
 
17480
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17481
  (exit $ac_status); }; }; then
 
17482
  ac_cv_type_int64=yes
 
17483
else
 
17484
  echo "$as_me: failed program was:" >&5
 
17485
cat conftest.$ac_ext >&5
 
17486
ac_cv_type_int64=no
 
17487
fi
 
17488
rm -f conftest.$ac_objext conftest.$ac_ext
 
17489
fi
 
17490
echo "$as_me:$LINENO: result: $ac_cv_type_int64" >&5
 
17491
echo "${ECHO_T}$ac_cv_type_int64" >&6
 
17492
if test $ac_cv_type_int64 = yes; then
 
17493
 
 
17494
cat >>confdefs.h <<_ACEOF
 
17495
#define HAVE_INT64 1
 
17496
_ACEOF
 
17497
 
 
17498
 
 
17499
fi
 
17500
echo "$as_me:$LINENO: checking for uint64" >&5
 
17501
echo $ECHO_N "checking for uint64... $ECHO_C" >&6
 
17502
if test "${ac_cv_type_uint64+set}" = set; then
 
17503
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
17504
else
 
17505
  cat >conftest.$ac_ext <<_ACEOF
 
17506
#line $LINENO "configure"
 
17507
#include "confdefs.h"
 
17508
#include <stdio.h>
 
17509
#ifdef HAVE_SUPPORTDEFS_H
 
17510
#include <SupportDefs.h>
 
17511
#endif
 
17512
 
 
17513
#ifdef F77_DUMMY_MAIN
 
17514
#  ifdef __cplusplus
 
17515
     extern "C"
 
17516
#  endif
 
17517
   int F77_DUMMY_MAIN() { return 1; }
 
17518
#endif
 
17519
int
 
17520
main ()
 
17521
{
 
17522
if ((uint64 *) 0)
 
17523
  return 0;
 
17524
if (sizeof (uint64))
 
17525
  return 0;
 
17526
  ;
 
17527
  return 0;
 
17528
}
 
17529
_ACEOF
 
17530
rm -f conftest.$ac_objext
 
17531
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
17532
  (eval $ac_compile) 2>&5
 
17533
  ac_status=$?
 
17534
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17535
  (exit $ac_status); } &&
 
17536
         { ac_try='test -s conftest.$ac_objext'
 
17537
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
17538
  (eval $ac_try) 2>&5
 
17539
  ac_status=$?
 
17540
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17541
  (exit $ac_status); }; }; then
 
17542
  ac_cv_type_uint64=yes
 
17543
else
 
17544
  echo "$as_me: failed program was:" >&5
 
17545
cat conftest.$ac_ext >&5
 
17546
ac_cv_type_uint64=no
 
17547
fi
 
17548
rm -f conftest.$ac_objext conftest.$ac_ext
 
17549
fi
 
17550
echo "$as_me:$LINENO: result: $ac_cv_type_uint64" >&5
 
17551
echo "${ECHO_T}$ac_cv_type_uint64" >&6
 
17552
if test $ac_cv_type_uint64 = yes; then
 
17553
 
 
17554
cat >>confdefs.h <<_ACEOF
 
17555
#define HAVE_UINT64 1
 
17556
_ACEOF
 
17557
 
 
17558
 
 
17559
fi
 
17560
 
 
17561
 
 
17562
# We also check for sig_atomic_t, which *should* be defined per ANSI
 
17563
# C, but is missing on some old platforms.
 
17564
echo "$as_me:$LINENO: checking for sig_atomic_t" >&5
 
17565
echo $ECHO_N "checking for sig_atomic_t... $ECHO_C" >&6
 
17566
if test "${ac_cv_type_sig_atomic_t+set}" = set; then
 
17567
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
17568
else
 
17569
  cat >conftest.$ac_ext <<_ACEOF
 
17570
#line $LINENO "configure"
 
17571
#include "confdefs.h"
 
17572
#include <signal.h>
 
17573
 
 
17574
#ifdef F77_DUMMY_MAIN
 
17575
#  ifdef __cplusplus
 
17576
     extern "C"
 
17577
#  endif
 
17578
   int F77_DUMMY_MAIN() { return 1; }
 
17579
#endif
 
17580
int
 
17581
main ()
 
17582
{
 
17583
if ((sig_atomic_t *) 0)
 
17584
  return 0;
 
17585
if (sizeof (sig_atomic_t))
 
17586
  return 0;
 
17587
  ;
 
17588
  return 0;
 
17589
}
 
17590
_ACEOF
 
17591
rm -f conftest.$ac_objext
 
17592
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
17593
  (eval $ac_compile) 2>&5
 
17594
  ac_status=$?
 
17595
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17596
  (exit $ac_status); } &&
 
17597
         { ac_try='test -s conftest.$ac_objext'
 
17598
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
17599
  (eval $ac_try) 2>&5
 
17600
  ac_status=$?
 
17601
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17602
  (exit $ac_status); }; }; then
 
17603
  ac_cv_type_sig_atomic_t=yes
 
17604
else
 
17605
  echo "$as_me: failed program was:" >&5
 
17606
cat conftest.$ac_ext >&5
 
17607
ac_cv_type_sig_atomic_t=no
 
17608
fi
 
17609
rm -f conftest.$ac_objext conftest.$ac_ext
 
17610
fi
 
17611
echo "$as_me:$LINENO: result: $ac_cv_type_sig_atomic_t" >&5
 
17612
echo "${ECHO_T}$ac_cv_type_sig_atomic_t" >&6
 
17613
if test $ac_cv_type_sig_atomic_t = yes; then
 
17614
 
 
17615
cat >>confdefs.h <<_ACEOF
 
17616
#define HAVE_SIG_ATOMIC_T 1
 
17617
_ACEOF
 
17618
 
 
17619
 
 
17620
fi
 
17621
 
 
17622
 
 
17623
 
 
17624
echo "$as_me:$LINENO: checking for POSIX signal interface" >&5
 
17625
echo $ECHO_N "checking for POSIX signal interface... $ECHO_C" >&6
 
17626
if test "${pgac_cv_func_posix_signals+set}" = set; then
 
17627
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
17628
else
 
17629
  cat >conftest.$ac_ext <<_ACEOF
 
17630
#line $LINENO "configure"
 
17631
#include "confdefs.h"
 
17632
#include <signal.h>
 
17633
 
 
17634
#ifdef F77_DUMMY_MAIN
 
17635
#  ifdef __cplusplus
 
17636
     extern "C"
 
17637
#  endif
 
17638
   int F77_DUMMY_MAIN() { return 1; }
 
17639
#endif
 
17640
int
 
17641
main ()
 
17642
{
 
17643
struct sigaction act, oact;
 
17644
sigemptyset(&act.sa_mask);
 
17645
act.sa_flags = SA_RESTART;
 
17646
sigaction(0, &act, &oact);
 
17647
  ;
 
17648
  return 0;
 
17649
}
 
17650
_ACEOF
 
17651
rm -f conftest.$ac_objext conftest$ac_exeext
 
17652
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
17653
  (eval $ac_link) 2>&5
 
17654
  ac_status=$?
 
17655
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17656
  (exit $ac_status); } &&
 
17657
         { ac_try='test -s conftest$ac_exeext'
 
17658
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
17659
  (eval $ac_try) 2>&5
 
17660
  ac_status=$?
 
17661
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17662
  (exit $ac_status); }; }; then
 
17663
  pgac_cv_func_posix_signals=yes
 
17664
else
 
17665
  echo "$as_me: failed program was:" >&5
 
17666
cat conftest.$ac_ext >&5
 
17667
pgac_cv_func_posix_signals=no
 
17668
fi
 
17669
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
17670
fi
 
17671
echo "$as_me:$LINENO: result: $pgac_cv_func_posix_signals" >&5
 
17672
echo "${ECHO_T}$pgac_cv_func_posix_signals" >&6
 
17673
if test x"$pgac_cv_func_posix_signals" = xyes ; then
 
17674
 
 
17675
cat >>confdefs.h <<\_ACEOF
 
17676
#define HAVE_POSIX_SIGNALS
 
17677
_ACEOF
 
17678
 
 
17679
fi
 
17680
HAVE_POSIX_SIGNALS=$pgac_cv_func_posix_signals
 
17681
 
 
17682
if test "$pgac_cv_func_posix_signals" != yes -a "$enable_thread_safety" = yes; then
 
17683
  { { echo "$as_me:$LINENO: error:
 
17684
*** Thread-safety requires POSIX signals, which are not supported by your
 
17685
*** operating system.
 
17686
" >&5
 
17687
echo "$as_me: error:
 
17688
*** Thread-safety requires POSIX signals, which are not supported by your
 
17689
*** operating system.
 
17690
" >&2;}
 
17691
   { (exit 1); exit 1; }; }
 
17692
fi
 
17693
 
 
17694
if test $ac_cv_func_fseeko = yes; then
 
17695
# Check whether --enable-largefile or --disable-largefile was given.
 
17696
if test "${enable_largefile+set}" = set; then
 
17697
  enableval="$enable_largefile"
 
17698
 
 
17699
fi;
 
17700
if test "$enable_largefile" != no; then
 
17701
 
 
17702
  echo "$as_me:$LINENO: checking for special C compiler options needed for large files" >&5
 
17703
echo $ECHO_N "checking for special C compiler options needed for large files... $ECHO_C" >&6
 
17704
if test "${ac_cv_sys_largefile_CC+set}" = set; then
 
17705
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
17706
else
 
17707
  ac_cv_sys_largefile_CC=no
 
17708
     if test "$GCC" != yes; then
 
17709
       ac_save_CC=$CC
 
17710
       while :; do
 
17711
         # IRIX 6.2 and later do not support large files by default,
 
17712
         # so use the C compiler's -n32 option if that helps.
 
17713
         cat >conftest.$ac_ext <<_ACEOF
 
17714
#line $LINENO "configure"
 
17715
#include "confdefs.h"
 
17716
#include <sys/types.h>
 
17717
 /* Check that off_t can represent 2**63 - 1 correctly.
 
17718
    We can't simply define LARGE_OFF_T to be 9223372036854775807,
 
17719
    since some C++ compilers masquerading as C compilers
 
17720
    incorrectly reject 9223372036854775807.  */
 
17721
#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
 
17722
  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
 
17723
                       && LARGE_OFF_T % 2147483647 == 1)
 
17724
                      ? 1 : -1];
 
17725
#ifdef F77_DUMMY_MAIN
 
17726
#  ifdef __cplusplus
 
17727
     extern "C"
 
17728
#  endif
 
17729
   int F77_DUMMY_MAIN() { return 1; }
 
17730
#endif
 
17731
int
 
17732
main ()
 
17733
{
 
17734
 
 
17735
  ;
 
17736
  return 0;
 
17737
}
 
17738
_ACEOF
 
17739
         rm -f conftest.$ac_objext
 
17740
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
17741
  (eval $ac_compile) 2>&5
 
17742
  ac_status=$?
 
17743
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17744
  (exit $ac_status); } &&
 
17745
         { ac_try='test -s conftest.$ac_objext'
 
17746
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
17747
  (eval $ac_try) 2>&5
 
17748
  ac_status=$?
 
17749
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17750
  (exit $ac_status); }; }; then
 
17751
  break
 
17752
else
 
17753
  echo "$as_me: failed program was:" >&5
 
17754
cat conftest.$ac_ext >&5
 
17755
fi
 
17756
rm -f conftest.$ac_objext
 
17757
         CC="$CC -n32"
 
17758
         rm -f conftest.$ac_objext
 
17759
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
17760
  (eval $ac_compile) 2>&5
 
17761
  ac_status=$?
 
17762
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17763
  (exit $ac_status); } &&
 
17764
         { ac_try='test -s conftest.$ac_objext'
 
17765
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
17766
  (eval $ac_try) 2>&5
 
17767
  ac_status=$?
 
17768
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17769
  (exit $ac_status); }; }; then
 
17770
  ac_cv_sys_largefile_CC=' -n32'; break
 
17771
else
 
17772
  echo "$as_me: failed program was:" >&5
 
17773
cat conftest.$ac_ext >&5
 
17774
fi
 
17775
rm -f conftest.$ac_objext
 
17776
         break
 
17777
       done
 
17778
       CC=$ac_save_CC
 
17779
       rm -f conftest.$ac_ext
 
17780
    fi
 
17781
fi
 
17782
echo "$as_me:$LINENO: result: $ac_cv_sys_largefile_CC" >&5
 
17783
echo "${ECHO_T}$ac_cv_sys_largefile_CC" >&6
 
17784
  if test "$ac_cv_sys_largefile_CC" != no; then
 
17785
    CC=$CC$ac_cv_sys_largefile_CC
 
17786
  fi
 
17787
 
 
17788
  echo "$as_me:$LINENO: checking for _FILE_OFFSET_BITS value needed for large files" >&5
 
17789
echo $ECHO_N "checking for _FILE_OFFSET_BITS value needed for large files... $ECHO_C" >&6
 
17790
if test "${ac_cv_sys_file_offset_bits+set}" = set; then
 
17791
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
17792
else
 
17793
  while :; do
 
17794
  ac_cv_sys_file_offset_bits=no
 
17795
  cat >conftest.$ac_ext <<_ACEOF
 
17796
#line $LINENO "configure"
 
17797
#include "confdefs.h"
 
17798
#include <sys/types.h>
 
17799
 /* Check that off_t can represent 2**63 - 1 correctly.
 
17800
    We can't simply define LARGE_OFF_T to be 9223372036854775807,
 
17801
    since some C++ compilers masquerading as C compilers
 
17802
    incorrectly reject 9223372036854775807.  */
 
17803
#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
 
17804
  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
 
17805
                       && LARGE_OFF_T % 2147483647 == 1)
 
17806
                      ? 1 : -1];
 
17807
#ifdef F77_DUMMY_MAIN
 
17808
#  ifdef __cplusplus
 
17809
     extern "C"
 
17810
#  endif
 
17811
   int F77_DUMMY_MAIN() { return 1; }
 
17812
#endif
 
17813
int
 
17814
main ()
 
17815
{
 
17816
 
 
17817
  ;
 
17818
  return 0;
 
17819
}
 
17820
_ACEOF
 
17821
rm -f conftest.$ac_objext
 
17822
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
17823
  (eval $ac_compile) 2>&5
 
17824
  ac_status=$?
 
17825
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17826
  (exit $ac_status); } &&
 
17827
         { ac_try='test -s conftest.$ac_objext'
 
17828
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
17829
  (eval $ac_try) 2>&5
 
17830
  ac_status=$?
 
17831
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17832
  (exit $ac_status); }; }; then
 
17833
  break
 
17834
else
 
17835
  echo "$as_me: failed program was:" >&5
 
17836
cat conftest.$ac_ext >&5
 
17837
fi
 
17838
rm -f conftest.$ac_objext conftest.$ac_ext
 
17839
  cat >conftest.$ac_ext <<_ACEOF
 
17840
#line $LINENO "configure"
 
17841
#include "confdefs.h"
 
17842
#define _FILE_OFFSET_BITS 64
 
17843
#include <sys/types.h>
 
17844
 /* Check that off_t can represent 2**63 - 1 correctly.
 
17845
    We can't simply define LARGE_OFF_T to be 9223372036854775807,
 
17846
    since some C++ compilers masquerading as C compilers
 
17847
    incorrectly reject 9223372036854775807.  */
 
17848
#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
 
17849
  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
 
17850
                       && LARGE_OFF_T % 2147483647 == 1)
 
17851
                      ? 1 : -1];
 
17852
#ifdef F77_DUMMY_MAIN
 
17853
#  ifdef __cplusplus
 
17854
     extern "C"
 
17855
#  endif
 
17856
   int F77_DUMMY_MAIN() { return 1; }
 
17857
#endif
 
17858
int
 
17859
main ()
 
17860
{
 
17861
 
 
17862
  ;
 
17863
  return 0;
 
17864
}
 
17865
_ACEOF
 
17866
rm -f conftest.$ac_objext
 
17867
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
17868
  (eval $ac_compile) 2>&5
 
17869
  ac_status=$?
 
17870
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17871
  (exit $ac_status); } &&
 
17872
         { ac_try='test -s conftest.$ac_objext'
 
17873
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
17874
  (eval $ac_try) 2>&5
 
17875
  ac_status=$?
 
17876
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17877
  (exit $ac_status); }; }; then
 
17878
  ac_cv_sys_file_offset_bits=64; break
 
17879
else
 
17880
  echo "$as_me: failed program was:" >&5
 
17881
cat conftest.$ac_ext >&5
 
17882
fi
 
17883
rm -f conftest.$ac_objext conftest.$ac_ext
 
17884
  break
 
17885
done
 
17886
fi
 
17887
echo "$as_me:$LINENO: result: $ac_cv_sys_file_offset_bits" >&5
 
17888
echo "${ECHO_T}$ac_cv_sys_file_offset_bits" >&6
 
17889
if test "$ac_cv_sys_file_offset_bits" != no; then
 
17890
 
 
17891
cat >>confdefs.h <<_ACEOF
 
17892
#define _FILE_OFFSET_BITS $ac_cv_sys_file_offset_bits
 
17893
_ACEOF
 
17894
 
 
17895
fi
 
17896
rm -f conftest*
 
17897
  echo "$as_me:$LINENO: checking for _LARGE_FILES value needed for large files" >&5
 
17898
echo $ECHO_N "checking for _LARGE_FILES value needed for large files... $ECHO_C" >&6
 
17899
if test "${ac_cv_sys_large_files+set}" = set; then
 
17900
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
17901
else
 
17902
  while :; do
 
17903
  ac_cv_sys_large_files=no
 
17904
  cat >conftest.$ac_ext <<_ACEOF
 
17905
#line $LINENO "configure"
 
17906
#include "confdefs.h"
 
17907
#include <sys/types.h>
 
17908
 /* Check that off_t can represent 2**63 - 1 correctly.
 
17909
    We can't simply define LARGE_OFF_T to be 9223372036854775807,
 
17910
    since some C++ compilers masquerading as C compilers
 
17911
    incorrectly reject 9223372036854775807.  */
 
17912
#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
 
17913
  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
 
17914
                       && LARGE_OFF_T % 2147483647 == 1)
 
17915
                      ? 1 : -1];
 
17916
#ifdef F77_DUMMY_MAIN
 
17917
#  ifdef __cplusplus
 
17918
     extern "C"
 
17919
#  endif
 
17920
   int F77_DUMMY_MAIN() { return 1; }
 
17921
#endif
 
17922
int
 
17923
main ()
 
17924
{
 
17925
 
 
17926
  ;
 
17927
  return 0;
 
17928
}
 
17929
_ACEOF
 
17930
rm -f conftest.$ac_objext
 
17931
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
17932
  (eval $ac_compile) 2>&5
 
17933
  ac_status=$?
 
17934
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17935
  (exit $ac_status); } &&
 
17936
         { ac_try='test -s conftest.$ac_objext'
 
17937
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
17938
  (eval $ac_try) 2>&5
 
17939
  ac_status=$?
 
17940
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17941
  (exit $ac_status); }; }; then
 
17942
  break
 
17943
else
 
17944
  echo "$as_me: failed program was:" >&5
 
17945
cat conftest.$ac_ext >&5
 
17946
fi
 
17947
rm -f conftest.$ac_objext conftest.$ac_ext
 
17948
  cat >conftest.$ac_ext <<_ACEOF
 
17949
#line $LINENO "configure"
 
17950
#include "confdefs.h"
 
17951
#define _LARGE_FILES 1
 
17952
#include <sys/types.h>
 
17953
 /* Check that off_t can represent 2**63 - 1 correctly.
 
17954
    We can't simply define LARGE_OFF_T to be 9223372036854775807,
 
17955
    since some C++ compilers masquerading as C compilers
 
17956
    incorrectly reject 9223372036854775807.  */
 
17957
#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
 
17958
  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
 
17959
                       && LARGE_OFF_T % 2147483647 == 1)
 
17960
                      ? 1 : -1];
 
17961
#ifdef F77_DUMMY_MAIN
 
17962
#  ifdef __cplusplus
 
17963
     extern "C"
 
17964
#  endif
 
17965
   int F77_DUMMY_MAIN() { return 1; }
 
17966
#endif
 
17967
int
 
17968
main ()
 
17969
{
 
17970
 
 
17971
  ;
 
17972
  return 0;
 
17973
}
 
17974
_ACEOF
 
17975
rm -f conftest.$ac_objext
 
17976
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
17977
  (eval $ac_compile) 2>&5
 
17978
  ac_status=$?
 
17979
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17980
  (exit $ac_status); } &&
 
17981
         { ac_try='test -s conftest.$ac_objext'
 
17982
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
17983
  (eval $ac_try) 2>&5
 
17984
  ac_status=$?
 
17985
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
17986
  (exit $ac_status); }; }; then
 
17987
  ac_cv_sys_large_files=1; break
 
17988
else
 
17989
  echo "$as_me: failed program was:" >&5
 
17990
cat conftest.$ac_ext >&5
 
17991
fi
 
17992
rm -f conftest.$ac_objext conftest.$ac_ext
 
17993
  break
 
17994
done
 
17995
fi
 
17996
echo "$as_me:$LINENO: result: $ac_cv_sys_large_files" >&5
 
17997
echo "${ECHO_T}$ac_cv_sys_large_files" >&6
 
17998
if test "$ac_cv_sys_large_files" != no; then
 
17999
 
 
18000
cat >>confdefs.h <<_ACEOF
 
18001
#define _LARGE_FILES $ac_cv_sys_large_files
 
18002
_ACEOF
 
18003
 
 
18004
fi
 
18005
rm -f conftest*
 
18006
fi
 
18007
 
 
18008
fi
 
18009
 
 
18010
 
 
18011
# Select semaphore implementation type.
 
18012
if test x"$USE_NAMED_POSIX_SEMAPHORES" = x"1" ; then
 
18013
 
 
18014
cat >>confdefs.h <<\_ACEOF
 
18015
#define USE_NAMED_POSIX_SEMAPHORES 1
 
18016
_ACEOF
 
18017
 
 
18018
  SEMA_IMPLEMENTATION="src/backend/port/posix_sema.c"
 
18019
else
 
18020
  if test x"$USE_UNNAMED_POSIX_SEMAPHORES" = x"1" ; then
 
18021
 
 
18022
cat >>confdefs.h <<\_ACEOF
 
18023
#define USE_UNNAMED_POSIX_SEMAPHORES 1
 
18024
_ACEOF
 
18025
 
 
18026
    SEMA_IMPLEMENTATION="src/backend/port/posix_sema.c"
 
18027
  else
 
18028
 
 
18029
cat >>confdefs.h <<\_ACEOF
 
18030
#define USE_SYSV_SEMAPHORES 1
 
18031
_ACEOF
 
18032
 
 
18033
    SEMA_IMPLEMENTATION="src/backend/port/sysv_sema.c"
 
18034
  fi
 
18035
fi
 
18036
 
 
18037
 
 
18038
# Select shared-memory implementation type.
 
18039
 
 
18040
cat >>confdefs.h <<\_ACEOF
 
18041
#define USE_SYSV_SHARED_MEMORY 1
 
18042
_ACEOF
 
18043
 
 
18044
SHMEM_IMPLEMENTATION="src/backend/port/sysv_shmem.c"
 
18045
 
 
18046
 
 
18047
if test "$enable_nls" = yes ; then
 
18048
 
 
18049
  echo "$as_me:$LINENO: checking for library containing gettext" >&5
 
18050
echo $ECHO_N "checking for library containing gettext... $ECHO_C" >&6
 
18051
if test "${ac_cv_search_gettext+set}" = set; then
 
18052
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
18053
else
 
18054
  ac_func_search_save_LIBS=$LIBS
 
18055
ac_cv_search_gettext=no
 
18056
cat >conftest.$ac_ext <<_ACEOF
 
18057
#line $LINENO "configure"
 
18058
#include "confdefs.h"
 
18059
 
 
18060
/* Override any gcc2 internal prototype to avoid an error.  */
 
18061
#ifdef __cplusplus
 
18062
extern "C"
 
18063
#endif
 
18064
/* We use char because int might match the return type of a gcc2
 
18065
   builtin and then its argument prototype would still apply.  */
 
18066
char gettext ();
 
18067
#ifdef F77_DUMMY_MAIN
 
18068
#  ifdef __cplusplus
 
18069
     extern "C"
 
18070
#  endif
 
18071
   int F77_DUMMY_MAIN() { return 1; }
 
18072
#endif
 
18073
int
 
18074
main ()
 
18075
{
 
18076
gettext ();
 
18077
  ;
 
18078
  return 0;
 
18079
}
 
18080
_ACEOF
 
18081
rm -f conftest.$ac_objext conftest$ac_exeext
 
18082
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
18083
  (eval $ac_link) 2>&5
 
18084
  ac_status=$?
 
18085
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
18086
  (exit $ac_status); } &&
 
18087
         { ac_try='test -s conftest$ac_exeext'
 
18088
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
18089
  (eval $ac_try) 2>&5
 
18090
  ac_status=$?
 
18091
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
18092
  (exit $ac_status); }; }; then
 
18093
  ac_cv_search_gettext="none required"
 
18094
else
 
18095
  echo "$as_me: failed program was:" >&5
 
18096
cat conftest.$ac_ext >&5
 
18097
fi
 
18098
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
18099
if test "$ac_cv_search_gettext" = no; then
 
18100
  for ac_lib in intl; do
 
18101
    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
 
18102
    cat >conftest.$ac_ext <<_ACEOF
 
18103
#line $LINENO "configure"
 
18104
#include "confdefs.h"
 
18105
 
 
18106
/* Override any gcc2 internal prototype to avoid an error.  */
 
18107
#ifdef __cplusplus
 
18108
extern "C"
 
18109
#endif
 
18110
/* We use char because int might match the return type of a gcc2
 
18111
   builtin and then its argument prototype would still apply.  */
 
18112
char gettext ();
 
18113
#ifdef F77_DUMMY_MAIN
 
18114
#  ifdef __cplusplus
 
18115
     extern "C"
 
18116
#  endif
 
18117
   int F77_DUMMY_MAIN() { return 1; }
 
18118
#endif
 
18119
int
 
18120
main ()
 
18121
{
 
18122
gettext ();
 
18123
  ;
 
18124
  return 0;
 
18125
}
 
18126
_ACEOF
 
18127
rm -f conftest.$ac_objext conftest$ac_exeext
 
18128
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
18129
  (eval $ac_link) 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_search_gettext="-l$ac_lib"
 
18140
break
 
18141
else
 
18142
  echo "$as_me: failed program was:" >&5
 
18143
cat conftest.$ac_ext >&5
 
18144
fi
 
18145
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
18146
  done
 
18147
fi
 
18148
LIBS=$ac_func_search_save_LIBS
 
18149
fi
 
18150
echo "$as_me:$LINENO: result: $ac_cv_search_gettext" >&5
 
18151
echo "${ECHO_T}$ac_cv_search_gettext" >&6
 
18152
if test "$ac_cv_search_gettext" != no; then
 
18153
  test "$ac_cv_search_gettext" = "none required" || LIBS="$ac_cv_search_gettext $LIBS"
 
18154
 
 
18155
else
 
18156
  { { echo "$as_me:$LINENO: error: a gettext implementation is required for NLS" >&5
 
18157
echo "$as_me: error: a gettext implementation is required for NLS" >&2;}
 
18158
   { (exit 1); exit 1; }; }
 
18159
fi
 
18160
 
 
18161
  if test "${ac_cv_header_libintl_h+set}" = set; then
 
18162
  echo "$as_me:$LINENO: checking for libintl.h" >&5
 
18163
echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6
 
18164
if test "${ac_cv_header_libintl_h+set}" = set; then
 
18165
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
18166
fi
 
18167
echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
 
18168
echo "${ECHO_T}$ac_cv_header_libintl_h" >&6
 
18169
else
 
18170
  # Is the header compilable?
 
18171
echo "$as_me:$LINENO: checking libintl.h usability" >&5
 
18172
echo $ECHO_N "checking libintl.h usability... $ECHO_C" >&6
 
18173
cat >conftest.$ac_ext <<_ACEOF
 
18174
#line $LINENO "configure"
 
18175
#include "confdefs.h"
 
18176
$ac_includes_default
 
18177
#include <libintl.h>
 
18178
_ACEOF
 
18179
rm -f conftest.$ac_objext
 
18180
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
18181
  (eval $ac_compile) 2>&5
 
18182
  ac_status=$?
 
18183
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
18184
  (exit $ac_status); } &&
 
18185
         { ac_try='test -s conftest.$ac_objext'
 
18186
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
18187
  (eval $ac_try) 2>&5
 
18188
  ac_status=$?
 
18189
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
18190
  (exit $ac_status); }; }; then
 
18191
  ac_header_compiler=yes
 
18192
else
 
18193
  echo "$as_me: failed program was:" >&5
 
18194
cat conftest.$ac_ext >&5
 
18195
ac_header_compiler=no
 
18196
fi
 
18197
rm -f conftest.$ac_objext conftest.$ac_ext
 
18198
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
18199
echo "${ECHO_T}$ac_header_compiler" >&6
 
18200
 
 
18201
# Is the header present?
 
18202
echo "$as_me:$LINENO: checking libintl.h presence" >&5
 
18203
echo $ECHO_N "checking libintl.h presence... $ECHO_C" >&6
 
18204
cat >conftest.$ac_ext <<_ACEOF
 
18205
#line $LINENO "configure"
 
18206
#include "confdefs.h"
 
18207
#include <libintl.h>
 
18208
_ACEOF
 
18209
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
18210
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
18211
  ac_status=$?
 
18212
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
18213
  rm -f conftest.er1
 
18214
  cat conftest.err >&5
 
18215
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
18216
  (exit $ac_status); } >/dev/null; then
 
18217
  if test -s conftest.err; then
 
18218
    ac_cpp_err=$ac_c_preproc_warn_flag
 
18219
  else
 
18220
    ac_cpp_err=
 
18221
  fi
 
18222
else
 
18223
  ac_cpp_err=yes
 
18224
fi
 
18225
if test -z "$ac_cpp_err"; then
 
18226
  ac_header_preproc=yes
 
18227
else
 
18228
  echo "$as_me: failed program was:" >&5
 
18229
  cat conftest.$ac_ext >&5
 
18230
  ac_header_preproc=no
 
18231
fi
 
18232
rm -f conftest.err conftest.$ac_ext
 
18233
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
18234
echo "${ECHO_T}$ac_header_preproc" >&6
 
18235
 
 
18236
# So?  What about this header?
 
18237
case $ac_header_compiler:$ac_header_preproc in
 
18238
  yes:no )
 
18239
    { echo "$as_me:$LINENO: WARNING: libintl.h: accepted by the compiler, rejected by the preprocessor!" >&5
 
18240
echo "$as_me: WARNING: libintl.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
18241
    { echo "$as_me:$LINENO: WARNING: libintl.h: proceeding with the preprocessor's result" >&5
 
18242
echo "$as_me: WARNING: libintl.h: proceeding with the preprocessor's result" >&2;};;
 
18243
  no:yes )
 
18244
    { echo "$as_me:$LINENO: WARNING: libintl.h: present but cannot be compiled" >&5
 
18245
echo "$as_me: WARNING: libintl.h: present but cannot be compiled" >&2;}
 
18246
    { echo "$as_me:$LINENO: WARNING: libintl.h: check for missing prerequisite headers?" >&5
 
18247
echo "$as_me: WARNING: libintl.h: check for missing prerequisite headers?" >&2;}
 
18248
    { echo "$as_me:$LINENO: WARNING: libintl.h: proceeding with the preprocessor's result" >&5
 
18249
echo "$as_me: WARNING: libintl.h: proceeding with the preprocessor's result" >&2;};;
 
18250
esac
 
18251
echo "$as_me:$LINENO: checking for libintl.h" >&5
 
18252
echo $ECHO_N "checking for libintl.h... $ECHO_C" >&6
 
18253
if test "${ac_cv_header_libintl_h+set}" = set; then
 
18254
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
18255
else
 
18256
  ac_cv_header_libintl_h=$ac_header_preproc
 
18257
fi
 
18258
echo "$as_me:$LINENO: result: $ac_cv_header_libintl_h" >&5
 
18259
echo "${ECHO_T}$ac_cv_header_libintl_h" >&6
 
18260
 
 
18261
fi
 
18262
if test $ac_cv_header_libintl_h = yes; then
 
18263
  :
 
18264
else
 
18265
  { { echo "$as_me:$LINENO: error: header file <libintl.h> is required for NLS" >&5
 
18266
echo "$as_me: error: header file <libintl.h> is required for NLS" >&2;}
 
18267
   { (exit 1); exit 1; }; }
 
18268
fi
 
18269
 
 
18270
 
 
18271
  for ac_prog in msgfmt
 
18272
do
 
18273
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
18274
set dummy $ac_prog; ac_word=$2
 
18275
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
18276
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
18277
if test "${ac_cv_prog_MSGFMT+set}" = set; then
 
18278
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
18279
else
 
18280
  if test -n "$MSGFMT"; then
 
18281
  ac_cv_prog_MSGFMT="$MSGFMT" # Let the user override the test.
 
18282
else
 
18283
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
18284
for as_dir in $PATH
 
18285
do
 
18286
  IFS=$as_save_IFS
 
18287
  test -z "$as_dir" && as_dir=.
 
18288
  for ac_exec_ext in '' $ac_executable_extensions; do
 
18289
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
18290
    ac_cv_prog_MSGFMT="$ac_prog"
 
18291
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
18292
    break 2
 
18293
  fi
 
18294
done
 
18295
done
 
18296
 
 
18297
fi
 
18298
fi
 
18299
MSGFMT=$ac_cv_prog_MSGFMT
 
18300
if test -n "$MSGFMT"; then
 
18301
  echo "$as_me:$LINENO: result: $MSGFMT" >&5
 
18302
echo "${ECHO_T}$MSGFMT" >&6
 
18303
else
 
18304
  echo "$as_me:$LINENO: result: no" >&5
 
18305
echo "${ECHO_T}no" >&6
 
18306
fi
 
18307
 
 
18308
  test -n "$MSGFMT" && break
 
18309
done
 
18310
 
 
18311
  if test -z "$MSGFMT"; then
 
18312
    { { echo "$as_me:$LINENO: error: msgfmt is required for NLS" >&5
 
18313
echo "$as_me: error: msgfmt is required for NLS" >&2;}
 
18314
   { (exit 1); exit 1; }; }
 
18315
  fi
 
18316
  for ac_prog in msgmerge
 
18317
do
 
18318
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
18319
set dummy $ac_prog; ac_word=$2
 
18320
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
18321
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
18322
if test "${ac_cv_prog_MSGMERGE+set}" = set; then
 
18323
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
18324
else
 
18325
  if test -n "$MSGMERGE"; then
 
18326
  ac_cv_prog_MSGMERGE="$MSGMERGE" # Let the user override the test.
 
18327
else
 
18328
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
18329
for as_dir in $PATH
 
18330
do
 
18331
  IFS=$as_save_IFS
 
18332
  test -z "$as_dir" && as_dir=.
 
18333
  for ac_exec_ext in '' $ac_executable_extensions; do
 
18334
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
18335
    ac_cv_prog_MSGMERGE="$ac_prog"
 
18336
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
18337
    break 2
 
18338
  fi
 
18339
done
 
18340
done
 
18341
 
 
18342
fi
 
18343
fi
 
18344
MSGMERGE=$ac_cv_prog_MSGMERGE
 
18345
if test -n "$MSGMERGE"; then
 
18346
  echo "$as_me:$LINENO: result: $MSGMERGE" >&5
 
18347
echo "${ECHO_T}$MSGMERGE" >&6
 
18348
else
 
18349
  echo "$as_me:$LINENO: result: no" >&5
 
18350
echo "${ECHO_T}no" >&6
 
18351
fi
 
18352
 
 
18353
  test -n "$MSGMERGE" && break
 
18354
done
 
18355
 
 
18356
  for ac_prog in xgettext
 
18357
do
 
18358
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
18359
set dummy $ac_prog; ac_word=$2
 
18360
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
18361
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
18362
if test "${ac_cv_prog_XGETTEXT+set}" = set; then
 
18363
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
18364
else
 
18365
  if test -n "$XGETTEXT"; then
 
18366
  ac_cv_prog_XGETTEXT="$XGETTEXT" # Let the user override the test.
 
18367
else
 
18368
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
18369
for as_dir in $PATH
 
18370
do
 
18371
  IFS=$as_save_IFS
 
18372
  test -z "$as_dir" && as_dir=.
 
18373
  for ac_exec_ext in '' $ac_executable_extensions; do
 
18374
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
18375
    ac_cv_prog_XGETTEXT="$ac_prog"
 
18376
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
18377
    break 2
 
18378
  fi
 
18379
done
 
18380
done
 
18381
 
 
18382
fi
 
18383
fi
 
18384
XGETTEXT=$ac_cv_prog_XGETTEXT
 
18385
if test -n "$XGETTEXT"; then
 
18386
  echo "$as_me:$LINENO: result: $XGETTEXT" >&5
 
18387
echo "${ECHO_T}$XGETTEXT" >&6
 
18388
else
 
18389
  echo "$as_me:$LINENO: result: no" >&5
 
18390
echo "${ECHO_T}no" >&6
 
18391
fi
 
18392
 
 
18393
  test -n "$XGETTEXT" && break
 
18394
done
 
18395
 
 
18396
 
 
18397
  # Note: share/locale is always the default, independent of $datadir
 
18398
  localedir='${prefix}/share/locale'
 
18399
  if test x"$prefix" = x"NONE"; then
 
18400
    exp_localedir="$ac_default_prefix/share/locale"
 
18401
  else
 
18402
    exp_localedir="$prefix/share/locale"
 
18403
  fi
 
18404
 
 
18405
 
 
18406
 
 
18407
cat >>confdefs.h <<_ACEOF
 
18408
#define LOCALEDIR "$exp_localedir"
 
18409
_ACEOF
 
18410
 
 
18411
 
 
18412
fi
 
18413
 
 
18414
# Check for Tcl configuration script tclConfig.sh
 
18415
if test "$with_tcl" = yes; then
 
18416
    for ac_prog in tclsh tcl
 
18417
do
 
18418
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
18419
set dummy $ac_prog; ac_word=$2
 
18420
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
18421
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
18422
if test "${ac_cv_path_TCLSH+set}" = set; then
 
18423
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
18424
else
 
18425
  case $TCLSH in
 
18426
  [\\/]* | ?:[\\/]*)
 
18427
  ac_cv_path_TCLSH="$TCLSH" # Let the user override the test with a path.
 
18428
  ;;
 
18429
  *)
 
18430
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
18431
for as_dir in $PATH
 
18432
do
 
18433
  IFS=$as_save_IFS
 
18434
  test -z "$as_dir" && as_dir=.
 
18435
  for ac_exec_ext in '' $ac_executable_extensions; do
 
18436
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
18437
    ac_cv_path_TCLSH="$as_dir/$ac_word$ac_exec_ext"
 
18438
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
18439
    break 2
 
18440
  fi
 
18441
done
 
18442
done
 
18443
 
 
18444
  ;;
 
18445
esac
 
18446
fi
 
18447
TCLSH=$ac_cv_path_TCLSH
 
18448
 
 
18449
if test -n "$TCLSH"; then
 
18450
  echo "$as_me:$LINENO: result: $TCLSH" >&5
 
18451
echo "${ECHO_T}$TCLSH" >&6
 
18452
else
 
18453
  echo "$as_me:$LINENO: result: no" >&5
 
18454
echo "${ECHO_T}no" >&6
 
18455
fi
 
18456
 
 
18457
  test -n "$TCLSH" && break
 
18458
done
 
18459
 
 
18460
echo "$as_me:$LINENO: checking for tclConfig.sh" >&5
 
18461
echo $ECHO_N "checking for tclConfig.sh... $ECHO_C" >&6
 
18462
# Let user override test
 
18463
if test -z "$TCL_CONFIG_SH"; then
 
18464
    pgac_test_dirs="$with_tclconfig"
 
18465
 
 
18466
    set X $pgac_test_dirs; shift
 
18467
    if test $# -eq 0; then
 
18468
        test -z "$TCLSH" && { { echo "$as_me:$LINENO: error: unable to locate tclConfig.sh because no Tcl shell was found" >&5
 
18469
echo "$as_me: error: unable to locate tclConfig.sh because no Tcl shell was found" >&2;}
 
18470
   { (exit 1); exit 1; }; }
 
18471
        set X `echo 'puts $auto_path' | $TCLSH`; shift
 
18472
    fi
 
18473
 
 
18474
    for pgac_dir do
 
18475
        if test -r "$pgac_dir/tclConfig.sh"; then
 
18476
            TCL_CONFIG_SH=$pgac_dir/tclConfig.sh
 
18477
            break
 
18478
        fi
 
18479
    done
 
18480
fi
 
18481
 
 
18482
if test -z "$TCL_CONFIG_SH"; then
 
18483
    echo "$as_me:$LINENO: result: no" >&5
 
18484
echo "${ECHO_T}no" >&6
 
18485
    { { echo "$as_me:$LINENO: error: file 'tclConfig.sh' is required for Tcl" >&5
 
18486
echo "$as_me: error: file 'tclConfig.sh' is required for Tcl" >&2;}
 
18487
   { (exit 1); exit 1; }; }
 
18488
else
 
18489
    echo "$as_me:$LINENO: result: $TCL_CONFIG_SH" >&5
 
18490
echo "${ECHO_T}$TCL_CONFIG_SH" >&6
 
18491
fi
 
18492
 
 
18493
 
 
18494
 
 
18495
    . "$TCL_CONFIG_SH"
 
18496
eval TCL_INCLUDE_SPEC=\"$TCL_INCLUDE_SPEC\"
 
18497
eval TCL_LIB_FILE=\"$TCL_LIB_FILE\"
 
18498
eval TCL_LIBS=\"$TCL_LIBS\"
 
18499
eval TCL_LIB_SPEC=\"$TCL_LIB_SPEC\"
 
18500
eval TCL_SHARED_BUILD=\"$TCL_SHARED_BUILD\"
 
18501
 
 
18502
        # now that we have TCL_INCLUDE_SPEC, we can check for <tcl.h>
 
18503
    ac_save_CPPFLAGS=$CPPFLAGS
 
18504
    CPPFLAGS="$TCL_INCLUDE_SPEC $CPPFLAGS"
 
18505
    if test "${ac_cv_header_tcl_h+set}" = set; then
 
18506
  echo "$as_me:$LINENO: checking for tcl.h" >&5
 
18507
echo $ECHO_N "checking for tcl.h... $ECHO_C" >&6
 
18508
if test "${ac_cv_header_tcl_h+set}" = set; then
 
18509
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
18510
fi
 
18511
echo "$as_me:$LINENO: result: $ac_cv_header_tcl_h" >&5
 
18512
echo "${ECHO_T}$ac_cv_header_tcl_h" >&6
 
18513
else
 
18514
  # Is the header compilable?
 
18515
echo "$as_me:$LINENO: checking tcl.h usability" >&5
 
18516
echo $ECHO_N "checking tcl.h usability... $ECHO_C" >&6
 
18517
cat >conftest.$ac_ext <<_ACEOF
 
18518
#line $LINENO "configure"
 
18519
#include "confdefs.h"
 
18520
$ac_includes_default
 
18521
#include <tcl.h>
 
18522
_ACEOF
 
18523
rm -f conftest.$ac_objext
 
18524
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
18525
  (eval $ac_compile) 2>&5
 
18526
  ac_status=$?
 
18527
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
18528
  (exit $ac_status); } &&
 
18529
         { ac_try='test -s conftest.$ac_objext'
 
18530
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
18531
  (eval $ac_try) 2>&5
 
18532
  ac_status=$?
 
18533
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
18534
  (exit $ac_status); }; }; then
 
18535
  ac_header_compiler=yes
 
18536
else
 
18537
  echo "$as_me: failed program was:" >&5
 
18538
cat conftest.$ac_ext >&5
 
18539
ac_header_compiler=no
 
18540
fi
 
18541
rm -f conftest.$ac_objext conftest.$ac_ext
 
18542
echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
18543
echo "${ECHO_T}$ac_header_compiler" >&6
 
18544
 
 
18545
# Is the header present?
 
18546
echo "$as_me:$LINENO: checking tcl.h presence" >&5
 
18547
echo $ECHO_N "checking tcl.h presence... $ECHO_C" >&6
 
18548
cat >conftest.$ac_ext <<_ACEOF
 
18549
#line $LINENO "configure"
 
18550
#include "confdefs.h"
 
18551
#include <tcl.h>
 
18552
_ACEOF
 
18553
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
18554
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
18555
  ac_status=$?
 
18556
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
18557
  rm -f conftest.er1
 
18558
  cat conftest.err >&5
 
18559
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
18560
  (exit $ac_status); } >/dev/null; then
 
18561
  if test -s conftest.err; then
 
18562
    ac_cpp_err=$ac_c_preproc_warn_flag
 
18563
  else
 
18564
    ac_cpp_err=
 
18565
  fi
 
18566
else
 
18567
  ac_cpp_err=yes
 
18568
fi
 
18569
if test -z "$ac_cpp_err"; then
 
18570
  ac_header_preproc=yes
 
18571
else
 
18572
  echo "$as_me: failed program was:" >&5
 
18573
  cat conftest.$ac_ext >&5
 
18574
  ac_header_preproc=no
 
18575
fi
 
18576
rm -f conftest.err conftest.$ac_ext
 
18577
echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
18578
echo "${ECHO_T}$ac_header_preproc" >&6
 
18579
 
 
18580
# So?  What about this header?
 
18581
case $ac_header_compiler:$ac_header_preproc in
 
18582
  yes:no )
 
18583
    { echo "$as_me:$LINENO: WARNING: tcl.h: accepted by the compiler, rejected by the preprocessor!" >&5
 
18584
echo "$as_me: WARNING: tcl.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
18585
    { echo "$as_me:$LINENO: WARNING: tcl.h: proceeding with the preprocessor's result" >&5
 
18586
echo "$as_me: WARNING: tcl.h: proceeding with the preprocessor's result" >&2;};;
 
18587
  no:yes )
 
18588
    { echo "$as_me:$LINENO: WARNING: tcl.h: present but cannot be compiled" >&5
 
18589
echo "$as_me: WARNING: tcl.h: present but cannot be compiled" >&2;}
 
18590
    { echo "$as_me:$LINENO: WARNING: tcl.h: check for missing prerequisite headers?" >&5
 
18591
echo "$as_me: WARNING: tcl.h: check for missing prerequisite headers?" >&2;}
 
18592
    { echo "$as_me:$LINENO: WARNING: tcl.h: proceeding with the preprocessor's result" >&5
 
18593
echo "$as_me: WARNING: tcl.h: proceeding with the preprocessor's result" >&2;};;
 
18594
esac
 
18595
echo "$as_me:$LINENO: checking for tcl.h" >&5
 
18596
echo $ECHO_N "checking for tcl.h... $ECHO_C" >&6
 
18597
if test "${ac_cv_header_tcl_h+set}" = set; then
 
18598
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
18599
else
 
18600
  ac_cv_header_tcl_h=$ac_header_preproc
 
18601
fi
 
18602
echo "$as_me:$LINENO: result: $ac_cv_header_tcl_h" >&5
 
18603
echo "${ECHO_T}$ac_cv_header_tcl_h" >&6
 
18604
 
 
18605
fi
 
18606
if test $ac_cv_header_tcl_h = yes; then
 
18607
  :
 
18608
else
 
18609
  { { echo "$as_me:$LINENO: error: header file <tcl.h> is required for Tcl" >&5
 
18610
echo "$as_me: error: header file <tcl.h> is required for Tcl" >&2;}
 
18611
   { (exit 1); exit 1; }; }
 
18612
fi
 
18613
 
 
18614
 
 
18615
    CPPFLAGS=$ac_save_CPPFLAGS
 
18616
fi
 
18617
 
 
18618
#
 
18619
# Check for DocBook and tools
 
18620
#
 
18621
for ac_prog in onsgmls nsgmls
 
18622
do
 
18623
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
18624
set dummy $ac_prog; ac_word=$2
 
18625
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
18626
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
18627
if test "${ac_cv_prog_NSGMLS+set}" = set; then
 
18628
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
18629
else
 
18630
  if test -n "$NSGMLS"; then
 
18631
  ac_cv_prog_NSGMLS="$NSGMLS" # Let the user override the test.
 
18632
else
 
18633
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
18634
for as_dir in $PATH
 
18635
do
 
18636
  IFS=$as_save_IFS
 
18637
  test -z "$as_dir" && as_dir=.
 
18638
  for ac_exec_ext in '' $ac_executable_extensions; do
 
18639
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
18640
    ac_cv_prog_NSGMLS="$ac_prog"
 
18641
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
18642
    break 2
 
18643
  fi
 
18644
done
 
18645
done
 
18646
 
 
18647
fi
 
18648
fi
 
18649
NSGMLS=$ac_cv_prog_NSGMLS
 
18650
if test -n "$NSGMLS"; then
 
18651
  echo "$as_me:$LINENO: result: $NSGMLS" >&5
 
18652
echo "${ECHO_T}$NSGMLS" >&6
 
18653
else
 
18654
  echo "$as_me:$LINENO: result: no" >&5
 
18655
echo "${ECHO_T}no" >&6
 
18656
fi
 
18657
 
 
18658
  test -n "$NSGMLS" && break
 
18659
done
 
18660
 
 
18661
for ac_prog in openjade jade
 
18662
do
 
18663
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
18664
set dummy $ac_prog; ac_word=$2
 
18665
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
18666
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
18667
if test "${ac_cv_prog_JADE+set}" = set; then
 
18668
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
18669
else
 
18670
  if test -n "$JADE"; then
 
18671
  ac_cv_prog_JADE="$JADE" # Let the user override the test.
 
18672
else
 
18673
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
18674
for as_dir in $PATH
 
18675
do
 
18676
  IFS=$as_save_IFS
 
18677
  test -z "$as_dir" && as_dir=.
 
18678
  for ac_exec_ext in '' $ac_executable_extensions; do
 
18679
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
18680
    ac_cv_prog_JADE="$ac_prog"
 
18681
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
18682
    break 2
 
18683
  fi
 
18684
done
 
18685
done
 
18686
 
 
18687
fi
 
18688
fi
 
18689
JADE=$ac_cv_prog_JADE
 
18690
if test -n "$JADE"; then
 
18691
  echo "$as_me:$LINENO: result: $JADE" >&5
 
18692
echo "${ECHO_T}$JADE" >&6
 
18693
else
 
18694
  echo "$as_me:$LINENO: result: no" >&5
 
18695
echo "${ECHO_T}no" >&6
 
18696
fi
 
18697
 
 
18698
  test -n "$JADE" && break
 
18699
done
 
18700
 
 
18701
 
 
18702
echo "$as_me:$LINENO: checking for DocBook V4.2" >&5
 
18703
echo $ECHO_N "checking for DocBook V4.2... $ECHO_C" >&6
 
18704
if test "${pgac_cv_check_docbook+set}" = set; then
 
18705
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
18706
else
 
18707
  cat >conftest.sgml <<EOF
 
18708
<!doctype book PUBLIC "-//OASIS//DTD DocBook V4.2//EN">
 
18709
<book>
 
18710
 <title>test</title>
 
18711
 <chapter>
 
18712
  <title>random</title>
 
18713
   <sect1>
 
18714
    <title>testsect</title>
 
18715
    <para>text</para>
 
18716
  </sect1>
 
18717
 </chapter>
 
18718
</book>
 
18719
EOF
 
18720
 
 
18721
pgac_cv_check_docbook=no
 
18722
 
 
18723
if test -n "$NSGMLS"; then
 
18724
  $NSGMLS -s conftest.sgml 1>&5 2>&1
 
18725
  if test $? -eq 0; then
 
18726
    pgac_cv_check_docbook=yes
 
18727
  fi
 
18728
fi
 
18729
rm -f conftest.sgml
 
18730
fi
 
18731
echo "$as_me:$LINENO: result: $pgac_cv_check_docbook" >&5
 
18732
echo "${ECHO_T}$pgac_cv_check_docbook" >&6
 
18733
 
 
18734
have_docbook=$pgac_cv_check_docbook
 
18735
 
 
18736
 
 
18737
echo "$as_me:$LINENO: checking for DocBook stylesheets" >&5
 
18738
echo $ECHO_N "checking for DocBook stylesheets... $ECHO_C" >&6
 
18739
if test "${pgac_cv_path_stylesheets+set}" = set; then
 
18740
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
18741
else
 
18742
  if test -n "$DOCBOOKSTYLE"; then
 
18743
  pgac_cv_path_stylesheets=$DOCBOOKSTYLE
 
18744
else
 
18745
  for pgac_prefix in /usr /usr/local /opt; do
 
18746
    for pgac_infix in share lib; do
 
18747
      for pgac_postfix in \
 
18748
        sgml/stylesheets/nwalsh-modular \
 
18749
        sgml/stylesheets/docbook \
 
18750
                sgml/docbook-dsssl \
 
18751
        sgml/docbook/dsssl/modular \
 
18752
        sgml/docbook/stylesheet/dsssl/modular \
 
18753
        sgml/docbook/dsssl-stylesheets
 
18754
      do
 
18755
        pgac_candidate=$pgac_prefix/$pgac_infix/$pgac_postfix
 
18756
        if test -r "$pgac_candidate/html/docbook.dsl" \
 
18757
           && test -r "$pgac_candidate/print/docbook.dsl"
 
18758
        then
 
18759
          pgac_cv_path_stylesheets=$pgac_candidate
 
18760
          break 3
 
18761
        fi
 
18762
      done
 
18763
    done
 
18764
  done
 
18765
fi
 
18766
fi
 
18767
 
 
18768
DOCBOOKSTYLE=$pgac_cv_path_stylesheets
 
18769
 
 
18770
if test -n "$DOCBOOKSTYLE"; then
 
18771
  echo "$as_me:$LINENO: result: $DOCBOOKSTYLE" >&5
 
18772
echo "${ECHO_T}$DOCBOOKSTYLE" >&6
 
18773
else
 
18774
  echo "$as_me:$LINENO: result: no" >&5
 
18775
echo "${ECHO_T}no" >&6
 
18776
fi
 
18777
if test -n "$DOCBOOKSTYLE"; then
 
18778
  for ac_prog in collateindex.pl
 
18779
do
 
18780
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
18781
set dummy $ac_prog; ac_word=$2
 
18782
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
18783
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
18784
if test "${ac_cv_path_COLLATEINDEX+set}" = set; then
 
18785
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
18786
else
 
18787
  case $COLLATEINDEX in
 
18788
  [\\/]* | ?:[\\/]*)
 
18789
  ac_cv_path_COLLATEINDEX="$COLLATEINDEX" # Let the user override the test with a path.
 
18790
  ;;
 
18791
  *)
 
18792
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
18793
for as_dir in $DOCBOOKSTYLE/bin $PATH
 
18794
do
 
18795
  IFS=$as_save_IFS
 
18796
  test -z "$as_dir" && as_dir=.
 
18797
  for ac_exec_ext in '' $ac_executable_extensions; do
 
18798
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
18799
    ac_cv_path_COLLATEINDEX="$as_dir/$ac_word$ac_exec_ext"
 
18800
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
18801
    break 2
 
18802
  fi
 
18803
done
 
18804
done
 
18805
 
 
18806
  ;;
 
18807
esac
 
18808
fi
 
18809
COLLATEINDEX=$ac_cv_path_COLLATEINDEX
 
18810
 
 
18811
if test -n "$COLLATEINDEX"; then
 
18812
  echo "$as_me:$LINENO: result: $COLLATEINDEX" >&5
 
18813
echo "${ECHO_T}$COLLATEINDEX" >&6
 
18814
else
 
18815
  echo "$as_me:$LINENO: result: no" >&5
 
18816
echo "${ECHO_T}no" >&6
 
18817
fi
 
18818
 
 
18819
  test -n "$COLLATEINDEX" && break
 
18820
done
 
18821
 
 
18822
else
 
18823
  for ac_prog in collateindex.pl
 
18824
do
 
18825
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
18826
set dummy $ac_prog; ac_word=$2
 
18827
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
18828
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
18829
if test "${ac_cv_path_COLLATEINDEX+set}" = set; then
 
18830
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
18831
else
 
18832
  case $COLLATEINDEX in
 
18833
  [\\/]* | ?:[\\/]*)
 
18834
  ac_cv_path_COLLATEINDEX="$COLLATEINDEX" # Let the user override the test with a path.
 
18835
  ;;
 
18836
  *)
 
18837
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
18838
for as_dir in $PATH
 
18839
do
 
18840
  IFS=$as_save_IFS
 
18841
  test -z "$as_dir" && as_dir=.
 
18842
  for ac_exec_ext in '' $ac_executable_extensions; do
 
18843
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
18844
    ac_cv_path_COLLATEINDEX="$as_dir/$ac_word$ac_exec_ext"
 
18845
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
18846
    break 2
 
18847
  fi
 
18848
done
 
18849
done
 
18850
 
 
18851
  ;;
 
18852
esac
 
18853
fi
 
18854
COLLATEINDEX=$ac_cv_path_COLLATEINDEX
 
18855
 
 
18856
if test -n "$COLLATEINDEX"; then
 
18857
  echo "$as_me:$LINENO: result: $COLLATEINDEX" >&5
 
18858
echo "${ECHO_T}$COLLATEINDEX" >&6
 
18859
else
 
18860
  echo "$as_me:$LINENO: result: no" >&5
 
18861
echo "${ECHO_T}no" >&6
 
18862
fi
 
18863
 
 
18864
  test -n "$COLLATEINDEX" && break
 
18865
done
 
18866
 
 
18867
fi
 
18868
for ac_prog in sgmlspl
 
18869
do
 
18870
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
18871
set dummy $ac_prog; ac_word=$2
 
18872
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
18873
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
18874
if test "${ac_cv_prog_SGMLSPL+set}" = set; then
 
18875
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
18876
else
 
18877
  if test -n "$SGMLSPL"; then
 
18878
  ac_cv_prog_SGMLSPL="$SGMLSPL" # Let the user override the test.
 
18879
else
 
18880
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
18881
for as_dir in $PATH
 
18882
do
 
18883
  IFS=$as_save_IFS
 
18884
  test -z "$as_dir" && as_dir=.
 
18885
  for ac_exec_ext in '' $ac_executable_extensions; do
 
18886
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
18887
    ac_cv_prog_SGMLSPL="$ac_prog"
 
18888
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
18889
    break 2
 
18890
  fi
 
18891
done
 
18892
done
 
18893
 
 
18894
fi
 
18895
fi
 
18896
SGMLSPL=$ac_cv_prog_SGMLSPL
 
18897
if test -n "$SGMLSPL"; then
 
18898
  echo "$as_me:$LINENO: result: $SGMLSPL" >&5
 
18899
echo "${ECHO_T}$SGMLSPL" >&6
 
18900
else
 
18901
  echo "$as_me:$LINENO: result: no" >&5
 
18902
echo "${ECHO_T}no" >&6
 
18903
fi
 
18904
 
 
18905
  test -n "$SGMLSPL" && break
 
18906
done
 
18907
 
 
18908
 
 
18909
# Thread testing
 
18910
 
 
18911
# We have to run the thread test near the end so we have all our symbols
 
18912
# defined.  Cross compiling throws a warning.
 
18913
#
 
18914
if test "$enable_thread_safety_force" = yes; then
 
18915
  { echo "$as_me:$LINENO: WARNING:
 
18916
*** Skipping thread test program.  --enable-thread-safety-force was used.
 
18917
*** Run the program in src/tools/thread on the your machine and add
 
18918
proper locking function calls to your applications to guarantee thread
 
18919
safety.
 
18920
" >&5
 
18921
echo "$as_me: WARNING:
 
18922
*** Skipping thread test program.  --enable-thread-safety-force was used.
 
18923
*** Run the program in src/tools/thread on the your machine and add
 
18924
proper locking function calls to your applications to guarantee thread
 
18925
safety.
 
18926
" >&2;}
 
18927
elif test "$enable_thread_safety" = yes; then
 
18928
echo "$as_me:$LINENO: checking thread safety of required library functions" >&5
 
18929
echo $ECHO_N "checking thread safety of required library functions... $ECHO_C" >&6
 
18930
 
 
18931
_CFLAGS="$CFLAGS"
 
18932
_LIBS="$LIBS"
 
18933
CFLAGS="$CFLAGS $PTHREAD_CFLAGS -DIN_CONFIGURE"
 
18934
LIBS="$LIBS $PTHREAD_LIBS"
 
18935
if test "$cross_compiling" = yes; then
 
18936
  echo "$as_me:$LINENO: result: maybe" >&5
 
18937
echo "${ECHO_T}maybe" >&6
 
18938
  { echo "$as_me:$LINENO: WARNING:
 
18939
*** Skipping thread test program because of cross-compile build.
 
18940
*** Run the program in src/tools/thread on the target machine.
 
18941
" >&5
 
18942
echo "$as_me: WARNING:
 
18943
*** Skipping thread test program because of cross-compile build.
 
18944
*** Run the program in src/tools/thread on the target machine.
 
18945
" >&2;}
 
18946
else
 
18947
  cat >conftest.$ac_ext <<_ACEOF
 
18948
#line $LINENO "configure"
 
18949
#include "confdefs.h"
 
18950
#include "$srcdir/src/tools/thread/thread_test.c"
 
18951
_ACEOF
 
18952
rm -f conftest$ac_exeext
 
18953
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
18954
  (eval $ac_link) 2>&5
 
18955
  ac_status=$?
 
18956
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
18957
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
18958
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
18959
  (eval $ac_try) 2>&5
 
18960
  ac_status=$?
 
18961
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
18962
  (exit $ac_status); }; }; then
 
18963
  echo "$as_me:$LINENO: result: yes" >&5
 
18964
echo "${ECHO_T}yes" >&6
 
18965
else
 
18966
  echo "$as_me: program exited with status $ac_status" >&5
 
18967
echo "$as_me: failed program was:" >&5
 
18968
cat conftest.$ac_ext >&5
 
18969
( exit $ac_status )
 
18970
echo "$as_me:$LINENO: result: no" >&5
 
18971
echo "${ECHO_T}no" >&6
 
18972
  { { echo "$as_me:$LINENO: error:
 
18973
*** Thread test program failed.  Your platform is not thread-safe.
 
18974
*** Check the file 'config.log'for the exact reason.
 
18975
***
 
18976
*** You can use the configure option --enable-thread-safety-force
 
18977
*** to force threads to be enabled.  However, you must then run
 
18978
*** the program in src/tools/thread and add locking function calls
 
18979
*** to your applications to guarantee thread safety.
 
18980
" >&5
 
18981
echo "$as_me: error:
 
18982
*** Thread test program failed.  Your platform is not thread-safe.
 
18983
*** Check the file 'config.log'for the exact reason.
 
18984
***
 
18985
*** You can use the configure option --enable-thread-safety-force
 
18986
*** to force threads to be enabled.  However, you must then run
 
18987
*** the program in src/tools/thread and add locking function calls
 
18988
*** to your applications to guarantee thread safety.
 
18989
" >&2;}
 
18990
   { (exit 1); exit 1; }; }
 
18991
fi
 
18992
rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 
18993
fi
 
18994
CFLAGS="$_CFLAGS"
 
18995
LIBS="$_LIBS"
 
18996
fi
 
18997
 
 
18998
# prepare build tree if outside source tree
 
18999
# Note 1: test -ef might not exist, but it's more reliable than `pwd`.
 
19000
# Note 2: /bin/pwd might be better than shell's built-in at getting
 
19001
#         a symlink-free name.
 
19002
if ( test "$srcdir" -ef . ) >/dev/null 2>&1 || test "`cd $srcdir && /bin/pwd`" = "`/bin/pwd`"; then
 
19003
  vpath_build=no
 
19004
else
 
19005
  vpath_build=yes
 
19006
  if test "$no_create" != yes; then
 
19007
    echo $ECHO_N "preparing build tree... $ECHO_C" >&6
 
19008
    pgac_abs_top_srcdir=`cd "$srcdir" && pwd`
 
19009
    $SHELL "$ac_aux_dir/prep_buildtree" "$pgac_abs_top_srcdir" "." \
 
19010
      || { { echo "$as_me:$LINENO: error: failed" >&5
 
19011
echo "$as_me: error: failed" >&2;}
 
19012
   { (exit 1); exit 1; }; }
 
19013
    echo "$as_me:$LINENO: result: done" >&5
 
19014
echo "${ECHO_T}done" >&6
 
19015
  fi
 
19016
fi
 
19017
 
 
19018
 
 
19019
 
 
19020
ac_config_files="$ac_config_files GNUmakefile src/Makefile.global"
 
19021
 
 
19022
 
 
19023
ac_config_links="$ac_config_links src/backend/port/dynloader.c:src/backend/port/dynloader/${template}.c src/backend/port/pg_sema.c:${SEMA_IMPLEMENTATION} src/backend/port/pg_shmem.c:${SHMEM_IMPLEMENTATION} src/include/dynloader.h:src/backend/port/dynloader/${template}.h src/include/pg_config_os.h:src/include/port/${template}.h src/Makefile.port:src/makefiles/Makefile.${template}"
 
19024
 
 
19025
 
 
19026
if test "$PORTNAME" = "win32"; then
 
19027
ac_config_commands="$ac_config_commands check_win32_symlinks"
 
19028
 
 
19029
fi
 
19030
 
 
19031
ac_config_headers="$ac_config_headers src/include/pg_config.h"
 
19032
 
 
19033
 
 
19034
cat >confcache <<\_ACEOF
 
19035
# This file is a shell script that caches the results of configure
 
19036
# tests run on this system so they can be shared between configure
 
19037
# scripts and configure runs, see configure's option --config-cache.
 
19038
# It is not useful on other systems.  If it contains results you don't
 
19039
# want to keep, you may remove or edit it.
 
19040
#
 
19041
# config.status only pays attention to the cache file if you give it
 
19042
# the --recheck option to rerun configure.
 
19043
#
 
19044
# `ac_cv_env_foo' variables (set or unset) will be overriden when
 
19045
# loading this file, other *unset* `ac_cv_foo' will be assigned the
 
19046
# following values.
 
19047
 
 
19048
_ACEOF
 
19049
 
 
19050
# The following way of writing the cache mishandles newlines in values,
 
19051
# but we know of no workaround that is simple, portable, and efficient.
 
19052
# So, don't put newlines in cache variables' values.
 
19053
# Ultrix sh set writes to stderr and can't be redirected directly,
 
19054
# and sets the high bit in the cache file unless we assign to the vars.
 
19055
{
 
19056
  (set) 2>&1 |
 
19057
    case `(ac_space=' '; set | grep ac_space) 2>&1` in
 
19058
    *ac_space=\ *)
 
19059
      # `set' does not quote correctly, so add quotes (double-quote
 
19060
      # substitution turns \\\\ into \\, and sed turns \\ into \).
 
19061
      sed -n \
 
19062
        "s/'/'\\\\''/g;
 
19063
          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
 
19064
      ;;
 
19065
    *)
 
19066
      # `set' quotes correctly as required by POSIX, so do not add quotes.
 
19067
      sed -n \
 
19068
        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
 
19069
      ;;
 
19070
    esac;
 
19071
} |
 
19072
  sed '
 
19073
     t clear
 
19074
     : clear
 
19075
     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
 
19076
     t end
 
19077
     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
 
19078
     : end' >>confcache
 
19079
if cmp -s $cache_file confcache; then :; else
 
19080
  if test -w $cache_file; then
 
19081
    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
 
19082
    cat confcache >$cache_file
 
19083
  else
 
19084
    echo "not updating unwritable cache $cache_file"
 
19085
  fi
 
19086
fi
 
19087
rm -f confcache
 
19088
 
 
19089
test "x$prefix" = xNONE && prefix=$ac_default_prefix
 
19090
# Let make expand exec_prefix.
 
19091
test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
 
19092
 
 
19093
# VPATH may cause trouble with some makes, so we remove $(srcdir),
 
19094
# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
 
19095
# trailing colons and then remove the whole line if VPATH becomes empty
 
19096
# (actually we leave an empty line to preserve line numbers).
 
19097
if test "x$srcdir" = x.; then
 
19098
  ac_vpsub='/^[         ]*VPATH[        ]*=/{
 
19099
s/:*\$(srcdir):*/:/;
 
19100
s/:*\${srcdir}:*/:/;
 
19101
s/:*@srcdir@:*/:/;
 
19102
s/^\([^=]*=[    ]*\):*/\1/;
 
19103
s/:*$//;
 
19104
s/^[^=]*=[      ]*$//;
 
19105
}'
 
19106
fi
 
19107
 
 
19108
DEFS=-DHAVE_CONFIG_H
 
19109
 
 
19110
 
 
19111
: ${CONFIG_STATUS=./config.status}
 
19112
ac_clean_files_save=$ac_clean_files
 
19113
ac_clean_files="$ac_clean_files $CONFIG_STATUS"
 
19114
{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
 
19115
echo "$as_me: creating $CONFIG_STATUS" >&6;}
 
19116
cat >$CONFIG_STATUS <<_ACEOF
 
19117
#! $SHELL
 
19118
# Generated by $as_me.
 
19119
# Run this file to recreate the current configuration.
 
19120
# Compiler output produced by configure, useful for debugging
 
19121
# configure, is in config.log if it exists.
 
19122
 
 
19123
debug=false
 
19124
SHELL=\${CONFIG_SHELL-$SHELL}
 
19125
_ACEOF
 
19126
 
 
19127
cat >>$CONFIG_STATUS <<\_ACEOF
 
19128
 
 
19129
## --------------------- ##
 
19130
## M4sh Initialization.  ##
 
19131
## --------------------- ##
 
19132
 
 
19133
# Be Bourne compatible
 
19134
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
 
19135
  emulate sh
 
19136
  NULLCMD=:
 
19137
elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
 
19138
  set -o posix
 
19139
fi
 
19140
 
 
19141
# NLS nuisances.
 
19142
# Support unset when possible.
 
19143
if (FOO=FOO; unset FOO) >/dev/null 2>&1; then
 
19144
  as_unset=unset
 
19145
else
 
19146
  as_unset=false
 
19147
fi
 
19148
 
 
19149
(set +x; test -n "`(LANG=C; export LANG) 2>&1`") &&
 
19150
    { $as_unset LANG || test "${LANG+set}" != set; } ||
 
19151
      { LANG=C; export LANG; }
 
19152
(set +x; test -n "`(LC_ALL=C; export LC_ALL) 2>&1`") &&
 
19153
    { $as_unset LC_ALL || test "${LC_ALL+set}" != set; } ||
 
19154
      { LC_ALL=C; export LC_ALL; }
 
19155
(set +x; test -n "`(LC_TIME=C; export LC_TIME) 2>&1`") &&
 
19156
    { $as_unset LC_TIME || test "${LC_TIME+set}" != set; } ||
 
19157
      { LC_TIME=C; export LC_TIME; }
 
19158
(set +x; test -n "`(LC_CTYPE=C; export LC_CTYPE) 2>&1`") &&
 
19159
    { $as_unset LC_CTYPE || test "${LC_CTYPE+set}" != set; } ||
 
19160
      { LC_CTYPE=C; export LC_CTYPE; }
 
19161
(set +x; test -n "`(LANGUAGE=C; export LANGUAGE) 2>&1`") &&
 
19162
    { $as_unset LANGUAGE || test "${LANGUAGE+set}" != set; } ||
 
19163
      { LANGUAGE=C; export LANGUAGE; }
 
19164
(set +x; test -n "`(LC_COLLATE=C; export LC_COLLATE) 2>&1`") &&
 
19165
    { $as_unset LC_COLLATE || test "${LC_COLLATE+set}" != set; } ||
 
19166
      { LC_COLLATE=C; export LC_COLLATE; }
 
19167
(set +x; test -n "`(LC_NUMERIC=C; export LC_NUMERIC) 2>&1`") &&
 
19168
    { $as_unset LC_NUMERIC || test "${LC_NUMERIC+set}" != set; } ||
 
19169
      { LC_NUMERIC=C; export LC_NUMERIC; }
 
19170
(set +x; test -n "`(LC_MESSAGES=C; export LC_MESSAGES) 2>&1`") &&
 
19171
    { $as_unset LC_MESSAGES || test "${LC_MESSAGES+set}" != set; } ||
 
19172
      { LC_MESSAGES=C; export LC_MESSAGES; }
 
19173
 
 
19174
 
 
19175
# Name of the executable.
 
19176
as_me=`(basename "$0") 2>/dev/null ||
 
19177
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
 
19178
         X"$0" : 'X\(//\)$' \| \
 
19179
         X"$0" : 'X\(/\)$' \| \
 
19180
         .     : '\(.\)' 2>/dev/null ||
 
19181
echo X/"$0" |
 
19182
    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
 
19183
          /^X\/\(\/\/\)$/{ s//\1/; q; }
 
19184
          /^X\/\(\/\).*/{ s//\1/; q; }
 
19185
          s/.*/./; q'`
 
19186
 
 
19187
# PATH needs CR, and LINENO needs CR and PATH.
 
19188
# Avoid depending upon Character Ranges.
 
19189
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
 
19190
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 
19191
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
 
19192
as_cr_digits='0123456789'
 
19193
as_cr_alnum=$as_cr_Letters$as_cr_digits
 
19194
 
 
19195
# The user is always right.
 
19196
if test "${PATH_SEPARATOR+set}" != set; then
 
19197
  echo "#! /bin/sh" >conftest.sh
 
19198
  echo  "exit 0"   >>conftest.sh
 
19199
  chmod +x conftest.sh
 
19200
  if (PATH=".;."; conftest.sh) >/dev/null 2>&1; then
 
19201
    PATH_SEPARATOR=';'
 
19202
  else
 
19203
    PATH_SEPARATOR=:
 
19204
  fi
 
19205
  rm -f conftest.sh
 
19206
fi
 
19207
 
 
19208
 
 
19209
  as_lineno_1=$LINENO
 
19210
  as_lineno_2=$LINENO
 
19211
  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 
19212
  test "x$as_lineno_1" != "x$as_lineno_2" &&
 
19213
  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 
19214
  # Find who we are.  Look in the path if we contain no path at all
 
19215
  # relative or not.
 
19216
  case $0 in
 
19217
    *[\\/]* ) as_myself=$0 ;;
 
19218
    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
19219
for as_dir in $PATH
 
19220
do
 
19221
  IFS=$as_save_IFS
 
19222
  test -z "$as_dir" && as_dir=.
 
19223
  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 
19224
done
 
19225
 
 
19226
       ;;
 
19227
  esac
 
19228
  # We did not find ourselves, most probably we were run as `sh COMMAND'
 
19229
  # in which case we are not to be found in the path.
 
19230
  if test "x$as_myself" = x; then
 
19231
    as_myself=$0
 
19232
  fi
 
19233
  if test ! -f "$as_myself"; then
 
19234
    { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
 
19235
echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
 
19236
   { (exit 1); exit 1; }; }
 
19237
  fi
 
19238
  case $CONFIG_SHELL in
 
19239
  '')
 
19240
    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
19241
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 
19242
do
 
19243
  IFS=$as_save_IFS
 
19244
  test -z "$as_dir" && as_dir=.
 
19245
  for as_base in sh bash ksh sh5; do
 
19246
         case $as_dir in
 
19247
         /*)
 
19248
           if ("$as_dir/$as_base" -c '
 
19249
  as_lineno_1=$LINENO
 
19250
  as_lineno_2=$LINENO
 
19251
  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 
19252
  test "x$as_lineno_1" != "x$as_lineno_2" &&
 
19253
  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 
19254
             CONFIG_SHELL=$as_dir/$as_base
 
19255
             export CONFIG_SHELL
 
19256
             exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 
19257
           fi;;
 
19258
         esac
 
19259
       done
 
19260
done
 
19261
;;
 
19262
  esac
 
19263
 
 
19264
  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 
19265
  # uniformly replaced by the line number.  The first 'sed' inserts a
 
19266
  # line-number line before each line; the second 'sed' does the real
 
19267
  # work.  The second script uses 'N' to pair each line-number line
 
19268
  # with the numbered line, and appends trailing '-' during
 
19269
  # substitution so that $LINENO is not a special case at line end.
 
19270
  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 
19271
  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 
19272
  sed '=' <$as_myself |
 
19273
    sed '
 
19274
      N
 
19275
      s,$,-,
 
19276
      : loop
 
19277
      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 
19278
      t loop
 
19279
      s,-$,,
 
19280
      s,^['$as_cr_digits']*\n,,
 
19281
    ' >$as_me.lineno &&
 
19282
  chmod +x $as_me.lineno ||
 
19283
    { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
 
19284
echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
 
19285
   { (exit 1); exit 1; }; }
 
19286
 
 
19287
  # Don't try to exec as it changes $[0], causing all sort of problems
 
19288
  # (the dirname of $[0] is not the place where we might find the
 
19289
  # original and so on.  Autoconf is especially sensible to this).
 
19290
  . ./$as_me.lineno
 
19291
  # Exit status is that of the last command.
 
19292
  exit
 
19293
}
 
19294
 
 
19295
 
 
19296
case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 
19297
  *c*,-n*) ECHO_N= ECHO_C='
 
19298
' ECHO_T='      ' ;;
 
19299
  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 
19300
  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 
19301
esac
 
19302
 
 
19303
if expr a : '\(a\)' >/dev/null 2>&1; then
 
19304
  as_expr=expr
 
19305
else
 
19306
  as_expr=false
 
19307
fi
 
19308
 
 
19309
rm -f conf$$ conf$$.exe conf$$.file
 
19310
echo >conf$$.file
 
19311
if ln -s conf$$.file conf$$ 2>/dev/null; then
 
19312
  # We could just check for DJGPP; but this test a) works b) is more generic
 
19313
  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 
19314
  if test -f conf$$.exe; then
 
19315
    # Don't use ln at all; we don't have any links
 
19316
    as_ln_s='cp -p'
 
19317
  else
 
19318
    as_ln_s='ln -s'
 
19319
  fi
 
19320
elif ln conf$$.file conf$$ 2>/dev/null; then
 
19321
  as_ln_s=ln
 
19322
else
 
19323
  as_ln_s='cp -p'
 
19324
fi
 
19325
rm -f conf$$ conf$$.exe conf$$.file
 
19326
 
 
19327
as_executable_p="test -f"
 
19328
 
 
19329
# Sed expression to map a string onto a valid CPP name.
 
19330
as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"
 
19331
 
 
19332
# Sed expression to map a string onto a valid variable name.
 
19333
as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g"
 
19334
 
 
19335
 
 
19336
# IFS
 
19337
# We need space, tab and new line, in precisely that order.
 
19338
as_nl='
 
19339
'
 
19340
IFS="   $as_nl"
 
19341
 
 
19342
# CDPATH.
 
19343
$as_unset CDPATH || test "${CDPATH+set}" != set || { CDPATH=$PATH_SEPARATOR; export CDPATH; }
 
19344
 
 
19345
exec 6>&1
 
19346
 
 
19347
# Open the log real soon, to keep \$[0] and so on meaningful, and to
 
19348
# report actual input values of CONFIG_FILES etc. instead of their
 
19349
# values after options handling.  Logging --version etc. is OK.
 
19350
exec 5>>config.log
 
19351
{
 
19352
  echo
 
19353
  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
 
19354
## Running $as_me. ##
 
19355
_ASBOX
 
19356
} >&5
 
19357
cat >&5 <<_CSEOF
 
19358
 
 
19359
This file was extended by PostgreSQL $as_me 8.0.3, which was
 
19360
generated by GNU Autoconf 2.53.  Invocation command line was
 
19361
 
 
19362
  CONFIG_FILES    = $CONFIG_FILES
 
19363
  CONFIG_HEADERS  = $CONFIG_HEADERS
 
19364
  CONFIG_LINKS    = $CONFIG_LINKS
 
19365
  CONFIG_COMMANDS = $CONFIG_COMMANDS
 
19366
  $ $0 $@
 
19367
 
 
19368
_CSEOF
 
19369
echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
 
19370
echo >&5
 
19371
_ACEOF
 
19372
 
 
19373
# Files that config.status was made for.
 
19374
if test -n "$ac_config_files"; then
 
19375
  echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
 
19376
fi
 
19377
 
 
19378
if test -n "$ac_config_headers"; then
 
19379
  echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
 
19380
fi
 
19381
 
 
19382
if test -n "$ac_config_links"; then
 
19383
  echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
 
19384
fi
 
19385
 
 
19386
if test -n "$ac_config_commands"; then
 
19387
  echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
 
19388
fi
 
19389
 
 
19390
cat >>$CONFIG_STATUS <<\_ACEOF
 
19391
 
 
19392
ac_cs_usage="\
 
19393
\`$as_me' instantiates files from templates according to the
 
19394
current configuration.
 
19395
 
 
19396
Usage: $0 [OPTIONS] [FILE]...
 
19397
 
 
19398
  -h, --help       print this help, then exit
 
19399
  -V, --version    print version number, then exit
 
19400
  -d, --debug      don't remove temporary files
 
19401
      --recheck    update $as_me by reconfiguring in the same conditions
 
19402
  --file=FILE[:TEMPLATE]
 
19403
                   instantiate the configuration file FILE
 
19404
  --header=FILE[:TEMPLATE]
 
19405
                   instantiate the configuration header FILE
 
19406
 
 
19407
Configuration files:
 
19408
$config_files
 
19409
 
 
19410
Configuration headers:
 
19411
$config_headers
 
19412
 
 
19413
Configuration links:
 
19414
$config_links
 
19415
 
 
19416
Configuration commands:
 
19417
$config_commands
 
19418
 
 
19419
Report bugs to <bug-autoconf@gnu.org>."
 
19420
_ACEOF
 
19421
 
 
19422
cat >>$CONFIG_STATUS <<_ACEOF
 
19423
ac_cs_version="\\
 
19424
PostgreSQL config.status 8.0.3
 
19425
configured by $0, generated by GNU Autoconf 2.53,
 
19426
  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
 
19427
 
 
19428
Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
 
19429
Free Software Foundation, Inc.
 
19430
This config.status script is free software; the Free Software Foundation
 
19431
gives unlimited permission to copy, distribute and modify it."
 
19432
srcdir=$srcdir
 
19433
_ACEOF
 
19434
 
 
19435
cat >>$CONFIG_STATUS <<\_ACEOF
 
19436
# If no file are specified by the user, then we need to provide default
 
19437
# value.  By we need to know if files were specified by the user.
 
19438
ac_need_defaults=:
 
19439
while test $# != 0
 
19440
do
 
19441
  case $1 in
 
19442
  --*=*)
 
19443
    ac_option=`expr "x$1" : 'x\([^=]*\)='`
 
19444
    ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
 
19445
    shift
 
19446
    set dummy "$ac_option" "$ac_optarg" ${1+"$@"}
 
19447
    shift
 
19448
    ;;
 
19449
  -*);;
 
19450
  *) # This is not an option, so the user has probably given explicit
 
19451
     # arguments.
 
19452
     ac_need_defaults=false;;
 
19453
  esac
 
19454
 
 
19455
  case $1 in
 
19456
  # Handling of the options.
 
19457
_ACEOF
 
19458
cat >>$CONFIG_STATUS <<_ACEOF
 
19459
  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
 
19460
    echo "running $SHELL $0 " $ac_configure_args " --no-create --no-recursion"
 
19461
    exec $SHELL $0 $ac_configure_args --no-create --no-recursion ;;
 
19462
_ACEOF
 
19463
cat >>$CONFIG_STATUS <<\_ACEOF
 
19464
  --version | --vers* | -V )
 
19465
    echo "$ac_cs_version"; exit 0 ;;
 
19466
  --he | --h)
 
19467
    # Conflict between --help and --header
 
19468
    { { echo "$as_me:$LINENO: error: ambiguous option: $1
 
19469
Try \`$0 --help' for more information." >&5
 
19470
echo "$as_me: error: ambiguous option: $1
 
19471
Try \`$0 --help' for more information." >&2;}
 
19472
   { (exit 1); exit 1; }; };;
 
19473
  --help | --hel | -h )
 
19474
    echo "$ac_cs_usage"; exit 0 ;;
 
19475
  --debug | --d* | -d )
 
19476
    debug=: ;;
 
19477
  --file | --fil | --fi | --f )
 
19478
    shift
 
19479
    CONFIG_FILES="$CONFIG_FILES $1"
 
19480
    ac_need_defaults=false;;
 
19481
  --header | --heade | --head | --hea )
 
19482
    shift
 
19483
    CONFIG_HEADERS="$CONFIG_HEADERS $1"
 
19484
    ac_need_defaults=false;;
 
19485
 
 
19486
  # This is an error.
 
19487
  -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
 
19488
Try \`$0 --help' for more information." >&5
 
19489
echo "$as_me: error: unrecognized option: $1
 
19490
Try \`$0 --help' for more information." >&2;}
 
19491
   { (exit 1); exit 1; }; } ;;
 
19492
 
 
19493
  *) ac_config_targets="$ac_config_targets $1" ;;
 
19494
 
 
19495
  esac
 
19496
  shift
 
19497
done
 
19498
 
 
19499
_ACEOF
 
19500
 
 
19501
 
 
19502
 
 
19503
 
 
19504
 
 
19505
cat >>$CONFIG_STATUS <<\_ACEOF
 
19506
for ac_config_target in $ac_config_targets
 
19507
do
 
19508
  case "$ac_config_target" in
 
19509
  # Handling of arguments.
 
19510
  "GNUmakefile" ) CONFIG_FILES="$CONFIG_FILES GNUmakefile" ;;
 
19511
  "src/Makefile.global" ) CONFIG_FILES="$CONFIG_FILES src/Makefile.global" ;;
 
19512
  "src/backend/port/tas.s" ) CONFIG_LINKS="$CONFIG_LINKS src/backend/port/tas.s:src/backend/port/tas/${tas_file}" ;;
 
19513
  "src/backend/port/dynloader.c" ) CONFIG_LINKS="$CONFIG_LINKS src/backend/port/dynloader.c:src/backend/port/dynloader/${template}.c" ;;
 
19514
  "src/backend/port/pg_sema.c" ) CONFIG_LINKS="$CONFIG_LINKS src/backend/port/pg_sema.c:${SEMA_IMPLEMENTATION}" ;;
 
19515
  "src/backend/port/pg_shmem.c" ) CONFIG_LINKS="$CONFIG_LINKS src/backend/port/pg_shmem.c:${SHMEM_IMPLEMENTATION}" ;;
 
19516
  "src/include/dynloader.h" ) CONFIG_LINKS="$CONFIG_LINKS src/include/dynloader.h:src/backend/port/dynloader/${template}.h" ;;
 
19517
  "src/include/pg_config_os.h" ) CONFIG_LINKS="$CONFIG_LINKS src/include/pg_config_os.h:src/include/port/${template}.h" ;;
 
19518
  "src/Makefile.port" ) CONFIG_LINKS="$CONFIG_LINKS src/Makefile.port:src/makefiles/Makefile.${template}" ;;
 
19519
  "check_win32_symlinks" ) CONFIG_COMMANDS="$CONFIG_COMMANDS check_win32_symlinks" ;;
 
19520
  "src/include/pg_config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS src/include/pg_config.h" ;;
 
19521
  *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
 
19522
echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
 
19523
   { (exit 1); exit 1; }; };;
 
19524
  esac
 
19525
done
 
19526
 
 
19527
# If the user did not use the arguments to specify the items to instantiate,
 
19528
# then the envvar interface is used.  Set only those that are not.
 
19529
# We use the long form for the default assignment because of an extremely
 
19530
# bizarre bug on SunOS 4.1.3.
 
19531
if $ac_need_defaults; then
 
19532
  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
 
19533
  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
 
19534
  test "${CONFIG_LINKS+set}" = set || CONFIG_LINKS=$config_links
 
19535
  test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
 
19536
fi
 
19537
 
 
19538
# Create a temporary directory, and hook for its removal unless debugging.
 
19539
$debug ||
 
19540
{
 
19541
  trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
 
19542
  trap '{ (exit 1); exit 1; }' 1 2 13 15
 
19543
}
 
19544
 
 
19545
# Create a (secure) tmp directory for tmp files.
 
19546
: ${TMPDIR=/tmp}
 
19547
{
 
19548
  tmp=`(umask 077 && mktemp -d -q "$TMPDIR/csXXXXXX") 2>/dev/null` &&
 
19549
  test -n "$tmp" && test -d "$tmp"
 
19550
}  ||
 
19551
{
 
19552
  tmp=$TMPDIR/cs$$-$RANDOM
 
19553
  (umask 077 && mkdir $tmp)
 
19554
} ||
 
19555
{
 
19556
   echo "$me: cannot create a temporary directory in $TMPDIR" >&2
 
19557
   { (exit 1); exit 1; }
 
19558
}
 
19559
 
 
19560
_ACEOF
 
19561
 
 
19562
cat >>$CONFIG_STATUS <<_ACEOF
 
19563
 
 
19564
#
 
19565
# CONFIG_FILES section.
 
19566
#
 
19567
 
 
19568
# No need to generate the scripts if there are no CONFIG_FILES.
 
19569
# This happens for instance when ./config.status config.h
 
19570
if test -n "\$CONFIG_FILES"; then
 
19571
  # Protect against being on the right side of a sed subst in config.status.
 
19572
  sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
 
19573
   s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
 
19574
s,@SHELL@,$SHELL,;t t
 
19575
s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
 
19576
s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
 
19577
s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
 
19578
s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
 
19579
s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
 
19580
s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
 
19581
s,@exec_prefix@,$exec_prefix,;t t
 
19582
s,@prefix@,$prefix,;t t
 
19583
s,@program_transform_name@,$program_transform_name,;t t
 
19584
s,@bindir@,$bindir,;t t
 
19585
s,@sbindir@,$sbindir,;t t
 
19586
s,@libexecdir@,$libexecdir,;t t
 
19587
s,@datadir@,$datadir,;t t
 
19588
s,@sysconfdir@,$sysconfdir,;t t
 
19589
s,@sharedstatedir@,$sharedstatedir,;t t
 
19590
s,@localstatedir@,$localstatedir,;t t
 
19591
s,@libdir@,$libdir,;t t
 
19592
s,@includedir@,$includedir,;t t
 
19593
s,@oldincludedir@,$oldincludedir,;t t
 
19594
s,@infodir@,$infodir,;t t
 
19595
s,@mandir@,$mandir,;t t
 
19596
s,@build_alias@,$build_alias,;t t
 
19597
s,@host_alias@,$host_alias,;t t
 
19598
s,@target_alias@,$target_alias,;t t
 
19599
s,@DEFS@,$DEFS,;t t
 
19600
s,@ECHO_C@,$ECHO_C,;t t
 
19601
s,@ECHO_N@,$ECHO_N,;t t
 
19602
s,@ECHO_T@,$ECHO_T,;t t
 
19603
s,@LIBS@,$LIBS,;t t
 
19604
s,@configure_args@,$configure_args,;t t
 
19605
s,@build@,$build,;t t
 
19606
s,@build_cpu@,$build_cpu,;t t
 
19607
s,@build_vendor@,$build_vendor,;t t
 
19608
s,@build_os@,$build_os,;t t
 
19609
s,@host@,$host,;t t
 
19610
s,@host_cpu@,$host_cpu,;t t
 
19611
s,@host_vendor@,$host_vendor,;t t
 
19612
s,@host_os@,$host_os,;t t
 
19613
s,@PORTNAME@,$PORTNAME,;t t
 
19614
s,@docdir@,$docdir,;t t
 
19615
s,@enable_nls@,$enable_nls,;t t
 
19616
s,@WANTED_LANGUAGES@,$WANTED_LANGUAGES,;t t
 
19617
s,@default_port@,$default_port,;t t
 
19618
s,@enable_shared@,$enable_shared,;t t
 
19619
s,@enable_rpath@,$enable_rpath,;t t
 
19620
s,@enable_debug@,$enable_debug,;t t
 
19621
s,@CC@,$CC,;t t
 
19622
s,@CFLAGS@,$CFLAGS,;t t
 
19623
s,@LDFLAGS@,$LDFLAGS,;t t
 
19624
s,@CPPFLAGS@,$CPPFLAGS,;t t
 
19625
s,@ac_ct_CC@,$ac_ct_CC,;t t
 
19626
s,@EXEEXT@,$EXEEXT,;t t
 
19627
s,@OBJEXT@,$OBJEXT,;t t
 
19628
s,@CPP@,$CPP,;t t
 
19629
s,@GCC@,$GCC,;t t
 
19630
s,@TAS@,$TAS,;t t
 
19631
s,@autodepend@,$autodepend,;t t
 
19632
s,@INCLUDES@,$INCLUDES,;t t
 
19633
s,@enable_thread_safety@,$enable_thread_safety,;t t
 
19634
s,@with_tcl@,$with_tcl,;t t
 
19635
s,@with_perl@,$with_perl,;t t
 
19636
s,@with_python@,$with_python,;t t
 
19637
s,@with_krb4@,$with_krb4,;t t
 
19638
s,@with_krb5@,$with_krb5,;t t
 
19639
s,@krb_srvtab@,$krb_srvtab,;t t
 
19640
s,@with_pam@,$with_pam,;t t
 
19641
s,@with_rendezvous@,$with_rendezvous,;t t
 
19642
s,@with_openssl@,$with_openssl,;t t
 
19643
s,@ELF_SYS@,$ELF_SYS,;t t
 
19644
s,@LDFLAGS_SL@,$LDFLAGS_SL,;t t
 
19645
s,@AWK@,$AWK,;t t
 
19646
s,@FLEX@,$FLEX,;t t
 
19647
s,@FLEXFLAGS@,$FLEXFLAGS,;t t
 
19648
s,@LN_S@,$LN_S,;t t
 
19649
s,@LD@,$LD,;t t
 
19650
s,@with_gnu_ld@,$with_gnu_ld,;t t
 
19651
s,@ld_R_works@,$ld_R_works,;t t
 
19652
s,@RANLIB@,$RANLIB,;t t
 
19653
s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
 
19654
s,@LORDER@,$LORDER,;t t
 
19655
s,@TAR@,$TAR,;t t
 
19656
s,@STRIP@,$STRIP,;t t
 
19657
s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t
 
19658
s,@STRIP_STATIC_LIB@,$STRIP_STATIC_LIB,;t t
 
19659
s,@STRIP_SHARED_LIB@,$STRIP_SHARED_LIB,;t t
 
19660
s,@YACC@,$YACC,;t t
 
19661
s,@YFLAGS@,$YFLAGS,;t t
 
19662
s,@PERL@,$PERL,;t t
 
19663
s,@perl_archlibexp@,$perl_archlibexp,;t t
 
19664
s,@perl_privlibexp@,$perl_privlibexp,;t t
 
19665
s,@perl_useshrplib@,$perl_useshrplib,;t t
 
19666
s,@perl_embed_ldflags@,$perl_embed_ldflags,;t t
 
19667
s,@PYTHON@,$PYTHON,;t t
 
19668
s,@python_version@,$python_version,;t t
 
19669
s,@python_configdir@,$python_configdir,;t t
 
19670
s,@python_includespec@,$python_includespec,;t t
 
19671
s,@python_libdir@,$python_libdir,;t t
 
19672
s,@python_libspec@,$python_libspec,;t t
 
19673
s,@python_additional_libs@,$python_additional_libs,;t t
 
19674
s,@LIBOBJS@,$LIBOBJS,;t t
 
19675
s,@HAVE_IPV6@,$HAVE_IPV6,;t t
 
19676
s,@acx_pthread_config@,$acx_pthread_config,;t t
 
19677
s,@PTHREAD_CC@,$PTHREAD_CC,;t t
 
19678
s,@PTHREAD_LIBS@,$PTHREAD_LIBS,;t t
 
19679
s,@PTHREAD_CFLAGS@,$PTHREAD_CFLAGS,;t t
 
19680
s,@HAVE_POSIX_SIGNALS@,$HAVE_POSIX_SIGNALS,;t t
 
19681
s,@MSGFMT@,$MSGFMT,;t t
 
19682
s,@MSGMERGE@,$MSGMERGE,;t t
 
19683
s,@XGETTEXT@,$XGETTEXT,;t t
 
19684
s,@localedir@,$localedir,;t t
 
19685
s,@TCLSH@,$TCLSH,;t t
 
19686
s,@TCL_CONFIG_SH@,$TCL_CONFIG_SH,;t t
 
19687
s,@TCL_INCLUDE_SPEC@,$TCL_INCLUDE_SPEC,;t t
 
19688
s,@TCL_LIB_FILE@,$TCL_LIB_FILE,;t t
 
19689
s,@TCL_LIBS@,$TCL_LIBS,;t t
 
19690
s,@TCL_LIB_SPEC@,$TCL_LIB_SPEC,;t t
 
19691
s,@TCL_SHARED_BUILD@,$TCL_SHARED_BUILD,;t t
 
19692
s,@TCL_SHLIB_LD_LIBS@,$TCL_SHLIB_LD_LIBS,;t t
 
19693
s,@NSGMLS@,$NSGMLS,;t t
 
19694
s,@JADE@,$JADE,;t t
 
19695
s,@have_docbook@,$have_docbook,;t t
 
19696
s,@DOCBOOKSTYLE@,$DOCBOOKSTYLE,;t t
 
19697
s,@COLLATEINDEX@,$COLLATEINDEX,;t t
 
19698
s,@SGMLSPL@,$SGMLSPL,;t t
 
19699
s,@vpath_build@,$vpath_build,;t t
 
19700
CEOF
 
19701
 
 
19702
_ACEOF
 
19703
 
 
19704
  cat >>$CONFIG_STATUS <<\_ACEOF
 
19705
  # Split the substitutions into bite-sized pieces for seds with
 
19706
  # small command number limits, like on Digital OSF/1 and HP-UX.
 
19707
  ac_max_sed_lines=48
 
19708
  ac_sed_frag=1 # Number of current file.
 
19709
  ac_beg=1 # First line for current file.
 
19710
  ac_end=$ac_max_sed_lines # Line after last line for current file.
 
19711
  ac_more_lines=:
 
19712
  ac_sed_cmds=
 
19713
  while $ac_more_lines; do
 
19714
    if test $ac_beg -gt 1; then
 
19715
      sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
 
19716
    else
 
19717
      sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
 
19718
    fi
 
19719
    if test ! -s $tmp/subs.frag; then
 
19720
      ac_more_lines=false
 
19721
    else
 
19722
      # The purpose of the label and of the branching condition is to
 
19723
      # speed up the sed processing (if there are no `@' at all, there
 
19724
      # is no need to browse any of the substitutions).
 
19725
      # These are the two extra sed commands mentioned above.
 
19726
      (echo ':t
 
19727
  /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
 
19728
      if test -z "$ac_sed_cmds"; then
 
19729
        ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
 
19730
      else
 
19731
        ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
 
19732
      fi
 
19733
      ac_sed_frag=`expr $ac_sed_frag + 1`
 
19734
      ac_beg=$ac_end
 
19735
      ac_end=`expr $ac_end + $ac_max_sed_lines`
 
19736
    fi
 
19737
  done
 
19738
  if test -z "$ac_sed_cmds"; then
 
19739
    ac_sed_cmds=cat
 
19740
  fi
 
19741
fi # test -n "$CONFIG_FILES"
 
19742
 
 
19743
_ACEOF
 
19744
cat >>$CONFIG_STATUS <<\_ACEOF
 
19745
for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
 
19746
  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
 
19747
  case $ac_file in
 
19748
  - | *:- | *:-:* ) # input from stdin
 
19749
        cat >$tmp/stdin
 
19750
        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
 
19751
        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
 
19752
  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
 
19753
        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
 
19754
  * )   ac_file_in=$ac_file.in ;;
 
19755
  esac
 
19756
 
 
19757
  # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
 
19758
  ac_dir=`(dirname "$ac_file") 2>/dev/null ||
 
19759
$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 
19760
         X"$ac_file" : 'X\(//\)[^/]' \| \
 
19761
         X"$ac_file" : 'X\(//\)$' \| \
 
19762
         X"$ac_file" : 'X\(/\)' \| \
 
19763
         .     : '\(.\)' 2>/dev/null ||
 
19764
echo X"$ac_file" |
 
19765
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 
19766
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 
19767
          /^X\(\/\/\)$/{ s//\1/; q; }
 
19768
          /^X\(\/\).*/{ s//\1/; q; }
 
19769
          s/.*/./; q'`
 
19770
  { case "$ac_dir" in
 
19771
  [\\/]* | ?:[\\/]* ) as_incr_dir=;;
 
19772
  *)                      as_incr_dir=.;;
 
19773
esac
 
19774
as_dummy="$ac_dir"
 
19775
for as_mkdir_dir in `IFS='/\\'; set X $as_dummy; shift; echo "$@"`; do
 
19776
  case $as_mkdir_dir in
 
19777
    # Skip DOS drivespec
 
19778
    ?:) as_incr_dir=$as_mkdir_dir ;;
 
19779
    *)
 
19780
      as_incr_dir=$as_incr_dir/$as_mkdir_dir
 
19781
      test -d "$as_incr_dir" ||
 
19782
        mkdir "$as_incr_dir" ||
 
19783
        { { echo "$as_me:$LINENO: error: cannot create \"$ac_dir\"" >&5
 
19784
echo "$as_me: error: cannot create \"$ac_dir\"" >&2;}
 
19785
   { (exit 1); exit 1; }; }
 
19786
    ;;
 
19787
  esac
 
19788
done; }
 
19789
 
 
19790
  ac_builddir=.
 
19791
 
 
19792
if test "$ac_dir" != .; then
 
19793
  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
 
19794
  # A "../" for each directory in $ac_dir_suffix.
 
19795
  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
 
19796
else
 
19797
  ac_dir_suffix= ac_top_builddir=
 
19798
fi
 
19799
 
 
19800
case $srcdir in
 
19801
  .)  # No --srcdir option.  We are building in place.
 
19802
    ac_srcdir=.
 
19803
    if test -z "$ac_top_builddir"; then
 
19804
       ac_top_srcdir=.
 
19805
    else
 
19806
       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
 
19807
    fi ;;
 
19808
  [\\/]* | ?:[\\/]* )  # Absolute path.
 
19809
    ac_srcdir=$srcdir$ac_dir_suffix;
 
19810
    ac_top_srcdir=$srcdir ;;
 
19811
  *) # Relative path.
 
19812
    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
 
19813
    ac_top_srcdir=$ac_top_builddir$srcdir ;;
 
19814
esac
 
19815
# Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be
 
19816
# absolute.
 
19817
ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd`
 
19818
ac_abs_top_builddir=`cd "$ac_dir" && cd $ac_top_builddir && pwd`
 
19819
ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd`
 
19820
ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd`
 
19821
 
 
19822
 
 
19823
 
 
19824
  if test x"$ac_file" != x-; then
 
19825
    { echo "$as_me:$LINENO: creating $ac_file" >&5
 
19826
echo "$as_me: creating $ac_file" >&6;}
 
19827
    rm -f "$ac_file"
 
19828
  fi
 
19829
  # Let's still pretend it is `configure' which instantiates (i.e., don't
 
19830
  # use $as_me), people would be surprised to read:
 
19831
  #    /* config.h.  Generated by config.status.  */
 
19832
  if test x"$ac_file" = x-; then
 
19833
    configure_input=
 
19834
  else
 
19835
    configure_input="$ac_file.  "
 
19836
  fi
 
19837
  configure_input=$configure_input"Generated from `echo $ac_file_in |
 
19838
                                     sed 's,.*/,,'` by configure."
 
19839
 
 
19840
  # First look for the input files in the build tree, otherwise in the
 
19841
  # src tree.
 
19842
  ac_file_inputs=`IFS=:
 
19843
    for f in $ac_file_in; do
 
19844
      case $f in
 
19845
      -) echo $tmp/stdin ;;
 
19846
      [\\/$]*)
 
19847
         # Absolute (can't be DOS-style, as IFS=:)
 
19848
         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
 
19849
echo "$as_me: error: cannot find input file: $f" >&2;}
 
19850
   { (exit 1); exit 1; }; }
 
19851
         echo $f;;
 
19852
      *) # Relative
 
19853
         if test -f "$f"; then
 
19854
           # Build tree
 
19855
           echo $f
 
19856
         elif test -f "$srcdir/$f"; then
 
19857
           # Source tree
 
19858
           echo $srcdir/$f
 
19859
         else
 
19860
           # /dev/null tree
 
19861
           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
 
19862
echo "$as_me: error: cannot find input file: $f" >&2;}
 
19863
   { (exit 1); exit 1; }; }
 
19864
         fi;;
 
19865
      esac
 
19866
    done` || { (exit 1); exit 1; }
 
19867
_ACEOF
 
19868
cat >>$CONFIG_STATUS <<_ACEOF
 
19869
  sed "$ac_vpsub
 
19870
$extrasub
 
19871
_ACEOF
 
19872
cat >>$CONFIG_STATUS <<\_ACEOF
 
19873
:t
 
19874
/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
 
19875
s,@configure_input@,$configure_input,;t t
 
19876
s,@srcdir@,$ac_srcdir,;t t
 
19877
s,@abs_srcdir@,$ac_abs_srcdir,;t t
 
19878
s,@top_srcdir@,$ac_top_srcdir,;t t
 
19879
s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
 
19880
s,@builddir@,$ac_builddir,;t t
 
19881
s,@abs_builddir@,$ac_abs_builddir,;t t
 
19882
s,@top_builddir@,$ac_top_builddir,;t t
 
19883
s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
 
19884
" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
 
19885
  rm -f $tmp/stdin
 
19886
  if test x"$ac_file" != x-; then
 
19887
    mv $tmp/out $ac_file
 
19888
  else
 
19889
    cat $tmp/out
 
19890
    rm -f $tmp/out
 
19891
  fi
 
19892
 
 
19893
done
 
19894
_ACEOF
 
19895
cat >>$CONFIG_STATUS <<\_ACEOF
 
19896
 
 
19897
#
 
19898
# CONFIG_HEADER section.
 
19899
#
 
19900
 
 
19901
# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
 
19902
# NAME is the cpp macro being defined and VALUE is the value it is being given.
 
19903
#
 
19904
# ac_d sets the value in "#define NAME VALUE" lines.
 
19905
ac_dA='s,^\([   ]*\)#\([        ]*define[       ][      ]*\)'
 
19906
ac_dB='[        ].*$,\1#\2'
 
19907
ac_dC=' '
 
19908
ac_dD=',;t'
 
19909
# ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
 
19910
ac_uA='s,^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
 
19911
ac_uB='$,\1#\2define\3'
 
19912
ac_uC=' '
 
19913
ac_uD=',;t'
 
19914
 
 
19915
for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue
 
19916
  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
 
19917
  case $ac_file in
 
19918
  - | *:- | *:-:* ) # input from stdin
 
19919
        cat >$tmp/stdin
 
19920
        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
 
19921
        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
 
19922
  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
 
19923
        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
 
19924
  * )   ac_file_in=$ac_file.in ;;
 
19925
  esac
 
19926
 
 
19927
  test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5
 
19928
echo "$as_me: creating $ac_file" >&6;}
 
19929
 
 
19930
  # First look for the input files in the build tree, otherwise in the
 
19931
  # src tree.
 
19932
  ac_file_inputs=`IFS=:
 
19933
    for f in $ac_file_in; do
 
19934
      case $f in
 
19935
      -) echo $tmp/stdin ;;
 
19936
      [\\/$]*)
 
19937
         # Absolute (can't be DOS-style, as IFS=:)
 
19938
         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
 
19939
echo "$as_me: error: cannot find input file: $f" >&2;}
 
19940
   { (exit 1); exit 1; }; }
 
19941
         echo $f;;
 
19942
      *) # Relative
 
19943
         if test -f "$f"; then
 
19944
           # Build tree
 
19945
           echo $f
 
19946
         elif test -f "$srcdir/$f"; then
 
19947
           # Source tree
 
19948
           echo $srcdir/$f
 
19949
         else
 
19950
           # /dev/null tree
 
19951
           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
 
19952
echo "$as_me: error: cannot find input file: $f" >&2;}
 
19953
   { (exit 1); exit 1; }; }
 
19954
         fi;;
 
19955
      esac
 
19956
    done` || { (exit 1); exit 1; }
 
19957
  # Remove the trailing spaces.
 
19958
  sed 's/[      ]*$//' $ac_file_inputs >$tmp/in
 
19959
 
 
19960
_ACEOF
 
19961
 
 
19962
# Transform confdefs.h into two sed scripts, `conftest.defines' and
 
19963
# `conftest.undefs', that substitutes the proper values into
 
19964
# config.h.in to produce config.h.  The first handles `#define'
 
19965
# templates, and the second `#undef' templates.
 
19966
# And first: Protect against being on the right side of a sed subst in
 
19967
# config.status.  Protect against being in an unquoted here document
 
19968
# in config.status.
 
19969
rm -f conftest.defines conftest.undefs
 
19970
# Using a here document instead of a string reduces the quoting nightmare.
 
19971
# Putting comments in sed scripts is not portable.
 
19972
#
 
19973
# `end' is used to avoid that the second main sed command (meant for
 
19974
# 0-ary CPP macros) applies to n-ary macro definitions.
 
19975
# See the Autoconf documentation for `clear'.
 
19976
cat >confdef2sed.sed <<\_ACEOF
 
19977
s/[\\&,]/\\&/g
 
19978
s,[\\$`],\\&,g
 
19979
t clear
 
19980
: clear
 
19981
s,^[    ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
 
19982
t end
 
19983
s,^[    ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
 
19984
: end
 
19985
_ACEOF
 
19986
# If some macros were called several times there might be several times
 
19987
# the same #defines, which is useless.  Nevertheless, we may not want to
 
19988
# sort them, since we want the *last* AC-DEFINE to be honored.
 
19989
uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines
 
19990
sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs
 
19991
rm -f confdef2sed.sed
 
19992
 
 
19993
# This sed command replaces #undef with comments.  This is necessary, for
 
19994
# example, in the case of _POSIX_SOURCE, which is predefined and required
 
19995
# on some systems where configure will not decide to define it.
 
19996
cat >>conftest.undefs <<\_ACEOF
 
19997
s,^[    ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
 
19998
_ACEOF
 
19999
 
 
20000
# Break up conftest.defines because some shells have a limit on the size
 
20001
# of here documents, and old seds have small limits too (100 cmds).
 
20002
echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
 
20003
echo '  if egrep "^[    ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
 
20004
echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
 
20005
echo '  :' >>$CONFIG_STATUS
 
20006
rm -f conftest.tail
 
20007
while grep . conftest.defines >/dev/null
 
20008
do
 
20009
  # Write a limited-size here document to $tmp/defines.sed.
 
20010
  echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
 
20011
  # Speed up: don't consider the non `#define' lines.
 
20012
  echo '/^[     ]*#[    ]*define/!b' >>$CONFIG_STATUS
 
20013
  # Work around the forget-to-reset-the-flag bug.
 
20014
  echo 't clr' >>$CONFIG_STATUS
 
20015
  echo ': clr' >>$CONFIG_STATUS
 
20016
  sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS
 
20017
  echo 'CEOF
 
20018
  sed -f $tmp/defines.sed $tmp/in >$tmp/out
 
20019
  rm -f $tmp/in
 
20020
  mv $tmp/out $tmp/in
 
20021
' >>$CONFIG_STATUS
 
20022
  sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail
 
20023
  rm -f conftest.defines
 
20024
  mv conftest.tail conftest.defines
 
20025
done
 
20026
rm -f conftest.defines
 
20027
echo '  fi # egrep' >>$CONFIG_STATUS
 
20028
echo >>$CONFIG_STATUS
 
20029
 
 
20030
# Break up conftest.undefs because some shells have a limit on the size
 
20031
# of here documents, and old seds have small limits too (100 cmds).
 
20032
echo '  # Handle all the #undef templates' >>$CONFIG_STATUS
 
20033
rm -f conftest.tail
 
20034
while grep . conftest.undefs >/dev/null
 
20035
do
 
20036
  # Write a limited-size here document to $tmp/undefs.sed.
 
20037
  echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
 
20038
  # Speed up: don't consider the non `#undef'
 
20039
  echo '/^[     ]*#[    ]*undef/!b' >>$CONFIG_STATUS
 
20040
  # Work around the forget-to-reset-the-flag bug.
 
20041
  echo 't clr' >>$CONFIG_STATUS
 
20042
  echo ': clr' >>$CONFIG_STATUS
 
20043
  sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS
 
20044
  echo 'CEOF
 
20045
  sed -f $tmp/undefs.sed $tmp/in >$tmp/out
 
20046
  rm -f $tmp/in
 
20047
  mv $tmp/out $tmp/in
 
20048
' >>$CONFIG_STATUS
 
20049
  sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail
 
20050
  rm -f conftest.undefs
 
20051
  mv conftest.tail conftest.undefs
 
20052
done
 
20053
rm -f conftest.undefs
 
20054
 
 
20055
cat >>$CONFIG_STATUS <<\_ACEOF
 
20056
  # Let's still pretend it is `configure' which instantiates (i.e., don't
 
20057
  # use $as_me), people would be surprised to read:
 
20058
  #    /* config.h.  Generated by config.status.  */
 
20059
  if test x"$ac_file" = x-; then
 
20060
    echo "/* Generated by configure.  */" >$tmp/config.h
 
20061
  else
 
20062
    echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h
 
20063
  fi
 
20064
  cat $tmp/in >>$tmp/config.h
 
20065
  rm -f $tmp/in
 
20066
  if test x"$ac_file" != x-; then
 
20067
    if cmp -s $ac_file $tmp/config.h 2>/dev/null; then
 
20068
      { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
 
20069
echo "$as_me: $ac_file is unchanged" >&6;}
 
20070
    else
 
20071
      ac_dir=`(dirname "$ac_file") 2>/dev/null ||
 
20072
$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 
20073
         X"$ac_file" : 'X\(//\)[^/]' \| \
 
20074
         X"$ac_file" : 'X\(//\)$' \| \
 
20075
         X"$ac_file" : 'X\(/\)' \| \
 
20076
         .     : '\(.\)' 2>/dev/null ||
 
20077
echo X"$ac_file" |
 
20078
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 
20079
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 
20080
          /^X\(\/\/\)$/{ s//\1/; q; }
 
20081
          /^X\(\/\).*/{ s//\1/; q; }
 
20082
          s/.*/./; q'`
 
20083
      { case "$ac_dir" in
 
20084
  [\\/]* | ?:[\\/]* ) as_incr_dir=;;
 
20085
  *)                      as_incr_dir=.;;
 
20086
esac
 
20087
as_dummy="$ac_dir"
 
20088
for as_mkdir_dir in `IFS='/\\'; set X $as_dummy; shift; echo "$@"`; do
 
20089
  case $as_mkdir_dir in
 
20090
    # Skip DOS drivespec
 
20091
    ?:) as_incr_dir=$as_mkdir_dir ;;
 
20092
    *)
 
20093
      as_incr_dir=$as_incr_dir/$as_mkdir_dir
 
20094
      test -d "$as_incr_dir" ||
 
20095
        mkdir "$as_incr_dir" ||
 
20096
        { { echo "$as_me:$LINENO: error: cannot create \"$ac_dir\"" >&5
 
20097
echo "$as_me: error: cannot create \"$ac_dir\"" >&2;}
 
20098
   { (exit 1); exit 1; }; }
 
20099
    ;;
 
20100
  esac
 
20101
done; }
 
20102
 
 
20103
      rm -f $ac_file
 
20104
      mv $tmp/config.h $ac_file
 
20105
    fi
 
20106
  else
 
20107
    cat $tmp/config.h
 
20108
    rm -f $tmp/config.h
 
20109
  fi
 
20110
  # Run the commands associated with the file.
 
20111
  case $ac_file in
 
20112
    src/include/pg_config.h )
 
20113
# Update timestamp for pg_config.h (see Makefile.global)
 
20114
echo >src/include/stamp-h
 
20115
 ;;
 
20116
  esac
 
20117
done
 
20118
_ACEOF
 
20119
cat >>$CONFIG_STATUS <<\_ACEOF
 
20120
 
 
20121
#
 
20122
# CONFIG_LINKS section.
 
20123
#
 
20124
 
 
20125
for ac_file in : $CONFIG_LINKS; do test "x$ac_file" = x: && continue
 
20126
  ac_dest=`echo "$ac_file" | sed 's,:.*,,'`
 
20127
  ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`
 
20128
 
 
20129
  { echo "$as_me:$LINENO: linking $srcdir/$ac_source to $ac_dest" >&5
 
20130
echo "$as_me: linking $srcdir/$ac_source to $ac_dest" >&6;}
 
20131
 
 
20132
  if test ! -r $srcdir/$ac_source; then
 
20133
    { { echo "$as_me:$LINENO: error: $srcdir/$ac_source: file not found" >&5
 
20134
echo "$as_me: error: $srcdir/$ac_source: file not found" >&2;}
 
20135
   { (exit 1); exit 1; }; }
 
20136
  fi
 
20137
  rm -f $ac_dest
 
20138
 
 
20139
  # Make relative symlinks.
 
20140
  ac_dest_dir=`(dirname "$ac_dest") 2>/dev/null ||
 
20141
$as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 
20142
         X"$ac_dest" : 'X\(//\)[^/]' \| \
 
20143
         X"$ac_dest" : 'X\(//\)$' \| \
 
20144
         X"$ac_dest" : 'X\(/\)' \| \
 
20145
         .     : '\(.\)' 2>/dev/null ||
 
20146
echo X"$ac_dest" |
 
20147
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 
20148
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 
20149
          /^X\(\/\/\)$/{ s//\1/; q; }
 
20150
          /^X\(\/\).*/{ s//\1/; q; }
 
20151
          s/.*/./; q'`
 
20152
  { case "$ac_dest_dir" in
 
20153
  [\\/]* | ?:[\\/]* ) as_incr_dir=;;
 
20154
  *)                      as_incr_dir=.;;
 
20155
esac
 
20156
as_dummy="$ac_dest_dir"
 
20157
for as_mkdir_dir in `IFS='/\\'; set X $as_dummy; shift; echo "$@"`; do
 
20158
  case $as_mkdir_dir in
 
20159
    # Skip DOS drivespec
 
20160
    ?:) as_incr_dir=$as_mkdir_dir ;;
 
20161
    *)
 
20162
      as_incr_dir=$as_incr_dir/$as_mkdir_dir
 
20163
      test -d "$as_incr_dir" ||
 
20164
        mkdir "$as_incr_dir" ||
 
20165
        { { echo "$as_me:$LINENO: error: cannot create \"$ac_dest_dir\"" >&5
 
20166
echo "$as_me: error: cannot create \"$ac_dest_dir\"" >&2;}
 
20167
   { (exit 1); exit 1; }; }
 
20168
    ;;
 
20169
  esac
 
20170
done; }
 
20171
 
 
20172
  ac_builddir=.
 
20173
 
 
20174
if test "$ac_dest_dir" != .; then
 
20175
  ac_dir_suffix=/`echo "$ac_dest_dir" | sed 's,^\.[\\/],,'`
 
20176
  # A "../" for each directory in $ac_dir_suffix.
 
20177
  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
 
20178
else
 
20179
  ac_dir_suffix= ac_top_builddir=
 
20180
fi
 
20181
 
 
20182
case $srcdir in
 
20183
  .)  # No --srcdir option.  We are building in place.
 
20184
    ac_srcdir=.
 
20185
    if test -z "$ac_top_builddir"; then
 
20186
       ac_top_srcdir=.
 
20187
    else
 
20188
       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
 
20189
    fi ;;
 
20190
  [\\/]* | ?:[\\/]* )  # Absolute path.
 
20191
    ac_srcdir=$srcdir$ac_dir_suffix;
 
20192
    ac_top_srcdir=$srcdir ;;
 
20193
  *) # Relative path.
 
20194
    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
 
20195
    ac_top_srcdir=$ac_top_builddir$srcdir ;;
 
20196
esac
 
20197
# Don't blindly perform a `cd "$ac_dest_dir"/$ac_foo && pwd` since $ac_foo can be
 
20198
# absolute.
 
20199
ac_abs_builddir=`cd "$ac_dest_dir" && cd $ac_builddir && pwd`
 
20200
ac_abs_top_builddir=`cd "$ac_dest_dir" && cd $ac_top_builddir && pwd`
 
20201
ac_abs_srcdir=`cd "$ac_dest_dir" && cd $ac_srcdir && pwd`
 
20202
ac_abs_top_srcdir=`cd "$ac_dest_dir" && cd $ac_top_srcdir && pwd`
 
20203
 
 
20204
 
 
20205
  case $srcdir in
 
20206
  [\\/$]* | ?:[\\/]* ) ac_rel_source=$srcdir/$ac_source ;;
 
20207
      *) ac_rel_source=$ac_top_builddir$srcdir/$ac_source ;;
 
20208
  esac
 
20209
 
 
20210
  # Make a symlink if possible; otherwise try a hard link.
 
20211
  ln -s $ac_rel_source $ac_dest 2>/dev/null ||
 
20212
    ln $srcdir/$ac_source $ac_dest ||
 
20213
    { { echo "$as_me:$LINENO: error: cannot link $ac_dest to $srcdir/$ac_source" >&5
 
20214
echo "$as_me: error: cannot link $ac_dest to $srcdir/$ac_source" >&2;}
 
20215
   { (exit 1); exit 1; }; }
 
20216
done
 
20217
_ACEOF
 
20218
cat >>$CONFIG_STATUS <<\_ACEOF
 
20219
 
 
20220
#
 
20221
# CONFIG_COMMANDS section.
 
20222
#
 
20223
for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue
 
20224
  ac_dest=`echo "$ac_file" | sed 's,:.*,,'`
 
20225
  ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`
 
20226
  ac_dir=`(dirname "$ac_dest") 2>/dev/null ||
 
20227
$as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 
20228
         X"$ac_dest" : 'X\(//\)[^/]' \| \
 
20229
         X"$ac_dest" : 'X\(//\)$' \| \
 
20230
         X"$ac_dest" : 'X\(/\)' \| \
 
20231
         .     : '\(.\)' 2>/dev/null ||
 
20232
echo X"$ac_dest" |
 
20233
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 
20234
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 
20235
          /^X\(\/\/\)$/{ s//\1/; q; }
 
20236
          /^X\(\/\).*/{ s//\1/; q; }
 
20237
          s/.*/./; q'`
 
20238
  ac_builddir=.
 
20239
 
 
20240
if test "$ac_dir" != .; then
 
20241
  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
 
20242
  # A "../" for each directory in $ac_dir_suffix.
 
20243
  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
 
20244
else
 
20245
  ac_dir_suffix= ac_top_builddir=
 
20246
fi
 
20247
 
 
20248
case $srcdir in
 
20249
  .)  # No --srcdir option.  We are building in place.
 
20250
    ac_srcdir=.
 
20251
    if test -z "$ac_top_builddir"; then
 
20252
       ac_top_srcdir=.
 
20253
    else
 
20254
       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
 
20255
    fi ;;
 
20256
  [\\/]* | ?:[\\/]* )  # Absolute path.
 
20257
    ac_srcdir=$srcdir$ac_dir_suffix;
 
20258
    ac_top_srcdir=$srcdir ;;
 
20259
  *) # Relative path.
 
20260
    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
 
20261
    ac_top_srcdir=$ac_top_builddir$srcdir ;;
 
20262
esac
 
20263
# Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be
 
20264
# absolute.
 
20265
ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd`
 
20266
ac_abs_top_builddir=`cd "$ac_dir" && cd $ac_top_builddir && pwd`
 
20267
ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd`
 
20268
ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd`
 
20269
 
 
20270
 
 
20271
  { echo "$as_me:$LINENO: executing $ac_dest commands" >&5
 
20272
echo "$as_me: executing $ac_dest commands" >&6;}
 
20273
  case $ac_dest in
 
20274
    check_win32_symlinks )
 
20275
# Links sometimes fail undetected on Mingw -
 
20276
# so here we detect it and warn the user
 
20277
for FILE in $CONFIG_LINKS
 
20278
 do
 
20279
        # test -e works for symlinks in the MinGW console
 
20280
        test -e `expr "$FILE" : '\([^:]*\)'` || { echo "$as_me:$LINENO: WARNING: *** link for $FILE - please fix by hand" >&5
 
20281
echo "$as_me: WARNING: *** link for $FILE - please fix by hand" >&2;}
 
20282
 done
 
20283
 ;;
 
20284
  esac
 
20285
done
 
20286
_ACEOF
 
20287
 
 
20288
cat >>$CONFIG_STATUS <<\_ACEOF
 
20289
 
 
20290
{ (exit 0); exit 0; }
 
20291
_ACEOF
 
20292
chmod +x $CONFIG_STATUS
 
20293
ac_clean_files=$ac_clean_files_save
 
20294
 
 
20295
 
 
20296
# configure is writing to config.log, and then calls config.status.
 
20297
# config.status does its own redirection, appending to config.log.
 
20298
# Unfortunately, on DOS this fails, as config.log is still kept open
 
20299
# by configure, so config.status won't be able to write to it; its
 
20300
# output is simply discarded.  So we exec the FD to /dev/null,
 
20301
# effectively closing config.log, so it can be properly (re)opened and
 
20302
# appended to by config.status.  When coming back to configure, we
 
20303
# need to make the FD available again.
 
20304
if test "$no_create" != yes; then
 
20305
  ac_cs_success=:
 
20306
  exec 5>/dev/null
 
20307
  $SHELL $CONFIG_STATUS || ac_cs_success=false
 
20308
  exec 5>>config.log
 
20309
  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
 
20310
  # would make configure fail if this is the last instruction.
 
20311
  $ac_cs_success || { (exit 1); exit 1; }
 
20312
fi
 
20313
 
 
20314