~ubuntu-branches/ubuntu/dapper/groff/dapper

« back to all changes in this revision

Viewing changes to configure

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson
  • Date: 2002-03-17 04:11:50 UTC
  • Revision ID: james.westby@ubuntu.com-20020317041150-wkgfawjc3gxlk0o5
Tags: upstream-1.17.2
ImportĀ upstreamĀ versionĀ 1.17.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
#! /bin/sh
 
2
# Guess values for system-dependent variables and create Makefiles.
 
3
# Generated by Autoconf 2.50.
 
4
#
 
5
# Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
 
6
# Free Software Foundation, Inc.
 
7
# This configure script is free software; the Free Software Foundation
 
8
# gives unlimited permission to copy, distribute and modify it.
 
9
 
 
10
# Be Bourne compatible
 
11
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
 
12
  emulate sh
 
13
  NULLCMD=:
 
14
elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
 
15
  set -o posix
 
16
fi
 
17
 
 
18
# Name of the executable.
 
19
as_me=`echo "$0" |sed 's,.*[\\/],,'`
 
20
 
 
21
if expr a : '\(a\)' >/dev/null 2>&1; then
 
22
  as_expr=expr
 
23
else
 
24
  as_expr=false
 
25
fi
 
26
 
 
27
rm -f conf$$ conf$$.exe conf$$.file
 
28
echo >conf$$.file
 
29
if ln -s conf$$.file conf$$ 2>/dev/null; then
 
30
  # We could just check for DJGPP; but this test a) works b) is more generic
 
31
  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 
32
  if test -f conf$$.exe; then
 
33
    # Don't use ln at all; we don't have any links
 
34
    as_ln_s='cp -p'
 
35
  else
 
36
    as_ln_s='ln -s'
 
37
  fi
 
38
elif ln conf$$.file conf$$ 2>/dev/null; then
 
39
  as_ln_s=ln
 
40
else
 
41
  as_ln_s='cp -p'
 
42
fi
 
43
rm -f conf$$ conf$$.exe conf$$.file
 
44
 
 
45
as_executable_p="test -f"
 
46
 
 
47
# Support unset when possible.
 
48
if (FOO=FOO; unset FOO) >/dev/null 2>&1; then
 
49
  as_unset=unset
 
50
else
 
51
  as_unset=false
 
52
fi
 
53
 
 
54
# NLS nuisances.
 
55
$as_unset LANG || test "${LANG+set}" != set || { LANG=C; export LANG; }
 
56
$as_unset LC_ALL || test "${LC_ALL+set}" != set || { LC_ALL=C; export LC_ALL; }
 
57
$as_unset LC_TIME || test "${LC_TIME+set}" != set || { LC_TIME=C; export LC_TIME; }
 
58
$as_unset LC_CTYPE || test "${LC_CTYPE+set}" != set || { LC_CTYPE=C; export LC_CTYPE; }
 
59
$as_unset LANGUAGE || test "${LANGUAGE+set}" != set || { LANGUAGE=C; export LANGUAGE; }
 
60
$as_unset LC_COLLATE || test "${LC_COLLATE+set}" != set || { LC_COLLATE=C; export LC_COLLATE; }
 
61
$as_unset LC_NUMERIC || test "${LC_NUMERIC+set}" != set || { LC_NUMERIC=C; export LC_NUMERIC; }
 
62
$as_unset LC_MESSAGES || test "${LC_MESSAGES+set}" != set || { LC_MESSAGES=C; export LC_MESSAGES; }
 
63
 
 
64
# IFS
 
65
# We need space, tab and new line, in precisely that order.
 
66
as_nl='
 
67
'
 
68
IFS="   $as_nl"
 
69
 
 
70
# CDPATH.
 
71
$as_unset CDPATH || test "${CDPATH+set}" != set || { CDPATH=:; export CDPATH; }
 
72
 
 
73
# Name of the host.
 
74
# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 
75
# so uname gets run too.
 
76
ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 
77
 
 
78
exec 6>&1
 
79
 
 
80
#
 
81
# Initializations.
 
82
#
 
83
ac_default_prefix=/usr/local
 
84
cross_compiling=no
 
85
subdirs=
 
86
MFLAGS= MAKEFLAGS=
 
87
SHELL=${CONFIG_SHELL-/bin/sh}
 
88
 
 
89
# Maximum number of lines to put in a shell here document.
 
90
# This variable seems obsolete.  It should probably be removed, and
 
91
# only ac_max_sed_lines should be used.
 
92
: ${ac_max_here_lines=38}
 
93
 
 
94
# Avoid depending upon Character Ranges.
 
95
ac_cr_az='abcdefghijklmnopqrstuvwxyz'
 
96
ac_cr_AZ='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 
97
ac_cr_09='0123456789'
 
98
ac_cr_alnum=$ac_cr_az$ac_cr_AZ$ac_cr_09
 
99
 
 
100
# Sed expression to map a string onto a valid sh and CPP variable names.
 
101
ac_tr_sh="sed y%*+%pp%;s%[^_$ac_cr_alnum]%_%g"
 
102
ac_tr_cpp="sed y%*$ac_cr_az%P$ac_cr_AZ%;s%[^_$ac_cr_alnum]%_%g"
 
103
 
 
104
ac_unique_file="src/roff/groff/groff.cc"
 
105
 
 
106
# Initialize some variables set by options.
 
107
ac_init_help=
 
108
ac_init_version=false
 
109
# The variables have the same names as the options, with
 
110
# dashes changed to underlines.
 
111
cache_file=/dev/null
 
112
exec_prefix=NONE
 
113
no_create=
 
114
no_recursion=
 
115
prefix=NONE
 
116
program_prefix=NONE
 
117
program_suffix=NONE
 
118
program_transform_name=s,x,x,
 
119
silent=
 
120
site=
 
121
srcdir=
 
122
verbose=
 
123
x_includes=NONE
 
124
x_libraries=NONE
 
125
 
 
126
# Installation directory options.
 
127
# These are left unexpanded so users can "make install exec_prefix=/foo"
 
128
# and all the variables that are supposed to be based on exec_prefix
 
129
# by default will actually change.
 
130
# Use braces instead of parens because sh, perl, etc. also accept them.
 
131
bindir='${exec_prefix}/bin'
 
132
sbindir='${exec_prefix}/sbin'
 
133
libexecdir='${exec_prefix}/libexec'
 
134
datadir='${prefix}/share'
 
135
sysconfdir='${prefix}/etc'
 
136
sharedstatedir='${prefix}/com'
 
137
localstatedir='${prefix}/var'
 
138
libdir='${exec_prefix}/lib'
 
139
includedir='${prefix}/include'
 
140
oldincludedir='/usr/include'
 
141
infodir='${prefix}/info'
 
142
mandir='${prefix}/man'
 
143
 
 
144
# Identity of this package.
 
145
PACKAGE_NAME=
 
146
PACKAGE_TARNAME=
 
147
PACKAGE_VERSION=
 
148
PACKAGE_STRING=
 
149
PACKAGE_BUGREPORT=
 
150
 
 
151
ac_prev=
 
152
for ac_option
 
153
do
 
154
  # If the previous option needs an argument, assign it.
 
155
  if test -n "$ac_prev"; then
 
156
    eval "$ac_prev=\$ac_option"
 
157
    ac_prev=
 
158
    continue
 
159
  fi
 
160
 
 
161
  ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 
162
 
 
163
  # Accept the important Cygnus configure options, so we can diagnose typos.
 
164
 
 
165
  case $ac_option in
 
166
 
 
167
  -bindir | --bindir | --bindi | --bind | --bin | --bi)
 
168
    ac_prev=bindir ;;
 
169
  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 
170
    bindir=$ac_optarg ;;
 
171
 
 
172
  -build | --build | --buil | --bui | --bu)
 
173
    ac_prev=build_alias ;;
 
174
  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 
175
    build_alias=$ac_optarg ;;
 
176
 
 
177
  -cache-file | --cache-file | --cache-fil | --cache-fi \
 
178
  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 
179
    ac_prev=cache_file ;;
 
180
  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 
181
  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 
182
    cache_file=$ac_optarg ;;
 
183
 
 
184
  --config-cache | -C)
 
185
    cache_file=config.cache ;;
 
186
 
 
187
  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 
188
    ac_prev=datadir ;;
 
189
  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 
190
  | --da=*)
 
191
    datadir=$ac_optarg ;;
 
192
 
 
193
  -disable-* | --disable-*)
 
194
    ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 
195
    # Reject names that are not valid shell variable names.
 
196
    expr "x$ac_feature" : ".*[^-_$ac_cr_alnum]" >/dev/null &&
 
197
      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 
198
   { (exit 1); exit 1; }; }
 
199
    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 
200
    eval "enable_$ac_feature=no" ;;
 
201
 
 
202
  -enable-* | --enable-*)
 
203
    ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 
204
    # Reject names that are not valid shell variable names.
 
205
    expr "x$ac_feature" : ".*[^-_$ac_cr_alnum]" >/dev/null &&
 
206
      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 
207
   { (exit 1); exit 1; }; }
 
208
    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 
209
    case $ac_option in
 
210
      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 
211
      *) ac_optarg=yes ;;
 
212
    esac
 
213
    eval "enable_$ac_feature='$ac_optarg'" ;;
 
214
 
 
215
  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 
216
  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 
217
  | --exec | --exe | --ex)
 
218
    ac_prev=exec_prefix ;;
 
219
  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 
220
  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 
221
  | --exec=* | --exe=* | --ex=*)
 
222
    exec_prefix=$ac_optarg ;;
 
223
 
 
224
  -gas | --gas | --ga | --g)
 
225
    # Obsolete; use --with-gas.
 
226
    with_gas=yes ;;
 
227
 
 
228
  -help | --help | --hel | --he | -h)
 
229
    ac_init_help=long ;;
 
230
  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 
231
    ac_init_help=recursive ;;
 
232
  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 
233
    ac_init_help=short ;;
 
234
 
 
235
  -host | --host | --hos | --ho)
 
236
    ac_prev=host_alias ;;
 
237
  -host=* | --host=* | --hos=* | --ho=*)
 
238
    host_alias=$ac_optarg ;;
 
239
 
 
240
  -includedir | --includedir | --includedi | --included | --include \
 
241
  | --includ | --inclu | --incl | --inc)
 
242
    ac_prev=includedir ;;
 
243
  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 
244
  | --includ=* | --inclu=* | --incl=* | --inc=*)
 
245
    includedir=$ac_optarg ;;
 
246
 
 
247
  -infodir | --infodir | --infodi | --infod | --info | --inf)
 
248
    ac_prev=infodir ;;
 
249
  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 
250
    infodir=$ac_optarg ;;
 
251
 
 
252
  -libdir | --libdir | --libdi | --libd)
 
253
    ac_prev=libdir ;;
 
254
  -libdir=* | --libdir=* | --libdi=* | --libd=*)
 
255
    libdir=$ac_optarg ;;
 
256
 
 
257
  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 
258
  | --libexe | --libex | --libe)
 
259
    ac_prev=libexecdir ;;
 
260
  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 
261
  | --libexe=* | --libex=* | --libe=*)
 
262
    libexecdir=$ac_optarg ;;
 
263
 
 
264
  -localstatedir | --localstatedir | --localstatedi | --localstated \
 
265
  | --localstate | --localstat | --localsta | --localst \
 
266
  | --locals | --local | --loca | --loc | --lo)
 
267
    ac_prev=localstatedir ;;
 
268
  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 
269
  | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 
270
  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 
271
    localstatedir=$ac_optarg ;;
 
272
 
 
273
  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 
274
    ac_prev=mandir ;;
 
275
  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 
276
    mandir=$ac_optarg ;;
 
277
 
 
278
  -nfp | --nfp | --nf)
 
279
    # Obsolete; use --without-fp.
 
280
    with_fp=no ;;
 
281
 
 
282
  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 
283
  | --no-cr | --no-c)
 
284
    no_create=yes ;;
 
285
 
 
286
  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 
287
  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 
288
    no_recursion=yes ;;
 
289
 
 
290
  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 
291
  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 
292
  | --oldin | --oldi | --old | --ol | --o)
 
293
    ac_prev=oldincludedir ;;
 
294
  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 
295
  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 
296
  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 
297
    oldincludedir=$ac_optarg ;;
 
298
 
 
299
  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 
300
    ac_prev=prefix ;;
 
301
  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 
302
    prefix=$ac_optarg ;;
 
303
 
 
304
  -program-prefix | --program-prefix | --program-prefi | --program-pref \
 
305
  | --program-pre | --program-pr | --program-p)
 
306
    ac_prev=program_prefix ;;
 
307
  -program-prefix=* | --program-prefix=* | --program-prefi=* \
 
308
  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 
309
    program_prefix=$ac_optarg ;;
 
310
 
 
311
  -program-suffix | --program-suffix | --program-suffi | --program-suff \
 
312
  | --program-suf | --program-su | --program-s)
 
313
    ac_prev=program_suffix ;;
 
314
  -program-suffix=* | --program-suffix=* | --program-suffi=* \
 
315
  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 
316
    program_suffix=$ac_optarg ;;
 
317
 
 
318
  -program-transform-name | --program-transform-name \
 
319
  | --program-transform-nam | --program-transform-na \
 
320
  | --program-transform-n | --program-transform- \
 
321
  | --program-transform | --program-transfor \
 
322
  | --program-transfo | --program-transf \
 
323
  | --program-trans | --program-tran \
 
324
  | --progr-tra | --program-tr | --program-t)
 
325
    ac_prev=program_transform_name ;;
 
326
  -program-transform-name=* | --program-transform-name=* \
 
327
  | --program-transform-nam=* | --program-transform-na=* \
 
328
  | --program-transform-n=* | --program-transform-=* \
 
329
  | --program-transform=* | --program-transfor=* \
 
330
  | --program-transfo=* | --program-transf=* \
 
331
  | --program-trans=* | --program-tran=* \
 
332
  | --progr-tra=* | --program-tr=* | --program-t=*)
 
333
    program_transform_name=$ac_optarg ;;
 
334
 
 
335
  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 
336
  | -silent | --silent | --silen | --sile | --sil)
 
337
    silent=yes ;;
 
338
 
 
339
  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 
340
    ac_prev=sbindir ;;
 
341
  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 
342
  | --sbi=* | --sb=*)
 
343
    sbindir=$ac_optarg ;;
 
344
 
 
345
  -sharedstatedir | --sharedstatedir | --sharedstatedi \
 
346
  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 
347
  | --sharedst | --shareds | --shared | --share | --shar \
 
348
  | --sha | --sh)
 
349
    ac_prev=sharedstatedir ;;
 
350
  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 
351
  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 
352
  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 
353
  | --sha=* | --sh=*)
 
354
    sharedstatedir=$ac_optarg ;;
 
355
 
 
356
  -site | --site | --sit)
 
357
    ac_prev=site ;;
 
358
  -site=* | --site=* | --sit=*)
 
359
    site=$ac_optarg ;;
 
360
 
 
361
  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 
362
    ac_prev=srcdir ;;
 
363
  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 
364
    srcdir=$ac_optarg ;;
 
365
 
 
366
  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 
367
  | --syscon | --sysco | --sysc | --sys | --sy)
 
368
    ac_prev=sysconfdir ;;
 
369
  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 
370
  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 
371
    sysconfdir=$ac_optarg ;;
 
372
 
 
373
  -target | --target | --targe | --targ | --tar | --ta | --t)
 
374
    ac_prev=target_alias ;;
 
375
  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 
376
    target_alias=$ac_optarg ;;
 
377
 
 
378
  -v | -verbose | --verbose | --verbos | --verbo | --verb)
 
379
    verbose=yes ;;
 
380
 
 
381
  -version | --version | --versio | --versi | --vers | -V)
 
382
    ac_init_version=: ;;
 
383
 
 
384
  -with-* | --with-*)
 
385
    ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 
386
    # Reject names that are not valid shell variable names.
 
387
    expr "x$ac_package" : ".*[^-_$ac_cr_alnum]" >/dev/null &&
 
388
      { echo "$as_me: error: invalid package name: $ac_package" >&2
 
389
   { (exit 1); exit 1; }; }
 
390
    ac_package=`echo $ac_package| sed 's/-/_/g'`
 
391
    case $ac_option in
 
392
      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 
393
      *) ac_optarg=yes ;;
 
394
    esac
 
395
    eval "with_$ac_package='$ac_optarg'" ;;
 
396
 
 
397
  -without-* | --without-*)
 
398
    ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 
399
    # Reject names that are not valid shell variable names.
 
400
    expr "x$ac_package" : ".*[^-_$ac_cr_alnum]" >/dev/null &&
 
401
      { echo "$as_me: error: invalid package name: $ac_package" >&2
 
402
   { (exit 1); exit 1; }; }
 
403
    ac_package=`echo $ac_package | sed 's/-/_/g'`
 
404
    eval "with_$ac_package=no" ;;
 
405
 
 
406
  --x)
 
407
    # Obsolete; use --with-x.
 
408
    with_x=yes ;;
 
409
 
 
410
  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 
411
  | --x-incl | --x-inc | --x-in | --x-i)
 
412
    ac_prev=x_includes ;;
 
413
  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 
414
  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 
415
    x_includes=$ac_optarg ;;
 
416
 
 
417
  -x-libraries | --x-libraries | --x-librarie | --x-librari \
 
418
  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 
419
    ac_prev=x_libraries ;;
 
420
  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 
421
  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 
422
    x_libraries=$ac_optarg ;;
 
423
 
 
424
  -*) { echo "$as_me: error: unrecognized option: $ac_option
 
425
Try \`$0 --help' for more information." >&2
 
426
   { (exit 1); exit 1; }; }
 
427
    ;;
 
428
 
 
429
  *=*)
 
430
    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 
431
    # Reject names that are not valid shell variable names.
 
432
    expr "x$ac_envvar" : ".*[^_$ac_cr_alnum]" >/dev/null &&
 
433
      { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 
434
   { (exit 1); exit 1; }; }
 
435
    ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 
436
    eval "$ac_envvar='$ac_optarg'"
 
437
    export $ac_envvar ;;
 
438
 
 
439
  *)
 
440
    # FIXME: should be removed in autoconf 3.0.
 
441
    echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 
442
    expr "x$ac_option" : ".*[^-._$ac_cr_alnum]" >/dev/null &&
 
443
      echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 
444
    : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 
445
    ;;
 
446
 
 
447
  esac
 
448
done
 
449
 
 
450
if test -n "$ac_prev"; then
 
451
  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 
452
  { echo "$as_me: error: missing argument to $ac_option" >&2
 
453
   { (exit 1); exit 1; }; }
 
454
fi
 
455
 
 
456
# Be sure to have absolute paths.
 
457
for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 
458
              localstatedir libdir includedir oldincludedir infodir mandir \
 
459
              exec_prefix prefix
 
460
do
 
461
  eval ac_val=$`echo $ac_var`
 
462
  case $ac_val in
 
463
    [\\/$]* | ?:[\\/]* ) ;;
 
464
    NONE ) ;;
 
465
    *)  { echo "$as_me: error: expected an absolute path for --$ac_var: $ac_val" >&2
 
466
   { (exit 1); exit 1; }; };;
 
467
  esac
 
468
done
 
469
 
 
470
# There might be people who depend on the old broken behavior: `$host'
 
471
# used to hold the argument of --host etc.
 
472
build=$build_alias
 
473
host=$host_alias
 
474
target=$target_alias
 
475
 
 
476
# FIXME: should be removed in autoconf 3.0.
 
477
if test "x$host_alias" != x; then
 
478
  if test "x$build_alias" = x; then
 
479
    cross_compiling=maybe
 
480
    echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 
481
    If a cross compiler is detected then cross compile mode will be used." >&2
 
482
  elif test "x$build_alias" != "x$host_alias"; then
 
483
    cross_compiling=yes
 
484
  fi
 
485
fi
 
486
 
 
487
ac_tool_prefix=
 
488
test -n "$host_alias" && ac_tool_prefix=$host_alias-
 
489
 
 
490
test "$silent" = yes && exec 6>/dev/null
 
491
 
 
492
# Find the source files, if location was not specified.
 
493
if test -z "$srcdir"; then
 
494
  ac_srcdir_defaulted=yes
 
495
  # Try the directory containing this script, then its parent.
 
496
  ac_prog=$0
 
497
  ac_confdir=`echo "$ac_prog" | sed 's%[\\/][^\\/][^\\/]*$%%'`
 
498
  test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
 
499
  srcdir=$ac_confdir
 
500
  if test ! -r $srcdir/$ac_unique_file; then
 
501
    srcdir=..
 
502
  fi
 
503
else
 
504
  ac_srcdir_defaulted=no
 
505
fi
 
506
if test ! -r $srcdir/$ac_unique_file; then
 
507
  if test "$ac_srcdir_defaulted" = yes; then
 
508
    { echo "$as_me: error: cannot find sources in $ac_confdir or .." >&2
 
509
   { (exit 1); exit 1; }; }
 
510
  else
 
511
    { echo "$as_me: error: cannot find sources in $srcdir" >&2
 
512
   { (exit 1); exit 1; }; }
 
513
  fi
 
514
fi
 
515
srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 
516
ac_env_build_alias_set=${build_alias+set}
 
517
ac_env_build_alias_value=$build_alias
 
518
ac_cv_env_build_alias_set=${build_alias+set}
 
519
ac_cv_env_build_alias_value=$build_alias
 
520
ac_env_host_alias_set=${host_alias+set}
 
521
ac_env_host_alias_value=$host_alias
 
522
ac_cv_env_host_alias_set=${host_alias+set}
 
523
ac_cv_env_host_alias_value=$host_alias
 
524
ac_env_target_alias_set=${target_alias+set}
 
525
ac_env_target_alias_value=$target_alias
 
526
ac_cv_env_target_alias_set=${target_alias+set}
 
527
ac_cv_env_target_alias_value=$target_alias
 
528
ac_env_CC_set=${CC+set}
 
529
ac_env_CC_value=$CC
 
530
ac_cv_env_CC_set=${CC+set}
 
531
ac_cv_env_CC_value=$CC
 
532
ac_env_CFLAGS_set=${CFLAGS+set}
 
533
ac_env_CFLAGS_value=$CFLAGS
 
534
ac_cv_env_CFLAGS_set=${CFLAGS+set}
 
535
ac_cv_env_CFLAGS_value=$CFLAGS
 
536
ac_env_LDFLAGS_set=${LDFLAGS+set}
 
537
ac_env_LDFLAGS_value=$LDFLAGS
 
538
ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 
539
ac_cv_env_LDFLAGS_value=$LDFLAGS
 
540
ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 
541
ac_env_CPPFLAGS_value=$CPPFLAGS
 
542
ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 
543
ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 
544
ac_env_CXX_set=${CXX+set}
 
545
ac_env_CXX_value=$CXX
 
546
ac_cv_env_CXX_set=${CXX+set}
 
547
ac_cv_env_CXX_value=$CXX
 
548
ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 
549
ac_env_CXXFLAGS_value=$CXXFLAGS
 
550
ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 
551
ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 
552
ac_env_CPP_set=${CPP+set}
 
553
ac_env_CPP_value=$CPP
 
554
ac_cv_env_CPP_set=${CPP+set}
 
555
ac_cv_env_CPP_value=$CPP
 
556
 
 
557
#
 
558
# Report the --help message.
 
559
#
 
560
if test "$ac_init_help" = "long"; then
 
561
  # Omit some internal or obsolete options to make the list less imposing.
 
562
  # This message is too long to be a string in the A/UX 3.1 sh.
 
563
  cat <<EOF
 
564
\`configure' configures this package to adapt to many kinds of systems.
 
565
 
 
566
Usage: $0 [OPTION]... [VAR=VALUE]...
 
567
 
 
568
To assign environment variables (e.g., CC, CFLAGS...), specify them as
 
569
VAR=VALUE.  See below for descriptions of some of the useful variables.
 
570
 
 
571
Defaults for the options are specified in brackets.
 
572
 
 
573
Configuration:
 
574
  -h, --help              display this help and exit
 
575
      --help=short        display options specific to this package
 
576
      --help=recursive    display the short help of all the included packages
 
577
  -V, --version           display version information and exit
 
578
  -q, --quiet, --silent   do not print \`checking...' messages
 
579
      --cache-file=FILE   cache test results in FILE [disabled]
 
580
  -C, --config-cache      alias for \`--cache-file=config.cache'
 
581
  -n, --no-create         do not create output files
 
582
      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 
583
 
 
584
EOF
 
585
 
 
586
  cat <<EOF
 
587
Installation directories:
 
588
  --prefix=PREFIX         install architecture-independent files in PREFIX
 
589
                          [$ac_default_prefix]
 
590
  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 
591
                          [PREFIX]
 
592
 
 
593
By default, \`make install' will install all the files in
 
594
\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 
595
an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 
596
for instance \`--prefix=\$HOME'.
 
597
 
 
598
For better control, use the options below.
 
599
 
 
600
Fine tuning of the installation directories:
 
601
  --bindir=DIR           user executables [EPREFIX/bin]
 
602
  --sbindir=DIR          system admin executables [EPREFIX/sbin]
 
603
  --libexecdir=DIR       program executables [EPREFIX/libexec]
 
604
  --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 
605
  --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 
606
  --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 
607
  --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 
608
  --libdir=DIR           object code libraries [EPREFIX/lib]
 
609
  --includedir=DIR       C header files [PREFIX/include]
 
610
  --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 
611
  --infodir=DIR          info documentation [PREFIX/info]
 
612
  --mandir=DIR           man documentation [PREFIX/man]
 
613
EOF
 
614
 
 
615
  cat <<\EOF
 
616
EOF
 
617
fi
 
618
 
 
619
if test -n "$ac_init_help"; then
 
620
 
 
621
  cat <<\EOF
 
622
 
 
623
Some influential environment variables:
 
624
  CC          C compiler command
 
625
  CFLAGS      C compiler flags
 
626
  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 
627
              nonstandard directory <lib dir>
 
628
  CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 
629
              headers in a nonstandard directory <include dir>
 
630
  CXX         C++ compiler command
 
631
  CXXFLAGS    C++ compiler flags
 
632
  CPP         C preprocessor
 
633
 
 
634
Use these variables to override the choices made by `configure' or to help
 
635
it to find libraries and programs with nonstandard names/locations.
 
636
 
 
637
EOF
 
638
fi
 
639
 
 
640
if test "$ac_init_help" = "recursive"; then
 
641
  # If there are subdirs, report their specific --help.
 
642
  ac_popdir=`pwd`
 
643
  for ac_subdir in : $ac_subdirs_all; do test "x$ac_subdir" = x: && continue
 
644
    cd $ac_subdir
 
645
    # A "../" for each directory in /$ac_subdir.
 
646
    ac_dots=`echo $ac_subdir |
 
647
             sed 's,^\./,,;s,[^/]$,&/,;s,[^/]*/,../,g'`
 
648
 
 
649
    case $srcdir in
 
650
    .) # No --srcdir option.  We are building in place.
 
651
      ac_sub_srcdir=$srcdir ;;
 
652
    [\\/]* | ?:[\\/]* ) # Absolute path.
 
653
      ac_sub_srcdir=$srcdir/$ac_subdir ;;
 
654
    *) # Relative path.
 
655
      ac_sub_srcdir=$ac_dots$srcdir/$ac_subdir ;;
 
656
    esac
 
657
 
 
658
    # Check for guested configure; otherwise get Cygnus style configure.
 
659
    if test -f $ac_sub_srcdir/configure.gnu; then
 
660
      echo
 
661
      $SHELL $ac_sub_srcdir/configure.gnu  --help=recursive
 
662
    elif test -f $ac_sub_srcdir/configure; then
 
663
      echo
 
664
      $SHELL $ac_sub_srcdir/configure  --help=recursive
 
665
    elif test -f $ac_sub_srcdir/configure.ac ||
 
666
           test -f $ac_sub_srcdir/configure.in; then
 
