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

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-newlib/] [newlib-1.17.0/] [configure] - Blame information for rev 9

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 9 jlechner
#! /bin/sh
2
# Guess values for system-dependent variables and create Makefiles.
3
# Generated by GNU Autoconf 2.59.
4
#
5
# Copyright (C) 2003 Free Software Foundation, Inc.
6
# This configure script is free software; the Free Software Foundation
7
# gives unlimited permission to copy, distribute and modify it.
8
## --------------------- ##
9
## M4sh Initialization.  ##
10
## --------------------- ##
11
 
12
# Be Bourne compatible
13
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
14
  emulate sh
15
  NULLCMD=:
16
  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
17
  # is contrary to our usage.  Disable this feature.
18
  alias -g '${1+"$@"}'='"$@"'
19
elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
20
  set -o posix
21
fi
22
DUALCASE=1; export DUALCASE # for MKS sh
23
 
24
# Support unset when possible.
25
if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
26
  as_unset=unset
27
else
28
  as_unset=false
29
fi
30
 
31
 
32
# Work around bugs in pre-3.0 UWIN ksh.
33
$as_unset ENV MAIL MAILPATH
34
PS1='$ '
35
PS2='> '
36
PS4='+ '
37
 
38
# NLS nuisances.
39
for as_var in \
40
  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
41
  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
42
  LC_TELEPHONE LC_TIME
43
do
44
  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
45
    eval $as_var=C; export $as_var
46
  else
47
    $as_unset $as_var
48
  fi
49
done
50
 
51
# Required to use basename.
52
if expr a : '\(a\)' >/dev/null 2>&1; then
53
  as_expr=expr
54
else
55
  as_expr=false
56
fi
57
 
58
if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
59
  as_basename=basename
60
else
61
  as_basename=false
62
fi
63
 
64
 
65
# Name of the executable.
66
as_me=`$as_basename "$0" ||
67
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
68
         X"$0" : 'X\(//\)$' \| \
69
         X"$0" : 'X\(/\)$' \| \
70
         .     : '\(.\)' 2>/dev/null ||
71
echo X/"$0" |
72
    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
73
          /^X\/\(\/\/\)$/{ s//\1/; q; }
74
          /^X\/\(\/\).*/{ s//\1/; q; }
75
          s/.*/./; q'`
76
 
77
 
78
# PATH needs CR, and LINENO needs CR and PATH.
79
# Avoid depending upon Character Ranges.
80
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
81
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
82
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
83
as_cr_digits='0123456789'
84
as_cr_alnum=$as_cr_Letters$as_cr_digits
85
 
86
# The user is always right.
87
if test "${PATH_SEPARATOR+set}" != set; then
88
  echo "#! /bin/sh" >conf$$.sh
89
  echo  "exit 0"   >>conf$$.sh
90
  chmod +x conf$$.sh
91
  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
92
    PATH_SEPARATOR=';'
93
  else
94
    PATH_SEPARATOR=:
95
  fi
96
  rm -f conf$$.sh
97
fi
98
 
99
 
100
  as_lineno_1=$LINENO
101
  as_lineno_2=$LINENO
102
  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
103
  test "x$as_lineno_1" != "x$as_lineno_2" &&
104
  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
105
  # Find who we are.  Look in the path if we contain no path at all
106
  # relative or not.
107
  case $0 in
108
    *[\\/]* ) as_myself=$0 ;;
109
    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
110
for as_dir in $PATH
111
do
112
  IFS=$as_save_IFS
113
  test -z "$as_dir" && as_dir=.
114
  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
115
done
116
 
117
       ;;
118
  esac
119
  # We did not find ourselves, most probably we were run as `sh COMMAND'
120
  # in which case we are not to be found in the path.
121
  if test "x$as_myself" = x; then
122
    as_myself=$0
123
  fi
124
  if test ! -f "$as_myself"; then
125
    { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
126
   { (exit 1); exit 1; }; }
127
  fi
128
  case $CONFIG_SHELL in
129
  '')
130
    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
131
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
132
do
133
  IFS=$as_save_IFS
134
  test -z "$as_dir" && as_dir=.
135
  for as_base in sh bash ksh sh5; do
136
         case $as_dir in
137
         /*)
138
           if ("$as_dir/$as_base" -c '
139
  as_lineno_1=$LINENO
140
  as_lineno_2=$LINENO
141
  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
142
  test "x$as_lineno_1" != "x$as_lineno_2" &&
143
  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
144
             $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
145
             $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
146
             CONFIG_SHELL=$as_dir/$as_base
147
             export CONFIG_SHELL
148
             exec "$CONFIG_SHELL" "$0" ${1+"$@"}
149
           fi;;
150
         esac
151
       done
152
done
153
;;
154
  esac
155
 
156
  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
157
  # uniformly replaced by the line number.  The first 'sed' inserts a
158
  # line-number line before each line; the second 'sed' does the real
159
  # work.  The second script uses 'N' to pair each line-number line
160
  # with the numbered line, and appends trailing '-' during
161
  # substitution so that $LINENO is not a special case at line end.
162
  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
163
  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
164
  sed '=' <$as_myself |
165
    sed '
166
      N
167
      s,$,-,
168
      : loop
169
      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
170
      t loop
171
      s,-$,,
172
      s,^['$as_cr_digits']*\n,,
173
    ' >$as_me.lineno &&
174
  chmod +x $as_me.lineno ||
175
    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
176
   { (exit 1); exit 1; }; }
177
 
178
  # Don't try to exec as it changes $[0], causing all sort of problems
179
  # (the dirname of $[0] is not the place where we might find the
180
  # original and so on.  Autoconf is especially sensible to this).
181
  . ./$as_me.lineno
182
  # Exit status is that of the last command.
183
  exit
184
}
185
 
186
 
187
case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
188
  *c*,-n*) ECHO_N= ECHO_C='
189
' ECHO_T='      ' ;;
190
  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
191
  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
192
esac
193
 
194
if expr a : '\(a\)' >/dev/null 2>&1; then
195
  as_expr=expr
196
else
197
  as_expr=false
198
fi
199
 
200
rm -f conf$$ conf$$.exe conf$$.file
201
echo >conf$$.file
202
if ln -s conf$$.file conf$$ 2>/dev/null; then
203
  # We could just check for DJGPP; but this test a) works b) is more generic
204
  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
205
  if test -f conf$$.exe; then
206
    # Don't use ln at all; we don't have any links
207
    as_ln_s='cp -p'
208
  else
209
    as_ln_s='ln -s'
210
  fi
211
elif ln conf$$.file conf$$ 2>/dev/null; then
212
  as_ln_s=ln
213
else
214
  as_ln_s='cp -p'
215
fi
216
rm -f conf$$ conf$$.exe conf$$.file
217
 
218
if mkdir -p . 2>/dev/null; then
219
  as_mkdir_p=:
220
else
221
  test -d ./-p && rmdir ./-p
222
  as_mkdir_p=false
223
fi
224
 
225
as_executable_p="test -f"
226
 
227
# Sed expression to map a string onto a valid CPP name.
228
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
229
 
230
# Sed expression to map a string onto a valid variable name.
231
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
232
 
233
 
234
# IFS
235
# We need space, tab and new line, in precisely that order.
236
as_nl='
237
'
238
IFS="   $as_nl"
239
 
240
# CDPATH.
241
$as_unset CDPATH
242
 
243
 
244
# Name of the host.
245
# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
246
# so uname gets run too.
247
ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
248
 
249
exec 6>&1
250
 
251
#
252
# Initializations.
253
#
254
ac_default_prefix=/usr/local
255
ac_config_libobj_dir=.
256
cross_compiling=no
257
subdirs=
258
MFLAGS=
259
MAKEFLAGS=
260
SHELL=${CONFIG_SHELL-/bin/sh}
261
 
262
# Maximum number of lines to put in a shell here document.
263
# This variable seems obsolete.  It should probably be removed, and
264
# only ac_max_sed_lines should be used.
265
: ${ac_max_here_lines=38}
266
 
267
# Identity of this package.
268
PACKAGE_NAME=
269
PACKAGE_TARNAME=
270
PACKAGE_VERSION=
271
PACKAGE_STRING=
272
PACKAGE_BUGREPORT=
273
 
274
ac_unique_file="move-if-change"
275
ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS TOPLEVEL_CONFIGURE_ARGUMENTS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc ppllibs pplinc clooglibs clooginc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET RPATH_ENVVAR GCC_SHLIB_SUBDIR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
276
ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
277
ac_pwd=`pwd`
278
 
279
# Initialize some variables set by options.
280
ac_init_help=
281
ac_init_version=false
282
# The variables have the same names as the options, with
283
# dashes changed to underlines.
284
cache_file=/dev/null
285
exec_prefix=NONE
286
no_create=
287
no_recursion=
288
prefix=NONE
289
program_prefix=NONE
290
program_suffix=NONE
291
program_transform_name=s,x,x,
292
silent=
293
site=
294
srcdir=
295
verbose=
296
x_includes=NONE
297
x_libraries=NONE
298
 
299
# Installation directory options.
300
# These are left unexpanded so users can "make install exec_prefix=/foo"
301
# and all the variables that are supposed to be based on exec_prefix
302
# by default will actually change.
303
# Use braces instead of parens because sh, perl, etc. also accept them.
304
bindir='${exec_prefix}/bin'
305
sbindir='${exec_prefix}/sbin'
306
libexecdir='${exec_prefix}/libexec'
307
datadir='${prefix}/share'
308
sysconfdir='${prefix}/etc'
309
sharedstatedir='${prefix}/com'
310
localstatedir='${prefix}/var'
311
libdir='${exec_prefix}/lib'
312
includedir='${prefix}/include'
313
oldincludedir='/usr/include'
314
infodir='${prefix}/info'
315
mandir='${prefix}/man'
316
 
317
ac_prev=
318
for ac_option
319
do
320
  # If the previous option needs an argument, assign it.
321
  if test -n "$ac_prev"; then
322
    eval "$ac_prev=\$ac_option"
323
    ac_prev=
324
    continue
325
  fi
326
 
327
  ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
328
 
329
  # Accept the important Cygnus configure options, so we can diagnose typos.
330
 
331
  case $ac_option in
332
 
333
  -bindir | --bindir | --bindi | --bind | --bin | --bi)
334
    ac_prev=bindir ;;
335
  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
336
    bindir=$ac_optarg ;;
337
 
338
  -build | --build | --buil | --bui | --bu)
339
    ac_prev=build_alias ;;
340
  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
341
    build_alias=$ac_optarg ;;
342
 
343
  -cache-file | --cache-file | --cache-fil | --cache-fi \
344
  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
345
    ac_prev=cache_file ;;
346
  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
347
  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
348
    cache_file=$ac_optarg ;;
349
 
350
  --config-cache | -C)
351
    cache_file=config.cache ;;
352
 
353
  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
354
    ac_prev=datadir ;;
355
  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
356
  | --da=*)
357
    datadir=$ac_optarg ;;
358
 
359
  -disable-* | --disable-*)
360
    ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
361
    # Reject names that are not valid shell variable names.
362
    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
363
      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
364
   { (exit 1); exit 1; }; }
365
    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
366
    eval "enable_$ac_feature=no" ;;
367
 
368
  -enable-* | --enable-*)
369
    ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
370
    # Reject names that are not valid shell variable names.
371
    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
372
      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
373
   { (exit 1); exit 1; }; }
374
    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
375
    case $ac_option in
376
      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
377
      *) ac_optarg=yes ;;
378
    esac
379
    eval "enable_$ac_feature='$ac_optarg'" ;;
380
 
381
  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
382
  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
383
  | --exec | --exe | --ex)
384
    ac_prev=exec_prefix ;;
385
  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
386
  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
387
  | --exec=* | --exe=* | --ex=*)
388
    exec_prefix=$ac_optarg ;;
389
 
390
  -gas | --gas | --ga | --g)
391
    # Obsolete; use --with-gas.
392
    with_gas=yes ;;
393
 
394
  -help | --help | --hel | --he | -h)
395
    ac_init_help=long ;;
396
  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
397
    ac_init_help=recursive ;;
398
  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
399
    ac_init_help=short ;;
400
 
401
  -host | --host | --hos | --ho)
402
    ac_prev=host_alias ;;
403
  -host=* | --host=* | --hos=* | --ho=*)
404
    host_alias=$ac_optarg ;;
405
 
406
  -includedir | --includedir | --includedi | --included | --include \
407
  | --includ | --inclu | --incl | --inc)
408
    ac_prev=includedir ;;
409
  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
410
  | --includ=* | --inclu=* | --incl=* | --inc=*)
411
    includedir=$ac_optarg ;;
412
 
413
  -infodir | --infodir | --infodi | --infod | --info | --inf)
414
    ac_prev=infodir ;;
415
  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
416
    infodir=$ac_optarg ;;
417
 
418
  -libdir | --libdir | --libdi | --libd)
419
    ac_prev=libdir ;;
420
  -libdir=* | --libdir=* | --libdi=* | --libd=*)
421
    libdir=$ac_optarg ;;
422
 
423
  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
424
  | --libexe | --libex | --libe)
425
    ac_prev=libexecdir ;;
426
  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
427
  | --libexe=* | --libex=* | --libe=*)
428
    libexecdir=$ac_optarg ;;
429
 
430
  -localstatedir | --localstatedir | --localstatedi | --localstated \
431
  | --localstate | --localstat | --localsta | --localst \
432
  | --locals | --local | --loca | --loc | --lo)
433
    ac_prev=localstatedir ;;
434
  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
435
  | --localstate=* | --localstat=* | --localsta=* | --localst=* \
436
  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
437
    localstatedir=$ac_optarg ;;
438
 
439
  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
440
    ac_prev=mandir ;;
441
  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
442
    mandir=$ac_optarg ;;
443
 
444
  -nfp | --nfp | --nf)
445
    # Obsolete; use --without-fp.
446
    with_fp=no ;;
447
 
448
  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
449
  | --no-cr | --no-c | -n)
450
    no_create=yes ;;
451
 
452
  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
453
  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
454
    no_recursion=yes ;;
455
 
456
  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
457
  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
458
  | --oldin | --oldi | --old | --ol | --o)
459
    ac_prev=oldincludedir ;;
460
  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
461
  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
462
  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
463
    oldincludedir=$ac_optarg ;;
464
 
465
  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
466
    ac_prev=prefix ;;
467
  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
468
    prefix=$ac_optarg ;;
469
 
470
  -program-prefix | --program-prefix | --program-prefi | --program-pref \
471
  | --program-pre | --program-pr | --program-p)
472
    ac_prev=program_prefix ;;
473
  -program-prefix=* | --program-prefix=* | --program-prefi=* \
474
  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
475
    program_prefix=$ac_optarg ;;
476
 
477
  -program-suffix | --program-suffix | --program-suffi | --program-suff \
478
  | --program-suf | --program-su | --program-s)
479
    ac_prev=program_suffix ;;
480
  -program-suffix=* | --program-suffix=* | --program-suffi=* \
481
  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
482
    program_suffix=$ac_optarg ;;
483
 
484
  -program-transform-name | --program-transform-name \
485
  | --program-transform-nam | --program-transform-na \
486
  | --program-transform-n | --program-transform- \
487
  | --program-transform | --program-transfor \
488
  | --program-transfo | --program-transf \
489
  | --program-trans | --program-tran \
490
  | --progr-tra | --program-tr | --program-t)
491
    ac_prev=program_transform_name ;;
492
  -program-transform-name=* | --program-transform-name=* \
493
  | --program-transform-nam=* | --program-transform-na=* \
494
  | --program-transform-n=* | --program-transform-=* \
495
  | --program-transform=* | --program-transfor=* \
496
  | --program-transfo=* | --program-transf=* \
497
  | --program-trans=* | --program-tran=* \
498
  | --progr-tra=* | --program-tr=* | --program-t=*)
499
    program_transform_name=$ac_optarg ;;
500
 
501
  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
502
  | -silent | --silent | --silen | --sile | --sil)
503
    silent=yes ;;
504
 
505
  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
506
    ac_prev=sbindir ;;
507
  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
508
  | --sbi=* | --sb=*)
509
    sbindir=$ac_optarg ;;
510
 
511
  -sharedstatedir | --sharedstatedir | --sharedstatedi \
512
  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
513
  | --sharedst | --shareds | --shared | --share | --shar \
514
  | --sha | --sh)
515
    ac_prev=sharedstatedir ;;
516
  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
517
  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
518
  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
519
  | --sha=* | --sh=*)
520
    sharedstatedir=$ac_optarg ;;
521
 
522
  -site | --site | --sit)
523
    ac_prev=site ;;
524
  -site=* | --site=* | --sit=*)
525
    site=$ac_optarg ;;
526
 
527
  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
528
    ac_prev=srcdir ;;
529
  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
530
    srcdir=$ac_optarg ;;
531
 
532
  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
533
  | --syscon | --sysco | --sysc | --sys | --sy)
534
    ac_prev=sysconfdir ;;
535
  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
536
  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
537
    sysconfdir=$ac_optarg ;;
538
 
539
  -target | --target | --targe | --targ | --tar | --ta | --t)
540
    ac_prev=target_alias ;;
541
  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
542
    target_alias=$ac_optarg ;;
543
 
544
  -v | -verbose | --verbose | --verbos | --verbo | --verb)
545
    verbose=yes ;;
546
 
547
  -version | --version | --versio | --versi | --vers | -V)
548
    ac_init_version=: ;;
549
 
550
  -with-* | --with-*)
551
    ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
552
    # Reject names that are not valid shell variable names.
553
    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
554
      { echo "$as_me: error: invalid package name: $ac_package" >&2
555
   { (exit 1); exit 1; }; }
556
    ac_package=`echo $ac_package| sed 's/-/_/g'`
557
    case $ac_option in
558
      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
559
      *) ac_optarg=yes ;;
560
    esac
561
    eval "with_$ac_package='$ac_optarg'" ;;
562
 
563
  -without-* | --without-*)
564
    ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
565
    # Reject names that are not valid shell variable names.
566
    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
567
      { echo "$as_me: error: invalid package name: $ac_package" >&2
568
   { (exit 1); exit 1; }; }
569
    ac_package=`echo $ac_package | sed 's/-/_/g'`
570
    eval "with_$ac_package=no" ;;
571
 
572
  --x)
573
    # Obsolete; use --with-x.
574
    with_x=yes ;;
575
 
576
  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
577
  | --x-incl | --x-inc | --x-in | --x-i)
578
    ac_prev=x_includes ;;
579
  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
580
  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
581
    x_includes=$ac_optarg ;;
582
 
583
  -x-libraries | --x-libraries | --x-librarie | --x-librari \
584
  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
585
    ac_prev=x_libraries ;;
586
  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
587
  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
588
    x_libraries=$ac_optarg ;;
589
 
590
  -*) { echo "$as_me: error: unrecognized option: $ac_option
591
Try \`$0 --help' for more information." >&2
592
   { (exit 1); exit 1; }; }
593
    ;;
594
 
595
  *=*)
596
    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
597
    # Reject names that are not valid shell variable names.
598
    expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
599
      { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
600
   { (exit 1); exit 1; }; }
601
    ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
602
    eval "$ac_envvar='$ac_optarg'"
603
    export $ac_envvar ;;
604
 
605
  *)
606
    # FIXME: should be removed in autoconf 3.0.
607
    echo "$as_me: WARNING: you should use --build, --host, --target" >&2
608
    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
609
      echo "$as_me: WARNING: invalid host type: $ac_option" >&2
610
    : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
611
    ;;
612
 
613
  esac
614
done
615
 
616
if test -n "$ac_prev"; then
617
  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
618
  { echo "$as_me: error: missing argument to $ac_option" >&2
619
   { (exit 1); exit 1; }; }
620
fi
621
 
622
# Be sure to have absolute paths.
623
for ac_var in exec_prefix prefix
624
do
625
  eval ac_val=$`echo $ac_var`
626
  case $ac_val in
627
    [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
628
    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
629
   { (exit 1); exit 1; }; };;
630
  esac
631
done
632
 
633
# Be sure to have absolute paths.
634
for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
635
              localstatedir libdir includedir oldincludedir infodir mandir
636
do
637
  eval ac_val=$`echo $ac_var`
638
  case $ac_val in
639
    [\\/$]* | ?:[\\/]* ) ;;
640
    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
641
   { (exit 1); exit 1; }; };;
642
  esac
643
done
644
 
645
# There might be people who depend on the old broken behavior: `$host'
646
# used to hold the argument of --host etc.
647
# FIXME: To remove some day.
648
build=$build_alias
649
host=$host_alias
650
target=$target_alias
651
 
652
# FIXME: To remove some day.
653
if test "x$host_alias" != x; then
654
  if test "x$build_alias" = x; then
655
    cross_compiling=maybe
656
    echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
657
    If a cross compiler is detected then cross compile mode will be used." >&2
658
  elif test "x$build_alias" != "x$host_alias"; then
659
    cross_compiling=yes
660
  fi
661
fi
662
 
663
ac_tool_prefix=
664
test -n "$host_alias" && ac_tool_prefix=$host_alias-
665
 
666
test "$silent" = yes && exec 6>/dev/null
667
 
668
 
669
# Find the source files, if location was not specified.
670
if test -z "$srcdir"; then
671
  ac_srcdir_defaulted=yes
672
  # Try the directory containing this script, then its parent.
673
  ac_confdir=`(dirname "$0") 2>/dev/null ||
674
$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
675
         X"$0" : 'X\(//\)[^/]' \| \
676
         X"$0" : 'X\(//\)$' \| \
677
         X"$0" : 'X\(/\)' \| \
678
         .     : '\(.\)' 2>/dev/null ||
679
echo X"$0" |
680
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
681
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
682
          /^X\(\/\/\)$/{ s//\1/; q; }
683
          /^X\(\/\).*/{ s//\1/; q; }
684
          s/.*/./; q'`
685
  srcdir=$ac_confdir
686
  if test ! -r $srcdir/$ac_unique_file; then
687
    srcdir=..
688
  fi
689
else
690
  ac_srcdir_defaulted=no
691
fi
692
if test ! -r $srcdir/$ac_unique_file; then
693
  if test "$ac_srcdir_defaulted" = yes; then
694
    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
695
   { (exit 1); exit 1; }; }
696
  else
697
    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
698
   { (exit 1); exit 1; }; }
699
  fi
700
fi
701
(cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
702
  { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
703
   { (exit 1); exit 1; }; }
704
srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
705
ac_env_build_alias_set=${build_alias+set}
706
ac_env_build_alias_value=$build_alias
707
ac_cv_env_build_alias_set=${build_alias+set}
708
ac_cv_env_build_alias_value=$build_alias
709
ac_env_host_alias_set=${host_alias+set}
710
ac_env_host_alias_value=$host_alias
711
ac_cv_env_host_alias_set=${host_alias+set}
712
ac_cv_env_host_alias_value=$host_alias
713
ac_env_target_alias_set=${target_alias+set}
714
ac_env_target_alias_value=$target_alias
715
ac_cv_env_target_alias_set=${target_alias+set}
716
ac_cv_env_target_alias_value=$target_alias
717
ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
718
 
719
ac_env_CC_set=${CC+set}
720
ac_env_CC_value=$CC
721
ac_cv_env_CC_set=${CC+set}
722
ac_cv_env_CC_value=$CC
723
ac_env_CFLAGS_set=${CFLAGS+set}
724
ac_env_CFLAGS_value=$CFLAGS
725
ac_cv_env_CFLAGS_set=${CFLAGS+set}
726
ac_cv_env_CFLAGS_value=$CFLAGS
727
ac_env_LDFLAGS_set=${LDFLAGS+set}
728
ac_env_LDFLAGS_value=$LDFLAGS
729
ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
730
ac_cv_env_LDFLAGS_value=$LDFLAGS
731
ac_env_CPPFLAGS_set=${CPPFLAGS+set}
732
ac_env_CPPFLAGS_value=$CPPFLAGS
733
ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
734
ac_cv_env_CPPFLAGS_value=$CPPFLAGS
735
ac_env_CXX_set=${CXX+set}
736
ac_env_CXX_value=$CXX
737
ac_cv_env_CXX_set=${CXX+set}
738
ac_cv_env_CXX_value=$CXX
739
ac_env_CXXFLAGS_set=${CXXFLAGS+set}
740
ac_env_CXXFLAGS_value=$CXXFLAGS
741
ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
742
ac_cv_env_CXXFLAGS_value=$CXXFLAGS
743
ac_env_AR_set=${AR+set}
744
ac_env_AR_value=$AR
745
ac_cv_env_AR_set=${AR+set}
746
ac_cv_env_AR_value=$AR
747
ac_env_AS_set=${AS+set}
748
ac_env_AS_value=$AS
749
ac_cv_env_AS_set=${AS+set}
750
ac_cv_env_AS_value=$AS
751
ac_env_DLLTOOL_set=${DLLTOOL+set}
752
ac_env_DLLTOOL_value=$DLLTOOL
753
ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
754
ac_cv_env_DLLTOOL_value=$DLLTOOL
755
ac_env_LD_set=${LD+set}
756
ac_env_LD_value=$LD
757
ac_cv_env_LD_set=${LD+set}
758
ac_cv_env_LD_value=$LD
759
ac_env_LIPO_set=${LIPO+set}
760
ac_env_LIPO_value=$LIPO
761
ac_cv_env_LIPO_set=${LIPO+set}
762
ac_cv_env_LIPO_value=$LIPO
763
ac_env_NM_set=${NM+set}
764
ac_env_NM_value=$NM
765
ac_cv_env_NM_set=${NM+set}
766
ac_cv_env_NM_value=$NM
767
ac_env_RANLIB_set=${RANLIB+set}
768
ac_env_RANLIB_value=$RANLIB
769
ac_cv_env_RANLIB_set=${RANLIB+set}
770
ac_cv_env_RANLIB_value=$RANLIB
771
ac_env_STRIP_set=${STRIP+set}
772
ac_env_STRIP_value=$STRIP
773
ac_cv_env_STRIP_set=${STRIP+set}
774
ac_cv_env_STRIP_value=$STRIP
775
ac_env_WINDRES_set=${WINDRES+set}
776
ac_env_WINDRES_value=$WINDRES
777
ac_cv_env_WINDRES_set=${WINDRES+set}
778
ac_cv_env_WINDRES_value=$WINDRES
779
ac_env_WINDMC_set=${WINDMC+set}
780
ac_env_WINDMC_value=$WINDMC
781
ac_cv_env_WINDMC_set=${WINDMC+set}
782
ac_cv_env_WINDMC_value=$WINDMC
783
ac_env_OBJCOPY_set=${OBJCOPY+set}
784
ac_env_OBJCOPY_value=$OBJCOPY
785
ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
786
ac_cv_env_OBJCOPY_value=$OBJCOPY
787
ac_env_OBJDUMP_set=${OBJDUMP+set}
788
ac_env_OBJDUMP_value=$OBJDUMP
789
ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
790
ac_cv_env_OBJDUMP_value=$OBJDUMP
791
ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
792
ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
793
ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
794
ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
795
ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
796
ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
797
ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
798
ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
799
ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
800
ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
801
ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
802
ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
803
ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
804
ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
805
ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
806
ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
807
ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
808
ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
809
ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
810
ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
811
ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
812
ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
813
ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
814
ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
815
ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
816
ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
817
ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
818
ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
819
ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
820
ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
821
ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
822
ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
823
ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
824
ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
825
ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
826
ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
827
ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
828
ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
829
ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
830
ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
831
ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
832
ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
833
ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
834
ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
835
ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
836
ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
837
ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
838
ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
839
ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
840
ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
841
ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
842
ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
843
ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
844
ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
845
ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
846
ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
847
ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
848
ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
849
ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
850
ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
851
ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
852
ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
853
ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
854
ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
855
 
856
#
857
# Report the --help message.
858
#
859
if test "$ac_init_help" = "long"; then
860
  # Omit some internal or obsolete options to make the list less imposing.
861
  # This message is too long to be a string in the A/UX 3.1 sh.
862
  cat <<_ACEOF
863
\`configure' configures this package to adapt to many kinds of systems.
864
 
865
Usage: $0 [OPTION]... [VAR=VALUE]...
866
 
867
To assign environment variables (e.g., CC, CFLAGS...), specify them as
868
VAR=VALUE.  See below for descriptions of some of the useful variables.
869
 
870
Defaults for the options are specified in brackets.
871
 
872
Configuration:
873
  -h, --help              display this help and exit
874
      --help=short        display options specific to this package
875
      --help=recursive    display the short help of all the included packages
876
  -V, --version           display version information and exit
877
  -q, --quiet, --silent   do not print \`checking...' messages
878
      --cache-file=FILE   cache test results in FILE [disabled]
879
  -C, --config-cache      alias for \`--cache-file=config.cache'
880
  -n, --no-create         do not create output files
881
      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
882
 
883
_ACEOF
884
 
885
  cat <<_ACEOF
886
Installation directories:
887
  --prefix=PREFIX         install architecture-independent files in PREFIX
888
                          [$ac_default_prefix]
889
  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
890
                          [PREFIX]
891
 
892
By default, \`make install' will install all the files in
893
\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
894
an installation prefix other than \`$ac_default_prefix' using \`--prefix',
895
for instance \`--prefix=\$HOME'.
896
 
897
For better control, use the options below.
898
 
899
Fine tuning of the installation directories:
900
  --bindir=DIR           user executables [EPREFIX/bin]
901
  --sbindir=DIR          system admin executables [EPREFIX/sbin]
902
  --libexecdir=DIR       program executables [EPREFIX/libexec]
903
  --datadir=DIR          read-only architecture-independent data [PREFIX/share]
904
  --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
905
  --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
906
  --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
907
  --libdir=DIR           object code libraries [EPREFIX/lib]
908
  --includedir=DIR       C header files [PREFIX/include]
909
  --oldincludedir=DIR    C header files for non-gcc [/usr/include]
910
  --infodir=DIR          info documentation [PREFIX/info]
911
  --mandir=DIR           man documentation [PREFIX/man]
912
_ACEOF
913
 
914
  cat <<\_ACEOF
915
 
916
Program names:
917
  --program-prefix=PREFIX            prepend PREFIX to installed program names
918
  --program-suffix=SUFFIX            append SUFFIX to installed program names
919
  --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
920
 
921
System types:
922
  --build=BUILD     configure for building on BUILD [guessed]
923
  --host=HOST       cross-compile to build programs to run on HOST [BUILD]
924
  --target=TARGET   configure for building compilers for TARGET [HOST]
925
_ACEOF
926
fi
927
 
928
if test -n "$ac_init_help"; then
929
 
930
  cat <<\_ACEOF
931
 
932
Optional Features:
933
  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
934
  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
935
  --enable-gold           use gold instead of ld
936
  --enable-libada         build libada directory
937
  --enable-libssp         build libssp directory
938
  --disable-ppl-version-check    disable check for PPL version
939
  --disable-cloog-version-check  disable check for CLooG version
940
  --enable-stage1-languages[=all]   choose additional languages to build during
941
                          stage1.  Mostly useful for compiler development.
942
  --enable-objc-gc        enable use of Boehm's garbage collector with the
943
                          GNU Objective-C runtime
944
  --enable-bootstrap      enable bootstrapping [yes if native build]
945
  --enable-serial-[{host,target,build}-]configure
946
                          force sequential configuration of
947
                          sub-packages for the host, target or build
948
                          machine, or all sub-packages
949
  --enable-maintainer-mode enable make rules and dependencies not useful
950
                          (and sometimes confusing) to the casual installer
951
  --enable-stage1-checking[=all]   choose additional checking for stage1
952
                          of the compiler
953
  --enable-werror         enable -Werror in bootstrap stage2 and later
954
 
955
Optional Packages:
956
  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
957
  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
958
  --with-build-libsubdir=DIR  Directory where to find libraries for build system
959
  --with-mpfr-dir=PATH    this option has been REMOVED
960
  --with-mpfr=PATH        specify prefix directory for installed MPFR package.
961
                          Equivalent to --with-mpfr-include=PATH/include
962
                          plus --with-mpfr-lib=PATH/lib
963
  --with-mpfr-include=PATH
964
                          specify directory for installed MPFR include files
965
  --with-mpfr-lib=PATH    specify directory for the installed MPFR library
966
  --with-gmp-dir=PATH     this option has been REMOVED
967
  --with-gmp=PATH         specify prefix directory for the installed GMP package.
968
                          Equivalent to --with-gmp-include=PATH/include
969
                          plus --with-gmp-lib=PATH/lib
970
  --with-gmp-include=PATH specify directory for installed GMP include files
971
  --with-gmp-lib=PATH     specify directory for the installed GMP library
972
  --with-ppl=PATH         Specify prefix directory for the installed PPL package
973
                          Equivalent to --with-ppl-include=PATH/include
974
                          plus --with-ppl-lib=PATH/lib
975
  --with-ppl-include=PATH Specify directory for installed PPL include files
976
  --with-ppl-lib=PATH     Specify the directory for the installed PPL library
977
  --with-cloog=PATH       Specify prefix directory for the installed CLooG-PPL package
978
                          Equivalent to --with-cloog-include=PATH/include
979
                          plus --with-cloog-lib=PATH/lib
980
  --with-cloog-include=PATH Specify directory for installed CLooG include files
981
  --with-cloog-lib=PATH   Specify the directory for the installed CLooG library
982
  --with-cloog-polylib=PATH Specify prefix directory for the installed CLooG-PolyLib package
983
  --with-build-sysroot=SYSROOT
984
                          use sysroot as the system root during the build
985
  --with-debug-prefix-map='A=B C=D ...'
986
                             map A to B, C to D ... in debug information
987
  --with-build-time-tools=PATH
988
                          use given path to find target tools during the build
989
  --with-datarootdir      use datarootdir as the data root directory.
990
  --with-docdir           install documentation in this directory.
991
  --with-pdfdir           install pdf in this directory.
992
  --with-htmldir          install html in this directory.
993
 
994
Some influential environment variables:
995
  CC          C compiler command
996
  CFLAGS      C compiler flags
997
  LDFLAGS     linker flags, e.g. -L if you have libraries in a
998
              nonstandard directory 
999
  CPPFLAGS    C/C++ preprocessor flags, e.g. -I if you have
1000
              headers in a nonstandard directory 
1001
  CXX         C++ compiler command
1002
  CXXFLAGS    C++ compiler flags
1003
  AR          AR for the host
1004
  AS          AS for the host
1005
  DLLTOOL     DLLTOOL for the host
1006
  LD          LD for the host
1007
  LIPO        LIPO for the host
1008
  NM          NM for the host
1009
  RANLIB      RANLIB for the host
1010
  STRIP       STRIP for the host
1011
  WINDRES     WINDRES for the host
1012
  WINDMC      WINDMC for the host
1013
  OBJCOPY     OBJCOPY for the host
1014
  OBJDUMP     OBJDUMP for the host
1015
  CC_FOR_TARGET
1016
              CC for the target
1017
  CXX_FOR_TARGET
1018
              CXX for the target
1019
  GCC_FOR_TARGET
1020
              GCC for the target
1021
  GCJ_FOR_TARGET
1022
              GCJ for the target
1023
  GFORTRAN_FOR_TARGET
1024
              GFORTRAN for the target
1025
  AR_FOR_TARGET
1026
              AR for the target
1027
  AS_FOR_TARGET
1028
              AS for the target
1029
  DLLTOOL_FOR_TARGET
1030
              DLLTOOL for the target
1031
  LD_FOR_TARGET
1032
              LD for the target
1033
  LIPO_FOR_TARGET
1034
              LIPO for the target
1035
  NM_FOR_TARGET
1036
              NM for the target
1037
  OBJDUMP_FOR_TARGET
1038
              OBJDUMP for the target
1039
  RANLIB_FOR_TARGET
1040
              RANLIB for the target
1041
  STRIP_FOR_TARGET
1042
              STRIP for the target
1043
  WINDRES_FOR_TARGET
1044
              WINDRES for the target
1045
  WINDMC_FOR_TARGET
1046
              WINDMC for the target
1047
 
1048
Use these variables to override the choices made by `configure' or to help
1049
it to find libraries and programs with nonstandard names/locations.
1050
 
1051
_ACEOF
1052
fi
1053
 
1054
if test "$ac_init_help" = "recursive"; then
1055
  # If there are subdirs, report their specific --help.
1056
  ac_popdir=`pwd`
1057
  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1058
    test -d $ac_dir || continue
1059
    ac_builddir=.
1060
 
1061
if test "$ac_dir" != .; then
1062
  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1063
  # A "../" for each directory in $ac_dir_suffix.
1064
  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1065
else
1066
  ac_dir_suffix= ac_top_builddir=
1067
fi
1068
 
1069
case $srcdir in
1070
  .)  # No --srcdir option.  We are building in place.
1071
    ac_srcdir=.
1072
    if test -z "$ac_top_builddir"; then
1073
       ac_top_srcdir=.
1074
    else
1075
       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1076
    fi ;;
1077
  [\\/]* | ?:[\\/]* )  # Absolute path.
1078
    ac_srcdir=$srcdir$ac_dir_suffix;
1079
    ac_top_srcdir=$srcdir ;;
1080
  *) # Relative path.
1081
    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1082
    ac_top_srcdir=$ac_top_builddir$srcdir ;;
1083
esac
1084
 
1085
# Do not use `cd foo && pwd` to compute absolute paths, because
1086
# the directories may not exist.
1087
case `pwd` in
1088
.) ac_abs_builddir="$ac_dir";;
1089
*)
1090
  case "$ac_dir" in
1091
  .) ac_abs_builddir=`pwd`;;
1092
  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1093
  *) ac_abs_builddir=`pwd`/"$ac_dir";;
1094
  esac;;
1095
esac
1096
case $ac_abs_builddir in
1097
.) ac_abs_top_builddir=${ac_top_builddir}.;;
1098
*)
1099
  case ${ac_top_builddir}. in
1100
  .) ac_abs_top_builddir=$ac_abs_builddir;;
1101
  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1102
  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1103
  esac;;
1104
esac
1105
case $ac_abs_builddir in
1106
.) ac_abs_srcdir=$ac_srcdir;;
1107
*)
1108
  case $ac_srcdir in
1109
  .) ac_abs_srcdir=$ac_abs_builddir;;
1110
  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1111
  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1112
  esac;;
1113
esac
1114
case $ac_abs_builddir in
1115
.) ac_abs_top_srcdir=$ac_top_srcdir;;
1116
*)
1117
  case $ac_top_srcdir in
1118
  .) ac_abs_top_srcdir=$ac_abs_builddir;;
1119
  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1120
  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1121
  esac;;
1122
esac
1123
 
1124
    cd $ac_dir
1125
    # Check for guested configure; otherwise get Cygnus style configure.
1126
    if test -f $ac_srcdir/configure.gnu; then
1127
      echo
1128
      $SHELL $ac_srcdir/configure.gnu  --help=recursive
1129
    elif test -f $ac_srcdir/configure; then
1130
      echo
1131
      $SHELL $ac_srcdir/configure  --help=recursive
1132
    elif test -f $ac_srcdir/configure.ac ||
1133
           test -f $ac_srcdir/configure.in; then
1134
      echo
1135
      $ac_configure --help
1136
    else
1137
      echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1138
    fi
1139
    cd $ac_popdir
1140
  done
1141
fi
1142
 
1143
test -n "$ac_init_help" && exit 0
1144
if $ac_init_version; then
1145
  cat <<\_ACEOF
1146
 
1147
Copyright (C) 2003 Free Software Foundation, Inc.
1148
This configure script is free software; the Free Software Foundation
1149
gives unlimited permission to copy, distribute and modify it.
1150
_ACEOF
1151
  exit 0
1152
fi
1153
exec 5>config.log
1154
cat >&5 <<_ACEOF
1155
This file contains any messages produced by compilers while
1156
running configure, to aid debugging if configure makes a mistake.
1157
 
1158
It was created by $as_me, which was
1159
generated by GNU Autoconf 2.59.  Invocation command line was
1160
 
1161
  $ $0 $@
1162
 
1163
_ACEOF
1164
{
1165
cat <<_ASUNAME
1166
## --------- ##
1167
## Platform. ##
1168
## --------- ##
1169
 
1170
hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1171
uname -m = `(uname -m) 2>/dev/null || echo unknown`
1172
uname -r = `(uname -r) 2>/dev/null || echo unknown`
1173
uname -s = `(uname -s) 2>/dev/null || echo unknown`
1174
uname -v = `(uname -v) 2>/dev/null || echo unknown`
1175
 
1176
/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1177
/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1178
 
1179
/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1180
/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1181
/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1182
hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1183
/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1184
/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1185
/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1186
 
1187
_ASUNAME
1188
 
1189
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1190
for as_dir in $PATH
1191
do
1192
  IFS=$as_save_IFS
1193
  test -z "$as_dir" && as_dir=.
1194
  echo "PATH: $as_dir"
1195
done
1196
 
1197
} >&5
1198
 
1199
cat >&5 <<_ACEOF
1200
 
1201
 
1202
## ----------- ##
1203
## Core tests. ##
1204
## ----------- ##
1205
 
1206
_ACEOF
1207
 
1208
 
1209
# Keep a trace of the command line.
1210
# Strip out --no-create and --no-recursion so they do not pile up.
1211
# Strip out --silent because we don't want to record it for future runs.
1212
# Also quote any args containing shell meta-characters.
1213
# Make two passes to allow for proper duplicate-argument suppression.
1214
ac_configure_args=
1215
ac_configure_args0=
1216
ac_configure_args1=
1217
ac_sep=
1218
ac_must_keep_next=false
1219
for ac_pass in 1 2
1220
do
1221
  for ac_arg
1222
  do
1223
    case $ac_arg in
1224
    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1225
    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1226
    | -silent | --silent | --silen | --sile | --sil)
1227
      continue ;;
1228
    *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1229
      ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1230
    esac
1231
    case $ac_pass in
1232
    1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1233
    2)
1234
      ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1235
      if test $ac_must_keep_next = true; then
1236
        ac_must_keep_next=false # Got value, back to normal.
1237
      else
1238
        case $ac_arg in
1239
          *=* | --config-cache | -C | -disable-* | --disable-* \
1240
          | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1241
          | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1242
          | -with-* | --with-* | -without-* | --without-* | --x)
1243
            case "$ac_configure_args0 " in
1244
              "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1245
            esac
1246
            ;;
1247
          -* ) ac_must_keep_next=true ;;
1248
        esac
1249
      fi
1250
      ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1251
      # Get rid of the leading space.
1252
      ac_sep=" "
1253
      ;;
1254
    esac
1255
  done
1256
done
1257
$as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1258
$as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1259
 
1260
# When interrupted or exit'd, cleanup temporary files, and complete
1261
# config.log.  We remove comments because anyway the quotes in there
1262
# would cause problems or look ugly.
1263
# WARNING: Be sure not to use single quotes in there, as some shells,
1264
# such as our DU 5.0 friend, will then `close' the trap.
1265
trap 'exit_status=$?
1266
  # Save into config.log some information that might help in debugging.
1267
  {
1268
    echo
1269
 
1270
    cat <<\_ASBOX
1271
## ---------------- ##
1272
## Cache variables. ##
1273
## ---------------- ##
1274
_ASBOX
1275
    echo
1276
    # The following way of writing the cache mishandles newlines in values,
1277
{
1278
  (set) 2>&1 |
1279
    case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1280
    *ac_space=\ *)
1281
      sed -n \
1282
        "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1283
          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1284
      ;;
1285
    *)
1286
      sed -n \
1287
        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1288
      ;;
1289
    esac;
1290
}
1291
    echo
1292
 
1293
    cat <<\_ASBOX
1294
## ----------------- ##
1295
## Output variables. ##
1296
## ----------------- ##
1297
_ASBOX
1298
    echo
1299
    for ac_var in $ac_subst_vars
1300
    do
1301
      eval ac_val=$`echo $ac_var`
1302
      echo "$ac_var='"'"'$ac_val'"'"'"
1303
    done | sort
1304
    echo
1305
 
1306
    if test -n "$ac_subst_files"; then
1307
      cat <<\_ASBOX
1308
## ------------- ##
1309
## Output files. ##
1310
## ------------- ##
1311
_ASBOX
1312
      echo
1313
      for ac_var in $ac_subst_files
1314
      do
1315
        eval ac_val=$`echo $ac_var`
1316
        echo "$ac_var='"'"'$ac_val'"'"'"
1317
      done | sort
1318
      echo
1319
    fi
1320
 
1321
    if test -s confdefs.h; then
1322
      cat <<\_ASBOX
1323
## ----------- ##
1324
## confdefs.h. ##
1325
## ----------- ##
1326
_ASBOX
1327
      echo
1328
      sed "/^$/d" confdefs.h | sort
1329
      echo
1330
    fi
1331
    test "$ac_signal" != 0 &&
1332
      echo "$as_me: caught signal $ac_signal"
1333
    echo "$as_me: exit $exit_status"
1334
  } >&5
1335
  rm -f core *.core &&
1336
  rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1337
    exit $exit_status
1338
     ' 0
1339
for ac_signal in 1 2 13 15; do
1340
  trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1341
done
1342
ac_signal=0
1343
 
1344
# confdefs.h avoids OS command line length limits that DEFS can exceed.
1345
rm -rf conftest* confdefs.h
1346
# AIX cpp loses on an empty file, so make sure it contains at least a newline.
1347
echo >confdefs.h
1348
 
1349
# Predefined preprocessor variables.
1350
 
1351
cat >>confdefs.h <<_ACEOF
1352
#define PACKAGE_NAME "$PACKAGE_NAME"
1353
_ACEOF
1354
 
1355
 
1356
cat >>confdefs.h <<_ACEOF
1357
#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1358
_ACEOF
1359
 
1360
 
1361
cat >>confdefs.h <<_ACEOF
1362
#define PACKAGE_VERSION "$PACKAGE_VERSION"
1363
_ACEOF
1364
 
1365
 
1366
cat >>confdefs.h <<_ACEOF
1367
#define PACKAGE_STRING "$PACKAGE_STRING"
1368
_ACEOF
1369
 
1370
 
1371
cat >>confdefs.h <<_ACEOF
1372
#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1373
_ACEOF
1374
 
1375
 
1376
# Let the site file select an alternate cache file if it wants to.
1377
# Prefer explicitly selected file to automatically selected ones.
1378
if test -z "$CONFIG_SITE"; then
1379
  if test "x$prefix" != xNONE; then
1380
    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1381
  else
1382
    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1383
  fi
1384
fi
1385
for ac_site_file in $CONFIG_SITE; do
1386
  if test -r "$ac_site_file"; then
1387
    { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1388
echo "$as_me: loading site script $ac_site_file" >&6;}
1389
    sed 's/^/| /' "$ac_site_file" >&5
1390
    . "$ac_site_file"
1391
  fi
1392
done
1393
 
1394
if test -r "$cache_file"; then
1395
  # Some versions of bash will fail to source /dev/null (special
1396
  # files actually), so we avoid doing that.
1397
  if test -f "$cache_file"; then
1398
    { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1399
echo "$as_me: loading cache $cache_file" >&6;}
1400
    case $cache_file in
1401
      [\\/]* | ?:[\\/]* ) . $cache_file;;
1402
      *)                      . ./$cache_file;;
1403
    esac
1404
  fi
1405
else
1406
  { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1407
echo "$as_me: creating cache $cache_file" >&6;}
1408
  >$cache_file
1409
fi
1410
 
1411
# Check that the precious variables saved in the cache have kept the same
1412
# value.
1413
ac_cache_corrupted=false
1414
for ac_var in `(set) 2>&1 |
1415
               sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1416
  eval ac_old_set=\$ac_cv_env_${ac_var}_set
1417
  eval ac_new_set=\$ac_env_${ac_var}_set
1418
  eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1419
  eval ac_new_val="\$ac_env_${ac_var}_value"
1420
  case $ac_old_set,$ac_new_set in
1421
    set,)
1422
      { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1423
echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1424
      ac_cache_corrupted=: ;;
1425
    ,set)
1426
      { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1427
echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1428
      ac_cache_corrupted=: ;;
1429
    ,);;
1430
    *)
1431
      if test "x$ac_old_val" != "x$ac_new_val"; then
1432
        # differences in whitespace do not lead to failure.
1433
        ac_old_val_w=`echo x $ac_old_val`
1434
        ac_new_val_w=`echo x $ac_new_val`
1435
        if test "$ac_old_val_w" != "$ac_new_val_w"; then
1436
          { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1437
echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1438
          ac_cache_corrupted=:
1439
        else
1440
          { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1441
echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1442
          eval $ac_var=\$ac_old_val
1443
        fi
1444
        { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1445
echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1446
        { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1447
echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1448
      fi;;
1449
  esac
1450
  # Pass precious variables to config.status.
1451
  if test "$ac_new_set" = set; then
1452
    case $ac_new_val in
1453
    *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1454
      ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1455
    *) ac_arg=$ac_var=$ac_new_val ;;
1456
    esac
1457
    case " $ac_configure_args " in
1458
      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1459
      *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1460
    esac
1461
  fi
1462
done
1463
if $ac_cache_corrupted; then
1464
  { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1465
echo "$as_me: error: in \`$ac_pwd':" >&2;}
1466
  { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1467
echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1468
  { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1469
echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1470
   { (exit 1); exit 1; }; }
1471
fi
1472
 
1473
ac_ext=c
1474
ac_cpp='$CPP $CPPFLAGS'
1475
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1476
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1477
ac_compiler_gnu=$ac_cv_c_compiler_gnu
1478
 
1479
 
1480
 
1481
 
1482
 
1483
 
1484
 
1485
 
1486
 
1487
 
1488
 
1489
 
1490
 
1491
 
1492
 
1493
 
1494
 
1495
 
1496
 
1497
 
1498
 
1499
 
1500
 
1501
 
1502
progname=$0
1503
# if PWD already has a value, it is probably wrong.
1504
if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1505
 
1506
# Export original configure arguments for use by sub-configures.
1507
# Quote arguments with shell meta charatcers.
1508
TOPLEVEL_CONFIGURE_ARGUMENTS=
1509
set -- "$progname" "$@"
1510
for ac_arg
1511
do
1512
  case "$ac_arg" in
1513
  *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1514
    ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1515
    # if the argument is of the form -foo=baz, quote the baz part only
1516
    ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1517
  *) ;;
1518
  esac
1519
  # Add the quoted argument to the list.
1520
  TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1521
done
1522
if test "$silent" = yes; then
1523
  TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1524
fi
1525
# Remove the initial space we just introduced and, as these will be
1526
# expanded by make, quote '$'.
1527
TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1528
 
1529
 
1530
# Find the build, host, and target systems.
1531
ac_aux_dir=
1532
for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1533
  if test -f $ac_dir/install-sh; then
1534
    ac_aux_dir=$ac_dir
1535
    ac_install_sh="$ac_aux_dir/install-sh -c"
1536
    break
1537
  elif test -f $ac_dir/install.sh; then
1538
    ac_aux_dir=$ac_dir
1539
    ac_install_sh="$ac_aux_dir/install.sh -c"
1540
    break
1541
  elif test -f $ac_dir/shtool; then
1542
    ac_aux_dir=$ac_dir
1543
    ac_install_sh="$ac_aux_dir/shtool install -c"
1544
    break
1545
  fi
1546
done
1547
if test -z "$ac_aux_dir"; then
1548
  { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1549
echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1550
   { (exit 1); exit 1; }; }
1551
fi
1552
ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1553
ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1554
ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1555
 
1556
# Make sure we can run config.sub.
1557
$ac_config_sub sun4 >/dev/null 2>&1 ||
1558
  { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1559
echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1560
   { (exit 1); exit 1; }; }
1561
 
1562
echo "$as_me:$LINENO: checking build system type" >&5
1563
echo $ECHO_N "checking build system type... $ECHO_C" >&6
1564
if test "${ac_cv_build+set}" = set; then
1565
  echo $ECHO_N "(cached) $ECHO_C" >&6
1566
else
1567
  ac_cv_build_alias=$build_alias
1568
test -z "$ac_cv_build_alias" &&
1569
  ac_cv_build_alias=`$ac_config_guess`
1570
test -z "$ac_cv_build_alias" &&
1571
  { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1572
echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1573
   { (exit 1); exit 1; }; }
1574
ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1575
  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1576
echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1577
   { (exit 1); exit 1; }; }
1578
 
1579
fi
1580
echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1581
echo "${ECHO_T}$ac_cv_build" >&6
1582
build=$ac_cv_build
1583
build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1584
build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1585
build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1586
 
1587
 
1588
 case ${build_alias} in
1589
  "") build_noncanonical=${build} ;;
1590
  *) build_noncanonical=${build_alias} ;;
1591
esac
1592
 
1593
 
1594
 
1595
 case ${host_alias} in
1596
  "") host_noncanonical=${build_noncanonical} ;;
1597
  *) host_noncanonical=${host_alias} ;;
1598
esac
1599
 
1600
 
1601
 
1602
 case ${target_alias} in
1603
  "") target_noncanonical=${host_noncanonical} ;;
1604
  *) target_noncanonical=${target_alias} ;;
1605
esac
1606
 
1607
 
1608
 
1609
 
1610
test "$host_noncanonical" = "$target_noncanonical" &&
1611
  test "$program_prefix$program_suffix$program_transform_name" = \
1612
    NONENONEs,x,x, &&
1613
  program_transform_name=s,y,y,
1614
 
1615
echo "$as_me:$LINENO: checking host system type" >&5
1616
echo $ECHO_N "checking host system type... $ECHO_C" >&6
1617
if test "${ac_cv_host+set}" = set; then
1618
  echo $ECHO_N "(cached) $ECHO_C" >&6
1619
else
1620
  ac_cv_host_alias=$host_alias
1621
test -z "$ac_cv_host_alias" &&
1622
  ac_cv_host_alias=$ac_cv_build_alias
1623
ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1624
  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1625
echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1626
   { (exit 1); exit 1; }; }
1627
 
1628
fi
1629
echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1630
echo "${ECHO_T}$ac_cv_host" >&6
1631
host=$ac_cv_host
1632
host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1633
host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1634
host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1635
 
1636
 
1637
echo "$as_me:$LINENO: checking target system type" >&5
1638
echo $ECHO_N "checking target system type... $ECHO_C" >&6
1639
if test "${ac_cv_target+set}" = set; then
1640
  echo $ECHO_N "(cached) $ECHO_C" >&6
1641
else
1642
  ac_cv_target_alias=$target_alias
1643
test "x$ac_cv_target_alias" = "x" &&
1644
  ac_cv_target_alias=$ac_cv_host_alias
1645
ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1646
  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1647
echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1648
   { (exit 1); exit 1; }; }
1649
 
1650
fi
1651
echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1652
echo "${ECHO_T}$ac_cv_target" >&6
1653
target=$ac_cv_target
1654
target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1655
target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1656
target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1657
 
1658
 
1659
# The aliases save the names the user supplied, while $host etc.
1660
# will get canonicalized.
1661
test -n "$target_alias" &&
1662
  test "$program_prefix$program_suffix$program_transform_name" = \
1663
    NONENONEs,x,x, &&
1664
  program_prefix=${target_alias}-
1665
test "$program_prefix" != NONE &&
1666
  program_transform_name="s,^,$program_prefix,;$program_transform_name"
1667
# Use a double $ so make ignores it.
1668
test "$program_suffix" != NONE &&
1669
  program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1670
# Double any \ or $.  echo might interpret backslashes.
1671
# By default was `s,x,x', remove it if useless.
1672
cat <<\_ACEOF >conftest.sed
1673
s/[\\$]/&&/g;s/;s,x,x,$//
1674
_ACEOF
1675
program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1676
rm conftest.sed
1677
 
1678
 
1679
 
1680
# Get 'install' or 'install-sh' and its variants.
1681
# Find a good install program.  We prefer a C program (faster),
1682
# so one script is as good as another.  But avoid the broken or
1683
# incompatible versions:
1684
# SysV /etc/install, /usr/sbin/install
1685
# SunOS /usr/etc/install
1686
# IRIX /sbin/install
1687
# AIX /bin/install
1688
# AmigaOS /C/install, which installs bootblocks on floppy discs
1689
# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1690
# AFS /usr/afsws/bin/install, which mishandles nonexistent args
1691
# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1692
# OS/2's system install, which has a completely different semantic
1693
# ./install, which can be erroneously created by make from ./install.sh.
1694
# Reject install programs that cannot install multiple files.
1695
echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1696
echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1697
if test -z "$INSTALL"; then
1698
if test "${ac_cv_path_install+set}" = set; then
1699
  echo $ECHO_N "(cached) $ECHO_C" >&6
1700
else
1701
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1702
for as_dir in $PATH
1703
do
1704
  IFS=$as_save_IFS
1705
  test -z "$as_dir" && as_dir=.
1706
  # Account for people who put trailing slashes in PATH elements.
1707
case $as_dir/ in
1708
  ./ | .// | /cC/* | \
1709
  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1710
  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1711
  /usr/ucb/* ) ;;
1712
  *)
1713
    # OSF1 and SCO ODT 3.0 have their own names for install.
1714
    # Don't use installbsd from OSF since it installs stuff as root
1715
    # by default.
1716
    for ac_prog in ginstall scoinst install; do
1717
      for ac_exec_ext in '' $ac_executable_extensions; do
1718
        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1719
          if test $ac_prog = install &&
1720
            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1721
            # AIX install.  It has an incompatible calling convention.
1722
            :
1723
          elif test $ac_prog = install &&
1724
            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1725
            # program-specific install script used by HP pwplus--don't use.
1726
            :
1727
          else
1728
            rm -rf conftest.one conftest.two conftest.dir
1729
            echo one > conftest.one
1730
            echo two > conftest.two
1731
            mkdir conftest.dir
1732
            if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1733
              test -s conftest.one && test -s conftest.two &&
1734
              test -s conftest.dir/conftest.one &&
1735
              test -s conftest.dir/conftest.two
1736
            then
1737
              ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1738
              break 3
1739
            fi
1740
          fi
1741
        fi
1742
      done
1743
    done
1744
    ;;
1745
esac
1746
done
1747
 
1748
rm -rf conftest.one conftest.two conftest.dir
1749
 
1750
fi
1751
  if test "${ac_cv_path_install+set}" = set; then
1752
    INSTALL=$ac_cv_path_install
1753
  else
1754
    # As a last resort, use the slow shell script.  Don't cache a
1755
    # value for INSTALL within a source directory, because that will
1756
    # break other packages using the cache if that directory is
1757
    # removed, or if the value is a relative name.
1758
    INSTALL=$ac_install_sh
1759
  fi
1760
fi
1761
echo "$as_me:$LINENO: result: $INSTALL" >&5
1762
echo "${ECHO_T}$INSTALL" >&6
1763
 
1764
# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1765
# It thinks the first close brace ends the variable substitution.
1766
test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1767
 
1768
test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1769
 
1770
test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1771
 
1772
echo "$as_me:$LINENO: checking whether ln works" >&5
1773
echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1774
if test "${acx_cv_prog_LN+set}" = set; then
1775
  echo $ECHO_N "(cached) $ECHO_C" >&6
1776
else
1777
  rm -f conftestdata_t
1778
echo >conftestdata_f
1779
if ln conftestdata_f conftestdata_t 2>/dev/null
1780
then
1781
  acx_cv_prog_LN=ln
1782
else
1783
  acx_cv_prog_LN=no
1784
fi
1785
rm -f conftestdata_f conftestdata_t
1786
 
1787
fi
1788
if test $acx_cv_prog_LN = no; then
1789
  LN="cp"
1790
  echo "$as_me:$LINENO: result: no, using $LN" >&5
1791
echo "${ECHO_T}no, using $LN" >&6
1792
else
1793
  LN="$acx_cv_prog_LN"
1794
  echo "$as_me:$LINENO: result: yes" >&5
1795
echo "${ECHO_T}yes" >&6
1796
fi
1797
 
1798
echo "$as_me:$LINENO: checking whether ln -s works" >&5
1799
echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1800
LN_S=$as_ln_s
1801
if test "$LN_S" = "ln -s"; then
1802
  echo "$as_me:$LINENO: result: yes" >&5
1803
echo "${ECHO_T}yes" >&6
1804
else
1805
  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1806
echo "${ECHO_T}no, using $LN_S" >&6
1807
fi
1808
 
1809
 
1810
### we might need to use some other shell than /bin/sh for running subshells
1811
### If we are on Windows, search for the shell.  This will permit people
1812
### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1813
### without also having to set CONFIG_SHELL.  This code will work when
1814
### using bash, which sets OSTYPE.
1815
case "${OSTYPE}" in
1816
*win32*)
1817
  if test x${CONFIG_SHELL} = x ; then
1818
    if test ! -f /bin/sh ; then
1819
      if test x${SHELL} != x && test -f ${SHELL} ; then
1820
        CONFIG_SHELL=${SHELL}
1821
        export CONFIG_SHELL
1822
      else
1823
        for prog in sh sh.exe bash bash.exe; do
1824
          IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1825
          for dir in $PATH; do
1826
            test -z "$dir" && dir=.
1827
            if test -f $dir/$prog; then
1828
              CONFIG_SHELL=$dir/$prog
1829
              export CONFIG_SHELL
1830
              break
1831
            fi
1832
          done
1833
          IFS="$save_ifs"
1834
          test -n "${CONFIG_SHELL}" && break
1835
        done
1836
      fi
1837
    fi
1838
  fi
1839
  ;;
1840
esac
1841
 
1842
config_shell=${CONFIG_SHELL-/bin/sh}
1843
 
1844
moveifchange=${srcdir}/move-if-change
1845
 
1846
srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1847
 
1848
# We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1849
# a relative path.
1850
if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1851
  INSTALL="${srcpwd}/install-sh -c"
1852
fi
1853
 
1854
# Set srcdir to "." if that's what it is.
1855
# This is important for multilib support.
1856
pwd=`${PWDCMD-pwd}`
1857
if test "${pwd}" = "${srcpwd}" ; then
1858
  srcdir=.
1859
fi
1860
 
1861
topsrcdir=$srcpwd
1862
 
1863
extra_host_args=
1864
 
1865
### To add a new directory to the tree, first choose whether it is a target
1866
### or a host dependent tool.  Then put it into the appropriate list
1867
### (library or tools, host or target), doing a dependency sort.
1868
 
1869
# Subdirs will be configured in the order listed in build_configdirs,
1870
# configdirs, or target_configdirs; see the serialization section below.
1871
 
1872
# Dependency sorting is only needed when *configuration* must be done in
1873
# a particular order.  In all cases a dependency should be specified in
1874
# the Makefile, whether or not it's implicitly specified here.
1875
 
1876
# Double entries in build_configdirs, configdirs, or target_configdirs may
1877
# cause circular dependencies and break everything horribly.
1878
 
1879
# these library is used by various programs built for the build
1880
# environment
1881
#
1882
build_libs="build-libiberty"
1883
 
1884
# these tools are built for the build environment
1885
build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1886
 
1887
# these libraries are used by various programs built for the host environment
1888
#
1889
host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr ppl cloog"
1890
 
1891
# these tools are built for the host environment
1892
# Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1893
# know that we are building the simulator.
1894
# binutils, gas and ld appear in that order because it makes sense to run
1895
# "make check" in that particular order.
1896
# If --enable-gold is used, "gold" will replace "ld".
1897
host_tools="texinfo byacc flex bison binutils gas ld fixincludes gcc sid sim gdb make patch prms send-pr gprof etc expect dejagnu ash bash bzip2 m4 autoconf automake libtool diff rcs fileutils shellutils time textutils wdiff find uudecode hello tar gzip indent recode release sed utils guile perl gawk findutils gettext zip fastjar gnattools"
1898
 
1899
# libgcj represents the runtime libraries only used by gcj.
1900
libgcj="target-libffi \
1901
        target-zlib \
1902
        target-qthreads \
1903
        target-libjava"
1904
 
1905
# these libraries are built for the target environment, and are built after
1906
# the host libraries and the host tools (which may be a cross compiler)
1907
#
1908
target_libraries="target-libgcc \
1909
                target-libiberty \
1910
                target-libgloss \
1911
                target-newlib \
1912
                target-libgomp \
1913
                target-libstdc++-v3 \
1914
                target-libmudflap \
1915
                target-libssp \
1916
                target-libgfortran \
1917
                target-boehm-gc \
1918
                ${libgcj} \
1919
                target-libobjc \
1920
                target-libada"
1921
 
1922
# these tools are built using the target libraries, and are intended to
1923
# run only in the target environment
1924
#
1925
# note: any program that *uses* libraries that are in the "target_libraries"
1926
# list belongs in this list.  those programs are also very likely
1927
# candidates for the "native_only" list which follows
1928
#
1929
target_tools="target-examples target-groff target-gperf target-rda"
1930
 
1931
################################################################################
1932
 
1933
## All tools belong in one of the four categories, and are assigned above
1934
## We assign ${configdirs} this way to remove all embedded newlines.  This
1935
## is important because configure will choke if they ever get through.
1936
## ${configdirs} is directories we build using the host tools.
1937
## ${target_configdirs} is directories we build using the target tools.
1938
configdirs=`echo ${host_libs} ${host_tools}`
1939
target_configdirs=`echo ${target_libraries} ${target_tools}`
1940
build_configdirs=`echo ${build_libs} ${build_tools}`
1941
 
1942
 
1943
 
1944
################################################################################
1945
 
1946
srcname="gnu development package"
1947
 
1948
# This gets set non-empty for some net releases of packages.
1949
appdirs=""
1950
 
1951
# Define is_cross_compiler to save on calls to 'test'.
1952
is_cross_compiler=
1953
if test x"${host}" = x"${target}" ; then
1954
  is_cross_compiler=no
1955
else
1956
  is_cross_compiler=yes
1957
fi
1958
 
1959
# Find the build and target subdir names.
1960
 
1961
# post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1962
# have matching libraries, they should use host libraries: Makefile.tpl
1963
# arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1964
# However, they still use the build modules, because the corresponding
1965
# host modules (e.g. bison) are only built for the host when bootstrap
1966
# finishes. So:
1967
# - build_subdir is where we find build modules, and never changes.
1968
# - build_libsubdir is where we find build libraries, and can be overridden.
1969
 
1970
# Prefix 'build-' so this never conflicts with target_subdir.
1971
build_subdir="build-${build_noncanonical}"
1972
 
1973
# Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1974
if test "${with_build_libsubdir+set}" = set; then
1975
  withval="$with_build_libsubdir"
1976
  build_libsubdir="$withval"
1977
else
1978
  build_libsubdir="$build_subdir"
1979
fi;
1980
# --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1981
if ( test $srcdir = . && test -d gcc ) \
1982
   || test -d $srcdir/../host-${host_noncanonical}; then
1983
  host_subdir="host-${host_noncanonical}"
1984
else
1985
  host_subdir=.
1986
fi
1987
# No prefix.
1988
target_subdir=${target_noncanonical}
1989
 
1990
 
1991
# Skipdirs are removed silently.
1992
skipdirs=
1993
# Noconfigdirs are removed loudly.
1994
noconfigdirs=""
1995
 
1996
use_gnu_ld=
1997
# Make sure we don't let GNU ld be added if we didn't want it.
1998
if test x$with_gnu_ld = xno ; then
1999
  use_gnu_ld=no
2000
  noconfigdirs="$noconfigdirs ld gold"
2001
fi
2002
 
2003
use_gnu_as=
2004
# Make sure we don't let GNU as be added if we didn't want it.
2005
if test x$with_gnu_as = xno ; then
2006
  use_gnu_as=no
2007
  noconfigdirs="$noconfigdirs gas"
2008
fi
2009
 
2010
# some tools are so dependent upon X11 that if we're not building with X,
2011
# it's not even worth trying to configure, much less build, that tool.
2012
 
2013
case ${with_x} in
2014
  yes | "") ;; # the default value for this tree is that X11 is available
2015
  no)
2016
    skipdirs="${skipdirs} tk itcl libgui"
2017
    # We won't be able to build gdbtk without X.
2018
    enable_gdbtk=no
2019
    ;;
2020
  *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2021
esac
2022
 
2023
# Some tools are only suitable for building in a "native" situation.
2024
# Remove these if host!=target.
2025
native_only="autoconf automake libtool fileutils find gawk gettext gzip hello indent m4 rcs recode sed shellutils tar textutils uudecode wdiff target-groff guile perl time ash bash bzip2 prms gnuserv target-gperf"
2026
 
2027
# Similarly, some are only suitable for cross toolchains.
2028
# Remove these if host=target.
2029
cross_only="target-libgloss target-newlib target-opcodes"
2030
 
2031
case $is_cross_compiler in
2032
  no) skipdirs="${skipdirs} ${cross_only}" ;;
2033
  yes) skipdirs="${skipdirs} ${native_only}" ;;
2034
esac
2035
 
2036
# If both --with-headers and --with-libs are specified, default to
2037
# --without-newlib.
2038
if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2039
   && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2040
  if test x"${with_newlib}" = x ; then
2041
    with_newlib=no
2042
  fi
2043
fi
2044
 
2045
# Recognize --with-newlib/--without-newlib.
2046
case ${with_newlib} in
2047
  no) skipdirs="${skipdirs} target-newlib" ;;
2048
  yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2049
esac
2050
 
2051
# Handle --enable-gold.
2052
 
2053
# Check whether --enable-gold or --disable-gold was given.
2054
if test "${enable_gold+set}" = set; then
2055
  enableval="$enable_gold"
2056
  ENABLE_GOLD=$enableval
2057
else
2058
  ENABLE_GOLD=no
2059
fi;
2060
if test "${ENABLE_GOLD}" = "yes"; then
2061
  # Check for ELF target.
2062
  is_elf=no
2063
  case "${target}" in
2064
    *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2065
    | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2066
    | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2067
      case "${target}" in
2068
        *-*-linux*aout* | *-*-linux*oldld*)
2069
          ;;
2070
        *)
2071
          is_elf=yes
2072
          ;;
2073
      esac
2074
  esac
2075
 
2076
  if test "$is_elf" = "yes"; then
2077
    # Check for target supported by gold.
2078
    case "${target}" in
2079
      i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-*)
2080
        configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2081
        ;;
2082
    esac
2083
  fi
2084
fi
2085
 
2086
# Configure extra directories which are host specific
2087
 
2088
case "${host}" in
2089
  *-cygwin*)
2090
    configdirs="$configdirs libtermcap" ;;
2091
esac
2092
 
2093
# A target can indicate whether a language isn't supported for some reason.
2094
# Only spaces may be used in this macro; not newlines or tabs.
2095
unsupported_languages=
2096
 
2097
# Remove more programs from consideration, based on the host or
2098
# target this usually means that a port of the program doesn't
2099
# exist yet.
2100
 
2101
case "${host}" in
2102
  hppa*64*-*-*)
2103
    noconfigdirs="$noconfigdirs byacc"
2104
    ;;
2105
  i[3456789]86-*-vsta)
2106
    noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2107
    ;;
2108
  i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2109
    noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2110
    ;;
2111
  x86_64-*-mingw*)
2112
    noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2113
    ;;
2114
  i[3456789]86-*-mingw32*)
2115
    # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2116
    noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2117
    ;;
2118
  i[3456789]86-*-beos*)
2119
    noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2120
    ;;
2121
  *-*-cygwin*)
2122
    noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2123
    ;;
2124
  *-*-netbsd*)
2125
    noconfigdirs="$noconfigdirs rcs"
2126
    ;;
2127
  ppc*-*-pe)
2128
    noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2129
    ;;
2130
  powerpc-*-beos*)
2131
    noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2132
    ;;
2133
esac
2134
 
2135
 
2136
# Check whether --enable-libada or --disable-libada was given.
2137
if test "${enable_libada+set}" = set; then
2138
  enableval="$enable_libada"
2139
  ENABLE_LIBADA=$enableval
2140
else
2141
  ENABLE_LIBADA=yes
2142
fi;
2143
if test "${ENABLE_LIBADA}" != "yes" ; then
2144
  noconfigdirs="$noconfigdirs gnattools"
2145
fi
2146
 
2147
# Check whether --enable-libssp or --disable-libssp was given.
2148
if test "${enable_libssp+set}" = set; then
2149
  enableval="$enable_libssp"
2150
  ENABLE_LIBSSP=$enableval
2151
else
2152
  ENABLE_LIBSSP=yes
2153
fi;
2154
 
2155
# Save it here so that, even in case of --enable-libgcj, if the Java
2156
# front-end isn't enabled, we still get libgcj disabled.
2157
libgcj_saved=$libgcj
2158
case $enable_libgcj in
2159
yes)
2160
  # If we reset it here, it won't get added to noconfigdirs in the
2161
  # target-specific build rules, so it will be forcibly enabled
2162
  # (unless the Java language itself isn't enabled).
2163
  libgcj=
2164
  ;;
2165
no)
2166
  # Make sure we get it printed in the list of not supported target libs.
2167
  noconfigdirs="$noconfigdirs ${libgcj}"
2168
  ;;
2169
esac
2170
 
2171
 
2172
# Disable libmudflap on some systems.
2173
if test x$enable_libmudflap = x ; then
2174
    case "${target}" in
2175
    *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2176
        # Enable libmudflap by default in GNU and friends.
2177
        ;;
2178
    *-*-freebsd*)
2179
        # Enable libmudflap by default in FreeBSD.
2180
        ;;
2181
    *)
2182
        # Disable it by default everywhere else.
2183
        noconfigdirs="$noconfigdirs target-libmudflap"
2184
        ;;
2185
    esac
2186
fi
2187
 
2188
# Disable libgomp on non POSIX hosted systems.
2189
if test x$enable_libgomp = x ; then
2190
    # Enable libgomp by default on hosted POSIX systems.
2191
    case "${target}" in
2192
    *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2193
        ;;
2194
    *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2195
        ;;
2196
    *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2197
        ;;
2198
    *-*-darwin* | *-*-aix*)
2199
        ;;
2200
    *)
2201
        noconfigdirs="$noconfigdirs target-libgomp"
2202
        ;;
2203
    esac
2204
fi
2205
 
2206
# Default libgloss CPU subdirectory.
2207
libgloss_dir="$target_cpu"
2208
 
2209
case "${target}" in
2210
  *-*-chorusos)
2211
    noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2212
    ;;
2213
  powerpc-*-darwin* | x86_64-*-darwin[912]*)
2214
    noconfigdirs="$noconfigdirs ld gas gdb gprof"
2215
    noconfigdirs="$noconfigdirs sim target-rda"
2216
    ;;
2217
  i[3456789]86-*-darwin*)
2218
    noconfigdirs="$noconfigdirs ld gas gprof"
2219
    noconfigdirs="$noconfigdirs sim target-rda"
2220
    ;;
2221
  *-*-darwin*)
2222
    noconfigdirs="$noconfigdirs ld gas gdb gprof"
2223
    noconfigdirs="$noconfigdirs sim target-rda"
2224
    noconfigdirs="$noconfigdirs ${libgcj}"
2225
    ;;
2226
  *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2227
    noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2228
    ;;
2229
  *-*-freebsd*)
2230
    noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2231
    if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2232
        && test -f /usr/local/include/gmp.h; then
2233
      with_gmp=/usr/local
2234
    fi
2235
 
2236
    # Skip some stuff that's unsupported on some FreeBSD configurations.
2237
    case "${target}" in
2238
      i*86-*-*) ;;
2239
      alpha*-*-*) ;;
2240
      *)
2241
        noconfigdirs="$noconfigdirs ${libgcj}"
2242
        ;;
2243
    esac
2244
    ;;
2245
  *-*-kaos*)
2246
    # Remove unsupported stuff on all kaOS configurations.
2247
    skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2248
    skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2249
    skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2250
    noconfigdirs="$noconfigdirs target-libgloss"
2251
    ;;
2252
  *-*-netbsd*)
2253
    # Skip some stuff on all NetBSD configurations.
2254
    noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2255
 
2256
    # Skip some stuff that's unsupported on some NetBSD configurations.
2257
    case "${target}" in
2258
      i*86-*-netbsdelf*) ;;
2259
      arm*-*-netbsdelf*) ;;
2260
      *)
2261
        noconfigdirs="$noconfigdirs ${libgcj}"
2262
        ;;
2263
    esac
2264
    ;;
2265
  *-*-netware*)
2266
    noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2267
    ;;
2268
  *-*-rtems*)
2269
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2270
    ;;
2271
    # The tpf target doesn't support gdb yet.
2272
  *-*-tpf*)
2273
    noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2274
    ;;
2275
  *-*-uclinux*)
2276
    noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2277
    ;;
2278
  *-*-vxworks*)
2279
    noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2280
    ;;
2281
  alpha*-dec-osf*)
2282
    # ld works, but does not support shared libraries.
2283
    # newlib is not 64 bit ready.  I'm not sure about fileutils.
2284
    # gas doesn't generate exception information.
2285
    noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2286
    ;;
2287
  alpha*-*-*vms*)
2288
    noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2289
    ;;
2290
  alpha*-*-linux*)
2291
    # newlib is not 64 bit ready
2292
    noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2293
    ;;
2294
  alpha*-*-*)
2295
    # newlib is not 64 bit ready
2296
    noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2297
    ;;
2298
  am33_2.0-*-linux*)
2299
    noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2300
    ;;
2301
  sh-*-linux*)
2302
    noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2303
    ;;
2304
  sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2305
    noconfigdirs="$noconfigdirs ${libgcj}"
2306
    noconfigdirs="$noconfigdirs target-examples"
2307
    noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2308
    noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2309
    noconfigdirs="$noconfigdirs expect dejagnu"
2310
    # the C++ libraries don't build on top of CE's C libraries
2311
    noconfigdirs="$noconfigdirs target-libstdc++-v3"
2312
    noconfigdirs="$noconfigdirs target-newlib"
2313
    case "${host}" in
2314
      *-*-cygwin*) ;; # keep gdb and readline
2315
      *) noconfigdirs="$noconfigdirs gdb readline"
2316
         ;;
2317
    esac
2318
    libgloss_dir=wince
2319
    ;;
2320
  arc-*-*)
2321
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2322
    ;;
2323
  arm-semi-aof )
2324
    ;;
2325
  arm-*-coff | strongarm-*-coff | xscale-*-coff)
2326
    noconfigdirs="$noconfigdirs ${libgcj}"
2327
    libgloss_dir=arm
2328
    ;;
2329
  arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2330
    noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2331
    libgloss_dir=arm
2332
    ;;
2333
  arm*-*-linux-gnueabi)
2334
    noconfigdirs="$noconfigdirs target-qthreads"
2335
    case ${with_newlib} in
2336
      no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2337
    esac
2338
    libgloss_dir=arm
2339
    ;;
2340
  arm*-*-symbianelf*)
2341
    noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2342
    libgloss_dir=arm
2343
    ;;
2344
  arm-*-pe*)
2345
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2346
    ;;
2347
  thumb-*-coff)
2348
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2349
    ;;
2350
  thumb-*-elf)
2351
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2352
    ;;
2353
  thumb-*-pe)
2354
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2355
    ;;
2356
  arm-*-riscix*)
2357
    noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2358
    ;;
2359
  avr-*-*)
2360
    noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2361
    ;;
2362
  bfin-*-*)
2363
    noconfigdirs="$noconfigdirs gdb"
2364
    if test x${is_cross_compiler} != xno ; then
2365
      target_configdirs="${target_configdirs} target-bsp target-cygmon"
2366
    fi
2367
    ;;
2368
  c4x-*-* | tic4x-*-*)
2369
    noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2370
    ;;
2371
  c54x*-*-* | tic54x-*-*)
2372
    noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2373
    ;;
2374
  cr16-*-*)
2375
    noconfigdirs="$noconfigdirs ${libgcj} gdb"
2376
    ;;
2377
  cris-*-* | crisv32-*-*)
2378
    unsupported_languages="$unsupported_languages java"
2379
    case "${target}" in
2380
      *-*-aout)
2381
        unsupported_languages="$unsupported_languages fortran"
2382
        noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2383
      *-*-elf)
2384
        noconfigdirs="$noconfigdirs target-boehm-gc";;
2385
      *-*-linux*)
2386
        noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2387
      *)
2388
        unsupported_languages="$unsupported_languages fortran"
2389
        noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2390
    esac
2391
    libgloss_dir=cris
2392
    ;;
2393
  crx-*-*)
2394
    noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2395
    ;;
2396
  d10v-*-*)
2397
    noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2398
    ;;
2399
  d30v-*-*)
2400
    noconfigdirs="$noconfigdirs ${libgcj} gdb"
2401
    ;;
2402
  ep9312-*-elf | ep9312-*-coff)
2403
    libgloss_dir=arm
2404
    ;;
2405
  fr30-*-elf*)
2406
    noconfigdirs="$noconfigdirs ${libgcj} gdb"
2407
    ;;
2408
  frv-*-*)
2409
    noconfigdirs="$noconfigdirs ${libgcj}"
2410
    ;;
2411
  h8300*-*-*)
2412
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2413
    ;;
2414
  h8500-*-*)
2415
    noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2416
    ;;
2417
  hppa1.1-*-osf* | hppa1.1-*-bsd* )
2418
    ;;
2419
  hppa*64*-*-linux* | parisc*64*-*-linux*)
2420
    # In this case, it's because the hppa64-linux target is for
2421
    # the kernel only at this point and has no libc, and thus no
2422
    # headers, crt*.o, etc., all of which are needed by these.
2423
    noconfigdirs="$noconfigdirs target-zlib"
2424
    ;;
2425
  parisc*-*-linux* | hppa*-*-linux*)
2426
    ;;
2427
  hppa*-*-*elf* | \
2428
  hppa*-*-lites* | \
2429
  hppa*-*-openbsd* | \
2430
  hppa*64*-*-*)
2431
    noconfigdirs="$noconfigdirs ${libgcj}"
2432
    ;;
2433
  hppa*-hp-hpux11*)
2434
    noconfigdirs="$noconfigdirs ld shellutils"
2435
    ;;
2436
  hppa*-*-pro*)
2437
    libgloss_dir=pa
2438
    ;;
2439
  hppa*-*-*)
2440
    # According to Alexandre Oliva , libjava won't
2441
    # build on HP-UX 10.20.
2442
    noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2443
    ;;
2444
  i960-*-*)
2445
    noconfigdirs="$noconfigdirs ${libgcj} gdb"
2446
    ;;
2447
  ia64*-*-elf*)
2448
    # No gdb support yet.
2449
    noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2450
    ;;
2451
  ia64*-**-hpux*)
2452
    # No gdb or ld support yet.
2453
    noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2454
    ;;
2455
  i370-*-opened*)
2456
    ;;
2457
  i[3456789]86-*-coff | i[3456789]86-*-elf)
2458
    noconfigdirs="$noconfigdirs ${libgcj}"
2459
    libgloss_dir=i386
2460
    ;;
2461
  i[3456789]86-*-linux*)
2462
    # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2463
    # not build java stuff by default.
2464
    case "${target}" in
2465
      *-*-*libc1*)
2466
        noconfigdirs="$noconfigdirs ${libgcj}";;
2467
    esac
2468
 
2469
    # This section makes it possible to build newlib natively on linux.
2470
    # If we are using a cross compiler then don't configure newlib.
2471
    if test x${is_cross_compiler} != xno ; then
2472
      noconfigdirs="$noconfigdirs target-newlib"
2473
    fi
2474
    noconfigdirs="$noconfigdirs target-libgloss"
2475
    # If we are not using a cross compiler, do configure newlib.
2476
    # Note however, that newlib will only be configured in this situation
2477
    # if the --with-newlib option has been given, because otherwise
2478
    # 'target-newlib' will appear in skipdirs.
2479
    ;;
2480
  i[3456789]86-*-mingw32*)
2481
    target_configdirs="$target_configdirs target-winsup"
2482
    noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2483
    ;;
2484
  x86_64-*-mingw*)
2485
    target_configdirs="$target_configdirs target-winsup"
2486
    noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2487
    ;;
2488
  *-*-cygwin*)
2489
    target_configdirs="$target_configdirs target-libtermcap target-winsup"
2490
    noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2491
    # always build newlib if winsup directory is present.
2492
    if test -d "$srcdir/winsup/cygwin"; then
2493
      skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2494
    elif test -d "$srcdir/newlib"; then
2495
      echo "Warning: winsup/cygwin is missing so newlib can't be built."
2496
    fi
2497
    ;;
2498
  i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2499
  i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2500
    ;;
2501
  i[3456789]86-*-pe)
2502
    noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2503
    ;;
2504
  i[3456789]86-*-sco3.2v5*)
2505
    # The linker does not yet know about weak symbols in COFF,
2506
    # and is not configured to handle mixed ELF and COFF.
2507
    noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2508
    ;;
2509
  i[3456789]86-*-sco*)
2510
    noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2511
    ;;
2512
  i[3456789]86-*-solaris2*)
2513
    noconfigdirs="$noconfigdirs target-libgloss"
2514
    ;;
2515
  i[3456789]86-*-sysv4*)
2516
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2517
    ;;
2518
  i[3456789]86-*-beos*)
2519
    noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2520
    ;;
2521
  i[3456789]86-*-rdos*)
2522
    noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2523
    ;;
2524
  m32r-*-*)
2525
    noconfigdirs="$noconfigdirs ${libgcj}"
2526
    ;;
2527
  m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2528
    noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2529
    libgloss_dir=m68hc11
2530
    ;;
2531
  m68k-*-elf*)
2532
    noconfigdirs="$noconfigdirs ${libgcj}"
2533
    ;;
2534
  m68k-*-coff*)
2535
    noconfigdirs="$noconfigdirs ${libgcj}"
2536
    ;;
2537
  m68*-*-* | fido-*-*)
2538
    libgloss_dir=m68k
2539
    ;;
2540
  mcore-*-pe*)
2541
  # The EPOC C++ environment does not support exceptions or rtti,
2542
  # and so building libstdc++-v3 tends not to always work.
2543
    noconfigdirs="$noconfigdirs target-libstdc++-v3"
2544
    ;;
2545
  mmix-*-*)
2546
    noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2547
    unsupported_languages="$unsupported_languages fortran java"
2548
    ;;
2549
  mn10200-*-*)
2550
    noconfigdirs="$noconfigdirs ${libgcj}"
2551
    ;;
2552
  mn10300-*-*)
2553
    noconfigdirs="$noconfigdirs ${libgcj}"
2554
    ;;
2555
  mt-*-*)
2556
    noconfigdirs="$noconfigdirs sim"
2557
    ;;
2558
  powerpc-*-aix*)
2559
    # copied from rs6000-*-* entry
2560
    noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2561
    ;;
2562
  powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2563
    target_configdirs="$target_configdirs target-winsup"
2564
    noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2565
    # always build newlib.
2566
    skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2567
    ;;
2568
    # This is temporary until we can link against shared libraries
2569
  powerpcle-*-solaris*)
2570
    noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2571
    libgloss_dir=rs6000
2572
    ;;
2573
  powerpc-*-beos*)
2574
    noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2575
    ;;
2576
  powerpc-*-eabi)
2577
    noconfigdirs="$noconfigdirs ${libgcj}"
2578
    libgloss_dir=rs6000
2579
    ;;
2580
  powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2581
    libgloss_dir=rs6000
2582
    ;;
2583
  rs6000-*-lynxos*)
2584
    noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2585
    ;;
2586
  rs6000-*-aix*)
2587
    noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2588
    ;;
2589
  rs6000-*-*)
2590
    noconfigdirs="$noconfigdirs gprof ${libgcj}"
2591
    ;;
2592
  m68k-apollo-*)
2593
    noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2594
    ;;
2595
  mips*-sde-elf*)
2596
    skipdirs="$skipdirs target-libiberty"
2597
    noconfigdirs="$noconfigdirs ${libgcj}"
2598
    if test x$with_newlib = xyes; then
2599
      noconfigdirs="$noconfigdirs gprof"
2600
    fi
2601
    libgloss_dir=mips
2602
    ;;
2603
  mips*-*-irix5*)
2604
    noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2605
    ;;
2606
  mips*-*-irix6*)
2607
    # Linking libjava exceeds command-line length limits on at least
2608
    # IRIX 6.2, but not on IRIX 6.5.
2609
    # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2610
    # 
2611
    noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2612
    ;;
2613
  mips*-*-bsd*)
2614
    noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2615
    ;;
2616
  mips*-*-linux*)
2617
    noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2618
    ;;
2619
  mips*-*-*)
2620
    noconfigdirs="$noconfigdirs gprof ${libgcj}"
2621
    libgloss_dir=mips
2622
    ;;
2623
  romp-*-*)
2624
    noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2625
    ;;
2626
  sh-*-* | sh64-*-*)
2627
    case "${host}" in
2628
      i[3456789]86-*-vsta) ;; # don't add gprof back in
2629
      i[3456789]86-*-go32*) ;; # don't add gprof back in
2630
      i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2631
      *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2632
    esac
2633
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2634
    ;;
2635
  sparclet-*-aout* | sparc86x-*-*)
2636
    libgloss_dir=sparc
2637
    ;;
2638
  sparc-*-elf*)
2639
    noconfigdirs="$noconfigdirs ${libgcj}"
2640
    ;;
2641
  sparc64-*-elf*)
2642
    noconfigdirs="$noconfigdirs ${libgcj}"
2643
    libgloss_dir=sparc
2644
    ;;
2645
  sparclite-*-*)
2646
    noconfigdirs="$noconfigdirs ${libgcj}"
2647
    libgloss_dir=sparc
2648
    ;;
2649
  sparc-*-sunos4*)
2650
    noconfigdirs="$noconfigdirs ${libgcj}"
2651
    if test x${is_cross_compiler} != xno ; then
2652
           noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2653
    else
2654
           use_gnu_ld=no
2655
    fi
2656
    ;;
2657
  sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2658
    noconfigdirs="$noconfigdirs ${libgcj}"
2659
    ;;
2660
  sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2661
    ;;
2662
  v810-*-*)
2663
    noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2664
    ;;
2665
  v850-*-*)
2666
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2667
    ;;
2668
  v850e-*-*)
2669
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2670
    ;;
2671
  v850ea-*-*)
2672
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2673
    ;;
2674
  vax-*-vms)
2675
    noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2676
    ;;
2677
  vax-*-*)
2678
    noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2679
    ;;
2680
  xtensa*-*-*)
2681
    noconfigdirs="$noconfigdirs ${libgcj}"
2682
    ;;
2683
  ip2k-*-*)
2684
    noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2685
    ;;
2686
  *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2687
    noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2688
    ;;
2689
  *-*-lynxos*)
2690
    noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2691
    ;;
2692
  *-*-*)
2693
    noconfigdirs="$noconfigdirs ${libgcj}"
2694
    ;;
2695
esac
2696
 
2697
# If we aren't building newlib, then don't build libgloss, since libgloss
2698
# depends upon some newlib header files.
2699
case "${noconfigdirs}" in
2700
  *target-libgloss*) ;;
2701
  *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2702
esac
2703
 
2704
# Work in distributions that contain no compiler tools, like Autoconf.
2705
tentative_cc=""
2706
host_makefile_frag=/dev/null
2707
if test -d ${srcdir}/config ; then
2708
case "${host}" in
2709
  m68k-hp-hpux*)
2710
    # Avoid "too much defining" errors from HPUX compiler.
2711
    tentative_cc="cc -Wp,-H256000"
2712
    # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2713
    # If it's HP/UX ar, this should be harmless.
2714
    RANLIB="ar ts"
2715
    ;;
2716
  m68k-apollo-sysv*)
2717
    tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2718
    ;;
2719
  m68k-apollo-bsd*)
2720
    #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2721
    # chokes on bfd, the compiler won't let you assign integers to enums, and
2722
    # other problems.  Defining CC to gcc is a questionable way to say "don't use
2723
    # the apollo compiler" (the preferred version of GCC could be called cc,
2724
    # or whatever), but I'm not sure leaving CC as cc is any better...
2725
    #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2726
    # Used to have BISON=yacc.
2727
    tentative_cc=gcc
2728
    ;;
2729
  m88k-dg-dgux*)
2730
    tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2731
    ;;
2732
  m88k-harris-cxux*)
2733
    # Under CX/UX, we want to tell the compiler to use ANSI mode.
2734
    tentative_cc="cc -Xa"
2735
    host_makefile_frag="config/mh-cxux"
2736
    ;;
2737
  m88k-motorola-sysv*)
2738
    ;;
2739
  mips*-dec-ultrix*)
2740
    tentative_cc="cc -Wf,-XNg1000"
2741
    host_makefile_frag="config/mh-decstation"
2742
    ;;
2743
  mips*-nec-sysv4*)
2744
    # The C compiler on NEC MIPS SVR4 needs bigger tables.
2745
    tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2746
    host_makefile_frag="config/mh-necv4"
2747
    ;;
2748
  mips*-sgi-irix4*)
2749
    # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2750
    # environment.  Also bump switch table size so that cp-parse will
2751
    # compile.  Bump string length limit so linker builds.
2752
    tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2753
    ;;
2754
  mips*-*-sysv4*)
2755
    host_makefile_frag="config/mh-sysv4"
2756
    ;;
2757
  mips*-*-sysv*)
2758
    # This is for a MIPS running RISC/os 4.52C.
2759
 
2760
    # This is needed for GDB, but needs to be in the top-level make because
2761
    # if a library is compiled with the bsd headers and gets linked with the
2762
    # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2763
    # a different size).
2764
    # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2765
    # known except to select the sysv environment.  Could we use /proc instead?
2766
    # These "sysv environments" and "bsd environments" often end up being a pain.
2767
    #
2768
    # This is not part of CFLAGS because perhaps not all C compilers have this
2769
    # option.
2770
    tentative_cc="cc -systype sysv"
2771
    ;;
2772
  i370-ibm-opened*)
2773
    tentative_cc="c89"
2774
    ;;
2775
  i[3456789]86-*-sysv5*)
2776
    host_makefile_frag="config/mh-sysv5"
2777
    ;;
2778
  i[3456789]86-*-dgux*)
2779
    tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2780
    host_makefile_frag="config/mh-dgux386"
2781
    ;;
2782
  i[3456789]86-ncr-sysv4.3*)
2783
    # The MetaWare compiler will generate a copyright message unless you
2784
    # turn it off by adding the -Hnocopyr flag.
2785
    tentative_cc="cc -Hnocopyr"
2786
    ;;
2787
  i[3456789]86-ncr-sysv4*)
2788
    # for an NCR 3000 (i486/SVR4) system.
2789
    # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2790
    # This compiler not only emits obnoxious copyright messages every time
2791
    # you run it, but it chokes and dies on a whole bunch of GNU source
2792
    # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2793
    tentative_cc="/usr/ccs/ATT/cc"
2794
    host_makefile_frag="config/mh-ncr3000"
2795
    ;;
2796
  i[3456789]86-*-sco3.2v5*)
2797
    ;;
2798
  i[3456789]86-*-sco*)
2799
    # The native C compiler botches some simple uses of const.  Unfortunately,
2800
    # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2801
    tentative_cc="cc -Dconst="
2802
    host_makefile_frag="config/mh-sco"
2803
    ;;
2804
  i[3456789]86-*-udk*)
2805
    host_makefile_frag="config/mh-sysv5"
2806
    ;;
2807
  i[3456789]86-*-solaris2*)
2808
    host_makefile_frag="config/mh-sysv4"
2809
    ;;
2810
  i[3456789]86-*-msdosdjgpp*)
2811
    host_makefile_frag="config/mh-djgpp"
2812
    ;;
2813
  *-cygwin*)
2814
 
2815
echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2816
echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2817
echo a >cygwin-cat-check
2818
if test `cat cygwin-cat-check` == a ; then
2819
  rm cygwin-cat-check
2820
  echo "$as_me:$LINENO: result: yes" >&5
2821
echo "${ECHO_T}yes" >&6
2822
else
2823
  rm cygwin-cat-check
2824
  echo "$as_me:$LINENO: result: no" >&5
2825
echo "${ECHO_T}no" >&6
2826
  { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2827
  Please either mount the build directory in binary mode or run the following
2828
  commands before running any configure script:
2829
set -o igncr
2830
export SHELLOPTS
2831
  " >&5
2832
echo "$as_me: error: The cat command does not ignore carriage return characters.
2833
  Please either mount the build directory in binary mode or run the following
2834
  commands before running any configure script:
2835
set -o igncr
2836
export SHELLOPTS
2837
  " >&2;}
2838
   { (exit 1); exit 1; }; }
2839
fi
2840
 
2841
    host_makefile_frag="config/mh-cygwin"
2842
    ;;
2843
  *-mingw*)
2844
    host_makefile_frag="config/mh-mingw"
2845
    ;;
2846
  *-interix*)
2847
    host_makefile_frag="config/mh-interix"
2848
    ;;
2849
  vax-*-ultrix2*)
2850
    # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2851
    tentative_cc=gcc
2852
    ;;
2853
  *-*-solaris2*)
2854
    host_makefile_frag="config/mh-solaris"
2855
    ;;
2856
  m68k-sun-sunos*)
2857
    # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2858
    # without overflowing the jump tables (-J says to use a 32 bit table)
2859
    tentative_cc="cc -J"
2860
    ;;
2861
  hppa*-hp-hpux10*)
2862
    tentative_cc="cc -Wp,-H256000"
2863
    host_makefile_frag="config/mh-pa-hpux10"
2864
    ;;
2865
  hppa*-hp-hpux* | hppa*-*-hiux*)
2866
    tentative_cc="cc -Wp,-H256000"
2867
    host_makefile_frag="config/mh-pa"
2868
    ;;
2869
  hppa*-*)
2870
    host_makefile_frag="config/mh-pa"
2871
    ;;
2872
  *-hp-hpux* | *-*-hiux*)
2873
    tentative_cc="cc -Wp,-H256000"
2874
    ;;
2875
  rs6000-*-lynxos*)
2876
    # /bin/cc is less than useful for our purposes.  Always use GCC
2877
    tentative_cc="/usr/cygnus/progressive/bin/gcc"
2878
    host_makefile_frag="config/mh-lynxrs6k"
2879
    ;;
2880
  powerpc-*-darwin*)
2881
    host_makefile_frag="config/mh-ppc-darwin"
2882
    ;;
2883
  powerpc-*-aix*)
2884
    host_makefile_frag="config/mh-ppc-aix"
2885
    ;;
2886
  rs6000-*-aix*)
2887
    host_makefile_frag="config/mh-ppc-aix"
2888
    ;;
2889
  *-*-lynxos*)
2890
    # /bin/cc is less than useful for our purposes.  Always use GCC
2891
    tentative_cc="/bin/gcc"
2892
    ;;
2893
  *-*-sysv4*)
2894
    host_makefile_frag="config/mh-sysv4"
2895
    ;;
2896
  # This is placed last to prevent interfering with the cases above.
2897
  i[3456789]86-*-*)
2898
    # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2899
    host_makefile_frag="config/mh-x86omitfp"
2900
    ;;
2901
esac
2902
fi
2903
 
2904
# If we aren't going to be using gcc, see if we can extract a definition
2905
# of CC from the fragment.
2906
# Actually, use the 'pre-extracted' version above.
2907
if test -z "${CC}" && test "${build}" = "${host}" ; then
2908
  IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2909
  found=
2910
  for dir in $PATH; do
2911
    test -z "$dir" && dir=.
2912
    if test -f $dir/gcc; then
2913
      found=yes
2914
      break
2915
    fi
2916
  done
2917
  IFS="$save_ifs"
2918
  if test -z "${found}" && test -n "${tentative_cc}" ; then
2919
    CC=$tentative_cc
2920
  fi
2921
fi
2922
 
2923
if test "${build}" != "${host}" ; then
2924
  AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2925
  AS_FOR_BUILD=${AS_FOR_BUILD-as}
2926
  CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2927
  CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2928
  GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2929
  GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2930
  DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2931
  LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2932
  NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2933
  RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2934
  WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2935
  WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2936
else
2937
  AR_FOR_BUILD="\$(AR)"
2938
  AS_FOR_BUILD="\$(AS)"
2939
  CC_FOR_BUILD="\$(CC)"
2940
  CXX_FOR_BUILD="\$(CXX)"
2941
  GCJ_FOR_BUILD="\$(GCJ)"
2942
  GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2943
  DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2944
  LD_FOR_BUILD="\$(LD)"
2945
  NM_FOR_BUILD="\$(NM)"
2946
  RANLIB_FOR_BUILD="\$(RANLIB)"
2947
  WINDRES_FOR_BUILD="\$(WINDRES)"
2948
  WINDMC_FOR_BUILD="\$(WINDMC)"
2949
fi
2950
 
2951
ac_ext=c
2952
ac_cpp='$CPP $CPPFLAGS'
2953
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2954
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2955
ac_compiler_gnu=$ac_cv_c_compiler_gnu
2956
if test -n "$ac_tool_prefix"; then
2957
  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2958
set dummy ${ac_tool_prefix}gcc; ac_word=$2
2959
echo "$as_me:$LINENO: checking for $ac_word" >&5
2960
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2961
if test "${ac_cv_prog_CC+set}" = set; then
2962
  echo $ECHO_N "(cached) $ECHO_C" >&6
2963
else
2964
  if test -n "$CC"; then
2965
  ac_cv_prog_CC="$CC" # Let the user override the test.
2966
else
2967
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2968
for as_dir in $PATH
2969
do
2970
  IFS=$as_save_IFS
2971
  test -z "$as_dir" && as_dir=.
2972
  for ac_exec_ext in '' $ac_executable_extensions; do
2973
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2974
    ac_cv_prog_CC="${ac_tool_prefix}gcc"
2975
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2976
    break 2
2977
  fi
2978
done
2979
done
2980
 
2981
fi
2982
fi
2983
CC=$ac_cv_prog_CC
2984
if test -n "$CC"; then
2985
  echo "$as_me:$LINENO: result: $CC" >&5
2986
echo "${ECHO_T}$CC" >&6
2987
else
2988
  echo "$as_me:$LINENO: result: no" >&5
2989
echo "${ECHO_T}no" >&6
2990
fi
2991
 
2992
fi
2993
if test -z "$ac_cv_prog_CC"; then
2994
  ac_ct_CC=$CC
2995
  # Extract the first word of "gcc", so it can be a program name with args.
2996
set dummy gcc; ac_word=$2
2997
echo "$as_me:$LINENO: checking for $ac_word" >&5
2998
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2999
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3000
  echo $ECHO_N "(cached) $ECHO_C" >&6
3001
else
3002
  if test -n "$ac_ct_CC"; then
3003
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3004
else
3005
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3006
for as_dir in $PATH
3007
do
3008
  IFS=$as_save_IFS
3009
  test -z "$as_dir" && as_dir=.
3010
  for ac_exec_ext in '' $ac_executable_extensions; do
3011
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3012
    ac_cv_prog_ac_ct_CC="gcc"
3013
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3014
    break 2
3015
  fi
3016
done
3017
done
3018
 
3019
fi
3020
fi
3021
ac_ct_CC=$ac_cv_prog_ac_ct_CC
3022
if test -n "$ac_ct_CC"; then
3023
  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3024
echo "${ECHO_T}$ac_ct_CC" >&6
3025
else
3026
  echo "$as_me:$LINENO: result: no" >&5
3027
echo "${ECHO_T}no" >&6
3028
fi
3029
 
3030
  CC=$ac_ct_CC
3031
else
3032
  CC="$ac_cv_prog_CC"
3033
fi
3034
 
3035
if test -z "$CC"; then
3036
  if test -n "$ac_tool_prefix"; then
3037
  # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3038
set dummy ${ac_tool_prefix}cc; ac_word=$2
3039
echo "$as_me:$LINENO: checking for $ac_word" >&5
3040
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3041
if test "${ac_cv_prog_CC+set}" = set; then
3042
  echo $ECHO_N "(cached) $ECHO_C" >&6
3043
else
3044
  if test -n "$CC"; then
3045
  ac_cv_prog_CC="$CC" # Let the user override the test.
3046
else
3047
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3048
for as_dir in $PATH
3049
do
3050
  IFS=$as_save_IFS
3051
  test -z "$as_dir" && as_dir=.
3052
  for ac_exec_ext in '' $ac_executable_extensions; do
3053
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3054
    ac_cv_prog_CC="${ac_tool_prefix}cc"
3055
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3056
    break 2
3057
  fi
3058
done
3059
done
3060
 
3061
fi
3062
fi
3063
CC=$ac_cv_prog_CC
3064
if test -n "$CC"; then
3065
  echo "$as_me:$LINENO: result: $CC" >&5
3066
echo "${ECHO_T}$CC" >&6
3067
else
3068
  echo "$as_me:$LINENO: result: no" >&5
3069
echo "${ECHO_T}no" >&6
3070
fi
3071
 
3072
fi
3073
if test -z "$ac_cv_prog_CC"; then
3074
  ac_ct_CC=$CC
3075
  # Extract the first word of "cc", so it can be a program name with args.
3076
set dummy cc; ac_word=$2
3077
echo "$as_me:$LINENO: checking for $ac_word" >&5
3078
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3079
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3080
  echo $ECHO_N "(cached) $ECHO_C" >&6
3081
else
3082
  if test -n "$ac_ct_CC"; then
3083
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3084
else
3085
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3086
for as_dir in $PATH
3087
do
3088
  IFS=$as_save_IFS
3089
  test -z "$as_dir" && as_dir=.
3090
  for ac_exec_ext in '' $ac_executable_extensions; do
3091
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3092
    ac_cv_prog_ac_ct_CC="cc"
3093
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3094
    break 2
3095
  fi
3096
done
3097
done
3098
 
3099
fi
3100
fi
3101
ac_ct_CC=$ac_cv_prog_ac_ct_CC
3102
if test -n "$ac_ct_CC"; then
3103
  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3104
echo "${ECHO_T}$ac_ct_CC" >&6
3105
else
3106
  echo "$as_me:$LINENO: result: no" >&5
3107
echo "${ECHO_T}no" >&6
3108
fi
3109
 
3110
  CC=$ac_ct_CC
3111
else
3112
  CC="$ac_cv_prog_CC"
3113
fi
3114
 
3115
fi
3116
if test -z "$CC"; then
3117
  # Extract the first word of "cc", so it can be a program name with args.
3118
set dummy cc; ac_word=$2
3119
echo "$as_me:$LINENO: checking for $ac_word" >&5
3120
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3121
if test "${ac_cv_prog_CC+set}" = set; then
3122
  echo $ECHO_N "(cached) $ECHO_C" >&6
3123
else
3124
  if test -n "$CC"; then
3125
  ac_cv_prog_CC="$CC" # Let the user override the test.
3126
else
3127
  ac_prog_rejected=no
3128
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3129
for as_dir in $PATH
3130
do
3131
  IFS=$as_save_IFS
3132
  test -z "$as_dir" && as_dir=.
3133
  for ac_exec_ext in '' $ac_executable_extensions; do
3134
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3135
    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3136
       ac_prog_rejected=yes
3137
       continue
3138
     fi
3139
    ac_cv_prog_CC="cc"
3140
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3141
    break 2
3142
  fi
3143
done
3144
done
3145
 
3146
if test $ac_prog_rejected = yes; then
3147
  # We found a bogon in the path, so make sure we never use it.
3148
  set dummy $ac_cv_prog_CC
3149
  shift
3150
  if test $# != 0; then
3151
    # We chose a different compiler from the bogus one.
3152
    # However, it has the same basename, so the bogon will be chosen
3153
    # first if we set CC to just the basename; use the full file name.
3154
    shift
3155
    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3156
  fi
3157
fi
3158
fi
3159
fi
3160
CC=$ac_cv_prog_CC
3161
if test -n "$CC"; then
3162
  echo "$as_me:$LINENO: result: $CC" >&5
3163
echo "${ECHO_T}$CC" >&6
3164
else
3165
  echo "$as_me:$LINENO: result: no" >&5
3166
echo "${ECHO_T}no" >&6
3167
fi
3168
 
3169
fi
3170
if test -z "$CC"; then
3171
  if test -n "$ac_tool_prefix"; then
3172
  for ac_prog in cl
3173
  do
3174
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3175
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3176
echo "$as_me:$LINENO: checking for $ac_word" >&5
3177
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3178
if test "${ac_cv_prog_CC+set}" = set; then
3179
  echo $ECHO_N "(cached) $ECHO_C" >&6
3180
else
3181
  if test -n "$CC"; then
3182
  ac_cv_prog_CC="$CC" # Let the user override the test.
3183
else
3184
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3185
for as_dir in $PATH
3186
do
3187
  IFS=$as_save_IFS
3188
  test -z "$as_dir" && as_dir=.
3189
  for ac_exec_ext in '' $ac_executable_extensions; do
3190
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3191
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3192
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3193
    break 2
3194
  fi
3195
done
3196
done
3197
 
3198
fi
3199
fi
3200
CC=$ac_cv_prog_CC
3201
if test -n "$CC"; then
3202
  echo "$as_me:$LINENO: result: $CC" >&5
3203
echo "${ECHO_T}$CC" >&6
3204
else
3205
  echo "$as_me:$LINENO: result: no" >&5
3206
echo "${ECHO_T}no" >&6
3207
fi
3208
 
3209
    test -n "$CC" && break
3210
  done
3211
fi
3212
if test -z "$CC"; then
3213
  ac_ct_CC=$CC
3214
  for ac_prog in cl
3215
do
3216
  # Extract the first word of "$ac_prog", so it can be a program name with args.
3217
set dummy $ac_prog; ac_word=$2
3218
echo "$as_me:$LINENO: checking for $ac_word" >&5
3219
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3220
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3221
  echo $ECHO_N "(cached) $ECHO_C" >&6
3222
else
3223
  if test -n "$ac_ct_CC"; then
3224
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3225
else
3226
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3227
for as_dir in $PATH
3228
do
3229
  IFS=$as_save_IFS
3230
  test -z "$as_dir" && as_dir=.
3231
  for ac_exec_ext in '' $ac_executable_extensions; do
3232
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3233
    ac_cv_prog_ac_ct_CC="$ac_prog"
3234
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3235
    break 2
3236
  fi
3237
done
3238
done
3239
 
3240
fi
3241
fi
3242
ac_ct_CC=$ac_cv_prog_ac_ct_CC
3243
if test -n "$ac_ct_CC"; then
3244
  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3245
echo "${ECHO_T}$ac_ct_CC" >&6
3246
else
3247
  echo "$as_me:$LINENO: result: no" >&5
3248
echo "${ECHO_T}no" >&6
3249
fi
3250
 
3251
  test -n "$ac_ct_CC" && break
3252
done
3253
 
3254
  CC=$ac_ct_CC
3255
fi
3256
 
3257
fi
3258
 
3259
 
3260
test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3261
echo "$as_me: error: in \`$ac_pwd':" >&2;}
3262
{ { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3263
See \`config.log' for more details." >&5
3264
echo "$as_me: error: no acceptable C compiler found in \$PATH
3265
See \`config.log' for more details." >&2;}
3266
   { (exit 1); exit 1; }; }; }
3267
 
3268
# Provide some information about the compiler.
3269
echo "$as_me:$LINENO:" \
3270
     "checking for C compiler version" >&5
3271
ac_compiler=`set X $ac_compile; echo $2`
3272
{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version &5\"") >&5
3273
  (eval $ac_compiler --version &5) 2>&5
3274
  ac_status=$?
3275
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3276
  (exit $ac_status); }
3277
{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v &5\"") >&5
3278
  (eval $ac_compiler -v &5) 2>&5
3279
  ac_status=$?
3280
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3281
  (exit $ac_status); }
3282
{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V &5\"") >&5
3283
  (eval $ac_compiler -V &5) 2>&5
3284
  ac_status=$?
3285
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3286
  (exit $ac_status); }
3287
 
3288
cat >conftest.$ac_ext <<_ACEOF
3289
/* confdefs.h.  */
3290
_ACEOF
3291
cat confdefs.h >>conftest.$ac_ext
3292
cat >>conftest.$ac_ext <<_ACEOF
3293
/* end confdefs.h.  */
3294
 
3295
int
3296
main ()
3297
{
3298
 
3299
  ;
3300
  return 0;
3301
}
3302
_ACEOF
3303
ac_clean_files_save=$ac_clean_files
3304
ac_clean_files="$ac_clean_files a.out a.exe b.out"
3305
# Try to create an executable without -o first, disregard a.out.
3306
# It will help us diagnose broken compilers, and finding out an intuition
3307
# of exeext.
3308
echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3309
echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3310
ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3311
if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3312
  (eval $ac_link_default) 2>&5
3313
  ac_status=$?
3314
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3315
  (exit $ac_status); }; then
3316
  # Find the output, starting from the most likely.  This scheme is
3317
# not robust to junk in `.', hence go to wildcards (a.*) only as a last
3318
# resort.
3319
 
3320
# Be careful to initialize this variable, since it used to be cached.
3321
# Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3322
ac_cv_exeext=
3323
# b.out is created by i960 compilers.
3324
for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3325
do
3326
  test -f "$ac_file" || continue
3327
  case $ac_file in
3328
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3329
        ;;
3330
    conftest.$ac_ext )
3331
        # This is the source file.
3332
        ;;
3333
    [ab].out )
3334
        # We found the default executable, but exeext='' is most
3335
        # certainly right.
3336
        break;;
3337
    *.* )
3338
        ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3339
        # FIXME: I believe we export ac_cv_exeext for Libtool,
3340
        # but it would be cool to find out if it's true.  Does anybody
3341
        # maintain Libtool? --akim.
3342
        export ac_cv_exeext
3343
        break;;
3344
    * )
3345
        break;;
3346
  esac
3347
done
3348
else
3349
  echo "$as_me: failed program was:" >&5
3350
sed 's/^/| /' conftest.$ac_ext >&5
3351
 
3352
{ { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3353
echo "$as_me: error: in \`$ac_pwd':" >&2;}
3354
{ { echo "$as_me:$LINENO: error: C compiler cannot create executables
3355
See \`config.log' for more details." >&5
3356
echo "$as_me: error: C compiler cannot create executables
3357
See \`config.log' for more details." >&2;}
3358
   { (exit 77); exit 77; }; }; }
3359
fi
3360
 
3361
ac_exeext=$ac_cv_exeext
3362
echo "$as_me:$LINENO: result: $ac_file" >&5
3363
echo "${ECHO_T}$ac_file" >&6
3364
 
3365
# Check the compiler produces executables we can run.  If not, either
3366
# the compiler is broken, or we cross compile.
3367
echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3368
echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3369
# FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3370
# If not cross compiling, check that we can run a simple program.
3371
if test "$cross_compiling" != yes; then
3372
  if { ac_try='./$ac_file'
3373
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3374
  (eval $ac_try) 2>&5
3375
  ac_status=$?
3376
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3377
  (exit $ac_status); }; }; then
3378
    cross_compiling=no
3379
  else
3380
    if test "$cross_compiling" = maybe; then
3381
        cross_compiling=yes
3382
    else
3383
        { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3384
echo "$as_me: error: in \`$ac_pwd':" >&2;}
3385
{ { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3386
If you meant to cross compile, use \`--host'.
3387
See \`config.log' for more details." >&5
3388
echo "$as_me: error: cannot run C compiled programs.
3389
If you meant to cross compile, use \`--host'.
3390
See \`config.log' for more details." >&2;}
3391
   { (exit 1); exit 1; }; }; }
3392
    fi
3393
  fi
3394
fi
3395
echo "$as_me:$LINENO: result: yes" >&5
3396
echo "${ECHO_T}yes" >&6
3397
 
3398
rm -f a.out a.exe conftest$ac_cv_exeext b.out
3399
ac_clean_files=$ac_clean_files_save
3400
# Check the compiler produces executables we can run.  If not, either
3401
# the compiler is broken, or we cross compile.
3402
echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3403
echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3404
echo "$as_me:$LINENO: result: $cross_compiling" >&5
3405
echo "${ECHO_T}$cross_compiling" >&6
3406
 
3407
echo "$as_me:$LINENO: checking for suffix of executables" >&5
3408
echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3409
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3410
  (eval $ac_link) 2>&5
3411
  ac_status=$?
3412
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3413
  (exit $ac_status); }; then
3414
  # If both `conftest.exe' and `conftest' are `present' (well, observable)
3415
# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3416
# work properly (i.e., refer to `conftest.exe'), while it won't with
3417
# `rm'.
3418
for ac_file in conftest.exe conftest conftest.*; do
3419
  test -f "$ac_file" || continue
3420
  case $ac_file in
3421
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3422
    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3423
          export ac_cv_exeext
3424
          break;;
3425
    * ) break;;
3426
  esac
3427
done
3428
else
3429
  { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3430
echo "$as_me: error: in \`$ac_pwd':" >&2;}
3431
{ { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3432
See \`config.log' for more details." >&5
3433
echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3434
See \`config.log' for more details." >&2;}
3435
   { (exit 1); exit 1; }; }; }
3436
fi
3437
 
3438
rm -f conftest$ac_cv_exeext
3439
echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3440
echo "${ECHO_T}$ac_cv_exeext" >&6
3441
 
3442
rm -f conftest.$ac_ext
3443
EXEEXT=$ac_cv_exeext
3444
ac_exeext=$EXEEXT
3445
echo "$as_me:$LINENO: checking for suffix of object files" >&5
3446
echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3447
if test "${ac_cv_objext+set}" = set; then
3448
  echo $ECHO_N "(cached) $ECHO_C" >&6
3449
else
3450
  cat >conftest.$ac_ext <<_ACEOF
3451
/* confdefs.h.  */
3452
_ACEOF
3453
cat confdefs.h >>conftest.$ac_ext
3454
cat >>conftest.$ac_ext <<_ACEOF
3455
/* end confdefs.h.  */
3456
 
3457
int
3458
main ()
3459
{
3460
 
3461
  ;
3462
  return 0;
3463
}
3464
_ACEOF
3465
rm -f conftest.o conftest.obj
3466
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3467
  (eval $ac_compile) 2>&5
3468
  ac_status=$?
3469
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3470
  (exit $ac_status); }; then
3471
  for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3472
  case $ac_file in
3473
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3474
    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3475
       break;;
3476
  esac
3477
done
3478
else
3479
  echo "$as_me: failed program was:" >&5
3480
sed 's/^/| /' conftest.$ac_ext >&5
3481
 
3482
{ { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3483
echo "$as_me: error: in \`$ac_pwd':" >&2;}
3484
{ { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3485
See \`config.log' for more details." >&5
3486
echo "$as_me: error: cannot compute suffix of object files: cannot compile
3487
See \`config.log' for more details." >&2;}
3488
   { (exit 1); exit 1; }; }; }
3489
fi
3490
 
3491
rm -f conftest.$ac_cv_objext conftest.$ac_ext
3492
fi
3493
echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3494
echo "${ECHO_T}$ac_cv_objext" >&6
3495
OBJEXT=$ac_cv_objext
3496
ac_objext=$OBJEXT
3497
echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3498
echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3499
if test "${ac_cv_c_compiler_gnu+set}" = set; then
3500
  echo $ECHO_N "(cached) $ECHO_C" >&6
3501
else
3502
  cat >conftest.$ac_ext <<_ACEOF
3503
/* confdefs.h.  */
3504
_ACEOF
3505
cat confdefs.h >>conftest.$ac_ext
3506
cat >>conftest.$ac_ext <<_ACEOF
3507
/* end confdefs.h.  */
3508
 
3509
int
3510
main ()
3511
{
3512
#ifndef __GNUC__
3513
       choke me
3514
#endif
3515
 
3516
  ;
3517
  return 0;
3518
}
3519
_ACEOF
3520
rm -f conftest.$ac_objext
3521
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3522
  (eval $ac_compile) 2>conftest.er1
3523
  ac_status=$?
3524
  grep -v '^ *+' conftest.er1 >conftest.err
3525
  rm -f conftest.er1
3526
  cat conftest.err >&5
3527
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3528
  (exit $ac_status); } &&
3529
         { ac_try='test -z "$ac_c_werror_flag"
3530
                         || test ! -s conftest.err'
3531
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3532
  (eval $ac_try) 2>&5
3533
  ac_status=$?
3534
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3535
  (exit $ac_status); }; } &&
3536
         { ac_try='test -s conftest.$ac_objext'
3537
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3538
  (eval $ac_try) 2>&5
3539
  ac_status=$?
3540
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3541
  (exit $ac_status); }; }; then
3542
  ac_compiler_gnu=yes
3543
else
3544
  echo "$as_me: failed program was:" >&5
3545
sed 's/^/| /' conftest.$ac_ext >&5
3546
 
3547
ac_compiler_gnu=no
3548
fi
3549
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3550
ac_cv_c_compiler_gnu=$ac_compiler_gnu
3551
 
3552
fi
3553
echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3554
echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3555
GCC=`test $ac_compiler_gnu = yes && echo yes`
3556
ac_test_CFLAGS=${CFLAGS+set}
3557
ac_save_CFLAGS=$CFLAGS
3558
CFLAGS="-g"
3559
echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3560
echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3561
if test "${ac_cv_prog_cc_g+set}" = set; then
3562
  echo $ECHO_N "(cached) $ECHO_C" >&6
3563
else
3564
  cat >conftest.$ac_ext <<_ACEOF
3565
/* confdefs.h.  */
3566
_ACEOF
3567
cat confdefs.h >>conftest.$ac_ext
3568
cat >>conftest.$ac_ext <<_ACEOF
3569
/* end confdefs.h.  */
3570
 
3571
int
3572
main ()
3573
{
3574
 
3575
  ;
3576
  return 0;
3577
}
3578
_ACEOF
3579
rm -f conftest.$ac_objext
3580
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3581
  (eval $ac_compile) 2>conftest.er1
3582
  ac_status=$?
3583
  grep -v '^ *+' conftest.er1 >conftest.err
3584
  rm -f conftest.er1
3585
  cat conftest.err >&5
3586
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3587
  (exit $ac_status); } &&
3588
         { ac_try='test -z "$ac_c_werror_flag"
3589
                         || test ! -s conftest.err'
3590
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3591
  (eval $ac_try) 2>&5
3592
  ac_status=$?
3593
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3594
  (exit $ac_status); }; } &&
3595
         { ac_try='test -s conftest.$ac_objext'
3596
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3597
  (eval $ac_try) 2>&5
3598
  ac_status=$?
3599
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3600
  (exit $ac_status); }; }; then
3601
  ac_cv_prog_cc_g=yes
3602
else
3603
  echo "$as_me: failed program was:" >&5
3604
sed 's/^/| /' conftest.$ac_ext >&5
3605
 
3606
ac_cv_prog_cc_g=no
3607
fi
3608
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3609
fi
3610
echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3611
echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3612
if test "$ac_test_CFLAGS" = set; then
3613
  CFLAGS=$ac_save_CFLAGS
3614
elif test $ac_cv_prog_cc_g = yes; then
3615
  if test "$GCC" = yes; then
3616
    CFLAGS="-g -O2"
3617
  else
3618
    CFLAGS="-g"
3619
  fi
3620
else
3621
  if test "$GCC" = yes; then
3622
    CFLAGS="-O2"
3623
  else
3624
    CFLAGS=
3625
  fi
3626
fi
3627
echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3628
echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3629
if test "${ac_cv_prog_cc_stdc+set}" = set; then
3630
  echo $ECHO_N "(cached) $ECHO_C" >&6
3631
else
3632
  ac_cv_prog_cc_stdc=no
3633
ac_save_CC=$CC
3634
cat >conftest.$ac_ext <<_ACEOF
3635
/* confdefs.h.  */
3636
_ACEOF
3637
cat confdefs.h >>conftest.$ac_ext
3638
cat >>conftest.$ac_ext <<_ACEOF
3639
/* end confdefs.h.  */
3640
#include 
3641
#include 
3642
#include 
3643
#include 
3644
/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3645
struct buf { int x; };
3646
FILE * (*rcsopen) (struct buf *, struct stat *, int);
3647
static char *e (p, i)
3648
     char **p;
3649
     int i;
3650
{
3651
  return p[i];
3652
}
3653
static char *f (char * (*g) (char **, int), char **p, ...)
3654
{
3655
  char *s;
3656
  va_list v;
3657
  va_start (v,p);
3658
  s = g (p, va_arg (v,int));
3659
  va_end (v);
3660
  return s;
3661
}
3662
 
3663
/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3664
   function prototypes and stuff, but not '\xHH' hex character constants.
3665
   These don't provoke an error unfortunately, instead are silently treated
3666
   as 'x'.  The following induces an error, until -std1 is added to get
3667
   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3668
   array size at least.  It's necessary to write '\x00'==0 to get something
3669
   that's true only with -std1.  */
3670
int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3671
 
3672
int test (int i, double x);
3673
struct s1 {int (*f) (int a);};
3674
struct s2 {int (*f) (double a);};
3675
int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3676
int argc;
3677
char **argv;
3678
int
3679
main ()
3680
{
3681
return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3682
  ;
3683
  return 0;
3684
}
3685
_ACEOF
3686
# Don't try gcc -ansi; that turns off useful extensions and
3687
# breaks some systems' header files.
3688
# AIX                   -qlanglvl=ansi
3689
# Ultrix and OSF/1      -std1
3690
# HP-UX 10.20 and later -Ae
3691
# HP-UX older versions  -Aa -D_HPUX_SOURCE
3692
# SVR4                  -Xc -D__EXTENSIONS__
3693
for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3694
do
3695
  CC="$ac_save_CC $ac_arg"
3696
  rm -f conftest.$ac_objext
3697
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3698
  (eval $ac_compile) 2>conftest.er1
3699
  ac_status=$?
3700
  grep -v '^ *+' conftest.er1 >conftest.err
3701
  rm -f conftest.er1
3702
  cat conftest.err >&5
3703
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3704
  (exit $ac_status); } &&
3705
         { ac_try='test -z "$ac_c_werror_flag"
3706
                         || test ! -s conftest.err'
3707
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3708
  (eval $ac_try) 2>&5
3709
  ac_status=$?
3710
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3711
  (exit $ac_status); }; } &&
3712
         { ac_try='test -s conftest.$ac_objext'
3713
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3714
  (eval $ac_try) 2>&5
3715
  ac_status=$?
3716
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3717
  (exit $ac_status); }; }; then
3718
  ac_cv_prog_cc_stdc=$ac_arg
3719
break
3720
else
3721
  echo "$as_me: failed program was:" >&5
3722
sed 's/^/| /' conftest.$ac_ext >&5
3723
 
3724
fi
3725
rm -f conftest.err conftest.$ac_objext
3726
done
3727
rm -f conftest.$ac_ext conftest.$ac_objext
3728
CC=$ac_save_CC
3729
 
3730
fi
3731
 
3732
case "x$ac_cv_prog_cc_stdc" in
3733
  x|xno)
3734
    echo "$as_me:$LINENO: result: none needed" >&5
3735
echo "${ECHO_T}none needed" >&6 ;;
3736
  *)
3737
    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3738
echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3739
    CC="$CC $ac_cv_prog_cc_stdc" ;;
3740
esac
3741
 
3742
# Some people use a C++ compiler to compile C.  Since we use `exit',
3743
# in C++ we need to declare it.  In case someone uses the same compiler
3744
# for both compiling C and C++ we need to have the C++ compiler decide
3745
# the declaration of exit, since it's the most demanding environment.
3746
cat >conftest.$ac_ext <<_ACEOF
3747
#ifndef __cplusplus
3748
  choke me
3749
#endif
3750
_ACEOF
3751
rm -f conftest.$ac_objext
3752
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3753
  (eval $ac_compile) 2>conftest.er1
3754
  ac_status=$?
3755
  grep -v '^ *+' conftest.er1 >conftest.err
3756
  rm -f conftest.er1
3757
  cat conftest.err >&5
3758
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3759
  (exit $ac_status); } &&
3760
         { ac_try='test -z "$ac_c_werror_flag"
3761
                         || test ! -s conftest.err'
3762
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3763
  (eval $ac_try) 2>&5
3764
  ac_status=$?
3765
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3766
  (exit $ac_status); }; } &&
3767
         { ac_try='test -s conftest.$ac_objext'
3768
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3769
  (eval $ac_try) 2>&5
3770
  ac_status=$?
3771
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3772
  (exit $ac_status); }; }; then
3773
  for ac_declaration in \
3774
   '' \
3775
   'extern "C" void std::exit (int) throw (); using std::exit;' \
3776
   'extern "C" void std::exit (int); using std::exit;' \
3777
   'extern "C" void exit (int) throw ();' \
3778
   'extern "C" void exit (int);' \
3779
   'void exit (int);'
3780
do
3781
  cat >conftest.$ac_ext <<_ACEOF
3782
/* confdefs.h.  */
3783
_ACEOF
3784
cat confdefs.h >>conftest.$ac_ext
3785
cat >>conftest.$ac_ext <<_ACEOF
3786
/* end confdefs.h.  */
3787
$ac_declaration
3788
#include 
3789
int
3790
main ()
3791
{
3792
exit (42);
3793
  ;
3794
  return 0;
3795
}
3796
_ACEOF
3797
rm -f conftest.$ac_objext
3798
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3799
  (eval $ac_compile) 2>conftest.er1
3800
  ac_status=$?
3801
  grep -v '^ *+' conftest.er1 >conftest.err
3802
  rm -f conftest.er1
3803
  cat conftest.err >&5
3804
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3805
  (exit $ac_status); } &&
3806
         { ac_try='test -z "$ac_c_werror_flag"
3807
                         || test ! -s conftest.err'
3808
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3809
  (eval $ac_try) 2>&5
3810
  ac_status=$?
3811
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3812
  (exit $ac_status); }; } &&
3813
         { ac_try='test -s conftest.$ac_objext'
3814
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3815
  (eval $ac_try) 2>&5
3816
  ac_status=$?
3817
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3818
  (exit $ac_status); }; }; then
3819
  :
3820
else
3821
  echo "$as_me: failed program was:" >&5
3822
sed 's/^/| /' conftest.$ac_ext >&5
3823
 
3824
continue
3825
fi
3826
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3827
  cat >conftest.$ac_ext <<_ACEOF
3828
/* confdefs.h.  */
3829
_ACEOF
3830
cat confdefs.h >>conftest.$ac_ext
3831
cat >>conftest.$ac_ext <<_ACEOF
3832
/* end confdefs.h.  */
3833
$ac_declaration
3834
int
3835
main ()
3836
{
3837
exit (42);
3838
  ;
3839
  return 0;
3840
}
3841
_ACEOF
3842
rm -f conftest.$ac_objext
3843
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3844
  (eval $ac_compile) 2>conftest.er1
3845
  ac_status=$?
3846
  grep -v '^ *+' conftest.er1 >conftest.err
3847
  rm -f conftest.er1
3848
  cat conftest.err >&5
3849
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3850
  (exit $ac_status); } &&
3851
         { ac_try='test -z "$ac_c_werror_flag"
3852
                         || test ! -s conftest.err'
3853
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3854
  (eval $ac_try) 2>&5
3855
  ac_status=$?
3856
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3857
  (exit $ac_status); }; } &&
3858
         { ac_try='test -s conftest.$ac_objext'
3859
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3860
  (eval $ac_try) 2>&5
3861
  ac_status=$?
3862
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3863
  (exit $ac_status); }; }; then
3864
  break
3865
else
3866
  echo "$as_me: failed program was:" >&5
3867
sed 's/^/| /' conftest.$ac_ext >&5
3868
 
3869
fi
3870
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3871
done
3872
rm -f conftest*
3873
if test -n "$ac_declaration"; then
3874
  echo '#ifdef __cplusplus' >>confdefs.h
3875
  echo $ac_declaration      >>confdefs.h
3876
  echo '#endif'             >>confdefs.h
3877
fi
3878
 
3879
else
3880
  echo "$as_me: failed program was:" >&5
3881
sed 's/^/| /' conftest.$ac_ext >&5
3882
 
3883
fi
3884
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3885
ac_ext=c
3886
ac_cpp='$CPP $CPPFLAGS'
3887
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3888
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3889
ac_compiler_gnu=$ac_cv_c_compiler_gnu
3890
 
3891
ac_ext=cc
3892
ac_cpp='$CXXCPP $CPPFLAGS'
3893
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3894
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3895
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3896
if test -n "$ac_tool_prefix"; then
3897
  for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3898
  do
3899
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3900
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3901
echo "$as_me:$LINENO: checking for $ac_word" >&5
3902
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3903
if test "${ac_cv_prog_CXX+set}" = set; then
3904
  echo $ECHO_N "(cached) $ECHO_C" >&6
3905
else
3906
  if test -n "$CXX"; then
3907
  ac_cv_prog_CXX="$CXX" # Let the user override the test.
3908
else
3909
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3910
for as_dir in $PATH
3911
do
3912
  IFS=$as_save_IFS
3913
  test -z "$as_dir" && as_dir=.
3914
  for ac_exec_ext in '' $ac_executable_extensions; do
3915
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3916
    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3917
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3918
    break 2
3919
  fi
3920
done
3921
done
3922
 
3923
fi
3924
fi
3925
CXX=$ac_cv_prog_CXX
3926
if test -n "$CXX"; then
3927
  echo "$as_me:$LINENO: result: $CXX" >&5
3928
echo "${ECHO_T}$CXX" >&6
3929
else
3930
  echo "$as_me:$LINENO: result: no" >&5
3931
echo "${ECHO_T}no" >&6
3932
fi
3933
 
3934
    test -n "$CXX" && break
3935
  done
3936
fi
3937
if test -z "$CXX"; then
3938
  ac_ct_CXX=$CXX
3939
  for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3940
do
3941
  # Extract the first word of "$ac_prog", so it can be a program name with args.
3942
set dummy $ac_prog; ac_word=$2
3943
echo "$as_me:$LINENO: checking for $ac_word" >&5
3944
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3945
if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3946
  echo $ECHO_N "(cached) $ECHO_C" >&6
3947
else
3948
  if test -n "$ac_ct_CXX"; then
3949
  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3950
else
3951
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3952
for as_dir in $PATH
3953
do
3954
  IFS=$as_save_IFS
3955
  test -z "$as_dir" && as_dir=.
3956
  for ac_exec_ext in '' $ac_executable_extensions; do
3957
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3958
    ac_cv_prog_ac_ct_CXX="$ac_prog"
3959
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3960
    break 2
3961
  fi
3962
done
3963
done
3964
 
3965
fi
3966
fi
3967
ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3968
if test -n "$ac_ct_CXX"; then
3969
  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3970
echo "${ECHO_T}$ac_ct_CXX" >&6
3971
else
3972
  echo "$as_me:$LINENO: result: no" >&5
3973
echo "${ECHO_T}no" >&6
3974
fi
3975
 
3976
  test -n "$ac_ct_CXX" && break
3977
done
3978
test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3979
 
3980
  CXX=$ac_ct_CXX
3981
fi
3982
 
3983
 
3984
# Provide some information about the compiler.
3985
echo "$as_me:$LINENO:" \
3986
     "checking for C++ compiler version" >&5
3987
ac_compiler=`set X $ac_compile; echo $2`
3988
{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version &5\"") >&5
3989
  (eval $ac_compiler --version &5) 2>&5
3990
  ac_status=$?
3991
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3992
  (exit $ac_status); }
3993
{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v &5\"") >&5
3994
  (eval $ac_compiler -v &5) 2>&5
3995
  ac_status=$?
3996
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3997
  (exit $ac_status); }
3998
{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V &5\"") >&5
3999
  (eval $ac_compiler -V &5) 2>&5
4000
  ac_status=$?
4001
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4002
  (exit $ac_status); }
4003
 
4004
echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4005
echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4006
if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4007
  echo $ECHO_N "(cached) $ECHO_C" >&6
4008
else
4009
  cat >conftest.$ac_ext <<_ACEOF
4010
/* confdefs.h.  */
4011
_ACEOF
4012
cat confdefs.h >>conftest.$ac_ext
4013
cat >>conftest.$ac_ext <<_ACEOF
4014
/* end confdefs.h.  */
4015
 
4016
int
4017
main ()
4018
{
4019
#ifndef __GNUC__
4020
       choke me
4021
#endif
4022
 
4023
  ;
4024
  return 0;
4025
}
4026
_ACEOF
4027
rm -f conftest.$ac_objext
4028
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4029
  (eval $ac_compile) 2>conftest.er1
4030
  ac_status=$?
4031
  grep -v '^ *+' conftest.er1 >conftest.err
4032
  rm -f conftest.er1
4033
  cat conftest.err >&5
4034
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4035
  (exit $ac_status); } &&
4036
         { ac_try='test -z "$ac_cxx_werror_flag"
4037
                         || test ! -s conftest.err'
4038
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4039
  (eval $ac_try) 2>&5
4040
  ac_status=$?
4041
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4042
  (exit $ac_status); }; } &&
4043
         { ac_try='test -s conftest.$ac_objext'
4044
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4045
  (eval $ac_try) 2>&5
4046
  ac_status=$?
4047
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4048
  (exit $ac_status); }; }; then
4049
  ac_compiler_gnu=yes
4050
else
4051
  echo "$as_me: failed program was:" >&5
4052
sed 's/^/| /' conftest.$ac_ext >&5
4053
 
4054
ac_compiler_gnu=no
4055
fi
4056
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4057
ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4058
 
4059
fi
4060
echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4061
echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4062
GXX=`test $ac_compiler_gnu = yes && echo yes`
4063
ac_test_CXXFLAGS=${CXXFLAGS+set}
4064
ac_save_CXXFLAGS=$CXXFLAGS
4065
CXXFLAGS="-g"
4066
echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4067
echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4068
if test "${ac_cv_prog_cxx_g+set}" = set; then
4069
  echo $ECHO_N "(cached) $ECHO_C" >&6
4070
else
4071
  cat >conftest.$ac_ext <<_ACEOF
4072
/* confdefs.h.  */
4073
_ACEOF
4074
cat confdefs.h >>conftest.$ac_ext
4075
cat >>conftest.$ac_ext <<_ACEOF
4076
/* end confdefs.h.  */
4077
 
4078
int
4079
main ()
4080
{
4081
 
4082
  ;
4083
  return 0;
4084
}
4085
_ACEOF
4086
rm -f conftest.$ac_objext
4087
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4088
  (eval $ac_compile) 2>conftest.er1
4089
  ac_status=$?
4090
  grep -v '^ *+' conftest.er1 >conftest.err
4091
  rm -f conftest.er1
4092
  cat conftest.err >&5
4093
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4094
  (exit $ac_status); } &&
4095
         { ac_try='test -z "$ac_cxx_werror_flag"
4096
                         || test ! -s conftest.err'
4097
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4098
  (eval $ac_try) 2>&5
4099
  ac_status=$?
4100
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4101
  (exit $ac_status); }; } &&
4102
         { ac_try='test -s conftest.$ac_objext'
4103
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4104
  (eval $ac_try) 2>&5
4105
  ac_status=$?
4106
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4107
  (exit $ac_status); }; }; then
4108
  ac_cv_prog_cxx_g=yes
4109
else
4110
  echo "$as_me: failed program was:" >&5
4111
sed 's/^/| /' conftest.$ac_ext >&5
4112
 
4113
ac_cv_prog_cxx_g=no
4114
fi
4115
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4116
fi
4117
echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4118
echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4119
if test "$ac_test_CXXFLAGS" = set; then
4120
  CXXFLAGS=$ac_save_CXXFLAGS
4121
elif test $ac_cv_prog_cxx_g = yes; then
4122
  if test "$GXX" = yes; then
4123
    CXXFLAGS="-g -O2"
4124
  else
4125
    CXXFLAGS="-g"
4126
  fi
4127
else
4128
  if test "$GXX" = yes; then
4129
    CXXFLAGS="-O2"
4130
  else
4131
    CXXFLAGS=
4132
  fi
4133
fi
4134
for ac_declaration in \
4135
   '' \
4136
   'extern "C" void std::exit (int) throw (); using std::exit;' \
4137
   'extern "C" void std::exit (int); using std::exit;' \
4138
   'extern "C" void exit (int) throw ();' \
4139
   'extern "C" void exit (int);' \
4140
   'void exit (int);'
4141
do
4142
  cat >conftest.$ac_ext <<_ACEOF
4143
/* confdefs.h.  */
4144
_ACEOF
4145
cat confdefs.h >>conftest.$ac_ext
4146
cat >>conftest.$ac_ext <<_ACEOF
4147
/* end confdefs.h.  */
4148
$ac_declaration
4149
#include 
4150
int
4151
main ()
4152
{
4153
exit (42);
4154
  ;
4155
  return 0;
4156
}
4157
_ACEOF
4158
rm -f conftest.$ac_objext
4159
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4160
  (eval $ac_compile) 2>conftest.er1
4161
  ac_status=$?
4162
  grep -v '^ *+' conftest.er1 >conftest.err
4163
  rm -f conftest.er1
4164
  cat conftest.err >&5
4165
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4166
  (exit $ac_status); } &&
4167
         { ac_try='test -z "$ac_cxx_werror_flag"
4168
                         || test ! -s conftest.err'
4169
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4170
  (eval $ac_try) 2>&5
4171
  ac_status=$?
4172
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4173
  (exit $ac_status); }; } &&
4174
         { ac_try='test -s conftest.$ac_objext'
4175
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4176
  (eval $ac_try) 2>&5
4177
  ac_status=$?
4178
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4179
  (exit $ac_status); }; }; then
4180
  :
4181
else
4182
  echo "$as_me: failed program was:" >&5
4183
sed 's/^/| /' conftest.$ac_ext >&5
4184
 
4185
continue
4186
fi
4187
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4188
  cat >conftest.$ac_ext <<_ACEOF
4189
/* confdefs.h.  */
4190
_ACEOF
4191
cat confdefs.h >>conftest.$ac_ext
4192
cat >>conftest.$ac_ext <<_ACEOF
4193
/* end confdefs.h.  */
4194
$ac_declaration
4195
int
4196
main ()
4197
{
4198
exit (42);
4199
  ;
4200
  return 0;
4201
}
4202
_ACEOF
4203
rm -f conftest.$ac_objext
4204
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4205
  (eval $ac_compile) 2>conftest.er1
4206
  ac_status=$?
4207
  grep -v '^ *+' conftest.er1 >conftest.err
4208
  rm -f conftest.er1
4209
  cat conftest.err >&5
4210
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4211
  (exit $ac_status); } &&
4212
         { ac_try='test -z "$ac_cxx_werror_flag"
4213
                         || test ! -s conftest.err'
4214
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4215
  (eval $ac_try) 2>&5
4216
  ac_status=$?
4217
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4218
  (exit $ac_status); }; } &&
4219
         { ac_try='test -s conftest.$ac_objext'
4220
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4221
  (eval $ac_try) 2>&5
4222
  ac_status=$?
4223
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4224
  (exit $ac_status); }; }; then
4225
  break
4226
else
4227
  echo "$as_me: failed program was:" >&5
4228
sed 's/^/| /' conftest.$ac_ext >&5
4229
 
4230
fi
4231
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4232
done
4233
rm -f conftest*
4234
if test -n "$ac_declaration"; then
4235
  echo '#ifdef __cplusplus' >>confdefs.h
4236
  echo $ac_declaration      >>confdefs.h
4237
  echo '#endif'             >>confdefs.h
4238
fi
4239
 
4240
ac_ext=c
4241
ac_cpp='$CPP $CPPFLAGS'
4242
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4243
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4244
ac_compiler_gnu=$ac_cv_c_compiler_gnu
4245
 
4246
 
4247
# We must set the default linker to the linker used by gcc for the correct
4248
# operation of libtool.  If LD is not defined and we are using gcc, try to
4249
# set the LD default to the ld used by gcc.
4250
if test -z "$LD"; then
4251
  if test "$GCC" = yes; then
4252
    case $build in
4253
    *-*-mingw*)
4254
      gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4255
    *)
4256
      gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4257
    esac
4258
    case $gcc_prog_ld in
4259
    # Accept absolute paths.
4260
    [\\/]* | [A-Za-z]:[\\/]*)
4261
      LD="$gcc_prog_ld" ;;
4262
    esac
4263
  fi
4264
fi
4265
 
4266
 
4267
 
4268
 
4269
if test -n "$ac_tool_prefix"; then
4270
  # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4271
set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4272
echo "$as_me:$LINENO: checking for $ac_word" >&5
4273
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4274
if test "${ac_cv_prog_GNATBIND+set}" = set; then
4275
  echo $ECHO_N "(cached) $ECHO_C" >&6
4276
else
4277
  if test -n "$GNATBIND"; then
4278
  ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4279
else
4280
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4281
for as_dir in $PATH
4282
do
4283
  IFS=$as_save_IFS
4284
  test -z "$as_dir" && as_dir=.
4285
  for ac_exec_ext in '' $ac_executable_extensions; do
4286
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4287
    ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4288
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4289
    break 2
4290
  fi
4291
done
4292
done
4293
 
4294
fi
4295
fi
4296
GNATBIND=$ac_cv_prog_GNATBIND
4297
if test -n "$GNATBIND"; then
4298
  echo "$as_me:$LINENO: result: $GNATBIND" >&5
4299
echo "${ECHO_T}$GNATBIND" >&6
4300
else
4301
  echo "$as_me:$LINENO: result: no" >&5
4302
echo "${ECHO_T}no" >&6
4303
fi
4304
 
4305
fi
4306
if test -z "$ac_cv_prog_GNATBIND"; then
4307
  ac_ct_GNATBIND=$GNATBIND
4308
  # Extract the first word of "gnatbind", so it can be a program name with args.
4309
set dummy gnatbind; ac_word=$2
4310
echo "$as_me:$LINENO: checking for $ac_word" >&5
4311
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4312
if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4313
  echo $ECHO_N "(cached) $ECHO_C" >&6
4314
else
4315
  if test -n "$ac_ct_GNATBIND"; then
4316
  ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4317
else
4318
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4319
for as_dir in $PATH
4320
do
4321
  IFS=$as_save_IFS
4322
  test -z "$as_dir" && as_dir=.
4323
  for ac_exec_ext in '' $ac_executable_extensions; do
4324
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4325
    ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4326
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4327
    break 2
4328
  fi
4329
done
4330
done
4331
 
4332
  test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4333
fi
4334
fi
4335
ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4336
if test -n "$ac_ct_GNATBIND"; then
4337
  echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4338
echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4339
else
4340
  echo "$as_me:$LINENO: result: no" >&5
4341
echo "${ECHO_T}no" >&6
4342
fi
4343
 
4344
  GNATBIND=$ac_ct_GNATBIND
4345
else
4346
  GNATBIND="$ac_cv_prog_GNATBIND"
4347
fi
4348
 
4349
if test -n "$ac_tool_prefix"; then
4350
  # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4351
set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4352
echo "$as_me:$LINENO: checking for $ac_word" >&5
4353
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4354
if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4355
  echo $ECHO_N "(cached) $ECHO_C" >&6
4356
else
4357
  if test -n "$GNATMAKE"; then
4358
  ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4359
else
4360
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4361
for as_dir in $PATH
4362
do
4363
  IFS=$as_save_IFS
4364
  test -z "$as_dir" && as_dir=.
4365
  for ac_exec_ext in '' $ac_executable_extensions; do
4366
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4367
    ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4368
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4369
    break 2
4370
  fi
4371
done
4372
done
4373
 
4374
fi
4375
fi
4376
GNATMAKE=$ac_cv_prog_GNATMAKE
4377
if test -n "$GNATMAKE"; then
4378
  echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4379
echo "${ECHO_T}$GNATMAKE" >&6
4380
else
4381
  echo "$as_me:$LINENO: result: no" >&5
4382
echo "${ECHO_T}no" >&6
4383
fi
4384
 
4385
fi
4386
if test -z "$ac_cv_prog_GNATMAKE"; then
4387
  ac_ct_GNATMAKE=$GNATMAKE
4388
  # Extract the first word of "gnatmake", so it can be a program name with args.
4389
set dummy gnatmake; ac_word=$2
4390
echo "$as_me:$LINENO: checking for $ac_word" >&5
4391
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4392
if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4393
  echo $ECHO_N "(cached) $ECHO_C" >&6
4394
else
4395
  if test -n "$ac_ct_GNATMAKE"; then
4396
  ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4397
else
4398
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4399
for as_dir in $PATH
4400
do
4401
  IFS=$as_save_IFS
4402
  test -z "$as_dir" && as_dir=.
4403
  for ac_exec_ext in '' $ac_executable_extensions; do
4404
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4405
    ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4406
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4407
    break 2
4408
  fi
4409
done
4410
done
4411
 
4412
  test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4413
fi
4414
fi
4415
ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4416
if test -n "$ac_ct_GNATMAKE"; then
4417
  echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4418
echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4419
else
4420
  echo "$as_me:$LINENO: result: no" >&5
4421
echo "${ECHO_T}no" >&6
4422
fi
4423
 
4424
  GNATMAKE=$ac_ct_GNATMAKE
4425
else
4426
  GNATMAKE="$ac_cv_prog_GNATMAKE"
4427
fi
4428
 
4429
echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4430
echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4431
if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4432
  echo $ECHO_N "(cached) $ECHO_C" >&6
4433
else
4434
  cat >conftest.adb <
4435
procedure conftest is begin null; end conftest;
4436
EOF
4437
acx_cv_cc_gcc_supports_ada=no
4438
# There is a bug in old released versions of GCC which causes the
4439
# driver to exit successfully when the appropriate language module
4440
# has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4441
# Therefore we must check for the error message as well as an
4442
# unsuccessful exit.
4443
# Other compilers, like HP Tru64 UNIX cc, exit successfully when
4444
# given a .adb file, but produce no object file.  So we must check
4445
# if an object file was really produced to guard against this.
4446
errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4447
if test x"$errors" = x && test -f conftest.$ac_objext; then
4448
  acx_cv_cc_gcc_supports_ada=yes
4449
fi
4450
rm -f conftest.*
4451
fi
4452
echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4453
echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4454
 
4455
if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4456
  have_gnat=yes
4457
else
4458
  have_gnat=no
4459
fi
4460
 
4461
echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4462
echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4463
if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4464
  echo $ECHO_N "(cached) $ECHO_C" >&6
4465
else
4466
   echo abfoo >t1
4467
  echo cdfoo >t2
4468
  gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4469
  if cmp t1 t2 2 2 > /dev/null 2>&1; then
4470
    if cmp t1 t2 1 1 > /dev/null 2>&1; then
4471
      :
4472
    else
4473
      gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4474
    fi
4475
  fi
4476
  if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4477
    if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4478
      :
4479
    else
4480
      gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4481
    fi
4482
  fi
4483
  rm t1 t2
4484
 
4485
fi
4486
echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4487
echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4488
do_compare="$gcc_cv_prog_cmp_skip"
4489
 
4490
 
4491
 
4492
# Check for GMP and MPFR
4493
gmplibs="-lmpfr -lgmp"
4494
gmpinc=
4495
have_gmp=no
4496
 
4497
# Specify a location for mpfr
4498
# check for this first so it ends up on the link line before gmp.
4499
 
4500
# Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4501
if test "${with_mpfr_dir+set}" = set; then
4502
  withval="$with_mpfr_dir"
4503
  { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4504
Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4505
echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4506
Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4507
   { (exit 1); exit 1; }; }
4508
fi;
4509
 
4510
 
4511
# Check whether --with-mpfr or --without-mpfr was given.
4512
if test "${with_mpfr+set}" = set; then
4513
  withval="$with_mpfr"
4514
 
4515
fi;
4516
 
4517
# Check whether --with-mpfr_include or --without-mpfr_include was given.
4518
if test "${with_mpfr_include+set}" = set; then
4519
  withval="$with_mpfr_include"
4520
 
4521
fi;
4522
 
4523
# Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4524
if test "${with_mpfr_lib+set}" = set; then
4525
  withval="$with_mpfr_lib"
4526
 
4527
fi;
4528
 
4529
if test "x$with_mpfr" != x; then
4530
  gmplibs="-L$with_mpfr/lib $gmplibs"
4531
  gmpinc="-I$with_mpfr/include"
4532
fi
4533
if test "x$with_mpfr_include" != x; then
4534
  gmpinc="-I$with_mpfr_include"
4535
fi
4536
if test "x$with_mpfr_lib" != x; then
4537
  gmplibs="-L$with_mpfr_lib $gmplibs"
4538
fi
4539
if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4540
  gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4541
  gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4542
  # Do not test the mpfr version.  Assume that it is sufficient, since
4543
  # it is in the source tree, and the library has not been built yet
4544
  # but it would be included on the link line in the version check below
4545
  # hence making the test fail.
4546
  have_gmp=yes
4547
fi
4548
 
4549
# Specify a location for gmp
4550
 
4551
# Check whether --with-gmp-dir or --without-gmp-dir was given.
4552
if test "${with_gmp_dir+set}" = set; then
4553
  withval="$with_gmp_dir"
4554
  { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4555
Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4556
echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4557
Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4558
   { (exit 1); exit 1; }; }
4559
fi;
4560
 
4561
 
4562
# Check whether --with-gmp or --without-gmp was given.
4563
if test "${with_gmp+set}" = set; then
4564
  withval="$with_gmp"
4565
 
4566
fi;
4567
 
4568
# Check whether --with-gmp_include or --without-gmp_include was given.
4569
if test "${with_gmp_include+set}" = set; then
4570
  withval="$with_gmp_include"
4571
 
4572
fi;
4573
 
4574
# Check whether --with-gmp_lib or --without-gmp_lib was given.
4575
if test "${with_gmp_lib+set}" = set; then
4576
  withval="$with_gmp_lib"
4577
 
4578
fi;
4579
 
4580
 
4581
if test "x$with_gmp" != x; then
4582
  gmplibs="-L$with_gmp/lib $gmplibs"
4583
  gmpinc="-I$with_gmp/include $gmpinc"
4584
fi
4585
if test "x$with_gmp_include" != x; then
4586
  gmpinc="-I$with_gmp_include $gmpinc"
4587
fi
4588
if test "x$with_gmp_lib" != x; then
4589
  gmplibs="-L$with_gmp_lib $gmplibs"
4590
fi
4591
if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4592
  gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4593
  gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4594
  # Do not test the gmp version.  Assume that it is sufficient, since
4595
  # it is in the source tree, and the library has not been built yet
4596
  # but it would be included on the link line in the version check below
4597
  # hence making the test fail.
4598
  have_gmp=yes
4599
fi
4600
 
4601
if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4602
  have_gmp=yes
4603
  saved_CFLAGS="$CFLAGS"
4604
  CFLAGS="$CFLAGS $gmpinc"
4605
  # Check GMP actually works
4606
  echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4607
echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4608
 
4609
cat >conftest.$ac_ext <<_ACEOF
4610
/* confdefs.h.  */
4611
_ACEOF
4612
cat confdefs.h >>conftest.$ac_ext
4613
cat >>conftest.$ac_ext <<_ACEOF
4614
/* end confdefs.h.  */
4615
#include "gmp.h"
4616
int
4617
main ()
4618
{
4619
 
4620
  #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4621
  choke me
4622
  #endif
4623
 
4624
  ;
4625
  return 0;
4626
}
4627
_ACEOF
4628
rm -f conftest.$ac_objext
4629
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4630
  (eval $ac_compile) 2>conftest.er1
4631
  ac_status=$?
4632
  grep -v '^ *+' conftest.er1 >conftest.err
4633
  rm -f conftest.er1
4634
  cat conftest.err >&5
4635
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4636
  (exit $ac_status); } &&
4637
         { ac_try='test -z "$ac_c_werror_flag"
4638
                         || test ! -s conftest.err'
4639
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4640
  (eval $ac_try) 2>&5
4641
  ac_status=$?
4642
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4643
  (exit $ac_status); }; } &&
4644
         { ac_try='test -s conftest.$ac_objext'
4645
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4646
  (eval $ac_try) 2>&5
4647
  ac_status=$?
4648
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4649
  (exit $ac_status); }; }; then
4650
  echo "$as_me:$LINENO: result: yes" >&5
4651
echo "${ECHO_T}yes" >&6
4652
else
4653
  echo "$as_me: failed program was:" >&5
4654
sed 's/^/| /' conftest.$ac_ext >&5
4655
 
4656
echo "$as_me:$LINENO: result: no" >&5
4657
echo "${ECHO_T}no" >&6; have_gmp=no
4658
fi
4659
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4660
 
4661
  if test x"$have_gmp" = xyes; then
4662
    saved_LIBS="$LIBS"
4663
    LIBS="$LIBS $gmplibs"
4664
        echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4665
echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4666
    cat >conftest.$ac_ext <<_ACEOF
4667
/* confdefs.h.  */
4668
_ACEOF
4669
cat confdefs.h >>conftest.$ac_ext
4670
cat >>conftest.$ac_ext <<_ACEOF
4671
/* end confdefs.h.  */
4672
#include 
4673
    #include 
4674
int
4675
main ()
4676
{
4677
 
4678
    #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4679
    choke me
4680
    #endif
4681
    mpfr_t n;
4682
    mpfr_t x;
4683
    int t;
4684
    mpfr_init (n);
4685
    mpfr_init (x);
4686
    mpfr_atan2 (n, n, x, GMP_RNDN);
4687
    mpfr_erfc (n, x, GMP_RNDN);
4688
    mpfr_subnormalize (x, t, GMP_RNDN);
4689
 
4690
  ;
4691
  return 0;
4692
}
4693
_ACEOF
4694
rm -f conftest.$ac_objext conftest$ac_exeext
4695
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4696
  (eval $ac_link) 2>conftest.er1
4697
  ac_status=$?
4698
  grep -v '^ *+' conftest.er1 >conftest.err
4699
  rm -f conftest.er1
4700
  cat conftest.err >&5
4701
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4702
  (exit $ac_status); } &&
4703
         { ac_try='test -z "$ac_c_werror_flag"
4704
                         || test ! -s conftest.err'
4705
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4706
  (eval $ac_try) 2>&5
4707
  ac_status=$?
4708
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4709
  (exit $ac_status); }; } &&
4710
         { ac_try='test -s conftest$ac_exeext'
4711
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4712
  (eval $ac_try) 2>&5
4713
  ac_status=$?
4714
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4715
  (exit $ac_status); }; }; then
4716
  cat >conftest.$ac_ext <<_ACEOF
4717
/* confdefs.h.  */
4718
_ACEOF
4719
cat confdefs.h >>conftest.$ac_ext
4720
cat >>conftest.$ac_ext <<_ACEOF
4721
/* end confdefs.h.  */
4722
#include 
4723
    #include 
4724
int
4725
main ()
4726
{
4727
 
4728
    #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4729
    choke me
4730
    #endif
4731
    mpfr_t n; mpfr_init(n);
4732
 
4733
  ;
4734
  return 0;
4735
}
4736
_ACEOF
4737
rm -f conftest.$ac_objext conftest$ac_exeext
4738
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4739
  (eval $ac_link) 2>conftest.er1
4740
  ac_status=$?
4741
  grep -v '^ *+' conftest.er1 >conftest.err
4742
  rm -f conftest.er1
4743
  cat conftest.err >&5
4744
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4745
  (exit $ac_status); } &&
4746
         { ac_try='test -z "$ac_c_werror_flag"
4747
                         || test ! -s conftest.err'
4748
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4749
  (eval $ac_try) 2>&5
4750
  ac_status=$?
4751
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4752
  (exit $ac_status); }; } &&
4753
         { ac_try='test -s conftest$ac_exeext'
4754
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4755
  (eval $ac_try) 2>&5
4756
  ac_status=$?
4757
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4758
  (exit $ac_status); }; }; then
4759
  echo "$as_me:$LINENO: result: yes" >&5
4760
echo "${ECHO_T}yes" >&6
4761
else
4762
  echo "$as_me: failed program was:" >&5
4763
sed 's/^/| /' conftest.$ac_ext >&5
4764
 
4765
echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4766
echo "${ECHO_T}buggy but acceptable" >&6
4767
fi
4768
rm -f conftest.err conftest.$ac_objext \
4769
      conftest$ac_exeext conftest.$ac_ext
4770
else
4771
  echo "$as_me: failed program was:" >&5
4772
sed 's/^/| /' conftest.$ac_ext >&5
4773
 
4774
echo "$as_me:$LINENO: result: no" >&5
4775
echo "${ECHO_T}no" >&6; have_gmp=no
4776
fi
4777
rm -f conftest.err conftest.$ac_objext \
4778
      conftest$ac_exeext conftest.$ac_ext
4779
      LIBS="$saved_LIBS"
4780
  fi
4781
  CFLAGS="$saved_CFLAGS"
4782
 
4783
  if test x$have_gmp != xyes; then
4784
    { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.2+.
4785
Try the --with-gmp and/or --with-mpfr options to specify their locations.
4786
Copies of these libraries' source code can be found at their respective
4787
hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4788
See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4789
If you obtained GMP and/or MPFR from a vendor distribution package, make
4790
sure that you have installed both the libraries and the header files.
4791
They may be located in separate packages." >&5
4792
echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.2+.
4793
Try the --with-gmp and/or --with-mpfr options to specify their locations.
4794
Copies of these libraries' source code can be found at their respective
4795
hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4796
See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4797
If you obtained GMP and/or MPFR from a vendor distribution package, make
4798
sure that you have installed both the libraries and the header files.
4799
They may be located in separate packages." >&2;}
4800
   { (exit 1); exit 1; }; }
4801
  fi
4802
fi
4803
 
4804
# Flags needed for both GMP and/or MPFR
4805
 
4806
 
4807
 
4808
 
4809
# Check for PPL
4810
ppl_major_version=0
4811
ppl_minor_version=10
4812
ppllibs=" -lppl_c -lppl -lgmpxx "
4813
pplinc=
4814
 
4815
 
4816
# Check whether --with-ppl or --without-ppl was given.
4817
if test "${with_ppl+set}" = set; then
4818
  withval="$with_ppl"
4819
 
4820
fi;
4821
 
4822
# Check whether --with-ppl_include or --without-ppl_include was given.
4823
if test "${with_ppl_include+set}" = set; then
4824
  withval="$with_ppl_include"
4825
 
4826
fi;
4827
 
4828
# Check whether --with-ppl_lib or --without-ppl_lib was given.
4829
if test "${with_ppl_lib+set}" = set; then
4830
  withval="$with_ppl_lib"
4831
 
4832
fi;
4833
 
4834
if test "x$with_ppl" != x; then
4835
  ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx"
4836
  pplinc="-I$with_ppl/include $pplinc"
4837
  LIBS="$ppllibs $LIBS"
4838
fi
4839
if test "x$with_ppl_include" != x; then
4840
  pplinc="-I$with_ppl_include $pplinc"
4841
fi
4842
if test "x$with_ppl_lib" != x; then
4843
  ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx"
4844
  LIBS="$ppllibs $LIBS"
4845
fi
4846
if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
4847
  ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '
4848
  pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
4849
  LIBS="$ppllibs $LIBS"
4850
fi
4851
 
4852
# Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
4853
if test "${enable_ppl_version_check+set}" = set; then
4854
  enableval="$enable_ppl_version_check"
4855
  ENABLE_PPL_CHECK=$enableval
4856
else
4857
  ENABLE_PPL_CHECK=yes
4858
fi;
4859
 
4860
if test "${ENABLE_PPL_CHECK}" = "yes"; then
4861
  saved_CFLAGS="$CFLAGS"
4862
  CFLAGS="$CFLAGS $pplinc $gmpinc"
4863
  echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
4864
echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
4865
  cat >conftest.$ac_ext <<_ACEOF
4866
/* confdefs.h.  */
4867
_ACEOF
4868
cat confdefs.h >>conftest.$ac_ext
4869
cat >>conftest.$ac_ext <<_ACEOF
4870
/* end confdefs.h.  */
4871
#include "ppl_c.h"
4872
int
4873
main ()
4874
{
4875
 
4876
  #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
4877
  choke me
4878
  #endif
4879
 
4880
  ;
4881
  return 0;
4882
}
4883
_ACEOF
4884
rm -f conftest.$ac_objext
4885
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4886
  (eval $ac_compile) 2>conftest.er1
4887
  ac_status=$?
4888
  grep -v '^ *+' conftest.er1 >conftest.err
4889
  rm -f conftest.er1
4890
  cat conftest.err >&5
4891
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4892
  (exit $ac_status); } &&
4893
         { ac_try='test -z "$ac_c_werror_flag"
4894
                         || test ! -s conftest.err'
4895
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4896
  (eval $ac_try) 2>&5
4897
  ac_status=$?
4898
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4899
  (exit $ac_status); }; } &&
4900
         { ac_try='test -s conftest.$ac_objext'
4901
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4902
  (eval $ac_try) 2>&5
4903
  ac_status=$?
4904
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4905
  (exit $ac_status); }; }; then
4906
  echo "$as_me:$LINENO: result: yes" >&5
4907
echo "${ECHO_T}yes" >&6
4908
else
4909
  echo "$as_me: failed program was:" >&5
4910
sed 's/^/| /' conftest.$ac_ext >&5
4911
 
4912
echo "$as_me:$LINENO: result: no" >&5
4913
echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
4914
fi
4915
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4916
  CFLAGS="$saved_CFLAGS"
4917
fi
4918
 
4919
# Flags needed for PPL
4920
 
4921
 
4922
 
4923
 
4924
# Check for CLOOG
4925
clooglibs=" -lcloog "
4926
clooginc=" -DCLOOG_PPL_BACKEND "
4927
 
4928
 
4929
# Check whether --with-cloog or --without-cloog was given.
4930
if test "${with_cloog+set}" = set; then
4931
  withval="$with_cloog"
4932
 
4933
fi;
4934
 
4935
# Check whether --with-cloog_include or --without-cloog_include was given.
4936
if test "${with_cloog_include+set}" = set; then
4937
  withval="$with_cloog_include"
4938
 
4939
fi;
4940
 
4941
# Check whether --with-cloog_lib or --without-cloog_lib was given.
4942
if test "${with_cloog_lib+set}" = set; then
4943
  withval="$with_cloog_lib"
4944
 
4945
fi;
4946
 
4947
# Check whether --with-cloog-polylib or --without-cloog-polylib was given.
4948
if test "${with_cloog_polylib+set}" = set; then
4949
  withval="$with_cloog_polylib"
4950
 
4951
fi;
4952
 
4953
if test "x$with_cloog" != x; then
4954
  clooglibs="-L$with_cloog/lib -lcloog"
4955
  clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
4956
  LIBS="$clooglibs $LIBS"
4957
fi
4958
if test "x$with_cloog_polylib" != x; then
4959
  clooglibs="-L$with_cloog/lib -lcloog"
4960
  clooginc="-I$with_cloog/include "
4961
  LIBS="$clooglibs $LIBS"
4962
fi
4963
if test "x$with_cloog_include" != x; then
4964
  clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
4965
fi
4966
if test "x$with_cloog_lib" != x; then
4967
  clooglibs="-L$with_cloog_lib -lcloog"
4968
  LIBS="$clooglibs $LIBS"
4969
fi
4970
if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
4971
  clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
4972
  clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
4973
  LIBS="$clooglibs $LIBS"
4974
fi
4975
 
4976
# Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
4977
if test "${enable_cloog_version_check+set}" = set; then
4978
  enableval="$enable_cloog_version_check"
4979
  ENABLE_CLOOG_CHECK=$enableval
4980
else
4981
  ENABLE_CLOOG_CHECK=yes
4982
fi;
4983
 
4984
if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
4985
  saved_CFLAGS="$CFLAGS"
4986
  CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
4987
  echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
4988
echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
4989
  cat >conftest.$ac_ext <<_ACEOF
4990
/* confdefs.h.  */
4991
_ACEOF
4992
cat confdefs.h >>conftest.$ac_ext
4993
cat >>conftest.$ac_ext <<_ACEOF
4994
/* end confdefs.h.  */
4995
#include "cloog/cloog.h"
4996
int
4997
main ()
4998
{
4999
 
5000
  #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
5001
  choke me
5002
  #endif
5003
 
5004
  ;
5005
  return 0;
5006
}
5007
_ACEOF
5008
rm -f conftest.$ac_objext
5009
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5010
  (eval $ac_compile) 2>conftest.er1
5011
  ac_status=$?
5012
  grep -v '^ *+' conftest.er1 >conftest.err
5013
  rm -f conftest.er1
5014
  cat conftest.err >&5
5015
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5016
  (exit $ac_status); } &&
5017
         { ac_try='test -z "$ac_c_werror_flag"
5018
                         || test ! -s conftest.err'
5019
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5020
  (eval $ac_try) 2>&5
5021
  ac_status=$?
5022
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5023
  (exit $ac_status); }; } &&
5024
         { ac_try='test -s conftest.$ac_objext'
5025
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5026
  (eval $ac_try) 2>&5
5027
  ac_status=$?
5028
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5029
  (exit $ac_status); }; }; then
5030
  echo "$as_me:$LINENO: result: yes" >&5
5031
echo "${ECHO_T}yes" >&6
5032
else
5033
  echo "$as_me: failed program was:" >&5
5034
sed 's/^/| /' conftest.$ac_ext >&5
5035
 
5036
echo "$as_me:$LINENO: result: no" >&5
5037
echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5038
fi
5039
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5040
  CFLAGS="$saved_CFLAGS"
5041
fi
5042
 
5043
# Flags needed for CLOOG
5044
 
5045
 
5046
 
5047
 
5048
# By default, C is the only stage 1 language.
5049
stage1_languages=,c,
5050
 
5051
# Figure out what language subdirectories are present.
5052
# Look if the user specified --enable-languages="..."; if not, use
5053
# the environment variable $LANGUAGES if defined. $LANGUAGES might
5054
# go away some day.
5055
# NB:  embedded tabs in this IF block -- do not untabify
5056
if test -d ${srcdir}/gcc; then
5057
  if test x"${enable_languages+set}" != xset; then
5058
    if test x"${LANGUAGES+set}" = xset; then
5059
      enable_languages="${LANGUAGES}"
5060
        echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5061
    else
5062
      enable_languages=all
5063
    fi
5064
  else
5065
    if test x"${enable_languages}" = x ||
5066
       test x"${enable_languages}" = xyes;
5067
       then
5068
      echo configure.in: --enable-languages needs at least one language argument 1>&2
5069
      exit 1
5070
    fi
5071
  fi
5072
  enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5073
 
5074
  # 'f95' is the old name for the 'fortran' language. We issue a warning
5075
  # and make the substitution.
5076
  case ,${enable_languages}, in
5077
    *,f95,*)
5078
      echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5079
      enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5080
      ;;
5081
  esac
5082
 
5083
  # First scan to see if an enabled language requires some other language.
5084
  # We assume that a given config-lang.in will list all the language
5085
  # front ends it requires, even if some are required indirectly.
5086
  for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5087
    case ${lang_frag} in
5088
      ..) ;;
5089
      # The odd quoting in the next line works around
5090
      # an apparent bug in bash 1.12 on linux.
5091
      ${srcdir}/gcc/[*]/config-lang.in) ;;
5092
      *)
5093
        # From the config-lang.in, get $language, $lang_requires
5094
        language=
5095
        lang_requires=
5096
        . ${lang_frag}
5097
        for other in ${lang_requires} ; do
5098
          case ,${enable_languages}, in
5099
            *,$other,*) ;;
5100
            *,all,*) ;;
5101
            *,$language,*)
5102
              echo " \`$other' language required by \`$language'; enabling" 1>&2
5103
              enable_languages="${enable_languages},${other}"
5104
              ;;
5105
          esac
5106
        done
5107
        ;;
5108
    esac
5109
  done
5110
 
5111
  new_enable_languages=,c,
5112
  missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5113
  potential_languages=,c,
5114
 
5115
  for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5116
    case ${lang_frag} in
5117
      ..) ;;
5118
      # The odd quoting in the next line works around
5119
      # an apparent bug in bash 1.12 on linux.
5120
      ${srcdir}/gcc/[*]/config-lang.in) ;;
5121
      *)
5122
        # From the config-lang.in, get $language, $target_libs,
5123
        # $lang_dirs, $boot_language, and $build_by_default
5124
        language=
5125
        target_libs=
5126
        lang_dirs=
5127
        subdir_requires=
5128
        boot_language=no
5129
        build_by_default=yes
5130
        . ${lang_frag}
5131
        if test x${language} = x; then
5132
          echo "${lang_frag} doesn't set \$language." 1>&2
5133
          exit 1
5134
        fi
5135
 
5136
        case ,${enable_languages}, in
5137
          *,${language},*)
5138
            # Language was explicitly selected; include it.
5139
            add_this_lang=yes
5140
            ;;
5141
          *,all,*)
5142
            # 'all' was selected, select it if it is a default language
5143
            add_this_lang=${build_by_default}
5144
            ;;
5145
          *)
5146
            add_this_lang=no
5147
            ;;
5148
        esac
5149
 
5150
        # Disable languages that need other directories if these aren't available.
5151
        for i in $subdir_requires; do
5152
          test -f "$srcdir/gcc/$i/config-lang.in" && continue
5153
          case ,${enable_languages}, in
5154
            *,${language},*)
5155
              # Specifically requested language; tell them.
5156
              { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5157
echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5158
   { (exit 1); exit 1; }; }
5159
              ;;
5160
            *)
5161
              # Silently disable.
5162
              add_this_lang=unsupported
5163
              ;;
5164
          esac
5165
        done
5166
 
5167
        # Disable Ada if no preexisting GNAT is available.
5168
        case ,${enable_languages},:${language}:${have_gnat} in
5169
          *,${language},*:ada:no)
5170
            # Specifically requested language; tell them.
5171
            { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5172
echo "$as_me: error: GNAT is required to build $language" >&2;}
5173
   { (exit 1); exit 1; }; }
5174
            ;;
5175
          *:ada:no)
5176
            # Silently disable.
5177
            add_this_lang=unsupported
5178
            ;;
5179
        esac
5180
 
5181
        # Disable a language that is unsupported by the target.
5182
        case " $unsupported_languages " in
5183
          *" $language "*)
5184
            add_this_lang=unsupported
5185
            ;;
5186
        esac
5187
 
5188
        case $add_this_lang in
5189
          unsupported)
5190
            # Remove language-dependent dirs.
5191
            eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5192
            ;;
5193
          no)
5194
            # Remove language-dependent dirs; still show language as supported.
5195
            eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5196
            potential_languages="${potential_languages}${language},"
5197
            ;;
5198
          yes)
5199
            new_enable_languages="${new_enable_languages}${language},"
5200
            potential_languages="${potential_languages}${language},"
5201
            missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5202
            case ${boot_language} in
5203
              yes)
5204
                # Add to (comma-separated) list of stage 1 languages.
5205
                stage1_languages="${stage1_languages}${language},"
5206
                ;;
5207
            esac
5208
            ;;
5209
        esac
5210
        ;;
5211
    esac
5212
  done
5213
 
5214
  # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5215
if test "${enable_stage1_languages+set}" = set; then
5216
  enableval="$enable_stage1_languages"
5217
  case ,${enable_stage1_languages}, in
5218
    ,no,|,,)
5219
      # Set it to something that will have no effect in the loop below
5220
      enable_stage1_languages=c ;;
5221
    ,yes,)
5222
      enable_stage1_languages=`echo $new_enable_languages | \
5223
        sed -e "s/^,//" -e "s/,$//" ` ;;
5224
    *,all,*)
5225
      enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5226
        sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5227
  esac
5228
 
5229
  # Add "good" languages from enable_stage1_languages to stage1_languages,
5230
  # while "bad" languages go in missing_languages.  Leave no duplicates.
5231
  for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5232
    case $potential_languages in
5233
      *,$i,*)
5234
        case $stage1_languages in
5235
          *,$i,*) ;;
5236
          *) stage1_languages="$stage1_languages$i," ;;
5237
        esac ;;
5238
      *)
5239
        case $missing_languages in
5240
          *,$i,*) ;;
5241
          *) missing_languages="$missing_languages$i," ;;
5242
        esac ;;
5243
     esac
5244
  done
5245
fi;
5246
 
5247
  # Remove leading/trailing commas that were added for simplicity
5248
  potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5249
  missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5250
  stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5251
  new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5252
 
5253
  if test "x$missing_languages" != x; then
5254
    { { echo "$as_me:$LINENO: error:
5255
The following requested languages could not be built: ${missing_languages}
5256
Supported languages are: ${potential_languages}" >&5
5257
echo "$as_me: error:
5258
The following requested languages could not be built: ${missing_languages}
5259
Supported languages are: ${potential_languages}" >&2;}
5260
   { (exit 1); exit 1; }; }
5261
  fi
5262
  if test "x$new_enable_languages" != "x$enable_languages"; then
5263
    echo The following languages will be built: ${new_enable_languages}
5264
    enable_languages="$new_enable_languages"
5265
  fi
5266
 
5267
 
5268
  ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5269
fi
5270
 
5271
# Handle --disable- generically.
5272
for dir in $configdirs $build_configdirs $target_configdirs ; do
5273
  dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5274
  varname=`echo $dirname | sed -e s/+/_/g`
5275
  if eval test x\${enable_${varname}} "=" xno ; then
5276
    noconfigdirs="$noconfigdirs $dir"
5277
  fi
5278
done
5279
 
5280
# Check for Boehm's garbage collector
5281
# Check whether --enable-objc-gc or --disable-objc-gc was given.
5282
if test "${enable_objc_gc+set}" = set; then
5283
  enableval="$enable_objc_gc"
5284
  case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5285
  *,objc,*:*:yes:*target-boehm-gc*)
5286
    { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5287
echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5288
   { (exit 1); exit 1; }; }
5289
    ;;
5290
esac
5291
fi;
5292
 
5293
# Make sure we only build Boehm's garbage collector if required.
5294
case ,${enable_languages},:${enable_objc_gc} in
5295
  *,objc,*:yes)
5296
    # Keep target-boehm-gc if requested for Objective-C.
5297
    ;;
5298
  *)
5299
    # Otherwise remove target-boehm-gc depending on target-libjava.
5300
    if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5301
      noconfigdirs="$noconfigdirs target-boehm-gc"
5302
    fi
5303
    ;;
5304
esac
5305
 
5306
# Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5307
# $build_configdirs and $target_configdirs.
5308
# If we have the source for $noconfigdirs entries, add them to $notsupp.
5309
 
5310
notsupp=""
5311
for dir in . $skipdirs $noconfigdirs ; do
5312
  dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5313
  if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5314
    configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5315
    if test -r $srcdir/$dirname/configure ; then
5316
      if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5317
        true
5318
      else
5319
        notsupp="$notsupp $dir"
5320
      fi
5321
    fi
5322
  fi
5323
  if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5324
    build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5325
    if test -r $srcdir/$dirname/configure ; then
5326
      if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5327
        true
5328
      else
5329
        notsupp="$notsupp $dir"
5330
      fi
5331
    fi
5332
  fi
5333
  if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5334
    target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5335
    if test -r $srcdir/$dirname/configure ; then
5336
      if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5337
        true
5338
      else
5339
        notsupp="$notsupp $dir"
5340
      fi
5341
    fi
5342
  fi
5343
done
5344
 
5345
# Sometimes the tools are distributed with libiberty but with no other
5346
# libraries.  In that case, we don't want to build target-libiberty.
5347
# Don't let libgcc imply libiberty either.
5348
if test -n "${target_configdirs}" ; then
5349
  libgcc=
5350
  others=
5351
  for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5352
    if test "$i" = "libgcc"; then
5353
      libgcc=target-libgcc
5354
    elif test "$i" != "libiberty" ; then
5355
      if test -r $srcdir/$i/configure ; then
5356
        others=yes;
5357
        break;
5358
      fi
5359
    fi
5360
  done
5361
  if test -z "${others}" ; then
5362
    target_configdirs=$libgcc
5363
  fi
5364
fi
5365
 
5366
# Quietly strip out all directories which aren't configurable in this tree.
5367
# This relies on all configurable subdirectories being autoconfiscated, which
5368
# is now the case.
5369
build_configdirs_all="$build_configdirs"
5370
build_configdirs=
5371
for i in ${build_configdirs_all} ; do
5372
  j=`echo $i | sed -e s/build-//g`
5373
  if test -f ${srcdir}/$j/configure ; then
5374
    build_configdirs="${build_configdirs} $i"
5375
  fi
5376
done
5377
 
5378
configdirs_all="$configdirs"
5379
configdirs=
5380
for i in ${configdirs_all} ; do
5381
  if test -f ${srcdir}/$i/configure ; then
5382
    configdirs="${configdirs} $i"
5383
  fi
5384
done
5385
 
5386
target_configdirs_all="$target_configdirs"
5387
target_configdirs=
5388
for i in ${target_configdirs_all} ; do
5389
  j=`echo $i | sed -e s/target-//g`
5390
  if test -f ${srcdir}/$j/configure ; then
5391
    target_configdirs="${target_configdirs} $i"
5392
  fi
5393
done
5394
 
5395
# Produce a warning message for the subdirs we can't configure.
5396
# This isn't especially interesting in the Cygnus tree, but in the individual
5397
# FSF releases, it's important to let people know when their machine isn't
5398
# supported by the one or two programs in a package.
5399
 
5400
if test -n "${notsupp}" && test -z "${norecursion}" ; then
5401
  # If $appdirs is non-empty, at least one of those directories must still
5402
  # be configured, or we error out.  (E.g., if the gas release supports a
5403
  # specified target in some subdirs but not the gas subdir, we shouldn't
5404
  # pretend that all is well.)
5405
  if test -n "$appdirs" ; then
5406
    for dir in $appdirs ; do
5407
      if test -r $dir/Makefile.in ; then
5408
        if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5409
          appdirs=""
5410
          break
5411
        fi
5412
        if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5413
          appdirs=""
5414
          break
5415
        fi
5416
      fi
5417
    done
5418
    if test -n "$appdirs" ; then
5419
      echo "*** This configuration is not supported by this package." 1>&2
5420
      exit 1
5421
    fi
5422
  fi
5423
  # Okay, some application will build, or we don't care to check.  Still
5424
  # notify of subdirs not getting built.
5425
  echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5426
  echo "    ${notsupp}" 1>&2
5427
  echo "    (Any other directories should still work fine.)" 1>&2
5428
fi
5429
 
5430
case "$host" in
5431
  *msdosdjgpp*)
5432
    enable_gdbtk=no ;;
5433
esac
5434
 
5435
# To find our prefix, in gcc_cv_tool_prefix.
5436
 
5437
# The user is always right.
5438
if test "${PATH_SEPARATOR+set}" != set; then
5439
  echo "#! /bin/sh" >conf$$.sh
5440
  echo  "exit 0"   >>conf$$.sh
5441
  chmod +x conf$$.sh
5442
  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5443
    PATH_SEPARATOR=';'
5444
  else
5445
    PATH_SEPARATOR=:
5446
  fi
5447
  rm -f conf$$.sh
5448
fi
5449
 
5450
 
5451
 
5452
if test "x$exec_prefix" = xNONE; then
5453
        if test "x$prefix" = xNONE; then
5454
                gcc_cv_tool_prefix=$ac_default_prefix
5455
        else
5456
                gcc_cv_tool_prefix=$prefix
5457
        fi
5458
else
5459
        gcc_cv_tool_prefix=$exec_prefix
5460
fi
5461
 
5462
# If there is no compiler in the tree, use the PATH only.  In any
5463
# case, if there is no compiler in the tree nobody should use
5464
# AS_FOR_TARGET and LD_FOR_TARGET.
5465
if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5466
    gcc_version=`cat $srcdir/gcc/BASE-VER`
5467
    gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5468
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5469
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5470
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5471
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5472
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5473
else
5474
    gcc_cv_tool_dirs=
5475
fi
5476
 
5477
if test x$build = x$target && test -n "$md_exec_prefix"; then
5478
        gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5479
fi
5480
 
5481
 
5482
 
5483
copy_dirs=
5484
 
5485
 
5486
# Check whether --with-build-sysroot or --without-build-sysroot was given.
5487
if test "${with_build_sysroot+set}" = set; then
5488
  withval="$with_build_sysroot"
5489
  if test x"$withval" != x ; then
5490
     SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5491
   fi
5492
else
5493
  SYSROOT_CFLAGS_FOR_TARGET=
5494
fi;
5495
 
5496
 
5497
 
5498
# Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5499
if test "${with_debug_prefix_map+set}" = set; then
5500
  withval="$with_debug_prefix_map"
5501
  if test x"$withval" != x; then
5502
     DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5503
     for debug_map in $withval; do
5504
       DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5505
     done
5506
   fi
5507
else
5508
  DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5509
fi;
5510
 
5511
 
5512
# During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5513
# might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5514
# might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5515
# We want to ensure that TARGET libraries (which we know are built with
5516
# gcc) are built with "-O2 -g", so include those options when setting
5517
# CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5518
if test "x$CFLAGS_FOR_TARGET" = x; then
5519
  CFLAGS_FOR_TARGET=$CFLAGS
5520
  case " $CFLAGS " in
5521
    *" -O2 "*) ;;
5522
    *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5523
  esac
5524
  case " $CFLAGS " in
5525
    *" -g "* | *" -g3 "*) ;;
5526
    *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5527
  esac
5528
fi
5529
 
5530
 
5531
if test "x$CXXFLAGS_FOR_TARGET" = x; then
5532
  CXXFLAGS_FOR_TARGET=$CXXFLAGS
5533
  case " $CXXFLAGS " in
5534
    *" -O2 "*) ;;
5535
    *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5536
  esac
5537
  case " $CXXFLAGS " in
5538
    *" -g "* | *" -g3 "*) ;;
5539
    *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5540
  esac
5541
fi
5542
 
5543
 
5544
# Handle --with-headers=XXX.  If the value is not "yes", the contents of
5545
# the named directory are copied to $(tooldir)/sys-include.
5546
if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5547
  if test x${is_cross_compiler} = xno ; then
5548
    echo 1>&2 '***' --with-headers is only supported when cross compiling
5549
    exit 1
5550
  fi
5551
  if test x"${with_headers}" != xyes ; then
5552
    x=${gcc_cv_tool_prefix}
5553
    copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5554
  fi
5555
fi
5556
 
5557
# Handle --with-libs=XXX.  If the value is not "yes", the contents of
5558
# the name directories are copied to $(tooldir)/lib.  Multiple directories
5559
# are permitted.
5560
if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5561
  if test x${is_cross_compiler} = xno ; then
5562
    echo 1>&2 '***' --with-libs is only supported when cross compiling
5563
    exit 1
5564
  fi
5565
  if test x"${with_libs}" != xyes ; then
5566
    # Copy the libraries in reverse order, so that files in the first named
5567
    # library override files in subsequent libraries.
5568
    x=${gcc_cv_tool_prefix}
5569
    for l in ${with_libs}; do
5570
      copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5571
    done
5572
  fi
5573
fi
5574
 
5575
# Set with_gnu_as and with_gnu_ld as appropriate.
5576
#
5577
# This is done by determining whether or not the appropriate directory
5578
# is available, and by checking whether or not specific configurations
5579
# have requested that this magic not happen.
5580
#
5581
# The command line options always override the explicit settings in
5582
# configure.in, and the settings in configure.in override this magic.
5583
#
5584
# If the default for a toolchain is to use GNU as and ld, and you don't
5585
# want to do that, then you should use the --without-gnu-as and
5586
# --without-gnu-ld options for the configure script.
5587
 
5588
if test x${use_gnu_as} = x &&
5589
   echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5590
  with_gnu_as=yes
5591
  extra_host_args="$extra_host_args --with-gnu-as"
5592
fi
5593
 
5594
if test x${use_gnu_ld} = x &&
5595
   echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5596
  with_gnu_ld=yes
5597
  extra_host_args="$extra_host_args --with-gnu-ld"
5598
fi
5599
 
5600
# If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5601
# can detect this case.
5602
 
5603
if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5604
  with_newlib=yes
5605
  extra_host_args="$extra_host_args --with-newlib"
5606
fi
5607
 
5608
# Handle ${copy_dirs}
5609
set fnord ${copy_dirs}
5610
shift
5611
while test $# != 0 ; do
5612
  if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5613
    :
5614
  else
5615
    echo Copying $1 to $2
5616
 
5617
    # Use the install script to create the directory and all required
5618
    # parent directories.
5619
    if test -d $2 ; then
5620
      :
5621
    else
5622
      echo >config.temp
5623
      ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5624
    fi
5625
 
5626
    # Copy the directory, assuming we have tar.
5627
    # FIXME: Should we use B in the second tar?  Not all systems support it.
5628
    (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5629
 
5630
    # It is the responsibility of the user to correctly adjust all
5631
    # symlinks.  If somebody can figure out how to handle them correctly
5632
    # here, feel free to add the code.
5633
 
5634
    echo $1 > $2/COPIED
5635
  fi
5636
  shift; shift
5637
done
5638
 
5639
# Determine a target-dependent exec_prefix that the installed
5640
# gcc will search in.  Keep this list sorted by triplet, with
5641
# the *-*-osname triplets last.
5642
md_exec_prefix=
5643
case "${target}" in
5644
  alpha*-*-*vms*)
5645
    md_exec_prefix=/gnu/lib/gcc-lib
5646
    ;;
5647
  i[34567]86-pc-msdosdjgpp*)
5648
    md_exec_prefix=/dev/env/DJDIR/bin
5649
    ;;
5650
  i[34567]86-*-sco3.2v5*)
5651
    if test $with_gnu_as = yes; then
5652
      md_exec_prefix=/usr/gnu/bin
5653
    else
5654
      md_exec_prefix=/usr/ccs/bin/elf
5655
    fi
5656
    ;;
5657
 
5658
  mn10300-*-* | \
5659
  powerpc-*-chorusos* | \
5660
  powerpc*-*-eabi* | \
5661
  powerpc*-*-sysv* | \
5662
  powerpc*-*-kaos* | \
5663
  s390x-ibm-tpf*)
5664
    md_exec_prefix=/usr/ccs/bin
5665
    ;;
5666
  sparc64-*-elf*)
5667
    ;;
5668
  v850*-*-*)
5669
    md_exec_prefix=/usr/ccs/bin
5670
    ;;
5671
  xtensa*-*-elf*)
5672
    ;;
5673
 
5674
  *-*-beos* | \
5675
  *-*-elf* | \
5676
  *-*-hpux* | \
5677
  *-*-netware* | \
5678
  *-*-nto-qnx* | \
5679
  *-*-rtems* | \
5680
  *-*-solaris2* | \
5681
  *-*-sysv[45]* | \
5682
  *-*-vxworks* | \
5683
  *-wrs-windiss)
5684
    md_exec_prefix=/usr/ccs/bin
5685
    ;;
5686
esac
5687
 
5688
extra_arflags_for_target=
5689
extra_nmflags_for_target=
5690
extra_ranlibflags_for_target=
5691
target_makefile_frag=/dev/null
5692
case "${target}" in
5693
  mep*-*-*)
5694
    target_makefile_frag="config/mt-mep"
5695
    ;;
5696
  spu-*-*)
5697
    target_makefile_frag="config/mt-spu"
5698
    ;;
5699
  mips*-sde-elf*)
5700
    target_makefile_frag="config/mt-sde"
5701
    ;;
5702
  mipsisa*-*-elfoabi*)
5703
    target_makefile_frag="config/mt-mips-elfoabi"
5704
    ;;
5705
  mips*-*-*linux* | mips*-*-gnu*)
5706
    target_makefile_frag="config/mt-mips-gnu"
5707
    ;;
5708
  *-*-netware*)
5709
    target_makefile_frag="config/mt-netware"
5710
    ;;
5711
  *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5712
    target_makefile_frag="config/mt-gnu"
5713
    ;;
5714
  *-*-aix4.[3456789]* | *-*-aix[56789].*)
5715
    # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5716
    # commands to handle both 32-bit and 64-bit objects.  These flags are
5717
    # harmless if we're using GNU nm or ar.
5718
    extra_arflags_for_target=" -X32_64"
5719
    extra_nmflags_for_target=" -B -X32_64"
5720
    ;;
5721
  *-*-darwin*)
5722
    # ranlib from Darwin requires the -c flag to look at common symbols.
5723
    extra_ranlibflags_for_target=" -c"
5724
    ;;
5725
  mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5726
    target_makefile_frag="config/mt-wince"
5727
    ;;
5728
esac
5729
 
5730
alphaieee_frag=/dev/null
5731
case $target in
5732
  alpha*-*-*)
5733
    # This just makes sure to use the -mieee option to build target libs.
5734
    # This should probably be set individually by each library.
5735
    alphaieee_frag="config/mt-alphaieee"
5736
    ;;
5737
esac
5738
 
5739
# If --enable-target-optspace always use -Os instead of -O2 to build
5740
# the target libraries, similarly if it is not specified, use -Os
5741
# on selected platforms.
5742
ospace_frag=/dev/null
5743
case "${enable_target_optspace}:${target}" in
5744
  yes:*)
5745
    ospace_frag="config/mt-ospace"
5746
    ;;
5747
  :d30v-*)
5748
    ospace_frag="config/mt-d30v"
5749
    ;;
5750
  :m32r-* | :d10v-* | :fr30-*)
5751
    ospace_frag="config/mt-ospace"
5752
    ;;
5753
  no:* | :*)
5754
    ;;
5755
  *)
5756
    echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5757
    ;;
5758
esac
5759
 
5760
# Default to using --with-stabs for certain targets.
5761
if test x${with_stabs} = x ; then
5762
  case "${target}" in
5763
  mips*-*-irix[56]*)
5764
    ;;
5765
  mips*-*-* | alpha*-*-osf*)
5766
    with_stabs=yes;
5767
    extra_host_args="${extra_host_args} --with-stabs"
5768
    ;;
5769
  esac
5770
fi
5771
 
5772
# hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5773
# them automatically.
5774
case "${host}" in
5775
  hppa*64*-*-hpux11*)
5776
    extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5777
    ;;
5778
esac
5779
 
5780
# Some systems (e.g., one of the i386-aix systems the gas testers are
5781
# using) don't handle "\$" correctly, so don't use it here.
5782
tooldir='${exec_prefix}'/${target_noncanonical}
5783
build_tooldir=${tooldir}
5784
 
5785
# Create a .gdbinit file which runs the one in srcdir
5786
# and tells GDB to look there for source files.
5787
 
5788
if test -r ${srcdir}/.gdbinit ; then
5789
  case ${srcdir} in
5790
    .) ;;
5791
    *) cat > ./.gdbinit <
5792
# ${NO_EDIT}
5793
dir ${srcdir}
5794
dir .
5795
source ${srcdir}/.gdbinit
5796
EOF
5797
    ;;
5798
  esac
5799
fi
5800
 
5801
# Make sure that the compiler is able to generate an executable.  If it
5802
# can't, we are probably in trouble.  We don't care whether we can run the
5803
# executable--we might be using a cross compiler--we only care whether it
5804
# can be created.  At this point the main configure script has set CC.
5805
we_are_ok=no
5806
echo "int main () { return 0; }" > conftest.c
5807
${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5808
if test $? = 0 ; then
5809
  if test -s conftest || test -s conftest.exe ; then
5810
    we_are_ok=yes
5811
  fi
5812
fi
5813
case $we_are_ok in
5814
  no)
5815
    echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5816
    echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5817
    rm -f conftest*
5818
    exit 1
5819
    ;;
5820
esac
5821
rm -f conftest*
5822
 
5823
# The Solaris /usr/ucb/cc compiler does not appear to work.
5824
case "${host}" in
5825
  sparc-sun-solaris2*)
5826
      CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5827
      if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5828
          could_use=
5829
          test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5830
          if test -d /opt/cygnus/bin ; then
5831
              if test "$could_use" = "" ; then
5832
                  could_use="/opt/cygnus/bin"
5833
              else
5834
                  could_use="$could_use or /opt/cygnus/bin"
5835
              fi
5836
          fi
5837
        if test "$could_use" = "" ; then
5838
            echo "Warning: compilation may fail because you're using"
5839
            echo "/usr/ucb/cc.  You should change your PATH or CC "
5840
            echo "variable and rerun configure."
5841
        else
5842
            echo "Warning: compilation may fail because you're using"
5843
            echo "/usr/ucb/cc, when you should use the C compiler from"
5844
            echo "$could_use.  You should change your"
5845
            echo "PATH or CC variable and rerun configure."
5846
        fi
5847
      fi
5848
  ;;
5849
esac
5850
 
5851
# Decide which environment variable is used to find dynamic libraries.
5852
case "${host}" in
5853
  *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5854
  *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5855
  *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
5856
  *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5857
esac
5858
 
5859
# On systems where the dynamic library environment variable is PATH,
5860
# gcc/ will put dynamic libraries into a subdirectory to avoid adding
5861
# built executables to PATH.
5862
if test "$RPATH_ENVVAR" = PATH; then
5863
  GCC_SHLIB_SUBDIR=/shlib
5864
else
5865
  GCC_SHLIB_SUBDIR=
5866
fi
5867
 
5868
# Record target_configdirs and the configure arguments for target and
5869
# build configuration in Makefile.
5870
target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5871
build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5872
 
5873
# Determine whether gdb needs tk/tcl or not.
5874
# Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5875
# and in that case we want gdb to be built without tk.  Ugh!
5876
# In fact I believe gdb is the *only* package directly dependent on tk,
5877
# so we should be able to put the 'maybe's in unconditionally and
5878
# leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5879
# 100% sure that that's safe though.
5880
 
5881
gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5882
case "$enable_gdbtk" in
5883
  no)
5884
    GDB_TK="" ;;
5885
  yes)
5886
    GDB_TK="${gdb_tk}" ;;
5887
  *)
5888
    # Only add the dependency on gdbtk when GDBtk is part of the gdb
5889
    # distro.  Eventually someone will fix this and move Insight, nee
5890
    # gdbtk to a separate directory.
5891
    if test -d ${srcdir}/gdb/gdbtk ; then
5892
      GDB_TK="${gdb_tk}"
5893
    else
5894
      GDB_TK=""
5895
    fi
5896
    ;;
5897
esac
5898
CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5899
INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5900
 
5901
# Strip out unwanted targets.
5902
 
5903
# While at that, we remove Makefiles if we were started for recursive
5904
# configuration, so that the top-level Makefile reconfigures them,
5905
# like we used to do when configure itself was recursive.
5906
 
5907
# Loop over modules.  $extrasub must be used with care, limiting as
5908
# much as possible the usage of range addresses.  That's because autoconf
5909
# splits the sed script to overcome limits in the number of commands,
5910
# and relying on carefully-timed sed passes may turn out to be very hard
5911
# to maintain later.  In this particular case, you just have to be careful
5912
# not to nest @if/@endif pairs, because configure will not warn you at all.
5913
 
5914
# Check whether --enable-bootstrap or --disable-bootstrap was given.
5915
if test "${enable_bootstrap+set}" = set; then
5916
  enableval="$enable_bootstrap"
5917
 
5918
else
5919
  enable_bootstrap=default
5920
fi;
5921
 
5922
# Issue errors and warnings for invalid/strange bootstrap combinations.
5923
case "$configdirs" in
5924
  *gcc*) have_compiler=yes ;;
5925
  *) have_compiler=no ;;
5926
esac
5927
 
5928
case "$have_compiler:$host:$target:$enable_bootstrap" in
5929
  *:*:*:no) ;;
5930
 
5931
  # Default behavior.  Enable bootstrap if we have a compiler
5932
  # and we are in a native configuration.
5933
  yes:$build:$build:default)
5934
    enable_bootstrap=yes ;;
5935
 
5936
  *:*:*:default)
5937
    enable_bootstrap=no ;;
5938
 
5939
  # We have a compiler and we are in a native configuration, bootstrap is ok
5940
  yes:$build:$build:yes)
5941
    ;;
5942
 
5943
  # Other configurations, but we have a compiler.  Assume the user knows
5944
  # what he's doing.
5945
  yes:*:*:yes)
5946
    { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5947
echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5948
    ;;
5949
 
5950
  # No compiler: if they passed --enable-bootstrap explicitly, fail
5951
  no:*:*:yes)
5952
    { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5953
echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5954
   { (exit 1); exit 1; }; } ;;
5955
 
5956
  # Fail if wrong command line
5957
  *)
5958
    { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5959
echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5960
   { (exit 1); exit 1; }; }
5961
    ;;
5962
esac
5963
 
5964
# Adjust the toplevel makefile according to whether bootstrap was selected.
5965
case "$enable_bootstrap" in
5966
  yes)
5967
    bootstrap_suffix=bootstrap ;;
5968
  no)
5969
    bootstrap_suffix=no-bootstrap ;;
5970
esac
5971
 
5972
for module in ${build_configdirs} ; do
5973
  if test -z "${no_recursion}" \
5974
     && test -f ${build_subdir}/${module}/Makefile; then
5975
    echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5976
    rm -f ${build_subdir}/${module}/Makefile
5977
  fi
5978
  extrasub="$extrasub
5979
/^@if build-$module\$/d
5980
/^@endif build-$module\$/d
5981
/^@if build-$module-$bootstrap_suffix\$/d
5982
/^@endif build-$module-$bootstrap_suffix\$/d"
5983
done
5984
for module in ${configdirs} ; do
5985
  if test -z "${no_recursion}"; then
5986
    for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5987
      if test -f ${file}; then
5988
        echo 1>&2 "*** removing ${file} to force reconfigure"
5989
        rm -f ${file}
5990
      fi
5991
    done
5992
  fi
5993
  extrasub="$extrasub
5994
/^@if $module\$/d
5995
/^@endif $module\$/d
5996
/^@if $module-$bootstrap_suffix\$/d
5997
/^@endif $module-$bootstrap_suffix\$/d"
5998
done
5999
for module in ${target_configdirs} ; do
6000
  if test -z "${no_recursion}" \
6001
     && test -f ${target_subdir}/${module}/Makefile; then
6002
    echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6003
    rm -f ${target_subdir}/${module}/Makefile
6004
  fi
6005
  extrasub="$extrasub
6006
/^@if target-$module\$/d
6007
/^@endif target-$module\$/d
6008
/^@if target-$module-$bootstrap_suffix\$/d
6009
/^@endif target-$module-$bootstrap_suffix\$/d"
6010
done
6011
 
6012
extrasub="$extrasub
6013
/^@if /,/^@endif /d"
6014
 
6015
# Create the serialization dependencies.  This uses a temporary file.
6016
 
6017
# Check whether --enable-serial-configure or --disable-serial-configure was given.
6018
if test "${enable_serial_configure+set}" = set; then
6019
  enableval="$enable_serial_configure"
6020
 
6021
fi;
6022
 
6023
case ${enable_serial_configure} in
6024
  yes)
6025
    enable_serial_build_configure=yes
6026
    enable_serial_host_configure=yes
6027
    enable_serial_target_configure=yes
6028
    ;;
6029
esac
6030
 
6031
# These force 'configure's to be done one at a time, to avoid problems
6032
# with contention over a shared config.cache.
6033
rm -f serdep.tmp
6034
echo '# serdep.tmp' > serdep.tmp
6035
olditem=
6036
test "x${enable_serial_build_configure}" = xyes &&
6037
for item in ${build_configdirs} ; do
6038
  case ${olditem} in
6039
    "") ;;
6040
    *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6041
  esac
6042
  olditem=${item}
6043
done
6044
olditem=
6045
test "x${enable_serial_host_configure}" = xyes &&
6046
for item in ${configdirs} ; do
6047
  case ${olditem} in
6048
    "") ;;
6049
    *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6050
  esac
6051
  olditem=${item}
6052
done
6053
olditem=
6054
test "x${enable_serial_target_configure}" = xyes &&
6055
for item in ${target_configdirs} ; do
6056
  case ${olditem} in
6057
    "") ;;
6058
    *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6059
  esac
6060
  olditem=${item}
6061
done
6062
serialization_dependencies=serdep.tmp
6063
 
6064
 
6065
# Base args.  Strip norecursion, cache-file, srcdir, host, build,
6066
# target, nonopt, and variable assignments.  These are the ones we
6067
# might not want to pass down to subconfigures.  Also strip
6068
# program-prefix, program-suffix, and program-transform-name, so that
6069
# we can pass down a consistent program-transform-name.
6070
baseargs=
6071
keep_next=no
6072
skip_next=no
6073
eval "set -- $ac_configure_args"
6074
for ac_arg
6075
do
6076
  if test X"$skip_next" = X"yes"; then
6077
    skip_next=no
6078
    continue
6079
  fi
6080
  if test X"$keep_next" = X"yes"; then
6081
    case $ac_arg in
6082
      *\'*)
6083
        ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6084
    esac
6085
    baseargs="$baseargs '$ac_arg'"
6086
    keep_next=no
6087
    continue
6088
  fi
6089
 
6090
  # Handle separated arguments.  Based on the logic generated by
6091
  # autoconf 2.59.
6092
  case $ac_arg in
6093
    *=* | --config-cache | -C | -disable-* | --disable-* \
6094
      | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6095
      | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6096
      | -with-* | --with-* | -without-* | --without-* | --x)
6097
      separate_arg=no
6098
      ;;
6099
    -*)
6100
      separate_arg=yes
6101
      ;;
6102
    *)
6103
      separate_arg=no
6104
      ;;
6105
  esac
6106
 
6107
  case "$ac_arg" in
6108
    --no*)
6109
      continue
6110
      ;;
6111
    --c* | \
6112
    --sr* | \
6113
    --ho* | \
6114
    --bu* | \
6115
    --t* | \
6116
    --program-* | \
6117
    -cache_file* | \
6118
    -srcdir* | \
6119
    -host* | \
6120
    -build* | \
6121
    -target* | \
6122
    -program-prefix* | \
6123
    -program-suffix* | \
6124
    -program-transform-name* )
6125
      skip_next=$separate_arg
6126
      continue
6127
      ;;
6128
    -*)
6129
      # An option.  Add it.
6130
      case $ac_arg in
6131
        *\'*)
6132
          ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6133
      esac
6134
      baseargs="$baseargs '$ac_arg'"
6135
      keep_next=$separate_arg
6136
      ;;
6137
    *)
6138
      # Either a variable assignment, or a nonopt (triplet).  Don't
6139
      # pass it down; let the Makefile handle this.
6140
      continue
6141
      ;;
6142
  esac
6143
done
6144
# Remove the initial space we just introduced and, as these will be
6145
# expanded by make, quote '$'.
6146
baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6147
 
6148
# Add in --program-transform-name, after --program-prefix and
6149
# --program-suffix have been applied to it.  Autoconf has already
6150
# doubled dollar signs and backslashes in program_transform_name; we want
6151
# the backslashes un-doubled, and then the entire thing wrapped in single
6152
# quotes, because this will be expanded first by make and then by the shell.
6153
# Also, because we want to override the logic in subdir configure scripts to
6154
# choose program_transform_name, replace any s,x,x, with s,y,y,.
6155
sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" < conftestsed.out
6156
${program_transform_name}
6157
EOF_SED
6158
gcc_transform_name=`cat conftestsed.out`
6159
rm -f conftestsed.out
6160
baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6161
if test "$silent" = yes; then
6162
  baseargs="$baseargs --silent"
6163
fi
6164
 
6165
# For the build-side libraries, we just need to pretend we're native,
6166
# and not use the same cache file.  Multilibs are neither needed nor
6167
# desired.
6168
build_configargs="--cache-file=../config.cache ${baseargs}"
6169
 
6170
# For host modules, accept cache file option, or specification as blank.
6171
case "${cache_file}" in
6172
"") # empty
6173
  cache_file_option="" ;;
6174
/* | [A-Za-z]:[\\/]* ) # absolute path
6175
  cache_file_option="--cache-file=${cache_file}" ;;
6176
*) # relative path
6177
  cache_file_option="--cache-file=../${cache_file}" ;;
6178
esac
6179
 
6180
# Host dirs don't like to share a cache file either, horribly enough.
6181
# This seems to be due to autoconf 2.5x stupidity.
6182
host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6183
 
6184
target_configargs=${baseargs}
6185
 
6186
# Passing a --with-cross-host argument lets the target libraries know
6187
# whether they are being built with a cross-compiler or being built
6188
# native.  However, it would be better to use other mechanisms to make the
6189
# sorts of decisions they want to make on this basis.  Please consider
6190
# this option to be deprecated.  FIXME.
6191
if test x${is_cross_compiler} = xyes ; then
6192
  target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6193
fi
6194
 
6195
# Default to --enable-multilib.
6196
if test x${enable_multilib} = x ; then
6197
  target_configargs="--enable-multilib ${target_configargs}"
6198
fi
6199
 
6200
# Pass --with-newlib if appropriate.  Note that target_configdirs has
6201
# changed from the earlier setting of with_newlib.
6202
if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6203
  target_configargs="--with-newlib ${target_configargs}"
6204
fi
6205
 
6206
# Different target subdirs use different values of certain variables
6207
# (notably CXX).  Worse, multilibs use *lots* of different values.
6208
# Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6209
# it doesn't automatically accept command-line overrides of them.
6210
# This means it's not safe for target subdirs to share a cache file,
6211
# which is disgusting, but there you have it.  Hopefully this can be
6212
# fixed in future.  It's still worthwhile to use a cache file for each
6213
# directory.  I think.
6214
 
6215
# Pass the appropriate --build, --host, --target and --cache-file arguments.
6216
# We need to pass --target, as newer autoconf's requires consistency
6217
# for target_alias and gcc doesn't manage it consistently.
6218
target_configargs="--cache-file=./config.cache ${target_configargs}"
6219
 
6220
FLAGS_FOR_TARGET=
6221
case " $target_configdirs " in
6222
 *" newlib "*)
6223
  case " $target_configargs " in
6224
  *" --with-newlib "*)
6225
   case "$target" in
6226
   *-cygwin*)
6227
     FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/winsup -L$$r/$(TARGET_SUBDIR)/winsup/cygwin -L$$r/$(TARGET_SUBDIR)/winsup/w32api/lib -isystem $$s/winsup/include -isystem $$s/winsup/cygwin/include -isystem $$s/winsup/w32api/include' ;;
6228
   esac
6229
 
6230
   # If we're not building GCC, don't discard standard headers.
6231
   if test -d ${srcdir}/gcc; then
6232
     FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6233
 
6234
     if test "${build}" != "${host}"; then
6235
       # On Canadian crosses, CC_FOR_TARGET will have already been set
6236
       # by `configure', so we won't have an opportunity to add -Bgcc/
6237
       # to it.  This is right: we don't want to search that directory
6238
       # for binaries, but we want the header files in there, so add
6239
       # them explicitly.
6240
       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6241
 
6242
       # Someone might think of using the pre-installed headers on
6243
       # Canadian crosses, in case the installed compiler is not fully
6244
       # compatible with the compiler being built.  In this case, it
6245
       # would be better to flag an error than risking having
6246
       # incompatible object files being constructed.  We can't
6247
       # guarantee that an error will be flagged, but let's hope the
6248
       # compiler will do it, when presented with incompatible header
6249
       # files.
6250
     fi
6251
   fi
6252
 
6253
   case "${target}-${is_cross_compiler}" in
6254
   i[3456789]86-*-linux*-no)
6255
      # Here host == target, so we don't need to build gcc,
6256
      # so we don't want to discard standard headers.
6257
      FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6258
      ;;
6259
   *)
6260
      # If we're building newlib, use its generic headers last, but search
6261
      # for any libc-related directories first (so make it the last -B
6262
      # switch).
6263
      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6264
 
6265
      # If we're building libgloss, find the startup file, simulator library
6266
      # and linker script.
6267
      case " $target_configdirs " in
6268
        *" libgloss "*)
6269
        # Look for startup file, simulator library and maybe linker script.
6270
        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6271
        # Look for libnosys.a in case the target needs it.
6272
        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6273
        # Most targets have the linker script in the source directory.
6274
        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6275
        ;;
6276
      esac
6277
      ;;
6278
   esac
6279
   ;;
6280
  esac
6281
  ;;
6282
esac
6283
case "$target" in
6284
*-mingw*)
6285
  # Can't be handled as Cygwin above since Mingw does not use newlib.
6286
  FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/winsup/mingw -L$$r/$(TARGET_SUBDIR)/winsup/w32api/lib -isystem $$s/winsup/mingw/include -isystem $$s/winsup/w32api/include' ;;
6287
esac
6288
 
6289
# Allow the user to override the flags for
6290
# our build compiler if desired.
6291
if test x"${build}" = x"${host}" ; then
6292
  CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6293
  CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6294
  LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6295
fi
6296
 
6297
# On Canadian crosses, we'll be searching the right directories for
6298
# the previously-installed cross compiler, so don't bother to add
6299
# flags for directories within the install tree of the compiler
6300
# being built; programs in there won't even run.
6301
if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6302
  # Search for pre-installed headers if nothing else fits.
6303
  FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6304
fi
6305
 
6306
if test "x${use_gnu_ld}" = x &&
6307
   echo " ${configdirs} " | grep " ld " > /dev/null ; then
6308
  # Arrange for us to find uninstalled linker scripts.
6309
  FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6310
fi
6311
 
6312
# Search for other target-specific linker scripts and such.
6313
case "${target}" in
6314
  mep*)
6315
    FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6316
    ;;
6317
esac
6318
 
6319
# Makefile fragments.
6320
for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6321
do
6322
  eval fragval=\$$frag
6323
  if test $fragval != /dev/null; then
6324
    eval $frag=${srcdir}/$fragval
6325
  fi
6326
done
6327
 
6328
 
6329
 
6330
 
6331
 
6332
# Miscellanea: directories, flags, etc.
6333
 
6334
 
6335
 
6336
 
6337
 
6338
 
6339
 
6340
 
6341
# Build module lists & subconfigure args.
6342
 
6343
 
6344
 
6345
# Host module lists & subconfigure args.
6346
 
6347
 
6348
 
6349
# Target module lists & subconfigure args.
6350
 
6351
 
6352
 
6353
# Build tools.
6354
 
6355
 
6356
 
6357
 
6358
 
6359
 
6360
 
6361
 
6362
 
6363
 
6364
 
6365
 
6366
 
6367
 
6368
 
6369
 
6370
 
6371
# Generate default definitions for YACC, M4, LEX and other programs that run
6372
# on the build machine.  These are used if the Makefile can't locate these
6373
# programs in objdir.
6374
MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6375
 
6376
for ac_prog in 'bison -y' byacc yacc
6377
do
6378
  # Extract the first word of "$ac_prog", so it can be a program name with args.
6379
set dummy $ac_prog; ac_word=$2
6380
echo "$as_me:$LINENO: checking for $ac_word" >&5
6381
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6382
if test "${ac_cv_prog_YACC+set}" = set; then
6383
  echo $ECHO_N "(cached) $ECHO_C" >&6
6384
else
6385
  if test -n "$YACC"; then
6386
  ac_cv_prog_YACC="$YACC" # Let the user override the test.
6387
else
6388
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6389
for as_dir in $PATH
6390
do
6391
  IFS=$as_save_IFS
6392
  test -z "$as_dir" && as_dir=.
6393
  for ac_exec_ext in '' $ac_executable_extensions; do
6394
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6395
    ac_cv_prog_YACC="$ac_prog"
6396
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6397
    break 2
6398
  fi
6399
done
6400
done
6401
 
6402
fi
6403
fi
6404
YACC=$ac_cv_prog_YACC
6405
if test -n "$YACC"; then
6406
  echo "$as_me:$LINENO: result: $YACC" >&5
6407
echo "${ECHO_T}$YACC" >&6
6408
else
6409
  echo "$as_me:$LINENO: result: no" >&5
6410
echo "${ECHO_T}no" >&6
6411
fi
6412
 
6413
  test -n "$YACC" && break
6414
done
6415
test -n "$YACC" || YACC="$MISSING bison -y"
6416
 
6417
case " $build_configdirs " in
6418
  *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6419
  *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6420
esac
6421
 
6422
for ac_prog in bison
6423
do
6424
  # Extract the first word of "$ac_prog", so it can be a program name with args.
6425
set dummy $ac_prog; ac_word=$2
6426
echo "$as_me:$LINENO: checking for $ac_word" >&5
6427
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6428
if test "${ac_cv_prog_BISON+set}" = set; then
6429
  echo $ECHO_N "(cached) $ECHO_C" >&6
6430
else
6431
  if test -n "$BISON"; then
6432
  ac_cv_prog_BISON="$BISON" # Let the user override the test.
6433
else
6434
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6435
for as_dir in $PATH
6436
do
6437
  IFS=$as_save_IFS
6438
  test -z "$as_dir" && as_dir=.
6439
  for ac_exec_ext in '' $ac_executable_extensions; do
6440
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6441
    ac_cv_prog_BISON="$ac_prog"
6442
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6443
    break 2
6444
  fi
6445
done
6446
done
6447
 
6448
fi
6449
fi
6450
BISON=$ac_cv_prog_BISON
6451
if test -n "$BISON"; then
6452
  echo "$as_me:$LINENO: result: $BISON" >&5
6453
echo "${ECHO_T}$BISON" >&6
6454
else
6455
  echo "$as_me:$LINENO: result: no" >&5
6456
echo "${ECHO_T}no" >&6
6457
fi
6458
 
6459
  test -n "$BISON" && break
6460
done
6461
test -n "$BISON" || BISON="$MISSING bison"
6462
 
6463
case " $build_configdirs " in
6464
  *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6465
esac
6466
 
6467
for ac_prog in gm4 gnum4 m4
6468
do
6469
  # Extract the first word of "$ac_prog", so it can be a program name with args.
6470
set dummy $ac_prog; ac_word=$2
6471
echo "$as_me:$LINENO: checking for $ac_word" >&5
6472
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6473
if test "${ac_cv_prog_M4+set}" = set; then
6474
  echo $ECHO_N "(cached) $ECHO_C" >&6
6475
else
6476
  if test -n "$M4"; then
6477
  ac_cv_prog_M4="$M4" # Let the user override the test.
6478
else
6479
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6480
for as_dir in $PATH
6481
do
6482
  IFS=$as_save_IFS
6483
  test -z "$as_dir" && as_dir=.
6484
  for ac_exec_ext in '' $ac_executable_extensions; do
6485
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6486
    ac_cv_prog_M4="$ac_prog"
6487
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6488
    break 2
6489
  fi
6490
done
6491
done
6492
 
6493
fi
6494
fi
6495
M4=$ac_cv_prog_M4
6496
if test -n "$M4"; then
6497
  echo "$as_me:$LINENO: result: $M4" >&5
6498
echo "${ECHO_T}$M4" >&6
6499
else
6500
  echo "$as_me:$LINENO: result: no" >&5
6501
echo "${ECHO_T}no" >&6
6502
fi
6503
 
6504
  test -n "$M4" && break
6505
done
6506
test -n "$M4" || M4="$MISSING m4"
6507
 
6508
case " $build_configdirs " in
6509
  *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6510
esac
6511
 
6512
for ac_prog in flex lex
6513
do
6514
  # Extract the first word of "$ac_prog", so it can be a program name with args.
6515
set dummy $ac_prog; ac_word=$2
6516
echo "$as_me:$LINENO: checking for $ac_word" >&5
6517
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6518
if test "${ac_cv_prog_LEX+set}" = set; then
6519
  echo $ECHO_N "(cached) $ECHO_C" >&6
6520
else
6521
  if test -n "$LEX"; then
6522
  ac_cv_prog_LEX="$LEX" # Let the user override the test.
6523
else
6524
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6525
for as_dir in $PATH
6526
do
6527
  IFS=$as_save_IFS
6528
  test -z "$as_dir" && as_dir=.
6529
  for ac_exec_ext in '' $ac_executable_extensions; do
6530
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6531
    ac_cv_prog_LEX="$ac_prog"
6532
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6533
    break 2
6534
  fi
6535
done
6536
done
6537
 
6538
fi
6539
fi
6540
LEX=$ac_cv_prog_LEX
6541
if test -n "$LEX"; then
6542
  echo "$as_me:$LINENO: result: $LEX" >&5
6543
echo "${ECHO_T}$LEX" >&6
6544
else
6545
  echo "$as_me:$LINENO: result: no" >&5
6546
echo "${ECHO_T}no" >&6
6547
fi
6548
 
6549
  test -n "$LEX" && break
6550
done
6551
test -n "$LEX" || LEX="$MISSING flex"
6552
 
6553
case " $build_configdirs " in
6554
  *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6555
  *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6556
esac
6557
 
6558
for ac_prog in flex
6559
do
6560
  # Extract the first word of "$ac_prog", so it can be a program name with args.
6561
set dummy $ac_prog; ac_word=$2
6562
echo "$as_me:$LINENO: checking for $ac_word" >&5
6563
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6564
if test "${ac_cv_prog_FLEX+set}" = set; then
6565
  echo $ECHO_N "(cached) $ECHO_C" >&6
6566
else
6567
  if test -n "$FLEX"; then
6568
  ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6569
else
6570
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6571
for as_dir in $PATH
6572
do
6573
  IFS=$as_save_IFS
6574
  test -z "$as_dir" && as_dir=.
6575
  for ac_exec_ext in '' $ac_executable_extensions; do
6576
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6577
    ac_cv_prog_FLEX="$ac_prog"
6578
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6579
    break 2
6580
  fi
6581
done
6582
done
6583
 
6584
fi
6585
fi
6586
FLEX=$ac_cv_prog_FLEX
6587
if test -n "$FLEX"; then
6588
  echo "$as_me:$LINENO: result: $FLEX" >&5
6589
echo "${ECHO_T}$FLEX" >&6
6590
else
6591
  echo "$as_me:$LINENO: result: no" >&5
6592
echo "${ECHO_T}no" >&6
6593
fi
6594
 
6595
  test -n "$FLEX" && break
6596
done
6597
test -n "$FLEX" || FLEX="$MISSING flex"
6598
 
6599
case " $build_configdirs " in
6600
  *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6601
esac
6602
 
6603
for ac_prog in makeinfo
6604
do
6605
  # Extract the first word of "$ac_prog", so it can be a program name with args.
6606
set dummy $ac_prog; ac_word=$2
6607
echo "$as_me:$LINENO: checking for $ac_word" >&5
6608
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6609
if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6610
  echo $ECHO_N "(cached) $ECHO_C" >&6
6611
else
6612
  if test -n "$MAKEINFO"; then
6613
  ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6614
else
6615
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6616
for as_dir in $PATH
6617
do
6618
  IFS=$as_save_IFS
6619
  test -z "$as_dir" && as_dir=.
6620
  for ac_exec_ext in '' $ac_executable_extensions; do
6621
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6622
    ac_cv_prog_MAKEINFO="$ac_prog"
6623
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6624
    break 2
6625
  fi
6626
done
6627
done
6628
 
6629
fi
6630
fi
6631
MAKEINFO=$ac_cv_prog_MAKEINFO
6632
if test -n "$MAKEINFO"; then
6633
  echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6634
echo "${ECHO_T}$MAKEINFO" >&6
6635
else
6636
  echo "$as_me:$LINENO: result: no" >&5
6637
echo "${ECHO_T}no" >&6
6638
fi
6639
 
6640
  test -n "$MAKEINFO" && break
6641
done
6642
test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6643
 
6644
case " $build_configdirs " in
6645
  *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6646
  *)
6647
 
6648
    # For an installed makeinfo, we require it to be from texinfo 4.6 or
6649
    # higher, else we use the "missing" dummy.
6650
    if ${MAKEINFO} --version \
6651
       | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6652
      :
6653
    else
6654
      MAKEINFO="$MISSING makeinfo"
6655
    fi
6656
    ;;
6657
 
6658
esac
6659
 
6660
# FIXME: expect and dejagnu may become build tools?
6661
 
6662
for ac_prog in expect
6663
do
6664
  # Extract the first word of "$ac_prog", so it can be a program name with args.
6665
set dummy $ac_prog; ac_word=$2
6666
echo "$as_me:$LINENO: checking for $ac_word" >&5
6667
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6668
if test "${ac_cv_prog_EXPECT+set}" = set; then
6669
  echo $ECHO_N "(cached) $ECHO_C" >&6
6670
else
6671
  if test -n "$EXPECT"; then
6672
  ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6673
else
6674
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6675
for as_dir in $PATH
6676
do
6677
  IFS=$as_save_IFS
6678
  test -z "$as_dir" && as_dir=.
6679
  for ac_exec_ext in '' $ac_executable_extensions; do
6680
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6681
    ac_cv_prog_EXPECT="$ac_prog"
6682
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6683
    break 2
6684
  fi
6685
done
6686
done
6687
 
6688
fi
6689
fi
6690
EXPECT=$ac_cv_prog_EXPECT
6691
if test -n "$EXPECT"; then
6692
  echo "$as_me:$LINENO: result: $EXPECT" >&5
6693
echo "${ECHO_T}$EXPECT" >&6
6694
else
6695
  echo "$as_me:$LINENO: result: no" >&5
6696
echo "${ECHO_T}no" >&6
6697
fi
6698
 
6699
  test -n "$EXPECT" && break
6700
done
6701
test -n "$EXPECT" || EXPECT="expect"
6702
 
6703
case " $configdirs " in
6704
  *" expect "*)
6705
    test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6706
    ;;
6707
esac
6708
 
6709
for ac_prog in runtest
6710
do
6711
  # Extract the first word of "$ac_prog", so it can be a program name with args.
6712
set dummy $ac_prog; ac_word=$2
6713
echo "$as_me:$LINENO: checking for $ac_word" >&5
6714
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6715
if test "${ac_cv_prog_RUNTEST+set}" = set; then
6716
  echo $ECHO_N "(cached) $ECHO_C" >&6
6717
else
6718
  if test -n "$RUNTEST"; then
6719
  ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6720
else
6721
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6722
for as_dir in $PATH
6723
do
6724
  IFS=$as_save_IFS
6725
  test -z "$as_dir" && as_dir=.
6726
  for ac_exec_ext in '' $ac_executable_extensions; do
6727
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6728
    ac_cv_prog_RUNTEST="$ac_prog"
6729
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6730
    break 2
6731
  fi
6732
done
6733
done
6734
 
6735
fi
6736
fi
6737
RUNTEST=$ac_cv_prog_RUNTEST
6738
if test -n "$RUNTEST"; then
6739
  echo "$as_me:$LINENO: result: $RUNTEST" >&5
6740
echo "${ECHO_T}$RUNTEST" >&6
6741
else
6742
  echo "$as_me:$LINENO: result: no" >&5
6743
echo "${ECHO_T}no" >&6
6744
fi
6745
 
6746
  test -n "$RUNTEST" && break
6747
done
6748
test -n "$RUNTEST" || RUNTEST="runtest"
6749
 
6750
case " $configdirs " in
6751
  *" dejagnu "*)
6752
    test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6753
    ;;
6754
esac
6755
 
6756
 
6757
# Host tools.
6758
ncn_tool_prefix=
6759
test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6760
ncn_target_tool_prefix=
6761
test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6762
 
6763
 
6764
 
6765
if test -n "$AR"; then
6766
  ac_cv_prog_AR=$AR
6767
elif test -n "$ac_cv_prog_AR"; then
6768
  AR=$ac_cv_prog_AR
6769
fi
6770
 
6771
if test -n "$ac_cv_prog_AR"; then
6772
  for ncn_progname in ar; do
6773
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6774
set dummy ${ncn_progname}; ac_word=$2
6775
echo "$as_me:$LINENO: checking for $ac_word" >&5
6776
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6777
if test "${ac_cv_prog_AR+set}" = set; then
6778
  echo $ECHO_N "(cached) $ECHO_C" >&6
6779
else
6780
  if test -n "$AR"; then
6781
  ac_cv_prog_AR="$AR" # Let the user override the test.
6782
else
6783
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6784
for as_dir in $PATH
6785
do
6786
  IFS=$as_save_IFS
6787
  test -z "$as_dir" && as_dir=.
6788
  for ac_exec_ext in '' $ac_executable_extensions; do
6789
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6790
    ac_cv_prog_AR="${ncn_progname}"
6791
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6792
    break 2
6793
  fi
6794
done
6795
done
6796
 
6797
fi
6798
fi
6799
AR=$ac_cv_prog_AR
6800
if test -n "$AR"; then
6801
  echo "$as_me:$LINENO: result: $AR" >&5
6802
echo "${ECHO_T}$AR" >&6
6803
else
6804
  echo "$as_me:$LINENO: result: no" >&5
6805
echo "${ECHO_T}no" >&6
6806
fi
6807
 
6808
  done
6809
fi
6810
 
6811
for ncn_progname in ar; do
6812
  if test -n "$ncn_tool_prefix"; then
6813
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6814
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6815
echo "$as_me:$LINENO: checking for $ac_word" >&5
6816
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6817
if test "${ac_cv_prog_AR+set}" = set; then
6818
  echo $ECHO_N "(cached) $ECHO_C" >&6
6819
else
6820
  if test -n "$AR"; then
6821
  ac_cv_prog_AR="$AR" # Let the user override the test.
6822
else
6823
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6824
for as_dir in $PATH
6825
do
6826
  IFS=$as_save_IFS
6827
  test -z "$as_dir" && as_dir=.
6828
  for ac_exec_ext in '' $ac_executable_extensions; do
6829
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6830
    ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6831
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6832
    break 2
6833
  fi
6834
done
6835
done
6836
 
6837
fi
6838
fi
6839
AR=$ac_cv_prog_AR
6840
if test -n "$AR"; then
6841
  echo "$as_me:$LINENO: result: $AR" >&5
6842
echo "${ECHO_T}$AR" >&6
6843
else
6844
  echo "$as_me:$LINENO: result: no" >&5
6845
echo "${ECHO_T}no" >&6
6846
fi
6847
 
6848
  fi
6849
  if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6850
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6851
set dummy ${ncn_progname}; ac_word=$2
6852
echo "$as_me:$LINENO: checking for $ac_word" >&5
6853
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6854
if test "${ac_cv_prog_AR+set}" = set; then
6855
  echo $ECHO_N "(cached) $ECHO_C" >&6
6856
else
6857
  if test -n "$AR"; then
6858
  ac_cv_prog_AR="$AR" # Let the user override the test.
6859
else
6860
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6861
for as_dir in $PATH
6862
do
6863
  IFS=$as_save_IFS
6864
  test -z "$as_dir" && as_dir=.
6865
  for ac_exec_ext in '' $ac_executable_extensions; do
6866
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6867
    ac_cv_prog_AR="${ncn_progname}"
6868
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6869
    break 2
6870
  fi
6871
done
6872
done
6873
 
6874
fi
6875
fi
6876
AR=$ac_cv_prog_AR
6877
if test -n "$AR"; then
6878
  echo "$as_me:$LINENO: result: $AR" >&5
6879
echo "${ECHO_T}$AR" >&6
6880
else
6881
  echo "$as_me:$LINENO: result: no" >&5
6882
echo "${ECHO_T}no" >&6
6883
fi
6884
 
6885
  fi
6886
  test -n "$ac_cv_prog_AR" && break
6887
done
6888
 
6889
if test -z "$ac_cv_prog_AR" ; then
6890
  set dummy ar
6891
  if test $build = $host ; then
6892
    AR="$2"
6893
  else
6894
    AR="${ncn_tool_prefix}$2"
6895
  fi
6896
fi
6897
 
6898
 
6899
 
6900
if test -n "$AS"; then
6901
  ac_cv_prog_AS=$AS
6902
elif test -n "$ac_cv_prog_AS"; then
6903
  AS=$ac_cv_prog_AS
6904
fi
6905
 
6906
if test -n "$ac_cv_prog_AS"; then
6907
  for ncn_progname in as; do
6908
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6909
set dummy ${ncn_progname}; ac_word=$2
6910
echo "$as_me:$LINENO: checking for $ac_word" >&5
6911
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6912
if test "${ac_cv_prog_AS+set}" = set; then
6913
  echo $ECHO_N "(cached) $ECHO_C" >&6
6914
else
6915
  if test -n "$AS"; then
6916
  ac_cv_prog_AS="$AS" # Let the user override the test.
6917
else
6918
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6919
for as_dir in $PATH
6920
do
6921
  IFS=$as_save_IFS
6922
  test -z "$as_dir" && as_dir=.
6923
  for ac_exec_ext in '' $ac_executable_extensions; do
6924
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6925
    ac_cv_prog_AS="${ncn_progname}"
6926
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6927
    break 2
6928
  fi
6929
done
6930
done
6931
 
6932
fi
6933
fi
6934
AS=$ac_cv_prog_AS
6935
if test -n "$AS"; then
6936
  echo "$as_me:$LINENO: result: $AS" >&5
6937
echo "${ECHO_T}$AS" >&6
6938
else
6939
  echo "$as_me:$LINENO: result: no" >&5
6940
echo "${ECHO_T}no" >&6
6941
fi
6942
 
6943
  done
6944
fi
6945
 
6946
for ncn_progname in as; do
6947
  if test -n "$ncn_tool_prefix"; then
6948
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6949
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6950
echo "$as_me:$LINENO: checking for $ac_word" >&5
6951
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6952
if test "${ac_cv_prog_AS+set}" = set; then
6953
  echo $ECHO_N "(cached) $ECHO_C" >&6
6954
else
6955
  if test -n "$AS"; then
6956
  ac_cv_prog_AS="$AS" # Let the user override the test.
6957
else
6958
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6959
for as_dir in $PATH
6960
do
6961
  IFS=$as_save_IFS
6962
  test -z "$as_dir" && as_dir=.
6963
  for ac_exec_ext in '' $ac_executable_extensions; do
6964
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6965
    ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6966
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6967
    break 2
6968
  fi
6969
done
6970
done
6971
 
6972
fi
6973
fi
6974
AS=$ac_cv_prog_AS
6975
if test -n "$AS"; then
6976
  echo "$as_me:$LINENO: result: $AS" >&5
6977
echo "${ECHO_T}$AS" >&6
6978
else
6979
  echo "$as_me:$LINENO: result: no" >&5
6980
echo "${ECHO_T}no" >&6
6981
fi
6982
 
6983
  fi
6984
  if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6985
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6986
set dummy ${ncn_progname}; ac_word=$2
6987
echo "$as_me:$LINENO: checking for $ac_word" >&5
6988
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6989
if test "${ac_cv_prog_AS+set}" = set; then
6990
  echo $ECHO_N "(cached) $ECHO_C" >&6
6991
else
6992
  if test -n "$AS"; then
6993
  ac_cv_prog_AS="$AS" # Let the user override the test.
6994
else
6995
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6996
for as_dir in $PATH
6997
do
6998
  IFS=$as_save_IFS
6999
  test -z "$as_dir" && as_dir=.
7000
  for ac_exec_ext in '' $ac_executable_extensions; do
7001
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7002
    ac_cv_prog_AS="${ncn_progname}"
7003
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7004
    break 2
7005
  fi
7006
done
7007
done
7008
 
7009
fi
7010
fi
7011
AS=$ac_cv_prog_AS
7012
if test -n "$AS"; then
7013
  echo "$as_me:$LINENO: result: $AS" >&5
7014
echo "${ECHO_T}$AS" >&6
7015
else
7016
  echo "$as_me:$LINENO: result: no" >&5
7017
echo "${ECHO_T}no" >&6
7018
fi
7019
 
7020
  fi
7021
  test -n "$ac_cv_prog_AS" && break
7022
done
7023
 
7024
if test -z "$ac_cv_prog_AS" ; then
7025
  set dummy as
7026
  if test $build = $host ; then
7027
    AS="$2"
7028
  else
7029
    AS="${ncn_tool_prefix}$2"
7030
  fi
7031
fi
7032
 
7033
 
7034
 
7035
if test -n "$DLLTOOL"; then
7036
  ac_cv_prog_DLLTOOL=$DLLTOOL
7037
elif test -n "$ac_cv_prog_DLLTOOL"; then
7038
  DLLTOOL=$ac_cv_prog_DLLTOOL
7039
fi
7040
 
7041
if test -n "$ac_cv_prog_DLLTOOL"; then
7042
  for ncn_progname in dlltool; do
7043
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7044
set dummy ${ncn_progname}; ac_word=$2
7045
echo "$as_me:$LINENO: checking for $ac_word" >&5
7046
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7047
if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7048
  echo $ECHO_N "(cached) $ECHO_C" >&6
7049
else
7050
  if test -n "$DLLTOOL"; then
7051
  ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7052
else
7053
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7054
for as_dir in $PATH
7055
do
7056
  IFS=$as_save_IFS
7057
  test -z "$as_dir" && as_dir=.
7058
  for ac_exec_ext in '' $ac_executable_extensions; do
7059
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7060
    ac_cv_prog_DLLTOOL="${ncn_progname}"
7061
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7062
    break 2
7063
  fi
7064
done
7065
done
7066
 
7067
fi
7068
fi
7069
DLLTOOL=$ac_cv_prog_DLLTOOL
7070
if test -n "$DLLTOOL"; then
7071
  echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7072
echo "${ECHO_T}$DLLTOOL" >&6
7073
else
7074
  echo "$as_me:$LINENO: result: no" >&5
7075
echo "${ECHO_T}no" >&6
7076
fi
7077
 
7078
  done
7079
fi
7080
 
7081
for ncn_progname in dlltool; do
7082
  if test -n "$ncn_tool_prefix"; then
7083
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7084
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7085
echo "$as_me:$LINENO: checking for $ac_word" >&5
7086
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7087
if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7088
  echo $ECHO_N "(cached) $ECHO_C" >&6
7089
else
7090
  if test -n "$DLLTOOL"; then
7091
  ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7092
else
7093
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7094
for as_dir in $PATH
7095
do
7096
  IFS=$as_save_IFS
7097
  test -z "$as_dir" && as_dir=.
7098
  for ac_exec_ext in '' $ac_executable_extensions; do
7099
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7100
    ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7101
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7102
    break 2
7103
  fi
7104
done
7105
done
7106
 
7107
fi
7108
fi
7109
DLLTOOL=$ac_cv_prog_DLLTOOL
7110
if test -n "$DLLTOOL"; then
7111
  echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7112
echo "${ECHO_T}$DLLTOOL" >&6
7113
else
7114
  echo "$as_me:$LINENO: result: no" >&5
7115
echo "${ECHO_T}no" >&6
7116
fi
7117
 
7118
  fi
7119
  if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7120
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7121
set dummy ${ncn_progname}; ac_word=$2
7122
echo "$as_me:$LINENO: checking for $ac_word" >&5
7123
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7124
if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7125
  echo $ECHO_N "(cached) $ECHO_C" >&6
7126
else
7127
  if test -n "$DLLTOOL"; then
7128
  ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7129
else
7130
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7131
for as_dir in $PATH
7132
do
7133
  IFS=$as_save_IFS
7134
  test -z "$as_dir" && as_dir=.
7135
  for ac_exec_ext in '' $ac_executable_extensions; do
7136
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7137
    ac_cv_prog_DLLTOOL="${ncn_progname}"
7138
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7139
    break 2
7140
  fi
7141
done
7142
done
7143
 
7144
fi
7145
fi
7146
DLLTOOL=$ac_cv_prog_DLLTOOL
7147
if test -n "$DLLTOOL"; then
7148
  echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7149
echo "${ECHO_T}$DLLTOOL" >&6
7150
else
7151
  echo "$as_me:$LINENO: result: no" >&5
7152
echo "${ECHO_T}no" >&6
7153
fi
7154
 
7155
  fi
7156
  test -n "$ac_cv_prog_DLLTOOL" && break
7157
done
7158
 
7159
if test -z "$ac_cv_prog_DLLTOOL" ; then
7160
  set dummy dlltool
7161
  if test $build = $host ; then
7162
    DLLTOOL="$2"
7163
  else
7164
    DLLTOOL="${ncn_tool_prefix}$2"
7165
  fi
7166
fi
7167
 
7168
 
7169
 
7170
if test -n "$LD"; then
7171
  ac_cv_prog_LD=$LD
7172
elif test -n "$ac_cv_prog_LD"; then
7173
  LD=$ac_cv_prog_LD
7174
fi
7175
 
7176
if test -n "$ac_cv_prog_LD"; then
7177
  for ncn_progname in ld; do
7178
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7179
set dummy ${ncn_progname}; ac_word=$2
7180
echo "$as_me:$LINENO: checking for $ac_word" >&5
7181
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7182
if test "${ac_cv_prog_LD+set}" = set; then
7183
  echo $ECHO_N "(cached) $ECHO_C" >&6
7184
else
7185
  if test -n "$LD"; then
7186
  ac_cv_prog_LD="$LD" # Let the user override the test.
7187
else
7188
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7189
for as_dir in $PATH
7190
do
7191
  IFS=$as_save_IFS
7192
  test -z "$as_dir" && as_dir=.
7193
  for ac_exec_ext in '' $ac_executable_extensions; do
7194
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7195
    ac_cv_prog_LD="${ncn_progname}"
7196
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7197
    break 2
7198
  fi
7199
done
7200
done
7201
 
7202
fi
7203
fi
7204
LD=$ac_cv_prog_LD
7205
if test -n "$LD"; then
7206
  echo "$as_me:$LINENO: result: $LD" >&5
7207
echo "${ECHO_T}$LD" >&6
7208
else
7209
  echo "$as_me:$LINENO: result: no" >&5
7210
echo "${ECHO_T}no" >&6
7211
fi
7212
 
7213
  done
7214
fi
7215
 
7216
for ncn_progname in ld; do
7217
  if test -n "$ncn_tool_prefix"; then
7218
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7219
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7220
echo "$as_me:$LINENO: checking for $ac_word" >&5
7221
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7222
if test "${ac_cv_prog_LD+set}" = set; then
7223
  echo $ECHO_N "(cached) $ECHO_C" >&6
7224
else
7225
  if test -n "$LD"; then
7226
  ac_cv_prog_LD="$LD" # Let the user override the test.
7227
else
7228
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7229
for as_dir in $PATH
7230
do
7231
  IFS=$as_save_IFS
7232
  test -z "$as_dir" && as_dir=.
7233
  for ac_exec_ext in '' $ac_executable_extensions; do
7234
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7235
    ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7236
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7237
    break 2
7238
  fi
7239
done
7240
done
7241
 
7242
fi
7243
fi
7244
LD=$ac_cv_prog_LD
7245
if test -n "$LD"; then
7246
  echo "$as_me:$LINENO: result: $LD" >&5
7247
echo "${ECHO_T}$LD" >&6
7248
else
7249
  echo "$as_me:$LINENO: result: no" >&5
7250
echo "${ECHO_T}no" >&6
7251
fi
7252
 
7253
  fi
7254
  if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7255
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7256
set dummy ${ncn_progname}; ac_word=$2
7257
echo "$as_me:$LINENO: checking for $ac_word" >&5
7258
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7259
if test "${ac_cv_prog_LD+set}" = set; then
7260
  echo $ECHO_N "(cached) $ECHO_C" >&6
7261
else
7262
  if test -n "$LD"; then
7263
  ac_cv_prog_LD="$LD" # Let the user override the test.
7264
else
7265
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7266
for as_dir in $PATH
7267
do
7268
  IFS=$as_save_IFS
7269
  test -z "$as_dir" && as_dir=.
7270
  for ac_exec_ext in '' $ac_executable_extensions; do
7271
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7272
    ac_cv_prog_LD="${ncn_progname}"
7273
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7274
    break 2
7275
  fi
7276
done
7277
done
7278
 
7279
fi
7280
fi
7281
LD=$ac_cv_prog_LD
7282
if test -n "$LD"; then
7283
  echo "$as_me:$LINENO: result: $LD" >&5
7284
echo "${ECHO_T}$LD" >&6
7285
else
7286
  echo "$as_me:$LINENO: result: no" >&5
7287
echo "${ECHO_T}no" >&6
7288
fi
7289
 
7290
  fi
7291
  test -n "$ac_cv_prog_LD" && break
7292
done
7293
 
7294
if test -z "$ac_cv_prog_LD" ; then
7295
  set dummy ld
7296
  if test $build = $host ; then
7297
    LD="$2"
7298
  else
7299
    LD="${ncn_tool_prefix}$2"
7300
  fi
7301
fi
7302
 
7303
 
7304
 
7305
if test -n "$LIPO"; then
7306
  ac_cv_prog_LIPO=$LIPO
7307
elif test -n "$ac_cv_prog_LIPO"; then
7308
  LIPO=$ac_cv_prog_LIPO
7309
fi
7310
 
7311
if test -n "$ac_cv_prog_LIPO"; then
7312
  for ncn_progname in lipo; do
7313
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7314
set dummy ${ncn_progname}; ac_word=$2
7315
echo "$as_me:$LINENO: checking for $ac_word" >&5
7316
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7317
if test "${ac_cv_prog_LIPO+set}" = set; then
7318
  echo $ECHO_N "(cached) $ECHO_C" >&6
7319
else
7320
  if test -n "$LIPO"; then
7321
  ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7322
else
7323
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7324
for as_dir in $PATH
7325
do
7326
  IFS=$as_save_IFS
7327
  test -z "$as_dir" && as_dir=.
7328
  for ac_exec_ext in '' $ac_executable_extensions; do
7329
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7330
    ac_cv_prog_LIPO="${ncn_progname}"
7331
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7332
    break 2
7333
  fi
7334
done
7335
done
7336
 
7337
fi
7338
fi
7339
LIPO=$ac_cv_prog_LIPO
7340
if test -n "$LIPO"; then
7341
  echo "$as_me:$LINENO: result: $LIPO" >&5
7342
echo "${ECHO_T}$LIPO" >&6
7343
else
7344
  echo "$as_me:$LINENO: result: no" >&5
7345
echo "${ECHO_T}no" >&6
7346
fi
7347
 
7348
  done
7349
fi
7350
 
7351
for ncn_progname in lipo; do
7352
  if test -n "$ncn_tool_prefix"; then
7353
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7354
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7355
echo "$as_me:$LINENO: checking for $ac_word" >&5
7356
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7357
if test "${ac_cv_prog_LIPO+set}" = set; then
7358
  echo $ECHO_N "(cached) $ECHO_C" >&6
7359
else
7360
  if test -n "$LIPO"; then
7361
  ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7362
else
7363
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7364
for as_dir in $PATH
7365
do
7366
  IFS=$as_save_IFS
7367
  test -z "$as_dir" && as_dir=.
7368
  for ac_exec_ext in '' $ac_executable_extensions; do
7369
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7370
    ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7371
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7372
    break 2
7373
  fi
7374
done
7375
done
7376
 
7377
fi
7378
fi
7379
LIPO=$ac_cv_prog_LIPO
7380
if test -n "$LIPO"; then
7381
  echo "$as_me:$LINENO: result: $LIPO" >&5
7382
echo "${ECHO_T}$LIPO" >&6
7383
else
7384
  echo "$as_me:$LINENO: result: no" >&5
7385
echo "${ECHO_T}no" >&6
7386
fi
7387
 
7388
  fi
7389
  if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7390
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7391
set dummy ${ncn_progname}; ac_word=$2
7392
echo "$as_me:$LINENO: checking for $ac_word" >&5
7393
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7394
if test "${ac_cv_prog_LIPO+set}" = set; then
7395
  echo $ECHO_N "(cached) $ECHO_C" >&6
7396
else
7397
  if test -n "$LIPO"; then
7398
  ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7399
else
7400
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7401
for as_dir in $PATH
7402
do
7403
  IFS=$as_save_IFS
7404
  test -z "$as_dir" && as_dir=.
7405
  for ac_exec_ext in '' $ac_executable_extensions; do
7406
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7407
    ac_cv_prog_LIPO="${ncn_progname}"
7408
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7409
    break 2
7410
  fi
7411
done
7412
done
7413
 
7414
fi
7415
fi
7416
LIPO=$ac_cv_prog_LIPO
7417
if test -n "$LIPO"; then
7418
  echo "$as_me:$LINENO: result: $LIPO" >&5
7419
echo "${ECHO_T}$LIPO" >&6
7420
else
7421
  echo "$as_me:$LINENO: result: no" >&5
7422
echo "${ECHO_T}no" >&6
7423
fi
7424
 
7425
  fi
7426
  test -n "$ac_cv_prog_LIPO" && break
7427
done
7428
 
7429
if test -z "$ac_cv_prog_LIPO" ; then
7430
  set dummy lipo
7431
  if test $build = $host ; then
7432
    LIPO="$2"
7433
  else
7434
    LIPO="${ncn_tool_prefix}$2"
7435
  fi
7436
fi
7437
 
7438
 
7439
 
7440
if test -n "$NM"; then
7441
  ac_cv_prog_NM=$NM
7442
elif test -n "$ac_cv_prog_NM"; then
7443
  NM=$ac_cv_prog_NM
7444
fi
7445
 
7446
if test -n "$ac_cv_prog_NM"; then
7447
  for ncn_progname in nm; do
7448
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7449
set dummy ${ncn_progname}; ac_word=$2
7450
echo "$as_me:$LINENO: checking for $ac_word" >&5
7451
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7452
if test "${ac_cv_prog_NM+set}" = set; then
7453
  echo $ECHO_N "(cached) $ECHO_C" >&6
7454
else
7455
  if test -n "$NM"; then
7456
  ac_cv_prog_NM="$NM" # Let the user override the test.
7457
else
7458
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7459
for as_dir in $PATH
7460
do
7461
  IFS=$as_save_IFS
7462
  test -z "$as_dir" && as_dir=.
7463
  for ac_exec_ext in '' $ac_executable_extensions; do
7464
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7465
    ac_cv_prog_NM="${ncn_progname}"
7466
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7467
    break 2
7468
  fi
7469
done
7470
done
7471
 
7472
fi
7473
fi
7474
NM=$ac_cv_prog_NM
7475
if test -n "$NM"; then
7476
  echo "$as_me:$LINENO: result: $NM" >&5
7477
echo "${ECHO_T}$NM" >&6
7478
else
7479
  echo "$as_me:$LINENO: result: no" >&5
7480
echo "${ECHO_T}no" >&6
7481
fi
7482
 
7483
  done
7484
fi
7485
 
7486
for ncn_progname in nm; do
7487
  if test -n "$ncn_tool_prefix"; then
7488
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7489
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7490
echo "$as_me:$LINENO: checking for $ac_word" >&5
7491
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7492
if test "${ac_cv_prog_NM+set}" = set; then
7493
  echo $ECHO_N "(cached) $ECHO_C" >&6
7494
else
7495
  if test -n "$NM"; then
7496
  ac_cv_prog_NM="$NM" # Let the user override the test.
7497
else
7498
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7499
for as_dir in $PATH
7500
do
7501
  IFS=$as_save_IFS
7502
  test -z "$as_dir" && as_dir=.
7503
  for ac_exec_ext in '' $ac_executable_extensions; do
7504
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7505
    ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7506
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7507
    break 2
7508
  fi
7509
done
7510
done
7511
 
7512
fi
7513
fi
7514
NM=$ac_cv_prog_NM
7515
if test -n "$NM"; then
7516
  echo "$as_me:$LINENO: result: $NM" >&5
7517
echo "${ECHO_T}$NM" >&6
7518
else
7519
  echo "$as_me:$LINENO: result: no" >&5
7520
echo "${ECHO_T}no" >&6
7521
fi
7522
 
7523
  fi
7524
  if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7525
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7526
set dummy ${ncn_progname}; ac_word=$2
7527
echo "$as_me:$LINENO: checking for $ac_word" >&5
7528
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7529
if test "${ac_cv_prog_NM+set}" = set; then
7530
  echo $ECHO_N "(cached) $ECHO_C" >&6
7531
else
7532
  if test -n "$NM"; then
7533
  ac_cv_prog_NM="$NM" # Let the user override the test.
7534
else
7535
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7536
for as_dir in $PATH
7537
do
7538
  IFS=$as_save_IFS
7539
  test -z "$as_dir" && as_dir=.
7540
  for ac_exec_ext in '' $ac_executable_extensions; do
7541
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7542
    ac_cv_prog_NM="${ncn_progname}"
7543
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7544
    break 2
7545
  fi
7546
done
7547
done
7548
 
7549
fi
7550
fi
7551
NM=$ac_cv_prog_NM
7552
if test -n "$NM"; then
7553
  echo "$as_me:$LINENO: result: $NM" >&5
7554
echo "${ECHO_T}$NM" >&6
7555
else
7556
  echo "$as_me:$LINENO: result: no" >&5
7557
echo "${ECHO_T}no" >&6
7558
fi
7559
 
7560
  fi
7561
  test -n "$ac_cv_prog_NM" && break
7562
done
7563
 
7564
if test -z "$ac_cv_prog_NM" ; then
7565
  set dummy nm
7566
  if test $build = $host ; then
7567
    NM="$2"
7568
  else
7569
    NM="${ncn_tool_prefix}$2"
7570
  fi
7571
fi
7572
 
7573
 
7574
 
7575
if test -n "$RANLIB"; then
7576
  ac_cv_prog_RANLIB=$RANLIB
7577
elif test -n "$ac_cv_prog_RANLIB"; then
7578
  RANLIB=$ac_cv_prog_RANLIB
7579
fi
7580
 
7581
if test -n "$ac_cv_prog_RANLIB"; then
7582
  for ncn_progname in ranlib; do
7583
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7584
set dummy ${ncn_progname}; ac_word=$2
7585
echo "$as_me:$LINENO: checking for $ac_word" >&5
7586
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7587
if test "${ac_cv_prog_RANLIB+set}" = set; then
7588
  echo $ECHO_N "(cached) $ECHO_C" >&6
7589
else
7590
  if test -n "$RANLIB"; then
7591
  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7592
else
7593
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7594
for as_dir in $PATH
7595
do
7596
  IFS=$as_save_IFS
7597
  test -z "$as_dir" && as_dir=.
7598
  for ac_exec_ext in '' $ac_executable_extensions; do
7599
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7600
    ac_cv_prog_RANLIB="${ncn_progname}"
7601
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7602
    break 2
7603
  fi
7604
done
7605
done
7606
 
7607
fi
7608
fi
7609
RANLIB=$ac_cv_prog_RANLIB
7610
if test -n "$RANLIB"; then
7611
  echo "$as_me:$LINENO: result: $RANLIB" >&5
7612
echo "${ECHO_T}$RANLIB" >&6
7613
else
7614
  echo "$as_me:$LINENO: result: no" >&5
7615
echo "${ECHO_T}no" >&6
7616
fi
7617
 
7618
  done
7619
fi
7620
 
7621
for ncn_progname in ranlib; do
7622
  if test -n "$ncn_tool_prefix"; then
7623
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7624
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7625
echo "$as_me:$LINENO: checking for $ac_word" >&5
7626
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7627
if test "${ac_cv_prog_RANLIB+set}" = set; then
7628
  echo $ECHO_N "(cached) $ECHO_C" >&6
7629
else
7630
  if test -n "$RANLIB"; then
7631
  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7632
else
7633
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7634
for as_dir in $PATH
7635
do
7636
  IFS=$as_save_IFS
7637
  test -z "$as_dir" && as_dir=.
7638
  for ac_exec_ext in '' $ac_executable_extensions; do
7639
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7640
    ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7641
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7642
    break 2
7643
  fi
7644
done
7645
done
7646
 
7647
fi
7648
fi
7649
RANLIB=$ac_cv_prog_RANLIB
7650
if test -n "$RANLIB"; then
7651
  echo "$as_me:$LINENO: result: $RANLIB" >&5
7652
echo "${ECHO_T}$RANLIB" >&6
7653
else
7654
  echo "$as_me:$LINENO: result: no" >&5
7655
echo "${ECHO_T}no" >&6
7656
fi
7657
 
7658
  fi
7659
  if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7660
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7661
set dummy ${ncn_progname}; ac_word=$2
7662
echo "$as_me:$LINENO: checking for $ac_word" >&5
7663
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7664
if test "${ac_cv_prog_RANLIB+set}" = set; then
7665
  echo $ECHO_N "(cached) $ECHO_C" >&6
7666
else
7667
  if test -n "$RANLIB"; then
7668
  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7669
else
7670
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7671
for as_dir in $PATH
7672
do
7673
  IFS=$as_save_IFS
7674
  test -z "$as_dir" && as_dir=.
7675
  for ac_exec_ext in '' $ac_executable_extensions; do
7676
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7677
    ac_cv_prog_RANLIB="${ncn_progname}"
7678
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7679
    break 2
7680
  fi
7681
done
7682
done
7683
 
7684
fi
7685
fi
7686
RANLIB=$ac_cv_prog_RANLIB
7687
if test -n "$RANLIB"; then
7688
  echo "$as_me:$LINENO: result: $RANLIB" >&5
7689
echo "${ECHO_T}$RANLIB" >&6
7690
else
7691
  echo "$as_me:$LINENO: result: no" >&5
7692
echo "${ECHO_T}no" >&6
7693
fi
7694
 
7695
  fi
7696
  test -n "$ac_cv_prog_RANLIB" && break
7697
done
7698
 
7699
if test -z "$ac_cv_prog_RANLIB" ; then
7700
  RANLIB=":"
7701
fi
7702
 
7703
 
7704
 
7705
if test -n "$STRIP"; then
7706
  ac_cv_prog_STRIP=$STRIP
7707
elif test -n "$ac_cv_prog_STRIP"; then
7708
  STRIP=$ac_cv_prog_STRIP
7709
fi
7710
 
7711
if test -n "$ac_cv_prog_STRIP"; then
7712
  for ncn_progname in strip; do
7713
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7714
set dummy ${ncn_progname}; ac_word=$2
7715
echo "$as_me:$LINENO: checking for $ac_word" >&5
7716
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7717
if test "${ac_cv_prog_STRIP+set}" = set; then
7718
  echo $ECHO_N "(cached) $ECHO_C" >&6
7719
else
7720
  if test -n "$STRIP"; then
7721
  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7722
else
7723
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7724
for as_dir in $PATH
7725
do
7726
  IFS=$as_save_IFS
7727
  test -z "$as_dir" && as_dir=.
7728
  for ac_exec_ext in '' $ac_executable_extensions; do
7729
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7730
    ac_cv_prog_STRIP="${ncn_progname}"
7731
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7732
    break 2
7733
  fi
7734
done
7735
done
7736
 
7737
fi
7738
fi
7739
STRIP=$ac_cv_prog_STRIP
7740
if test -n "$STRIP"; then
7741
  echo "$as_me:$LINENO: result: $STRIP" >&5
7742
echo "${ECHO_T}$STRIP" >&6
7743
else
7744
  echo "$as_me:$LINENO: result: no" >&5
7745
echo "${ECHO_T}no" >&6
7746
fi
7747
 
7748
  done
7749
fi
7750
 
7751
for ncn_progname in strip; do
7752
  if test -n "$ncn_tool_prefix"; then
7753
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7754
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7755
echo "$as_me:$LINENO: checking for $ac_word" >&5
7756
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7757
if test "${ac_cv_prog_STRIP+set}" = set; then
7758
  echo $ECHO_N "(cached) $ECHO_C" >&6
7759
else
7760
  if test -n "$STRIP"; then
7761
  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7762
else
7763
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7764
for as_dir in $PATH
7765
do
7766
  IFS=$as_save_IFS
7767
  test -z "$as_dir" && as_dir=.
7768
  for ac_exec_ext in '' $ac_executable_extensions; do
7769
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7770
    ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7771
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7772
    break 2
7773
  fi
7774
done
7775
done
7776
 
7777
fi
7778
fi
7779
STRIP=$ac_cv_prog_STRIP
7780
if test -n "$STRIP"; then
7781
  echo "$as_me:$LINENO: result: $STRIP" >&5
7782
echo "${ECHO_T}$STRIP" >&6
7783
else
7784
  echo "$as_me:$LINENO: result: no" >&5
7785
echo "${ECHO_T}no" >&6
7786
fi
7787
 
7788
  fi
7789
  if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7790
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7791
set dummy ${ncn_progname}; ac_word=$2
7792
echo "$as_me:$LINENO: checking for $ac_word" >&5
7793
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7794
if test "${ac_cv_prog_STRIP+set}" = set; then
7795
  echo $ECHO_N "(cached) $ECHO_C" >&6
7796
else
7797
  if test -n "$STRIP"; then
7798
  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7799
else
7800
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7801
for as_dir in $PATH
7802
do
7803
  IFS=$as_save_IFS
7804
  test -z "$as_dir" && as_dir=.
7805
  for ac_exec_ext in '' $ac_executable_extensions; do
7806
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7807
    ac_cv_prog_STRIP="${ncn_progname}"
7808
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7809
    break 2
7810
  fi
7811
done
7812
done
7813
 
7814
fi
7815
fi
7816
STRIP=$ac_cv_prog_STRIP
7817
if test -n "$STRIP"; then
7818
  echo "$as_me:$LINENO: result: $STRIP" >&5
7819
echo "${ECHO_T}$STRIP" >&6
7820
else
7821
  echo "$as_me:$LINENO: result: no" >&5
7822
echo "${ECHO_T}no" >&6
7823
fi
7824
 
7825
  fi
7826
  test -n "$ac_cv_prog_STRIP" && break
7827
done
7828
 
7829
if test -z "$ac_cv_prog_STRIP" ; then
7830
  STRIP=":"
7831
fi
7832
 
7833
 
7834
 
7835
if test -n "$WINDRES"; then
7836
  ac_cv_prog_WINDRES=$WINDRES
7837
elif test -n "$ac_cv_prog_WINDRES"; then
7838
  WINDRES=$ac_cv_prog_WINDRES
7839
fi
7840
 
7841
if test -n "$ac_cv_prog_WINDRES"; then
7842
  for ncn_progname in windres; do
7843
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7844
set dummy ${ncn_progname}; ac_word=$2
7845
echo "$as_me:$LINENO: checking for $ac_word" >&5
7846
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7847
if test "${ac_cv_prog_WINDRES+set}" = set; then
7848
  echo $ECHO_N "(cached) $ECHO_C" >&6
7849
else
7850
  if test -n "$WINDRES"; then
7851
  ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7852
else
7853
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7854
for as_dir in $PATH
7855
do
7856
  IFS=$as_save_IFS
7857
  test -z "$as_dir" && as_dir=.
7858
  for ac_exec_ext in '' $ac_executable_extensions; do
7859
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7860
    ac_cv_prog_WINDRES="${ncn_progname}"
7861
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7862
    break 2
7863
  fi
7864
done
7865
done
7866
 
7867
fi
7868
fi
7869
WINDRES=$ac_cv_prog_WINDRES
7870
if test -n "$WINDRES"; then
7871
  echo "$as_me:$LINENO: result: $WINDRES" >&5
7872
echo "${ECHO_T}$WINDRES" >&6
7873
else
7874
  echo "$as_me:$LINENO: result: no" >&5
7875
echo "${ECHO_T}no" >&6
7876
fi
7877
 
7878
  done
7879
fi
7880
 
7881
for ncn_progname in windres; do
7882
  if test -n "$ncn_tool_prefix"; then
7883
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7884
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7885
echo "$as_me:$LINENO: checking for $ac_word" >&5
7886
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7887
if test "${ac_cv_prog_WINDRES+set}" = set; then
7888
  echo $ECHO_N "(cached) $ECHO_C" >&6
7889
else
7890
  if test -n "$WINDRES"; then
7891
  ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7892
else
7893
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7894
for as_dir in $PATH
7895
do
7896
  IFS=$as_save_IFS
7897
  test -z "$as_dir" && as_dir=.
7898
  for ac_exec_ext in '' $ac_executable_extensions; do
7899
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7900
    ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7901
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7902
    break 2
7903
  fi
7904
done
7905
done
7906
 
7907
fi
7908
fi
7909
WINDRES=$ac_cv_prog_WINDRES
7910
if test -n "$WINDRES"; then
7911
  echo "$as_me:$LINENO: result: $WINDRES" >&5
7912
echo "${ECHO_T}$WINDRES" >&6
7913
else
7914
  echo "$as_me:$LINENO: result: no" >&5
7915
echo "${ECHO_T}no" >&6
7916
fi
7917
 
7918
  fi
7919
  if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7920
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7921
set dummy ${ncn_progname}; ac_word=$2
7922
echo "$as_me:$LINENO: checking for $ac_word" >&5
7923
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7924
if test "${ac_cv_prog_WINDRES+set}" = set; then
7925
  echo $ECHO_N "(cached) $ECHO_C" >&6
7926
else
7927
  if test -n "$WINDRES"; then
7928
  ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7929
else
7930
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7931
for as_dir in $PATH
7932
do
7933
  IFS=$as_save_IFS
7934
  test -z "$as_dir" && as_dir=.
7935
  for ac_exec_ext in '' $ac_executable_extensions; do
7936
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7937
    ac_cv_prog_WINDRES="${ncn_progname}"
7938
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7939
    break 2
7940
  fi
7941
done
7942
done
7943
 
7944
fi
7945
fi
7946
WINDRES=$ac_cv_prog_WINDRES
7947
if test -n "$WINDRES"; then
7948
  echo "$as_me:$LINENO: result: $WINDRES" >&5
7949
echo "${ECHO_T}$WINDRES" >&6
7950
else
7951
  echo "$as_me:$LINENO: result: no" >&5
7952
echo "${ECHO_T}no" >&6
7953
fi
7954
 
7955
  fi
7956
  test -n "$ac_cv_prog_WINDRES" && break
7957
done
7958
 
7959
if test -z "$ac_cv_prog_WINDRES" ; then
7960
  set dummy windres
7961
  if test $build = $host ; then
7962
    WINDRES="$2"
7963
  else
7964
    WINDRES="${ncn_tool_prefix}$2"
7965
  fi
7966
fi
7967
 
7968
 
7969
 
7970
if test -n "$WINDMC"; then
7971
  ac_cv_prog_WINDMC=$WINDMC
7972
elif test -n "$ac_cv_prog_WINDMC"; then
7973
  WINDMC=$ac_cv_prog_WINDMC
7974
fi
7975
 
7976
if test -n "$ac_cv_prog_WINDMC"; then
7977
  for ncn_progname in windmc; do
7978
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7979
set dummy ${ncn_progname}; ac_word=$2
7980
echo "$as_me:$LINENO: checking for $ac_word" >&5
7981
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7982
if test "${ac_cv_prog_WINDMC+set}" = set; then
7983
  echo $ECHO_N "(cached) $ECHO_C" >&6
7984
else
7985
  if test -n "$WINDMC"; then
7986
  ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7987
else
7988
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7989
for as_dir in $PATH
7990
do
7991
  IFS=$as_save_IFS
7992
  test -z "$as_dir" && as_dir=.
7993
  for ac_exec_ext in '' $ac_executable_extensions; do
7994
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7995
    ac_cv_prog_WINDMC="${ncn_progname}"
7996
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7997
    break 2
7998
  fi
7999
done
8000
done
8001
 
8002
fi
8003
fi
8004
WINDMC=$ac_cv_prog_WINDMC
8005
if test -n "$WINDMC"; then
8006
  echo "$as_me:$LINENO: result: $WINDMC" >&5
8007
echo "${ECHO_T}$WINDMC" >&6
8008
else
8009
  echo "$as_me:$LINENO: result: no" >&5
8010
echo "${ECHO_T}no" >&6
8011
fi
8012
 
8013
  done
8014
fi
8015
 
8016
for ncn_progname in windmc; do
8017
  if test -n "$ncn_tool_prefix"; then
8018
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8019
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8020
echo "$as_me:$LINENO: checking for $ac_word" >&5
8021
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8022
if test "${ac_cv_prog_WINDMC+set}" = set; then
8023
  echo $ECHO_N "(cached) $ECHO_C" >&6
8024
else
8025
  if test -n "$WINDMC"; then
8026
  ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8027
else
8028
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8029
for as_dir in $PATH
8030
do
8031
  IFS=$as_save_IFS
8032
  test -z "$as_dir" && as_dir=.
8033
  for ac_exec_ext in '' $ac_executable_extensions; do
8034
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8035
    ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8036
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8037
    break 2
8038
  fi
8039
done
8040
done
8041
 
8042
fi
8043
fi
8044
WINDMC=$ac_cv_prog_WINDMC
8045
if test -n "$WINDMC"; then
8046
  echo "$as_me:$LINENO: result: $WINDMC" >&5
8047
echo "${ECHO_T}$WINDMC" >&6
8048
else
8049
  echo "$as_me:$LINENO: result: no" >&5
8050
echo "${ECHO_T}no" >&6
8051
fi
8052
 
8053
  fi
8054
  if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8055
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8056
set dummy ${ncn_progname}; ac_word=$2
8057
echo "$as_me:$LINENO: checking for $ac_word" >&5
8058
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8059
if test "${ac_cv_prog_WINDMC+set}" = set; then
8060
  echo $ECHO_N "(cached) $ECHO_C" >&6
8061
else
8062
  if test -n "$WINDMC"; then
8063
  ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8064
else
8065
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8066
for as_dir in $PATH
8067
do
8068
  IFS=$as_save_IFS
8069
  test -z "$as_dir" && as_dir=.
8070
  for ac_exec_ext in '' $ac_executable_extensions; do
8071
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8072
    ac_cv_prog_WINDMC="${ncn_progname}"
8073
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8074
    break 2
8075
  fi
8076
done
8077
done
8078
 
8079
fi
8080
fi
8081
WINDMC=$ac_cv_prog_WINDMC
8082
if test -n "$WINDMC"; then
8083
  echo "$as_me:$LINENO: result: $WINDMC" >&5
8084
echo "${ECHO_T}$WINDMC" >&6
8085
else
8086
  echo "$as_me:$LINENO: result: no" >&5
8087
echo "${ECHO_T}no" >&6
8088
fi
8089
 
8090
  fi
8091
  test -n "$ac_cv_prog_WINDMC" && break
8092
done
8093
 
8094
if test -z "$ac_cv_prog_WINDMC" ; then
8095
  set dummy windmc
8096
  if test $build = $host ; then
8097
    WINDMC="$2"
8098
  else
8099
    WINDMC="${ncn_tool_prefix}$2"
8100
  fi
8101
fi
8102
 
8103
 
8104
 
8105
if test -n "$OBJCOPY"; then
8106
  ac_cv_prog_OBJCOPY=$OBJCOPY
8107
elif test -n "$ac_cv_prog_OBJCOPY"; then
8108
  OBJCOPY=$ac_cv_prog_OBJCOPY
8109
fi
8110
 
8111
if test -n "$ac_cv_prog_OBJCOPY"; then
8112
  for ncn_progname in objcopy; do
8113
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8114
set dummy ${ncn_progname}; ac_word=$2
8115
echo "$as_me:$LINENO: checking for $ac_word" >&5
8116
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8117
if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8118
  echo $ECHO_N "(cached) $ECHO_C" >&6
8119
else
8120
  if test -n "$OBJCOPY"; then
8121
  ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8122
else
8123
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8124
for as_dir in $PATH
8125
do
8126
  IFS=$as_save_IFS
8127
  test -z "$as_dir" && as_dir=.
8128
  for ac_exec_ext in '' $ac_executable_extensions; do
8129
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8130
    ac_cv_prog_OBJCOPY="${ncn_progname}"
8131
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8132
    break 2
8133
  fi
8134
done
8135
done
8136
 
8137
fi
8138
fi
8139
OBJCOPY=$ac_cv_prog_OBJCOPY
8140
if test -n "$OBJCOPY"; then
8141
  echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8142
echo "${ECHO_T}$OBJCOPY" >&6
8143
else
8144
  echo "$as_me:$LINENO: result: no" >&5
8145
echo "${ECHO_T}no" >&6
8146
fi
8147
 
8148
  done
8149
fi
8150
 
8151
for ncn_progname in objcopy; do
8152
  if test -n "$ncn_tool_prefix"; then
8153
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8154
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8155
echo "$as_me:$LINENO: checking for $ac_word" >&5
8156
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8157
if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8158
  echo $ECHO_N "(cached) $ECHO_C" >&6
8159
else
8160
  if test -n "$OBJCOPY"; then
8161
  ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8162
else
8163
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8164
for as_dir in $PATH
8165
do
8166
  IFS=$as_save_IFS
8167
  test -z "$as_dir" && as_dir=.
8168
  for ac_exec_ext in '' $ac_executable_extensions; do
8169
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8170
    ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8171
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8172
    break 2
8173
  fi
8174
done
8175
done
8176
 
8177
fi
8178
fi
8179
OBJCOPY=$ac_cv_prog_OBJCOPY
8180
if test -n "$OBJCOPY"; then
8181
  echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8182
echo "${ECHO_T}$OBJCOPY" >&6
8183
else
8184
  echo "$as_me:$LINENO: result: no" >&5
8185
echo "${ECHO_T}no" >&6
8186
fi
8187
 
8188
  fi
8189
  if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8190
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8191
set dummy ${ncn_progname}; ac_word=$2
8192
echo "$as_me:$LINENO: checking for $ac_word" >&5
8193
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8194
if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8195
  echo $ECHO_N "(cached) $ECHO_C" >&6
8196
else
8197
  if test -n "$OBJCOPY"; then
8198
  ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8199
else
8200
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8201
for as_dir in $PATH
8202
do
8203
  IFS=$as_save_IFS
8204
  test -z "$as_dir" && as_dir=.
8205
  for ac_exec_ext in '' $ac_executable_extensions; do
8206
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8207
    ac_cv_prog_OBJCOPY="${ncn_progname}"
8208
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8209
    break 2
8210
  fi
8211
done
8212
done
8213
 
8214
fi
8215
fi
8216
OBJCOPY=$ac_cv_prog_OBJCOPY
8217
if test -n "$OBJCOPY"; then
8218
  echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8219
echo "${ECHO_T}$OBJCOPY" >&6
8220
else
8221
  echo "$as_me:$LINENO: result: no" >&5
8222
echo "${ECHO_T}no" >&6
8223
fi
8224
 
8225
  fi
8226
  test -n "$ac_cv_prog_OBJCOPY" && break
8227
done
8228
 
8229
if test -z "$ac_cv_prog_OBJCOPY" ; then
8230
  set dummy objcopy
8231
  if test $build = $host ; then
8232
    OBJCOPY="$2"
8233
  else
8234
    OBJCOPY="${ncn_tool_prefix}$2"
8235
  fi
8236
fi
8237
 
8238
 
8239
 
8240
if test -n "$OBJDUMP"; then
8241
  ac_cv_prog_OBJDUMP=$OBJDUMP
8242
elif test -n "$ac_cv_prog_OBJDUMP"; then
8243
  OBJDUMP=$ac_cv_prog_OBJDUMP
8244
fi
8245
 
8246
if test -n "$ac_cv_prog_OBJDUMP"; then
8247
  for ncn_progname in objdump; do
8248
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8249
set dummy ${ncn_progname}; ac_word=$2
8250
echo "$as_me:$LINENO: checking for $ac_word" >&5
8251
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8252
if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8253
  echo $ECHO_N "(cached) $ECHO_C" >&6
8254
else
8255
  if test -n "$OBJDUMP"; then
8256
  ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8257
else
8258
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8259
for as_dir in $PATH
8260
do
8261
  IFS=$as_save_IFS
8262
  test -z "$as_dir" && as_dir=.
8263
  for ac_exec_ext in '' $ac_executable_extensions; do
8264
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8265
    ac_cv_prog_OBJDUMP="${ncn_progname}"
8266
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8267
    break 2
8268
  fi
8269
done
8270
done
8271
 
8272
fi
8273
fi
8274
OBJDUMP=$ac_cv_prog_OBJDUMP
8275
if test -n "$OBJDUMP"; then
8276
  echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8277
echo "${ECHO_T}$OBJDUMP" >&6
8278
else
8279
  echo "$as_me:$LINENO: result: no" >&5
8280
echo "${ECHO_T}no" >&6
8281
fi
8282
 
8283
  done
8284
fi
8285
 
8286
for ncn_progname in objdump; do
8287
  if test -n "$ncn_tool_prefix"; then
8288
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8289
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8290
echo "$as_me:$LINENO: checking for $ac_word" >&5
8291
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8292
if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8293
  echo $ECHO_N "(cached) $ECHO_C" >&6
8294
else
8295
  if test -n "$OBJDUMP"; then
8296
  ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8297
else
8298
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8299
for as_dir in $PATH
8300
do
8301
  IFS=$as_save_IFS
8302
  test -z "$as_dir" && as_dir=.
8303
  for ac_exec_ext in '' $ac_executable_extensions; do
8304
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8305
    ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8306
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8307
    break 2
8308
  fi
8309
done
8310
done
8311
 
8312
fi
8313
fi
8314
OBJDUMP=$ac_cv_prog_OBJDUMP
8315
if test -n "$OBJDUMP"; then
8316
  echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8317
echo "${ECHO_T}$OBJDUMP" >&6
8318
else
8319
  echo "$as_me:$LINENO: result: no" >&5
8320
echo "${ECHO_T}no" >&6
8321
fi
8322
 
8323
  fi
8324
  if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8325
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8326
set dummy ${ncn_progname}; ac_word=$2
8327
echo "$as_me:$LINENO: checking for $ac_word" >&5
8328
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8329
if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8330
  echo $ECHO_N "(cached) $ECHO_C" >&6
8331
else
8332
  if test -n "$OBJDUMP"; then
8333
  ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8334
else
8335
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8336
for as_dir in $PATH
8337
do
8338
  IFS=$as_save_IFS
8339
  test -z "$as_dir" && as_dir=.
8340
  for ac_exec_ext in '' $ac_executable_extensions; do
8341
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8342
    ac_cv_prog_OBJDUMP="${ncn_progname}"
8343
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8344
    break 2
8345
  fi
8346
done
8347
done
8348
 
8349
fi
8350
fi
8351
OBJDUMP=$ac_cv_prog_OBJDUMP
8352
if test -n "$OBJDUMP"; then
8353
  echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8354
echo "${ECHO_T}$OBJDUMP" >&6
8355
else
8356
  echo "$as_me:$LINENO: result: no" >&5
8357
echo "${ECHO_T}no" >&6
8358
fi
8359
 
8360
  fi
8361
  test -n "$ac_cv_prog_OBJDUMP" && break
8362
done
8363
 
8364
if test -z "$ac_cv_prog_OBJDUMP" ; then
8365
  set dummy objdump
8366
  if test $build = $host ; then
8367
    OBJDUMP="$2"
8368
  else
8369
    OBJDUMP="${ncn_tool_prefix}$2"
8370
  fi
8371
fi
8372
 
8373
 
8374
 
8375
 
8376
 
8377
 
8378
# Target tools.
8379
 
8380
# Check whether --with-build-time-tools or --without-build-time-tools was given.
8381
if test "${with_build_time_tools+set}" = set; then
8382
  withval="$with_build_time_tools"
8383
  case x"$withval" in
8384
     x/*) ;;
8385
     *)
8386
       with_build_time_tools=
8387
       { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8388
echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8389
       ;;
8390
   esac
8391
else
8392
  with_build_time_tools=
8393
fi;
8394
 
8395
 
8396
 
8397
if test -n "$CC_FOR_TARGET"; then
8398
  ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8399
elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8400
  CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8401
fi
8402
 
8403
if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8404
  for ncn_progname in cc gcc; do
8405
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8406
set dummy ${ncn_progname}; ac_word=$2
8407
echo "$as_me:$LINENO: checking for $ac_word" >&5
8408
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8409
if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8410
  echo $ECHO_N "(cached) $ECHO_C" >&6
8411
else
8412
  if test -n "$CC_FOR_TARGET"; then
8413
  ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8414
else
8415
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8416
for as_dir in $PATH
8417
do
8418
  IFS=$as_save_IFS
8419
  test -z "$as_dir" && as_dir=.
8420
  for ac_exec_ext in '' $ac_executable_extensions; do
8421
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8422
    ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8423
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8424
    break 2
8425
  fi
8426
done
8427
done
8428
 
8429
fi
8430
fi
8431
CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8432
if test -n "$CC_FOR_TARGET"; then
8433
  echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8434
echo "${ECHO_T}$CC_FOR_TARGET" >&6
8435
else
8436
  echo "$as_me:$LINENO: result: no" >&5
8437
echo "${ECHO_T}no" >&6
8438
fi
8439
 
8440
  done
8441
fi
8442
 
8443
if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8444
  for ncn_progname in cc gcc; do
8445
    echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8446
echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8447
    if test -x $with_build_time_tools/${ncn_progname}; then
8448
      ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8449
      echo "$as_me:$LINENO: result: yes" >&5
8450
echo "${ECHO_T}yes" >&6
8451
      break
8452
    else
8453
      echo "$as_me:$LINENO: result: no" >&5
8454
echo "${ECHO_T}no" >&6
8455
    fi
8456
  done
8457
fi
8458
 
8459
if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8460
  for ncn_progname in cc gcc; do
8461
    if test -n "$ncn_target_tool_prefix"; then
8462
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8463
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8464
echo "$as_me:$LINENO: checking for $ac_word" >&5
8465
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8466
if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8467
  echo $ECHO_N "(cached) $ECHO_C" >&6
8468
else
8469
  if test -n "$CC_FOR_TARGET"; then
8470
  ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8471
else
8472
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8473
for as_dir in $PATH
8474
do
8475
  IFS=$as_save_IFS
8476
  test -z "$as_dir" && as_dir=.
8477
  for ac_exec_ext in '' $ac_executable_extensions; do
8478
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8479
    ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8480
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8481
    break 2
8482
  fi
8483
done
8484
done
8485
 
8486
fi
8487
fi
8488
CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8489
if test -n "$CC_FOR_TARGET"; then
8490
  echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8491
echo "${ECHO_T}$CC_FOR_TARGET" >&6
8492
else
8493
  echo "$as_me:$LINENO: result: no" >&5
8494
echo "${ECHO_T}no" >&6
8495
fi
8496
 
8497
    fi
8498
    if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8499
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8500
set dummy ${ncn_progname}; ac_word=$2
8501
echo "$as_me:$LINENO: checking for $ac_word" >&5
8502
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8503
if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8504
  echo $ECHO_N "(cached) $ECHO_C" >&6
8505
else
8506
  if test -n "$CC_FOR_TARGET"; then
8507
  ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8508
else
8509
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8510
for as_dir in $PATH
8511
do
8512
  IFS=$as_save_IFS
8513
  test -z "$as_dir" && as_dir=.
8514
  for ac_exec_ext in '' $ac_executable_extensions; do
8515
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8516
    ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8517
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8518
    break 2
8519
  fi
8520
done
8521
done
8522
 
8523
fi
8524
fi
8525
CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8526
if test -n "$CC_FOR_TARGET"; then
8527
  echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8528
echo "${ECHO_T}$CC_FOR_TARGET" >&6
8529
else
8530
  echo "$as_me:$LINENO: result: no" >&5
8531
echo "${ECHO_T}no" >&6
8532
fi
8533
 
8534
    fi
8535
    test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8536
  done
8537
fi
8538
 
8539
if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8540
  set dummy cc gcc
8541
  if test $build = $target ; then
8542
    CC_FOR_TARGET="$2"
8543
  else
8544
    CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8545
  fi
8546
else
8547
  CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8548
fi
8549
 
8550
 
8551
 
8552
if test -n "$CXX_FOR_TARGET"; then
8553
  ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8554
elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8555
  CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8556
fi
8557
 
8558
if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8559
  for ncn_progname in c++ g++ cxx gxx; do
8560
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8561
set dummy ${ncn_progname}; ac_word=$2
8562
echo "$as_me:$LINENO: checking for $ac_word" >&5
8563
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8564
if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8565
  echo $ECHO_N "(cached) $ECHO_C" >&6
8566
else
8567
  if test -n "$CXX_FOR_TARGET"; then
8568
  ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8569
else
8570
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8571
for as_dir in $PATH
8572
do
8573
  IFS=$as_save_IFS
8574
  test -z "$as_dir" && as_dir=.
8575
  for ac_exec_ext in '' $ac_executable_extensions; do
8576
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8577
    ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8578
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8579
    break 2
8580
  fi
8581
done
8582
done
8583
 
8584
fi
8585
fi
8586
CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8587
if test -n "$CXX_FOR_TARGET"; then
8588
  echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8589
echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8590
else
8591
  echo "$as_me:$LINENO: result: no" >&5
8592
echo "${ECHO_T}no" >&6
8593
fi
8594
 
8595
  done
8596
fi
8597
 
8598
if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8599
  for ncn_progname in c++ g++ cxx gxx; do
8600
    echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8601
echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8602
    if test -x $with_build_time_tools/${ncn_progname}; then
8603
      ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8604
      echo "$as_me:$LINENO: result: yes" >&5
8605
echo "${ECHO_T}yes" >&6
8606
      break
8607
    else
8608
      echo "$as_me:$LINENO: result: no" >&5
8609
echo "${ECHO_T}no" >&6
8610
    fi
8611
  done
8612
fi
8613
 
8614
if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8615
  for ncn_progname in c++ g++ cxx gxx; do
8616
    if test -n "$ncn_target_tool_prefix"; then
8617
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8618
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8619
echo "$as_me:$LINENO: checking for $ac_word" >&5
8620
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8621
if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8622
  echo $ECHO_N "(cached) $ECHO_C" >&6
8623
else
8624
  if test -n "$CXX_FOR_TARGET"; then
8625
  ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8626
else
8627
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8628
for as_dir in $PATH
8629
do
8630
  IFS=$as_save_IFS
8631
  test -z "$as_dir" && as_dir=.
8632
  for ac_exec_ext in '' $ac_executable_extensions; do
8633
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8634
    ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8635
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8636
    break 2
8637
  fi
8638
done
8639
done
8640
 
8641
fi
8642
fi
8643
CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8644
if test -n "$CXX_FOR_TARGET"; then
8645
  echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8646
echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8647
else
8648
  echo "$as_me:$LINENO: result: no" >&5
8649
echo "${ECHO_T}no" >&6
8650
fi
8651
 
8652
    fi
8653
    if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8654
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8655
set dummy ${ncn_progname}; ac_word=$2
8656
echo "$as_me:$LINENO: checking for $ac_word" >&5
8657
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8658
if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8659
  echo $ECHO_N "(cached) $ECHO_C" >&6
8660
else
8661
  if test -n "$CXX_FOR_TARGET"; then
8662
  ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8663
else
8664
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8665
for as_dir in $PATH
8666
do
8667
  IFS=$as_save_IFS
8668
  test -z "$as_dir" && as_dir=.
8669
  for ac_exec_ext in '' $ac_executable_extensions; do
8670
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8671
    ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8672
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8673
    break 2
8674
  fi
8675
done
8676
done
8677
 
8678
fi
8679
fi
8680
CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8681
if test -n "$CXX_FOR_TARGET"; then
8682
  echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8683
echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8684
else
8685
  echo "$as_me:$LINENO: result: no" >&5
8686
echo "${ECHO_T}no" >&6
8687
fi
8688
 
8689
    fi
8690
    test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8691
  done
8692
fi
8693
 
8694
if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8695
  set dummy c++ g++ cxx gxx
8696
  if test $build = $target ; then
8697
    CXX_FOR_TARGET="$2"
8698
  else
8699
    CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8700
  fi
8701
else
8702
  CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8703
fi
8704
 
8705
 
8706
 
8707
if test -n "$GCC_FOR_TARGET"; then
8708
  ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8709
elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8710
  GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8711
fi
8712
 
8713
if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8714
  for ncn_progname in gcc; do
8715
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8716
set dummy ${ncn_progname}; ac_word=$2
8717
echo "$as_me:$LINENO: checking for $ac_word" >&5
8718
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8719
if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8720
  echo $ECHO_N "(cached) $ECHO_C" >&6
8721
else
8722
  if test -n "$GCC_FOR_TARGET"; then
8723
  ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8724
else
8725
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8726
for as_dir in $PATH
8727
do
8728
  IFS=$as_save_IFS
8729
  test -z "$as_dir" && as_dir=.
8730
  for ac_exec_ext in '' $ac_executable_extensions; do
8731
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8732
    ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8733
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8734
    break 2
8735
  fi
8736
done
8737
done
8738
 
8739
fi
8740
fi
8741
GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8742
if test -n "$GCC_FOR_TARGET"; then
8743
  echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8744
echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8745
else
8746
  echo "$as_me:$LINENO: result: no" >&5
8747
echo "${ECHO_T}no" >&6
8748
fi
8749
 
8750
  done
8751
fi
8752
 
8753
if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8754
  for ncn_progname in gcc; do
8755
    echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8756
echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8757
    if test -x $with_build_time_tools/${ncn_progname}; then
8758
      ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8759
      echo "$as_me:$LINENO: result: yes" >&5
8760
echo "${ECHO_T}yes" >&6
8761
      break
8762
    else
8763
      echo "$as_me:$LINENO: result: no" >&5
8764
echo "${ECHO_T}no" >&6
8765
    fi
8766
  done
8767
fi
8768
 
8769
if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8770
  for ncn_progname in gcc; do
8771
    if test -n "$ncn_target_tool_prefix"; then
8772
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8773
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8774
echo "$as_me:$LINENO: checking for $ac_word" >&5
8775
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8776
if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8777
  echo $ECHO_N "(cached) $ECHO_C" >&6
8778
else
8779
  if test -n "$GCC_FOR_TARGET"; then
8780
  ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8781
else
8782
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8783
for as_dir in $PATH
8784
do
8785
  IFS=$as_save_IFS
8786
  test -z "$as_dir" && as_dir=.
8787
  for ac_exec_ext in '' $ac_executable_extensions; do
8788
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8789
    ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8790
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8791
    break 2
8792
  fi
8793
done
8794
done
8795
 
8796
fi
8797
fi
8798
GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8799
if test -n "$GCC_FOR_TARGET"; then
8800
  echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8801
echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8802
else
8803
  echo "$as_me:$LINENO: result: no" >&5
8804
echo "${ECHO_T}no" >&6
8805
fi
8806
 
8807
    fi
8808
    if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8809
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8810
set dummy ${ncn_progname}; ac_word=$2
8811
echo "$as_me:$LINENO: checking for $ac_word" >&5
8812
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8813
if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8814
  echo $ECHO_N "(cached) $ECHO_C" >&6
8815
else
8816
  if test -n "$GCC_FOR_TARGET"; then
8817
  ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8818
else
8819
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8820
for as_dir in $PATH
8821
do
8822
  IFS=$as_save_IFS
8823
  test -z "$as_dir" && as_dir=.
8824
  for ac_exec_ext in '' $ac_executable_extensions; do
8825
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8826
    ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8827
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8828
    break 2
8829
  fi
8830
done
8831
done
8832
 
8833
fi
8834
fi
8835
GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8836
if test -n "$GCC_FOR_TARGET"; then
8837
  echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8838
echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8839
else
8840
  echo "$as_me:$LINENO: result: no" >&5
8841
echo "${ECHO_T}no" >&6
8842
fi
8843
 
8844
    fi
8845
    test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8846
  done
8847
fi
8848
 
8849
if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8850
  GCC_FOR_TARGET="${CC_FOR_TARGET}"
8851
else
8852
  GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8853
fi
8854
 
8855
 
8856
 
8857
if test -n "$GCJ_FOR_TARGET"; then
8858
  ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8859
elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8860
  GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8861
fi
8862
 
8863
if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8864
  for ncn_progname in gcj; do
8865
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8866
set dummy ${ncn_progname}; ac_word=$2
8867
echo "$as_me:$LINENO: checking for $ac_word" >&5
8868
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8869
if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8870
  echo $ECHO_N "(cached) $ECHO_C" >&6
8871
else
8872
  if test -n "$GCJ_FOR_TARGET"; then
8873
  ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8874
else
8875
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8876
for as_dir in $PATH
8877
do
8878
  IFS=$as_save_IFS
8879
  test -z "$as_dir" && as_dir=.
8880
  for ac_exec_ext in '' $ac_executable_extensions; do
8881
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8882
    ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8883
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8884
    break 2
8885
  fi
8886
done
8887
done
8888
 
8889
fi
8890
fi
8891
GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8892
if test -n "$GCJ_FOR_TARGET"; then
8893
  echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8894
echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8895
else
8896
  echo "$as_me:$LINENO: result: no" >&5
8897
echo "${ECHO_T}no" >&6
8898
fi
8899
 
8900
  done
8901
fi
8902
 
8903
if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8904
  for ncn_progname in gcj; do
8905
    echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8906
echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8907
    if test -x $with_build_time_tools/${ncn_progname}; then
8908
      ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8909
      echo "$as_me:$LINENO: result: yes" >&5
8910
echo "${ECHO_T}yes" >&6
8911
      break
8912
    else
8913
      echo "$as_me:$LINENO: result: no" >&5
8914
echo "${ECHO_T}no" >&6
8915
    fi
8916
  done
8917
fi
8918
 
8919
if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8920
  for ncn_progname in gcj; do
8921
    if test -n "$ncn_target_tool_prefix"; then
8922
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8923
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8924
echo "$as_me:$LINENO: checking for $ac_word" >&5
8925
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8926
if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8927
  echo $ECHO_N "(cached) $ECHO_C" >&6
8928
else
8929
  if test -n "$GCJ_FOR_TARGET"; then
8930
  ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8931
else
8932
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8933
for as_dir in $PATH
8934
do
8935
  IFS=$as_save_IFS
8936
  test -z "$as_dir" && as_dir=.
8937
  for ac_exec_ext in '' $ac_executable_extensions; do
8938
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8939
    ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8940
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8941
    break 2
8942
  fi
8943
done
8944
done
8945
 
8946
fi
8947
fi
8948
GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8949
if test -n "$GCJ_FOR_TARGET"; then
8950
  echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8951
echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8952
else
8953
  echo "$as_me:$LINENO: result: no" >&5
8954
echo "${ECHO_T}no" >&6
8955
fi
8956
 
8957
    fi
8958
    if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8959
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8960
set dummy ${ncn_progname}; ac_word=$2
8961
echo "$as_me:$LINENO: checking for $ac_word" >&5
8962
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8963
if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8964
  echo $ECHO_N "(cached) $ECHO_C" >&6
8965
else
8966
  if test -n "$GCJ_FOR_TARGET"; then
8967
  ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8968
else
8969
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8970
for as_dir in $PATH
8971
do
8972
  IFS=$as_save_IFS
8973
  test -z "$as_dir" && as_dir=.
8974
  for ac_exec_ext in '' $ac_executable_extensions; do
8975
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8976
    ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8977
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8978
    break 2
8979
  fi
8980
done
8981
done
8982
 
8983
fi
8984
fi
8985
GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8986
if test -n "$GCJ_FOR_TARGET"; then
8987
  echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8988
echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8989
else
8990
  echo "$as_me:$LINENO: result: no" >&5
8991
echo "${ECHO_T}no" >&6
8992
fi
8993
 
8994
    fi
8995
    test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8996
  done
8997
fi
8998
 
8999
if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9000
  set dummy gcj
9001
  if test $build = $target ; then
9002
    GCJ_FOR_TARGET="$2"
9003
  else
9004
    GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9005
  fi
9006
else
9007
  GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9008
fi
9009
 
9010
 
9011
 
9012
if test -n "$GFORTRAN_FOR_TARGET"; then
9013
  ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9014
elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9015
  GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9016
fi
9017
 
9018
if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9019
  for ncn_progname in gfortran; do
9020
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9021
set dummy ${ncn_progname}; ac_word=$2
9022
echo "$as_me:$LINENO: checking for $ac_word" >&5
9023
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9024
if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9025
  echo $ECHO_N "(cached) $ECHO_C" >&6
9026
else
9027
  if test -n "$GFORTRAN_FOR_TARGET"; then
9028
  ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9029
else
9030
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9031
for as_dir in $PATH
9032
do
9033
  IFS=$as_save_IFS
9034
  test -z "$as_dir" && as_dir=.
9035
  for ac_exec_ext in '' $ac_executable_extensions; do
9036
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9037
    ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9038
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9039
    break 2
9040
  fi
9041
done
9042
done
9043
 
9044
fi
9045
fi
9046
GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9047
if test -n "$GFORTRAN_FOR_TARGET"; then
9048
  echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9049
echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9050
else
9051
  echo "$as_me:$LINENO: result: no" >&5
9052
echo "${ECHO_T}no" >&6
9053
fi
9054
 
9055
  done
9056
fi
9057
 
9058
if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9059
  for ncn_progname in gfortran; do
9060
    echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9061
echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9062
    if test -x $with_build_time_tools/${ncn_progname}; then
9063
      ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9064
      echo "$as_me:$LINENO: result: yes" >&5
9065
echo "${ECHO_T}yes" >&6
9066
      break
9067
    else
9068
      echo "$as_me:$LINENO: result: no" >&5
9069
echo "${ECHO_T}no" >&6
9070
    fi
9071
  done
9072
fi
9073
 
9074
if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9075
  for ncn_progname in gfortran; do
9076
    if test -n "$ncn_target_tool_prefix"; then
9077
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9078
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9079
echo "$as_me:$LINENO: checking for $ac_word" >&5
9080
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9081
if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9082
  echo $ECHO_N "(cached) $ECHO_C" >&6
9083
else
9084
  if test -n "$GFORTRAN_FOR_TARGET"; then
9085
  ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9086
else
9087
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9088
for as_dir in $PATH
9089
do
9090
  IFS=$as_save_IFS
9091
  test -z "$as_dir" && as_dir=.
9092
  for ac_exec_ext in '' $ac_executable_extensions; do
9093
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9094
    ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9095
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9096
    break 2
9097
  fi
9098
done
9099
done
9100
 
9101
fi
9102
fi
9103
GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9104
if test -n "$GFORTRAN_FOR_TARGET"; then
9105
  echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9106
echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9107
else
9108
  echo "$as_me:$LINENO: result: no" >&5
9109
echo "${ECHO_T}no" >&6
9110
fi
9111
 
9112
    fi
9113
    if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9114
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9115
set dummy ${ncn_progname}; ac_word=$2
9116
echo "$as_me:$LINENO: checking for $ac_word" >&5
9117
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9118
if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9119
  echo $ECHO_N "(cached) $ECHO_C" >&6
9120
else
9121
  if test -n "$GFORTRAN_FOR_TARGET"; then
9122
  ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9123
else
9124
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9125
for as_dir in $PATH
9126
do
9127
  IFS=$as_save_IFS
9128
  test -z "$as_dir" && as_dir=.
9129
  for ac_exec_ext in '' $ac_executable_extensions; do
9130
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9131
    ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9132
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9133
    break 2
9134
  fi
9135
done
9136
done
9137
 
9138
fi
9139
fi
9140
GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9141
if test -n "$GFORTRAN_FOR_TARGET"; then
9142
  echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9143
echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9144
else
9145
  echo "$as_me:$LINENO: result: no" >&5
9146
echo "${ECHO_T}no" >&6
9147
fi
9148
 
9149
    fi
9150
    test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9151
  done
9152
fi
9153
 
9154
if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9155
  set dummy gfortran
9156
  if test $build = $target ; then
9157
    GFORTRAN_FOR_TARGET="$2"
9158
  else
9159
    GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9160
  fi
9161
else
9162
  GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9163
fi
9164
 
9165
 
9166
 
9167
cat > conftest.c << \EOF
9168
#ifdef __GNUC__
9169
  gcc_yay;
9170
#endif
9171
EOF
9172
if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9173
  have_gcc_for_target=yes
9174
else
9175
  GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9176
  have_gcc_for_target=no
9177
fi
9178
rm conftest.c
9179
 
9180
 
9181
 
9182
 
9183
if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9184
  if test -n "$with_build_time_tools"; then
9185
    echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9186
echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9187
    if test -x $with_build_time_tools/ar; then
9188
      AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9189
      ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9190
      echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9191
echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9192
    else
9193
      echo "$as_me:$LINENO: result: no" >&5
9194
echo "${ECHO_T}no" >&6
9195
    fi
9196
  elif test $build != $host && test $have_gcc_for_target = yes; then
9197
    AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9198
    test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9199
    test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9200
  fi
9201
fi
9202
if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9203
  # Extract the first word of "ar", so it can be a program name with args.
9204
set dummy ar; ac_word=$2
9205
echo "$as_me:$LINENO: checking for $ac_word" >&5
9206
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9207
if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9208
  echo $ECHO_N "(cached) $ECHO_C" >&6
9209
else
9210
  case $AR_FOR_TARGET in
9211
  [\\/]* | ?:[\\/]*)
9212
  ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9213
  ;;
9214
  *)
9215
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9216
for as_dir in $gcc_cv_tool_dirs
9217
do
9218
  IFS=$as_save_IFS
9219
  test -z "$as_dir" && as_dir=.
9220
  for ac_exec_ext in '' $ac_executable_extensions; do
9221
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9222
    ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9223
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9224
    break 2
9225
  fi
9226
done
9227
done
9228
 
9229
  ;;
9230
esac
9231
fi
9232
AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9233
 
9234
if test -n "$AR_FOR_TARGET"; then
9235
  echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9236
echo "${ECHO_T}$AR_FOR_TARGET" >&6
9237
else
9238
  echo "$as_me:$LINENO: result: no" >&5
9239
echo "${ECHO_T}no" >&6
9240
fi
9241
 
9242
fi
9243
if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9244
 
9245
 
9246
if test -n "$AR_FOR_TARGET"; then
9247
  ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9248
elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9249
  AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9250
fi
9251
 
9252
if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9253
  for ncn_progname in ar; do
9254
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9255
set dummy ${ncn_progname}; ac_word=$2
9256
echo "$as_me:$LINENO: checking for $ac_word" >&5
9257
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9258
if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9259
  echo $ECHO_N "(cached) $ECHO_C" >&6
9260
else
9261
  if test -n "$AR_FOR_TARGET"; then
9262
  ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9263
else
9264
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9265
for as_dir in $PATH
9266
do
9267
  IFS=$as_save_IFS
9268
  test -z "$as_dir" && as_dir=.
9269
  for ac_exec_ext in '' $ac_executable_extensions; do
9270
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9271
    ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9272
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9273
    break 2
9274
  fi
9275
done
9276
done
9277
 
9278
fi
9279
fi
9280
AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9281
if test -n "$AR_FOR_TARGET"; then
9282
  echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9283
echo "${ECHO_T}$AR_FOR_TARGET" >&6
9284
else
9285
  echo "$as_me:$LINENO: result: no" >&5
9286
echo "${ECHO_T}no" >&6
9287
fi
9288
 
9289
  done
9290
fi
9291
 
9292
if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9293
  for ncn_progname in ar; do
9294
    echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9295
echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9296
    if test -x $with_build_time_tools/${ncn_progname}; then
9297
      ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9298
      echo "$as_me:$LINENO: result: yes" >&5
9299
echo "${ECHO_T}yes" >&6
9300
      break
9301
    else
9302
      echo "$as_me:$LINENO: result: no" >&5
9303
echo "${ECHO_T}no" >&6
9304
    fi
9305
  done
9306
fi
9307
 
9308
if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9309
  for ncn_progname in ar; do
9310
    if test -n "$ncn_target_tool_prefix"; then
9311
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9312
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9313
echo "$as_me:$LINENO: checking for $ac_word" >&5
9314
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9315
if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9316
  echo $ECHO_N "(cached) $ECHO_C" >&6
9317
else
9318
  if test -n "$AR_FOR_TARGET"; then
9319
  ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9320
else
9321
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9322
for as_dir in $PATH
9323
do
9324
  IFS=$as_save_IFS
9325
  test -z "$as_dir" && as_dir=.
9326
  for ac_exec_ext in '' $ac_executable_extensions; do
9327
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9328
    ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9329
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9330
    break 2
9331
  fi
9332
done
9333
done
9334
 
9335
fi
9336
fi
9337
AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9338
if test -n "$AR_FOR_TARGET"; then
9339
  echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9340
echo "${ECHO_T}$AR_FOR_TARGET" >&6
9341
else
9342
  echo "$as_me:$LINENO: result: no" >&5
9343
echo "${ECHO_T}no" >&6
9344
fi
9345
 
9346
    fi
9347
    if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9348
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9349
set dummy ${ncn_progname}; ac_word=$2
9350
echo "$as_me:$LINENO: checking for $ac_word" >&5
9351
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9352
if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9353
  echo $ECHO_N "(cached) $ECHO_C" >&6
9354
else
9355
  if test -n "$AR_FOR_TARGET"; then
9356
  ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9357
else
9358
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9359
for as_dir in $PATH
9360
do
9361
  IFS=$as_save_IFS
9362
  test -z "$as_dir" && as_dir=.
9363
  for ac_exec_ext in '' $ac_executable_extensions; do
9364
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9365
    ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9366
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9367
    break 2
9368
  fi
9369
done
9370
done
9371
 
9372
fi
9373
fi
9374
AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9375
if test -n "$AR_FOR_TARGET"; then
9376
  echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9377
echo "${ECHO_T}$AR_FOR_TARGET" >&6
9378
else
9379
  echo "$as_me:$LINENO: result: no" >&5
9380
echo "${ECHO_T}no" >&6
9381
fi
9382
 
9383
    fi
9384
    test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9385
  done
9386
fi
9387
 
9388
if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9389
  set dummy ar
9390
  if test $build = $target ; then
9391
    AR_FOR_TARGET="$2"
9392
  else
9393
    AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9394
  fi
9395
else
9396
  AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9397
fi
9398
 
9399
else
9400
  AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9401
fi
9402
 
9403
 
9404
 
9405
 
9406
if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9407
  if test -n "$with_build_time_tools"; then
9408
    echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9409
echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9410
    if test -x $with_build_time_tools/as; then
9411
      AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9412
      ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9413
      echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9414
echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9415
    else
9416
      echo "$as_me:$LINENO: result: no" >&5
9417
echo "${ECHO_T}no" >&6
9418
    fi
9419
  elif test $build != $host && test $have_gcc_for_target = yes; then
9420
    AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9421
    test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9422
    test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9423
  fi
9424
fi
9425
if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9426
  # Extract the first word of "as", so it can be a program name with args.
9427
set dummy as; ac_word=$2
9428
echo "$as_me:$LINENO: checking for $ac_word" >&5
9429
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9430
if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9431
  echo $ECHO_N "(cached) $ECHO_C" >&6
9432
else
9433
  case $AS_FOR_TARGET in
9434
  [\\/]* | ?:[\\/]*)
9435
  ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9436
  ;;
9437
  *)
9438
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9439
for as_dir in $gcc_cv_tool_dirs
9440
do
9441
  IFS=$as_save_IFS
9442
  test -z "$as_dir" && as_dir=.
9443
  for ac_exec_ext in '' $ac_executable_extensions; do
9444
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9445
    ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9446
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9447
    break 2
9448
  fi
9449
done
9450
done
9451
 
9452
  ;;
9453
esac
9454
fi
9455
AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9456
 
9457
if test -n "$AS_FOR_TARGET"; then
9458
  echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9459
echo "${ECHO_T}$AS_FOR_TARGET" >&6
9460
else
9461
  echo "$as_me:$LINENO: result: no" >&5
9462
echo "${ECHO_T}no" >&6
9463
fi
9464
 
9465
fi
9466
if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9467
 
9468
 
9469
if test -n "$AS_FOR_TARGET"; then
9470
  ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9471
elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9472
  AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9473
fi
9474
 
9475
if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9476
  for ncn_progname in as; do
9477
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9478
set dummy ${ncn_progname}; ac_word=$2
9479
echo "$as_me:$LINENO: checking for $ac_word" >&5
9480
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9481
if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9482
  echo $ECHO_N "(cached) $ECHO_C" >&6
9483
else
9484
  if test -n "$AS_FOR_TARGET"; then
9485
  ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9486
else
9487
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9488
for as_dir in $PATH
9489
do
9490
  IFS=$as_save_IFS
9491
  test -z "$as_dir" && as_dir=.
9492
  for ac_exec_ext in '' $ac_executable_extensions; do
9493
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9494
    ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9495
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9496
    break 2
9497
  fi
9498
done
9499
done
9500
 
9501
fi
9502
fi
9503
AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9504
if test -n "$AS_FOR_TARGET"; then
9505
  echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9506
echo "${ECHO_T}$AS_FOR_TARGET" >&6
9507
else
9508
  echo "$as_me:$LINENO: result: no" >&5
9509
echo "${ECHO_T}no" >&6
9510
fi
9511
 
9512
  done
9513
fi
9514
 
9515
if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9516
  for ncn_progname in as; do
9517
    echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9518
echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9519
    if test -x $with_build_time_tools/${ncn_progname}; then
9520
      ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9521
      echo "$as_me:$LINENO: result: yes" >&5
9522
echo "${ECHO_T}yes" >&6
9523
      break
9524
    else
9525
      echo "$as_me:$LINENO: result: no" >&5
9526
echo "${ECHO_T}no" >&6
9527
    fi
9528
  done
9529
fi
9530
 
9531
if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9532
  for ncn_progname in as; do
9533
    if test -n "$ncn_target_tool_prefix"; then
9534
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9535
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9536
echo "$as_me:$LINENO: checking for $ac_word" >&5
9537
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9538
if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9539
  echo $ECHO_N "(cached) $ECHO_C" >&6
9540
else
9541
  if test -n "$AS_FOR_TARGET"; then
9542
  ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9543
else
9544
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9545
for as_dir in $PATH
9546
do
9547
  IFS=$as_save_IFS
9548
  test -z "$as_dir" && as_dir=.
9549
  for ac_exec_ext in '' $ac_executable_extensions; do
9550
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9551
    ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9552
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9553
    break 2
9554
  fi
9555
done
9556
done
9557
 
9558
fi
9559
fi
9560
AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9561
if test -n "$AS_FOR_TARGET"; then
9562
  echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9563
echo "${ECHO_T}$AS_FOR_TARGET" >&6
9564
else
9565
  echo "$as_me:$LINENO: result: no" >&5
9566
echo "${ECHO_T}no" >&6
9567
fi
9568
 
9569
    fi
9570
    if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9571
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9572
set dummy ${ncn_progname}; ac_word=$2
9573
echo "$as_me:$LINENO: checking for $ac_word" >&5
9574
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9575
if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9576
  echo $ECHO_N "(cached) $ECHO_C" >&6
9577
else
9578
  if test -n "$AS_FOR_TARGET"; then
9579
  ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9580
else
9581
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9582
for as_dir in $PATH
9583
do
9584
  IFS=$as_save_IFS
9585
  test -z "$as_dir" && as_dir=.
9586
  for ac_exec_ext in '' $ac_executable_extensions; do
9587
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9588
    ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9589
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9590
    break 2
9591
  fi
9592
done
9593
done
9594
 
9595
fi
9596
fi
9597
AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9598
if test -n "$AS_FOR_TARGET"; then
9599
  echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9600
echo "${ECHO_T}$AS_FOR_TARGET" >&6
9601
else
9602
  echo "$as_me:$LINENO: result: no" >&5
9603
echo "${ECHO_T}no" >&6
9604
fi
9605
 
9606
    fi
9607
    test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9608
  done
9609
fi
9610
 
9611
if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9612
  set dummy as
9613
  if test $build = $target ; then
9614
    AS_FOR_TARGET="$2"
9615
  else
9616
    AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9617
  fi
9618
else
9619
  AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9620
fi
9621
 
9622
else
9623
  AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9624
fi
9625
 
9626
 
9627
 
9628
 
9629
if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9630
  if test -n "$with_build_time_tools"; then
9631
    echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9632
echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9633
    if test -x $with_build_time_tools/dlltool; then
9634
      DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9635
      ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9636
      echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9637
echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9638
    else
9639
      echo "$as_me:$LINENO: result: no" >&5
9640
echo "${ECHO_T}no" >&6
9641
    fi
9642
  elif test $build != $host && test $have_gcc_for_target = yes; then
9643
    DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9644
    test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9645
    test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9646
  fi
9647
fi
9648
if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9649
  # Extract the first word of "dlltool", so it can be a program name with args.
9650
set dummy dlltool; ac_word=$2
9651
echo "$as_me:$LINENO: checking for $ac_word" >&5
9652
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9653
if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9654
  echo $ECHO_N "(cached) $ECHO_C" >&6
9655
else
9656
  case $DLLTOOL_FOR_TARGET in
9657
  [\\/]* | ?:[\\/]*)
9658
  ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9659
  ;;
9660
  *)
9661
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9662
for as_dir in $gcc_cv_tool_dirs
9663
do
9664
  IFS=$as_save_IFS
9665
  test -z "$as_dir" && as_dir=.
9666
  for ac_exec_ext in '' $ac_executable_extensions; do
9667
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9668
    ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9669
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9670
    break 2
9671
  fi
9672
done
9673
done
9674
 
9675
  ;;
9676
esac
9677
fi
9678
DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9679
 
9680
if test -n "$DLLTOOL_FOR_TARGET"; then
9681
  echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9682
echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9683
else
9684
  echo "$as_me:$LINENO: result: no" >&5
9685
echo "${ECHO_T}no" >&6
9686
fi
9687
 
9688
fi
9689
if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9690
 
9691
 
9692
if test -n "$DLLTOOL_FOR_TARGET"; then
9693
  ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9694
elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9695
  DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9696
fi
9697
 
9698
if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9699
  for ncn_progname in dlltool; do
9700
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9701
set dummy ${ncn_progname}; ac_word=$2
9702
echo "$as_me:$LINENO: checking for $ac_word" >&5
9703
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9704
if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9705
  echo $ECHO_N "(cached) $ECHO_C" >&6
9706
else
9707
  if test -n "$DLLTOOL_FOR_TARGET"; then
9708
  ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9709
else
9710
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9711
for as_dir in $PATH
9712
do
9713
  IFS=$as_save_IFS
9714
  test -z "$as_dir" && as_dir=.
9715
  for ac_exec_ext in '' $ac_executable_extensions; do
9716
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9717
    ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9718
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9719
    break 2
9720
  fi
9721
done
9722
done
9723
 
9724
fi
9725
fi
9726
DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9727
if test -n "$DLLTOOL_FOR_TARGET"; then
9728
  echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9729
echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9730
else
9731
  echo "$as_me:$LINENO: result: no" >&5
9732
echo "${ECHO_T}no" >&6
9733
fi
9734
 
9735
  done
9736
fi
9737
 
9738
if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9739
  for ncn_progname in dlltool; do
9740
    echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9741
echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9742
    if test -x $with_build_time_tools/${ncn_progname}; then
9743
      ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9744
      echo "$as_me:$LINENO: result: yes" >&5
9745
echo "${ECHO_T}yes" >&6
9746
      break
9747
    else
9748
      echo "$as_me:$LINENO: result: no" >&5
9749
echo "${ECHO_T}no" >&6
9750
    fi
9751
  done
9752
fi
9753
 
9754
if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9755
  for ncn_progname in dlltool; do
9756
    if test -n "$ncn_target_tool_prefix"; then
9757
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9758
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9759
echo "$as_me:$LINENO: checking for $ac_word" >&5
9760
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9761
if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9762
  echo $ECHO_N "(cached) $ECHO_C" >&6
9763
else
9764
  if test -n "$DLLTOOL_FOR_TARGET"; then
9765
  ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9766
else
9767
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9768
for as_dir in $PATH
9769
do
9770
  IFS=$as_save_IFS
9771
  test -z "$as_dir" && as_dir=.
9772
  for ac_exec_ext in '' $ac_executable_extensions; do
9773
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9774
    ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9775
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9776
    break 2
9777
  fi
9778
done
9779
done
9780
 
9781
fi
9782
fi
9783
DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9784
if test -n "$DLLTOOL_FOR_TARGET"; then
9785
  echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9786
echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9787
else
9788
  echo "$as_me:$LINENO: result: no" >&5
9789
echo "${ECHO_T}no" >&6
9790
fi
9791
 
9792
    fi
9793
    if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9794
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9795
set dummy ${ncn_progname}; ac_word=$2
9796
echo "$as_me:$LINENO: checking for $ac_word" >&5
9797
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9798
if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9799
  echo $ECHO_N "(cached) $ECHO_C" >&6
9800
else
9801
  if test -n "$DLLTOOL_FOR_TARGET"; then
9802
  ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9803
else
9804
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9805
for as_dir in $PATH
9806
do
9807
  IFS=$as_save_IFS
9808
  test -z "$as_dir" && as_dir=.
9809
  for ac_exec_ext in '' $ac_executable_extensions; do
9810
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9811
    ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9812
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9813
    break 2
9814
  fi
9815
done
9816
done
9817
 
9818
fi
9819
fi
9820
DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9821
if test -n "$DLLTOOL_FOR_TARGET"; then
9822
  echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9823
echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9824
else
9825
  echo "$as_me:$LINENO: result: no" >&5
9826
echo "${ECHO_T}no" >&6
9827
fi
9828
 
9829
    fi
9830
    test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9831
  done
9832
fi
9833
 
9834
if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9835
  set dummy dlltool
9836
  if test $build = $target ; then
9837
    DLLTOOL_FOR_TARGET="$2"
9838
  else
9839
    DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9840
  fi
9841
else
9842
  DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9843
fi
9844
 
9845
else
9846
  DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9847
fi
9848
 
9849
 
9850
 
9851
 
9852
if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9853
  if test -n "$with_build_time_tools"; then
9854
    echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9855
echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9856
    if test -x $with_build_time_tools/ld; then
9857
      LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9858
      ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9859
      echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9860
echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9861
    else
9862
      echo "$as_me:$LINENO: result: no" >&5
9863
echo "${ECHO_T}no" >&6
9864
    fi
9865
  elif test $build != $host && test $have_gcc_for_target = yes; then
9866
    LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9867
    test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9868
    test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9869
  fi
9870
fi
9871
if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9872
  # Extract the first word of "ld", so it can be a program name with args.
9873
set dummy ld; ac_word=$2
9874
echo "$as_me:$LINENO: checking for $ac_word" >&5
9875
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9876
if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9877
  echo $ECHO_N "(cached) $ECHO_C" >&6
9878
else
9879
  case $LD_FOR_TARGET in
9880
  [\\/]* | ?:[\\/]*)
9881
  ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9882
  ;;
9883
  *)
9884
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9885
for as_dir in $gcc_cv_tool_dirs
9886
do
9887
  IFS=$as_save_IFS
9888
  test -z "$as_dir" && as_dir=.
9889
  for ac_exec_ext in '' $ac_executable_extensions; do
9890
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9891
    ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9892
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9893
    break 2
9894
  fi
9895
done
9896
done
9897
 
9898
  ;;
9899
esac
9900
fi
9901
LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9902
 
9903
if test -n "$LD_FOR_TARGET"; then
9904
  echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9905
echo "${ECHO_T}$LD_FOR_TARGET" >&6
9906
else
9907
  echo "$as_me:$LINENO: result: no" >&5
9908
echo "${ECHO_T}no" >&6
9909
fi
9910
 
9911
fi
9912
if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9913
 
9914
 
9915
if test -n "$LD_FOR_TARGET"; then
9916
  ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9917
elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9918
  LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9919
fi
9920
 
9921
if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9922
  for ncn_progname in ld; do
9923
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9924
set dummy ${ncn_progname}; ac_word=$2
9925
echo "$as_me:$LINENO: checking for $ac_word" >&5
9926
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9927
if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9928
  echo $ECHO_N "(cached) $ECHO_C" >&6
9929
else
9930
  if test -n "$LD_FOR_TARGET"; then
9931
  ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9932
else
9933
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9934
for as_dir in $PATH
9935
do
9936
  IFS=$as_save_IFS
9937
  test -z "$as_dir" && as_dir=.
9938
  for ac_exec_ext in '' $ac_executable_extensions; do
9939
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9940
    ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9941
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9942
    break 2
9943
  fi
9944
done
9945
done
9946
 
9947
fi
9948
fi
9949
LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9950
if test -n "$LD_FOR_TARGET"; then
9951
  echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9952
echo "${ECHO_T}$LD_FOR_TARGET" >&6
9953
else
9954
  echo "$as_me:$LINENO: result: no" >&5
9955
echo "${ECHO_T}no" >&6
9956
fi
9957
 
9958
  done
9959
fi
9960
 
9961
if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9962
  for ncn_progname in ld; do
9963
    echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9964
echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9965
    if test -x $with_build_time_tools/${ncn_progname}; then
9966
      ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9967
      echo "$as_me:$LINENO: result: yes" >&5
9968
echo "${ECHO_T}yes" >&6
9969
      break
9970
    else
9971
      echo "$as_me:$LINENO: result: no" >&5
9972
echo "${ECHO_T}no" >&6
9973
    fi
9974
  done
9975
fi
9976
 
9977
if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9978
  for ncn_progname in ld; do
9979
    if test -n "$ncn_target_tool_prefix"; then
9980
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9981
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9982
echo "$as_me:$LINENO: checking for $ac_word" >&5
9983
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9984
if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9985
  echo $ECHO_N "(cached) $ECHO_C" >&6
9986
else
9987
  if test -n "$LD_FOR_TARGET"; then
9988
  ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9989
else
9990
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9991
for as_dir in $PATH
9992
do
9993
  IFS=$as_save_IFS
9994
  test -z "$as_dir" && as_dir=.
9995
  for ac_exec_ext in '' $ac_executable_extensions; do
9996
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9997
    ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9998
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9999
    break 2
10000
  fi
10001
done
10002
done
10003
 
10004
fi
10005
fi
10006
LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10007
if test -n "$LD_FOR_TARGET"; then
10008
  echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10009
echo "${ECHO_T}$LD_FOR_TARGET" >&6
10010
else
10011
  echo "$as_me:$LINENO: result: no" >&5
10012
echo "${ECHO_T}no" >&6
10013
fi
10014
 
10015
    fi
10016
    if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10017
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10018
set dummy ${ncn_progname}; ac_word=$2
10019
echo "$as_me:$LINENO: checking for $ac_word" >&5
10020
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10021
if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10022
  echo $ECHO_N "(cached) $ECHO_C" >&6
10023
else
10024
  if test -n "$LD_FOR_TARGET"; then
10025
  ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10026
else
10027
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10028
for as_dir in $PATH
10029
do
10030
  IFS=$as_save_IFS
10031
  test -z "$as_dir" && as_dir=.
10032
  for ac_exec_ext in '' $ac_executable_extensions; do
10033
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10034
    ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10035
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10036
    break 2
10037
  fi
10038
done
10039
done
10040
 
10041
fi
10042
fi
10043
LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10044
if test -n "$LD_FOR_TARGET"; then
10045
  echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10046
echo "${ECHO_T}$LD_FOR_TARGET" >&6
10047
else
10048
  echo "$as_me:$LINENO: result: no" >&5
10049
echo "${ECHO_T}no" >&6
10050
fi
10051
 
10052
    fi
10053
    test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10054
  done
10055
fi
10056
 
10057
if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10058
  set dummy ld
10059
  if test $build = $target ; then
10060
    LD_FOR_TARGET="$2"
10061
  else
10062
    LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10063
  fi
10064
else
10065
  LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10066
fi
10067
 
10068
else
10069
  LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10070
fi
10071
 
10072
 
10073
 
10074
 
10075
if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10076
  if test -n "$with_build_time_tools"; then
10077
    echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10078
echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10079
    if test -x $with_build_time_tools/lipo; then
10080
      LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10081
      ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10082
      echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10083
echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10084
    else
10085
      echo "$as_me:$LINENO: result: no" >&5
10086
echo "${ECHO_T}no" >&6
10087
    fi
10088
  elif test $build != $host && test $have_gcc_for_target = yes; then
10089
    LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10090
    test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10091
    test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10092
  fi
10093
fi
10094
if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10095
  # Extract the first word of "lipo", so it can be a program name with args.
10096
set dummy lipo; ac_word=$2
10097
echo "$as_me:$LINENO: checking for $ac_word" >&5
10098
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10099
if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10100
  echo $ECHO_N "(cached) $ECHO_C" >&6
10101
else
10102
  case $LIPO_FOR_TARGET in
10103
  [\\/]* | ?:[\\/]*)
10104
  ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10105
  ;;
10106
  *)
10107
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10108
for as_dir in $gcc_cv_tool_dirs
10109
do
10110
  IFS=$as_save_IFS
10111
  test -z "$as_dir" && as_dir=.
10112
  for ac_exec_ext in '' $ac_executable_extensions; do
10113
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10114
    ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10115
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10116
    break 2
10117
  fi
10118
done
10119
done
10120
 
10121
  ;;
10122
esac
10123
fi
10124
LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10125
 
10126
if test -n "$LIPO_FOR_TARGET"; then
10127
  echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10128
echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10129
else
10130
  echo "$as_me:$LINENO: result: no" >&5
10131
echo "${ECHO_T}no" >&6
10132
fi
10133
 
10134
fi
10135
if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10136
 
10137
 
10138
if test -n "$LIPO_FOR_TARGET"; then
10139
  ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10140
elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10141
  LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10142
fi
10143
 
10144
if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10145
  for ncn_progname in lipo; do
10146
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10147
set dummy ${ncn_progname}; ac_word=$2
10148
echo "$as_me:$LINENO: checking for $ac_word" >&5
10149
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10150
if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10151
  echo $ECHO_N "(cached) $ECHO_C" >&6
10152
else
10153
  if test -n "$LIPO_FOR_TARGET"; then
10154
  ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10155
else
10156
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10157
for as_dir in $PATH
10158
do
10159
  IFS=$as_save_IFS
10160
  test -z "$as_dir" && as_dir=.
10161
  for ac_exec_ext in '' $ac_executable_extensions; do
10162
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10163
    ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10164
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10165
    break 2
10166
  fi
10167
done
10168
done
10169
 
10170
fi
10171
fi
10172
LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10173
if test -n "$LIPO_FOR_TARGET"; then
10174
  echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10175
echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10176
else
10177
  echo "$as_me:$LINENO: result: no" >&5
10178
echo "${ECHO_T}no" >&6
10179
fi
10180
 
10181
  done
10182
fi
10183
 
10184
if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10185
  for ncn_progname in lipo; do
10186
    echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10187
echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10188
    if test -x $with_build_time_tools/${ncn_progname}; then
10189
      ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10190
      echo "$as_me:$LINENO: result: yes" >&5
10191
echo "${ECHO_T}yes" >&6
10192
      break
10193
    else
10194
      echo "$as_me:$LINENO: result: no" >&5
10195
echo "${ECHO_T}no" >&6
10196
    fi
10197
  done
10198
fi
10199
 
10200
if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10201
  for ncn_progname in lipo; do
10202
    if test -n "$ncn_target_tool_prefix"; then
10203
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10204
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10205
echo "$as_me:$LINENO: checking for $ac_word" >&5
10206
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10207
if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10208
  echo $ECHO_N "(cached) $ECHO_C" >&6
10209
else
10210
  if test -n "$LIPO_FOR_TARGET"; then
10211
  ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10212
else
10213
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10214
for as_dir in $PATH
10215
do
10216
  IFS=$as_save_IFS
10217
  test -z "$as_dir" && as_dir=.
10218
  for ac_exec_ext in '' $ac_executable_extensions; do
10219
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10220
    ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10221
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10222
    break 2
10223
  fi
10224
done
10225
done
10226
 
10227
fi
10228
fi
10229
LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10230
if test -n "$LIPO_FOR_TARGET"; then
10231
  echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10232
echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10233
else
10234
  echo "$as_me:$LINENO: result: no" >&5
10235
echo "${ECHO_T}no" >&6
10236
fi
10237
 
10238
    fi
10239
    if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10240
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10241
set dummy ${ncn_progname}; ac_word=$2
10242
echo "$as_me:$LINENO: checking for $ac_word" >&5
10243
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10244
if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10245
  echo $ECHO_N "(cached) $ECHO_C" >&6
10246
else
10247
  if test -n "$LIPO_FOR_TARGET"; then
10248
  ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10249
else
10250
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10251
for as_dir in $PATH
10252
do
10253
  IFS=$as_save_IFS
10254
  test -z "$as_dir" && as_dir=.
10255
  for ac_exec_ext in '' $ac_executable_extensions; do
10256
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10257
    ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10258
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10259
    break 2
10260
  fi
10261
done
10262
done
10263
 
10264
fi
10265
fi
10266
LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10267
if test -n "$LIPO_FOR_TARGET"; then
10268
  echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10269
echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10270
else
10271
  echo "$as_me:$LINENO: result: no" >&5
10272
echo "${ECHO_T}no" >&6
10273
fi
10274
 
10275
    fi
10276
    test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10277
  done
10278
fi
10279
 
10280
if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10281
  set dummy lipo
10282
  if test $build = $target ; then
10283
    LIPO_FOR_TARGET="$2"
10284
  else
10285
    LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10286
  fi
10287
else
10288
  LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10289
fi
10290
 
10291
else
10292
  LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10293
fi
10294
 
10295
 
10296
 
10297
 
10298
if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10299
  if test -n "$with_build_time_tools"; then
10300
    echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10301
echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10302
    if test -x $with_build_time_tools/nm; then
10303
      NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10304
      ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10305
      echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10306
echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10307
    else
10308
      echo "$as_me:$LINENO: result: no" >&5
10309
echo "${ECHO_T}no" >&6
10310
    fi
10311
  elif test $build != $host && test $have_gcc_for_target = yes; then
10312
    NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10313
    test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10314
    test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10315
  fi
10316
fi
10317
if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10318
  # Extract the first word of "nm", so it can be a program name with args.
10319
set dummy nm; ac_word=$2
10320
echo "$as_me:$LINENO: checking for $ac_word" >&5
10321
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10322
if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10323
  echo $ECHO_N "(cached) $ECHO_C" >&6
10324
else
10325
  case $NM_FOR_TARGET in
10326
  [\\/]* | ?:[\\/]*)
10327
  ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10328
  ;;
10329
  *)
10330
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10331
for as_dir in $gcc_cv_tool_dirs
10332
do
10333
  IFS=$as_save_IFS
10334
  test -z "$as_dir" && as_dir=.
10335
  for ac_exec_ext in '' $ac_executable_extensions; do
10336
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10337
    ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10338
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10339
    break 2
10340
  fi
10341
done
10342
done
10343
 
10344
  ;;
10345
esac
10346
fi
10347
NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10348
 
10349
if test -n "$NM_FOR_TARGET"; then
10350
  echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10351
echo "${ECHO_T}$NM_FOR_TARGET" >&6
10352
else
10353
  echo "$as_me:$LINENO: result: no" >&5
10354
echo "${ECHO_T}no" >&6
10355
fi
10356
 
10357
fi
10358
if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10359
 
10360
 
10361
if test -n "$NM_FOR_TARGET"; then
10362
  ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10363
elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10364
  NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10365
fi
10366
 
10367
if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10368
  for ncn_progname in nm; do
10369
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10370
set dummy ${ncn_progname}; ac_word=$2
10371
echo "$as_me:$LINENO: checking for $ac_word" >&5
10372
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10373
if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10374
  echo $ECHO_N "(cached) $ECHO_C" >&6
10375
else
10376
  if test -n "$NM_FOR_TARGET"; then
10377
  ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10378
else
10379
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10380
for as_dir in $PATH
10381
do
10382
  IFS=$as_save_IFS
10383
  test -z "$as_dir" && as_dir=.
10384
  for ac_exec_ext in '' $ac_executable_extensions; do
10385
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10386
    ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10387
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10388
    break 2
10389
  fi
10390
done
10391
done
10392
 
10393
fi
10394
fi
10395
NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10396
if test -n "$NM_FOR_TARGET"; then
10397
  echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10398
echo "${ECHO_T}$NM_FOR_TARGET" >&6
10399
else
10400
  echo "$as_me:$LINENO: result: no" >&5
10401
echo "${ECHO_T}no" >&6
10402
fi
10403
 
10404
  done
10405
fi
10406
 
10407
if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10408
  for ncn_progname in nm; do
10409
    echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10410
echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10411
    if test -x $with_build_time_tools/${ncn_progname}; then
10412
      ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10413
      echo "$as_me:$LINENO: result: yes" >&5
10414
echo "${ECHO_T}yes" >&6
10415
      break
10416
    else
10417
      echo "$as_me:$LINENO: result: no" >&5
10418
echo "${ECHO_T}no" >&6
10419
    fi
10420
  done
10421
fi
10422
 
10423
if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10424
  for ncn_progname in nm; do
10425
    if test -n "$ncn_target_tool_prefix"; then
10426
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10427
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10428
echo "$as_me:$LINENO: checking for $ac_word" >&5
10429
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10430
if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10431
  echo $ECHO_N "(cached) $ECHO_C" >&6
10432
else
10433
  if test -n "$NM_FOR_TARGET"; then
10434
  ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10435
else
10436
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10437
for as_dir in $PATH
10438
do
10439
  IFS=$as_save_IFS
10440
  test -z "$as_dir" && as_dir=.
10441
  for ac_exec_ext in '' $ac_executable_extensions; do
10442
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10443
    ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10444
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10445
    break 2
10446
  fi
10447
done
10448
done
10449
 
10450
fi
10451
fi
10452
NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10453
if test -n "$NM_FOR_TARGET"; then
10454
  echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10455
echo "${ECHO_T}$NM_FOR_TARGET" >&6
10456
else
10457
  echo "$as_me:$LINENO: result: no" >&5
10458
echo "${ECHO_T}no" >&6
10459
fi
10460
 
10461
    fi
10462
    if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10463
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10464
set dummy ${ncn_progname}; ac_word=$2
10465
echo "$as_me:$LINENO: checking for $ac_word" >&5
10466
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10467
if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10468
  echo $ECHO_N "(cached) $ECHO_C" >&6
10469
else
10470
  if test -n "$NM_FOR_TARGET"; then
10471
  ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10472
else
10473
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10474
for as_dir in $PATH
10475
do
10476
  IFS=$as_save_IFS
10477
  test -z "$as_dir" && as_dir=.
10478
  for ac_exec_ext in '' $ac_executable_extensions; do
10479
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10480
    ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10481
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10482
    break 2
10483
  fi
10484
done
10485
done
10486
 
10487
fi
10488
fi
10489
NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10490
if test -n "$NM_FOR_TARGET"; then
10491
  echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10492
echo "${ECHO_T}$NM_FOR_TARGET" >&6
10493
else
10494
  echo "$as_me:$LINENO: result: no" >&5
10495
echo "${ECHO_T}no" >&6
10496
fi
10497
 
10498
    fi
10499
    test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10500
  done
10501
fi
10502
 
10503
if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10504
  set dummy nm
10505
  if test $build = $target ; then
10506
    NM_FOR_TARGET="$2"
10507
  else
10508
    NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10509
  fi
10510
else
10511
  NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10512
fi
10513
 
10514
else
10515
  NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10516
fi
10517
 
10518
 
10519
 
10520
 
10521
if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10522
  if test -n "$with_build_time_tools"; then
10523
    echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10524
echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10525
    if test -x $with_build_time_tools/objdump; then
10526
      OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10527
      ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10528
      echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10529
echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10530
    else
10531
      echo "$as_me:$LINENO: result: no" >&5
10532
echo "${ECHO_T}no" >&6
10533
    fi
10534
  elif test $build != $host && test $have_gcc_for_target = yes; then
10535
    OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10536
    test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10537
    test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10538
  fi
10539
fi
10540
if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10541
  # Extract the first word of "objdump", so it can be a program name with args.
10542
set dummy objdump; ac_word=$2
10543
echo "$as_me:$LINENO: checking for $ac_word" >&5
10544
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10545
if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10546
  echo $ECHO_N "(cached) $ECHO_C" >&6
10547
else
10548
  case $OBJDUMP_FOR_TARGET in
10549
  [\\/]* | ?:[\\/]*)
10550
  ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10551
  ;;
10552
  *)
10553
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10554
for as_dir in $gcc_cv_tool_dirs
10555
do
10556
  IFS=$as_save_IFS
10557
  test -z "$as_dir" && as_dir=.
10558
  for ac_exec_ext in '' $ac_executable_extensions; do
10559
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10560
    ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10561
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10562
    break 2
10563
  fi
10564
done
10565
done
10566
 
10567
  ;;
10568
esac
10569
fi
10570
OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10571
 
10572
if test -n "$OBJDUMP_FOR_TARGET"; then
10573
  echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10574
echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10575
else
10576
  echo "$as_me:$LINENO: result: no" >&5
10577
echo "${ECHO_T}no" >&6
10578
fi
10579
 
10580
fi
10581
if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10582
 
10583
 
10584
if test -n "$OBJDUMP_FOR_TARGET"; then
10585
  ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10586
elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10587
  OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10588
fi
10589
 
10590
if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10591
  for ncn_progname in objdump; do
10592
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10593
set dummy ${ncn_progname}; ac_word=$2
10594
echo "$as_me:$LINENO: checking for $ac_word" >&5
10595
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10596
if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10597
  echo $ECHO_N "(cached) $ECHO_C" >&6
10598
else
10599
  if test -n "$OBJDUMP_FOR_TARGET"; then
10600
  ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10601
else
10602
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10603
for as_dir in $PATH
10604
do
10605
  IFS=$as_save_IFS
10606
  test -z "$as_dir" && as_dir=.
10607
  for ac_exec_ext in '' $ac_executable_extensions; do
10608
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10609
    ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10610
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10611
    break 2
10612
  fi
10613
done
10614
done
10615
 
10616
fi
10617
fi
10618
OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10619
if test -n "$OBJDUMP_FOR_TARGET"; then
10620
  echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10621
echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10622
else
10623
  echo "$as_me:$LINENO: result: no" >&5
10624
echo "${ECHO_T}no" >&6
10625
fi
10626
 
10627
  done
10628
fi
10629
 
10630
if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10631
  for ncn_progname in objdump; do
10632
    echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10633
echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10634
    if test -x $with_build_time_tools/${ncn_progname}; then
10635
      ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10636
      echo "$as_me:$LINENO: result: yes" >&5
10637
echo "${ECHO_T}yes" >&6
10638
      break
10639
    else
10640
      echo "$as_me:$LINENO: result: no" >&5
10641
echo "${ECHO_T}no" >&6
10642
    fi
10643
  done
10644
fi
10645
 
10646
if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10647
  for ncn_progname in objdump; do
10648
    if test -n "$ncn_target_tool_prefix"; then
10649
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10650
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10651
echo "$as_me:$LINENO: checking for $ac_word" >&5
10652
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10653
if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10654
  echo $ECHO_N "(cached) $ECHO_C" >&6
10655
else
10656
  if test -n "$OBJDUMP_FOR_TARGET"; then
10657
  ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10658
else
10659
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10660
for as_dir in $PATH
10661
do
10662
  IFS=$as_save_IFS
10663
  test -z "$as_dir" && as_dir=.
10664
  for ac_exec_ext in '' $ac_executable_extensions; do
10665
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10666
    ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10667
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10668
    break 2
10669
  fi
10670
done
10671
done
10672
 
10673
fi
10674
fi
10675
OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10676
if test -n "$OBJDUMP_FOR_TARGET"; then
10677
  echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10678
echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10679
else
10680
  echo "$as_me:$LINENO: result: no" >&5
10681
echo "${ECHO_T}no" >&6
10682
fi
10683
 
10684
    fi
10685
    if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10686
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10687
set dummy ${ncn_progname}; ac_word=$2
10688
echo "$as_me:$LINENO: checking for $ac_word" >&5
10689
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10690
if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10691
  echo $ECHO_N "(cached) $ECHO_C" >&6
10692
else
10693
  if test -n "$OBJDUMP_FOR_TARGET"; then
10694
  ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10695
else
10696
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10697
for as_dir in $PATH
10698
do
10699
  IFS=$as_save_IFS
10700
  test -z "$as_dir" && as_dir=.
10701
  for ac_exec_ext in '' $ac_executable_extensions; do
10702
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10703
    ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10704
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10705
    break 2
10706
  fi
10707
done
10708
done
10709
 
10710
fi
10711
fi
10712
OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10713
if test -n "$OBJDUMP_FOR_TARGET"; then
10714
  echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10715
echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10716
else
10717
  echo "$as_me:$LINENO: result: no" >&5
10718
echo "${ECHO_T}no" >&6
10719
fi
10720
 
10721
    fi
10722
    test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10723
  done
10724
fi
10725
 
10726
if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10727
  set dummy objdump
10728
  if test $build = $target ; then
10729
    OBJDUMP_FOR_TARGET="$2"
10730
  else
10731
    OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10732
  fi
10733
else
10734
  OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10735
fi
10736
 
10737
else
10738
  OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10739
fi
10740
 
10741
 
10742
 
10743
 
10744
if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10745
  if test -n "$with_build_time_tools"; then
10746
    echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10747
echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10748
    if test -x $with_build_time_tools/ranlib; then
10749
      RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10750
      ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10751
      echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10752
echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10753
    else
10754
      echo "$as_me:$LINENO: result: no" >&5
10755
echo "${ECHO_T}no" >&6
10756
    fi
10757
  elif test $build != $host && test $have_gcc_for_target = yes; then
10758
    RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10759
    test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10760
    test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10761
  fi
10762
fi
10763
if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10764
  # Extract the first word of "ranlib", so it can be a program name with args.
10765
set dummy ranlib; ac_word=$2
10766
echo "$as_me:$LINENO: checking for $ac_word" >&5
10767
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10768
if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10769
  echo $ECHO_N "(cached) $ECHO_C" >&6
10770
else
10771
  case $RANLIB_FOR_TARGET in
10772
  [\\/]* | ?:[\\/]*)
10773
  ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10774
  ;;
10775
  *)
10776
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10777
for as_dir in $gcc_cv_tool_dirs
10778
do
10779
  IFS=$as_save_IFS
10780
  test -z "$as_dir" && as_dir=.
10781
  for ac_exec_ext in '' $ac_executable_extensions; do
10782
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10783
    ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10784
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10785
    break 2
10786
  fi
10787
done
10788
done
10789
 
10790
  ;;
10791
esac
10792
fi
10793
RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10794
 
10795
if test -n "$RANLIB_FOR_TARGET"; then
10796
  echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10797
echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10798
else
10799
  echo "$as_me:$LINENO: result: no" >&5
10800
echo "${ECHO_T}no" >&6
10801
fi
10802
 
10803
fi
10804
if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10805
 
10806
 
10807
if test -n "$RANLIB_FOR_TARGET"; then
10808
  ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10809
elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10810
  RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10811
fi
10812
 
10813
if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10814
  for ncn_progname in ranlib; do
10815
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10816
set dummy ${ncn_progname}; ac_word=$2
10817
echo "$as_me:$LINENO: checking for $ac_word" >&5
10818
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10819
if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10820
  echo $ECHO_N "(cached) $ECHO_C" >&6
10821
else
10822
  if test -n "$RANLIB_FOR_TARGET"; then
10823
  ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10824
else
10825
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10826
for as_dir in $PATH
10827
do
10828
  IFS=$as_save_IFS
10829
  test -z "$as_dir" && as_dir=.
10830
  for ac_exec_ext in '' $ac_executable_extensions; do
10831
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10832
    ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10833
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10834
    break 2
10835
  fi
10836
done
10837
done
10838
 
10839
fi
10840
fi
10841
RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10842
if test -n "$RANLIB_FOR_TARGET"; then
10843
  echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10844
echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10845
else
10846
  echo "$as_me:$LINENO: result: no" >&5
10847
echo "${ECHO_T}no" >&6
10848
fi
10849
 
10850
  done
10851
fi
10852
 
10853
if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10854
  for ncn_progname in ranlib; do
10855
    echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10856
echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10857
    if test -x $with_build_time_tools/${ncn_progname}; then
10858
      ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10859
      echo "$as_me:$LINENO: result: yes" >&5
10860
echo "${ECHO_T}yes" >&6
10861
      break
10862
    else
10863
      echo "$as_me:$LINENO: result: no" >&5
10864
echo "${ECHO_T}no" >&6
10865
    fi
10866
  done
10867
fi
10868
 
10869
if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10870
  for ncn_progname in ranlib; do
10871
    if test -n "$ncn_target_tool_prefix"; then
10872
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10873
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10874
echo "$as_me:$LINENO: checking for $ac_word" >&5
10875
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10876
if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10877
  echo $ECHO_N "(cached) $ECHO_C" >&6
10878
else
10879
  if test -n "$RANLIB_FOR_TARGET"; then
10880
  ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10881
else
10882
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10883
for as_dir in $PATH
10884
do
10885
  IFS=$as_save_IFS
10886
  test -z "$as_dir" && as_dir=.
10887
  for ac_exec_ext in '' $ac_executable_extensions; do
10888
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10889
    ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10890
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10891
    break 2
10892
  fi
10893
done
10894
done
10895
 
10896
fi
10897
fi
10898
RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10899
if test -n "$RANLIB_FOR_TARGET"; then
10900
  echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10901
echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10902
else
10903
  echo "$as_me:$LINENO: result: no" >&5
10904
echo "${ECHO_T}no" >&6
10905
fi
10906
 
10907
    fi
10908
    if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10909
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10910
set dummy ${ncn_progname}; ac_word=$2
10911
echo "$as_me:$LINENO: checking for $ac_word" >&5
10912
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10913
if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10914
  echo $ECHO_N "(cached) $ECHO_C" >&6
10915
else
10916
  if test -n "$RANLIB_FOR_TARGET"; then
10917
  ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10918
else
10919
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10920
for as_dir in $PATH
10921
do
10922
  IFS=$as_save_IFS
10923
  test -z "$as_dir" && as_dir=.
10924
  for ac_exec_ext in '' $ac_executable_extensions; do
10925
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10926
    ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10927
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10928
    break 2
10929
  fi
10930
done
10931
done
10932
 
10933
fi
10934
fi
10935
RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10936
if test -n "$RANLIB_FOR_TARGET"; then
10937
  echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10938
echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10939
else
10940
  echo "$as_me:$LINENO: result: no" >&5
10941
echo "${ECHO_T}no" >&6
10942
fi
10943
 
10944
    fi
10945
    test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10946
  done
10947
fi
10948
 
10949
if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10950
  set dummy ranlib
10951
  if test $build = $target ; then
10952
    RANLIB_FOR_TARGET="$2"
10953
  else
10954
    RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10955
  fi
10956
else
10957
  RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10958
fi
10959
 
10960
else
10961
  RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10962
fi
10963
 
10964
 
10965
 
10966
 
10967
if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10968
  if test -n "$with_build_time_tools"; then
10969
    echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10970
echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10971
    if test -x $with_build_time_tools/strip; then
10972
      STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10973
      ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10974
      echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10975
echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10976
    else
10977
      echo "$as_me:$LINENO: result: no" >&5
10978
echo "${ECHO_T}no" >&6
10979
    fi
10980
  elif test $build != $host && test $have_gcc_for_target = yes; then
10981
    STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10982
    test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10983
    test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10984
  fi
10985
fi
10986
if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10987
  # Extract the first word of "strip", so it can be a program name with args.
10988
set dummy strip; ac_word=$2
10989
echo "$as_me:$LINENO: checking for $ac_word" >&5
10990
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10991
if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10992
  echo $ECHO_N "(cached) $ECHO_C" >&6
10993
else
10994
  case $STRIP_FOR_TARGET in
10995
  [\\/]* | ?:[\\/]*)
10996
  ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10997
  ;;
10998
  *)
10999
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11000
for as_dir in $gcc_cv_tool_dirs
11001
do
11002
  IFS=$as_save_IFS
11003
  test -z "$as_dir" && as_dir=.
11004
  for ac_exec_ext in '' $ac_executable_extensions; do
11005
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11006
    ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11007
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11008
    break 2
11009
  fi
11010
done
11011
done
11012
 
11013
  ;;
11014
esac
11015
fi
11016
STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11017
 
11018
if test -n "$STRIP_FOR_TARGET"; then
11019
  echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11020
echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11021
else
11022
  echo "$as_me:$LINENO: result: no" >&5
11023
echo "${ECHO_T}no" >&6
11024
fi
11025
 
11026
fi
11027
if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11028
 
11029
 
11030
if test -n "$STRIP_FOR_TARGET"; then
11031
  ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11032
elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11033
  STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11034
fi
11035
 
11036
if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11037
  for ncn_progname in strip; do
11038
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11039
set dummy ${ncn_progname}; ac_word=$2
11040
echo "$as_me:$LINENO: checking for $ac_word" >&5
11041
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11042
if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11043
  echo $ECHO_N "(cached) $ECHO_C" >&6
11044
else
11045
  if test -n "$STRIP_FOR_TARGET"; then
11046
  ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11047
else
11048
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11049
for as_dir in $PATH
11050
do
11051
  IFS=$as_save_IFS
11052
  test -z "$as_dir" && as_dir=.
11053
  for ac_exec_ext in '' $ac_executable_extensions; do
11054
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11055
    ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11056
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11057
    break 2
11058
  fi
11059
done
11060
done
11061
 
11062
fi
11063
fi
11064
STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11065
if test -n "$STRIP_FOR_TARGET"; then
11066
  echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11067
echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11068
else
11069
  echo "$as_me:$LINENO: result: no" >&5
11070
echo "${ECHO_T}no" >&6
11071
fi
11072
 
11073
  done
11074
fi
11075
 
11076
if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11077
  for ncn_progname in strip; do
11078
    echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11079
echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11080
    if test -x $with_build_time_tools/${ncn_progname}; then
11081
      ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11082
      echo "$as_me:$LINENO: result: yes" >&5
11083
echo "${ECHO_T}yes" >&6
11084
      break
11085
    else
11086
      echo "$as_me:$LINENO: result: no" >&5
11087
echo "${ECHO_T}no" >&6
11088
    fi
11089
  done
11090
fi
11091
 
11092
if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11093
  for ncn_progname in strip; do
11094
    if test -n "$ncn_target_tool_prefix"; then
11095
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11096
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11097
echo "$as_me:$LINENO: checking for $ac_word" >&5
11098
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11099
if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11100
  echo $ECHO_N "(cached) $ECHO_C" >&6
11101
else
11102
  if test -n "$STRIP_FOR_TARGET"; then
11103
  ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11104
else
11105
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11106
for as_dir in $PATH
11107
do
11108
  IFS=$as_save_IFS
11109
  test -z "$as_dir" && as_dir=.
11110
  for ac_exec_ext in '' $ac_executable_extensions; do
11111
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11112
    ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11113
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11114
    break 2
11115
  fi
11116
done
11117
done
11118
 
11119
fi
11120
fi
11121
STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11122
if test -n "$STRIP_FOR_TARGET"; then
11123
  echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11124
echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11125
else
11126
  echo "$as_me:$LINENO: result: no" >&5
11127
echo "${ECHO_T}no" >&6
11128
fi
11129
 
11130
    fi
11131
    if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11132
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11133
set dummy ${ncn_progname}; ac_word=$2
11134
echo "$as_me:$LINENO: checking for $ac_word" >&5
11135
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11136
if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11137
  echo $ECHO_N "(cached) $ECHO_C" >&6
11138
else
11139
  if test -n "$STRIP_FOR_TARGET"; then
11140
  ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11141
else
11142
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11143
for as_dir in $PATH
11144
do
11145
  IFS=$as_save_IFS
11146
  test -z "$as_dir" && as_dir=.
11147
  for ac_exec_ext in '' $ac_executable_extensions; do
11148
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11149
    ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11150
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11151
    break 2
11152
  fi
11153
done
11154
done
11155
 
11156
fi
11157
fi
11158
STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11159
if test -n "$STRIP_FOR_TARGET"; then
11160
  echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11161
echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11162
else
11163
  echo "$as_me:$LINENO: result: no" >&5
11164
echo "${ECHO_T}no" >&6
11165
fi
11166
 
11167
    fi
11168
    test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11169
  done
11170
fi
11171
 
11172
if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11173
  set dummy strip
11174
  if test $build = $target ; then
11175
    STRIP_FOR_TARGET="$2"
11176
  else
11177
    STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11178
  fi
11179
else
11180
  STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11181
fi
11182
 
11183
else
11184
  STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11185
fi
11186
 
11187
 
11188
 
11189
 
11190
if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11191
  if test -n "$with_build_time_tools"; then
11192
    echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11193
echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11194
    if test -x $with_build_time_tools/windres; then
11195
      WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11196
      ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11197
      echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11198
echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11199
    else
11200
      echo "$as_me:$LINENO: result: no" >&5
11201
echo "${ECHO_T}no" >&6
11202
    fi
11203
  elif test $build != $host && test $have_gcc_for_target = yes; then
11204
    WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11205
    test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11206
    test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11207
  fi
11208
fi
11209
if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11210
  # Extract the first word of "windres", so it can be a program name with args.
11211
set dummy windres; ac_word=$2
11212
echo "$as_me:$LINENO: checking for $ac_word" >&5
11213
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11214
if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11215
  echo $ECHO_N "(cached) $ECHO_C" >&6
11216
else
11217
  case $WINDRES_FOR_TARGET in
11218
  [\\/]* | ?:[\\/]*)
11219
  ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11220
  ;;
11221
  *)
11222
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11223
for as_dir in $gcc_cv_tool_dirs
11224
do
11225
  IFS=$as_save_IFS
11226
  test -z "$as_dir" && as_dir=.
11227
  for ac_exec_ext in '' $ac_executable_extensions; do
11228
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11229
    ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11230
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11231
    break 2
11232
  fi
11233
done
11234
done
11235
 
11236
  ;;
11237
esac
11238
fi
11239
WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11240
 
11241
if test -n "$WINDRES_FOR_TARGET"; then
11242
  echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11243
echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11244
else
11245
  echo "$as_me:$LINENO: result: no" >&5
11246
echo "${ECHO_T}no" >&6
11247
fi
11248
 
11249
fi
11250
if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11251
 
11252
 
11253
if test -n "$WINDRES_FOR_TARGET"; then
11254
  ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11255
elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11256
  WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11257
fi
11258
 
11259
if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11260
  for ncn_progname in windres; do
11261
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11262
set dummy ${ncn_progname}; ac_word=$2
11263
echo "$as_me:$LINENO: checking for $ac_word" >&5
11264
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11265
if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11266
  echo $ECHO_N "(cached) $ECHO_C" >&6
11267
else
11268
  if test -n "$WINDRES_FOR_TARGET"; then
11269
  ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11270
else
11271
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11272
for as_dir in $PATH
11273
do
11274
  IFS=$as_save_IFS
11275
  test -z "$as_dir" && as_dir=.
11276
  for ac_exec_ext in '' $ac_executable_extensions; do
11277
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11278
    ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11279
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11280
    break 2
11281
  fi
11282
done
11283
done
11284
 
11285
fi
11286
fi
11287
WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11288
if test -n "$WINDRES_FOR_TARGET"; then
11289
  echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11290
echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11291
else
11292
  echo "$as_me:$LINENO: result: no" >&5
11293
echo "${ECHO_T}no" >&6
11294
fi
11295
 
11296
  done
11297
fi
11298
 
11299
if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11300
  for ncn_progname in windres; do
11301
    echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11302
echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11303
    if test -x $with_build_time_tools/${ncn_progname}; then
11304
      ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11305
      echo "$as_me:$LINENO: result: yes" >&5
11306
echo "${ECHO_T}yes" >&6
11307
      break
11308
    else
11309
      echo "$as_me:$LINENO: result: no" >&5
11310
echo "${ECHO_T}no" >&6
11311
    fi
11312
  done
11313
fi
11314
 
11315
if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11316
  for ncn_progname in windres; do
11317
    if test -n "$ncn_target_tool_prefix"; then
11318
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11319
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11320
echo "$as_me:$LINENO: checking for $ac_word" >&5
11321
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11322
if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11323
  echo $ECHO_N "(cached) $ECHO_C" >&6
11324
else
11325
  if test -n "$WINDRES_FOR_TARGET"; then
11326
  ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11327
else
11328
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11329
for as_dir in $PATH
11330
do
11331
  IFS=$as_save_IFS
11332
  test -z "$as_dir" && as_dir=.
11333
  for ac_exec_ext in '' $ac_executable_extensions; do
11334
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11335
    ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11336
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11337
    break 2
11338
  fi
11339
done
11340
done
11341
 
11342
fi
11343
fi
11344
WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11345
if test -n "$WINDRES_FOR_TARGET"; then
11346
  echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11347
echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11348
else
11349
  echo "$as_me:$LINENO: result: no" >&5
11350
echo "${ECHO_T}no" >&6
11351
fi
11352
 
11353
    fi
11354
    if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11355
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11356
set dummy ${ncn_progname}; ac_word=$2
11357
echo "$as_me:$LINENO: checking for $ac_word" >&5
11358
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11359
if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11360
  echo $ECHO_N "(cached) $ECHO_C" >&6
11361
else
11362
  if test -n "$WINDRES_FOR_TARGET"; then
11363
  ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11364
else
11365
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11366
for as_dir in $PATH
11367
do
11368
  IFS=$as_save_IFS
11369
  test -z "$as_dir" && as_dir=.
11370
  for ac_exec_ext in '' $ac_executable_extensions; do
11371
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11372
    ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11373
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11374
    break 2
11375
  fi
11376
done
11377
done
11378
 
11379
fi
11380
fi
11381
WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11382
if test -n "$WINDRES_FOR_TARGET"; then
11383
  echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11384
echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11385
else
11386
  echo "$as_me:$LINENO: result: no" >&5
11387
echo "${ECHO_T}no" >&6
11388
fi
11389
 
11390
    fi
11391
    test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11392
  done
11393
fi
11394
 
11395
if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11396
  set dummy windres
11397
  if test $build = $target ; then
11398
    WINDRES_FOR_TARGET="$2"
11399
  else
11400
    WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11401
  fi
11402
else
11403
  WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11404
fi
11405
 
11406
else
11407
  WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11408
fi
11409
 
11410
 
11411
 
11412
 
11413
if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11414
  if test -n "$with_build_time_tools"; then
11415
    echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11416
echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11417
    if test -x $with_build_time_tools/windmc; then
11418
      WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11419
      ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11420
      echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11421
echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11422
    else
11423
      echo "$as_me:$LINENO: result: no" >&5
11424
echo "${ECHO_T}no" >&6
11425
    fi
11426
  elif test $build != $host && test $have_gcc_for_target = yes; then
11427
    WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11428
    test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11429
    test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11430
  fi
11431
fi
11432
if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11433
  # Extract the first word of "windmc", so it can be a program name with args.
11434
set dummy windmc; ac_word=$2
11435
echo "$as_me:$LINENO: checking for $ac_word" >&5
11436
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11437
if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11438
  echo $ECHO_N "(cached) $ECHO_C" >&6
11439
else
11440
  case $WINDMC_FOR_TARGET in
11441
  [\\/]* | ?:[\\/]*)
11442
  ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11443
  ;;
11444
  *)
11445
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11446
for as_dir in $gcc_cv_tool_dirs
11447
do
11448
  IFS=$as_save_IFS
11449
  test -z "$as_dir" && as_dir=.
11450
  for ac_exec_ext in '' $ac_executable_extensions; do
11451
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11452
    ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11453
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11454
    break 2
11455
  fi
11456
done
11457
done
11458
 
11459
  ;;
11460
esac
11461
fi
11462
WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11463
 
11464
if test -n "$WINDMC_FOR_TARGET"; then
11465
  echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11466
echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11467
else
11468
  echo "$as_me:$LINENO: result: no" >&5
11469
echo "${ECHO_T}no" >&6
11470
fi
11471
 
11472
fi
11473
if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11474
 
11475
 
11476
if test -n "$WINDMC_FOR_TARGET"; then
11477
  ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11478
elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11479
  WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11480
fi
11481
 
11482
if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11483
  for ncn_progname in windmc; do
11484
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11485
set dummy ${ncn_progname}; ac_word=$2
11486
echo "$as_me:$LINENO: checking for $ac_word" >&5
11487
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11488
if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11489
  echo $ECHO_N "(cached) $ECHO_C" >&6
11490
else
11491
  if test -n "$WINDMC_FOR_TARGET"; then
11492
  ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11493
else
11494
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11495
for as_dir in $PATH
11496
do
11497
  IFS=$as_save_IFS
11498
  test -z "$as_dir" && as_dir=.
11499
  for ac_exec_ext in '' $ac_executable_extensions; do
11500
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11501
    ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11502
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11503
    break 2
11504
  fi
11505
done
11506
done
11507
 
11508
fi
11509
fi
11510
WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11511
if test -n "$WINDMC_FOR_TARGET"; then
11512
  echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11513
echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11514
else
11515
  echo "$as_me:$LINENO: result: no" >&5
11516
echo "${ECHO_T}no" >&6
11517
fi
11518
 
11519
  done
11520
fi
11521
 
11522
if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11523
  for ncn_progname in windmc; do
11524
    echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11525
echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11526
    if test -x $with_build_time_tools/${ncn_progname}; then
11527
      ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11528
      echo "$as_me:$LINENO: result: yes" >&5
11529
echo "${ECHO_T}yes" >&6
11530
      break
11531
    else
11532
      echo "$as_me:$LINENO: result: no" >&5
11533
echo "${ECHO_T}no" >&6
11534
    fi
11535
  done
11536
fi
11537
 
11538
if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11539
  for ncn_progname in windmc; do
11540
    if test -n "$ncn_target_tool_prefix"; then
11541
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11542
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11543
echo "$as_me:$LINENO: checking for $ac_word" >&5
11544
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11545
if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11546
  echo $ECHO_N "(cached) $ECHO_C" >&6
11547
else
11548
  if test -n "$WINDMC_FOR_TARGET"; then
11549
  ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11550
else
11551
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11552
for as_dir in $PATH
11553
do
11554
  IFS=$as_save_IFS
11555
  test -z "$as_dir" && as_dir=.
11556
  for ac_exec_ext in '' $ac_executable_extensions; do
11557
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11558
    ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11559
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11560
    break 2
11561
  fi
11562
done
11563
done
11564
 
11565
fi
11566
fi
11567
WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11568
if test -n "$WINDMC_FOR_TARGET"; then
11569
  echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11570
echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11571
else
11572
  echo "$as_me:$LINENO: result: no" >&5
11573
echo "${ECHO_T}no" >&6
11574
fi
11575
 
11576
    fi
11577
    if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11578
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11579
set dummy ${ncn_progname}; ac_word=$2
11580
echo "$as_me:$LINENO: checking for $ac_word" >&5
11581
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11582
if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11583
  echo $ECHO_N "(cached) $ECHO_C" >&6
11584
else
11585
  if test -n "$WINDMC_FOR_TARGET"; then
11586
  ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11587
else
11588
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11589
for as_dir in $PATH
11590
do
11591
  IFS=$as_save_IFS
11592
  test -z "$as_dir" && as_dir=.
11593
  for ac_exec_ext in '' $ac_executable_extensions; do
11594
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11595
    ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11596
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11597
    break 2
11598
  fi
11599
done
11600
done
11601
 
11602
fi
11603
fi
11604
WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11605
if test -n "$WINDMC_FOR_TARGET"; then
11606
  echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11607
echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11608
else
11609
  echo "$as_me:$LINENO: result: no" >&5
11610
echo "${ECHO_T}no" >&6
11611
fi
11612
 
11613
    fi
11614
    test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11615
  done
11616
fi
11617
 
11618
if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11619
  set dummy windmc
11620
  if test $build = $target ; then
11621
    WINDMC_FOR_TARGET="$2"
11622
  else
11623
    WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11624
  fi
11625
else
11626
  WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11627
fi
11628
 
11629
else
11630
  WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11631
fi
11632
 
11633
 
11634
RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11635
 
11636
echo "$as_me:$LINENO: checking where to find the target ar" >&5
11637
echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11638
if test "x${build}" != "x${host}" ; then
11639
  if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11640
    # We already found the complete path
11641
    ac_dir=`dirname $AR_FOR_TARGET`
11642
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11643
echo "${ECHO_T}pre-installed in $ac_dir" >&6
11644
  else
11645
    # Canadian cross, just use what we found
11646
    echo "$as_me:$LINENO: result: pre-installed" >&5
11647
echo "${ECHO_T}pre-installed" >&6
11648
  fi
11649
else
11650
  ok=yes
11651
  case " ${configdirs} " in
11652
    *" binutils "*) ;;
11653
    *) ok=no ;;
11654
  esac
11655
 
11656
  if test $ok = yes; then
11657
    # An in-tree tool is available and we can use it
11658
    AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11659
    echo "$as_me:$LINENO: result: just compiled" >&5
11660
echo "${ECHO_T}just compiled" >&6
11661
  elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11662
    # We already found the complete path
11663
    ac_dir=`dirname $AR_FOR_TARGET`
11664
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11665
echo "${ECHO_T}pre-installed in $ac_dir" >&6
11666
  elif test "x$target" = "x$host"; then
11667
    # We can use an host tool
11668
    AR_FOR_TARGET='$(AR)'
11669
    echo "$as_me:$LINENO: result: host tool" >&5
11670
echo "${ECHO_T}host tool" >&6
11671
  else
11672
    # We need a cross tool
11673
    echo "$as_me:$LINENO: result: pre-installed" >&5
11674
echo "${ECHO_T}pre-installed" >&6
11675
  fi
11676
fi
11677
 
11678
echo "$as_me:$LINENO: checking where to find the target as" >&5
11679
echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11680
if test "x${build}" != "x${host}" ; then
11681
  if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11682
    # We already found the complete path
11683
    ac_dir=`dirname $AS_FOR_TARGET`
11684
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11685
echo "${ECHO_T}pre-installed in $ac_dir" >&6
11686
  else
11687
    # Canadian cross, just use what we found
11688
    echo "$as_me:$LINENO: result: pre-installed" >&5
11689
echo "${ECHO_T}pre-installed" >&6
11690
  fi
11691
else
11692
  ok=yes
11693
  case " ${configdirs} " in
11694
    *" gas "*) ;;
11695
    *) ok=no ;;
11696
  esac
11697
 
11698
  if test $ok = yes; then
11699
    # An in-tree tool is available and we can use it
11700
    AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11701
    echo "$as_me:$LINENO: result: just compiled" >&5
11702
echo "${ECHO_T}just compiled" >&6
11703
  elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11704
    # We already found the complete path
11705
    ac_dir=`dirname $AS_FOR_TARGET`
11706
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11707
echo "${ECHO_T}pre-installed in $ac_dir" >&6
11708
  elif test "x$target" = "x$host"; then
11709
    # We can use an host tool
11710
    AS_FOR_TARGET='$(AS)'
11711
    echo "$as_me:$LINENO: result: host tool" >&5
11712
echo "${ECHO_T}host tool" >&6
11713
  else
11714
    # We need a cross tool
11715
    echo "$as_me:$LINENO: result: pre-installed" >&5
11716
echo "${ECHO_T}pre-installed" >&6
11717
  fi
11718
fi
11719
 
11720
echo "$as_me:$LINENO: checking where to find the target cc" >&5
11721
echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11722
if test "x${build}" != "x${host}" ; then
11723
  if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11724
    # We already found the complete path
11725
    ac_dir=`dirname $CC_FOR_TARGET`
11726
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11727
echo "${ECHO_T}pre-installed in $ac_dir" >&6
11728
  else
11729
    # Canadian cross, just use what we found
11730
    echo "$as_me:$LINENO: result: pre-installed" >&5
11731
echo "${ECHO_T}pre-installed" >&6
11732
  fi
11733
else
11734
  ok=yes
11735
  case " ${configdirs} " in
11736
    *" gcc "*) ;;
11737
    *) ok=no ;;
11738
  esac
11739
 
11740
  if test $ok = yes; then
11741
    # An in-tree tool is available and we can use it
11742
    CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11743
    echo "$as_me:$LINENO: result: just compiled" >&5
11744
echo "${ECHO_T}just compiled" >&6
11745
  elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11746
    # We already found the complete path
11747
    ac_dir=`dirname $CC_FOR_TARGET`
11748
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11749
echo "${ECHO_T}pre-installed in $ac_dir" >&6
11750
  elif test "x$target" = "x$host"; then
11751
    # We can use an host tool
11752
    CC_FOR_TARGET='$(CC)'
11753
    echo "$as_me:$LINENO: result: host tool" >&5
11754
echo "${ECHO_T}host tool" >&6
11755
  else
11756
    # We need a cross tool
11757
    echo "$as_me:$LINENO: result: pre-installed" >&5
11758
echo "${ECHO_T}pre-installed" >&6
11759
  fi
11760
fi
11761
 
11762
echo "$as_me:$LINENO: checking where to find the target c++" >&5
11763
echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11764
if test "x${build}" != "x${host}" ; then
11765
  if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11766
    # We already found the complete path
11767
    ac_dir=`dirname $CXX_FOR_TARGET`
11768
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11769
echo "${ECHO_T}pre-installed in $ac_dir" >&6
11770
  else
11771
    # Canadian cross, just use what we found
11772
    echo "$as_me:$LINENO: result: pre-installed" >&5
11773
echo "${ECHO_T}pre-installed" >&6
11774
  fi
11775
else
11776
  ok=yes
11777
  case " ${configdirs} " in
11778
    *" gcc "*) ;;
11779
    *) ok=no ;;
11780
  esac
11781
  case ,${enable_languages}, in
11782
    *,c++,*) ;;
11783
    *) ok=no ;;
11784
  esac
11785
  if test $ok = yes; then
11786
    # An in-tree tool is available and we can use it
11787
    CXX_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/g++ -B$$r/$(HOST_SUBDIR)/gcc/ -nostdinc++ `test ! -f $$r/$(TARGET_SUBDIR)/libstdc++-v3/scripts/testsuite_flags || $(SHELL) $$r/$(TARGET_SUBDIR)/libstdc++-v3/scripts/testsuite_flags --build-includes` -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src/.libs'
11788
    echo "$as_me:$LINENO: result: just compiled" >&5
11789
echo "${ECHO_T}just compiled" >&6
11790
  elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11791
    # We already found the complete path
11792
    ac_dir=`dirname $CXX_FOR_TARGET`
11793
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11794
echo "${ECHO_T}pre-installed in $ac_dir" >&6
11795
  elif test "x$target" = "x$host"; then
11796
    # We can use an host tool
11797
    CXX_FOR_TARGET='$(CXX)'
11798
    echo "$as_me:$LINENO: result: host tool" >&5
11799
echo "${ECHO_T}host tool" >&6
11800
  else
11801
    # We need a cross tool
11802
    echo "$as_me:$LINENO: result: pre-installed" >&5
11803
echo "${ECHO_T}pre-installed" >&6
11804
  fi
11805
fi
11806
 
11807
echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11808
echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11809
if test "x${build}" != "x${host}" ; then
11810
  if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11811
    # We already found the complete path
11812
    ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11813
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11814
echo "${ECHO_T}pre-installed in $ac_dir" >&6
11815
  else
11816
    # Canadian cross, just use what we found
11817
    echo "$as_me:$LINENO: result: pre-installed" >&5
11818
echo "${ECHO_T}pre-installed" >&6
11819
  fi
11820
else
11821
  ok=yes
11822
  case " ${configdirs} " in
11823
    *" gcc "*) ;;
11824
    *) ok=no ;;
11825
  esac
11826
  case ,${enable_languages}, in
11827
    *,c++,*) ;;
11828
    *) ok=no ;;
11829
  esac
11830
  if test $ok = yes; then
11831
    # An in-tree tool is available and we can use it
11832
    RAW_CXX_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -shared-libgcc -B$$r/$(HOST_SUBDIR)/gcc -nostdinc++ -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src/.libs'
11833
    echo "$as_me:$LINENO: result: just compiled" >&5
11834
echo "${ECHO_T}just compiled" >&6
11835
  elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11836
    # We already found the complete path
11837
    ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11838
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11839
echo "${ECHO_T}pre-installed in $ac_dir" >&6
11840
  elif test "x$target" = "x$host"; then
11841
    # We can use an host tool
11842
    RAW_CXX_FOR_TARGET='$(CXX)'
11843
    echo "$as_me:$LINENO: result: host tool" >&5
11844
echo "${ECHO_T}host tool" >&6
11845
  else
11846
    # We need a cross tool
11847
    echo "$as_me:$LINENO: result: pre-installed" >&5
11848
echo "${ECHO_T}pre-installed" >&6
11849
  fi
11850
fi
11851
 
11852
echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11853
echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11854
if test "x${build}" != "x${host}" ; then
11855
  if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11856
    # We already found the complete path
11857
    ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11858
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11859
echo "${ECHO_T}pre-installed in $ac_dir" >&6
11860
  else
11861
    # Canadian cross, just use what we found
11862
    echo "$as_me:$LINENO: result: pre-installed" >&5
11863
echo "${ECHO_T}pre-installed" >&6
11864
  fi
11865
else
11866
  ok=yes
11867
  case " ${configdirs} " in
11868
    *" binutils "*) ;;
11869
    *) ok=no ;;
11870
  esac
11871
 
11872
  if test $ok = yes; then
11873
    # An in-tree tool is available and we can use it
11874
    DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11875
    echo "$as_me:$LINENO: result: just compiled" >&5
11876
echo "${ECHO_T}just compiled" >&6
11877
  elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11878
    # We already found the complete path
11879
    ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11880
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11881
echo "${ECHO_T}pre-installed in $ac_dir" >&6
11882
  elif test "x$target" = "x$host"; then
11883
    # We can use an host tool
11884
    DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11885
    echo "$as_me:$LINENO: result: host tool" >&5
11886
echo "${ECHO_T}host tool" >&6
11887
  else
11888
    # We need a cross tool
11889
    echo "$as_me:$LINENO: result: pre-installed" >&5
11890
echo "${ECHO_T}pre-installed" >&6
11891
  fi
11892
fi
11893
 
11894
echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11895
echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11896
if test "x${build}" != "x${host}" ; then
11897
  if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11898
    # We already found the complete path
11899
    ac_dir=`dirname $GCC_FOR_TARGET`
11900
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11901
echo "${ECHO_T}pre-installed in $ac_dir" >&6
11902
  else
11903
    # Canadian cross, just use what we found
11904
    echo "$as_me:$LINENO: result: pre-installed" >&5
11905
echo "${ECHO_T}pre-installed" >&6
11906
  fi
11907
else
11908
  ok=yes
11909
  case " ${configdirs} " in
11910
    *" gcc "*) ;;
11911
    *) ok=no ;;
11912
  esac
11913
 
11914
  if test $ok = yes; then
11915
    # An in-tree tool is available and we can use it
11916
    GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11917
    echo "$as_me:$LINENO: result: just compiled" >&5
11918
echo "${ECHO_T}just compiled" >&6
11919
  elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11920
    # We already found the complete path
11921
    ac_dir=`dirname $GCC_FOR_TARGET`
11922
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11923
echo "${ECHO_T}pre-installed in $ac_dir" >&6
11924
  elif test "x$target" = "x$host"; then
11925
    # We can use an host tool
11926
    GCC_FOR_TARGET='$()'
11927
    echo "$as_me:$LINENO: result: host tool" >&5
11928
echo "${ECHO_T}host tool" >&6
11929
  else
11930
    # We need a cross tool
11931
    echo "$as_me:$LINENO: result: pre-installed" >&5
11932
echo "${ECHO_T}pre-installed" >&6
11933
  fi
11934
fi
11935
 
11936
echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11937
echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11938
if test "x${build}" != "x${host}" ; then
11939
  if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11940
    # We already found the complete path
11941
    ac_dir=`dirname $GCJ_FOR_TARGET`
11942
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11943
echo "${ECHO_T}pre-installed in $ac_dir" >&6
11944
  else
11945
    # Canadian cross, just use what we found
11946
    echo "$as_me:$LINENO: result: pre-installed" >&5
11947
echo "${ECHO_T}pre-installed" >&6
11948
  fi
11949
else
11950
  ok=yes
11951
  case " ${configdirs} " in
11952
    *" gcc "*) ;;
11953
    *) ok=no ;;
11954
  esac
11955
  case ,${enable_languages}, in
11956
    *,java,*) ;;
11957
    *) ok=no ;;
11958
  esac
11959
  if test $ok = yes; then
11960
    # An in-tree tool is available and we can use it
11961
    GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11962
    echo "$as_me:$LINENO: result: just compiled" >&5
11963
echo "${ECHO_T}just compiled" >&6
11964
  elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11965
    # We already found the complete path
11966
    ac_dir=`dirname $GCJ_FOR_TARGET`
11967
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11968
echo "${ECHO_T}pre-installed in $ac_dir" >&6
11969
  elif test "x$target" = "x$host"; then
11970
    # We can use an host tool
11971
    GCJ_FOR_TARGET='$(GCJ)'
11972
    echo "$as_me:$LINENO: result: host tool" >&5
11973
echo "${ECHO_T}host tool" >&6
11974
  else
11975
    # We need a cross tool
11976
    echo "$as_me:$LINENO: result: pre-installed" >&5
11977
echo "${ECHO_T}pre-installed" >&6
11978
  fi
11979
fi
11980
 
11981
echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11982
echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11983
if test "x${build}" != "x${host}" ; then
11984
  if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11985
    # We already found the complete path
11986
    ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11987
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11988
echo "${ECHO_T}pre-installed in $ac_dir" >&6
11989
  else
11990
    # Canadian cross, just use what we found
11991
    echo "$as_me:$LINENO: result: pre-installed" >&5
11992
echo "${ECHO_T}pre-installed" >&6
11993
  fi
11994
else
11995
  ok=yes
11996
  case " ${configdirs} " in
11997
    *" gcc "*) ;;
11998
    *) ok=no ;;
11999
  esac
12000
  case ,${enable_languages}, in
12001
    *,fortran,*) ;;
12002
    *) ok=no ;;
12003
  esac
12004
  if test $ok = yes; then
12005
    # An in-tree tool is available and we can use it
12006
    GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12007
    echo "$as_me:$LINENO: result: just compiled" >&5
12008
echo "${ECHO_T}just compiled" >&6
12009
  elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12010
    # We already found the complete path
12011
    ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12012
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12013
echo "${ECHO_T}pre-installed in $ac_dir" >&6
12014
  elif test "x$target" = "x$host"; then
12015
    # We can use an host tool
12016
    GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12017
    echo "$as_me:$LINENO: result: host tool" >&5
12018
echo "${ECHO_T}host tool" >&6
12019
  else
12020
    # We need a cross tool
12021
    echo "$as_me:$LINENO: result: pre-installed" >&5
12022
echo "${ECHO_T}pre-installed" >&6
12023
  fi
12024
fi
12025
 
12026
echo "$as_me:$LINENO: checking where to find the target ld" >&5
12027
echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12028
if test "x${build}" != "x${host}" ; then
12029
  if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12030
    # We already found the complete path
12031
    ac_dir=`dirname $LD_FOR_TARGET`
12032
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12033
echo "${ECHO_T}pre-installed in $ac_dir" >&6
12034
  else
12035
    # Canadian cross, just use what we found
12036
    echo "$as_me:$LINENO: result: pre-installed" >&5
12037
echo "${ECHO_T}pre-installed" >&6
12038
  fi
12039
else
12040
  ok=yes
12041
  case " ${configdirs} " in
12042
    *" ld "*) ;;
12043
    *) ok=no ;;
12044
  esac
12045
 
12046
  if test $ok = yes; then
12047
    # An in-tree tool is available and we can use it
12048
    LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12049
    echo "$as_me:$LINENO: result: just compiled" >&5
12050
echo "${ECHO_T}just compiled" >&6
12051
  elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12052
    # We already found the complete path
12053
    ac_dir=`dirname $LD_FOR_TARGET`
12054
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12055
echo "${ECHO_T}pre-installed in $ac_dir" >&6
12056
  elif test "x$target" = "x$host"; then
12057
    # We can use an host tool
12058
    LD_FOR_TARGET='$(LD)'
12059
    echo "$as_me:$LINENO: result: host tool" >&5
12060
echo "${ECHO_T}host tool" >&6
12061
  else
12062
    # We need a cross tool
12063
    echo "$as_me:$LINENO: result: pre-installed" >&5
12064
echo "${ECHO_T}pre-installed" >&6
12065
  fi
12066
fi
12067
 
12068
echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12069
echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12070
if test "x${build}" != "x${host}" ; then
12071
  if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12072
    # We already found the complete path
12073
    ac_dir=`dirname $LIPO_FOR_TARGET`
12074
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12075
echo "${ECHO_T}pre-installed in $ac_dir" >&6
12076
  else
12077
    # Canadian cross, just use what we found
12078
    echo "$as_me:$LINENO: result: pre-installed" >&5
12079
echo "${ECHO_T}pre-installed" >&6
12080
  fi
12081
else
12082
  if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12083
    # We already found the complete path
12084
    ac_dir=`dirname $LIPO_FOR_TARGET`
12085
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12086
echo "${ECHO_T}pre-installed in $ac_dir" >&6
12087
  elif test "x$target" = "x$host"; then
12088
    # We can use an host tool
12089
    LIPO_FOR_TARGET='$(LIPO)'
12090
    echo "$as_me:$LINENO: result: host tool" >&5
12091
echo "${ECHO_T}host tool" >&6
12092
  else
12093
    # We need a cross tool
12094
    echo "$as_me:$LINENO: result: pre-installed" >&5
12095
echo "${ECHO_T}pre-installed" >&6
12096
  fi
12097
fi
12098
 
12099
echo "$as_me:$LINENO: checking where to find the target nm" >&5
12100
echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12101
if test "x${build}" != "x${host}" ; then
12102
  if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12103
    # We already found the complete path
12104
    ac_dir=`dirname $NM_FOR_TARGET`
12105
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12106
echo "${ECHO_T}pre-installed in $ac_dir" >&6
12107
  else
12108
    # Canadian cross, just use what we found
12109
    echo "$as_me:$LINENO: result: pre-installed" >&5
12110
echo "${ECHO_T}pre-installed" >&6
12111
  fi
12112
else
12113
  ok=yes
12114
  case " ${configdirs} " in
12115
    *" binutils "*) ;;
12116
    *) ok=no ;;
12117
  esac
12118
 
12119
  if test $ok = yes; then
12120
    # An in-tree tool is available and we can use it
12121
    NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12122
    echo "$as_me:$LINENO: result: just compiled" >&5
12123
echo "${ECHO_T}just compiled" >&6
12124
  elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12125
    # We already found the complete path
12126
    ac_dir=`dirname $NM_FOR_TARGET`
12127
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12128
echo "${ECHO_T}pre-installed in $ac_dir" >&6
12129
  elif test "x$target" = "x$host"; then
12130
    # We can use an host tool
12131
    NM_FOR_TARGET='$(NM)'
12132
    echo "$as_me:$LINENO: result: host tool" >&5
12133
echo "${ECHO_T}host tool" >&6
12134
  else
12135
    # We need a cross tool
12136
    echo "$as_me:$LINENO: result: pre-installed" >&5
12137
echo "${ECHO_T}pre-installed" >&6
12138
  fi
12139
fi
12140
 
12141
echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12142
echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12143
if test "x${build}" != "x${host}" ; then
12144
  if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12145
    # We already found the complete path
12146
    ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12147
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12148
echo "${ECHO_T}pre-installed in $ac_dir" >&6
12149
  else
12150
    # Canadian cross, just use what we found
12151
    echo "$as_me:$LINENO: result: pre-installed" >&5
12152
echo "${ECHO_T}pre-installed" >&6
12153
  fi
12154
else
12155
  ok=yes
12156
  case " ${configdirs} " in
12157
    *" binutils "*) ;;
12158
    *) ok=no ;;
12159
  esac
12160
 
12161
  if test $ok = yes; then
12162
    # An in-tree tool is available and we can use it
12163
    OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12164
    echo "$as_me:$LINENO: result: just compiled" >&5
12165
echo "${ECHO_T}just compiled" >&6
12166
  elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12167
    # We already found the complete path
12168
    ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12169
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12170
echo "${ECHO_T}pre-installed in $ac_dir" >&6
12171
  elif test "x$target" = "x$host"; then
12172
    # We can use an host tool
12173
    OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12174
    echo "$as_me:$LINENO: result: host tool" >&5
12175
echo "${ECHO_T}host tool" >&6
12176
  else
12177
    # We need a cross tool
12178
    echo "$as_me:$LINENO: result: pre-installed" >&5
12179
echo "${ECHO_T}pre-installed" >&6
12180
  fi
12181
fi
12182
 
12183
echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12184
echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12185
if test "x${build}" != "x${host}" ; then
12186
  if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12187
    # We already found the complete path
12188
    ac_dir=`dirname $RANLIB_FOR_TARGET`
12189
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12190
echo "${ECHO_T}pre-installed in $ac_dir" >&6
12191
  else
12192
    # Canadian cross, just use what we found
12193
    echo "$as_me:$LINENO: result: pre-installed" >&5
12194
echo "${ECHO_T}pre-installed" >&6
12195
  fi
12196
else
12197
  ok=yes
12198
  case " ${configdirs} " in
12199
    *" binutils "*) ;;
12200
    *) ok=no ;;
12201
  esac
12202
 
12203
  if test $ok = yes; then
12204
    # An in-tree tool is available and we can use it
12205
    RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12206
    echo "$as_me:$LINENO: result: just compiled" >&5
12207
echo "${ECHO_T}just compiled" >&6
12208
  elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12209
    # We already found the complete path
12210
    ac_dir=`dirname $RANLIB_FOR_TARGET`
12211
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12212
echo "${ECHO_T}pre-installed in $ac_dir" >&6
12213
  elif test "x$target" = "x$host"; then
12214
    # We can use an host tool
12215
    RANLIB_FOR_TARGET='$(RANLIB)'
12216
    echo "$as_me:$LINENO: result: host tool" >&5
12217
echo "${ECHO_T}host tool" >&6
12218
  else
12219
    # We need a cross tool
12220
    echo "$as_me:$LINENO: result: pre-installed" >&5
12221
echo "${ECHO_T}pre-installed" >&6
12222
  fi
12223
fi
12224
 
12225
echo "$as_me:$LINENO: checking where to find the target strip" >&5
12226
echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12227
if test "x${build}" != "x${host}" ; then
12228
  if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12229
    # We already found the complete path
12230
    ac_dir=`dirname $STRIP_FOR_TARGET`
12231
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12232
echo "${ECHO_T}pre-installed in $ac_dir" >&6
12233
  else
12234
    # Canadian cross, just use what we found
12235
    echo "$as_me:$LINENO: result: pre-installed" >&5
12236
echo "${ECHO_T}pre-installed" >&6
12237
  fi
12238
else
12239
  ok=yes
12240
  case " ${configdirs} " in
12241
    *" binutils "*) ;;
12242
    *) ok=no ;;
12243
  esac
12244
 
12245
  if test $ok = yes; then
12246
    # An in-tree tool is available and we can use it
12247
    STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12248
    echo "$as_me:$LINENO: result: just compiled" >&5
12249
echo "${ECHO_T}just compiled" >&6
12250
  elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12251
    # We already found the complete path
12252
    ac_dir=`dirname $STRIP_FOR_TARGET`
12253
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12254
echo "${ECHO_T}pre-installed in $ac_dir" >&6
12255
  elif test "x$target" = "x$host"; then
12256
    # We can use an host tool
12257
    STRIP_FOR_TARGET='$(STRIP)'
12258
    echo "$as_me:$LINENO: result: host tool" >&5
12259
echo "${ECHO_T}host tool" >&6
12260
  else
12261
    # We need a cross tool
12262
    echo "$as_me:$LINENO: result: pre-installed" >&5
12263
echo "${ECHO_T}pre-installed" >&6
12264
  fi
12265
fi
12266
 
12267
echo "$as_me:$LINENO: checking where to find the target windres" >&5
12268
echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12269
if test "x${build}" != "x${host}" ; then
12270
  if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12271
    # We already found the complete path
12272
    ac_dir=`dirname $WINDRES_FOR_TARGET`
12273
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12274
echo "${ECHO_T}pre-installed in $ac_dir" >&6
12275
  else
12276
    # Canadian cross, just use what we found
12277
    echo "$as_me:$LINENO: result: pre-installed" >&5
12278
echo "${ECHO_T}pre-installed" >&6
12279
  fi
12280
else
12281
  ok=yes
12282
  case " ${configdirs} " in
12283
    *" binutils "*) ;;
12284
    *) ok=no ;;
12285
  esac
12286
 
12287
  if test $ok = yes; then
12288
    # An in-tree tool is available and we can use it
12289
    WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12290
    echo "$as_me:$LINENO: result: just compiled" >&5
12291
echo "${ECHO_T}just compiled" >&6
12292
  elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12293
    # We already found the complete path
12294
    ac_dir=`dirname $WINDRES_FOR_TARGET`
12295
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12296
echo "${ECHO_T}pre-installed in $ac_dir" >&6
12297
  elif test "x$target" = "x$host"; then
12298
    # We can use an host tool
12299
    WINDRES_FOR_TARGET='$(WINDRES)'
12300
    echo "$as_me:$LINENO: result: host tool" >&5
12301
echo "${ECHO_T}host tool" >&6
12302
  else
12303
    # We need a cross tool
12304
    echo "$as_me:$LINENO: result: pre-installed" >&5
12305
echo "${ECHO_T}pre-installed" >&6
12306
  fi
12307
fi
12308
 
12309
echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12310
echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12311
if test "x${build}" != "x${host}" ; then
12312
  if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12313
    # We already found the complete path
12314
    ac_dir=`dirname $WINDMC_FOR_TARGET`
12315
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12316
echo "${ECHO_T}pre-installed in $ac_dir" >&6
12317
  else
12318
    # Canadian cross, just use what we found
12319
    echo "$as_me:$LINENO: result: pre-installed" >&5
12320
echo "${ECHO_T}pre-installed" >&6
12321
  fi
12322
else
12323
  ok=yes
12324
  case " ${configdirs} " in
12325
    *" binutils "*) ;;
12326
    *) ok=no ;;
12327
  esac
12328
 
12329
  if test $ok = yes; then
12330
    # An in-tree tool is available and we can use it
12331
    WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12332
    echo "$as_me:$LINENO: result: just compiled" >&5
12333
echo "${ECHO_T}just compiled" >&6
12334
  elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12335
    # We already found the complete path
12336
    ac_dir=`dirname $WINDMC_FOR_TARGET`
12337
    echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12338
echo "${ECHO_T}pre-installed in $ac_dir" >&6
12339
  elif test "x$target" = "x$host"; then
12340
    # We can use an host tool
12341
    WINDMC_FOR_TARGET='$(WINDMC)'
12342
    echo "$as_me:$LINENO: result: host tool" >&5
12343
echo "${ECHO_T}host tool" >&6
12344
  else
12345
    # We need a cross tool
12346
    echo "$as_me:$LINENO: result: pre-installed" >&5
12347
echo "${ECHO_T}pre-installed" >&6
12348
  fi
12349
fi
12350
 
12351
 
12352
 
12353
 
12354
 
12355
# Certain tools may need extra flags.
12356
AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12357
RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12358
NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12359
 
12360
# When building target libraries, except in a Canadian cross, we use
12361
# the same toolchain as the compiler we just built.
12362
COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12363
COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12364
COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12365
if test $host = $build; then
12366
  case " $configdirs " in
12367
    *" gcc "*)
12368
      COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12369
      COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12370
      COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12371
      ;;
12372
  esac
12373
fi
12374
 
12375
 
12376
 
12377
 
12378
 
12379
echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12380
echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12381
# Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12382
if test "${enable_maintainer_mode+set}" = set; then
12383
  enableval="$enable_maintainer_mode"
12384
  USE_MAINTAINER_MODE=$enableval
12385
else
12386
  USE_MAINTAINER_MODE=no
12387
fi;
12388
echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12389
echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12390
 
12391
 
12392
if test "$USE_MAINTAINER_MODE" = yes; then
12393
  MAINTAINER_MODE_TRUE=
12394
  MAINTAINER_MODE_FALSE='#'
12395
else
12396
  MAINTAINER_MODE_TRUE='#'
12397
  MAINTAINER_MODE_FALSE=
12398
fi
12399
MAINT=$MAINTAINER_MODE_TRUE
12400
 
12401
# ---------------------
12402
# GCC bootstrap support
12403
# ---------------------
12404
 
12405
# Stage specific cflags for build.
12406
stage1_cflags="-g"
12407
case $build in
12408
  vax-*-*)
12409
    case ${GCC} in
12410
      yes) stage1_cflags="-g -Wa,-J" ;;
12411
      *) stage1_cflags="-g -J" ;;
12412
    esac ;;
12413
esac
12414
 
12415
# This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12416
if test "$GCC" = yes; then
12417
  saved_CFLAGS="$CFLAGS"
12418
 
12419
  # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12420
  CFLAGS="$CFLAGS -fkeep-inline-functions"
12421
  echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12422
echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12423
  cat >conftest.$ac_ext <<_ACEOF
12424
/* confdefs.h.  */
12425
_ACEOF
12426
cat confdefs.h >>conftest.$ac_ext
12427
cat >>conftest.$ac_ext <<_ACEOF
12428
/* end confdefs.h.  */
12429
 
12430
#if (__GNUC__ < 3) \
12431
    || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12432
                          || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12433
#error http://gcc.gnu.org/PR29382
12434
#endif
12435
 
12436
int
12437
main ()
12438
{
12439
 
12440
  ;
12441
  return 0;
12442
}
12443
_ACEOF
12444
rm -f conftest.$ac_objext
12445
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12446
  (eval $ac_compile) 2>conftest.er1
12447
  ac_status=$?
12448
  grep -v '^ *+' conftest.er1 >conftest.err
12449
  rm -f conftest.er1
12450
  cat conftest.err >&5
12451
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12452
  (exit $ac_status); } &&
12453
         { ac_try='test -z "$ac_c_werror_flag"
12454
                         || test ! -s conftest.err'
12455
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12456
  (eval $ac_try) 2>&5
12457
  ac_status=$?
12458
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12459
  (exit $ac_status); }; } &&
12460
         { ac_try='test -s conftest.$ac_objext'
12461
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12462
  (eval $ac_try) 2>&5
12463
  ac_status=$?
12464
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12465
  (exit $ac_status); }; }; then
12466
  echo "$as_me:$LINENO: result: yes" >&5
12467
echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12468
else
12469
  echo "$as_me: failed program was:" >&5
12470
sed 's/^/| /' conftest.$ac_ext >&5
12471
 
12472
echo "$as_me:$LINENO: result: no" >&5
12473
echo "${ECHO_T}no" >&6
12474
fi
12475
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12476
 
12477
  CFLAGS="$saved_CFLAGS"
12478
fi
12479
 
12480
 
12481
 
12482
# Enable --enable-checking in stage1 of the compiler.
12483
# Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12484
if test "${enable_stage1_checking+set}" = set; then
12485
  enableval="$enable_stage1_checking"
12486
  stage1_checking=--enable-checking=${enable_stage1_checking}
12487
else
12488
  if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12489
  stage1_checking=--enable-checking=yes,types
12490
else
12491
  stage1_checking=--enable-checking=$enable_checking,types
12492
fi
12493
fi;
12494
 
12495
 
12496
# Enable -Werror in bootstrap stage2 and later.
12497
# Check whether --enable-werror or --disable-werror was given.
12498
if test "${enable_werror+set}" = set; then
12499
  enableval="$enable_werror"
12500
 
12501
else
12502
  if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12503
  enable_werror=yes
12504
else
12505
  enable_werror=no
12506
fi
12507
fi;
12508
case ${enable_werror} in
12509
  yes) stage2_werror_flag="--enable-werror-always" ;;
12510
  *) stage2_werror_flag="" ;;
12511
esac
12512
 
12513
 
12514
# Flags needed to enable html installing and building
12515
 
12516
# Check whether --with-datarootdir or --without-datarootdir was given.
12517
if test "${with_datarootdir+set}" = set; then
12518
  withval="$with_datarootdir"
12519
  datarootdir="\${prefix}/${withval}"
12520
else
12521
  datarootdir="\${prefix}/share"
12522
fi;
12523
 
12524
 
12525
# Check whether --with-docdir or --without-docdir was given.
12526
if test "${with_docdir+set}" = set; then
12527
  withval="$with_docdir"
12528
  docdir="\${prefix}/${withval}"
12529
else
12530
  docdir="\${datarootdir}/doc"
12531
fi;
12532
 
12533
 
12534
# Check whether --with-pdfdir or --without-pdfdir was given.
12535
if test "${with_pdfdir+set}" = set; then
12536
  withval="$with_pdfdir"
12537
  pdfdir="\${prefix}/${withval}"
12538
else
12539
  pdfdir="\${docdir}"
12540
fi;
12541
 
12542
 
12543
# Check whether --with-htmldir or --without-htmldir was given.
12544
if test "${with_htmldir+set}" = set; then
12545
  withval="$with_htmldir"
12546
  htmldir="\${prefix}/${withval}"
12547
else
12548
  htmldir="\${docdir}"
12549
fi;
12550
 
12551
 
12552
 
12553
 
12554
 
12555
 
12556
          ac_config_files="$ac_config_files Makefile"
12557
cat >confcache <<\_ACEOF
12558
# This file is a shell script that caches the results of configure
12559
# tests run on this system so they can be shared between configure
12560
# scripts and configure runs, see configure's option --config-cache.
12561
# It is not useful on other systems.  If it contains results you don't
12562
# want to keep, you may remove or edit it.
12563
#
12564
# config.status only pays attention to the cache file if you give it
12565
# the --recheck option to rerun configure.
12566
#
12567
# `ac_cv_env_foo' variables (set or unset) will be overridden when
12568
# loading this file, other *unset* `ac_cv_foo' will be assigned the
12569
# following values.
12570
 
12571
_ACEOF
12572
 
12573
# The following way of writing the cache mishandles newlines in values,
12574
# but we know of no workaround that is simple, portable, and efficient.
12575
# So, don't put newlines in cache variables' values.
12576
# Ultrix sh set writes to stderr and can't be redirected directly,
12577
# and sets the high bit in the cache file unless we assign to the vars.
12578
{
12579
  (set) 2>&1 |
12580
    case `(ac_space=' '; set | grep ac_space) 2>&1` in
12581
    *ac_space=\ *)
12582
      # `set' does not quote correctly, so add quotes (double-quote
12583
      # substitution turns \\\\ into \\, and sed turns \\ into \).
12584
      sed -n \
12585
        "s/'/'\\\\''/g;
12586
          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12587
      ;;
12588
    *)
12589
      # `set' quotes correctly as required by POSIX, so do not add quotes.
12590
      sed -n \
12591
        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12592
      ;;
12593
    esac;
12594
} |
12595
  sed '
12596
     t clear
12597
     : clear
12598
     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12599
     t end
12600
     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12601
     : end' >>confcache
12602
if diff $cache_file confcache >/dev/null 2>&1; then :; else
12603
  if test -w $cache_file; then
12604
    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12605
    cat confcache >$cache_file
12606
  else
12607
    echo "not updating unwritable cache $cache_file"
12608
  fi
12609
fi
12610
rm -f confcache
12611
 
12612
test "x$prefix" = xNONE && prefix=$ac_default_prefix
12613
# Let make expand exec_prefix.
12614
test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12615
 
12616
# VPATH may cause trouble with some makes, so we remove $(srcdir),
12617
# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12618
# trailing colons and then remove the whole line if VPATH becomes empty
12619
# (actually we leave an empty line to preserve line numbers).
12620
if test "x$srcdir" = x.; then
12621
  ac_vpsub='/^[  ]*VPATH[        ]*=/{
12622
s/:*\$(srcdir):*/:/;
12623
s/:*\${srcdir}:*/:/;
12624
s/:*@srcdir@:*/:/;
12625
s/^\([^=]*=[     ]*\):*/\1/;
12626
s/:*$//;
12627
s/^[^=]*=[       ]*$//;
12628
}'
12629
fi
12630
 
12631
# Transform confdefs.h into DEFS.
12632
# Protect against shell expansion while executing Makefile rules.
12633
# Protect against Makefile macro expansion.
12634
#
12635
# If the first sed substitution is executed (which looks for macros that
12636
# take arguments), then we branch to the quote section.  Otherwise,
12637
# look for a macro that doesn't take arguments.
12638
cat >confdef2opt.sed <<\_ACEOF
12639
t clear
12640
: clear
12641
s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12642
t quote
12643
s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12644
t quote
12645
d
12646
: quote
12647
s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12648
s,\[,\\&,g
12649
s,\],\\&,g
12650
s,\$,$$,g
12651
p
12652
_ACEOF
12653
# We use echo to avoid assuming a particular line-breaking character.
12654
# The extra dot is to prevent the shell from consuming trailing
12655
# line-breaks from the sub-command output.  A line-break within
12656
# single-quotes doesn't work because, if this script is created in a
12657
# platform that uses two characters for line-breaks (e.g., DOS), tr
12658
# would break.
12659
ac_LF_and_DOT=`echo; echo .`
12660
DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12661
rm -f confdef2opt.sed
12662
 
12663
 
12664
ac_libobjs=
12665
ac_ltlibobjs=
12666
for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12667
  # 1. Remove the extension, and $U if already installed.
12668
  ac_i=`echo "$ac_i" |
12669
         sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12670
  # 2. Add them.
12671
  ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12672
  ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12673
done
12674
LIBOBJS=$ac_libobjs
12675
 
12676
LTLIBOBJS=$ac_ltlibobjs
12677
 
12678
 
12679
 
12680
: ${CONFIG_STATUS=./config.status}
12681
ac_clean_files_save=$ac_clean_files
12682
ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12683
{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12684
echo "$as_me: creating $CONFIG_STATUS" >&6;}
12685
cat >$CONFIG_STATUS <<_ACEOF
12686
#! $SHELL
12687
# Generated by $as_me.
12688
# Run this file to recreate the current configuration.
12689
# Compiler output produced by configure, useful for debugging
12690
# configure, is in config.log if it exists.
12691
 
12692
debug=false
12693
ac_cs_recheck=false
12694
ac_cs_silent=false
12695
SHELL=\${CONFIG_SHELL-$SHELL}
12696
_ACEOF
12697
 
12698
cat >>$CONFIG_STATUS <<\_ACEOF
12699
## --------------------- ##
12700
## M4sh Initialization.  ##
12701
## --------------------- ##
12702
 
12703
# Be Bourne compatible
12704
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12705
  emulate sh
12706
  NULLCMD=:
12707
  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12708
  # is contrary to our usage.  Disable this feature.
12709
  alias -g '${1+"$@"}'='"$@"'
12710
elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12711
  set -o posix
12712
fi
12713
DUALCASE=1; export DUALCASE # for MKS sh
12714
 
12715
# Support unset when possible.
12716
if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12717
  as_unset=unset
12718
else
12719
  as_unset=false
12720
fi
12721
 
12722
 
12723
# Work around bugs in pre-3.0 UWIN ksh.
12724
$as_unset ENV MAIL MAILPATH
12725
PS1='$ '
12726
PS2='> '
12727
PS4='+ '
12728
 
12729
# NLS nuisances.
12730
for as_var in \
12731
  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12732
  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12733
  LC_TELEPHONE LC_TIME
12734
do
12735
  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12736
    eval $as_var=C; export $as_var
12737
  else
12738
    $as_unset $as_var
12739
  fi
12740
done
12741
 
12742
# Required to use basename.
12743
if expr a : '\(a\)' >/dev/null 2>&1; then
12744
  as_expr=expr
12745
else
12746
  as_expr=false
12747
fi
12748
 
12749
if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12750
  as_basename=basename
12751
else
12752
  as_basename=false
12753
fi
12754
 
12755
 
12756
# Name of the executable.
12757
as_me=`$as_basename "$0" ||
12758
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12759
         X"$0" : 'X\(//\)$' \| \
12760
         X"$0" : 'X\(/\)$' \| \
12761
         .     : '\(.\)' 2>/dev/null ||
12762
echo X/"$0" |
12763
    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12764
          /^X\/\(\/\/\)$/{ s//\1/; q; }
12765
          /^X\/\(\/\).*/{ s//\1/; q; }
12766
          s/.*/./; q'`
12767
 
12768
 
12769
# PATH needs CR, and LINENO needs CR and PATH.
12770
# Avoid depending upon Character Ranges.
12771
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12772
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12773
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12774
as_cr_digits='0123456789'
12775
as_cr_alnum=$as_cr_Letters$as_cr_digits
12776
 
12777
# The user is always right.
12778
if test "${PATH_SEPARATOR+set}" != set; then
12779
  echo "#! /bin/sh" >conf$$.sh
12780
  echo  "exit 0"   >>conf$$.sh
12781
  chmod +x conf$$.sh
12782
  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12783
    PATH_SEPARATOR=';'
12784
  else
12785
    PATH_SEPARATOR=:
12786
  fi
12787
  rm -f conf$$.sh
12788
fi
12789
 
12790
 
12791
  as_lineno_1=$LINENO
12792
  as_lineno_2=$LINENO
12793
  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12794
  test "x$as_lineno_1" != "x$as_lineno_2" &&
12795
  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12796
  # Find who we are.  Look in the path if we contain no path at all
12797
  # relative or not.
12798
  case $0 in
12799
    *[\\/]* ) as_myself=$0 ;;
12800
    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12801
for as_dir in $PATH
12802
do
12803
  IFS=$as_save_IFS
12804
  test -z "$as_dir" && as_dir=.
12805
  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12806
done
12807
 
12808
       ;;
12809
  esac
12810
  # We did not find ourselves, most probably we were run as `sh COMMAND'
12811
  # in which case we are not to be found in the path.
12812
  if test "x$as_myself" = x; then
12813
    as_myself=$0
12814
  fi
12815
  if test ! -f "$as_myself"; then
12816
    { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12817
echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12818
   { (exit 1); exit 1; }; }
12819
  fi
12820
  case $CONFIG_SHELL in
12821
  '')
12822
    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12823
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12824
do
12825
  IFS=$as_save_IFS
12826
  test -z "$as_dir" && as_dir=.
12827
  for as_base in sh bash ksh sh5; do
12828
         case $as_dir in
12829
         /*)
12830
           if ("$as_dir/$as_base" -c '
12831
  as_lineno_1=$LINENO
12832
  as_lineno_2=$LINENO
12833
  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12834
  test "x$as_lineno_1" != "x$as_lineno_2" &&
12835
  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12836
             $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12837
             $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12838
             CONFIG_SHELL=$as_dir/$as_base
12839
             export CONFIG_SHELL
12840
             exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12841
           fi;;
12842
         esac
12843
       done
12844
done
12845
;;
12846
  esac
12847
 
12848
  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12849
  # uniformly replaced by the line number.  The first 'sed' inserts a
12850
  # line-number line before each line; the second 'sed' does the real
12851
  # work.  The second script uses 'N' to pair each line-number line
12852
  # with the numbered line, and appends trailing '-' during
12853
  # substitution so that $LINENO is not a special case at line end.
12854
  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12855
  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12856
  sed '=' <$as_myself |
12857
    sed '
12858
      N
12859
      s,$,-,
12860
      : loop
12861
      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12862
      t loop
12863
      s,-$,,
12864
      s,^['$as_cr_digits']*\n,,
12865
    ' >$as_me.lineno &&
12866
  chmod +x $as_me.lineno ||
12867
    { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12868
echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12869
   { (exit 1); exit 1; }; }
12870
 
12871
  # Don't try to exec as it changes $[0], causing all sort of problems
12872
  # (the dirname of $[0] is not the place where we might find the
12873
  # original and so on.  Autoconf is especially sensible to this).
12874
  . ./$as_me.lineno
12875
  # Exit status is that of the last command.
12876
  exit
12877
}
12878
 
12879
 
12880
case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12881
  *c*,-n*) ECHO_N= ECHO_C='
12882
' ECHO_T='      ' ;;
12883
  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12884
  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12885
esac
12886
 
12887
if expr a : '\(a\)' >/dev/null 2>&1; then
12888
  as_expr=expr
12889
else
12890
  as_expr=false
12891
fi
12892
 
12893
rm -f conf$$ conf$$.exe conf$$.file
12894
echo >conf$$.file
12895
if ln -s conf$$.file conf$$ 2>/dev/null; then
12896
  # We could just check for DJGPP; but this test a) works b) is more generic
12897
  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12898
  if test -f conf$$.exe; then
12899
    # Don't use ln at all; we don't have any links
12900
    as_ln_s='cp -p'
12901
  else
12902
    as_ln_s='ln -s'
12903
  fi
12904
elif ln conf$$.file conf$$ 2>/dev/null; then
12905
  as_ln_s=ln
12906
else
12907
  as_ln_s='cp -p'
12908
fi
12909
rm -f conf$$ conf$$.exe conf$$.file
12910
 
12911
if mkdir -p . 2>/dev/null; then
12912
  as_mkdir_p=:
12913
else
12914
  test -d ./-p && rmdir ./-p
12915
  as_mkdir_p=false
12916
fi
12917
 
12918
as_executable_p="test -f"
12919
 
12920
# Sed expression to map a string onto a valid CPP name.
12921
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12922
 
12923
# Sed expression to map a string onto a valid variable name.
12924
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12925
 
12926
 
12927
# IFS
12928
# We need space, tab and new line, in precisely that order.
12929
as_nl='
12930
'
12931
IFS="   $as_nl"
12932
 
12933
# CDPATH.
12934
$as_unset CDPATH
12935
 
12936
exec 6>&1
12937
 
12938
# Open the log real soon, to keep \$[0] and so on meaningful, and to
12939
# report actual input values of CONFIG_FILES etc. instead of their
12940
# values after options handling.  Logging --version etc. is OK.
12941
exec 5>>config.log
12942
{
12943
  echo
12944
  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12945
## Running $as_me. ##
12946
_ASBOX
12947
} >&5
12948
cat >&5 <<_CSEOF
12949
 
12950
This file was extended by $as_me, which was
12951
generated by GNU Autoconf 2.59.  Invocation command line was
12952
 
12953
  CONFIG_FILES    = $CONFIG_FILES
12954
  CONFIG_HEADERS  = $CONFIG_HEADERS
12955
  CONFIG_LINKS    = $CONFIG_LINKS
12956
  CONFIG_COMMANDS = $CONFIG_COMMANDS
12957
  $ $0 $@
12958
 
12959
_CSEOF
12960
echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12961
echo >&5
12962
_ACEOF
12963
 
12964
# Files that config.status was made for.
12965
if test -n "$ac_config_files"; then
12966
  echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12967
fi
12968
 
12969
if test -n "$ac_config_headers"; then
12970
  echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12971
fi
12972
 
12973
if test -n "$ac_config_links"; then
12974
  echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12975
fi
12976
 
12977
if test -n "$ac_config_commands"; then
12978
  echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12979
fi
12980
 
12981
cat >>$CONFIG_STATUS <<\_ACEOF
12982
 
12983
ac_cs_usage="\
12984
\`$as_me' instantiates files from templates according to the
12985
current configuration.
12986
 
12987
Usage: $0 [OPTIONS] [FILE]...
12988
 
12989
  -h, --help       print this help, then exit
12990
  -V, --version    print version number, then exit
12991
  -q, --quiet      do not print progress messages
12992
  -d, --debug      don't remove temporary files
12993
      --recheck    update $as_me by reconfiguring in the same conditions
12994
  --file=FILE[:TEMPLATE]
12995
                   instantiate the configuration file FILE
12996
 
12997
Configuration files:
12998
$config_files
12999
 
13000
Report bugs to ."
13001
_ACEOF
13002
 
13003
cat >>$CONFIG_STATUS <<_ACEOF
13004
ac_cs_version="\\
13005
config.status
13006
configured by $0, generated by GNU Autoconf 2.59,
13007
  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13008
 
13009
Copyright (C) 2003 Free Software Foundation, Inc.
13010
This config.status script is free software; the Free Software Foundation
13011
gives unlimited permission to copy, distribute and modify it."
13012
srcdir=$srcdir
13013
INSTALL="$INSTALL"
13014
_ACEOF
13015
 
13016
cat >>$CONFIG_STATUS <<\_ACEOF
13017
# If no file are specified by the user, then we need to provide default
13018
# value.  By we need to know if files were specified by the user.
13019
ac_need_defaults=:
13020
while test $# != 0
13021
do
13022
  case $1 in
13023
  --*=*)
13024
    ac_option=`expr "x$1" : 'x\([^=]*\)='`
13025
    ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13026
    ac_shift=:
13027
    ;;
13028
  -*)
13029
    ac_option=$1
13030
    ac_optarg=$2
13031
    ac_shift=shift
13032
    ;;
13033
  *) # This is not an option, so the user has probably given explicit
13034
     # arguments.
13035
     ac_option=$1
13036
     ac_need_defaults=false;;
13037
  esac
13038
 
13039
  case $ac_option in
13040
  # Handling of the options.
13041
_ACEOF
13042
cat >>$CONFIG_STATUS <<\_ACEOF
13043
  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13044
    ac_cs_recheck=: ;;
13045
  --version | --vers* | -V )
13046
    echo "$ac_cs_version"; exit 0 ;;
13047
  --he | --h)
13048
    # Conflict between --help and --header
13049
    { { echo "$as_me:$LINENO: error: ambiguous option: $1
13050
Try \`$0 --help' for more information." >&5
13051
echo "$as_me: error: ambiguous option: $1
13052
Try \`$0 --help' for more information." >&2;}
13053
   { (exit 1); exit 1; }; };;
13054
  --help | --hel | -h )
13055
    echo "$ac_cs_usage"; exit 0 ;;
13056
  --debug | --d* | -d )
13057
    debug=: ;;
13058
  --file | --fil | --fi | --f )
13059
    $ac_shift
13060
    CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13061
    ac_need_defaults=false;;
13062
  --header | --heade | --head | --hea )
13063
    $ac_shift
13064
    CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13065
    ac_need_defaults=false;;
13066
  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13067
  | -silent | --silent | --silen | --sile | --sil | --si | --s)
13068
    ac_cs_silent=: ;;
13069
 
13070
  # This is an error.
13071
  -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13072
Try \`$0 --help' for more information." >&5
13073
echo "$as_me: error: unrecognized option: $1
13074
Try \`$0 --help' for more information." >&2;}
13075
   { (exit 1); exit 1; }; } ;;
13076
 
13077
  *) ac_config_targets="$ac_config_targets $1" ;;
13078
 
13079
  esac
13080
  shift
13081
done
13082
 
13083
ac_configure_extra_args=
13084
 
13085
if $ac_cs_silent; then
13086
  exec 6>/dev/null
13087
  ac_configure_extra_args="$ac_configure_extra_args --silent"
13088
fi
13089
 
13090
_ACEOF
13091
cat >>$CONFIG_STATUS <<_ACEOF
13092
if \$ac_cs_recheck; then
13093
  echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13094
  exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13095
fi
13096
 
13097
_ACEOF
13098
 
13099
 
13100
 
13101
 
13102
 
13103
cat >>$CONFIG_STATUS <<\_ACEOF
13104
for ac_config_target in $ac_config_targets
13105
do
13106
  case "$ac_config_target" in
13107
  # Handling of arguments.
13108
  "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13109
  *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13110
echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13111
   { (exit 1); exit 1; }; };;
13112
  esac
13113
done
13114
 
13115
# If the user did not use the arguments to specify the items to instantiate,
13116
# then the envvar interface is used.  Set only those that are not.
13117
# We use the long form for the default assignment because of an extremely
13118
# bizarre bug on SunOS 4.1.3.
13119
if $ac_need_defaults; then
13120
  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13121
fi
13122
 
13123
# Have a temporary directory for convenience.  Make it in the build tree
13124
# simply because there is no reason to put it here, and in addition,
13125
# creating and moving files from /tmp can sometimes cause problems.
13126
# Create a temporary directory, and hook for its removal unless debugging.
13127
$debug ||
13128
{
13129
  trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13130
  trap '{ (exit 1); exit 1; }' 1 2 13 15
13131
}
13132
 
13133
# Create a (secure) tmp directory for tmp files.
13134
 
13135
{
13136
  tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13137
  test -n "$tmp" && test -d "$tmp"
13138
}  ||
13139
{
13140
  tmp=./confstat$$-$RANDOM
13141
  (umask 077 && mkdir $tmp)
13142
} ||
13143
{
13144
   echo "$me: cannot create a temporary directory in ." >&2
13145
   { (exit 1); exit 1; }
13146
}
13147
 
13148
_ACEOF
13149
 
13150
cat >>$CONFIG_STATUS <<_ACEOF
13151
 
13152
#
13153
# CONFIG_FILES section.
13154
#
13155
 
13156
# No need to generate the scripts if there are no CONFIG_FILES.
13157
# This happens for instance when ./config.status config.h
13158
if test -n "\$CONFIG_FILES"; then
13159
  # Protect against being on the right side of a sed subst in config.status.
13160
  sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13161
   s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13162
s,@SHELL@,$SHELL,;t t
13163
s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13164
s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13165
s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13166
s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13167
s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13168
s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13169
s,@exec_prefix@,$exec_prefix,;t t
13170
s,@prefix@,$prefix,;t t
13171
s,@program_transform_name@,$program_transform_name,;t t
13172
s,@bindir@,$bindir,;t t
13173
s,@sbindir@,$sbindir,;t t
13174
s,@libexecdir@,$libexecdir,;t t
13175
s,@datadir@,$datadir,;t t
13176
s,@sysconfdir@,$sysconfdir,;t t
13177
s,@sharedstatedir@,$sharedstatedir,;t t
13178
s,@localstatedir@,$localstatedir,;t t
13179
s,@libdir@,$libdir,;t t
13180
s,@includedir@,$includedir,;t t
13181
s,@oldincludedir@,$oldincludedir,;t t
13182
s,@infodir@,$infodir,;t t
13183
s,@mandir@,$mandir,;t t
13184
s,@build_alias@,$build_alias,;t t
13185
s,@host_alias@,$host_alias,;t t
13186
s,@target_alias@,$target_alias,;t t
13187
s,@DEFS@,$DEFS,;t t
13188
s,@ECHO_C@,$ECHO_C,;t t
13189
s,@ECHO_N@,$ECHO_N,;t t
13190
s,@ECHO_T@,$ECHO_T,;t t
13191
s,@LIBS@,$LIBS,;t t
13192
s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13193
s,@build@,$build,;t t
13194
s,@build_cpu@,$build_cpu,;t t
13195
s,@build_vendor@,$build_vendor,;t t
13196
s,@build_os@,$build_os,;t t
13197
s,@build_noncanonical@,$build_noncanonical,;t t
13198
s,@host_noncanonical@,$host_noncanonical,;t t
13199
s,@target_noncanonical@,$target_noncanonical,;t t
13200
s,@host@,$host,;t t
13201
s,@host_cpu@,$host_cpu,;t t
13202
s,@host_vendor@,$host_vendor,;t t
13203
s,@host_os@,$host_os,;t t
13204
s,@target@,$target,;t t
13205
s,@target_cpu@,$target_cpu,;t t
13206
s,@target_vendor@,$target_vendor,;t t
13207
s,@target_os@,$target_os,;t t
13208
s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13209
s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13210
s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13211
s,@LN@,$LN,;t t
13212
s,@LN_S@,$LN_S,;t t
13213
s,@build_libsubdir@,$build_libsubdir,;t t
13214
s,@build_subdir@,$build_subdir,;t t
13215
s,@host_subdir@,$host_subdir,;t t
13216
s,@target_subdir@,$target_subdir,;t t
13217
s,@CC@,$CC,;t t
13218
s,@CFLAGS@,$CFLAGS,;t t
13219
s,@LDFLAGS@,$LDFLAGS,;t t
13220
s,@CPPFLAGS@,$CPPFLAGS,;t t
13221
s,@ac_ct_CC@,$ac_ct_CC,;t t
13222
s,@EXEEXT@,$EXEEXT,;t t
13223
s,@OBJEXT@,$OBJEXT,;t t
13224
s,@CXX@,$CXX,;t t
13225
s,@CXXFLAGS@,$CXXFLAGS,;t t
13226
s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13227
s,@GNATBIND@,$GNATBIND,;t t
13228
s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13229
s,@GNATMAKE@,$GNATMAKE,;t t
13230
s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13231
s,@do_compare@,$do_compare,;t t
13232
s,@gmplibs@,$gmplibs,;t t
13233
s,@gmpinc@,$gmpinc,;t t
13234
s,@ppllibs@,$ppllibs,;t t
13235
s,@pplinc@,$pplinc,;t t
13236
s,@clooglibs@,$clooglibs,;t t
13237
s,@clooginc@,$clooginc,;t t
13238
s,@stage1_languages@,$stage1_languages,;t t
13239
s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13240
s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13241
s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13242
s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13243
s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13244
s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13245
s,@tooldir@,$tooldir,;t t
13246
s,@build_tooldir@,$build_tooldir,;t t
13247
s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13248
s,@GDB_TK@,$GDB_TK,;t t
13249
s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13250
s,@build_configargs@,$build_configargs,;t t
13251
s,@build_configdirs@,$build_configdirs,;t t
13252
s,@host_configargs@,$host_configargs,;t t
13253
s,@configdirs@,$configdirs,;t t
13254
s,@target_configargs@,$target_configargs,;t t
13255
s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13256
s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13257
s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13258
s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13259
s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13260
s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13261
s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13262
s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13263
s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13264
s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13265
s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13266
s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13267
s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13268
s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13269
s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13270
s,@config_shell@,$config_shell,;t t
13271
s,@YACC@,$YACC,;t t
13272
s,@BISON@,$BISON,;t t
13273
s,@M4@,$M4,;t t
13274
s,@LEX@,$LEX,;t t
13275
s,@FLEX@,$FLEX,;t t
13276
s,@MAKEINFO@,$MAKEINFO,;t t
13277
s,@EXPECT@,$EXPECT,;t t
13278
s,@RUNTEST@,$RUNTEST,;t t
13279
s,@AR@,$AR,;t t
13280
s,@AS@,$AS,;t t
13281
s,@DLLTOOL@,$DLLTOOL,;t t
13282
s,@LD@,$LD,;t t
13283
s,@LIPO@,$LIPO,;t t
13284
s,@NM@,$NM,;t t
13285
s,@RANLIB@,$RANLIB,;t t
13286
s,@STRIP@,$STRIP,;t t
13287
s,@WINDRES@,$WINDRES,;t t
13288
s,@WINDMC@,$WINDMC,;t t
13289
s,@OBJCOPY@,$OBJCOPY,;t t
13290
s,@OBJDUMP@,$OBJDUMP,;t t
13291
s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13292
s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13293
s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13294
s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13295
s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13296
s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13297
s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13298
s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13299
s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13300
s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13301
s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13302
s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13303
s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13304
s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13305
s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13306
s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13307
s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13308
s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13309
s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13310
s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13311
s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13312
s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13313
s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13314
s,@MAINT@,$MAINT,;t t
13315
s,@stage1_cflags@,$stage1_cflags,;t t
13316
s,@stage1_checking@,$stage1_checking,;t t
13317
s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13318
s,@datarootdir@,$datarootdir,;t t
13319
s,@docdir@,$docdir,;t t
13320
s,@pdfdir@,$pdfdir,;t t
13321
s,@htmldir@,$htmldir,;t t
13322
s,@LIBOBJS@,$LIBOBJS,;t t
13323
s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13324
/@serialization_dependencies@/r $serialization_dependencies
13325
s,@serialization_dependencies@,,;t t
13326
/@host_makefile_frag@/r $host_makefile_frag
13327
s,@host_makefile_frag@,,;t t
13328
/@target_makefile_frag@/r $target_makefile_frag
13329
s,@target_makefile_frag@,,;t t
13330
/@alphaieee_frag@/r $alphaieee_frag
13331
s,@alphaieee_frag@,,;t t
13332
/@ospace_frag@/r $ospace_frag
13333
s,@ospace_frag@,,;t t
13334
CEOF
13335
 
13336
_ACEOF
13337
 
13338
  cat >>$CONFIG_STATUS <<\_ACEOF
13339
  # Split the substitutions into bite-sized pieces for seds with
13340
  # small command number limits, like on Digital OSF/1 and HP-UX.
13341
  ac_max_sed_lines=48
13342
  ac_sed_frag=1 # Number of current file.
13343
  ac_beg=1 # First line for current file.
13344
  ac_end=$ac_max_sed_lines # Line after last line for current file.
13345
  ac_more_lines=:
13346
  ac_sed_cmds=
13347
  while $ac_more_lines; do
13348
    if test $ac_beg -gt 1; then
13349
      sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13350
    else
13351
      sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13352
    fi
13353
    if test ! -s $tmp/subs.frag; then
13354
      ac_more_lines=false
13355
    else
13356
      # The purpose of the label and of the branching condition is to
13357
      # speed up the sed processing (if there are no `@' at all, there
13358
      # is no need to browse any of the substitutions).
13359
      # These are the two extra sed commands mentioned above.
13360
      (echo ':t
13361
  /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13362
      if test -z "$ac_sed_cmds"; then
13363
        ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13364
      else
13365
        ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13366
      fi
13367
      ac_sed_frag=`expr $ac_sed_frag + 1`
13368
      ac_beg=$ac_end
13369
      ac_end=`expr $ac_end + $ac_max_sed_lines`
13370
    fi
13371
  done
13372
  if test -z "$ac_sed_cmds"; then
13373
    ac_sed_cmds=cat
13374
  fi
13375
fi # test -n "$CONFIG_FILES"
13376
 
13377
_ACEOF
13378
cat >>$CONFIG_STATUS <<\_ACEOF
13379
for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13380
  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13381
  case $ac_file in
13382
  - | *:- | *:-:* ) # input from stdin
13383
        cat >$tmp/stdin
13384
        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13385
        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13386
  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13387
        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13388
  * )   ac_file_in=$ac_file.in ;;
13389
  esac
13390
 
13391
  # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13392
  ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13393
$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13394
         X"$ac_file" : 'X\(//\)[^/]' \| \
13395
         X"$ac_file" : 'X\(//\)$' \| \
13396
         X"$ac_file" : 'X\(/\)' \| \
13397
         .     : '\(.\)' 2>/dev/null ||
13398
echo X"$ac_file" |
13399
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13400
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13401
          /^X\(\/\/\)$/{ s//\1/; q; }
13402
          /^X\(\/\).*/{ s//\1/; q; }
13403
          s/.*/./; q'`
13404
  { if $as_mkdir_p; then
13405
    mkdir -p "$ac_dir"
13406
  else
13407
    as_dir="$ac_dir"
13408
    as_dirs=
13409
    while test ! -d "$as_dir"; do
13410
      as_dirs="$as_dir $as_dirs"
13411
      as_dir=`(dirname "$as_dir") 2>/dev/null ||
13412
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13413
         X"$as_dir" : 'X\(//\)[^/]' \| \
13414
         X"$as_dir" : 'X\(//\)$' \| \
13415
         X"$as_dir" : 'X\(/\)' \| \
13416
         .     : '\(.\)' 2>/dev/null ||
13417
echo X"$as_dir" |
13418
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13419
          /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13420
          /^X\(\/\/\)$/{ s//\1/; q; }
13421
          /^X\(\/\).*/{ s//\1/; q; }
13422
          s/.*/./; q'`
13423
    done
13424
    test ! -n "$as_dirs" || mkdir $as_dirs
13425
  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13426
echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13427
   { (exit 1); exit 1; }; }; }
13428
 
13429
  ac_builddir=.
13430
 
13431
if test "$ac_dir" != .; then
13432
  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13433
  # A "../" for each directory in $ac_dir_suffix.
13434
  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13435
else
13436
  ac_dir_suffix= ac_top_builddir=
13437
fi
13438
 
13439
case $srcdir in
13440
  .)  # No --srcdir option.  We are building in place.
13441
    ac_srcdir=.
13442
    if test -z "$ac_top_builddir"; then
13443
       ac_top_srcdir=.
13444
    else
13445
       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13446
    fi ;;
13447
  [\\/]* | ?:[\\/]* )  # Absolute path.
13448
    ac_srcdir=$srcdir$ac_dir_suffix;
13449
    ac_top_srcdir=$srcdir ;;
13450
  *) # Relative path.
13451
    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13452
    ac_top_srcdir=$ac_top_builddir$srcdir ;;
13453
esac
13454
 
13455
# Do not use `cd foo && pwd` to compute absolute paths, because
13456
# the directories may not exist.
13457
case `pwd` in
13458
.) ac_abs_builddir="$ac_dir";;
13459
*)
13460
  case "$ac_dir" in
13461
  .) ac_abs_builddir=`pwd`;;
13462
  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13463
  *) ac_abs_builddir=`pwd`/"$ac_dir";;
13464
  esac;;
13465
esac
13466
case $ac_abs_builddir in
13467
.) ac_abs_top_builddir=${ac_top_builddir}.;;
13468
*)
13469
  case ${ac_top_builddir}. in
13470
  .) ac_abs_top_builddir=$ac_abs_builddir;;
13471
  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13472
  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13473
  esac;;
13474
esac
13475
case $ac_abs_builddir in
13476
.) ac_abs_srcdir=$ac_srcdir;;
13477
*)
13478
  case $ac_srcdir in
13479
  .) ac_abs_srcdir=$ac_abs_builddir;;
13480
  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13481
  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13482
  esac;;
13483
esac
13484
case $ac_abs_builddir in
13485
.) ac_abs_top_srcdir=$ac_top_srcdir;;
13486
*)
13487
  case $ac_top_srcdir in
13488
  .) ac_abs_top_srcdir=$ac_abs_builddir;;
13489
  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13490
  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13491
  esac;;
13492
esac
13493
 
13494
 
13495
  case $INSTALL in
13496
  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13497
  *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13498
  esac
13499
 
13500
  if test x"$ac_file" != x-; then
13501
    { echo "$as_me:$LINENO: creating $ac_file" >&5
13502
echo "$as_me: creating $ac_file" >&6;}
13503
    rm -f "$ac_file"
13504
  fi
13505
  # Let's still pretend it is `configure' which instantiates (i.e., don't
13506
  # use $as_me), people would be surprised to read:
13507
  #    /* config.h.  Generated by config.status.  */
13508
  if test x"$ac_file" = x-; then
13509
    configure_input=
13510
  else
13511
    configure_input="$ac_file.  "
13512
  fi
13513
  configure_input=$configure_input"Generated from `echo $ac_file_in |
13514
                                     sed 's,.*/,,'` by configure."
13515
 
13516
  # First look for the input files in the build tree, otherwise in the
13517
  # src tree.
13518
  ac_file_inputs=`IFS=:
13519
    for f in $ac_file_in; do
13520
      case $f in
13521
      -) echo $tmp/stdin ;;
13522
      [\\/$]*)
13523
         # Absolute (can't be DOS-style, as IFS=:)
13524
         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13525
echo "$as_me: error: cannot find input file: $f" >&2;}
13526
   { (exit 1); exit 1; }; }
13527
         echo "$f";;
13528
      *) # Relative
13529
         if test -f "$f"; then
13530
           # Build tree
13531
           echo "$f"
13532
         elif test -f "$srcdir/$f"; then
13533
           # Source tree
13534
           echo "$srcdir/$f"
13535
         else
13536
           # /dev/null tree
13537
           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13538
echo "$as_me: error: cannot find input file: $f" >&2;}
13539
   { (exit 1); exit 1; }; }
13540
         fi;;
13541
      esac
13542
    done` || { (exit 1); exit 1; }
13543
_ACEOF
13544
cat >>$CONFIG_STATUS <<_ACEOF
13545
  sed "$ac_vpsub
13546
$extrasub
13547
_ACEOF
13548
cat >>$CONFIG_STATUS <<\_ACEOF
13549
:t
13550
/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13551
s,@configure_input@,$configure_input,;t t
13552
s,@srcdir@,$ac_srcdir,;t t
13553
s,@abs_srcdir@,$ac_abs_srcdir,;t t
13554
s,@top_srcdir@,$ac_top_srcdir,;t t
13555
s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13556
s,@builddir@,$ac_builddir,;t t
13557
s,@abs_builddir@,$ac_abs_builddir,;t t
13558
s,@top_builddir@,$ac_top_builddir,;t t
13559
s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13560
s,@INSTALL@,$ac_INSTALL,;t t
13561
" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13562
  rm -f $tmp/stdin
13563
  if test x"$ac_file" != x-; then
13564
    mv $tmp/out $ac_file
13565
  else
13566
    cat $tmp/out
13567
    rm -f $tmp/out
13568
  fi
13569
 
13570
done
13571
_ACEOF
13572
 
13573
cat >>$CONFIG_STATUS <<\_ACEOF
13574
 
13575
{ (exit 0); exit 0; }
13576
_ACEOF
13577
chmod +x $CONFIG_STATUS
13578
ac_clean_files=$ac_clean_files_save
13579
 
13580
 
13581
# configure is writing to config.log, and then calls config.status.
13582
# config.status does its own redirection, appending to config.log.
13583
# Unfortunately, on DOS this fails, as config.log is still kept open
13584
# by configure, so config.status won't be able to write to it; its
13585
# output is simply discarded.  So we exec the FD to /dev/null,
13586
# effectively closing config.log, so it can be properly (re)opened and
13587
# appended to by config.status.  When coming back to configure, we
13588
# need to make the FD available again.
13589
if test "$no_create" != yes; then
13590
  ac_cs_success=:
13591
  ac_config_status_args=
13592
  test "$silent" = yes &&
13593
    ac_config_status_args="$ac_config_status_args --quiet"
13594
  exec 5>/dev/null
13595
  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13596
  exec 5>>config.log
13597
  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13598
  # would make configure fail if this is the last instruction.
13599
  $ac_cs_success || { (exit 1); exit 1; }
13600
fi
13601
 

powered by: WebSVN 2.1.0

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