667
      echo
 
668
      $ac_configure --help
 
669
    else
 
670
      echo "$as_me: WARNING: no configuration information is in $ac_subdir" >&2
 
671
    fi
 
672
    cd $ac_popdir
 
673
  done
 
674
fi
 
675
 
 
676
test -n "$ac_init_help" && exit 0
 
677
if $ac_init_version; then
 
678
  cat <<\EOF
 
679
 
 
680
Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
 
681
Free Software Foundation, Inc.
 
682
This configure script is free software; the Free Software Foundation
 
683
gives unlimited permission to copy, distribute and modify it.
 
684
EOF
 
685
  exit 0
 
686
fi
 
687
exec 5>config.log
 
688
cat >&5 <<EOF
 
689
This file contains any messages produced by compilers while
 
690
running configure, to aid debugging if configure makes a mistake.
 
691
 
 
692
It was created by $as_me, which was
 
693
generated by GNU Autoconf 2.50.  Invocation command line was
 
694
 
 
695
  $ $0 $@
 
696
 
 
697
EOF
 
698
{
 
699
cat <<_ASUNAME
 
700
## ---------- ##
 
701
## Platform.  ##
 
702
## ---------- ##
 
703
 
 
704
hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
 
705
uname -m = `(uname -m) 2>/dev/null || echo unknown`
 
706
uname -r = `(uname -r) 2>/dev/null || echo unknown`
 
707
uname -s = `(uname -s) 2>/dev/null || echo unknown`
 
708
uname -v = `(uname -v) 2>/dev/null || echo unknown`
 
709
 
 
710
/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
 
711
/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
 
712
 
 
713
/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
 
714
/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
 
715
/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
 
716
hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
 
717
/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
 
718
/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
 
719
/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
 
720
 
 
721
PATH = $PATH
 
722
 
 
723
_ASUNAME
 
724
} >&5
 
725
 
 
726
cat >&5 <<EOF
 
727
## ------------ ##
 
728
## Core tests.  ##
 
729
## ------------ ##
 
730
 
 
731
EOF
 
732
 
 
733
# Keep a trace of the command line.
 
734
# Strip out --no-create and --no-recursion so they do not pile up.
 
735
# Also quote any args containing shell meta-characters.
 
736
ac_configure_args=
 
737
ac_sep=
 
738
for ac_arg
 
739
do
 
740
  case $ac_arg in
 
741
  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 
742
  | --no-cr | --no-c) ;;
 
743
  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 
744
  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
 
745
  *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
 
746
    ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
 
747
    ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
 
748
    ac_sep=" " ;;
 
749
  *) ac_configure_args="$ac_configure_args$ac_sep$ac_arg"
 
750
     ac_sep=" " ;;
 
751
  esac
 
752
  # Get rid of the leading space.
 
753
done
 
754
 
 
755
# When interrupted or exit'd, cleanup temporary files, and complete
 
756
# config.log.  We remove comments because anyway the quotes in there
 
757
# would cause problems or look ugly.
 
758
trap 'exit_status=$?
 
759
  # Save into config.log some information that might help in debugging.
 
760
  echo >&5
 
761
  echo "## ----------------- ##" >&5
 
762
  echo "## Cache variables.  ##" >&5
 
763
  echo "## ----------------- ##" >&5
 
764
  echo >&5
 
765
  # The following way of writing the cache mishandles newlines in values,
 
766
{
 
767
  (set) 2>&1 |
 
768
    case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
 
769
    *ac_space=\ *)
 
770
      sed -n \
 
771
        "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
 
772
          s/^\\([_$ac_cr_alnum]*_cv_[_$ac_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
 
773
      ;;
 
774
    *)
 
775
      sed -n \
 
776
        "s/^\\([_$ac_cr_alnum]*_cv_[_$ac_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
 
777
      ;;
 
778
    esac;
 
779
} >&5
 
780
  sed "/^$/d" confdefs.h >conftest.log
 
781
  if test -s conftest.log; then
 
782
    echo >&5
 
783
    echo "## ------------ ##" >&5
 
784
    echo "## confdefs.h.  ##" >&5
 
785
    echo "## ------------ ##" >&5
 
786
    echo >&5
 
787
    cat conftest.log >&5
 
788
  fi
 
789
  (echo; echo) >&5
 
790
  test "$ac_signal" != 0 &&
 
791
    echo "$as_me: caught signal $ac_signal" >&5
 
792
  echo "$as_me: exit $exit_status" >&5
 
793
  rm -rf conftest* confdefs* core core.* *.core conf$$* $ac_clean_files &&
 
794
    exit $exit_status
 
795
     ' 0
 
796
for ac_signal in 1 2 13 15; do
 
797
  trap 'ac_status=$?; ac_signal='$ac_signal'; { (exit $ac_status); exit $ac_status; }' $ac_signal
 
798
done
 
799
ac_signal=0
 
800
 
 
801
# confdefs.h avoids OS command line length limits that DEFS can exceed.
 
802
rm -rf conftest* confdefs.h
 
803
# AIX cpp loses on an empty file, so make sure it contains at least a newline.
 
804
echo >confdefs.h
 
805
 
 
806
# Let the site file select an alternate cache file if it wants to.
 
807
# Prefer explicitly selected file to automatically selected ones.
 
808
if test -z "$CONFIG_SITE"; then
 
809
  if test "x$prefix" != xNONE; then
 
810
    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
 
811
  else
 
812
    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
 
813
  fi
 
814
fi
 
815
for ac_site_file in $CONFIG_SITE; do
 
816
  if test -r "$ac_site_file"; then
 
817
    { echo "$as_me:817: loading site script $ac_site_file" >&5
 
818
echo "$as_me: loading site script $ac_site_file" >&6;}
 
819
    cat "$ac_site_file" >&5
 
820
    . "$ac_site_file"
 
821
  fi
 
822
done
 
823
 
 
824
if test -r "$cache_file"; then
 
825
  # Some versions of bash will fail to source /dev/null (special
 
826
  # files actually), so we avoid doing that.
 
827
  if test -f "$cache_file"; then
 
828
    { echo "$as_me:828: loading cache $cache_file" >&5
 
829
echo "$as_me: loading cache $cache_file" >&6;}
 
830
    case $cache_file in
 
831
      [\\/]* | ?:[\\/]* ) . $cache_file;;
 
832
      *)                      . ./$cache_file;;
 
833
    esac
 
834
  fi
 
835
else
 
836
  { echo "$as_me:836: creating cache $cache_file" >&5
 
837
echo "$as_me: creating cache $cache_file" >&6;}
 
838
  >$cache_file
 
839
fi
 
840
 
 
841
# Check that the precious variables saved in the cache have kept the same
 
842
# value.
 
843
ac_suggest_removing_cache=false
 
844
for ac_var in `(set) 2>&1 |
 
845
               sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
 
846
  eval ac_old_set=\$ac_cv_env_${ac_var}_set
 
847
  eval ac_new_set=\$ac_env_${ac_var}_set
 
848
  eval ac_old_val="\$ac_cv_env_${ac_var}_value"
 
849
  eval ac_new_val="\$ac_env_${ac_var}_value"
 
850
  case $ac_old_set,$ac_new_set in
 
851
    set,)
 
852
      { echo "$as_me:852: WARNING: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
 
853
echo "$as_me: WARNING: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
 
854
      ac_suggest_removing_cache=: ;;
 
855
    ,set)
 
856
      { echo "$as_me:856: WARNING: \`$ac_var' was not set in the previous run" >&5
 
857
echo "$as_me: WARNING: \`$ac_var' was not set in the previous run" >&2;}
 
858
      ac_suggest_removing_cache=: ;;
 
859
    ,);;
 
860
    *)
 
861
      if test "x$ac_old_val" != "x$ac_new_val"; then
 
862
        { echo "$as_me:862: WARNING: \`$ac_var' has changed since the previous run:" >&5
 
863
echo "$as_me: WARNING: \`$ac_var' has changed since the previous run:" >&2;}
 
864
        { echo "$as_me:864: WARNING:   former value:  $ac_old_val" >&5
 
865
echo "$as_me: WARNING:   former value:  $ac_old_val" >&2;}
 
866
        { echo "$as_me:866: WARNING:   current value: $ac_new_val" >&5
 
867
echo "$as_me: WARNING:   current value: $ac_new_val" >&2;}
 
868
        ac_suggest_removing_cache=:
 
869
      fi;;
 
870
  esac
 
871
done
 
872
if $ac_suggest_removing_cache; then
 
873
  { echo "$as_me:873: WARNING: changes in the environment can compromise the build" >&5
 
874
echo "$as_me: WARNING: changes in the environment can compromise the build" >&2;}
 
875
  { echo "$as_me:875: WARNING: consider removing $cache_file and starting over" >&5
 
876
echo "$as_me: WARNING: consider removing $cache_file and starting over" >&2;}
 
877
fi
 
878
 
 
879
ac_ext=c
 
880
ac_cpp='$CPP $CPPFLAGS'
 
881
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
882
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
883
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
884
 
 
885
case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 
886
  *c*,-n*) ECHO_N= ECHO_C='
 
887
' ECHO_T='      ' ;;
 
888
  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 
889
  *)      ECHO_N= ECHO_C='\c' ECHO_T= ;;
 
890
esac
 
891
echo "#! $SHELL" >conftest.sh
 
892
echo  "exit 0"   >>conftest.sh
 
893
chmod +x conftest.sh
 
894
if { (echo "$as_me:894: PATH=\".;.\"; conftest.sh") >&5
 
895
  (PATH=".;."; conftest.sh) 2>&5
 
896
  ac_status=$?
 
897
  echo "$as_me:897: \$? = $ac_status" >&5
 
898
  (exit $ac_status); }; then
 
899
  ac_path_separator=';'
 
900
else
 
901
  ac_path_separator=:
 
902
fi
 
903
PATH_SEPARATOR="$ac_path_separator"
 
904
rm -f conftest.sh
 
905
 
 
906
ac_srcdir_defaulted=no
 
907
srcdir=`cd $srcdir; pwd`
 
908
top_builddir=`pwd`
 
909
 
 
910
ac_ext=c
 
911
ac_cpp='$CPP $CPPFLAGS'
 
912
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
913
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
914
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
915
if test -n "$ac_tool_prefix"; then
 
916
  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
 
917
set dummy ${ac_tool_prefix}gcc; ac_word=$2
 
918
echo "$as_me:918: checking for $ac_word" >&5
 
919
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
920
if test "${ac_cv_prog_CC+set}" = set; then
 
921
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
922
else
 
923
  if test -n "$CC"; then
 
924
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
925
else
 
926
  ac_save_IFS=$IFS; IFS=$ac_path_separator
 
927
ac_dummy="$PATH"
 
928
for ac_dir in $ac_dummy; do
 
929
  IFS=$ac_save_IFS
 
930
  test -z "$ac_dir" && ac_dir=.
 
931
  $as_executable_p "$ac_dir/$ac_word" || continue
 
932
ac_cv_prog_CC="${ac_tool_prefix}gcc"
 
933
echo "$as_me:933: found $ac_dir/$ac_word" >&5
 
934
break
 
935
done
 
936
 
 
937
fi
 
938
fi
 
939
CC=$ac_cv_prog_CC
 
940
if test -n "$CC"; then
 
941
  echo "$as_me:941: result: $CC" >&5
 
942
echo "${ECHO_T}$CC" >&6
 
943
else
 
944
  echo "$as_me:944: result: no" >&5
 
945
echo "${ECHO_T}no" >&6
 
946
fi
 
947
 
 
948
fi
 
949
if test -z "$ac_cv_prog_CC"; then
 
950
  ac_ct_CC=$CC
 
951
  # Extract the first word of "gcc", so it can be a program name with args.
 
952
set dummy gcc; ac_word=$2
 
953
echo "$as_me:953: checking for $ac_word" >&5
 
954
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
955
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
 
956
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
957
else
 
958
  if test -n "$ac_ct_CC"; then
 
959
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 
960
else
 
961
  ac_save_IFS=$IFS; IFS=$ac_path_separator
 
962
ac_dummy="$PATH"
 
963
for ac_dir in $ac_dummy; do
 
964
  IFS=$ac_save_IFS
 
965
  test -z "$ac_dir" && ac_dir=.
 
966
  $as_executable_p "$ac_dir/$ac_word" || continue
 
967
ac_cv_prog_ac_ct_CC="gcc"
 
968
echo "$as_me:968: found $ac_dir/$ac_word" >&5
 
969
break
 
970
done
 
971
 
 
972
fi
 
973
fi
 
974
ac_ct_CC=$ac_cv_prog_ac_ct_CC
 
975
if test -n "$ac_ct_CC"; then
 
976
  echo "$as_me:976: result: $ac_ct_CC" >&5
 
977
echo "${ECHO_T}$ac_ct_CC" >&6
 
978
else
 
979
  echo "$as_me:979: result: no" >&5
 
980
echo "${ECHO_T}no" >&6
 
981
fi
 
982
 
 
983
  CC=$ac_ct_CC
 
984
else
 
985
  CC="$ac_cv_prog_CC"
 
986
fi
 
987
 
 
988
if test -z "$CC"; then
 
989
  if test -n "$ac_tool_prefix"; then
 
990
  # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
 
991
set dummy ${ac_tool_prefix}cc; ac_word=$2
 
992
echo "$as_me:992: checking for $ac_word" >&5
 
993
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
994
if test "${ac_cv_prog_CC+set}" = set; then
 
995
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
996
else
 
997
  if test -n "$CC"; then
 
998
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
999
else
 
1000
  ac_save_IFS=$IFS; IFS=$ac_path_separator
 
1001
ac_dummy="$PATH"
 
1002
for ac_dir in $ac_dummy; do
 
1003
  IFS=$ac_save_IFS
 
1004
  test -z "$ac_dir" && ac_dir=.
 
1005
  $as_executable_p "$ac_dir/$ac_word" || continue
 
1006
ac_cv_prog_CC="${ac_tool_prefix}cc"
 
1007
echo "$as_me:1007: found $ac_dir/$ac_word" >&5
 
1008
break
 
1009
done
 
1010
 
 
1011
fi
 
1012
fi
 
1013
CC=$ac_cv_prog_CC
 
1014
if test -n "$CC"; then
 
1015
  echo "$as_me:1015: result: $CC" >&5
 
1016
echo "${ECHO_T}$CC" >&6
 
1017
else
 
1018
  echo "$as_me:1018: result: no" >&5
 
1019
echo "${ECHO_T}no" >&6
 
1020
fi
 
1021
 
 
1022
fi
 
1023
if test -z "$ac_cv_prog_CC"; then
 
1024
  ac_ct_CC=$CC
 
1025
  # Extract the first word of "cc", so it can be a program name with args.
 
1026
set dummy cc; ac_word=$2
 
1027
echo "$as_me:1027: checking for $ac_word" >&5
 
1028
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
1029
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
 
1030
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
1031
else
 
1032
  if test -n "$ac_ct_CC"; then
 
1033
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 
1034
else
 
1035
  ac_save_IFS=$IFS; IFS=$ac_path_separator
 
1036
ac_dummy="$PATH"
 
1037
for ac_dir in $ac_dummy; do
 
1038
  IFS=$ac_save_IFS
 
1039
  test -z "$ac_dir" && ac_dir=.
 
1040
  $as_executable_p "$ac_dir/$ac_word" || continue
 
1041
ac_cv_prog_ac_ct_CC="cc"
 
1042
echo "$as_me:1042: found $ac_dir/$ac_word" >&5
 
1043
break
 
1044
done
 
1045
 
 
1046
fi
 
1047
fi
 
1048
ac_ct_CC=$ac_cv_prog_ac_ct_CC
 
1049
if test -n "$ac_ct_CC"; then
 
1050
  echo "$as_me:1050: result: $ac_ct_CC" >&5
 
1051
echo "${ECHO_T}$ac_ct_CC" >&6
 
1052
else
 
1053
  echo "$as_me:1053: result: no" >&5
 
1054
echo "${ECHO_T}no" >&6
 
1055
fi
 
1056
 
 
1057
  CC=$ac_ct_CC
 
1058
else
 
1059
  CC="$ac_cv_prog_CC"
 
1060
fi
 
1061
 
 
1062
fi
 
1063
if test -z "$CC"; then
 
1064
  # Extract the first word of "cc", so it can be a program name with args.
 
1065
set dummy cc; ac_word=$2
 
1066
echo "$as_me:1066: checking for $ac_word" >&5
 
1067
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
1068
if test "${ac_cv_prog_CC+set}" = set; then
 
1069
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
1070
else
 
1071
  if test -n "$CC"; then
 
1072
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
1073
else
 
1074
  ac_prog_rejected=no
 
1075
  ac_save_IFS=$IFS; IFS=$ac_path_separator
 
1076
ac_dummy="$PATH"
 
1077
for ac_dir in $ac_dummy; do
 
1078
  IFS=$ac_save_IFS
 
1079
  test -z "$ac_dir" && ac_dir=.
 
1080
  $as_executable_p "$ac_dir/$ac_word" || continue
 
1081
if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
 
1082
  ac_prog_rejected=yes
 
1083
  continue
 
1084
fi
 
1085
ac_cv_prog_CC="cc"
 
1086
echo "$as_me:1086: found $ac_dir/$ac_word" >&5
 
1087
break
 
1088
done
 
1089
 
 
1090
if test $ac_prog_rejected = yes; then
 
1091
  # We found a bogon in the path, so make sure we never use it.
 
1092
  set dummy $ac_cv_prog_CC
 
1093
  shift
 
1094
  if test $# != 0; then
 
1095
    # We chose a different compiler from the bogus one.
 
1096
    # However, it has the same basename, so the bogon will be chosen
 
1097
    # first if we set CC to just the basename; use the full file name.
 
1098
    shift
 
1099
    set dummy "$ac_dir/$ac_word" ${1+"$@"}
 
1100
    shift
 
1101
    ac_cv_prog_CC="$@"
 
1102
  fi
 
1103
fi
 
1104
fi
 
1105
fi
 
1106
CC=$ac_cv_prog_CC
 
1107
if test -n "$CC"; then
 
1108
  echo "$as_me:1108: result: $CC" >&5
 
1109
echo "${ECHO_T}$CC" >&6
 
1110
else
 
1111
  echo "$as_me:1111: result: no" >&5
 
1112
echo "${ECHO_T}no" >&6
 
1113
fi
 
1114
 
 
1115
fi
 
1116
if test -z "$CC"; then
 
1117
  if test -n "$ac_tool_prefix"; then
 
1118
  for ac_prog in cl
 
1119
  do
 
1120
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
 
1121
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
 
1122
echo "$as_me:1122: checking for $ac_word" >&5
 
1123
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
1124
if test "${ac_cv_prog_CC+set}" = set; then
 
1125
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
1126
else
 
1127
  if test -n "$CC"; then
 
1128
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
1129
else
 
1130
  ac_save_IFS=$IFS; IFS=$ac_path_separator
 
1131
ac_dummy="$PATH"
 
1132
for ac_dir in $ac_dummy; do
 
1133
  IFS=$ac_save_IFS
 
1134
  test -z "$ac_dir" && ac_dir=.
 
1135
  $as_executable_p "$ac_dir/$ac_word" || continue
 
1136
ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
 
1137
echo "$as_me:1137: found $ac_dir/$ac_word" >&5
 
1138
break
 
1139
done
 
1140
 
 
1141
fi
 
1142
fi
 
1143
CC=$ac_cv_prog_CC
 
1144
if test -n "$CC"; then
 
1145
  echo "$as_me:1145: result: $CC" >&5
 
1146
echo "${ECHO_T}$CC" >&6
 
1147
else
 
1148
  echo "$as_me:1148: result: no" >&5
 
1149
echo "${ECHO_T}no" >&6
 
1150
fi
 
1151
 
 
1152
    test -n "$CC" && break
 
1153
  done
 
1154
fi
 
1155
if test -z "$CC"; then
 
1156
  ac_ct_CC=$CC
 
1157
  for ac_prog in cl
 
1158
do
 
1159
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
1160
set dummy $ac_prog; ac_word=$2
 
1161
echo "$as_me:1161: checking for $ac_word" >&5
 
1162
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
1163
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
 
1164
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
1165
else
 
1166
  if test -n "$ac_ct_CC"; then
 
1167
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 
1168
else
 
1169
  ac_save_IFS=$IFS; IFS=$ac_path_separator
 
1170
ac_dummy="$PATH"
 
1171
for ac_dir in $ac_dummy; do
 
1172
  IFS=$ac_save_IFS
 
1173
  test -z "$ac_dir" && ac_dir=.
 
1174
  $as_executable_p "$ac_dir/$ac_word" || continue
 
1175
ac_cv_prog_ac_ct_CC="$ac_prog"
 
1176
echo "$as_me:1176: found $ac_dir/$ac_word" >&5
 
1177
break
 
1178
done
 
1179
 
 
1180
fi
 
1181
fi
 
1182
ac_ct_CC=$ac_cv_prog_ac_ct_CC
 
1183
if test -n "$ac_ct_CC"; then
 
1184
  echo "$as_me:1184: result: $ac_ct_CC" >&5
 
1185
echo "${ECHO_T}$ac_ct_CC" >&6
 
1186
else
 
1187
  echo "$as_me:1187: result: no" >&5
 
1188
echo "${ECHO_T}no" >&6
 
1189
fi
 
1190
 
 
1191
  test -n "$ac_ct_CC" && break
 
1192
done
 
1193
 
 
1194
  CC=$ac_ct_CC
 
1195
fi
 
1196
 
 
1197
fi
 
1198
 
 
1199
test -z "$CC" && { { echo "$as_me:1199: error: no acceptable cc found in \$PATH" >&5
 
1200
echo "$as_me: error: no acceptable cc found in \$PATH" >&2;}
 
1201
   { (exit 1); exit 1; }; }
 
1202
 
 
1203
cat >conftest.$ac_ext <<_ACEOF
 
1204
#line 1204 "configure"
 
1205
#include "confdefs.h"
 
1206
 
 
1207
int
 
1208
main ()
 
1209
{
 
1210
 
 
1211
  ;
 
1212
  return 0;
 
1213
}
 
1214
_ACEOF
 
1215
ac_clean_files_save=$ac_clean_files
 
1216
ac_clean_files="$ac_clean_files a.out a.exe"
 
1217
# Try to create an executable without -o first, disregard a.out.
 
1218
# It will help us diagnose broken compiler, and finding out an intuition
 
1219
# of exeext.
 
1220
echo "$as_me:1220: checking for C compiler default output" >&5
 
1221
echo $ECHO_N "checking for C compiler default output... $ECHO_C" >&6
 
1222
ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
 
1223
if { (eval echo "$as_me:1223: \"$ac_link_default\"") >&5
 
1224
  (eval $ac_link_default) 2>&5
 
1225
  ac_status=$?
 
1226
  echo "$as_me:1226: \$? = $ac_status" >&5
 
1227
  (exit $ac_status); }; then
 
1228
  for ac_file in `ls a.exe conftest.exe a.* conftest conftest.* 2>/dev/null`; do
 
1229
  case $ac_file in
 
1230
    *.$ac_ext | *.o | *.obj | *.xcoff | *.tds | *.d | *.pdb ) ;;
 
1231
    a.out ) # We found the default executable, but exeext='' is most
 
1232
            # certainly right.
 
1233
            break;;
 
1234
    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
 
1235
          export ac_cv_exeext
 
1236
          break;;
 
1237
    * ) break;;
 
1238
  esac
 
1239
done
 
1240
else
 
1241
  echo "$as_me: failed program was:" >&5
 
1242
cat conftest.$ac_ext >&5
 
1243
{ { echo "$as_me:1243: error: C compiler cannot create executables" >&5
 
1244
echo "$as_me: error: C compiler cannot create executables" >&2;}
 
1245
   { (exit 77); exit 77; }; }
 
1246
fi
 
1247
 
 
1248
ac_exeext=$ac_cv_exeext
 
1249
echo "$as_me:1249: result: $ac_file" >&5
 
1250
echo "${ECHO_T}$ac_file" >&6
 
1251
 
 
1252
# Check the compiler produces executables we can run.  If not, either
 
1253
# the compiler is broken, or we cross compile.
 
1254
echo "$as_me:1254: checking whether the C compiler works" >&5
 
1255
echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
 
1256
# FIXME: These cross compiler hacks should be removed for Autoconf 3.0
 
1257
# If not cross compiling, check that we can run a simple program.
 
1258
if test "$cross_compiling" != yes; then
 
1259
  if { ac_try='./$ac_file'
 
1260
  { (eval echo "$as_me:1260: \"$ac_try\"") >&5
 
1261
  (eval $ac_try) 2>&5
 
1262
  ac_status=$?
 
1263
  echo "$as_me:1263: \$? = $ac_status" >&5
 
1264
  (exit $ac_status); }; }; then
 
1265
    cross_compiling=no
 
1266
  else
 
1267
    if test "$cross_compiling" = maybe; then
 
1268
        cross_compiling=yes
 
1269
    else
 
1270
        { { echo "$as_me:1270: error: cannot run C compiled programs.
 
1271
If you meant to cross compile, use \`--host'." >&5
 
1272
echo "$as_me: error: cannot run C compiled programs.
 
1273
If you meant to cross compile, use \`--host'." >&2;}
 
1274
   { (exit 1); exit 1; }; }
 
1275
    fi
 
1276
  fi
 
1277
fi
 
1278
echo "$as_me:1278: result: yes" >&5
 
1279
echo "${ECHO_T}yes" >&6
 
1280
 
 
1281
rm -f a.out a.exe conftest$ac_cv_exeext
 
1282
ac_clean_files=$ac_clean_files_save
 
1283
# Check the compiler produces executables we can run.  If not, either
 
1284
# the compiler is broken, or we cross compile.
 
1285
echo "$as_me:1285: checking whether we are cross compiling" >&5
 
1286
echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
 
1287
echo "$as_me:1287: result: $cross_compiling" >&5
 
1288
echo "${ECHO_T}$cross_compiling" >&6
 
1289
 
 
1290
echo "$as_me:1290: checking for executable suffix" >&5
 
1291
echo $ECHO_N "checking for executable suffix... $ECHO_C" >&6
 
1292
if { (eval echo "$as_me:1292: \"$ac_link\"") >&5
 
1293
  (eval $ac_link) 2>&5
 
1294
  ac_status=$?
 
1295
  echo "$as_me:1295: \$? = $ac_status" >&5
 
1296
  (exit $ac_status); }; then
 
1297
  # If both `conftest.exe' and `conftest' are `present' (well, observable)
 
1298
# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
 
1299
# work properly (i.e., refer to `conftest.exe'), while it won't with
 
1300
# `rm'.
 
1301
for ac_file in `(ls conftest.exe; ls conftest; ls conftest.*) 2>/dev/null`; do
 
1302
  case $ac_file in
 
1303
    *.$ac_ext | *.o | *.obj | *.xcoff | *.tds | *.d | *.pdb ) ;;
 
1304
    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
 
1305
          export ac_cv_exeext
 
1306
          break;;
 
1307
    * ) break;;
 
1308
  esac
 
1309
done
 
1310
else
 
1311
  { { echo "$as_me:1311: error: cannot compute EXEEXT: cannot compile and link" >&5
 
1312
echo "$as_me: error: cannot compute EXEEXT: cannot compile and link" >&2;}
 
1313
   { (exit 1); exit 1; }; }
 
1314
fi
 
1315
 
 
1316
rm -f conftest$ac_cv_exeext
 
1317
echo "$as_me:1317: result: $ac_cv_exeext" >&5
 
1318
echo "${ECHO_T}$ac_cv_exeext" >&6
 
1319
 
 
1320
rm -f conftest.$ac_ext
 
1321
EXEEXT=$ac_cv_exeext
 
1322
ac_exeext=$EXEEXT
 
1323
echo "$as_me:1323: checking for object suffix" >&5
 
1324
echo $ECHO_N "checking for object suffix... $ECHO_C" >&6
 
1325
if test "${ac_cv_objext+set}" = set; then
 
1326
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
1327
else
 
1328
  cat >conftest.$ac_ext <<_ACEOF
 
1329
#line 1329 "configure"
 
1330
#include "confdefs.h"
 
1331
 
 
1332
int
 
1333
main ()
 
1334
{
 
1335
 
 
1336
  ;
 
1337
  return 0;
 
1338
}
 
1339
_ACEOF
 
1340
rm -f conftest.o conftest.obj
 
1341
if { (eval echo "$as_me:1341: \"$ac_compile\"") >&5
 
1342
  (eval $ac_compile) 2>&5
 
1343
  ac_status=$?
 
1344
  echo "$as_me:1344: \$? = $ac_status" >&5
 
1345
  (exit $ac_status); }; then
 
1346
  for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
 
1347
  case $ac_file in
 
1348
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb ) ;;
 
1349
    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
 
1350
       break;;
 
1351
  esac
 
1352
done
 
1353
else
 
1354
  echo "$as_me: failed program was:" >&5
 
1355
cat conftest.$ac_ext >&5
 
1356
{ { echo "$as_me:1356: error: cannot compute OBJEXT: cannot compile" >&5
 
1357
echo "$as_me: error: cannot compute OBJEXT: cannot compile" >&2;}
 
1358
   { (exit 1); exit 1; }; }
 
1359
fi
 
1360
 
 
1361
rm -f conftest.$ac_cv_objext conftest.$ac_ext
 
1362
fi
 
1363
echo "$as_me:1363: result: $ac_cv_objext" >&5
 
1364
echo "${ECHO_T}$ac_cv_objext" >&6
 
1365
OBJEXT=$ac_cv_objext
 
1366
ac_objext=$OBJEXT
 
1367
echo "$as_me:1367: checking whether we are using the GNU C compiler" >&5
 
1368
echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
 
1369
if test "${ac_cv_c_compiler_gnu+set}" = set; then
 
1370
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
1371
else
 
1372
  cat >conftest.$ac_ext <<_ACEOF
 
1373
#line 1373 "configure"
 
1374
#include "confdefs.h"
 
1375
 
 
1376
int
 
1377
main ()
 
1378
{
 
1379
#ifndef __GNUC__
 
1380
       choke me
 
1381
#endif
 
1382
 
 
1383
  ;
 
1384
  return 0;
 
1385
}
 
1386
_ACEOF
 
1387
rm -f conftest.$ac_objext
 
1388
if { (eval echo "$as_me:1388: \"$ac_compile\"") >&5
 
1389
  (eval $ac_compile) 2>&5
 
1390
  ac_status=$?
 
1391
  echo "$as_me:1391: \$? = $ac_status" >&5
 
1392
  (exit $ac_status); } &&
 
1393
         { ac_try='test -s conftest.$ac_objext'
 
1394
  { (eval echo "$as_me:1394: \"$ac_try\"") >&5
 
1395
  (eval $ac_try) 2>&5
 
1396
  ac_status=$?
 
1397
  echo "$as_me:1397: \$? = $ac_status" >&5
 
1398
  (exit $ac_status); }; }; then
 
1399
  ac_compiler_gnu=yes
 
1400
else
 
1401
  echo "$as_me: failed program was:" >&5
 
1402
cat conftest.$ac_ext >&5
 
1403
ac_compiler_gnu=no
 
1404
fi
 
1405
rm -f conftest.$ac_objext conftest.$ac_ext
 
1406
ac_cv_c_compiler_gnu=$ac_compiler_gnu
 
1407
 
 
1408
fi
 
1409
echo "$as_me:1409: result: $ac_cv_c_compiler_gnu" >&5
 
1410
echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
 
1411
GCC=`test $ac_compiler_gnu = yes && echo yes`
 
1412
ac_test_CFLAGS=${CFLAGS+set}
 
1413
ac_save_CFLAGS=$CFLAGS
 
1414
CFLAGS="-g"
 
1415
echo "$as_me:1415: checking whether $CC accepts -g" >&5
 
1416
echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
 
1417
if test "${ac_cv_prog_cc_g+set}" = set; then
 
1418
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
1419
else
 
1420
  cat >conftest.$ac_ext <<_ACEOF
 
1421
#line 1421 "configure"
 
1422
#include "confdefs.h"
 
1423
 
 
1424
int
 
1425
main ()
 
1426
{
 
1427
 
 
1428
  ;
 
1429
  return 0;
 
1430
}
 
1431
_ACEOF
 
1432
rm -f conftest.$ac_objext
 
1433
if { (eval echo "$as_me:1433: \"$ac_compile\"") >&5
 
1434
  (eval $ac_compile) 2>&5
 
1435
  ac_status=$?
 
1436
  echo "$as_me:1436: \$? = $ac_status" >&5
 
1437
  (exit $ac_status); } &&
 
1438
         { ac_try='test -s conftest.$ac_objext'
 
1439
  { (eval echo "$as_me:1439: \"$ac_try\"") >&5
 
1440
  (eval $ac_try) 2>&5
 
1441
  ac_status=$?
 
1442
  echo "$as_me:1442: \$? = $ac_status" >&5
 
1443
  (exit $ac_status); }; }; then
 
1444
  ac_cv_prog_cc_g=yes
 
1445
else
 
1446
  echo "$as_me: failed program was:" >&5
 
1447
cat conftest.$ac_ext >&5
 
1448
ac_cv_prog_cc_g=no
 
1449
fi
 
1450
rm -f conftest.$ac_objext conftest.$ac_ext
 
1451
fi
 
1452
echo "$as_me:1452: result: $ac_cv_prog_cc_g" >&5
 
1453
echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
 
1454
if test "$ac_test_CFLAGS" = set; then
 
1455
  CFLAGS=$ac_save_CFLAGS
 
1456
elif test $ac_cv_prog_cc_g = yes; then
 
1457
  if test "$GCC" = yes; then
 
1458
    CFLAGS="-g -O2"
 
1459
  else
 
1460
    CFLAGS="-g"
 
1461
  fi
 
1462
else
 
1463
  if test "$GCC" = yes; then
 
1464
    CFLAGS="-O2"
 
1465
  else
 
1466
    CFLAGS=
 
1467
  fi
 
1468
fi
 
1469
# Some people use a C++ compiler to compile C.  Since we use `exit',
 
1470
# in C++ we need to declare it.  In case someone uses the same compiler
 
1471
# for both compiling C and C++ we need to have the C++ compiler decide
 
1472
# the declaration of exit, since it's the most demanding environment.
 
1473
cat >conftest.$ac_ext <<_ACEOF
 
1474
#ifndef __cplusplus
 
1475
  choke me
 
1476
#endif
 
1477
_ACEOF
 
1478
rm -f conftest.$ac_objext
 
1479
if { (eval echo "$as_me:1479: \"$ac_compile\"") >&5
 
1480
  (eval $ac_compile) 2>&5
 
1481
  ac_status=$?
 
1482
  echo "$as_me:1482: \$? = $ac_status" >&5
 
1483
  (exit $ac_status); } &&
 
1484
         { ac_try='test -s conftest.$ac_objext'
 
1485
  { (eval echo "$as_me:1485: \"$ac_try\"") >&5
 
1486
  (eval $ac_try) 2>&5
 
1487
  ac_status=$?
 
1488
  echo "$as_me:1488: \$? = $ac_status" >&5
 
1489
  (exit $ac_status); }; }; then
 
1490
  for ac_declaration in \
 
1491
   ''\
 
1492
   '#include <stdlib.h>' \
 
1493
   'extern "C" void std::exit (int) throw (); using std::exit;' \
 
1494
   'extern "C" void std::exit (int); using std::exit;' \
 
1495
   'extern "C" void exit (int) throw ();' \
 
1496
   'extern "C" void exit (int);' \
 
1497
   'void exit (int);'
 
1498
do
 
1499
  cat >conftest.$ac_ext <<_ACEOF
 
1500
#line 1500 "configure"
 
1501
#include "confdefs.h"
 
1502
#include <stdlib.h>
 
1503
$ac_declaration
 
1504
int
 
1505
main ()
 
1506
{
 
1507
exit (42);
 
1508
  ;
 
1509
  return 0;
 
1510
}
 
1511
_ACEOF
 
1512
rm -f conftest.$ac_objext
 
1513
if { (eval echo "$as_me:1513: \"$ac_compile\"") >&5
 
1514
  (eval $ac_compile) 2>&5
 
1515
  ac_status=$?
 
1516
  echo "$as_me:1516: \$? = $ac_status" >&5
 
1517
  (exit $ac_status); } &&
 
1518
         { ac_try='test -s conftest.$ac_objext'
 
1519
  { (eval echo "$as_me:1519: \"$ac_try\"") >&5
 
1520
  (eval $ac_try) 2>&5
 
1521
  ac_status=$?
 
1522
  echo "$as_me:1522: \$? = $ac_status" >&5
 
1523
  (exit $ac_status); }; }; then
 
1524
  :
 
1525
else
 
1526
  echo "$as_me: failed program was:" >&5
 
1527
cat conftest.$ac_ext >&5
 
1528
continue
 
1529
fi
 
1530
rm -f conftest.$ac_objext conftest.$ac_ext
 
1531
  cat >conftest.$ac_ext <<_ACEOF
 
1532
#line 1532 "configure"
 
1533
#include "confdefs.h"
 
1534
$ac_declaration
 
1535
int
 
1536
main ()
 
1537
{
 
1538
exit (42);
 
1539
  ;
 
1540
  return 0;
 
1541
}
 
1542
_ACEOF
 
1543
rm -f conftest.$ac_objext
 
1544
if { (eval echo "$as_me:1544: \"$ac_compile\"") >&5
 
1545
  (eval $ac_compile) 2>&5
 
1546
  ac_status=$?
 
1547
  echo "$as_me:1547: \$? = $ac_status" >&5
 
1548
  (exit $ac_status); } &&
 
1549
         { ac_try='test -s conftest.$ac_objext'
 
1550
  { (eval echo "$as_me:1550: \"$ac_try\"") >&5
 
1551
  (eval $ac_try) 2>&5
 
1552
  ac_status=$?
 
1553
  echo "$as_me:1553: \$? = $ac_status" >&5
 
1554
  (exit $ac_status); }; }; then
 
1555
  break
 
1556
else
 
1557
  echo "$as_me: failed program was:" >&5
 
1558
cat conftest.$ac_ext >&5
 
1559
fi
 
1560
rm -f conftest.$ac_objext conftest.$ac_ext
 
1561
done
 
1562
echo '#ifdef __cplusplus' >>confdefs.h
 
1563
echo $ac_declaration      >>confdefs.h
 
1564
echo '#endif'             >>confdefs.h
 
1565
 
 
1566
else
 
1567
  echo "$as_me: failed program was:" >&5
 
1568
cat conftest.$ac_ext >&5
 
1569
fi
 
1570
rm -f conftest.$ac_objext conftest.$ac_ext
 
1571
ac_ext=c
 
1572
ac_cpp='$CPP $CPPFLAGS'
 
1573
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
1574
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
1575
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
1576
 
 
1577
ac_ext=cc
 
1578
ac_cpp='$CXXCPP $CPPFLAGS'
 
1579
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
1580
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
1581
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
1582
if test -n "$ac_tool_prefix"; then
 
1583
  for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl KCC RCC xlC_r xlC
 
1584
  do
 
1585
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
 
1586
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
 
1587
echo "$as_me:1587: checking for $ac_word" >&5
 
1588
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
1589
if test "${ac_cv_prog_CXX+set}" = set; then
 
1590
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
1591
else
 
1592
  if test -n "$CXX"; then
 
1593
  ac_cv_prog_CXX="$CXX" # Let the user override the test.
 
1594
else
 
1595
  ac_save_IFS=$IFS; IFS=$ac_path_separator
 
1596
ac_dummy="$PATH"
 
1597
for ac_dir in $ac_dummy; do
 
1598
  IFS=$ac_save_IFS
 
1599
  test -z "$ac_dir" && ac_dir=.
 
1600
  $as_executable_p "$ac_dir/$ac_word" || continue
 
1601
ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
 
1602
echo "$as_me:1602: found $ac_dir/$ac_word" >&5
 
1603
break
 
1604
done
 
1605
 
 
1606
fi
 
1607
fi
 
1608
CXX=$ac_cv_prog_CXX
 
1609
if test -n "$CXX"; then
 
1610
  echo "$as_me:1610: result: $CXX" >&5
 
1611
echo "${ECHO_T}$CXX" >&6
 
1612
else
 
1613
  echo "$as_me:1613: result: no" >&5
 
1614
echo "${ECHO_T}no" >&6
 
1615
fi
 
1616
 
 
1617
    test -n "$CXX" && break
 
1618
  done
 
1619
fi
 
1620
if test -z "$CXX"; then
 
1621
  ac_ct_CXX=$CXX
 
1622
  for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl KCC RCC xlC_r xlC
 
1623
do
 
1624
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
1625
set dummy $ac_prog; ac_word=$2
 
1626
echo "$as_me:1626: checking for $ac_word" >&5
 
1627
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
1628
if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
 
1629
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
1630
else
 
1631
  if test -n "$ac_ct_CXX"; then
 
1632
  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
 
1633
else
 
1634
  ac_save_IFS=$IFS; IFS=$ac_path_separator
 
1635
ac_dummy="$PATH"
 
1636
for ac_dir in $ac_dummy; do
 
1637
  IFS=$ac_save_IFS
 
1638
  test -z "$ac_dir" && ac_dir=.
 
1639
  $as_executable_p "$ac_dir/$ac_word" || continue
 
1640
ac_cv_prog_ac_ct_CXX="$ac_prog"
 
1641
echo "$as_me:1641: found $ac_dir/$ac_word" >&5
 
1642
break
 
1643
done
 
1644
 
 
1645
fi
 
1646
fi
 
1647
ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
 
1648
if test -n "$ac_ct_CXX"; then
 
1649
  echo "$as_me:1649: result: $ac_ct_CXX" >&5
 
1650
echo "${ECHO_T}$ac_ct_CXX" >&6
 
1651
else
 
1652
  echo "$as_me:1652: result: no" >&5
 
1653
echo "${ECHO_T}no" >&6
 
1654
fi
 
1655
 
 
1656
  test -n "$ac_ct_CXX" && break
 
1657
done
 
1658
test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
 
1659
 
 
1660
  CXX=$ac_ct_CXX
 
1661
fi
 
1662
 
 
1663
echo "$as_me:1663: checking whether we are using the GNU C++ compiler" >&5
 
1664
echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
 
1665
if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
 
1666
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
1667
else
 
1668
  cat >conftest.$ac_ext <<_ACEOF
 
1669
#line 1669 "configure"
 
1670
#include "confdefs.h"
 
1671
 
 
1672
int
 
1673
main ()
 
1674
{
 
1675
#ifndef __GNUC__
 
1676
       choke me
 
1677
#endif
 
1678
 
 
1679
  ;
 
1680
  return 0;
 
1681
}
 
1682
_ACEOF
 
1683
rm -f conftest.$ac_objext
 
1684
if { (eval echo "$as_me:1684: \"$ac_compile\"") >&5
 
1685
  (eval $ac_compile) 2>&5
 
1686
  ac_status=$?
 
1687
  echo "$as_me:1687: \$? = $ac_status" >&5
 
1688
  (exit $ac_status); } &&
 
1689
         { ac_try='test -s conftest.$ac_objext'
 
1690
  { (eval echo "$as_me:1690: \"$ac_try\"") >&5
 
1691
  (eval $ac_try) 2>&5
 
1692
  ac_status=$?
 
1693
  echo "$as_me:1693: \$? = $ac_status" >&5
 
1694
  (exit $ac_status); }; }; then
 
1695
  ac_compiler_gnu=yes
 
1696
else
 
1697
  echo "$as_me: failed program was:" >&5
 
1698
cat conftest.$ac_ext >&5
 
1699
ac_compiler_gnu=no
 
1700
fi
 
1701
rm -f conftest.$ac_objext conftest.$ac_ext
 
1702
ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
 
1703
 
 
1704
fi
 
1705
echo "$as_me:1705: result: $ac_cv_cxx_compiler_gnu" >&5
 
1706
echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
 
1707
GXX=`test $ac_compiler_gnu = yes && echo yes`
 
1708
ac_test_CXXFLAGS=${CXXFLAGS+set}
 
1709
ac_save_CXXFLAGS=$CXXFLAGS
 
1710
CXXFLAGS="-g"
 
1711
echo "$as_me:1711: checking whether $CXX accepts -g" >&5
 
1712
echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
 
1713
if test "${ac_cv_prog_cxx_g+set}" = set; then
 
1714
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
1715
else
 
1716
  cat >conftest.$ac_ext <<_ACEOF
 
1717
#line 1717 "configure"
 
1718
#include "confdefs.h"
 
1719
 
 
1720
int
 
1721
main ()
 
1722
{
 
1723
 
 
1724
  ;
 
1725
  return 0;
 
1726
}
 
1727
_ACEOF
 
1728
rm -f conftest.$ac_objext
 
1729
if { (eval echo "$as_me:1729: \"$ac_compile\"") >&5
 
1730
  (eval $ac_compile) 2>&5
 
1731
  ac_status=$?
 
1732
  echo "$as_me:1732: \$? = $ac_status" >&5
 
1733
  (exit $ac_status); } &&
 
1734
         { ac_try='test -s conftest.$ac_objext'
 
1735
  { (eval echo "$as_me:1735: \"$ac_try\"") >&5
 
1736
  (eval $ac_try) 2>&5
 
1737
  ac_status=$?
 
1738
  echo "$as_me:1738: \$? = $ac_status" >&5
 
1739
  (exit $ac_status); }; }; then
 
1740
  ac_cv_prog_cxx_g=yes
 
1741
else
 
1742
  echo "$as_me: failed program was:" >&5
 
1743
cat conftest.$ac_ext >&5
 
1744
ac_cv_prog_cxx_g=no
 
1745
fi
 
1746
rm -f conftest.$ac_objext conftest.$ac_ext
 
1747
fi
 
1748
echo "$as_me:1748: result: $ac_cv_prog_cxx_g" >&5
 
1749
echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
 
1750
if test "$ac_test_CXXFLAGS" = set; then
 
1751
  CXXFLAGS=$ac_save_CXXFLAGS
 
1752
elif test $ac_cv_prog_cxx_g = yes; then
 
1753
  if test "$GXX" = yes; then
 
1754
    CXXFLAGS="-g -O2"
 
1755
  else
 
1756
    CXXFLAGS="-g"
 
1757
  fi
 
1758
else
 
1759
  if test "$GXX" = yes; then
 
1760
    CXXFLAGS="-O2"
 
1761
  else
 
1762
    CXXFLAGS=
 
1763
  fi
 
1764
fi
 
1765
for ac_declaration in \
 
1766
   ''\
 
1767
   '#include <stdlib.h>' \
 
1768
   'extern "C" void std::exit (int) throw (); using std::exit;' \
 
1769
   'extern "C" void std::exit (int); using std::exit;' \
 
1770
   'extern "C" void exit (int) throw ();' \
 
1771
   'extern "C" void exit (int);' \
 
1772
   'void exit (int);'
 
1773
do
 
1774
  cat >conftest.$ac_ext <<_ACEOF
 
1775
#line 1775 "configure"
 
1776
#include "confdefs.h"
 
1777
#include <stdlib.h>
 
1778
$ac_declaration
 
1779
int
 
1780
main ()
 
1781
{
 
1782
exit (42);
 
1783
  ;
 
1784
  return 0;
 
1785
}
 
1786
_ACEOF
 
1787
rm -f conftest.$ac_objext
 
1788
if { (eval echo "$as_me:1788: \"$ac_compile\"") >&5
 
1789
  (eval $ac_compile) 2>&5
 
1790
  ac_status=$?
 
1791
  echo "$as_me:1791: \$? = $ac_status" >&5
 
1792
  (exit $ac_status); } &&
 
1793
         { ac_try='test -s conftest.$ac_objext'
 
1794
  { (eval echo "$as_me:1794: \"$ac_try\"") >&5
 
1795
  (eval $ac_try) 2>&5
 
1796
  ac_status=$?
 
1797
  echo "$as_me:1797: \$? = $ac_status" >&5
 
1798
  (exit $ac_status); }; }; then
 
1799
  :
 
1800
else
 
1801
  echo "$as_me: failed program was:" >&5
 
1802
cat conftest.$ac_ext >&5
 
1803
continue
 
1804
fi
 
1805
rm -f conftest.$ac_objext conftest.$ac_ext
 
1806
  cat >conftest.$ac_ext <<_ACEOF
 
1807
#line 1807 "configure"
 
1808
#include "confdefs.h"
 
1809
$ac_declaration
 
1810
int
 
1811
main ()
 
1812
{
 
1813
exit (42);
 
1814
  ;
 
1815
  return 0;
 
1816
}
 
1817
_ACEOF
 
1818
rm -f conftest.$ac_objext
 
1819
if { (eval echo "$as_me:1819: \"$ac_compile\"") >&5
 
1820
  (eval $ac_compile) 2>&5
 
1821
  ac_status=$?
 
1822
  echo "$as_me:1822: \$? = $ac_status" >&5
 
1823
  (exit $ac_status); } &&
 
1824
         { ac_try='test -s conftest.$ac_objext'
 
1825
  { (eval echo "$as_me:1825: \"$ac_try\"") >&5
 
1826
  (eval $ac_try) 2>&5
 
1827
  ac_status=$?
 
1828
  echo "$as_me:1828: \$? = $ac_status" >&5
 
1829
  (exit $ac_status); }; }; then
 
1830
  break
 
1831
else
 
1832
  echo "$as_me: failed program was:" >&5
 
1833
cat conftest.$ac_ext >&5
 
1834
fi
 
1835
rm -f conftest.$ac_objext conftest.$ac_ext
 
1836
done
 
1837
echo '#ifdef __cplusplus' >>confdefs.h
 
1838
echo $ac_declaration      >>confdefs.h
 
1839
echo '#endif'             >>confdefs.h
 
1840
 
 
1841
ac_ext=c
 
1842
ac_cpp='$CPP $CPPFLAGS'
 
1843
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
1844
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
1845
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
1846
 
 
1847
ac_ext=cc
 
1848
ac_cpp='$CXXCPP $CPPFLAGS'
 
1849
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
1850
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
1851
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
1852
 
 
1853
if test "$cross_compiling" = no; then
 
1854
        echo "$as_me:1854: checking that C++ compiler can compile simple program" >&5
 
1855
echo $ECHO_N "checking that C++ compiler can compile simple program... $ECHO_C" >&6
 
1856
fi
 
1857
if test "$cross_compiling" = yes; then
 
1858
  :
 
1859
else
 
1860
  cat >conftest.$ac_ext <<_ACEOF
 
1861
#line 1861 "configure"
 
1862
#include "confdefs.h"
 
1863
int main() { return 0; }
 
1864
_ACEOF
 
1865
rm -f conftest$ac_exeext
 
1866
if { (eval echo "$as_me:1866: \"$ac_link\"") >&5
 
1867
  (eval $ac_link) 2>&5
 
1868
  ac_status=$?
 
1869
  echo "$as_me:1869: \$? = $ac_status" >&5
 
1870
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
1871
  { (eval echo "$as_me:1871: \"$ac_try\"") >&5
 
1872
  (eval $ac_try) 2>&5
 
1873
  ac_status=$?
 
1874
  echo "$as_me:1874: \$? = $ac_status" >&5
 
1875
  (exit $ac_status); }; }; then
 
1876
  echo "$as_me:1876: result: yes" >&5
 
1877
echo "${ECHO_T}yes" >&6
 
1878
else
 
1879
  echo "$as_me: program exited with status $ac_status" >&5
 
1880
echo "$as_me: failed program was:" >&5
 
1881
cat conftest.$ac_ext >&5
 
1882
echo "$as_me:1882: result: no" >&5
 
1883
echo "${ECHO_T}no" >&6;{ { echo "$as_me:1883: error: a working C++ compiler is required" >&5
 
1884
echo "$as_me: error: a working C++ compiler is required" >&2;}
 
1885
   { (exit 1); exit 1; }; }
 
1886
fi
 
1887
rm -f core core.* *.core conftest$ac_exeext conftest.$ac_ext
 
1888
fi
 
1889
if test "$cross_compiling" = no; then
 
1890
        echo "$as_me:1890: checking that C++ static constructors and destructors are called" >&5
 
1891
echo $ECHO_N "checking that C++ static constructors and destructors are called... $ECHO_C" >&6
 
1892
fi
 
1893
if test "$cross_compiling" = yes; then
 
1894
  :
 
1895
else
 
1896
  cat >conftest.$ac_ext <<_ACEOF
 
1897
#line 1897 "configure"
 
1898
#include "confdefs.h"
 
1899
 
 
1900
extern "C" {
 
1901
  void _exit(int);
 
1902
}
 
1903
int i;
 
1904
struct A {
 
1905
  char dummy;
 
1906
  A() { i = 1; }
 
1907
  ~A() { if (i == 1) _exit(0); }
 
1908
};
 
1909
A a;
 
1910
int main() { return 1; }
 
1911
 
 
1912
_ACEOF
 
1913
rm -f conftest$ac_exeext
 
1914
if { (eval echo "$as_me:1914: \"$ac_link\"") >&5
 
1915
  (eval $ac_link) 2>&5
 
1916
  ac_status=$?
 
1917
  echo "$as_me:1917: \$? = $ac_status" >&5
 
1918
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
1919
  { (eval echo "$as_me:1919: \"$ac_try\"") >&5
 
1920
  (eval $ac_try) 2>&5
 
1921
  ac_status=$?
 
1922
  echo "$as_me:1922: \$? = $ac_status" >&5
 
1923
  (exit $ac_status); }; }; then
 
1924
  echo "$as_me:1924: result: yes" >&5
 
1925
echo "${ECHO_T}yes" >&6
 
1926
else
 
1927
  echo "$as_me: program exited with status $ac_status" >&5
 
1928
echo "$as_me: failed program was:" >&5
 
1929
cat conftest.$ac_ext >&5
 
1930
echo "$as_me:1930: result: no" >&5
 
1931
echo "${ECHO_T}no" >&6;{ { echo "$as_me:1931: error: a working C++ compiler is required" >&5
 
1932
echo "$as_me: error: a working C++ compiler is required" >&2;}
 
1933
   { (exit 1); exit 1; }; }
 
1934
fi
 
1935
rm -f core core.* *.core conftest$ac_exeext conftest.$ac_ext
 
1936
fi
 
1937
echo "$as_me:1937: checking that header files support C++" >&5
 
1938
echo $ECHO_N "checking that header files support C++... $ECHO_C" >&6
 
1939
cat >conftest.$ac_ext <<_ACEOF
 
1940
#line 1940 "configure"
 
1941
#include "confdefs.h"
 
1942
#include <stdio.h>
 
1943
int
 
1944
main ()
 
1945
{
 
1946
fopen(0, 0);
 
1947
  ;
 
1948
  return 0;
 
1949
}
 
1950
_ACEOF
 
1951
rm -f conftest.$ac_objext conftest$ac_exeext
 
1952
if { (eval echo "$as_me:1952: \"$ac_link\"") >&5
 
1953
  (eval $ac_link) 2>&5
 
1954
  ac_status=$?
 
1955
  echo "$as_me:1955: \$? = $ac_status" >&5
 
1956
  (exit $ac_status); } &&
 
1957
         { ac_try='test -s conftest$ac_exeext'
 
1958
  { (eval echo "$as_me:1958: \"$ac_try\"") >&5
 
1959
  (eval $ac_try) 2>&5
 
1960
  ac_status=$?
 
1961
  echo "$as_me:1961: \$? = $ac_status" >&5
 
1962
  (exit $ac_status); }; }; then
 
1963
  echo "$as_me:1963: result: yes" >&5
 
1964
echo "${ECHO_T}yes" >&6
 
1965
else
 
1966
  echo "$as_me: failed program was:" >&5
 
1967
cat conftest.$ac_ext >&5
 
1968
echo "$as_me:1968: result: no" >&5
 
1969
echo "${ECHO_T}no" >&6;{ { echo "$as_me:1969: error: header files do not support C++ (if you are using a version of gcc/g++ earlier than 2.5, you should install libg++)" >&5
 
1970
echo "$as_me: error: header files do not support C++ (if you are using a version of gcc/g++ earlier than 2.5, you should install libg++)" >&2;}
 
1971
   { (exit 1); exit 1; }; }
 
1972
fi
 
1973
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
1974
ac_ext=c
 
1975
ac_cpp='$CPP $CPPFLAGS'
 
1976
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
1977
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
1978
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
1979
 
 
1980
echo "$as_me:1980: checking whether character set is EBCDIC" >&5
 
1981
echo $ECHO_N "checking whether character set is EBCDIC... $ECHO_C" >&6
 
1982
cat >conftest.$ac_ext <<_ACEOF
 
1983
#line 1983 "configure"
 
1984
#include "confdefs.h"
 
1985
 
 
1986
int
 
1987
main ()
 
1988
{
 
1989
/* Treat any failure as ASCII for compatibility with existing art.
 
1990
    Use compile-time rather than run-time tests for cross-compiler
 
1991
    tolerance. */
 
1992
#if '0' != 240
 
1993
make an error "Character set is not EBCDIC"
 
1994
#endif
 
1995
  ;
 
1996
  return 0;
 
1997
}
 
1998
_ACEOF
 
1999
rm -f conftest.$ac_objext
 
2000
if { (eval echo "$as_me:2000: \"$ac_compile\"") >&5
 
2001
  (eval $ac_compile) 2>&5
 
2002
  ac_status=$?
 
2003
  echo "$as_me:2003: \$? = $ac_status" >&5
 
2004
  (exit $ac_status); } &&
 
2005
         { ac_try='test -s conftest.$ac_objext'
 
2006
  { (eval echo "$as_me:2006: \"$ac_try\"") >&5
 
2007
  (eval $ac_try) 2>&5
 
2008
  ac_status=$?
 
2009
  echo "$as_me:2009: \$? = $ac_status" >&5
 
2010
  (exit $ac_status); }; }; then
 
2011
  groff_cv_ebcdic="yes"
 
2012
 TTYDEVDIRS="font/devcp1047"
 
2013
 echo "$as_me:2013: result: yes" >&5
 
2014
echo "${ECHO_T}yes" >&6
 
2015
 cat >>confdefs.h <<\EOF
 
2016
#define IS_EBCDIC_HOST 1
 
2017
EOF
 
2018
 
 
2019
else
 
2020
  echo "$as_me: failed program was:" >&5
 
2021
cat conftest.$ac_ext >&5
 
2022
groff_cv_ebcdic="no"
 
2023
 TTYDEVDIRS="font/devascii font/devlatin1 font/devutf8"
 
2024
 echo "$as_me:2024: result: no" >&5
 
2025
echo "${ECHO_T}no" >&6
 
2026
fi
 
2027
rm -f conftest.$ac_objext conftest.$ac_ext
 
2028
 
 
2029
if test "$groff_cv_ebcdic" = "yes"; then
 
2030
        echo "$as_me:2030: checking for OS/390 Unix" >&5
 
2031
echo $ECHO_N "checking for OS/390 Unix... $ECHO_C" >&6
 
2032
        case `uname` in
 
2033
        OS/390)
 
2034
                CFLAGS="$CFLAGS -D_ALL_SOURCE"
 
2035
                echo "$as_me:2035: result: yes" >&5
 
2036
echo "${ECHO_T}yes" >&6 ;;
 
2037
        *)
 
2038
                echo "$as_me:2038: result: no" >&5
 
2039
echo "${ECHO_T}no" >&6 ;;
 
2040
        esac
 
2041
fi
 
2042
if test -z "$PSPRINT"; then
 
2043
        for ac_prog in lpr
 
2044
do
 
2045
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
2046
set dummy $ac_prog; ac_word=$2
 
2047
echo "$as_me:2047: checking for $ac_word" >&5
 
2048
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
2049
if test "${ac_cv_prog_LPR+set}" = set; then
 
2050
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
2051
else
 
2052
  if test -n "$LPR"; then
 
2053
  ac_cv_prog_LPR="$LPR" # Let the user override the test.
 
2054
else
 
2055
  ac_save_IFS=$IFS; IFS=$ac_path_separator
 
2056
ac_dummy="$PATH"
 
2057
for ac_dir in $ac_dummy; do
 
2058
  IFS=$ac_save_IFS
 
2059
  test -z "$ac_dir" && ac_dir=.
 
2060
  $as_executable_p "$ac_dir/$ac_word" || continue
 
2061
ac_cv_prog_LPR="$ac_prog"
 
2062
echo "$as_me:2062: found $ac_dir/$ac_word" >&5
 
2063
break
 
2064
done
 
2065
 
 
2066
fi
 
2067
fi
 
2068
LPR=$ac_cv_prog_LPR
 
2069
if test -n "$LPR"; then
 
2070
  echo "$as_me:2070: result: $LPR" >&5
 
2071
echo "${ECHO_T}$LPR" >&6
 
2072
else
 
2073
  echo "$as_me:2073: result: no" >&5
 
2074
echo "${ECHO_T}no" >&6
 
2075
fi
 
2076
 
 
2077
  test -n "$LPR" && break
 
2078
done
 
2079
 
 
2080
        for ac_prog in lp
 
2081
do
 
2082
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
2083
set dummy $ac_prog; ac_word=$2
 
2084
echo "$as_me:2084: checking for $ac_word" >&5
 
2085
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
2086
if test "${ac_cv_prog_LP+set}" = set; then
 
2087
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
2088
else
 
2089
  if test -n "$LP"; then
 
2090
  ac_cv_prog_LP="$LP" # Let the user override the test.
 
2091
else
 
2092
  ac_save_IFS=$IFS; IFS=$ac_path_separator
 
2093
ac_dummy="$PATH"
 
2094
for ac_dir in $ac_dummy; do
 
2095
  IFS=$ac_save_IFS
 
2096
  test -z "$ac_dir" && ac_dir=.
 
2097
  $as_executable_p "$ac_dir/$ac_word" || continue
 
2098
ac_cv_prog_LP="$ac_prog"
 
2099
echo "$as_me:2099: found $ac_dir/$ac_word" >&5
 
2100
break
 
2101
done
 
2102
 
 
2103
fi
 
2104
fi
 
2105
LP=$ac_cv_prog_LP
 
2106
if test -n "$LP"; then
 
2107
  echo "$as_me:2107: result: $LP" >&5
 
2108
echo "${ECHO_T}$LP" >&6
 
2109
else
 
2110
  echo "$as_me:2110: result: no" >&5
 
2111
echo "${ECHO_T}no" >&6
 
2112
fi
 
2113
 
 
2114
  test -n "$LP" && break
 
2115
done
 
2116
 
 
2117
        if test -n "$LPR" && test -n "$LP"; then
 
2118
                # HP-UX provides an lpr command that emulates lpr using lp,
 
2119
                # but it doesn't have lpq; in this case we want to use lp
 
2120
                # rather than lpr.
 
2121
                for ac_prog in lpq
 
2122
do
 
2123
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
2124
set dummy $ac_prog; ac_word=$2
 
2125
echo "$as_me:2125: checking for $ac_word" >&5
 
2126
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
2127
if test "${ac_cv_prog_LPQ+set}" = set; then
 
2128
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
2129
else
 
2130
  if test -n "$LPQ"; then
 
2131
  ac_cv_prog_LPQ="$LPQ" # Let the user override the test.
 
2132
else
 
2133
  ac_save_IFS=$IFS; IFS=$ac_path_separator
 
2134
ac_dummy="$PATH"
 
2135
for ac_dir in $ac_dummy; do
 
2136
  IFS=$ac_save_IFS
 
2137
  test -z "$ac_dir" && ac_dir=.
 
2138
  $as_executable_p "$ac_dir/$ac_word" || continue
 
2139
ac_cv_prog_LPQ="$ac_prog"
 
2140
echo "$as_me:2140: found $ac_dir/$ac_word" >&5
 
2141
break
 
2142
done
 
2143
 
 
2144
fi
 
2145
fi
 
2146
LPQ=$ac_cv_prog_LPQ
 
2147
if test -n "$LPQ"; then
 
2148
  echo "$as_me:2148: result: $LPQ" >&5
 
2149
echo "${ECHO_T}$LPQ" >&6
 
2150
else
 
2151
  echo "$as_me:2151: result: no" >&5
 
2152
echo "${ECHO_T}no" >&6
 
2153
fi
 
2154
 
 
2155
  test -n "$LPQ" && break
 
2156
done
 
2157
 
 
2158
                test -n "$LPQ" || LPR=
 
2159
        fi
 
2160
        if test -n "$LPR"; then
 
2161
                PSPRINT="$LPR"
 
2162
        elif test -n "$LP"; then
 
2163
                PSPRINT="$LP"
 
2164
        fi
 
2165
fi
 
2166
 
 
2167
echo "$as_me:2167: checking for command to use for printing PostScript files" >&5
 
2168
echo $ECHO_N "checking for command to use for printing PostScript files... $ECHO_C" >&6
 
2169
echo "$as_me:2169: result: $PSPRINT" >&5
 
2170
echo "${ECHO_T}$PSPRINT" >&6
 
2171
# Figure out DVIPRINT from PSPRINT.
 
2172
echo "$as_me:2172: checking for command to use for printing dvi files" >&5
 
2173
echo $ECHO_N "checking for command to use for printing dvi files... $ECHO_C" >&6
 
2174
if test -n "$PSPRINT" && test -z "$DVIPRINT"; then
 
2175
        if test "X$PSPRINT" = "Xlpr"; then
 
2176
                DVIPRINT="lpr -d"
 
2177
        else
 
2178
                DVIPRINT="$PSPRINT"
 
2179
        fi
 
2180
fi
 
2181
 
 
2182
echo "$as_me:2182: result: $DVIPRINT" >&5
 
2183
echo "${ECHO_T}$DVIPRINT" >&6
 
2184
# Extract the first word of "perl", so it can be a program name with args.
 
2185
set dummy perl; ac_word=$2
 
2186
echo "$as_me:2186: checking for $ac_word" >&5
 
2187
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
2188
if test "${ac_cv_path_PERLPATH+set}" = set; then
 
2189
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
2190
else
 
2191
  case $PERLPATH in
 
2192
  [\\/]* | ?:[\\/]*)
 
2193
  ac_cv_path_PERLPATH="$PERLPATH" # Let the user override the test with a path.
 
2194
  ;;
 
2195
  *)
 
2196
  ac_save_IFS=$IFS; IFS=$ac_path_separator
 
2197
ac_dummy="$PATH"
 
2198
for ac_dir in $ac_dummy; do
 
2199
  IFS=$ac_save_IFS
 
2200
  test -z "$ac_dir" && ac_dir=.
 
2201
  if $as_executable_p "$ac_dir/$ac_word"; then
 
2202
   ac_cv_path_PERLPATH="$ac_dir/$ac_word"
 
2203
   echo "$as_me:2203: found $ac_dir/$ac_word" >&5
 
2204
   break
 
2205
fi
 
2206
done
 
2207
 
 
2208
  test -z "$ac_cv_path_PERLPATH" && ac_cv_path_PERLPATH="/usr/bin/perl"
 
2209
  ;;
 
2210
esac
 
2211
fi
 
2212
PERLPATH=$ac_cv_path_PERLPATH
 
2213
 
 
2214
if test -n "$PERLPATH"; then
 
2215
  echo "$as_me:2215: result: $PERLPATH" >&5
 
2216
echo "${ECHO_T}$PERLPATH" >&6
 
2217
else
 
2218
  echo "$as_me:2218: result: no" >&5
 
2219
echo "${ECHO_T}no" >&6
 
2220
fi
 
2221
 
 
2222
for ac_prog in byacc 'bison -y'
 
2223
do
 
2224
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
2225
set dummy $ac_prog; ac_word=$2
 
2226
echo "$as_me:2226: checking for $ac_word" >&5
 
2227
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
2228
if test "${ac_cv_prog_YACC+set}" = set; then
 
2229
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
2230
else
 
2231
  if test -n "$YACC"; then
 
2232
  ac_cv_prog_YACC="$YACC" # Let the user override the test.
 
2233
else
 
2234
  ac_save_IFS=$IFS; IFS=$ac_path_separator
 
2235
ac_dummy="$PATH"
 
2236
for ac_dir in $ac_dummy; do
 
2237
  IFS=$ac_save_IFS
 
2238
  test -z "$ac_dir" && ac_dir=.
 
2239
  $as_executable_p "$ac_dir/$ac_word" || continue
 
2240
ac_cv_prog_YACC="$ac_prog"
 
2241
echo "$as_me:2241: found $ac_dir/$ac_word" >&5
 
2242
break
 
2243
done
 
2244
 
 
2245
fi
 
2246
fi
 
2247
YACC=$ac_cv_prog_YACC
 
2248
if test -n "$YACC"; then
 
2249
  echo "$as_me:2249: result: $YACC" >&5
 
2250
echo "${ECHO_T}$YACC" >&6
 
2251
else
 
2252
  echo "$as_me:2252: result: no" >&5
 
2253
echo "${ECHO_T}no" >&6
 
2254
fi
 
2255
 
 
2256
  test -n "$YACC" && break
 
2257
done
 
2258
test -n "$YACC" || YACC="yacc"
 
2259
 
 
2260
if test -n "$ac_tool_prefix"; then
 
2261
  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
 
2262
set dummy ${ac_tool_prefix}ranlib; ac_word=$2
 
2263
echo "$as_me:2263: checking for $ac_word" >&5
 
2264
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
2265
if test "${ac_cv_prog_RANLIB+set}" = set; then
 
2266
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
2267
else
 
2268
  if test -n "$RANLIB"; then
 
2269
  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
 
2270
else
 
2271
  ac_save_IFS=$IFS; IFS=$ac_path_separator
 
2272
ac_dummy="$PATH"
 
2273
for ac_dir in $ac_dummy; do
 
2274
  IFS=$ac_save_IFS
 
2275
  test -z "$ac_dir" && ac_dir=.
 
2276
  $as_executable_p "$ac_dir/$ac_word" || continue
 
2277
ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
 
2278
echo "$as_me:2278: found $ac_dir/$ac_word" >&5
 
2279
break
 
2280
done
 
2281
 
 
2282
fi
 
2283
fi
 
2284
RANLIB=$ac_cv_prog_RANLIB
 
2285
if test -n "$RANLIB"; then
 
2286
  echo "$as_me:2286: result: $RANLIB" >&5
 
2287
echo "${ECHO_T}$RANLIB" >&6
 
2288
else
 
2289
  echo "$as_me:2289: result: no" >&5
 
2290
echo "${ECHO_T}no" >&6
 
2291
fi
 
2292
 
 
2293
fi
 
2294
if test -z "$ac_cv_prog_RANLIB"; then
 
2295
  ac_ct_RANLIB=$RANLIB
 
2296
  # Extract the first word of "ranlib", so it can be a program name with args.
 
2297
set dummy ranlib; ac_word=$2
 
2298
echo "$as_me:2298: checking for $ac_word" >&5
 
2299
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
2300
if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
 
2301
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
2302
else
 
2303
  if test -n "$ac_ct_RANLIB"; then
 
2304
  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
 
2305
else
 
2306
  ac_save_IFS=$IFS; IFS=$ac_path_separator
 
2307
ac_dummy="$PATH"
 
2308
for ac_dir in $ac_dummy; do
 
2309
  IFS=$ac_save_IFS
 
2310
  test -z "$ac_dir" && ac_dir=.
 
2311
  $as_executable_p "$ac_dir/$ac_word" || continue
 
2312
ac_cv_prog_ac_ct_RANLIB="ranlib"
 
2313
echo "$as_me:2313: found $ac_dir/$ac_word" >&5
 
2314
break
 
2315
done
 
2316
 
 
2317
  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
 
2318
fi
 
2319
fi
 
2320
ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
 
2321
if test -n "$ac_ct_RANLIB"; then
 
2322
  echo "$as_me:2322: result: $ac_ct_RANLIB" >&5
 
2323
echo "${ECHO_T}$ac_ct_RANLIB" >&6
 
2324
else
 
2325
  echo "$as_me:2325: result: no" >&5
 
2326
echo "${ECHO_T}no" >&6
 
2327
fi
 
2328
 
 
2329
  RANLIB=$ac_ct_RANLIB
 
2330
else
 
2331
  RANLIB="$ac_cv_prog_RANLIB"
 
2332
fi
 
2333
 
 
2334
ac_aux_dir=
 
2335
for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
 
2336
  if test -f $ac_dir/install-sh; then
 
2337
    ac_aux_dir=$ac_dir
 
2338
    ac_install_sh="$ac_aux_dir/install-sh -c"
 
2339
    break
 
2340
  elif test -f $ac_dir/install.sh; then
 
2341
    ac_aux_dir=$ac_dir
 
2342
    ac_install_sh="$ac_aux_dir/install.sh -c"
 
2343
    break
 
2344
  elif test -f $ac_dir/shtool; then
 
2345
    ac_aux_dir=$ac_dir
 
2346
    ac_install_sh="$ac_aux_dir/shtool install -c"
 
2347
    break
 
2348
  fi
 
2349
done
 
2350
if test -z "$ac_aux_dir"; then
 
2351
  { { echo "$as_me:2351: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
 
2352
echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
 
2353
   { (exit 1); exit 1; }; }
 
2354
fi
 
2355
ac_config_guess="$SHELL $ac_aux_dir/config.guess"
 
2356
ac_config_sub="$SHELL $ac_aux_dir/config.sub"
 
2357
ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
 
2358
 
 
2359
ac_dir=`cd $ac_aux_dir; pwd`
 
2360
ac_install_sh="$ac_dir/install-sh -c"
 
2361
# Find a good install program.  We prefer a C program (faster),
 
2362
# so one script is as good as another.  But avoid the broken or
 
2363
# incompatible versions:
 
2364
# SysV /etc/install, /usr/sbin/install
 
2365
# SunOS /usr/etc/install
 
2366
# IRIX /sbin/install
 
2367
# AIX /bin/install
 
2368
# AmigaOS /C/install, which installs bootblocks on floppy discs
 
2369
# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
 
2370
# AFS /usr/afsws/bin/install, which mishandles nonexistent args
 
2371
# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 
2372
# ./install, which can be erroneously created by make from ./install.sh.
 
2373
echo "$as_me:2373: checking for a BSD compatible install" >&5
 
2374
echo $ECHO_N "checking for a BSD compatible install... $ECHO_C" >&6
 
2375
if test -z "$INSTALL"; then
 
2376
if test "${ac_cv_path_install+set}" = set; then
 
2377
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
2378
else
 
2379
    ac_save_IFS=$IFS; IFS=$ac_path_separator
 
2380
  for ac_dir in $PATH; do
 
2381
    IFS=$ac_save_IFS
 
2382
    # Account for people who put trailing slashes in PATH elements.
 
2383
    case $ac_dir/ in
 
2384
    / | ./ | .// | /cC/* \
 
2385
    | /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* \
 
2386
    | /usr/ucb/* ) ;;
 
2387
    *)
 
2388
      # OSF1 and SCO ODT 3.0 have their own names for install.
 
2389
      # Don't use installbsd from OSF since it installs stuff as root
 
2390
      # by default.
 
2391
      for ac_prog in ginstall scoinst install; do
 
2392
        if $as_executable_p "$ac_dir/$ac_prog"; then
 
2393
          if test $ac_prog = install &&
 
2394
            grep dspmsg "$ac_dir/$ac_prog" >/dev/null 2>&1; then
 
2395
            # AIX install.  It has an incompatible calling convention.
 
2396
            :
 
2397
          elif test $ac_prog = install &&
 
2398
            grep pwplus "$ac_dir/$ac_prog" >/dev/null 2>&1; then
 
2399
            # program-specific install script used by HP pwplus--don't use.
 
2400
            :
 
2401
          else
 
2402
            ac_cv_path_install="$ac_dir/$ac_prog -c"
 
2403
            break 2
 
2404
          fi
 
2405
        fi
 
2406
      done
 
2407
      ;;
 
2408
    esac
 
2409
  done
 
2410
 
 
2411
fi
 
2412
  if test "${ac_cv_path_install+set}" = set; then
 
2413
    INSTALL=$ac_cv_path_install
 
2414
  else
 
2415
    # As a last resort, use the slow shell script.  We don't cache a
 
2416
    # path for INSTALL within a source directory, because that will
 
2417
    # break other packages using the cache if that directory is
 
2418
    # removed, or if the path is relative.
 
2419
    INSTALL=$ac_install_sh
 
2420
  fi
 
2421
fi
 
2422
echo "$as_me:2422: result: $INSTALL" >&5
 
2423
echo "${ECHO_T}$INSTALL" >&6
 
2424
 
 
2425
# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
 
2426
# It thinks the first close brace ends the variable substitution.
 
2427
test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
 
2428
 
 
2429
test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
 
2430
 
 
2431
test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 
2432
 
 
2433
echo "$as_me:2433: checking whether ln -s works" >&5
 
2434
echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
 
2435
LN_S=$as_ln_s
 
2436
if test "$LN_S" = "ln -s"; then
 
2437
  echo "$as_me:2437: result: yes" >&5
 
2438
echo "${ECHO_T}yes" >&6
 
2439
else
 
2440
  echo "$as_me:2440: result: no, using $LN_S" >&5
 
2441
echo "${ECHO_T}no, using $LN_S" >&6
 
2442
fi
 
2443
 
 
2444
echo "$as_me:2444: checking for csh hash hack" >&5
 
2445
echo $ECHO_N "checking for csh hash hack... $ECHO_C" >&6
 
2446
cat <<EOF >conftest.sh
 
2447
#!/bin/sh
 
2448
true || exit 0
 
2449
export PATH || exit 0
 
2450
exit 1
 
2451
EOF
 
2452
chmod +x conftest.sh
 
2453
if echo ./conftest.sh | (csh >/dev/null 2>&1) >/dev/null 2>&1; then
 
2454
        echo "$as_me:2454: result: yes" >&5
 
2455
echo "${ECHO_T}yes" >&6; SH_SCRIPT_SED_CMD='1s/.*/:/'
 
2456
else
 
2457
        echo "$as_me:2457: result: no" >&5
 
2458
echo "${ECHO_T}no" >&6; SH_SCRIPT_SED_CMD='1s/a/a/'
 
2459
fi
 
2460
rm -f conftest.sh
 
2461
 
 
2462
ac_ext=c
 
2463
ac_cpp='$CPP $CPPFLAGS'
 
2464
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
2465
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
2466
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
2467
echo "$as_me:2467: checking how to run the C preprocessor" >&5
 
2468
echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
 
2469
# On Suns, sometimes $CPP names a directory.
 
2470
if test -n "$CPP" && test -d "$CPP"; then
 
2471
  CPP=
 
2472
fi
 
2473
if test -z "$CPP"; then
 
2474
  if test "${ac_cv_prog_CPP+set}" = set; then
 
2475
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
2476
else
 
2477
      # Double quotes because CPP needs to be expanded
 
2478
    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
 
2479
    do
 
2480
      # break 2 since there is a loop in there.
 
2481
      ac_preproc_ok=false
 
2482
for ac_c_preproc_warn_flag in '' yes
 
2483
do
 
2484
  # Use a header file that comes with gcc, so configuring glibc
 
2485
  # with a fresh cross-compiler works.
 
2486
  # On the NeXT, cc -E runs the code through the compiler's parser,
 
2487
  # not just through cpp. "Syntax error" is here to catch this case.
 
2488
  cat >conftest.$ac_ext <<_ACEOF
 
2489
#line 2489 "configure"
 
2490
#include "confdefs.h"
 
2491
#include <assert.h>
 
2492
                     Syntax error
 
2493
_ACEOF
 
2494
if { (eval echo "$as_me:2494: \"$ac_cpp conftest.$ac_ext\"") >&5
 
2495
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
2496
  ac_status=$?
 
2497
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
2498
  rm -f conftest.er1
 
2499
  cat conftest.err >&5
 
2500
  echo "$as_me:2500: \$? = $ac_status" >&5
 
2501
  (exit $ac_status); } >/dev/null; then
 
2502
  if test -s conftest.err; then
 
2503
    ac_cpp_err=$ac_c_preproc_warn_flag
 
2504
  else
 
2505
    ac_cpp_err=
 
2506
  fi
 
2507
else
 
2508
  ac_cpp_err=yes
 
2509
fi
 
2510
if test -z "$ac_cpp_err"; then
 
2511
  :
 
2512
else
 
2513
  echo "$as_me: failed program was:" >&5
 
2514
  cat conftest.$ac_ext >&5
 
2515
  # Broken: fails on valid input.
 
2516
continue
 
2517
fi
 
2518
rm -f conftest.err conftest.$ac_ext
 
2519
 
 
2520
  # OK, works on sane cases.  Now check whether non-existent headers
 
2521
  # can be detected and how.
 
2522
  cat >conftest.$ac_ext <<_ACEOF
 
2523
#line 2523 "configure"
 
2524
#include "confdefs.h"
 
2525
#include <ac_nonexistent.h>
 
2526
_ACEOF
 
2527
if { (eval echo "$as_me:2527: \"$ac_cpp conftest.$ac_ext\"") >&5
 
2528
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
2529
  ac_status=$?
 
2530
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
2531
  rm -f conftest.er1
 
2532
  cat conftest.err >&5
 
2533
  echo "$as_me:2533: \$? = $ac_status" >&5
 
2534
  (exit $ac_status); } >/dev/null; then
 
2535
  if test -s conftest.err; then
 
2536
    ac_cpp_err=$ac_c_preproc_warn_flag
 
2537
  else
 
2538
    ac_cpp_err=
 
2539
  fi
 
2540
else
 
2541
  ac_cpp_err=yes
 
2542
fi
 
2543
if test -z "$ac_cpp_err"; then
 
2544
  # Broken: success on invalid input.
 
2545
continue
 
2546
else
 
2547
  echo "$as_me: failed program was:" >&5
 
2548
  cat conftest.$ac_ext >&5
 
2549
  # Passes both tests.
 
2550
ac_preproc_ok=:
 
2551
break
 
2552
fi
 
2553
rm -f conftest.err conftest.$ac_ext
 
2554
 
 
2555
done
 
2556
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
 
2557
rm -f conftest.err conftest.$ac_ext
 
2558
if $ac_preproc_ok; then
 
2559
  break 2
 
2560
fi
 
2561
 
 
2562
    done
 
2563
    ac_cv_prog_CPP=$CPP
 
2564
 
 
2565
fi
 
2566
  CPP=$ac_cv_prog_CPP
 
2567
else
 
2568
  ac_cv_prog_CPP=$CPP
 
2569
fi
 
2570
echo "$as_me:2570: result: $CPP" >&5
 
2571
echo "${ECHO_T}$CPP" >&6
 
2572
ac_preproc_ok=false
 
2573
for ac_c_preproc_warn_flag in '' yes
 
2574
do
 
2575
  # Use a header file that comes with gcc, so configuring glibc
 
2576
  # with a fresh cross-compiler works.
 
2577
  # On the NeXT, cc -E runs the code through the compiler's parser,
 
2578
  # not just through cpp. "Syntax error" is here to catch this case.
 
2579
  cat >conftest.$ac_ext <<_ACEOF
 
2580
#line 2580 "configure"
 
2581
#include "confdefs.h"
 
2582
#include <assert.h>
 
2583
                     Syntax error
 
2584
_ACEOF
 
2585
if { (eval echo "$as_me:2585: \"$ac_cpp conftest.$ac_ext\"") >&5
 
2586
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
2587
  ac_status=$?
 
2588
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
2589
  rm -f conftest.er1
 
2590
  cat conftest.err >&5
 
2591
  echo "$as_me:2591: \$? = $ac_status" >&5
 
2592
  (exit $ac_status); } >/dev/null; then
 
2593
  if test -s conftest.err; then
 
2594
    ac_cpp_err=$ac_c_preproc_warn_flag
 
2595
  else
 
2596
    ac_cpp_err=
 
2597
  fi
 
2598
else
 
2599
  ac_cpp_err=yes
 
2600
fi
 
2601
if test -z "$ac_cpp_err"; then
 
2602
  :
 
2603
else
 
2604
  echo "$as_me: failed program was:" >&5
 
2605
  cat conftest.$ac_ext >&5
 
2606
  # Broken: fails on valid input.
 
2607
continue
 
2608
fi
 
2609
rm -f conftest.err conftest.$ac_ext
 
2610
 
 
2611
  # OK, works on sane cases.  Now check whether non-existent headers
 
2612
  # can be detected and how.
 
2613
  cat >conftest.$ac_ext <<_ACEOF
 
2614
#line 2614 "configure"
 
2615
#include "confdefs.h"
 
2616
#include <ac_nonexistent.h>
 
2617
_ACEOF
 
2618
if { (eval echo "$as_me:2618: \"$ac_cpp conftest.$ac_ext\"") >&5
 
2619
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
2620
  ac_status=$?
 
2621
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
2622
  rm -f conftest.er1
 
2623
  cat conftest.err >&5
 
2624
  echo "$as_me:2624: \$? = $ac_status" >&5
 
2625
  (exit $ac_status); } >/dev/null; then
 
2626
  if test -s conftest.err; then
 
2627
    ac_cpp_err=$ac_c_preproc_warn_flag
 
2628
  else
 
2629
    ac_cpp_err=
 
2630
  fi
 
2631
else
 
2632
  ac_cpp_err=yes
 
2633
fi
 
2634
if test -z "$ac_cpp_err"; then
 
2635
  # Broken: success on invalid input.
 
2636
continue
 
2637
else
 
2638
  echo "$as_me: failed program was:" >&5
 
2639
  cat conftest.$ac_ext >&5
 
2640
  # Passes both tests.
 
2641
ac_preproc_ok=:
 
2642
break
 
2643
fi
 
2644
rm -f conftest.err conftest.$ac_ext
 
2645
 
 
2646
done
 
2647
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
 
2648
rm -f conftest.err conftest.$ac_ext
 
2649
if $ac_preproc_ok; then
 
2650
  :
 
2651
else
 
2652
  { { echo "$as_me:2652: error: C preprocessor \"$CPP\" fails sanity check" >&5
 
2653
echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check" >&2;}
 
2654
   { (exit 1); exit 1; }; }
 
2655
fi
 
2656
 
 
2657
ac_ext=c
 
2658
ac_cpp='$CPP $CPPFLAGS'
 
2659
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
2660
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
2661
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
2662
 
 
2663
for ac_header in stdlib.h unistd.h dirent.h limits.h sys/dir.h \
 
2664
                 string.h strings.h math.h
 
2665
do
 
2666
ac_ac_Header=`echo "ac_cv_header_$ac_header" | $ac_tr_sh`
 
2667
echo "$as_me:2667: checking for $ac_header" >&5
 
2668
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
2669
if eval "test \"\${$ac_ac_Header+set}\" = set"; then
 
2670
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
2671
else
 
2672
  cat >conftest.$ac_ext <<_ACEOF
 
2673
#line 2673 "configure"
 
2674
#include "confdefs.h"
 
2675
#include <$ac_header>
 
2676
_ACEOF
 
2677
if { (eval echo "$as_me:2677: \"$ac_cpp conftest.$ac_ext\"") >&5
 
2678
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
2679
  ac_status=$?
 
2680
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
2681
  rm -f conftest.er1
 
2682
  cat conftest.err >&5
 
2683
  echo "$as_me:2683: \$? = $ac_status" >&5
 
2684
  (exit $ac_status); } >/dev/null; then
 
2685
  if test -s conftest.err; then
 
2686
    ac_cpp_err=$ac_c_preproc_warn_flag
 
2687
  else
 
2688
    ac_cpp_err=
 
2689
  fi
 
2690
else
 
2691
  ac_cpp_err=yes
 
2692
fi
 
2693
if test -z "$ac_cpp_err"; then
 
2694
  eval "$ac_ac_Header=yes"
 
2695
else
 
2696
  echo "$as_me: failed program was:" >&5
 
2697
  cat conftest.$ac_ext >&5
 
2698
  eval "$ac_ac_Header=no"
 
2699
fi
 
2700
rm -f conftest.err conftest.$ac_ext
 
2701
fi
 
2702
echo "$as_me:2702: result: `eval echo '${'$ac_ac_Header'}'`" >&5
 
2703
echo "${ECHO_T}`eval echo '${'$ac_ac_Header'}'`" >&6
 
2704
if test `eval echo '${'$ac_ac_Header'}'` = yes; then
 
2705
  cat >>confdefs.h <<EOF
 
2706
#define `echo "HAVE_$ac_header" | $ac_tr_cpp` 1
 
2707
EOF
 
2708
 
 
2709
fi
 
2710
done
 
2711
 
 
2712
echo "$as_me:2712: checking for ISC 3.x or 4.x" >&5
 
2713
echo $ECHO_N "checking for ISC 3.x or 4.x... $ECHO_C" >&6
 
2714
if grep '[34]\.' /usr/options/cb.name >/dev/null 2>&1
 
2715
then
 
2716
        echo "$as_me:2716: result: yes" >&5
 
2717
echo "${ECHO_T}yes" >&6
 
2718
        cat >>confdefs.h <<\EOF
 
2719
#define _SYSV3 1
 
2720
EOF
 
2721
 
 
2722
else
 
2723
        echo "$as_me:2723: result: no" >&5
 
2724
echo "${ECHO_T}no" >&6
 
2725
fi
 
2726
echo "$as_me:2726: checking whether -D_POSIX_SOURCE is necessary" >&5
 
2727
echo $ECHO_N "checking whether -D_POSIX_SOURCE is necessary... $ECHO_C" >&6
 
2728
ac_ext=cc
 
2729
ac_cpp='$CXXCPP $CPPFLAGS'
 
2730
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
2731
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
2732
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
2733
 
 
2734
cat >conftest.$ac_ext <<_ACEOF
 
2735
#line 2735 "configure"
 
2736
#include "confdefs.h"
 
2737
#include <stdio.h>
 
2738
extern "C" { void fileno(int); }
 
2739
int
 
2740
main ()
 
2741
{
 
2742
 
 
2743
  ;
 
2744
  return 0;
 
2745
}
 
2746
_ACEOF
 
2747
rm -f conftest.$ac_objext
 
2748
if { (eval echo "$as_me:2748: \"$ac_compile\"") >&5
 
2749
  (eval $ac_compile) 2>&5
 
2750
  ac_status=$?
 
2751
  echo "$as_me:2751: \$? = $ac_status" >&5
 
2752
  (exit $ac_status); } &&
 
2753
         { ac_try='test -s conftest.$ac_objext'
 
2754
  { (eval echo "$as_me:2754: \"$ac_try\"") >&5
 
2755
  (eval $ac_try) 2>&5
 
2756
  ac_status=$?
 
2757
  echo "$as_me:2757: \$? = $ac_status" >&5
 
2758
  (exit $ac_status); }; }; then
 
2759
  echo "$as_me:2759: result: yes" >&5
 
2760
echo "${ECHO_T}yes" >&6;cat >>confdefs.h <<\EOF
 
2761
#define _POSIX_SOURCE 1
 
2762
EOF
 
2763
 
 
2764
else
 
2765
  echo "$as_me: failed program was:" >&5
 
2766
cat conftest.$ac_ext >&5
 
2767
echo "$as_me:2767: result: no" >&5
 
2768
echo "${ECHO_T}no" >&6
 
2769
fi
 
2770
rm -f conftest.$ac_objext conftest.$ac_ext
 
2771
ac_ext=c
 
2772
ac_cpp='$CPP $CPPFLAGS'
 
2773
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
2774
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
2775
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
2776
 
 
2777
ac_ext=cc
 
2778
ac_cpp='$CXXCPP $CPPFLAGS'
 
2779
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
2780
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
2781
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
2782
 
 
2783
echo "$as_me:2783: checking for return type of srand" >&5
 
2784
echo $ECHO_N "checking for return type of srand... $ECHO_C" >&6
 
2785
cat >conftest.$ac_ext <<_ACEOF
 
2786
#line 2786 "configure"
 
2787
#include "confdefs.h"
 
2788
#include <stdlib.h>
 
2789
extern "C" { void srand(unsigned int); }
 
2790
int
 
2791
main ()
 
2792
{
 
2793
 
 
2794
  ;
 
2795
  return 0;
 
2796
}
 
2797
_ACEOF
 
2798
rm -f conftest.$ac_objext
 
2799
if { (eval echo "$as_me:2799: \"$ac_compile\"") >&5
 
2800
  (eval $ac_compile) 2>&5
 
2801
  ac_status=$?
 
2802
  echo "$as_me:2802: \$? = $ac_status" >&5
 
2803
  (exit $ac_status); } &&
 
2804
         { ac_try='test -s conftest.$ac_objext'
 
2805
  { (eval echo "$as_me:2805: \"$ac_try\"") >&5
 
2806
  (eval $ac_try) 2>&5
 
2807
  ac_status=$?
 
2808
  echo "$as_me:2808: \$? = $ac_status" >&5
 
2809
  (exit $ac_status); }; }; then
 
2810
  echo "$as_me:2810: result: void" >&5
 
2811
echo "${ECHO_T}void" >&6;cat >>confdefs.h <<\EOF
 
2812
#define RET_TYPE_SRAND_IS_VOID 1
 
2813
EOF
 
2814
 
 
2815
else
 
2816
  echo "$as_me: failed program was:" >&5
 
2817
cat conftest.$ac_ext >&5
 
2818
echo "$as_me:2818: result: int" >&5
 
2819
echo "${ECHO_T}int" >&6
 
2820
fi
 
2821
rm -f conftest.$ac_objext conftest.$ac_ext
 
2822
ac_ext=c
 
2823
ac_cpp='$CPP $CPPFLAGS'
 
2824
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
2825
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
2826
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
2827
 
 
2828
echo "$as_me:2828: checking whether hypot must be declared" >&5
 
2829
echo $ECHO_N "checking whether hypot must be declared... $ECHO_C" >&6
 
2830
ac_ext=cc
 
2831
ac_cpp='$CXXCPP $CPPFLAGS'
 
2832
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
2833
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
2834
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
2835
 
 
2836
if test "${groff_cv_decl_needed_hypot+set}" = set; then
 
2837
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
2838
else
 
2839
  cat >conftest.$ac_ext <<_ACEOF
 
2840
#line 2840 "configure"
 
2841
#include "confdefs.h"
 
2842
 
 
2843
#include <stdio.h>
 
2844
#ifdef HAVE_STRING_H
 
2845
#include <string.h>
 
2846
#endif
 
2847
#ifdef HAVE_STRINGS_H
 
2848
#include <strings.h>
 
2849
#endif
 
2850
#ifdef HAVE_STDLIB_H
 
2851
#include <stdlib.h>
 
2852
#endif
 
2853
#ifdef HAVE_UNISTD_H
 
2854
#include <unistd.h>
 
2855
#endif
 
2856
#ifdef HAVE_MATH_H
 
2857
#include <math.h>
 
2858
#endif
 
2859
int
 
2860
main ()
 
2861
{
 
2862
char *(*pfn) = (char *(*)) hypot
 
2863
  ;
 
2864
  return 0;
 
2865
}
 
2866
_ACEOF
 
2867
rm -f conftest.$ac_objext
 
2868
if { (eval echo "$as_me:2868: \"$ac_compile\"") >&5
 
2869
  (eval $ac_compile) 2>&5
 
2870
  ac_status=$?
 
2871
  echo "$as_me:2871: \$? = $ac_status" >&5
 
2872
  (exit $ac_status); } &&
 
2873
         { ac_try='test -s conftest.$ac_objext'
 
2874
  { (eval echo "$as_me:2874: \"$ac_try\"") >&5
 
2875
  (eval $ac_try) 2>&5
 
2876
  ac_status=$?
 
2877
  echo "$as_me:2877: \$? = $ac_status" >&5
 
2878
  (exit $ac_status); }; }; then
 
2879
  groff_cv_decl_needed_hypot=no
 
2880
else
 
2881
  echo "$as_me: failed program was:" >&5
 
2882
cat conftest.$ac_ext >&5
 
2883
groff_cv_decl_needed_hypot=yes
 
2884
fi
 
2885
rm -f conftest.$ac_objext conftest.$ac_ext
 
2886
fi
 
2887
 
 
2888
echo "$as_me:2888: result: $groff_cv_decl_needed_hypot" >&5
 
2889
echo "${ECHO_T}$groff_cv_decl_needed_hypot" >&6
 
2890
if test $groff_cv_decl_needed_hypot = yes; then
 
2891
        cat >>confdefs.h <<\EOF
 
2892
#define NEED_DECLARATION_HYPOT 1
 
2893
EOF
 
2894
 
 
2895
fi
 
2896
ac_ext=c
 
2897
ac_cpp='$CPP $CPPFLAGS'
 
2898
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
2899
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
2900
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
2901
 
 
2902
echo "$as_me:2902: checking whether popen must be declared" >&5
 
2903
echo $ECHO_N "checking whether popen must be declared... $ECHO_C" >&6
 
2904
ac_ext=cc
 
2905
ac_cpp='$CXXCPP $CPPFLAGS'
 
2906
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
2907
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
2908
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
2909
 
 
2910
if test "${groff_cv_decl_needed_popen+set}" = set; then
 
2911
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
2912
else
 
2913
  cat >conftest.$ac_ext <<_ACEOF
 
2914
#line 2914 "configure"
 
2915
#include "confdefs.h"
 
2916
 
 
2917
#include <stdio.h>
 
2918
#ifdef HAVE_STRING_H
 
2919
#include <string.h>
 
2920
#endif
 
2921
#ifdef HAVE_STRINGS_H
 
2922
#include <strings.h>
 
2923
#endif
 
2924
#ifdef HAVE_STDLIB_H
 
2925
#include <stdlib.h>
 
2926
#endif
 
2927
#ifdef HAVE_UNISTD_H
 
2928
#include <unistd.h>
 
2929
#endif
 
2930
#ifdef HAVE_MATH_H
 
2931
#include <math.h>
 
2932
#endif
 
2933
int
 
2934
main ()
 
2935
{
 
2936
char *(*pfn) = (char *(*)) popen
 
2937
  ;
 
2938
  return 0;
 
2939
}
 
2940
_ACEOF
 
2941
rm -f conftest.$ac_objext
 
2942
if { (eval echo "$as_me:2942: \"$ac_compile\"") >&5
 
2943
  (eval $ac_compile) 2>&5
 
2944
  ac_status=$?
 
2945
  echo "$as_me:2945: \$? = $ac_status" >&5
 
2946
  (exit $ac_status); } &&
 
2947
         { ac_try='test -s conftest.$ac_objext'
 
2948
  { (eval echo "$as_me:2948: \"$ac_try\"") >&5
 
2949
  (eval $ac_try) 2>&5
 
2950
  ac_status=$?
 
2951
  echo "$as_me:2951: \$? = $ac_status" >&5
 
2952
  (exit $ac_status); }; }; then
 
2953
  groff_cv_decl_needed_popen=no
 
2954
else
 
2955
  echo "$as_me: failed program was:" >&5
 
2956
cat conftest.$ac_ext >&5
 
2957
groff_cv_decl_needed_popen=yes
 
2958
fi
 
2959
rm -f conftest.$ac_objext conftest.$ac_ext
 
2960
fi
 
2961
 
 
2962
echo "$as_me:2962: result: $groff_cv_decl_needed_popen" >&5
 
2963
echo "${ECHO_T}$groff_cv_decl_needed_popen" >&6
 
2964
if test $groff_cv_decl_needed_popen = yes; then
 
2965
        cat >>confdefs.h <<\EOF
 
2966
#define NEED_DECLARATION_POPEN 1
 
2967
EOF
 
2968
 
 
2969
fi
 
2970
ac_ext=c
 
2971
ac_cpp='$CPP $CPPFLAGS'
 
2972
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
2973
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
2974
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
2975
 
 
2976
echo "$as_me:2976: checking whether pclose must be declared" >&5
 
2977
echo $ECHO_N "checking whether pclose must be declared... $ECHO_C" >&6
 
2978
ac_ext=cc
 
2979
ac_cpp='$CXXCPP $CPPFLAGS'
 
2980
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
2981
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
2982
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
2983
 
 
2984
if test "${groff_cv_decl_needed_pclose+set}" = set; then
 
2985
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
2986
else
 
2987
  cat >conftest.$ac_ext <<_ACEOF
 
2988
#line 2988 "configure"
 
2989
#include "confdefs.h"
 
2990
 
 
2991
#include <stdio.h>
 
2992
#ifdef HAVE_STRING_H
 
2993
#include <string.h>
 
2994
#endif
 
2995
#ifdef HAVE_STRINGS_H
 
2996
#include <strings.h>
 
2997
#endif
 
2998
#ifdef HAVE_STDLIB_H
 
2999
#include <stdlib.h>
 
3000
#endif
 
3001
#ifdef HAVE_UNISTD_H
 
3002
#include <unistd.h>
 
3003
#endif
 
3004
#ifdef HAVE_MATH_H
 
3005
#include <math.h>
 
3006
#endif
 
3007
int
 
3008
main ()
 
3009
{
 
3010
char *(*pfn) = (char *(*)) pclose
 
3011
  ;
 
3012
  return 0;
 
3013
}
 
3014
_ACEOF
 
3015
rm -f conftest.$ac_objext
 
3016
if { (eval echo "$as_me:3016: \"$ac_compile\"") >&5
 
3017
  (eval $ac_compile) 2>&5
 
3018
  ac_status=$?
 
3019
  echo "$as_me:3019: \$? = $ac_status" >&5
 
3020
  (exit $ac_status); } &&
 
3021
         { ac_try='test -s conftest.$ac_objext'
 
3022
  { (eval echo "$as_me:3022: \"$ac_try\"") >&5
 
3023
  (eval $ac_try) 2>&5
 
3024
  ac_status=$?
 
3025
  echo "$as_me:3025: \$? = $ac_status" >&5
 
3026
  (exit $ac_status); }; }; then
 
3027
  groff_cv_decl_needed_pclose=no
 
3028
else
 
3029
  echo "$as_me: failed program was:" >&5
 
3030
cat conftest.$ac_ext >&5
 
3031
groff_cv_decl_needed_pclose=yes
 
3032
fi
 
3033
rm -f conftest.$ac_objext conftest.$ac_ext
 
3034
fi
 
3035
 
 
3036
echo "$as_me:3036: result: $groff_cv_decl_needed_pclose" >&5
 
3037
echo "${ECHO_T}$groff_cv_decl_needed_pclose" >&6
 
3038
if test $groff_cv_decl_needed_pclose = yes; then
 
3039
        cat >>confdefs.h <<\EOF
 
3040
#define NEED_DECLARATION_PCLOSE 1
 
3041
EOF
 
3042
 
 
3043
fi
 
3044
ac_ext=c
 
3045
ac_cpp='$CPP $CPPFLAGS'
 
3046
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
3047
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
3048
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
3049
 
 
3050
echo "$as_me:3050: checking whether putenv must be declared" >&5
 
3051
echo $ECHO_N "checking whether putenv must be declared... $ECHO_C" >&6
 
3052
ac_ext=cc
 
3053
ac_cpp='$CXXCPP $CPPFLAGS'
 
3054
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
3055
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
3056
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
3057
 
 
3058
if test "${groff_cv_decl_needed_putenv+set}" = set; then
 
3059
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3060
else
 
3061
  cat >conftest.$ac_ext <<_ACEOF
 
3062
#line 3062 "configure"
 
3063
#include "confdefs.h"
 
3064
 
 
3065
#include <stdio.h>
 
3066
#ifdef HAVE_STRING_H
 
3067
#include <string.h>
 
3068
#endif
 
3069
#ifdef HAVE_STRINGS_H
 
3070
#include <strings.h>
 
3071
#endif
 
3072
#ifdef HAVE_STDLIB_H
 
3073
#include <stdlib.h>
 
3074
#endif
 
3075
#ifdef HAVE_UNISTD_H
 
3076
#include <unistd.h>
 
3077
#endif
 
3078
#ifdef HAVE_MATH_H
 
3079
#include <math.h>
 
3080
#endif
 
3081
int
 
3082
main ()
 
3083
{
 
3084
char *(*pfn) = (char *(*)) putenv
 
3085
  ;
 
3086
  return 0;
 
3087
}
 
3088
_ACEOF
 
3089
rm -f conftest.$ac_objext
 
3090
if { (eval echo "$as_me:3090: \"$ac_compile\"") >&5
 
3091
  (eval $ac_compile) 2>&5
 
3092
  ac_status=$?
 
3093
  echo "$as_me:3093: \$? = $ac_status" >&5
 
3094
  (exit $ac_status); } &&
 
3095
         { ac_try='test -s conftest.$ac_objext'
 
3096
  { (eval echo "$as_me:3096: \"$ac_try\"") >&5
 
3097
  (eval $ac_try) 2>&5
 
3098
  ac_status=$?
 
3099
  echo "$as_me:3099: \$? = $ac_status" >&5
 
3100
  (exit $ac_status); }; }; then
 
3101
  groff_cv_decl_needed_putenv=no
 
3102
else
 
3103
  echo "$as_me: failed program was:" >&5
 
3104
cat conftest.$ac_ext >&5
 
3105
groff_cv_decl_needed_putenv=yes
 
3106
fi
 
3107
rm -f conftest.$ac_objext conftest.$ac_ext
 
3108
fi
 
3109
 
 
3110
echo "$as_me:3110: result: $groff_cv_decl_needed_putenv" >&5
 
3111
echo "${ECHO_T}$groff_cv_decl_needed_putenv" >&6
 
3112
if test $groff_cv_decl_needed_putenv = yes; then
 
3113
        cat >>confdefs.h <<\EOF
 
3114
#define NEED_DECLARATION_PUTENV 1
 
3115
EOF
 
3116
 
 
3117
fi
 
3118
ac_ext=c
 
3119
ac_cpp='$CPP $CPPFLAGS'
 
3120
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
3121
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
3122
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
3123
 
 
3124
echo "$as_me:3124: checking whether strncasecmp must be declared" >&5
 
3125
echo $ECHO_N "checking whether strncasecmp must be declared... $ECHO_C" >&6
 
3126
ac_ext=cc
 
3127
ac_cpp='$CXXCPP $CPPFLAGS'
 
3128
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
3129
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
3130
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
3131
 
 
3132
if test "${groff_cv_decl_needed_strncasecmp+set}" = set; then
 
3133
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3134
else
 
3135
  cat >conftest.$ac_ext <<_ACEOF
 
3136
#line 3136 "configure"
 
3137
#include "confdefs.h"
 
3138
 
 
3139
#include <stdio.h>
 
3140
#ifdef HAVE_STRING_H
 
3141
#include <string.h>
 
3142
#endif
 
3143
#ifdef HAVE_STRINGS_H
 
3144
#include <strings.h>
 
3145
#endif
 
3146
#ifdef HAVE_STDLIB_H
 
3147
#include <stdlib.h>
 
3148
#endif
 
3149
#ifdef HAVE_UNISTD_H
 
3150
#include <unistd.h>
 
3151
#endif
 
3152
#ifdef HAVE_MATH_H
 
3153
#include <math.h>
 
3154
#endif
 
3155
int
 
3156
main ()
 
3157
{
 
3158
char *(*pfn) = (char *(*)) strncasecmp
 
3159
  ;
 
3160
  return 0;
 
3161
}
 
3162
_ACEOF
 
3163
rm -f conftest.$ac_objext
 
3164
if { (eval echo "$as_me:3164: \"$ac_compile\"") >&5
 
3165
  (eval $ac_compile) 2>&5
 
3166
  ac_status=$?
 
3167
  echo "$as_me:3167: \$? = $ac_status" >&5
 
3168
  (exit $ac_status); } &&
 
3169
         { ac_try='test -s conftest.$ac_objext'
 
3170
  { (eval echo "$as_me:3170: \"$ac_try\"") >&5
 
3171
  (eval $ac_try) 2>&5
 
3172
  ac_status=$?
 
3173
  echo "$as_me:3173: \$? = $ac_status" >&5
 
3174
  (exit $ac_status); }; }; then
 
3175
  groff_cv_decl_needed_strncasecmp=no
 
3176
else
 
3177
  echo "$as_me: failed program was:" >&5
 
3178
cat conftest.$ac_ext >&5
 
3179
groff_cv_decl_needed_strncasecmp=yes
 
3180
fi
 
3181
rm -f conftest.$ac_objext conftest.$ac_ext
 
3182
fi
 
3183
 
 
3184
echo "$as_me:3184: result: $groff_cv_decl_needed_strncasecmp" >&5
 
3185
echo "${ECHO_T}$groff_cv_decl_needed_strncasecmp" >&6
 
3186
if test $groff_cv_decl_needed_strncasecmp = yes; then
 
3187
        cat >>confdefs.h <<\EOF
 
3188
#define NEED_DECLARATION_STRNCASECMP 1
 
3189
EOF
 
3190
 
 
3191
fi
 
3192
ac_ext=c
 
3193
ac_cpp='$CPP $CPPFLAGS'
 
3194
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
3195
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
3196
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
3197
 
 
3198
ac_ext=cc
 
3199
ac_cpp='$CXXCPP $CPPFLAGS'
 
3200
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
3201
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
3202
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
3203
 
 
3204
echo "$as_me:3204: checking for sys_nerr in <errno.h> or <stdio.h>" >&5
 
3205
echo $ECHO_N "checking for sys_nerr in <errno.h> or <stdio.h>... $ECHO_C" >&6
 
3206
cat >conftest.$ac_ext <<_ACEOF
 
3207
#line 3207 "configure"
 
3208
#include "confdefs.h"
 
3209
#include <errno.h>
 
3210
#include <stdio.h>
 
3211
int
 
3212
main ()
 
3213
{
 
3214
int k; k = sys_nerr;
 
3215
  ;
 
3216
  return 0;
 
3217
}
 
3218
_ACEOF
 
3219
rm -f conftest.$ac_objext
 
3220
if { (eval echo "$as_me:3220: \"$ac_compile\"") >&5
 
3221
  (eval $ac_compile) 2>&5
 
3222
  ac_status=$?
 
3223
  echo "$as_me:3223: \$? = $ac_status" >&5
 
3224
  (exit $ac_status); } &&
 
3225
         { ac_try='test -s conftest.$ac_objext'
 
3226
  { (eval echo "$as_me:3226: \"$ac_try\"") >&5
 
3227
  (eval $ac_try) 2>&5
 
3228
  ac_status=$?
 
3229
  echo "$as_me:3229: \$? = $ac_status" >&5
 
3230
  (exit $ac_status); }; }; then
 
3231
  echo "$as_me:3231: result: yes" >&5
 
3232
echo "${ECHO_T}yes" >&6;cat >>confdefs.h <<\EOF
 
3233
#define HAVE_SYS_NERR 1
 
3234
EOF
 
3235
 
 
3236
else
 
3237
  echo "$as_me: failed program was:" >&5
 
3238
cat conftest.$ac_ext >&5
 
3239
echo "$as_me:3239: result: no" >&5
 
3240
echo "${ECHO_T}no" >&6
 
3241
fi
 
3242
rm -f conftest.$ac_objext conftest.$ac_ext
 
3243
ac_ext=c
 
3244
ac_cpp='$CPP $CPPFLAGS'
 
3245
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
3246
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
3247
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
3248
 
 
3249
echo "$as_me:3249: checking for sys_errlist in <errno.h> or <stdio.h>" >&5
 
3250
echo $ECHO_N "checking for sys_errlist in <errno.h> or <stdio.h>... $ECHO_C" >&6
 
3251
cat >conftest.$ac_ext <<_ACEOF
 
3252
#line 3252 "configure"
 
3253
#include "confdefs.h"
 
3254
#include <errno.h>
 
3255
#include <stdio.h>
 
3256
int
 
3257
main ()
 
3258
{
 
3259
int k; k = (int)sys_errlist[0];
 
3260
  ;
 
3261
  return 0;
 
3262
}
 
3263
_ACEOF
 
3264
rm -f conftest.$ac_objext
 
3265
if { (eval echo "$as_me:3265: \"$ac_compile\"") >&5
 
3266
  (eval $ac_compile) 2>&5
 
3267
  ac_status=$?
 
3268
  echo "$as_me:3268: \$? = $ac_status" >&5
 
3269
  (exit $ac_status); } &&
 
3270
         { ac_try='test -s conftest.$ac_objext'
 
3271
  { (eval echo "$as_me:3271: \"$ac_try\"") >&5
 
3272
  (eval $ac_try) 2>&5
 
3273
  ac_status=$?
 
3274
  echo "$as_me:3274: \$? = $ac_status" >&5
 
3275
  (exit $ac_status); }; }; then
 
3276
  echo "$as_me:3276: result: yes" >&5
 
3277
echo "${ECHO_T}yes" >&6;cat >>confdefs.h <<\EOF
 
3278
#define HAVE_SYS_ERRLIST 1
 
3279
EOF
 
3280
 
 
3281
else
 
3282
  echo "$as_me: failed program was:" >&5
 
3283
cat conftest.$ac_ext >&5
 
3284
echo "$as_me:3284: result: no" >&5
 
3285
echo "${ECHO_T}no" >&6
 
3286
fi
 
3287
rm -f conftest.$ac_objext conftest.$ac_ext
 
3288
ac_ext=cc
 
3289
ac_cpp='$CXXCPP $CPPFLAGS'
 
3290
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
3291
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
3292
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
3293
 
 
3294
echo "$as_me:3294: checking C++ <osfcn.h>" >&5
 
3295
echo $ECHO_N "checking C++ <osfcn.h>... $ECHO_C" >&6
 
3296
cat >conftest.$ac_ext <<_ACEOF
 
3297
#line 3297 "configure"
 
3298
#include "confdefs.h"
 
3299
#include <osfcn.h>
 
3300
int
 
3301
main ()
 
3302
{
 
3303
read(0, 0, 0); open(0, 0);
 
3304
  ;
 
3305
  return 0;
 
3306
}
 
3307
_ACEOF
 
3308
rm -f conftest.$ac_objext
 
3309
if { (eval echo "$as_me:3309: \"$ac_compile\"") >&5
 
3310
  (eval $ac_compile) 2>&5
 
3311
  ac_status=$?
 
3312
  echo "$as_me:3312: \$? = $ac_status" >&5
 
3313
  (exit $ac_status); } &&
 
3314
         { ac_try='test -s conftest.$ac_objext'
 
3315
  { (eval echo "$as_me:3315: \"$ac_try\"") >&5
 
3316
  (eval $ac_try) 2>&5
 
3317
  ac_status=$?
 
3318
  echo "$as_me:3318: \$? = $ac_status" >&5
 
3319
  (exit $ac_status); }; }; then
 
3320
  echo "$as_me:3320: result: yes" >&5
 
3321
echo "${ECHO_T}yes" >&6;cat >>confdefs.h <<\EOF
 
3322
#define HAVE_CC_OSFCN_H 1
 
3323
EOF
 
3324
 
 
3325
else
 
3326
  echo "$as_me: failed program was:" >&5
 
3327
cat conftest.$ac_ext >&5
 
3328
echo "$as_me:3328: result: no" >&5
 
3329
echo "${ECHO_T}no" >&6
 
3330
fi
 
3331
rm -f conftest.$ac_objext conftest.$ac_ext
 
3332
ac_ext=c
 
3333
ac_cpp='$CPP $CPPFLAGS'
 
3334
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
3335
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
3336
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
3337
 
 
3338
ac_ext=cc
 
3339
ac_cpp='$CXXCPP $CPPFLAGS'
 
3340
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
3341
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
3342
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
3343
 
 
3344
echo "$as_me:3344: checking C++ <limits.h>" >&5
 
3345
echo $ECHO_N "checking C++ <limits.h>... $ECHO_C" >&6
 
3346
cat >conftest.$ac_ext <<_ACEOF
 
3347
#line 3347 "configure"
 
3348
#include "confdefs.h"
 
3349
#include <limits.h>
 
3350
int
 
3351
main ()
 
3352
{
 
3353
int x = INT_MIN; int y = INT_MAX; int z = UCHAR_MAX;
 
3354
  ;
 
3355
  return 0;
 
3356
}
 
3357
_ACEOF
 
3358
rm -f conftest.$ac_objext
 
3359
if { (eval echo "$as_me:3359: \"$ac_compile\"") >&5
 
3360
  (eval $ac_compile) 2>&5
 
3361
  ac_status=$?
 
3362
  echo "$as_me:3362: \$? = $ac_status" >&5
 
3363
  (exit $ac_status); } &&
 
3364
         { ac_try='test -s conftest.$ac_objext'
 
3365
  { (eval echo "$as_me:3365: \"$ac_try\"") >&5
 
3366
  (eval $ac_try) 2>&5
 
3367
  ac_status=$?
 
3368
  echo "$as_me:3368: \$? = $ac_status" >&5
 
3369
  (exit $ac_status); }; }; then
 
3370
  echo "$as_me:3370: result: yes" >&5
 
3371
echo "${ECHO_T}yes" >&6;cat >>confdefs.h <<\EOF
 
3372
#define HAVE_CC_LIMITS_H 1
 
3373
EOF
 
3374
 
 
3375
else
 
3376
  echo "$as_me: failed program was:" >&5
 
3377
cat conftest.$ac_ext >&5
 
3378
echo "$as_me:3378: result: no" >&5
 
3379
echo "${ECHO_T}no" >&6
 
3380
fi
 
3381
rm -f conftest.$ac_objext conftest.$ac_ext
 
3382
ac_ext=c
 
3383
ac_cpp='$CPP $CPPFLAGS'
 
3384
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
3385
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
3386
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
3387
 
 
3388
ac_ext=cc
 
3389
ac_cpp='$CXXCPP $CPPFLAGS'
 
3390
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
3391
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
3392
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
3393
 
 
3394
echo "$as_me:3394: checking for declaration of time_t" >&5
 
3395
echo $ECHO_N "checking for declaration of time_t... $ECHO_C" >&6
 
3396
cat >conftest.$ac_ext <<_ACEOF
 
3397
#line 3397 "configure"
 
3398
#include "confdefs.h"
 
3399
#include <time.h>
 
3400
int
 
3401
main ()
 
3402
{
 
3403
time_t t = time(0); struct tm *p = localtime(&t);
 
3404
  ;
 
3405
  return 0;
 
3406
}
 
3407
_ACEOF
 
3408
rm -f conftest.$ac_objext
 
3409
if { (eval echo "$as_me:3409: \"$ac_compile\"") >&5
 
3410
  (eval $ac_compile) 2>&5
 
3411
  ac_status=$?
 
3412
  echo "$as_me:3412: \$? = $ac_status" >&5
 
3413
  (exit $ac_status); } &&
 
3414
         { ac_try='test -s conftest.$ac_objext'
 
3415
  { (eval echo "$as_me:3415: \"$ac_try\"") >&5
 
3416
  (eval $ac_try) 2>&5
 
3417
  ac_status=$?
 
3418
  echo "$as_me:3418: \$? = $ac_status" >&5
 
3419
  (exit $ac_status); }; }; then
 
3420
  echo "$as_me:3420: result: yes" >&5
 
3421
echo "${ECHO_T}yes" >&6
 
3422
else
 
3423
  echo "$as_me: failed program was:" >&5
 
3424
cat conftest.$ac_ext >&5
 
3425
echo "$as_me:3425: result: no" >&5
 
3426
echo "${ECHO_T}no" >&6;cat >>confdefs.h <<\EOF
 
3427
#define LONG_FOR_TIME_T 1
 
3428
EOF
 
3429
 
 
3430
fi
 
3431
rm -f conftest.$ac_objext conftest.$ac_ext
 
3432
ac_ext=c
 
3433
ac_cpp='$CPP $CPPFLAGS'
 
3434
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
3435
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
3436
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
3437
 
 
3438
echo "$as_me:3438: checking return type of signal handlers" >&5
 
3439
echo $ECHO_N "checking return type of signal handlers... $ECHO_C" >&6
 
3440
if test "${ac_cv_type_signal+set}" = set; then
 
3441
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3442
else
 
3443
  cat >conftest.$ac_ext <<_ACEOF
 
3444
#line 3444 "configure"
 
3445
#include "confdefs.h"
 
3446
#include <sys/types.h>
 
3447
#include <signal.h>
 
3448
#ifdef signal
 
3449
# undef signal
 
3450
#endif
 
3451
#ifdef __cplusplus
 
3452
extern "C" void (*signal (int, void (*)(int)))(int);
 
3453
#else
 
3454
void (*signal ()) ();
 
3455
#endif
 
3456
 
 
3457
int
 
3458
main ()
 
3459
{
 
3460
int i;
 
3461
  ;
 
3462
  return 0;
 
3463
}
 
3464
_ACEOF
 
3465
rm -f conftest.$ac_objext
 
3466
if { (eval echo "$as_me:3466: \"$ac_compile\"") >&5
 
3467
  (eval $ac_compile) 2>&5
 
3468
  ac_status=$?
 
3469
  echo "$as_me:3469: \$? = $ac_status" >&5
 
3470
  (exit $ac_status); } &&
 
3471
         { ac_try='test -s conftest.$ac_objext'
 
3472
  { (eval echo "$as_me:3472: \"$ac_try\"") >&5
 
3473
  (eval $ac_try) 2>&5
 
3474
  ac_status=$?
 
3475
  echo "$as_me:3475: \$? = $ac_status" >&5
 
3476
  (exit $ac_status); }; }; then
 
3477
  ac_cv_type_signal=void
 
3478
else
 
3479
  echo "$as_me: failed program was:" >&5
 
3480
cat conftest.$ac_ext >&5
 
3481
ac_cv_type_signal=int
 
3482
fi
 
3483
rm -f conftest.$ac_objext conftest.$ac_ext
 
3484
fi
 
3485
echo "$as_me:3485: result: $ac_cv_type_signal" >&5
 
3486
echo "${ECHO_T}$ac_cv_type_signal" >&6
 
3487
 
 
3488
cat >>confdefs.h <<EOF
 
3489
#define RETSIGTYPE $ac_cv_type_signal
 
3490
EOF
 
3491
 
 
3492
echo "$as_me:3492: checking struct exception" >&5
 
3493
echo $ECHO_N "checking struct exception... $ECHO_C" >&6
 
3494
cat >conftest.$ac_ext <<_ACEOF
 
3495
#line 3495 "configure"
 
3496
#include "confdefs.h"
 
3497
#include <math.h>
 
3498
int
 
3499
main ()
 
3500
{
 
3501
struct exception e;
 
3502
  ;
 
3503
  return 0;
 
3504
}
 
3505
_ACEOF
 
3506
rm -f conftest.$ac_objext
 
3507
if { (eval echo "$as_me:3507: \"$ac_compile\"") >&5
 
3508
  (eval $ac_compile) 2>&5
 
3509
  ac_status=$?
 
3510
  echo "$as_me:3510: \$? = $ac_status" >&5
 
3511
  (exit $ac_status); } &&
 
3512
         { ac_try='test -s conftest.$ac_objext'
 
3513
  { (eval echo "$as_me:3513: \"$ac_try\"") >&5
 
3514
  (eval $ac_try) 2>&5
 
3515
  ac_status=$?
 
3516
  echo "$as_me:3516: \$? = $ac_status" >&5
 
3517
  (exit $ac_status); }; }; then
 
3518
  echo "$as_me:3518: result: yes" >&5
 
3519
echo "${ECHO_T}yes" >&6;cat >>confdefs.h <<\EOF
 
3520
#define HAVE_STRUCT_EXCEPTION 1
 
3521
EOF
 
3522
 
 
3523
else
 
3524
  echo "$as_me: failed program was:" >&5
 
3525
cat conftest.$ac_ext >&5
 
3526
echo "$as_me:3526: result: no" >&5
 
3527
echo "${ECHO_T}no" >&6
 
3528
fi
 
3529
rm -f conftest.$ac_objext conftest.$ac_ext
 
3530
echo "$as_me:3530: checking for sin in -lm" >&5
 
3531
echo $ECHO_N "checking for sin in -lm... $ECHO_C" >&6
 
3532
if test "${ac_cv_lib_m_sin+set}" = set; then
 
3533
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3534
else
 
3535
  ac_check_lib_save_LIBS=$LIBS
 
3536
LIBS="-lm  $LIBS"
 
3537
cat >conftest.$ac_ext <<_ACEOF
 
3538
#line 3538 "configure"
 
3539
#include "confdefs.h"
 
3540
 
 
3541
/* Override any gcc2 internal prototype to avoid an error.  */
 
3542
#ifdef __cplusplus
 
3543
extern "C"
 
3544
#endif
 
3545
/* We use char because int might match the return type of a gcc2
 
3546
   builtin and then its argument prototype would still apply.  */
 
3547
char sin ();
 
3548
int
 
3549
main ()
 
3550
{
 
3551
sin ();
 
3552
  ;
 
3553
  return 0;
 
3554
}
 
3555
_ACEOF
 
3556
rm -f conftest.$ac_objext conftest$ac_exeext
 
3557
if { (eval echo "$as_me:3557: \"$ac_link\"") >&5
 
3558
  (eval $ac_link) 2>&5
 
3559
  ac_status=$?
 
3560
  echo "$as_me:3560: \$? = $ac_status" >&5
 
3561
  (exit $ac_status); } &&
 
3562
         { ac_try='test -s conftest$ac_exeext'
 
3563
  { (eval echo "$as_me:3563: \"$ac_try\"") >&5
 
3564
  (eval $ac_try) 2>&5
 
3565
  ac_status=$?
 
3566
  echo "$as_me:3566: \$? = $ac_status" >&5
 
3567
  (exit $ac_status); }; }; then
 
3568
  ac_cv_lib_m_sin=yes
 
3569
else
 
3570
  echo "$as_me: failed program was:" >&5
 
3571
cat conftest.$ac_ext >&5
 
3572
ac_cv_lib_m_sin=no
 
3573
fi
 
3574
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
3575
LIBS=$ac_check_lib_save_LIBS
 
3576
fi
 
3577
echo "$as_me:3577: result: $ac_cv_lib_m_sin" >&5
 
3578
echo "${ECHO_T}$ac_cv_lib_m_sin" >&6
 
3579
if test $ac_cv_lib_m_sin = yes; then
 
3580
  LIBM=-lm
 
3581
fi
 
3582
 
 
3583
for ac_header in stdlib.h unistd.h
 
3584
do
 
3585
ac_ac_Header=`echo "ac_cv_header_$ac_header" | $ac_tr_sh`
 
3586
echo "$as_me:3586: checking for $ac_header" >&5
 
3587
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
3588
if eval "test \"\${$ac_ac_Header+set}\" = set"; then
 
3589
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3590
else
 
3591
  cat >conftest.$ac_ext <<_ACEOF
 
3592
#line 3592 "configure"
 
3593
#include "confdefs.h"
 
3594
#include <$ac_header>
 
3595
_ACEOF
 
3596
if { (eval echo "$as_me:3596: \"$ac_cpp conftest.$ac_ext\"") >&5
 
3597
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
3598
  ac_status=$?
 
3599
  egrep -v '^ *\+' conftest.er1 >conftest.err
 
3600
  rm -f conftest.er1
 
3601
  cat conftest.err >&5
 
3602
  echo "$as_me:3602: \$? = $ac_status" >&5
 
3603
  (exit $ac_status); } >/dev/null; then
 
3604
  if test -s conftest.err; then
 
3605
    ac_cpp_err=$ac_c_preproc_warn_flag
 
3606
  else
 
3607
    ac_cpp_err=
 
3608
  fi
 
3609
else
 
3610
  ac_cpp_err=yes
 
3611
fi
 
3612
if test -z "$ac_cpp_err"; then
 
3613
  eval "$ac_ac_Header=yes"
 
3614
else
 
3615
  echo "$as_me: failed program was:" >&5
 
3616
  cat conftest.$ac_ext >&5
 
3617
  eval "$ac_ac_Header=no"
 
3618
fi
 
3619
rm -f conftest.err conftest.$ac_ext
 
3620
fi
 
3621
echo "$as_me:3621: result: `eval echo '${'$ac_ac_Header'}'`" >&5
 
3622
echo "${ECHO_T}`eval echo '${'$ac_ac_Header'}'`" >&6
 
3623
if test `eval echo '${'$ac_ac_Header'}'` = yes; then
 
3624
  cat >>confdefs.h <<EOF
 
3625
#define `echo "HAVE_$ac_header" | $ac_tr_cpp` 1
 
3626
EOF
 
3627
 
 
3628
fi
 
3629
done
 
3630
 
 
3631
for ac_func in getpagesize
 
3632
do
 
3633
ac_ac_var=`echo "ac_cv_func_$ac_func" | $ac_tr_sh`
 
3634
echo "$as_me:3634: checking for $ac_func" >&5
 
3635
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
 
3636
if eval "test \"\${$ac_ac_var+set}\" = set"; then
 
3637
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3638
else
 
3639
  cat >conftest.$ac_ext <<_ACEOF
 
3640
#line 3640 "configure"
 
3641
#include "confdefs.h"
 
3642
/* System header to define __stub macros and hopefully few prototypes,
 
3643
    which can conflict with char $ac_func (); below.  */
 
3644
#include <assert.h>
 
3645
/* Override any gcc2 internal prototype to avoid an error.  */
 
3646
#ifdef __cplusplus
 
3647
extern "C"
 
3648
#endif
 
3649
/* We use char because int might match the return type of a gcc2
 
3650
   builtin and then its argument prototype would still apply.  */
 
3651
char $ac_func ();
 
3652
char (*f) ();
 
3653
 
 
3654
int
 
3655
main ()
 
3656
{
 
3657
/* The GNU C library defines this for functions which it implements
 
3658
    to always fail with ENOSYS.  Some functions are actually named
 
3659
    something starting with __ and the normal name is an alias.  */
 
3660
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
 
3661
choke me
 
3662
#else
 
3663
f = $ac_func;
 
3664
#endif
 
3665
 
 
3666
  ;
 
3667
  return 0;
 
3668
}
 
3669
_ACEOF
 
3670
rm -f conftest.$ac_objext conftest$ac_exeext
 
3671
if { (eval echo "$as_me:3671: \"$ac_link\"") >&5
 
3672
  (eval $ac_link) 2>&5
 
3673
  ac_status=$?
 
3674
  echo "$as_me:3674: \$? = $ac_status" >&5
 
3675
  (exit $ac_status); } &&
 
3676
         { ac_try='test -s conftest$ac_exeext'
 
3677
  { (eval echo "$as_me:3677: \"$ac_try\"") >&5
 
3678
  (eval $ac_try) 2>&5
 
3679
  ac_status=$?
 
3680
  echo "$as_me:3680: \$? = $ac_status" >&5
 
3681
  (exit $ac_status); }; }; then
 
3682
  eval "$ac_ac_var=yes"
 
3683
else
 
3684
  echo "$as_me: failed program was:" >&5
 
3685
cat conftest.$ac_ext >&5
 
3686
eval "$ac_ac_var=no"
 
3687
fi
 
3688
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
3689
fi
 
3690
echo "$as_me:3690: result: `eval echo '${'$ac_ac_var'}'`" >&5
 
3691
echo "${ECHO_T}`eval echo '${'$ac_ac_var'}'`" >&6
 
3692
if test `eval echo '${'$ac_ac_var'}'` = yes; then
 
3693
  cat >>confdefs.h <<EOF
 
3694
#define `echo "HAVE_$ac_func" | $ac_tr_cpp` 1
 
3695
EOF
 
3696
 
 
3697
fi
 
3698
done
 
3699
 
 
3700
echo "$as_me:3700: checking for working mmap" >&5
 
3701
echo $ECHO_N "checking for working mmap... $ECHO_C" >&6
 
3702
if test "${ac_cv_func_mmap_fixed_mapped+set}" = set; then
 
3703
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3704
else
 
3705
  if test "$cross_compiling" = yes; then
 
3706
  ac_cv_func_mmap_fixed_mapped=no
 
3707
else
 
3708
  cat >conftest.$ac_ext <<_ACEOF
 
3709
#line 3709 "configure"
 
3710
#include "confdefs.h"
 
3711
/* Thanks to Mike Haertel and Jim Avera for this test.
 
3712
   Here is a matrix of mmap possibilities:
 
3713
        mmap private not fixed
 
3714
        mmap private fixed at somewhere currently unmapped
 
3715
        mmap private fixed at somewhere already mapped
 
3716
        mmap shared not fixed
 
3717
        mmap shared fixed at somewhere currently unmapped
 
3718
        mmap shared fixed at somewhere already mapped
 
3719
   For private mappings, we should verify that changes cannot be read()
 
3720
   back from the file, nor mmap's back from the file at a different
 
3721
   address.  (There have been systems where private was not correctly
 
3722
   implemented like the infamous i386 svr4.0, and systems where the
 
3723
   VM page cache was not coherent with the file system buffer cache
 
3724
   like early versions of FreeBSD and possibly contemporary NetBSD.)
 
3725
   For shared mappings, we should conversely verify that changes get
 
3726
   propogated back to all the places they're supposed to be.
 
3727
 
 
3728
   Grep wants private fixed already mapped.
 
3729
   The main things grep needs to know about mmap are:
 
3730
   * does it exist and is it safe to write into the mmap'd area
 
3731
   * how to use it (BSD variants)  */
 
3732
#include <sys/types.h>
 
3733
#include <fcntl.h>
 
3734
#include <sys/mman.h>
 
3735
 
 
3736
#if STDC_HEADERS || HAVE_STDLIB_H
 
3737
# include <stdlib.h>
 
3738
#else
 
3739
char *malloc ();
 
3740
#endif
 
3741
#if HAVE_UNISTD_H
 
3742
# include <unistd.h>
 
3743
#endif
 
3744
#include <sys/stat.h>
 
3745
 
 
3746
/* This mess was copied from the GNU getpagesize.h.  */
 
3747
#if !HAVE_GETPAGESIZE
 
3748
/* Assume that all systems that can run configure have sys/param.h.  */
 
3749
# if !HAVE_SYS_PARAM_H
 
3750
#  define HAVE_SYS_PARAM_H 1
 
3751
# endif
 
3752
 
 
3753
# ifdef _SC_PAGESIZE
 
3754
#  define getpagesize() sysconf(_SC_PAGESIZE)
 
3755
# else /* no _SC_PAGESIZE */
 
3756
#  if HAVE_SYS_PARAM_H
 
3757
#   include <sys/param.h>
 
3758
#   ifdef EXEC_PAGESIZE
 
3759
#    define getpagesize() EXEC_PAGESIZE
 
3760
#   else /* no EXEC_PAGESIZE */
 
3761
#    ifdef NBPG
 
3762
#     define getpagesize() NBPG * CLSIZE
 
3763
#     ifndef CLSIZE
 
3764
#      define CLSIZE 1
 
3765
#     endif /* no CLSIZE */
 
3766
#    else /* no NBPG */
 
3767
#     ifdef NBPC
 
3768
#      define getpagesize() NBPC
 
3769
#     else /* no NBPC */
 
3770
#      ifdef PAGESIZE
 
3771
#       define getpagesize() PAGESIZE
 
3772
#      endif /* PAGESIZE */
 
3773
#     endif /* no NBPC */
 
3774
#    endif /* no NBPG */
 
3775
#   endif /* no EXEC_PAGESIZE */
 
3776
#  else /* no HAVE_SYS_PARAM_H */
 
3777
#   define getpagesize() 8192   /* punt totally */
 
3778
#  endif /* no HAVE_SYS_PARAM_H */
 
3779
# endif /* no _SC_PAGESIZE */
 
3780
 
 
3781
#endif /* no HAVE_GETPAGESIZE */
 
3782
 
 
3783
int
 
3784
main ()
 
3785
{
 
3786
  char *data, *data2, *data3;
 
3787
  int i, pagesize;
 
3788
  int fd;
 
3789
 
 
3790
  pagesize = getpagesize ();
 
3791
 
 
3792
  /* First, make a file with some known garbage in it. */
 
3793
  data = (char *) malloc (pagesize);
 
3794
  if (!data)
 
3795
    exit (1);
 
3796
  for (i = 0; i < pagesize; ++i)
 
3797
    *(data + i) = rand ();
 
3798
  umask (0);
 
3799
  fd = creat ("conftest.mmap", 0600);
 
3800
  if (fd < 0)
 
3801
    exit (1);
 
3802
  if (write (fd, data, pagesize) != pagesize)
 
3803
    exit (1);
 
3804
  close (fd);
 
3805
 
 
3806
  /* Next, try to mmap the file at a fixed address which already has
 
3807
     something else allocated at it.  If we can, also make sure that
 
3808
     we see the same garbage.  */
 
3809
  fd = open ("conftest.mmap", O_RDWR);
 
3810
  if (fd < 0)
 
3811
    exit (1);
 
3812
  data2 = (char *) malloc (2 * pagesize);
 
3813
  if (!data2)
 
3814
    exit (1);
 
3815
  data2 += (pagesize - ((int) data2 & (pagesize - 1))) & (pagesize - 1);
 
3816
  if (data2 != mmap (data2, pagesize, PROT_READ | PROT_WRITE,
 
3817
                     MAP_PRIVATE | MAP_FIXED, fd, 0L))
 
3818
    exit (1);
 
3819
  for (i = 0; i < pagesize; ++i)
 
3820
    if (*(data + i) != *(data2 + i))
 
3821
      exit (1);
 
3822
 
 
3823
  /* Finally, make sure that changes to the mapped area do not
 
3824
     percolate back to the file as seen by read().  (This is a bug on
 
3825
     some variants of i386 svr4.0.)  */
 
3826
  for (i = 0; i < pagesize; ++i)
 
3827
    *(data2 + i) = *(data2 + i) + 1;
 
3828
  data3 = (char *) malloc (pagesize);
 
3829
  if (!data3)
 
3830
    exit (1);
 
3831
  if (read (fd, data3, pagesize) != pagesize)
 
3832
    exit (1);
 
3833
  for (i = 0; i < pagesize; ++i)
 
3834
    if (*(data + i) != *(data3 + i))
 
3835
      exit (1);
 
3836
  close (fd);
 
3837
  exit (0);
 
3838
}
 
3839
_ACEOF
 
3840
rm -f conftest$ac_exeext
 
3841
if { (eval echo "$as_me:3841: \"$ac_link\"") >&5
 
3842
  (eval $ac_link) 2>&5
 
3843
  ac_status=$?
 
3844
  echo "$as_me:3844: \$? = $ac_status" >&5
 
3845
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
3846
  { (eval echo "$as_me:3846: \"$ac_try\"") >&5
 
3847
  (eval $ac_try) 2>&5
 
3848
  ac_status=$?
 
3849
  echo "$as_me:3849: \$? = $ac_status" >&5
 
3850
  (exit $ac_status); }; }; then
 
3851
  ac_cv_func_mmap_fixed_mapped=yes
 
3852
else
 
3853
  echo "$as_me: program exited with status $ac_status" >&5
 
3854
echo "$as_me: failed program was:" >&5
 
3855
cat conftest.$ac_ext >&5
 
3856
ac_cv_func_mmap_fixed_mapped=no
 
3857
fi
 
3858
rm -f core core.* *.core conftest$ac_exeext conftest.$ac_ext
 
3859
fi
 
3860
fi
 
3861
echo "$as_me:3861: result: $ac_cv_func_mmap_fixed_mapped" >&5
 
3862
echo "${ECHO_T}$ac_cv_func_mmap_fixed_mapped" >&6
 
3863
if test $ac_cv_func_mmap_fixed_mapped = yes; then
 
3864
 
 
3865
cat >>confdefs.h <<\EOF
 
3866
#define HAVE_MMAP 1
 
3867
EOF
 
3868
 
 
3869
fi
 
3870
rm -f conftest.mmap
 
3871
 
 
3872
saved_libs="$LIBS"
 
3873
LIBS="$LIBS -lc $LIBM"
 
3874
 
 
3875
for ac_func in fmod strtol getcwd strerror putenv
 
3876
do
 
3877
ac_ac_var=`echo "ac_cv_func_$ac_func" | $ac_tr_sh`
 
3878
echo "$as_me:3878: checking for $ac_func" >&5
 
3879
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
 
3880
if eval "test \"\${$ac_ac_var+set}\" = set"; then
 
3881
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3882
else
 
3883
  cat >conftest.$ac_ext <<_ACEOF
 
3884
#line 3884 "configure"
 
3885
#include "confdefs.h"
 
3886
/* System header to define __stub macros and hopefully few prototypes,
 
3887
    which can conflict with char $ac_func (); below.  */
 
3888
#include <assert.h>
 
3889
/* Override any gcc2 internal prototype to avoid an error.  */
 
3890
#ifdef __cplusplus
 
3891
extern "C"
 
3892
#endif
 
3893
/* We use char because int might match the return type of a gcc2
 
3894
   builtin and then its argument prototype would still apply.  */
 
3895
char $ac_func ();
 
3896
char (*f) ();
 
3897
 
 
3898
int
 
3899
main ()
 
3900
{
 
3901
/* The GNU C library defines this for functions which it implements
 
3902
    to always fail with ENOSYS.  Some functions are actually named
 
3903
    something starting with __ and the normal name is an alias.  */
 
3904
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
 
3905
choke me
 
3906
#else
 
3907
f = $ac_func;
 
3908
#endif
 
3909
 
 
3910
  ;
 
3911
  return 0;
 
3912
}
 
3913
_ACEOF
 
3914
rm -f conftest.$ac_objext conftest$ac_exeext
 
3915
if { (eval echo "$as_me:3915: \"$ac_link\"") >&5
 
3916
  (eval $ac_link) 2>&5
 
3917
  ac_status=$?
 
3918
  echo "$as_me:3918: \$? = $ac_status" >&5
 
3919
  (exit $ac_status); } &&
 
3920
         { ac_try='test -s conftest$ac_exeext'
 
3921
  { (eval echo "$as_me:3921: \"$ac_try\"") >&5
 
3922
  (eval $ac_try) 2>&5
 
3923
  ac_status=$?
 
3924
  echo "$as_me:3924: \$? = $ac_status" >&5
 
3925
  (exit $ac_status); }; }; then
 
3926
  eval "$ac_ac_var=yes"
 
3927
else
 
3928
  echo "$as_me: failed program was:" >&5
 
3929
cat conftest.$ac_ext >&5
 
3930
eval "$ac_ac_var=no"
 
3931
fi
 
3932
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
3933
fi
 
3934
echo "$as_me:3934: result: `eval echo '${'$ac_ac_var'}'`" >&5
 
3935
echo "${ECHO_T}`eval echo '${'$ac_ac_var'}'`" >&6
 
3936
if test `eval echo '${'$ac_ac_var'}'` = yes; then
 
3937
  cat >>confdefs.h <<EOF
 
3938
#define `echo "HAVE_$ac_func" | $ac_tr_cpp` 1
 
3939
EOF
 
3940
 
 
3941
else
 
3942
  LIBOBJS="$LIBOBJS $ac_func.$ac_objext"
 
3943
fi
 
3944
done
 
3945
 
 
3946
LIBS="$saved_libs"
 
3947
 
 
3948
for ac_func in rename strcasecmp strncasecmp strsep strdup
 
3949
do
 
3950
ac_ac_var=`echo "ac_cv_func_$ac_func" | $ac_tr_sh`
 
3951
echo "$as_me:3951: checking for $ac_func" >&5
 
3952
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
 
3953
if eval "test \"\${$ac_ac_var+set}\" = set"; then
 
3954
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3955
else
 
3956
  cat >conftest.$ac_ext <<_ACEOF
 
3957
#line 3957 "configure"
 
3958
#include "confdefs.h"
 
3959
/* System header to define __stub macros and hopefully few prototypes,
 
3960
    which can conflict with char $ac_func (); below.  */
 
3961
#include <assert.h>
 
3962
/* Override any gcc2 internal prototype to avoid an error.  */
 
3963
#ifdef __cplusplus
 
3964
extern "C"
 
3965
#endif
 
3966
/* We use char because int might match the return type of a gcc2
 
3967
   builtin and then its argument prototype would still apply.  */
 
3968
char $ac_func ();
 
3969
char (*f) ();
 
3970
 
 
3971
int
 
3972
main ()
 
3973
{
 
3974
/* The GNU C library defines this for functions which it implements
 
3975
    to always fail with ENOSYS.  Some functions are actually named
 
3976
    something starting with __ and the normal name is an alias.  */
 
3977
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
 
3978
choke me
 
3979
#else
 
3980
f = $ac_func;
 
3981
#endif
 
3982
 
 
3983
  ;
 
3984
  return 0;
 
3985
}
 
3986
_ACEOF
 
3987
rm -f conftest.$ac_objext conftest$ac_exeext
 
3988
if { (eval echo "$as_me:3988: \"$ac_link\"") >&5
 
3989
  (eval $ac_link) 2>&5
 
3990
  ac_status=$?
 
3991
  echo "$as_me:3991: \$? = $ac_status" >&5
 
3992
  (exit $ac_status); } &&
 
3993
         { ac_try='test -s conftest$ac_exeext'
 
3994
  { (eval echo "$as_me:3994: \"$ac_try\"") >&5
 
3995
  (eval $ac_try) 2>&5
 
3996
  ac_status=$?
 
3997
  echo "$as_me:3997: \$? = $ac_status" >&5
 
3998
  (exit $ac_status); }; }; then
 
3999
  eval "$ac_ac_var=yes"
 
4000
else
 
4001
  echo "$as_me: failed program was:" >&5
 
4002
cat conftest.$ac_ext >&5
 
4003
eval "$ac_ac_var=no"
 
4004
fi
 
4005
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
4006
fi
 
4007
echo "$as_me:4007: result: `eval echo '${'$ac_ac_var'}'`" >&5
 
4008
echo "${ECHO_T}`eval echo '${'$ac_ac_var'}'`" >&6
 
4009
if test `eval echo '${'$ac_ac_var'}'` = yes; then
 
4010
  cat >>confdefs.h <<EOF
 
4011
#define `echo "HAVE_$ac_func" | $ac_tr_cpp` 1
 
4012
EOF
 
4013
 
 
4014
fi
 
4015
done
 
4016
 
 
4017
echo "$as_me:4017: checking for mkstemp" >&5
 
4018
echo $ECHO_N "checking for mkstemp... $ECHO_C" >&6
 
4019
if test "${ac_cv_func_mkstemp+set}" = set; then
 
4020
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4021
else
 
4022
  cat >conftest.$ac_ext <<_ACEOF
 
4023
#line 4023 "configure"
 
4024
#include "confdefs.h"
 
4025
/* System header to define __stub macros and hopefully few prototypes,
 
4026
    which can conflict with char mkstemp (); below.  */
 
4027
#include <assert.h>
 
4028
/* Override any gcc2 internal prototype to avoid an error.  */
 
4029
#ifdef __cplusplus
 
4030
extern "C"
 
4031
#endif
 
4032
/* We use char because int might match the return type of a gcc2
 
4033
   builtin and then its argument prototype would still apply.  */
 
4034
char mkstemp ();
 
4035
char (*f) ();
 
4036
 
 
4037
int
 
4038
main ()
 
4039
{
 
4040
/* The GNU C library defines this for functions which it implements
 
4041
    to always fail with ENOSYS.  Some functions are actually named
 
4042
    something starting with __ and the normal name is an alias.  */
 
4043
#if defined (__stub_mkstemp) || defined (__stub___mkstemp)
 
4044
choke me
 
4045
#else
 
4046
f = mkstemp;
 
4047
#endif
 
4048
 
 
4049
  ;
 
4050
  return 0;
 
4051
}
 
4052
_ACEOF
 
4053
rm -f conftest.$ac_objext conftest$ac_exeext
 
4054
if { (eval echo "$as_me:4054: \"$ac_link\"") >&5
 
4055
  (eval $ac_link) 2>&5
 
4056
  ac_status=$?
 
4057
  echo "$as_me:4057: \$? = $ac_status" >&5
 
4058
  (exit $ac_status); } &&
 
4059
         { ac_try='test -s conftest$ac_exeext'
 
4060
  { (eval echo "$as_me:4060: \"$ac_try\"") >&5
 
4061
  (eval $ac_try) 2>&5
 
4062
  ac_status=$?
 
4063
  echo "$as_me:4063: \$? = $ac_status" >&5
 
4064
  (exit $ac_status); }; }; then
 
4065
  ac_cv_func_mkstemp=yes
 
4066
else
 
4067
  echo "$as_me: failed program was:" >&5
 
4068
cat conftest.$ac_ext >&5
 
4069
ac_cv_func_mkstemp=no
 
4070
fi
 
4071
rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 
4072
fi
 
4073
echo "$as_me:4073: result: $ac_cv_func_mkstemp" >&5
 
4074
echo "${ECHO_T}$ac_cv_func_mkstemp" >&6
 
4075
if test $ac_cv_func_mkstemp = yes; then
 
4076
  cat >>confdefs.h <<\EOF
 
4077
#define HAVE_MKSTEMP 1
 
4078
EOF
 
4079
 
 
4080
echo "$as_me:4080: checking for mkstemp prototype in <stdlib.h>" >&5
 
4081
echo $ECHO_N "checking for mkstemp prototype in <stdlib.h>... $ECHO_C" >&6
 
4082
cat >conftest.$ac_ext <<_ACEOF
 
4083
#line 4083 "configure"
 
4084
#include "confdefs.h"
 
4085
#include <stdlib.h>
 
4086
_ACEOF
 
4087
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
 
4088
  egrep "mkstemp" >/dev/null 2>&1; then
 
4089
  echo "$as_me:4089: result: yes" >&5
 
4090
echo "${ECHO_T}yes" >&6;cat >>confdefs.h <<\EOF
 
4091
#define HAVE_MKSTEMP_PROTO 1
 
4092
EOF
 
4093
 
 
4094
else
 
4095
  echo "$as_me:4095: result: no" >&5
 
4096
echo "${ECHO_T}no" >&6
 
4097
fi
 
4098
rm -f conftest*
 
4099
 
 
4100
fi
 
4101
 
 
4102
echo "$as_me:4102: checking for sys_siglist declaration in signal.h or unistd.h" >&5
 
4103
echo $ECHO_N "checking for sys_siglist declaration in signal.h or unistd.h... $ECHO_C" >&6
 
4104
if test "${ac_cv_decl_sys_siglist+set}" = set; then
 
4105
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4106
else
 
4107
  cat >conftest.$ac_ext <<_ACEOF
 
4108
#line 4108 "configure"
 
4109
#include "confdefs.h"
 
4110
#include <sys/types.h>
 
4111
#include <signal.h>
 
4112
/* NetBSD declares sys_siglist in unistd.h.  */
 
4113
#if HAVE_UNISTD_H
 
4114
# include <unistd.h>
 
4115
#endif
 
4116
 
 
4117
int
 
4118
main ()
 
4119
{
 
4120
char *msg = *(sys_siglist + 1);
 
4121
  ;
 
4122
  return 0;
 
4123
}
 
4124
_ACEOF
 
4125
rm -f conftest.$ac_objext
 
4126
if { (eval echo "$as_me:4126: \"$ac_compile\"") >&5
 
4127
  (eval $ac_compile) 2>&5
 
4128
  ac_status=$?
 
4129
  echo "$as_me:4129: \$? = $ac_status" >&5
 
4130
  (exit $ac_status); } &&
 
4131
         { ac_try='test -s conftest.$ac_objext'
 
4132
  { (eval echo "$as_me:4132: \"$ac_try\"") >&5
 
4133
  (eval $ac_try) 2>&5
 
4134
  ac_status=$?
 
4135
  echo "$as_me:4135: \$? = $ac_status" >&5
 
4136
  (exit $ac_status); }; }; then
 
4137
  ac_cv_decl_sys_siglist=yes
 
4138
else
 
4139
  echo "$as_me: failed program was:" >&5
 
4140
cat conftest.$ac_ext >&5
 
4141
ac_cv_decl_sys_siglist=no
 
4142
fi
 
4143
rm -f conftest.$ac_objext conftest.$ac_ext
 
4144
fi
 
4145
echo "$as_me:4145: result: $ac_cv_decl_sys_siglist" >&5
 
4146
echo "${ECHO_T}$ac_cv_decl_sys_siglist" >&6
 
4147
if test $ac_cv_decl_sys_siglist = yes; then
 
4148
 
 
4149
cat >>confdefs.h <<\EOF
 
4150
#define SYS_SIGLIST_DECLARED 1
 
4151
EOF
 
4152
 
 
4153
fi
 
4154
 
 
4155
ac_ext=cc
 
4156
ac_cpp='$CXXCPP $CPPFLAGS'
 
4157
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
4158
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
4159
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
4160
 
 
4161
echo "$as_me:4161: checking whether ANSI array delete syntax supported" >&5
 
4162
echo $ECHO_N "checking whether ANSI array delete syntax supported... $ECHO_C" >&6
 
4163
cat >conftest.$ac_ext <<_ACEOF
 
4164
#line 4164 "configure"
 
4165
#include "confdefs.h"
 
4166
 
 
4167
int
 
4168
main ()
 
4169
{
 
4170
char *p = new char[5]; delete [] p;
 
4171
  ;
 
4172
  return 0;
 
4173
}
 
4174
_ACEOF
 
4175
rm -f conftest.$ac_objext
 
4176
if { (eval echo "$as_me:4176: \"$ac_compile\"") >&5
 
4177
  (eval $ac_compile) 2>&5
 
4178
  ac_status=$?
 
4179
  echo "$as_me:4179: \$? = $ac_status" >&5
 
4180
  (exit $ac_status); } &&
 
4181
         { ac_try='test -s conftest.$ac_objext'
 
4182
  { (eval echo "$as_me:4182: \"$ac_try\"") >&5
 
4183
  (eval $ac_try) 2>&5
 
4184
  ac_status=$?
 
4185
  echo "$as_me:4185: \$? = $ac_status" >&5
 
4186
  (exit $ac_status); }; }; then
 
4187
  echo "$as_me:4187: result: yes" >&5
 
4188
echo "${ECHO_T}yes" >&6
 
4189
else
 
4190
  echo "$as_me: failed program was:" >&5
 
4191
cat conftest.$ac_ext >&5
 
4192
echo "$as_me:4192: result: no" >&5
 
4193
echo "${ECHO_T}no" >&6;cat >>confdefs.h <<\EOF
 
4194
#define ARRAY_DELETE_NEEDS_SIZE 1
 
4195
EOF
 
4196
 
 
4197
fi
 
4198
rm -f conftest.$ac_objext conftest.$ac_ext
 
4199
ac_ext=c
 
4200
ac_cpp='$CPP $CPPFLAGS'
 
4201
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
4202
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
4203
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
4204
 
 
4205
ac_ext=cc
 
4206
ac_cpp='$CXXCPP $CPPFLAGS'
 
4207
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
4208
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
4209
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
4210
 
 
4211
echo "$as_me:4211: checking traditional preprocessor" >&5
 
4212
echo $ECHO_N "checking traditional preprocessor... $ECHO_C" >&6
 
4213
cat >conftest.$ac_ext <<_ACEOF
 
4214
#line 4214 "configure"
 
4215
#include "confdefs.h"
 
4216
#define name2(a,b) a/**/b
 
4217
int
 
4218
main ()
 
4219
{
 
4220
int name2(foo,bar);
 
4221
  ;
 
4222
  return 0;
 
4223
}
 
4224
_ACEOF
 
4225
rm -f conftest.$ac_objext
 
4226
if { (eval echo "$as_me:4226: \"$ac_compile\"") >&5
 
4227
  (eval $ac_compile) 2>&5
 
4228
  ac_status=$?
 
4229
  echo "$as_me:4229: \$? = $ac_status" >&5
 
4230
  (exit $ac_status); } &&
 
4231
         { ac_try='test -s conftest.$ac_objext'
 
4232
  { (eval echo "$as_me:4232: \"$ac_try\"") >&5
 
4233
  (eval $ac_try) 2>&5
 
4234
  ac_status=$?
 
4235
  echo "$as_me:4235: \$? = $ac_status" >&5
 
4236
  (exit $ac_status); }; }; then
 
4237
  echo "$as_me:4237: result: yes" >&5
 
4238
echo "${ECHO_T}yes" >&6;cat >>confdefs.h <<\EOF
 
4239
#define TRADITIONAL_CPP 1
 
4240
EOF
 
4241
 
 
4242
else
 
4243
  echo "$as_me: failed program was:" >&5
 
4244
cat conftest.$ac_ext >&5
 
4245
echo "$as_me:4245: result: no" >&5
 
4246
echo "${ECHO_T}no" >&6
 
4247
fi
 
4248
rm -f conftest.$ac_objext conftest.$ac_ext
 
4249
ac_ext=c
 
4250
ac_cpp='$CPP $CPPFLAGS'
 
4251
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
4252
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
4253
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
4254
 
 
4255
echo "$as_me:4255: checking w_coredump" >&5
 
4256
echo $ECHO_N "checking w_coredump... $ECHO_C" >&6
 
4257
if test "$cross_compiling" = yes; then
 
4258
  echo "$as_me:4258: result: no" >&5
 
4259
echo "${ECHO_T}no" >&6
 
4260
else
 
4261
  cat >conftest.$ac_ext <<_ACEOF
 
4262
#line 4262 "configure"
 
4263
#include "confdefs.h"
 
4264
#include <sys/types.h>
 
4265
#include <sys/wait.h>
 
4266
main()
 
4267
{
 
4268
#ifdef WCOREFLAG
 
4269
  exit(1);
 
4270
#else
 
4271
  int i = 0;
 
4272
  ((union wait *)&i)->w_coredump = 1;
 
4273
  exit(i != 0200);
 
4274
#endif
 
4275
}
 
4276
_ACEOF
 
4277
rm -f conftest$ac_exeext
 
4278
if { (eval echo "$as_me:4278: \"$ac_link\"") >&5
 
4279
  (eval $ac_link) 2>&5
 
4280
  ac_status=$?
 
4281
  echo "$as_me:4281: \$? = $ac_status" >&5
 
4282
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
4283
  { (eval echo "$as_me:4283: \"$ac_try\"") >&5
 
4284
  (eval $ac_try) 2>&5
 
4285
  ac_status=$?
 
4286
  echo "$as_me:4286: \$? = $ac_status" >&5
 
4287
  (exit $ac_status); }; }; then
 
4288
  echo "$as_me:4288: result: yes" >&5
 
4289
echo "${ECHO_T}yes" >&6;cat >>confdefs.h <<\EOF
 
4290
#define WCOREFLAG 0200
 
4291
EOF
 
4292
 
 
4293
else
 
4294
  echo "$as_me: program exited with status $ac_status" >&5
 
4295
echo "$as_me: failed program was:" >&5
 
4296
cat conftest.$ac_ext >&5
 
4297
echo "$as_me:4297: result: no" >&5
 
4298
echo "${ECHO_T}no" >&6
 
4299
fi
 
4300
rm -f core core.* *.core conftest$ac_exeext conftest.$ac_ext
 
4301
fi
 
4302
echo "$as_me:4302: checking default value for grops -b option" >&5
 
4303
echo $ECHO_N "checking default value for grops -b option... $ECHO_C" >&6
 
4304
test -n "${BROKEN_SPOOLER_FLAGS}" || BROKEN_SPOOLER_FLAGS=7
 
4305
echo "$as_me:4305: result: $BROKEN_SPOOLER_FLAGS" >&5
 
4306
echo "${ECHO_T}$BROKEN_SPOOLER_FLAGS" >&6
 
4307
 
 
4308
echo "$as_me:4308: checking default paper size" >&5
 
4309
echo $ECHO_N "checking default paper size... $ECHO_C" >&6
 
4310
if test -z "$PAGE"; then
 
4311
        descfile=
 
4312
        if test -r $prefix/share/groff/font/devps/DESC; then
 
4313
                descfile=$prefix/share/groff/font/devps/DESC
 
4314
        elif test -r $prefix/lib/groff/font/devps/DESC; then
 
4315
                descfile=$prefix/lib/groff/font/devps/DESC
 
4316
        else
 
4317
                for f in $prefix/share/groff/*/font/devps/DESC; do
 
4318
                        if test -r $f; then
 
4319
                                descfile=$f
 
4320
                                break
 
4321
                        fi
 
4322
                done
 
4323
        fi
 
4324
        if test -n "$descfile" \
 
4325
          && grep "^paperlength 841890" $descfile >/dev/null 2>&1; then
 
4326
                PAGE=A4
 
4327
        fi
 
4328
fi
 
4329
if test -z "$PAGE"; then
 
4330
        dom=`awk '($1 == "dom" || $1 == "search") { print $2; exit}' \
 
4331
            /etc/resolv.conf 2>/dev/null`
 
4332
        if test -z "$dom"; then
 
4333
                dom=`(domainname) 2>/dev/null | tr -d '+'`
 
4334
                if test -z "$dom" \
 
4335
                  || test "$dom" = '(none)'; then
 
4336
                        dom=`(hostname) 2>/dev/null | grep '\.'`
 
4337
                fi
 
4338
        fi
 
4339
        # If the top-level domain is two letters and it's not `us' or `ca'
 
4340
        # then they probably use A4 paper.
 
4341
        case "$dom" in
 
4342
        *.[Uu][Ss]|*.[Cc][Aa]) ;;
 
4343
        *.[A-Za-z][A-Za-z]) PAGE=A4 ;;
 
4344
        esac
 
4345
fi
 
4346
test -n "$PAGE" || PAGE=letter
 
4347
echo "$as_me:4347: result: $PAGE" >&5
 
4348
echo "${ECHO_T}$PAGE" >&6
 
4349
 
 
4350
echo "$as_me:4350: checking for existing troff installation" >&5
 
4351
echo $ECHO_N "checking for existing troff installation... $ECHO_C" >&6
 
4352
if test "x`(echo .tm '|n(.g' | tr '|' '\\\\' | troff -z -i 2>&1) 2>/dev/null`" = x0; then
 
4353
        echo "$as_me:4353: result: yes" >&5
 
4354
echo "${ECHO_T}yes" >&6
 
4355
        g=g
 
4356
else
 
4357
        echo "$as_me:4357: result: no" >&5
 
4358
echo "${ECHO_T}no" >&6
 
4359
        g=
 
4360
fi
 
4361
 
 
4362
echo "$as_me:4362: checking for prefix of system macro packages" >&5
 
4363
echo $ECHO_N "checking for prefix of system macro packages... $ECHO_C" >&6
 
4364
sys_tmac_prefix=
 
4365
sys_tmac_file_prefix=
 
4366
for d in /usr/share/lib/tmac /usr/lib/tmac; do
 
4367
        for t in "" tmac.; do
 
4368
                for m in an s m; do
 
4369
                        f=$d/$t$m
 
4370
                        if test -z "$sys_tmac_prefix" \
 
4371
                          && test -f $f \
 
4372
                          && grep '^\.if' $f >/dev/null 2>&1; then
 
4373
                                sys_tmac_prefix=$d/$t
 
4374
                                sys_tmac_file_prefix=$t
 
4375
                        fi
 
4376
                done
 
4377
        done
 
4378
done
 
4379
echo "$as_me:4379: result: $sys_tmac_prefix" >&5
 
4380
echo "${ECHO_T}$sys_tmac_prefix" >&6
 
4381
 
 
4382
tmac_wrap=
 
4383
echo "$as_me:4383: checking which system macro packages should be made available" >&5
 
4384
echo $ECHO_N "checking which system macro packages should be made available... $ECHO_C" >&6
 
4385
if test "x$sys_tmac_file_prefix" = "xtmac."; then
 
4386
        for f in $sys_tmac_prefix*; do
 
4387
                suff=`echo $f | sed -e "s;$sys_tmac_prefix;;"`
 
4388
                case "$suff" in
 
4389
                e) ;;
 
4390
                *)
 
4391
                        grep "Copyright.*Free Software Foundation" $f >/dev/null \
 
4392
                          || tmac_wrap="$tmac_wrap $suff" ;;
 
4393
                esac
 
4394
        done
 
4395
elif test -n "$sys_tmac_prefix"; then
 
4396
        files=`echo $sys_tmac_prefix*`
 
4397
        grep "\\.so" $files >conftest.sol
 
4398
        for f in $files; do
 
4399
                case "$f" in
 
4400
                ${sys_tmac_prefix}e) ;;
 
4401
                *.me) ;;
 
4402
                */ms.*) ;;
 
4403
                *)
 
4404
                        b=`basename $f`
 
4405
                        if grep "\\.so.*/$b\$" conftest.sol >/dev/null \
 
4406
                          || grep -l "Copyright.*Free Software Foundation" $f >/dev/null; then
 
4407
                                :
 
4408
                        else
 
4409
                                suff=`echo $f | sed -e "s;$sys_tmac_prefix;;"`
 
4410
                                case "$suff" in
 
4411
                                tmac.*) ;;
 
4412
                                *) tmac_wrap="$tmac_wrap $suff" ;;
 
4413
                                esac
 
4414
                        fi
 
4415
                esac
 
4416
        done
 
4417
        rm -f conftest.sol
 
4418
fi
 
4419
echo "$as_me:4419: result: $tmac_wrap" >&5
 
4420
echo "${ECHO_T}$tmac_wrap" >&6
 
4421
 
 
4422
$srcdir/mkinstalldirs src/xditview
 
4423
ac_config_files="$ac_config_files Makefile src/xditview/Imakefile"
 
4424
 
 
4425
cat >confcache <<\_ACEOF
 
4426
# This file is a shell script that caches the results of configure
 
4427
# tests run on this system so they can be shared between configure
 
4428
# scripts and configure runs, see configure's option --config-cache.
 
4429
# It is not useful on other systems.  If it contains results you don't
 
4430
# want to keep, you may remove or edit it.
 
4431
#
 
4432
# config.status only pays attention to the cache file if you give it
 
4433
# the --recheck option to rerun configure.
 
4434
#
 
4435
# `ac_cv_env_foo' variables (set or unset) will be overriden when
 
4436
# loading this file, other *unset* `ac_cv_foo' will be assigned the
 
4437
# following values.
 
4438
 
 
4439
_ACEOF
 
4440
 
 
4441
# The following way of writing the cache mishandles newlines in values,
 
4442
# but we know of no workaround that is simple, portable, and efficient.
 
4443
# So, don't put newlines in cache variables' values.
 
4444
# Ultrix sh set writes to stderr and can't be redirected directly,
 
4445
# and sets the high bit in the cache file unless we assign to the vars.
 
4446
{
 
4447
  (set) 2>&1 |
 
4448
    case `(ac_space=' '; set | grep ac_space) 2>&1` in
 
4449
    *ac_space=\ *)
 
4450
      # `set' does not quote correctly, so add quotes (double-quote
 
4451
      # substitution turns \\\\ into \\, and sed turns \\ into \).
 
4452
      sed -n \
 
4453
        "s/'/'\\\\''/g;
 
4454
          s/^\\([_$ac_cr_alnum]*_cv_[_$ac_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
 
4455
      ;;
 
4456
    *)
 
4457
      # `set' quotes correctly as required by POSIX, so do not add quotes.
 
4458
      sed -n \
 
4459
        "s/^\\([_$ac_cr_alnum]*_cv_[_$ac_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
 
4460
      ;;
 
4461
    esac;
 
4462
} |
 
4463
  sed '
 
4464
     t clear
 
4465
     : clear
 
4466
     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
 
4467
     t end
 
4468
     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
 
4469
     : end' >>confcache
 
4470
if cmp -s $cache_file confcache; then :; else
 
4471
  if test -w $cache_file; then
 
4472
    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
 
4473
    cat confcache >$cache_file
 
4474
  else
 
4475
    echo "not updating unwritable cache $cache_file"
 
4476
  fi
 
4477
fi
 
4478
rm -f confcache
 
4479
 
 
4480
test "x$prefix" = xNONE && prefix=$ac_default_prefix
 
4481
# Let make expand exec_prefix.
 
4482
test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
 
4483
 
 
4484
# VPATH may cause trouble with some makes, so we remove $(srcdir),
 
4485
# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
 
4486
# trailing colons and then remove the whole line if VPATH becomes empty
 
4487
# (actually we leave an empty line to preserve line numbers).
 
4488
if test "x$srcdir" = x.; then
 
4489
  ac_vpsub='/^[         ]*VPATH[        ]*=/{
 
4490
s/:*\$(srcdir):*/:/;
 
4491
s/:*\${srcdir}:*/:/;
 
4492
s/:*@srcdir@:*/:/;
 
4493
s/^\([^=]*=[    ]*\):*/\1/;
 
4494
s/:*$//;
 
4495
s/^[^=]*=[      ]*$//;
 
4496
}'
 
4497
fi
 
4498
 
 
4499
# Transform confdefs.h into DEFS.
 
4500
# Protect against shell expansion while executing Makefile rules.
 
4501
# Protect against Makefile macro expansion.
 
4502
#
 
4503
# If the first sed substitution is executed (which looks for macros that
 
4504
# take arguments), then we branch to the quote section.  Otherwise,
 
4505
# look for a macro that doesn't take arguments.
 
4506
cat >confdef2opt.sed <<\EOF
 
4507
t clear
 
4508
: clear
 
4509
s,^[    ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
 
4510
t quote
 
4511
s,^[    ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
 
4512
t quote
 
4513
d
 
4514
: quote
 
4515
s,[     `~#$^&*(){}\\|;'"<>?],\\&,g
 
4516
s,\[,\\&,g
 
4517
s,\],\\&,g
 
4518
s,\$,$$,g
 
4519
p
 
4520
EOF
 
4521
# We use echo to avoid assuming a particular line-breaking character.
 
4522
# The extra dot is to prevent the shell from consuming trailing
 
4523
# line-breaks from the sub-command output.  A line-break within
 
4524
# single-quotes doesn't work because, if this script is created in a
 
4525
# platform that uses two characters for line-breaks (e.g., DOS), tr
 
4526
# would break.
 
4527
ac_LF_and_DOT=`echo; echo .`
 
4528
DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
 
4529
rm -f confdef2opt.sed
 
4530
 
 
4531
: ${CONFIG_STATUS=./config.status}
 
4532
ac_clean_files_save=$ac_clean_files
 
4533
ac_clean_files="$ac_clean_files $CONFIG_STATUS"
 
4534
{ echo "$as_me:4534: creating $CONFIG_STATUS" >&5
 
4535
echo "$as_me: creating $CONFIG_STATUS" >&6;}
 
4536
cat >$CONFIG_STATUS <<_ACEOF
 
4537
#! $SHELL
 
4538
# Generated automatically by configure.
 
4539
# Run this file to recreate the current configuration.
 
4540
# Compiler output produced by configure, useful for debugging
 
4541
# configure, is in config.log if it exists.
 
4542
 
 
4543
debug=false
 
4544
SHELL=\${CONFIG_SHELL-$SHELL}
 
4545
ac_cs_invocation="\$0 \$@"
 
4546
 
 
4547
_ACEOF
 
4548
 
 
4549
cat >>$CONFIG_STATUS <<\_ACEOF
 
4550
# Be Bourne compatible
 
4551
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
 
4552
  emulate sh
 
4553
  NULLCMD=:
 
4554
elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
 
4555
  set -o posix
 
4556
fi
 
4557
 
 
4558
# Name of the executable.
 
4559
as_me=`echo "$0" |sed 's,.*[\\/],,'`
 
4560
 
 
4561
if expr a : '\(a\)' >/dev/null 2>&1; then
 
4562
  as_expr=expr
 
4563
else
 
4564
  as_expr=false
 
4565
fi
 
4566
 
 
4567
rm -f conf$$ conf$$.exe conf$$.file
 
4568
echo >conf$$.file
 
4569
if ln -s conf$$.file conf$$ 2>/dev/null; then
 
4570
  # We could just check for DJGPP; but this test a) works b) is more generic
 
4571
  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 
4572
  if test -f conf$$.exe; then
 
4573
    # Don't use ln at all; we don't have any links
 
4574
    as_ln_s='cp -p'
 
4575
  else
 
4576
    as_ln_s='ln -s'
 
4577
  fi
 
4578
elif ln conf$$.file conf$$ 2>/dev/null; then
 
4579
  as_ln_s=ln
 
4580
else
 
4581
  as_ln_s='cp -p'
 
4582
fi
 
4583
rm -f conf$$ conf$$.exe conf$$.file
 
4584
 
 
4585
as_executable_p="test -f"
 
4586
 
 
4587
# Support unset when possible.
 
4588
if (FOO=FOO; unset FOO) >/dev/null 2>&1; then
 
4589
  as_unset=unset
 
4590
else
 
4591
  as_unset=false
 
4592
fi
 
4593
 
 
4594
# NLS nuisances.
 
4595
$as_unset LANG || test "${LANG+set}" != set || { LANG=C; export LANG; }
 
4596
$as_unset LC_ALL || test "${LC_ALL+set}" != set || { LC_ALL=C; export LC_ALL; }
 
4597
$as_unset LC_TIME || test "${LC_TIME+set}" != set || { LC_TIME=C; export LC_TIME; }
 
4598
$as_unset LC_CTYPE || test "${LC_CTYPE+set}" != set || { LC_CTYPE=C; export LC_CTYPE; }
 
4599
$as_unset LANGUAGE || test "${LANGUAGE+set}" != set || { LANGUAGE=C; export LANGUAGE; }
 
4600
$as_unset LC_COLLATE || test "${LC_COLLATE+set}" != set || { LC_COLLATE=C; export LC_COLLATE; }
 
4601
$as_unset LC_NUMERIC || test "${LC_NUMERIC+set}" != set || { LC_NUMERIC=C; export LC_NUMERIC; }
 
4602
$as_unset LC_MESSAGES || test "${LC_MESSAGES+set}" != set || { LC_MESSAGES=C; export LC_MESSAGES; }
 
4603
 
 
4604
# IFS
 
4605
# We need space, tab and new line, in precisely that order.
 
4606
as_nl='
 
4607
'
 
4608
IFS="   $as_nl"
 
4609
 
 
4610
# CDPATH.
 
4611
$as_unset CDPATH || test "${CDPATH+set}" != set || { CDPATH=:; export CDPATH; }
 
4612
 
 
4613
exec 6>&1
 
4614
 
 
4615
_ACEOF
 
4616
 
 
4617
# Files that config.status was made for.
 
4618
if test -n "$ac_config_files"; then
 
4619
  echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
 
4620
fi
 
4621
 
 
4622
if test -n "$ac_config_headers"; then
 
4623
  echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
 
4624
fi
 
4625
 
 
4626
if test -n "$ac_config_links"; then
 
4627
  echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
 
4628
fi
 
4629
 
 
4630
if test -n "$ac_config_commands"; then
 
4631
  echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
 
4632
fi
 
4633
 
 
4634
cat >>$CONFIG_STATUS <<\EOF
 
4635
 
 
4636
ac_cs_usage="\
 
4637
\`$as_me' instantiates files from templates according to the
 
4638
current configuration.
 
4639
 
 
4640
Usage: $0 [OPTIONS] [FILE]...
 
4641
 
 
4642
  -h, --help       print this help, then exit
 
4643
  -V, --version    print version number, then exit
 
4644
  -d, --debug      don't remove temporary files
 
4645
      --recheck    update $as_me by reconfiguring in the same conditions
 
4646
  --file=FILE[:TEMPLATE]
 
4647
                   instantiate the configuration file FILE
 
4648
 
 
4649
Configuration files:
 
4650
$config_files
 
4651
 
 
4652
Report bugs to <bug-autoconf@gnu.org>."
 
4653
EOF
 
4654
 
 
4655
cat >>$CONFIG_STATUS <<EOF
 
4656
ac_cs_version="\\
 
4657
config.status
 
4658
configured by $0, generated by GNU Autoconf 2.50,
 
4659
  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
 
4660
 
 
4661
Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
 
4662
Free Software Foundation, Inc.
 
4663
This config.status script is free software; the Free Software Foundation
 
4664
gives unlimited permission to copy, distribute and modify it."
 
4665
srcdir=$srcdir
 
4666
INSTALL="$INSTALL"
 
4667
EOF
 
4668
 
 
4669
cat >>$CONFIG_STATUS <<\EOF
 
4670
# If no file are specified by the user, then we need to provide default
 
4671
# value.  By we need to know if files were specified by the user.
 
4672
ac_need_defaults=:
 
4673
while test $# != 0
 
4674
do
 
4675
  case $1 in
 
4676
  --*=*)
 
4677
    ac_option=`expr "x$1" : 'x\([^=]*\)='`
 
4678
    ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
 
4679
    shift
 
4680
    set dummy "$ac_option" "$ac_optarg" ${1+"$@"}
 
4681
    shift
 
4682
    ;;
 
4683
  -*);;
 
4684
  *) # This is not an option, so the user has probably given explicit
 
4685
     # arguments.
 
4686
     ac_need_defaults=false;;
 
4687
  esac
 
4688
 
 
4689
  case $1 in
 
4690
  # Handling of the options.
 
4691
EOF
 
4692
cat >>$CONFIG_STATUS <<EOF
 
4693
  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
 
4694
    echo "running $SHELL $0 " $ac_configure_args " --no-create --no-recursion"
 
4695
    exec $SHELL $0 $ac_configure_args --no-create --no-recursion ;;
 
4696
EOF
 
4697
cat >>$CONFIG_STATUS <<\EOF
 
4698
  --version | --vers* | -V )
 
4699
    echo "$ac_cs_version"; exit 0 ;;
 
4700
  --he | --h)
 
4701
    # Conflict between --help and --header
 
4702
    { { echo "$as_me:4702: error: ambiguous option: $1
 
4703
Try \`$0 --help' for more information." >&5
 
4704
echo "$as_me: error: ambiguous option: $1
 
4705
Try \`$0 --help' for more information." >&2;}
 
4706
   { (exit 1); exit 1; }; };;
 
4707
  --help | --hel | -h )
 
4708
    echo "$ac_cs_usage"; exit 0 ;;
 
4709
  --debug | --d* | -d )
 
4710
    debug=: ;;
 
4711
  --file | --fil | --fi | --f )
 
4712
    shift
 
4713
    CONFIG_FILES="$CONFIG_FILES $1"
 
4714
    ac_need_defaults=false;;
 
4715
  --header | --heade | --head | --hea )
 
4716
    shift
 
4717
    CONFIG_HEADERS="$CONFIG_HEADERS $1"
 
4718
    ac_need_defaults=false;;
 
4719
 
 
4720
  # Handling of arguments.
 
4721
  'Makefile' ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
 
4722
  'src/xditview/Imakefile' ) CONFIG_FILES="$CONFIG_FILES src/xditview/Imakefile" ;;
 
4723
 
 
4724
  # This is an error.
 
4725
  -*) { { echo "$as_me:4725: error: unrecognized option: $1
 
4726
Try \`$0 --help' for more information." >&5
 
4727
echo "$as_me: error: unrecognized option: $1
 
4728
Try \`$0 --help' for more information." >&2;}
 
4729
   { (exit 1); exit 1; }; } ;;
 
4730
  *) { { echo "$as_me:4730: error: invalid argument: $1" >&5
 
4731
echo "$as_me: error: invalid argument: $1" >&2;}
 
4732
   { (exit 1); exit 1; }; };;
 
4733
  esac
 
4734
  shift
 
4735
done
 
4736
 
 
4737
exec 5>>config.log
 
4738
cat >&5 << _ACEOF
 
4739
 
 
4740
## ----------------------- ##
 
4741
## Running config.status.  ##
 
4742
## ----------------------- ##
 
4743
 
 
4744
This file was extended by $as_me 2.50, executed with
 
4745
  > $ac_cs_invocation
 
4746
on `(hostname || uname -n) 2>/dev/null | sed 1q`
 
4747
 
 
4748
_ACEOF
 
4749
EOF
 
4750
 
 
4751
cat >>$CONFIG_STATUS <<\EOF
 
4752
# If the user did not use the arguments to specify the items to instantiate,
 
4753
# then the envvar interface is used.  Set only those that are not.
 
4754
# We use the long form for the default assignment because of an extremely
 
4755
# bizarre bug on SunOS 4.1.3.
 
4756
if $ac_need_defaults; then
 
4757
  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
 
4758
fi
 
4759
 
 
4760
# Create a temporary directory, and hook for its removal unless debugging.
 
4761
$debug ||
 
4762
{
 
4763
  trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
 
4764
  trap '{ (exit $?); exit $?; }' 1 2 13 15
 
4765
}
 
4766
 
 
4767
# Create a (secure) tmp directory for tmp files.
 
4768
: ${TMPDIR=/tmp}
 
4769
{
 
4770
  tmp=`(umask 077 && mktemp -d -q "$TMPDIR/csXXXXXX") 2>/dev/null` &&
 
4771
  test -n "$tmp" && test -d "$tmp"
 
4772
}  ||
 
4773
{
 
4774
  tmp=$TMPDIR/cs$$-$RANDOM
 
4775
  (umask 077 && mkdir $tmp)
 
4776
} ||
 
4777
{
 
4778
   echo "$me: cannot create a temporary directory in $TMPDIR" >&2
 
4779
   { (exit 1); exit 1; }
 
4780
}
 
4781
 
 
4782
EOF
 
4783
 
 
4784
cat >>$CONFIG_STATUS <<EOF
 
4785
 
 
4786
#
 
4787
# CONFIG_FILES section.
 
4788
#
 
4789
 
 
4790
# No need to generate the scripts if there are no CONFIG_FILES.
 
4791
# This happens for instance when ./config.status config.h
 
4792
if test -n "\$CONFIG_FILES"; then
 
4793
  # Protect against being on the right side of a sed subst in config.status.
 
4794
  sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
 
4795
   s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
 
4796
s,@SHELL@,$SHELL,;t t
 
4797
s,@exec_prefix@,$exec_prefix,;t t
 
4798
s,@prefix@,$prefix,;t t
 
4799
s,@program_transform_name@,$program_transform_name,;t t
 
4800
s,@bindir@,$bindir,;t t
 
4801
s,@sbindir@,$sbindir,;t t
 
4802
s,@libexecdir@,$libexecdir,;t t
 
4803
s,@datadir@,$datadir,;t t
 
4804
s,@sysconfdir@,$sysconfdir,;t t
 
4805
s,@sharedstatedir@,$sharedstatedir,;t t
 
4806
s,@localstatedir@,$localstatedir,;t t
 
4807
s,@libdir@,$libdir,;t t
 
4808
s,@includedir@,$includedir,;t t
 
4809
s,@oldincludedir@,$oldincludedir,;t t
 
4810
s,@infodir@,$infodir,;t t
 
4811
s,@mandir@,$mandir,;t t
 
4812
s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
 
4813
s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
 
4814
s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
 
4815
s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
 
4816
s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
 
4817
s,@ECHO_C@,$ECHO_C,;t t
 
4818
s,@ECHO_N@,$ECHO_N,;t t
 
4819
s,@ECHO_T@,$ECHO_T,;t t
 
4820
s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
 
4821
s,@DEFS@,$DEFS,;t t
 
4822
s,@LIBS@,$LIBS,;t t
 
4823
s,@top_builddir@,$top_builddir,;t t
 
4824
s,@CC@,$CC,;t t
 
4825
s,@CFLAGS@,$CFLAGS,;t t
 
4826
s,@LDFLAGS@,$LDFLAGS,;t t
 
4827
s,@CPPFLAGS@,$CPPFLAGS,;t t
 
4828
s,@ac_ct_CC@,$ac_ct_CC,;t t
 
4829
s,@EXEEXT@,$EXEEXT,;t t
 
4830
s,@OBJEXT@,$OBJEXT,;t t
 
4831
s,@CXX@,$CXX,;t t
 
4832
s,@CXXFLAGS@,$CXXFLAGS,;t t
 
4833
s,@ac_ct_CXX@,$ac_ct_CXX,;t t
 
4834
s,@TTYDEVDIRS@,$TTYDEVDIRS,;t t
 
4835
s,@LPR@,$LPR,;t t
 
4836
s,@LP@,$LP,;t t
 
4837
s,@LPQ@,$LPQ,;t t
 
4838
s,@PSPRINT@,$PSPRINT,;t t
 
4839
s,@DVIPRINT@,$DVIPRINT,;t t
 
4840
s,@PERLPATH@,$PERLPATH,;t t
 
4841
s,@YACC@,$YACC,;t t
 
4842
s,@RANLIB@,$RANLIB,;t t
 
4843
s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
 
4844
s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
 
4845
s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
 
4846
s,@INSTALL_DATA@,$INSTALL_DATA,;t t
 
4847
s,@LN_S@,$LN_S,;t t
 
4848
s,@SH_SCRIPT_SED_CMD@,$SH_SCRIPT_SED_CMD,;t t
 
4849
s,@CPP@,$CPP,;t t
 
4850
s,@LIBM@,$LIBM,;t t
 
4851
s,@LIBOBJS@,$LIBOBJS,;t t
 
4852
s,@BROKEN_SPOOLER_FLAGS@,$BROKEN_SPOOLER_FLAGS,;t t
 
4853
s,@PAGE@,$PAGE,;t t
 
4854
s,@g@,$g,;t t
 
4855
s,@sys_tmac_prefix@,$sys_tmac_prefix,;t t
 
4856
s,@tmac_wrap@,$tmac_wrap,;t t
 
4857
CEOF
 
4858
 
 
4859
EOF
 
4860
 
 
4861
  cat >>$CONFIG_STATUS <<\EOF
 
4862
  # Split the substitutions into bite-sized pieces for seds with
 
4863
  # small command number limits, like on Digital OSF/1 and HP-UX.
 
4864
  ac_max_sed_lines=48
 
4865
  ac_sed_frag=1 # Number of current file.
 
4866
  ac_beg=1 # First line for current file.
 
4867
  ac_end=$ac_max_sed_lines # Line after last line for current file.
 
4868
  ac_more_lines=:
 
4869
  ac_sed_cmds=
 
4870
  while $ac_more_lines; do
 
4871
    if test $ac_beg -gt 1; then
 
4872
      sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
 
4873
    else
 
4874
      sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
 
4875
    fi
 
4876
    if test ! -s $tmp/subs.frag; then
 
4877
      ac_more_lines=false
 
4878
    else
 
4879
      # The purpose of the label and of the branching condition is to
 
4880
      # speed up the sed processing (if there are no `@' at all, there
 
4881
      # is no need to browse any of the substitutions).
 
4882
      # These are the two extra sed commands mentioned above.
 
4883
      (echo ':t
 
4884
  /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
 
4885
      if test -z "$ac_sed_cmds"; then
 
4886
        ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
 
4887
      else
 
4888
        ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
 
4889
      fi
 
4890
      ac_sed_frag=`expr $ac_sed_frag + 1`
 
4891
      ac_beg=$ac_end
 
4892
      ac_end=`expr $ac_end + $ac_max_sed_lines`
 
4893
    fi
 
4894
  done
 
4895
  if test -z "$ac_sed_cmds"; then
 
4896
    ac_sed_cmds=cat
 
4897
  fi
 
4898
fi # test -n "$CONFIG_FILES"
 
4899
 
 
4900
EOF
 
4901
cat >>$CONFIG_STATUS <<\EOF
 
4902
for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
 
4903
  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
 
4904
  case $ac_file in
 
4905
  - | *:- | *:-:* ) # input from stdin
 
4906
        cat >$tmp/stdin
 
4907
        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
 
4908
        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
 
4909
  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
 
4910
        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
 
4911
  * )   ac_file_in=$ac_file.in ;;
 
4912
  esac
 
4913
 
 
4914
  # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
 
4915
  ac_dir=`$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 
4916
         X"$ac_file" : 'X\(//\)[^/]' \| \
 
4917
         X"$ac_file" : 'X\(//\)$' \| \
 
4918
         X"$ac_file" : 'X\(/\)' \| \
 
4919
         .     : '\(.\)' 2>/dev/null ||
 
4920
echo X"$ac_file" |
 
4921
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 
4922
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 
4923
          /^X\(\/\/\)$/{ s//\1/; q; }
 
4924
          /^X\(\/\).*/{ s//\1/; q; }
 
4925
          s/.*/./; q'`
 
4926
  if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
 
4927
    { case "$ac_dir" in
 
4928
  [\\/]* | ?:[\\/]* ) as_incr_dir=;;
 
4929
  *)                      as_incr_dir=.;;
 
4930
esac
 
4931
as_dummy="$ac_dir"
 
4932
for as_mkdir_dir in `IFS='/\\'; set X $as_dummy; shift; echo "$@"`; do
 
4933
  case $as_mkdir_dir in
 
4934
    # Skip DOS drivespec
 
4935
    ?:) as_incr_dir=$as_mkdir_dir ;;
 
4936
    *)
 
4937
      as_incr_dir=$as_incr_dir/$as_mkdir_dir
 
4938
      test -d "$as_incr_dir" || mkdir "$as_incr_dir"
 
4939
    ;;
 
4940
  esac
 
4941
done; }
 
4942
 
 
4943
    ac_dir_suffix="/`echo $ac_dir|sed 's,^\./,,'`"
 
4944
    # A "../" for each directory in $ac_dir_suffix.
 
4945
    ac_dots=`echo "$ac_dir_suffix" | sed 's,/[^/]*,../,g'`
 
4946
  else
 
4947
    ac_dir_suffix= ac_dots=
 
4948
  fi
 
4949
 
 
4950
  case $srcdir in
 
4951
  .)  ac_srcdir=.
 
4952
      if test -z "$ac_dots"; then
 
4953
         ac_top_srcdir=.
 
4954
      else
 
4955
         ac_top_srcdir=`echo $ac_dots | sed 's,/$,,'`
 
4956
      fi ;;
 
4957
  [\\/]* | ?:[\\/]* )
 
4958
      ac_srcdir=$srcdir$ac_dir_suffix;
 
4959
      ac_top_srcdir=$srcdir ;;
 
4960
  *) # Relative path.
 
4961
    ac_srcdir=$ac_dots$srcdir$ac_dir_suffix
 
4962
    ac_top_srcdir=$ac_dots$srcdir ;;
 
4963
  esac
 
4964
 
 
4965
  case $INSTALL in
 
4966
  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
 
4967
  *) ac_INSTALL=$ac_dots$INSTALL ;;
 
4968
  esac
 
4969
 
 
4970
  if test x"$ac_file" != x-; then
 
4971
    { echo "$as_me:4971: creating $ac_file" >&5
 
4972
echo "$as_me: creating $ac_file" >&6;}
 
4973
    rm -f "$ac_file"
 
4974
  fi
 
4975
  # Let's still pretend it is `configure' which instantiates (i.e., don't
 
4976
  # use $as_me), people would be surprised to read:
 
4977
  #    /* config.h.  Generated automatically by config.status.  */
 
4978
  configure_input="Generated automatically from `echo $ac_file_in |
 
4979
                                                 sed 's,.*/,,'` by configure."
 
4980
 
 
4981
  # First look for the input files in the build tree, otherwise in the
 
4982
  # src tree.
 
4983
  ac_file_inputs=`IFS=:
 
4984
    for f in $ac_file_in; do
 
4985
      case $f in
 
4986
      -) echo $tmp/stdin ;;
 
4987
      [\\/$]*)
 
4988
         # Absolute (can't be DOS-style, as IFS=:)
 
4989
         test -f "$f" || { { echo "$as_me:4989: error: cannot find input file: $f" >&5
 
4990
echo "$as_me: error: cannot find input file: $f" >&2;}
 
4991
   { (exit 1); exit 1; }; }
 
4992
         echo $f;;
 
4993
      *) # Relative
 
4994
         if test -f "$f"; then
 
4995
           # Build tree
 
4996
           echo $f
 
4997
         elif test -f "$srcdir/$f"; then
 
4998
           # Source tree
 
4999
           echo $srcdir/$f
 
5000
         else
 
5001
           # /dev/null tree
 
5002
           { { echo "$as_me:5002: error: cannot find input file: $f" >&5
 
5003
echo "$as_me: error: cannot find input file: $f" >&2;}
 
5004
   { (exit 1); exit 1; }; }
 
5005
         fi;;
 
5006
      esac
 
5007
    done` || { (exit 1); exit 1; }
 
5008
EOF
 
5009
cat >>$CONFIG_STATUS <<EOF
 
5010
  sed "$ac_vpsub
 
5011
$extrasub
 
5012
EOF
 
5013
cat >>$CONFIG_STATUS <<\EOF
 
5014
:t
 
5015
/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
 
5016
s,@configure_input@,$configure_input,;t t
 
5017
s,@srcdir@,$ac_srcdir,;t t
 
5018
s,@top_srcdir@,$ac_top_srcdir,;t t
 
5019
s,@INSTALL@,$ac_INSTALL,;t t
 
5020
" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
 
5021
  rm -f $tmp/stdin
 
5022
  if test x"$ac_file" != x-; then
 
5023
    mv $tmp/out $ac_file
 
5024
  else
 
5025
    cat $tmp/out
 
5026
    rm -f $tmp/out
 
5027
  fi
 
5028
 
 
5029
done
 
5030
EOF
 
5031
 
 
5032
cat >>$CONFIG_STATUS <<\EOF
 
5033
 
 
5034
{ (exit 0); exit 0; }
 
5035
EOF
 
5036
chmod +x $CONFIG_STATUS
 
5037
ac_clean_files=$ac_clean_files_save
 
5038
 
 
5039
# configure is writing to config.log, and then calls config.status.
 
5040
# config.status does its own redirection, appending to config.log.
 
5041
# Unfortunately, on DOS this fails, as config.log is still kept open
 
5042
# by configure, so config.status won't be able to write to it; its
 
5043
# output is simply discarded.  So we exec the FD to /dev/null,
 
5044
# effectively closing config.log, so it can be properly (re)opened and
 
5045
# appended to by config.status.  When coming back to configure, we
 
5046
# need to make the FD available again.
 
5047
if test "$no_create" != yes; then
 
5048
  ac_cs_success=:
 
5049
  exec 5>/dev/null
 
5050
  $SHELL $CONFIG_STATUS || ac_cs_success=false
 
5051
  exec 5>>config.log
 
5052
  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
 
5053
  # would make configure fail if this is the last instruction.
 
5054
  $ac_cs_success || { (exit 1); exit 1; }
 
5055
fi
 
5056