configure

   1 #! /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 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 TOPLEVEL_CONFIGURE_ARGUMENTS 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 stage1_languages SYSROOT_CFLAGS_FOR_TARGET RPATH_ENVVAR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs CC_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES OBJCOPY OBJDUMP CFLAGS_FOR_BUILD 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 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
 278 # Initialize some variables set by options.
 279 ac_init_help=
 280 ac_init_version=false
 281 # The variables have the same names as the options, with
 282 # dashes changed to underlines.
 283 cache_file=/dev/null
 284 exec_prefix=NONE
 285 no_create=
 286 no_recursion=
 287 prefix=NONE
 288 program_prefix=NONE
 289 program_suffix=NONE
 290 program_transform_name=s,x,x,
 291 silent=
 292 site=
 293 srcdir=
 294 verbose=
 295 x_includes=NONE
 296 x_libraries=NONE
 297
 298 # Installation directory options.
 299 # These are left unexpanded so users can "make install exec_prefix=/foo"
 300 # and all the variables that are supposed to be based on exec_prefix
 301 # by default will actually change.
 302 # Use braces instead of parens because sh, perl, etc. also accept them.
 303 bindir='${exec_prefix}/bin'
 304 sbindir='${exec_prefix}/sbin'
 305 libexecdir='${exec_prefix}/libexec'
 306 datadir='${prefix}/share'
 307 sysconfdir='${prefix}/etc'
 308 sharedstatedir='${prefix}/com'
 309 localstatedir='${prefix}/var'
 310 libdir='${exec_prefix}/lib'
 311 includedir='${prefix}/include'
 312 oldincludedir='/usr/include'
 313 infodir='${prefix}/info'
 314 mandir='${prefix}/man'
 315
 316 ac_prev=
 317 for ac_option
 318 do
 319   # If the previous option needs an argument, assign it.
 320   if test -n "$ac_prev"; then
 321     eval "$ac_prev=\$ac_option"
 322     ac_prev=
 323     continue
 324   fi
 325
 326   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 327
 328   # Accept the important Cygnus configure options, so we can diagnose typos.
 329
 330   case $ac_option in
 331
 332   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 333     ac_prev=bindir ;;
 334   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 335     bindir=$ac_optarg ;;
 336
 337   -build | --build | --buil | --bui | --bu)
 338     ac_prev=build_alias ;;
 339   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 340     build_alias=$ac_optarg ;;
 341
 342   -cache-file | --cache-file | --cache-fil | --cache-fi \
 343   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 344     ac_prev=cache_file ;;
 345   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 346   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 347     cache_file=$ac_optarg ;;
 348
 349   --config-cache | -C)
 350     cache_file=config.cache ;;
 351
 352   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 353     ac_prev=datadir ;;
 354   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 355   | --da=*)
 356     datadir=$ac_optarg ;;
 357
 358   -disable-* | --disable-*)
 359     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 360     # Reject names that are not valid shell variable names.
 361     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 362       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 363    { (exit 1); exit 1; }; }
 364     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 365     eval "enable_$ac_feature=no" ;;
 366
 367   -enable-* | --enable-*)
 368     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 369     # Reject names that are not valid shell variable names.
 370     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 371       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 372    { (exit 1); exit 1; }; }
 373     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 374     case $ac_option in
 375       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 376       *) ac_optarg=yes ;;
 377     esac
 378     eval "enable_$ac_feature='$ac_optarg'" ;;
 379
 380   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 381   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 382   | --exec | --exe | --ex)
 383     ac_prev=exec_prefix ;;
 384   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 385   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 386   | --exec=* | --exe=* | --ex=*)
 387     exec_prefix=$ac_optarg ;;
 388
 389   -gas | --gas | --ga | --g)
 390     # Obsolete; use --with-gas.
 391     with_gas=yes ;;
 392
 393   -help | --help | --hel | --he | -h)
 394     ac_init_help=long ;;
 395   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 396     ac_init_help=recursive ;;
 397   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 398     ac_init_help=short ;;
 399
 400   -host | --host | --hos | --ho)
 401     ac_prev=host_alias ;;
 402   -host=* | --host=* | --hos=* | --ho=*)
 403     host_alias=$ac_optarg ;;
 404
 405   -includedir | --includedir | --includedi | --included | --include \
 406   | --includ | --inclu | --incl | --inc)
 407     ac_prev=includedir ;;
 408   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 409   | --includ=* | --inclu=* | --incl=* | --inc=*)
 410     includedir=$ac_optarg ;;
 411
 412   -infodir | --infodir | --infodi | --infod | --info | --inf)
 413     ac_prev=infodir ;;
 414   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 415     infodir=$ac_optarg ;;
 416
 417   -libdir | --libdir | --libdi | --libd)
 418     ac_prev=libdir ;;
 419   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 420     libdir=$ac_optarg ;;
 421
 422   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 423   | --libexe | --libex | --libe)
 424     ac_prev=libexecdir ;;
 425   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 426   | --libexe=* | --libex=* | --libe=*)
 427     libexecdir=$ac_optarg ;;
 428
 429   -localstatedir | --localstatedir | --localstatedi | --localstated \
 430   | --localstate | --localstat | --localsta | --localst \
 431   | --locals | --local | --loca | --loc | --lo)
 432     ac_prev=localstatedir ;;
 433   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 434   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 435   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 436     localstatedir=$ac_optarg ;;
 437
 438   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 439     ac_prev=mandir ;;
 440   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 441     mandir=$ac_optarg ;;
 442
 443   -nfp | --nfp | --nf)
 444     # Obsolete; use --without-fp.
 445     with_fp=no ;;
 446
 447   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 448   | --no-cr | --no-c | -n)
 449     no_create=yes ;;
 450
 451   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 452   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 453     no_recursion=yes ;;
 454
 455   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 456   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 457   | --oldin | --oldi | --old | --ol | --o)
 458     ac_prev=oldincludedir ;;
 459   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 460   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 461   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 462     oldincludedir=$ac_optarg ;;
 463
 464   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 465     ac_prev=prefix ;;
 466   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 467     prefix=$ac_optarg ;;
 468
 469   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 470   | --program-pre | --program-pr | --program-p)
 471     ac_prev=program_prefix ;;
 472   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 473   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 474     program_prefix=$ac_optarg ;;
 475
 476   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 477   | --program-suf | --program-su | --program-s)
 478     ac_prev=program_suffix ;;
 479   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 480   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 481     program_suffix=$ac_optarg ;;
 482
 483   -program-transform-name | --program-transform-name \
 484   | --program-transform-nam | --program-transform-na \
 485   | --program-transform-n | --program-transform- \
 486   | --program-transform | --program-transfor \
 487   | --program-transfo | --program-transf \
 488   | --program-trans | --program-tran \
 489   | --progr-tra | --program-tr | --program-t)
 490     ac_prev=program_transform_name ;;
 491   -program-transform-name=* | --program-transform-name=* \
 492   | --program-transform-nam=* | --program-transform-na=* \
 493   | --program-transform-n=* | --program-transform-=* \
 494   | --program-transform=* | --program-transfor=* \
 495   | --program-transfo=* | --program-transf=* \
 496   | --program-trans=* | --program-tran=* \
 497   | --progr-tra=* | --program-tr=* | --program-t=*)
 498     program_transform_name=$ac_optarg ;;
 499
 500   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 501   | -silent | --silent | --silen | --sile | --sil)
 502     silent=yes ;;
 503
 504   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 505     ac_prev=sbindir ;;
 506   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 507   | --sbi=* | --sb=*)
 508     sbindir=$ac_optarg ;;
 509
 510   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 511   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 512   | --sharedst | --shareds | --shared | --share | --shar \
 513   | --sha | --sh)
 514     ac_prev=sharedstatedir ;;
 515   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 516   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 517   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 518   | --sha=* | --sh=*)
 519     sharedstatedir=$ac_optarg ;;
 520
 521   -site | --site | --sit)
 522     ac_prev=site ;;
 523   -site=* | --site=* | --sit=*)
 524     site=$ac_optarg ;;
 525
 526   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 527     ac_prev=srcdir ;;
 528   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 529     srcdir=$ac_optarg ;;
 530
 531   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 532   | --syscon | --sysco | --sysc | --sys | --sy)
 533     ac_prev=sysconfdir ;;
 534   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 535   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 536     sysconfdir=$ac_optarg ;;
 537
 538   -target | --target | --targe | --targ | --tar | --ta | --t)
 539     ac_prev=target_alias ;;
 540   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 541     target_alias=$ac_optarg ;;
 542
 543   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 544     verbose=yes ;;
 545
 546   -version | --version | --versio | --versi | --vers | -V)
 547     ac_init_version=: ;;
 548
 549   -with-* | --with-*)
 550     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 551     # Reject names that are not valid shell variable names.
 552     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 553       { echo "$as_me: error: invalid package name: $ac_package" >&2
 554    { (exit 1); exit 1; }; }
 555     ac_package=`echo $ac_package| sed 's/-/_/g'`
 556     case $ac_option in
 557       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 558       *) ac_optarg=yes ;;
 559     esac
 560     eval "with_$ac_package='$ac_optarg'" ;;
 561
 562   -without-* | --without-*)
 563     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 564     # Reject names that are not valid shell variable names.
 565     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 566       { echo "$as_me: error: invalid package name: $ac_package" >&2
 567    { (exit 1); exit 1; }; }
 568     ac_package=`echo $ac_package | sed 's/-/_/g'`
 569     eval "with_$ac_package=no" ;;
 570
 571   --x)
 572     # Obsolete; use --with-x.
 573     with_x=yes ;;
 574
 575   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 576   | --x-incl | --x-inc | --x-in | --x-i)
 577     ac_prev=x_includes ;;
 578   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 579   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 580     x_includes=$ac_optarg ;;
 581
 582   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 583   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 584     ac_prev=x_libraries ;;
 585   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 586   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 587     x_libraries=$ac_optarg ;;
 588
 589   -*) { echo "$as_me: error: unrecognized option: $ac_option
 590 Try \`$0 --help' for more information." >&2
 591    { (exit 1); exit 1; }; }
 592     ;;
 593
 594   *=*)
 595     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 596     # Reject names that are not valid shell variable names.
 597     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 598       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 599    { (exit 1); exit 1; }; }
 600     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 601     eval "$ac_envvar='$ac_optarg'"
 602     export $ac_envvar ;;
 603
 604   *)
 605     # FIXME: should be removed in autoconf 3.0.
 606     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 607     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 608       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 609     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 610     ;;
 611
 612   esac
 613 done
 614
 615 if test -n "$ac_prev"; then
 616   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 617   { echo "$as_me: error: missing argument to $ac_option" >&2
 618    { (exit 1); exit 1; }; }
 619 fi
 620
 621 # Be sure to have absolute paths.
 622 for ac_var in exec_prefix prefix
 623 do
 624   eval ac_val=$`echo $ac_var`
 625   case $ac_val in
 626     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 627     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 628    { (exit 1); exit 1; }; };;
 629   esac
 630 done
 631
 632 # Be sure to have absolute paths.
 633 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 634               localstatedir libdir includedir oldincludedir infodir mandir
 635 do
 636   eval ac_val=$`echo $ac_var`
 637   case $ac_val in
 638     [\\/$]* | ?:[\\/]* ) ;;
 639     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 640    { (exit 1); exit 1; }; };;
 641   esac
 642 done
 643
 644 # There might be people who depend on the old broken behavior: `$host'
 645 # used to hold the argument of --host etc.
 646 # FIXME: To remove some day.
 647 build=$build_alias
 648 host=$host_alias
 649 target=$target_alias
 650
 651 # FIXME: To remove some day.
 652 if test "x$host_alias" != x; then
 653   if test "x$build_alias" = x; then
 654     cross_compiling=maybe
 655     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 656     If a cross compiler is detected then cross compile mode will be used." >&2
 657   elif test "x$build_alias" != "x$host_alias"; then
 658     cross_compiling=yes
 659   fi
 660 fi
 661
 662 ac_tool_prefix=
 663 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 664
 665 test "$silent" = yes && exec 6>/dev/null
 666
 667
 668 # Find the source files, if location was not specified.
 669 if test -z "$srcdir"; then
 670   ac_srcdir_defaulted=yes
 671   # Try the directory containing this script, then its parent.
 672   ac_confdir=`(dirname "$0") 2>/dev/null ||
 673 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 674          X"$0" : 'X\(//\)[^/]' \| \
 675          X"$0" : 'X\(//\)$' \| \
 676          X"$0" : 'X\(/\)' \| \
 677          .     : '\(.\)' 2>/dev/null ||
 678 echo X"$0" |
 679     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 680           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 681           /^X\(\/\/\)$/{ s//\1/; q; }
 682           /^X\(\/\).*/{ s//\1/; q; }
 683           s/.*/./; q'`
 684   srcdir=$ac_confdir
 685   if test ! -r $srcdir/$ac_unique_file; then
 686     srcdir=..
 687   fi
 688 else
 689   ac_srcdir_defaulted=no
 690 fi
 691 if test ! -r $srcdir/$ac_unique_file; then
 692   if test "$ac_srcdir_defaulted" = yes; then
 693     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 694    { (exit 1); exit 1; }; }
 695   else
 696     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 697    { (exit 1); exit 1; }; }
 698   fi
 699 fi
 700 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 701   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 702    { (exit 1); exit 1; }; }
 703 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 704 ac_env_build_alias_set=${build_alias+set}
 705 ac_env_build_alias_value=$build_alias
 706 ac_cv_env_build_alias_set=${build_alias+set}
 707 ac_cv_env_build_alias_value=$build_alias
 708 ac_env_host_alias_set=${host_alias+set}
 709 ac_env_host_alias_value=$host_alias
 710 ac_cv_env_host_alias_set=${host_alias+set}
 711 ac_cv_env_host_alias_value=$host_alias
 712 ac_env_target_alias_set=${target_alias+set}
 713 ac_env_target_alias_value=$target_alias
 714 ac_cv_env_target_alias_set=${target_alias+set}
 715 ac_cv_env_target_alias_value=$target_alias
 716 ac_env_CC_set=${CC+set}
 717 ac_env_CC_value=$CC
 718 ac_cv_env_CC_set=${CC+set}
 719 ac_cv_env_CC_value=$CC
 720 ac_env_CFLAGS_set=${CFLAGS+set}
 721 ac_env_CFLAGS_value=$CFLAGS
 722 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 723 ac_cv_env_CFLAGS_value=$CFLAGS
 724 ac_env_LDFLAGS_set=${LDFLAGS+set}
 725 ac_env_LDFLAGS_value=$LDFLAGS
 726 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 727 ac_cv_env_LDFLAGS_value=$LDFLAGS
 728 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 729 ac_env_CPPFLAGS_value=$CPPFLAGS
 730 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 731 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 732 ac_env_CXX_set=${CXX+set}
 733 ac_env_CXX_value=$CXX
 734 ac_cv_env_CXX_set=${CXX+set}
 735 ac_cv_env_CXX_value=$CXX
 736 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 737 ac_env_CXXFLAGS_value=$CXXFLAGS
 738 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 739 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 740 ac_env_AR_set=${AR+set}
 741 ac_env_AR_value=$AR
 742 ac_cv_env_AR_set=${AR+set}
 743 ac_cv_env_AR_value=$AR
 744 ac_env_AS_set=${AS+set}
 745 ac_env_AS_value=$AS
 746 ac_cv_env_AS_set=${AS+set}
 747 ac_cv_env_AS_value=$AS
 748 ac_env_DLLTOOL_set=${DLLTOOL+set}
 749 ac_env_DLLTOOL_value=$DLLTOOL
 750 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 751 ac_cv_env_DLLTOOL_value=$DLLTOOL
 752 ac_env_LD_set=${LD+set}
 753 ac_env_LD_value=$LD
 754 ac_cv_env_LD_set=${LD+set}
 755 ac_cv_env_LD_value=$LD
 756 ac_env_LIPO_set=${LIPO+set}
 757 ac_env_LIPO_value=$LIPO
 758 ac_cv_env_LIPO_set=${LIPO+set}
 759 ac_cv_env_LIPO_value=$LIPO
 760 ac_env_NM_set=${NM+set}
 761 ac_env_NM_value=$NM
 762 ac_cv_env_NM_set=${NM+set}
 763 ac_cv_env_NM_value=$NM
 764 ac_env_RANLIB_set=${RANLIB+set}
 765 ac_env_RANLIB_value=$RANLIB
 766 ac_cv_env_RANLIB_set=${RANLIB+set}
 767 ac_cv_env_RANLIB_value=$RANLIB
 768 ac_env_STRIP_set=${STRIP+set}
 769 ac_env_STRIP_value=$STRIP
 770 ac_cv_env_STRIP_set=${STRIP+set}
 771 ac_cv_env_STRIP_value=$STRIP
 772 ac_env_WINDRES_set=${WINDRES+set}
 773 ac_env_WINDRES_value=$WINDRES
 774 ac_cv_env_WINDRES_set=${WINDRES+set}
 775 ac_cv_env_WINDRES_value=$WINDRES
 776 ac_env_OBJCOPY_set=${OBJCOPY+set}
 777 ac_env_OBJCOPY_value=$OBJCOPY
 778 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 779 ac_cv_env_OBJCOPY_value=$OBJCOPY
 780 ac_env_OBJDUMP_set=${OBJDUMP+set}
 781 ac_env_OBJDUMP_value=$OBJDUMP
 782 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 783 ac_cv_env_OBJDUMP_value=$OBJDUMP
 784 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 785 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 786 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 787 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 788 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 789 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 790 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 791 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 792 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 793 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 794 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 795 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 796 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 797 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 798 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 799 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 800 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 801 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 802 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 803 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 804 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 805 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 806 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 807 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 808 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 809 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 810 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 811 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 812 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 813 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 814 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 815 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 816 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 817 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 818 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 819 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 820 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 821 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 822 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 823 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 824 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 825 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 826 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 827 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 828 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 829 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 830 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 831 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 832 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 833 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 834 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 835 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 836 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 837 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 838 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 839 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 840 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 841 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 842 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 843 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 844
 845 #
 846 # Report the --help message.
 847 #
 848 if test "$ac_init_help" = "long"; then
 849   # Omit some internal or obsolete options to make the list less imposing.
 850   # This message is too long to be a string in the A/UX 3.1 sh.
 851   cat <<_ACEOF
 852 \`configure' configures this package to adapt to many kinds of systems.
 853
 854 Usage: $0 [OPTION]... [VAR=VALUE]...
 855
 856 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 857 VAR=VALUE.  See below for descriptions of some of the useful variables.
 858
 859 Defaults for the options are specified in brackets.
 860
 861 Configuration:
 862   -h, --help              display this help and exit
 863       --help=short        display options specific to this package
 864       --help=recursive    display the short help of all the included packages
 865   -V, --version           display version information and exit
 866   -q, --quiet, --silent   do not print \`checking...' messages
 867       --cache-file=FILE   cache test results in FILE [disabled]
 868   -C, --config-cache      alias for \`--cache-file=config.cache'
 869   -n, --no-create         do not create output files
 870       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 871
 872 _ACEOF
 873
 874   cat <<_ACEOF
 875 Installation directories:
 876   --prefix=PREFIX         install architecture-independent files in PREFIX
 877                           [$ac_default_prefix]
 878   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 879                           [PREFIX]
 880
 881 By default, \`make install' will install all the files in
 882 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 883 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 884 for instance \`--prefix=\$HOME'.
 885
 886 For better control, use the options below.
 887
 888 Fine tuning of the installation directories:
 889   --bindir=DIR           user executables [EPREFIX/bin]
 890   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 891   --libexecdir=DIR       program executables [EPREFIX/libexec]
 892   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 893   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 894   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 895   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 896   --libdir=DIR           object code libraries [EPREFIX/lib]
 897   --includedir=DIR       C header files [PREFIX/include]
 898   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 899   --infodir=DIR          info documentation [PREFIX/info]
 900   --mandir=DIR           man documentation [PREFIX/man]
 901 _ACEOF
 902
 903   cat <<\_ACEOF
 904
 905 Program names:
 906   --program-prefix=PREFIX            prepend PREFIX to installed program names
 907   --program-suffix=SUFFIX            append SUFFIX to installed program names
 908   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 909
 910 System types:
 911   --build=BUILD     configure for building on BUILD [guessed]
 912   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 913   --target=TARGET   configure for building compilers for TARGET [HOST]
 914 _ACEOF
 915 fi
 916
 917 if test -n "$ac_init_help"; then
 918
 919   cat <<\_ACEOF
 920
 921 Optional Features:
 922   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 923   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 924   --enable-libada        Builds libada directory
 925   --enable-libssp        Builds libssp directory
 926   --enable-stage1-languages=all   choose additional languages to build during
 927                           stage1.  Mostly useful for compiler development.
 928   --enable-objc-gc       enable the use of Boehm's garbage collector with
 929                           the GNU Objective-C runtime.
 930   --enable-bootstrap           Enable bootstrapping yes if native build
 931   --enable-serial-{host,target,build}-configure
 932                           Force sequential configuration of
 933                           sub-packages for the host, target or build
 934                           machine, or all sub-packages
 935   --enable-maintainer-mode enable make rules and dependencies not useful
 936                           (and sometimes confusing) to the casual installer
 937   --enable-stage1-checking=all   choose additional checking for stage1
 938                           of the compiler.
 939   --enable-werror         enable -Werror in bootstrap stage2 and later
 940
 941 Optional Packages:
 942   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 943   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 944   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 945   --with-mpfr-dir=PATH    This option has been REMOVED
 946   --with-mpfr=PATH        Specify prefix directory for installed MPFR package
 947                           Equivalent to --with-mpfr-include=PATH/include
 948                           plus --with-mpfr-lib=PATH/lib
 949   --with-mpfr-include=PATH
 950                           Specify directory for installed MPFR include files
 951   --with-mpfr-lib=PATH    Specify the directory for the installed MPFR library
 952   --with-gmp-dir=PATH     This option has been REMOVED
 953   --with-gmp=PATH         Specify prefix directory for the installed GMP package
 954                           Equivalent to --with-gmp-include=PATH/include
 955                           plus --with-gmp-lib=PATH/lib
 956   --with-gmp-include=PATH Specify directory for installed GMP include files
 957   --with-gmp-lib=PATH     Specify the directory for the installed GMP library
 958   --with-build-sysroot=sysroot
 959                           use sysroot as the system root during the build
 960   --with-build-time-tools=path
 961                           use given path to find target tools during the build
 962   --with-datarootdir    Use datarootdir as the data root directory.
 963   --with-docdir Install documentation in this directory.
 964   --with-pdfdir Install pdf in this directory.
 965   --with-htmldir        Install html in this directory.
 966
 967 Some influential environment variables:
 968   CC          C compiler command
 969   CFLAGS      C compiler flags
 970   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 971               nonstandard directory <lib dir>
 972   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 973               headers in a nonstandard directory <include dir>
 974   CXX         C++ compiler command
 975   CXXFLAGS    C++ compiler flags
 976   AR          AR for the host
 977   AS          AS for the host
 978   DLLTOOL     DLLTOOL for the host
 979   LD          LD for the host
 980   LIPO        LIPO for the host
 981   NM          NM for the host
 982   RANLIB      RANLIB for the host
 983   STRIP       STRIP for the host
 984   WINDRES     WINDRES for the host
 985   OBJCOPY     OBJCOPY for the host
 986   OBJDUMP     OBJDUMP for the host
 987   CC_FOR_TARGET
 988               CC for the target
 989   CXX_FOR_TARGET
 990               CXX for the target
 991   GCC_FOR_TARGET
 992               GCC for the target
 993   GCJ_FOR_TARGET
 994               GCJ for the target
 995   GFORTRAN_FOR_TARGET
 996               GFORTRAN for the target
 997   AR_FOR_TARGET
 998               AR for the target
 999   AS_FOR_TARGET
1000               AS for the target
1001   DLLTOOL_FOR_TARGET
1002               DLLTOOL for the target
1003   LD_FOR_TARGET
1004               LD for the target
1005   LIPO_FOR_TARGET
1006               LIPO for the target
1007   NM_FOR_TARGET
1008               NM for the target
1009   OBJDUMP_FOR_TARGET
1010               OBJDUMP for the target
1011   RANLIB_FOR_TARGET
1012               RANLIB for the target
1013   STRIP_FOR_TARGET
1014               STRIP for the target
1015   WINDRES_FOR_TARGET
1016               WINDRES for the target
1017
1018 Use these variables to override the choices made by `configure' or to help
1019 it to find libraries and programs with nonstandard names/locations.
1020
1021 _ACEOF
1022 fi
1023
1024 if test "$ac_init_help" = "recursive"; then
1025   # If there are subdirs, report their specific --help.
1026   ac_popdir=`pwd`
1027   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1028     test -d $ac_dir || continue
1029     ac_builddir=.
1030
1031 if test "$ac_dir" != .; then
1032   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1033   # A "../" for each directory in $ac_dir_suffix.
1034   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1035 else
1036   ac_dir_suffix= ac_top_builddir=
1037 fi
1038
1039 case $srcdir in
1040   .)  # No --srcdir option.  We are building in place.
1041     ac_srcdir=.
1042     if test -z "$ac_top_builddir"; then
1043        ac_top_srcdir=.
1044     else
1045        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1046     fi ;;
1047   [\\/]* | ?:[\\/]* )  # Absolute path.
1048     ac_srcdir=$srcdir$ac_dir_suffix;
1049     ac_top_srcdir=$srcdir ;;
1050   *) # Relative path.
1051     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1052     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1053 esac
1054
1055 # Do not use `cd foo && pwd` to compute absolute paths, because
1056 # the directories may not exist.
1057 case `pwd` in
1058 .) ac_abs_builddir="$ac_dir";;
1059 *)
1060   case "$ac_dir" in
1061   .) ac_abs_builddir=`pwd`;;
1062   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1063   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1064   esac;;
1065 esac
1066 case $ac_abs_builddir in
1067 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1068 *)
1069   case ${ac_top_builddir}. in
1070   .) ac_abs_top_builddir=$ac_abs_builddir;;
1071   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1072   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1073   esac;;
1074 esac
1075 case $ac_abs_builddir in
1076 .) ac_abs_srcdir=$ac_srcdir;;
1077 *)
1078   case $ac_srcdir in
1079   .) ac_abs_srcdir=$ac_abs_builddir;;
1080   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1081   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1082   esac;;
1083 esac
1084 case $ac_abs_builddir in
1085 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1086 *)
1087   case $ac_top_srcdir in
1088   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1089   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1090   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1091   esac;;
1092 esac
1093
1094     cd $ac_dir
1095     # Check for guested configure; otherwise get Cygnus style configure.
1096     if test -f $ac_srcdir/configure.gnu; then
1097       echo
1098       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1099     elif test -f $ac_srcdir/configure; then
1100       echo
1101       $SHELL $ac_srcdir/configure  --help=recursive
1102     elif test -f $ac_srcdir/configure.ac ||
1103            test -f $ac_srcdir/configure.in; then
1104       echo
1105       $ac_configure --help
1106     else
1107       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1108     fi
1109     cd $ac_popdir
1110   done
1111 fi
1112
1113 test -n "$ac_init_help" && exit 0
1114 if $ac_init_version; then
1115   cat <<\_ACEOF
1116
1117 Copyright (C) 2003 Free Software Foundation, Inc.
1118 This configure script is free software; the Free Software Foundation
1119 gives unlimited permission to copy, distribute and modify it.
1120 _ACEOF
1121   exit 0
1122 fi
1123 exec 5>config.log
1124 cat >&5 <<_ACEOF
1125 This file contains any messages produced by compilers while
1126 running configure, to aid debugging if configure makes a mistake.
1127
1128 It was created by $as_me, which was
1129 generated by GNU Autoconf 2.59.  Invocation command line was
1130
1131   $ $0 $@
1132
1133 _ACEOF
1134 {
1135 cat <<_ASUNAME
1136 ## --------- ##
1137 ## Platform. ##
1138 ## --------- ##
1139
1140 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1141 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1142 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1143 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1144 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1145
1146 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1147 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1148
1149 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1150 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1151 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1152 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1153 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1154 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1155 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1156
1157 _ASUNAME
1158
1159 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1160 for as_dir in $PATH
1161 do
1162   IFS=$as_save_IFS
1163   test -z "$as_dir" && as_dir=.
1164   echo "PATH: $as_dir"
1165 done
1166
1167 } >&5
1168
1169 cat >&5 <<_ACEOF
1170
1171
1172 ## ----------- ##
1173 ## Core tests. ##
1174 ## ----------- ##
1175
1176 _ACEOF
1177
1178
1179 # Keep a trace of the command line.
1180 # Strip out --no-create and --no-recursion so they do not pile up.
1181 # Strip out --silent because we don't want to record it for future runs.
1182 # Also quote any args containing shell meta-characters.
1183 # Make two passes to allow for proper duplicate-argument suppression.
1184 ac_configure_args=
1185 ac_configure_args0=
1186 ac_configure_args1=
1187 ac_sep=
1188 ac_must_keep_next=false
1189 for ac_pass in 1 2
1190 do
1191   for ac_arg
1192   do
1193     case $ac_arg in
1194     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1195     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1196     | -silent | --silent | --silen | --sile | --sil)
1197       continue ;;
1198     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1199       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1200     esac
1201     case $ac_pass in
1202     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1203     2)
1204       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1205       if test $ac_must_keep_next = true; then
1206         ac_must_keep_next=false # Got value, back to normal.
1207       else
1208         case $ac_arg in
1209           *=* | --config-cache | -C | -disable-* | --disable-* \
1210           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1211           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1212           | -with-* | --with-* | -without-* | --without-* | --x)
1213             case "$ac_configure_args0 " in
1214               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1215             esac
1216             ;;
1217           -* ) ac_must_keep_next=true ;;
1218         esac
1219       fi
1220       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1221       # Get rid of the leading space.
1222       ac_sep=" "
1223       ;;
1224     esac
1225   done
1226 done
1227 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1228 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1229
1230 # When interrupted or exit'd, cleanup temporary files, and complete
1231 # config.log.  We remove comments because anyway the quotes in there
1232 # would cause problems or look ugly.
1233 # WARNING: Be sure not to use single quotes in there, as some shells,
1234 # such as our DU 5.0 friend, will then `close' the trap.
1235 trap 'exit_status=$?
1236   # Save into config.log some information that might help in debugging.
1237   {
1238     echo
1239
1240     cat <<\_ASBOX
1241 ## ---------------- ##
1242 ## Cache variables. ##
1243 ## ---------------- ##
1244 _ASBOX
1245     echo
1246     # The following way of writing the cache mishandles newlines in values,
1247 {
1248   (set) 2>&1 |
1249     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1250     *ac_space=\ *)
1251       sed -n \
1252         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1253           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1254       ;;
1255     *)
1256       sed -n \
1257         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1258       ;;
1259     esac;
1260 }
1261     echo
1262
1263     cat <<\_ASBOX
1264 ## ----------------- ##
1265 ## Output variables. ##
1266 ## ----------------- ##
1267 _ASBOX
1268     echo
1269     for ac_var in $ac_subst_vars
1270     do
1271       eval ac_val=$`echo $ac_var`
1272       echo "$ac_var='"'"'$ac_val'"'"'"
1273     done | sort
1274     echo
1275
1276     if test -n "$ac_subst_files"; then
1277       cat <<\_ASBOX
1278 ## ------------- ##
1279 ## Output files. ##
1280 ## ------------- ##
1281 _ASBOX
1282       echo
1283       for ac_var in $ac_subst_files
1284       do
1285         eval ac_val=$`echo $ac_var`
1286         echo "$ac_var='"'"'$ac_val'"'"'"
1287       done | sort
1288       echo
1289     fi
1290
1291     if test -s confdefs.h; then
1292       cat <<\_ASBOX
1293 ## ----------- ##
1294 ## confdefs.h. ##
1295 ## ----------- ##
1296 _ASBOX
1297       echo
1298       sed "/^$/d" confdefs.h | sort
1299       echo
1300     fi
1301     test "$ac_signal" != 0 &&
1302       echo "$as_me: caught signal $ac_signal"
1303     echo "$as_me: exit $exit_status"
1304   } >&5
1305   rm -f core *.core &&
1306   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1307     exit $exit_status
1308      ' 0
1309 for ac_signal in 1 2 13 15; do
1310   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1311 done
1312 ac_signal=0
1313
1314 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1315 rm -rf conftest* confdefs.h
1316 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1317 echo >confdefs.h
1318
1319 # Predefined preprocessor variables.
1320
1321 cat >>confdefs.h <<_ACEOF
1322 #define PACKAGE_NAME "$PACKAGE_NAME"
1323 _ACEOF
1324
1325
1326 cat >>confdefs.h <<_ACEOF
1327 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1328 _ACEOF
1329
1330
1331 cat >>confdefs.h <<_ACEOF
1332 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1333 _ACEOF
1334
1335
1336 cat >>confdefs.h <<_ACEOF
1337 #define PACKAGE_STRING "$PACKAGE_STRING"
1338 _ACEOF
1339
1340
1341 cat >>confdefs.h <<_ACEOF
1342 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1343 _ACEOF
1344
1345
1346 # Let the site file select an alternate cache file if it wants to.
1347 # Prefer explicitly selected file to automatically selected ones.
1348 if test -z "$CONFIG_SITE"; then
1349   if test "x$prefix" != xNONE; then
1350     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1351   else
1352     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1353   fi
1354 fi
1355 for ac_site_file in $CONFIG_SITE; do
1356   if test -r "$ac_site_file"; then
1357     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1358 echo "$as_me: loading site script $ac_site_file" >&6;}
1359     sed 's/^/| /' "$ac_site_file" >&5
1360     . "$ac_site_file"
1361   fi
1362 done
1363
1364 if test -r "$cache_file"; then
1365   # Some versions of bash will fail to source /dev/null (special
1366   # files actually), so we avoid doing that.
1367   if test -f "$cache_file"; then
1368     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1369 echo "$as_me: loading cache $cache_file" >&6;}
1370     case $cache_file in
1371       [\\/]* | ?:[\\/]* ) . $cache_file;;
1372       *)                      . ./$cache_file;;
1373     esac
1374   fi
1375 else
1376   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1377 echo "$as_me: creating cache $cache_file" >&6;}
1378   >$cache_file
1379 fi
1380
1381 # Check that the precious variables saved in the cache have kept the same
1382 # value.
1383 ac_cache_corrupted=false
1384 for ac_var in `(set) 2>&1 |
1385                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1386   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1387   eval ac_new_set=\$ac_env_${ac_var}_set
1388   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1389   eval ac_new_val="\$ac_env_${ac_var}_value"
1390   case $ac_old_set,$ac_new_set in
1391     set,)
1392       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1393 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1394       ac_cache_corrupted=: ;;
1395     ,set)
1396       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1397 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1398       ac_cache_corrupted=: ;;
1399     ,);;
1400     *)
1401       if test "x$ac_old_val" != "x$ac_new_val"; then
1402         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1403 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1404         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1405 echo "$as_me:   former value:  $ac_old_val" >&2;}
1406         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1407 echo "$as_me:   current value: $ac_new_val" >&2;}
1408         ac_cache_corrupted=:
1409       fi;;
1410   esac
1411   # Pass precious variables to config.status.
1412   if test "$ac_new_set" = set; then
1413     case $ac_new_val in
1414     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1415       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1416     *) ac_arg=$ac_var=$ac_new_val ;;
1417     esac
1418     case " $ac_configure_args " in
1419       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1420       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1421     esac
1422   fi
1423 done
1424 if $ac_cache_corrupted; then
1425   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1426 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1427   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1428 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1429    { (exit 1); exit 1; }; }
1430 fi
1431
1432 ac_ext=c
1433 ac_cpp='$CPP $CPPFLAGS'
1434 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1435 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1436 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458 # Find the build, host, and target systems.
1459 ac_aux_dir=
1460 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1461   if test -f $ac_dir/install-sh; then
1462     ac_aux_dir=$ac_dir
1463     ac_install_sh="$ac_aux_dir/install-sh -c"
1464     break
1465   elif test -f $ac_dir/install.sh; then
1466     ac_aux_dir=$ac_dir
1467     ac_install_sh="$ac_aux_dir/install.sh -c"
1468     break
1469   elif test -f $ac_dir/shtool; then
1470     ac_aux_dir=$ac_dir
1471     ac_install_sh="$ac_aux_dir/shtool install -c"
1472     break
1473   fi
1474 done
1475 if test -z "$ac_aux_dir"; then
1476   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1477 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1478    { (exit 1); exit 1; }; }
1479 fi
1480 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1481 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1482 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1483
1484 # Make sure we can run config.sub.
1485 $ac_config_sub sun4 >/dev/null 2>&1 ||
1486   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1487 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1488    { (exit 1); exit 1; }; }
1489
1490 echo "$as_me:$LINENO: checking build system type" >&5
1491 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1492 if test "${ac_cv_build+set}" = set; then
1493   echo $ECHO_N "(cached) $ECHO_C" >&6
1494 else
1495   ac_cv_build_alias=$build_alias
1496 test -z "$ac_cv_build_alias" &&
1497   ac_cv_build_alias=`$ac_config_guess`
1498 test -z "$ac_cv_build_alias" &&
1499   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1500 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1501    { (exit 1); exit 1; }; }
1502 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1503   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1504 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1505    { (exit 1); exit 1; }; }
1506
1507 fi
1508 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1509 echo "${ECHO_T}$ac_cv_build" >&6
1510 build=$ac_cv_build
1511 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1512 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1513 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1514
1515
1516  case ${build_alias} in
1517   "") build_noncanonical=${build} ;;
1518   *) build_noncanonical=${build_alias} ;;
1519 esac
1520
1521
1522
1523  case ${host_alias} in
1524   "") host_noncanonical=${build_noncanonical} ;;
1525   *) host_noncanonical=${host_alias} ;;
1526 esac
1527
1528
1529
1530  case ${target_alias} in
1531   "") target_noncanonical=${host_noncanonical} ;;
1532   *) target_noncanonical=${target_alias} ;;
1533 esac
1534
1535
1536
1537
1538 test "$host_noncanonical" = "$target_noncanonical" &&
1539   test "$program_prefix$program_suffix$program_transform_name" = \
1540     NONENONEs,x,x, &&
1541   program_transform_name=s,y,y,
1542
1543 echo "$as_me:$LINENO: checking host system type" >&5
1544 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1545 if test "${ac_cv_host+set}" = set; then
1546   echo $ECHO_N "(cached) $ECHO_C" >&6
1547 else
1548   ac_cv_host_alias=$host_alias
1549 test -z "$ac_cv_host_alias" &&
1550   ac_cv_host_alias=$ac_cv_build_alias
1551 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1552   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1553 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1554    { (exit 1); exit 1; }; }
1555
1556 fi
1557 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1558 echo "${ECHO_T}$ac_cv_host" >&6
1559 host=$ac_cv_host
1560 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1561 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1562 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1563
1564
1565 echo "$as_me:$LINENO: checking target system type" >&5
1566 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1567 if test "${ac_cv_target+set}" = set; then
1568   echo $ECHO_N "(cached) $ECHO_C" >&6
1569 else
1570   ac_cv_target_alias=$target_alias
1571 test "x$ac_cv_target_alias" = "x" &&
1572   ac_cv_target_alias=$ac_cv_host_alias
1573 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1574   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1575 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1576    { (exit 1); exit 1; }; }
1577
1578 fi
1579 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1580 echo "${ECHO_T}$ac_cv_target" >&6
1581 target=$ac_cv_target
1582 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1583 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1584 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1585
1586
1587 # The aliases save the names the user supplied, while $host etc.
1588 # will get canonicalized.
1589 test -n "$target_alias" &&
1590   test "$program_prefix$program_suffix$program_transform_name" = \
1591     NONENONEs,x,x, &&
1592   program_prefix=${target_alias}-
1593 test "$program_prefix" != NONE &&
1594   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1595 # Use a double $ so make ignores it.
1596 test "$program_suffix" != NONE &&
1597   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1598 # Double any \ or $.  echo might interpret backslashes.
1599 # By default was `s,x,x', remove it if useless.
1600 cat <<\_ACEOF >conftest.sed
1601 s/[\\$]/&&/g;s/;s,x,x,$//
1602 _ACEOF
1603 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1604 rm conftest.sed
1605
1606
1607
1608 # Get 'install' or 'install-sh' and its variants.
1609 # Find a good install program.  We prefer a C program (faster),
1610 # so one script is as good as another.  But avoid the broken or
1611 # incompatible versions:
1612 # SysV /etc/install, /usr/sbin/install
1613 # SunOS /usr/etc/install
1614 # IRIX /sbin/install
1615 # AIX /bin/install
1616 # AmigaOS /C/install, which installs bootblocks on floppy discs
1617 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1618 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1619 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1620 # OS/2's system install, which has a completely different semantic
1621 # ./install, which can be erroneously created by make from ./install.sh.
1622 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1623 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1624 if test -z "$INSTALL"; then
1625 if test "${ac_cv_path_install+set}" = set; then
1626   echo $ECHO_N "(cached) $ECHO_C" >&6
1627 else
1628   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1629 for as_dir in $PATH
1630 do
1631   IFS=$as_save_IFS
1632   test -z "$as_dir" && as_dir=.
1633   # Account for people who put trailing slashes in PATH elements.
1634 case $as_dir/ in
1635   ./ | .// | /cC/* | \
1636   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1637   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1638   /usr/ucb/* ) ;;
1639   *)
1640     # OSF1 and SCO ODT 3.0 have their own names for install.
1641     # Don't use installbsd from OSF since it installs stuff as root
1642     # by default.
1643     for ac_prog in ginstall scoinst install; do
1644       for ac_exec_ext in '' $ac_executable_extensions; do
1645         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1646           if test $ac_prog = install &&
1647             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1648             # AIX install.  It has an incompatible calling convention.
1649             :
1650           elif test $ac_prog = install &&
1651             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1652             # program-specific install script used by HP pwplus--don't use.
1653             :
1654           else
1655             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1656             break 3
1657           fi
1658         fi
1659       done
1660     done
1661     ;;
1662 esac
1663 done
1664
1665
1666 fi
1667   if test "${ac_cv_path_install+set}" = set; then
1668     INSTALL=$ac_cv_path_install
1669   else
1670     # As a last resort, use the slow shell script.  We don't cache a
1671     # path for INSTALL within a source directory, because that will
1672     # break other packages using the cache if that directory is
1673     # removed, or if the path is relative.
1674     INSTALL=$ac_install_sh
1675   fi
1676 fi
1677 echo "$as_me:$LINENO: result: $INSTALL" >&5
1678 echo "${ECHO_T}$INSTALL" >&6
1679
1680 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1681 # It thinks the first close brace ends the variable substitution.
1682 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1683
1684 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1685
1686 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1687
1688 echo "$as_me:$LINENO: checking whether ln works" >&5
1689 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1690 if test "${acx_cv_prog_LN+set}" = set; then
1691   echo $ECHO_N "(cached) $ECHO_C" >&6
1692 else
1693   rm -f conftestdata_t
1694 echo >conftestdata_f
1695 if ln conftestdata_f conftestdata_t 2>/dev/null
1696 then
1697   acx_cv_prog_LN=ln
1698 else
1699   acx_cv_prog_LN=no
1700 fi
1701 rm -f conftestdata_f conftestdata_t
1702
1703 fi
1704 if test $acx_cv_prog_LN = no; then
1705   LN="cp"
1706   echo "$as_me:$LINENO: result: no, using $LN" >&5
1707 echo "${ECHO_T}no, using $LN" >&6
1708 else
1709   LN="$acx_cv_prog_LN"
1710   echo "$as_me:$LINENO: result: yes" >&5
1711 echo "${ECHO_T}yes" >&6
1712 fi
1713
1714 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1715 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1716 LN_S=$as_ln_s
1717 if test "$LN_S" = "ln -s"; then
1718   echo "$as_me:$LINENO: result: yes" >&5
1719 echo "${ECHO_T}yes" >&6
1720 else
1721   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1722 echo "${ECHO_T}no, using $LN_S" >&6
1723 fi
1724
1725
1726 ### we might need to use some other shell than /bin/sh for running subshells
1727 ### If we are on Windows, search for the shell.  This will permit people
1728 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1729 ### without also having to set CONFIG_SHELL.  This code will work when
1730 ### using bash, which sets OSTYPE.
1731 case "${OSTYPE}" in
1732 *win32*)
1733   if test x${CONFIG_SHELL} = x ; then
1734     if test ! -f /bin/sh ; then
1735       if test x${SHELL} != x && test -f ${SHELL} ; then
1736         CONFIG_SHELL=${SHELL}
1737         export CONFIG_SHELL
1738       else
1739         for prog in sh sh.exe bash bash.exe; do
1740           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1741           for dir in $PATH; do
1742             test -z "$dir" && dir=.
1743             if test -f $dir/$prog; then
1744               CONFIG_SHELL=$dir/$prog
1745               export CONFIG_SHELL
1746               break
1747             fi
1748           done
1749           IFS="$save_ifs"
1750           test -n "${CONFIG_SHELL}" && break
1751         done
1752       fi
1753     fi
1754   fi
1755   ;;
1756 esac
1757
1758 config_shell=${CONFIG_SHELL-/bin/sh}
1759
1760 progname=$0
1761 # if PWD already has a value, it is probably wrong.
1762 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1763
1764 # Export original configure arguments for use by sub-configures.
1765 # Quote arguments with shell meta charatcers.
1766 TOPLEVEL_CONFIGURE_ARGUMENTS=
1767 set -- "$progname" "$@"
1768 for ac_arg
1769 do
1770   case "$ac_arg" in
1771   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1772     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1773     # if the argument is of the form -foo=baz, quote the baz part only
1774     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1775   *) ;;
1776   esac
1777   # Add the quoted argument to the list.
1778   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1779 done
1780 # Remove the initial space we just introduced and, as these will be
1781 # expanded by make, quote '$'.
1782 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1783
1784
1785 moveifchange=${srcdir}/move-if-change
1786
1787 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1788
1789 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1790 # a relative path.
1791 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1792   INSTALL="${srcpwd}/install-sh -c"
1793 fi
1794
1795 # Set srcdir to "." if that's what it is.
1796 # This is important for multilib support.
1797 pwd=`${PWDCMD-pwd}`
1798 if test "${pwd}" = "${srcpwd}" ; then
1799   srcdir=.
1800 fi
1801
1802 topsrcdir=$srcpwd
1803
1804 extra_host_args=
1805
1806 ### To add a new directory to the tree, first choose whether it is a target
1807 ### or a host dependent tool.  Then put it into the appropriate list
1808 ### (library or tools, host or target), doing a dependency sort.
1809
1810 # Subdirs will be configured in the order listed in build_configdirs,
1811 # configdirs, or target_configdirs; see the serialization section below.
1812
1813 # Dependency sorting is only needed when *configuration* must be done in
1814 # a particular order.  In all cases a dependency should be specified in
1815 # the Makefile, whether or not it's implicitly specified here.
1816
1817 # Double entries in build_configdirs, configdirs, or target_configdirs may
1818 # cause circular dependencies and break everything horribly.
1819
1820 # these library is used by various programs built for the build
1821 # environment
1822 #
1823 build_libs="build-libiberty"
1824
1825 # these tools are built for the build environment
1826 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1827
1828 # these libraries are used by various programs built for the host environment
1829 #
1830 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1831
1832 # these tools are built for the host environment
1833 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1834 # know that we are building the simulator.
1835 # binutils, gas and ld appear in that order because it makes sense to run
1836 # "make check" in that particular order.
1837 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"
1838
1839 # libgcj represents the runtime libraries only used by gcj.
1840 libgcj="target-libffi \
1841         target-zlib \
1842         target-qthreads \
1843         target-libjava"
1844
1845 # these libraries are built for the target environment, and are built after
1846 # the host libraries and the host tools (which may be a cross compiler)
1847 #
1848 target_libraries="target-libgcc \
1849                 target-libiberty \
1850                 target-libgloss \
1851                 target-newlib \
1852                 target-libstdc++-v3 \
1853                 target-libmudflap \
1854                 target-libssp \
1855                 target-libgfortran \
1856                 target-boehm-gc \
1857                 ${libgcj} \
1858                 target-libobjc \
1859                 target-libada \
1860                 target-libgomp"
1861
1862 # these tools are built using the target libraries, and are intended to
1863 # run only in the target environment
1864 #
1865 # note: any program that *uses* libraries that are in the "target_libraries"
1866 # list belongs in this list.  those programs are also very likely
1867 # candidates for the "native_only" list which follows
1868 #
1869 target_tools="target-examples target-groff target-gperf target-rda"
1870
1871 ################################################################################
1872
1873 ## All tools belong in one of the four categories, and are assigned above
1874 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1875 ## is important because configure will choke if they ever get through.
1876 ## ${configdirs} is directories we build using the host tools.
1877 ## ${target_configdirs} is directories we build using the target tools.
1878 configdirs=`echo ${host_libs} ${host_tools}`
1879 target_configdirs=`echo ${target_libraries} ${target_tools}`
1880 build_configdirs=`echo ${build_libs} ${build_tools}`
1881
1882 ################################################################################
1883
1884 srcname="gnu development package"
1885
1886 # This gets set non-empty for some net releases of packages.
1887 appdirs=""
1888
1889 # Define is_cross_compiler to save on calls to 'test'.
1890 is_cross_compiler=
1891 if test x"${host}" = x"${target}" ; then
1892   is_cross_compiler=no
1893 else
1894   is_cross_compiler=yes
1895 fi
1896
1897 # Find the build and target subdir names.
1898
1899 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1900 # have matching libraries, they should use host libraries: Makefile.tpl
1901 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1902 # However, they still use the build modules, because the corresponding
1903 # host modules (e.g. bison) are only built for the host when bootstrap
1904 # finishes. So:
1905 # - build_subdir is where we find build modules, and never changes.
1906 # - build_libsubdir is where we find build libraries, and can be overridden.
1907
1908 # Prefix 'build-' so this never conflicts with target_subdir.
1909 build_subdir="build-${build_noncanonical}"
1910
1911 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1912 if test "${with_build_libsubdir+set}" = set; then
1913   withval="$with_build_libsubdir"
1914   build_libsubdir="$withval"
1915 else
1916   build_libsubdir="$build_subdir"
1917 fi;
1918 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1919 if ( test $srcdir = . && test -d gcc ) \
1920    || test -d $srcdir/../host-${host_noncanonical}; then
1921   host_subdir="host-${host_noncanonical}"
1922 else
1923   host_subdir=.
1924 fi
1925 # No prefix.
1926 target_subdir=${target_noncanonical}
1927
1928
1929 # Skipdirs are removed silently.
1930 skipdirs=
1931 # Noconfigdirs are removed loudly.
1932 noconfigdirs=""
1933
1934 use_gnu_ld=
1935 # Make sure we don't let GNU ld be added if we didn't want it.
1936 if test x$with_gnu_ld = xno ; then
1937   use_gnu_ld=no
1938   noconfigdirs="$noconfigdirs ld"
1939 fi
1940
1941 use_gnu_as=
1942 # Make sure we don't let GNU as be added if we didn't want it.
1943 if test x$with_gnu_as = xno ; then
1944   use_gnu_as=no
1945   noconfigdirs="$noconfigdirs gas"
1946 fi
1947
1948 # some tools are so dependent upon X11 that if we're not building with X,
1949 # it's not even worth trying to configure, much less build, that tool.
1950
1951 case ${with_x} in
1952   yes | "") ;; # the default value for this tree is that X11 is available
1953   no)
1954     skipdirs="${skipdirs} tk itcl libgui"
1955     # We won't be able to build gdbtk without X.
1956     enable_gdbtk=no
1957     ;;
1958   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
1959 esac
1960
1961 # Some tools are only suitable for building in a "native" situation.
1962 # Remove these if host!=target.
1963 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"
1964
1965 # Similarly, some are only suitable for cross toolchains.
1966 # Remove these if host=target.
1967 cross_only="target-libgloss target-newlib target-opcodes"
1968
1969 case $is_cross_compiler in
1970   no) skipdirs="${skipdirs} ${cross_only}" ;;
1971   yes) skipdirs="${skipdirs} ${native_only}" ;;
1972 esac
1973
1974 # If both --with-headers and --with-libs are specified, default to
1975 # --without-newlib.
1976 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
1977    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
1978   if test x"${with_newlib}" = x ; then
1979     with_newlib=no
1980   fi
1981 fi
1982
1983 # Recognize --with-newlib/--without-newlib.
1984 case ${with_newlib} in
1985   no) skipdirs="${skipdirs} target-newlib" ;;
1986   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
1987 esac
1988
1989 # Configure extra directories which are host specific
1990
1991 case "${host}" in
1992   *-cygwin*)
1993     configdirs="$configdirs libtermcap" ;;
1994 esac
1995
1996 # A target can indicate whether a language isn't supported for some reason.
1997 # Only spaces may be used in this macro; not newlines or tabs.
1998 unsupported_languages=
1999
2000 # Remove more programs from consideration, based on the host or
2001 # target this usually means that a port of the program doesn't
2002 # exist yet.
2003
2004 case "${host}" in
2005   hppa*64*-*-*)
2006     noconfigdirs="$noconfigdirs byacc"
2007     ;;
2008   i[3456789]86-*-vsta)
2009     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2010     ;;
2011   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2012     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2013     ;;
2014   x86_64-*-mingw*)
2015     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2016     ;;
2017   i[3456789]86-*-mingw32*)
2018     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2019     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2020     ;;
2021   i[3456789]86-*-beos*)
2022     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2023     ;;
2024   *-*-cygwin*)
2025     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2026     ;;
2027   *-*-netbsd*)
2028     noconfigdirs="$noconfigdirs rcs"
2029     ;;
2030   ppc*-*-pe)
2031     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2032     ;;
2033   powerpc-*-beos*)
2034     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2035     ;;
2036 esac
2037
2038
2039 # Check whether --enable-libada or --disable-libada was given.
2040 if test "${enable_libada+set}" = set; then
2041   enableval="$enable_libada"
2042   ENABLE_LIBADA=$enableval
2043 else
2044   ENABLE_LIBADA=yes
2045 fi;
2046 if test "${ENABLE_LIBADA}" != "yes" ; then
2047   noconfigdirs="$noconfigdirs gnattools"
2048 fi
2049
2050 # Check whether --enable-libssp or --disable-libssp was given.
2051 if test "${enable_libssp+set}" = set; then
2052   enableval="$enable_libssp"
2053   ENABLE_LIBSSP=$enableval
2054 else
2055   ENABLE_LIBSSP=yes
2056 fi;
2057
2058 # Save it here so that, even in case of --enable-libgcj, if the Java
2059 # front-end isn't enabled, we still get libgcj disabled.
2060 libgcj_saved=$libgcj
2061 case $enable_libgcj in
2062 yes)
2063   # If we reset it here, it won't get added to noconfigdirs in the
2064   # target-specific build rules, so it will be forcibly enabled
2065   # (unless the Java language itself isn't enabled).
2066   libgcj=
2067   ;;
2068 no)
2069   # Make sure we get it printed in the list of not supported target libs.
2070   noconfigdirs="$noconfigdirs ${libgcj}"
2071   ;;
2072 esac
2073
2074
2075 # Disable libmudflap on some systems.
2076 if test x$enable_libmudflap = x ; then
2077     case "${target}" in
2078     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2079         # Enable libmudflap by default in GNU and friends.
2080         ;;
2081     *-*-freebsd*)
2082         # Enable libmudflap by default in FreeBSD.
2083         ;;
2084     *)
2085         # Disable it by default everywhere else.
2086         noconfigdirs="$noconfigdirs target-libmudflap"
2087         ;;
2088     esac
2089 fi
2090
2091 # Disable libgomp on non POSIX hosted systems.
2092 if test x$enable_libgomp = x ; then
2093     # Enable libgomp by default on hosted POSIX systems.
2094     case "${target}" in
2095     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2096         ;;
2097     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2098         ;;
2099     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2100         ;;
2101     *-*-darwin* | *-*-aix*)
2102         ;;
2103     *)
2104         noconfigdirs="$noconfigdirs target-libgomp"
2105         ;;
2106     esac
2107 fi
2108
2109
2110 case "${target}" in
2111   *-*-chorusos)
2112     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2113     ;;
2114   powerpc-*-darwin* | i[3456789]86-*-darwin*)
2115     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2116     noconfigdirs="$noconfigdirs sim target-rda"
2117     ;;
2118   *-*-darwin*)
2119     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2120     noconfigdirs="$noconfigdirs sim target-rda"
2121     noconfigdirs="$noconfigdirs ${libgcj}"
2122     ;;
2123   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2124     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2125     ;;
2126   *-*-freebsd*)
2127     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2128     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2129         && test -f /usr/local/include/gmp.h; then
2130       with_gmp=/usr/local
2131     fi
2132
2133     # Skip some stuff that's unsupported on some FreeBSD configurations.
2134     case "${target}" in
2135       i*86-*-*) ;;
2136       alpha*-*-*) ;;
2137       *)
2138         noconfigdirs="$noconfigdirs ${libgcj}"
2139         ;;
2140     esac
2141     ;;
2142   *-*-kaos*)
2143     # Remove unsupported stuff on all kaOS configurations.
2144     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2145     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2146     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2147     noconfigdirs="$noconfigdirs target-libgloss"
2148     ;;
2149   *-*-netbsd*)
2150     # Skip some stuff on all NetBSD configurations.
2151     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2152
2153     # Skip some stuff that's unsupported on some NetBSD configurations.
2154     case "${target}" in
2155       i*86-*-netbsdelf*) ;;
2156       arm*-*-netbsdelf*) ;;
2157       *)
2158         noconfigdirs="$noconfigdirs ${libgcj}"
2159         ;;
2160     esac
2161     ;;
2162   *-*-netware*)
2163     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2164     ;;
2165   *-*-rtems*)
2166     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2167     ;;
2168     # The tpf target doesn't support gdb yet.
2169   *-*-tpf*)
2170     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2171     ;;
2172   *-*-uclinux*)
2173     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2174     ;;
2175   *-*-vxworks*)
2176     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2177     ;;
2178   alpha*-dec-osf*)
2179     # ld works, but does not support shared libraries.
2180     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2181     # gas doesn't generate exception information.
2182     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2183     ;;
2184   alpha*-*-*vms*)
2185     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2186     ;;
2187   alpha*-*-linux*)
2188     # newlib is not 64 bit ready
2189     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2190     ;;
2191   alpha*-*-*)
2192     # newlib is not 64 bit ready
2193     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2194     ;;
2195   am33_2.0-*-linux*)
2196     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2197     ;;
2198   sh-*-linux*)
2199     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2200     ;;
2201   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2202     noconfigdirs="$noconfigdirs ${libgcj}"
2203     noconfigdirs="$noconfigdirs target-examples"
2204     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2205     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2206     noconfigdirs="$noconfigdirs expect dejagnu"
2207     # the C++ libraries don't build on top of CE's C libraries
2208     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2209     noconfigdirs="$noconfigdirs target-newlib"
2210     case "${host}" in
2211       *-*-cygwin*) ;; # keep gdb and readline
2212       *) noconfigdirs="$noconfigdirs gdb readline"
2213          ;;
2214     esac
2215     ;;
2216   arc-*-*)
2217     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2218     ;;
2219   arm-semi-aof )
2220     ;;
2221   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2222     noconfigdirs="$noconfigdirs ${libgcj}"
2223     ;;
2224   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2225     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2226     ;;
2227   arm*-*-linux-gnueabi)
2228     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2229     noconfigdirs="$noconfigdirs target-libjava target-libobjc"
2230     ;;
2231   arm*-*-symbianelf*)
2232     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2233     ;;
2234   arm-*-pe*)
2235     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2236     ;;
2237   thumb-*-coff)
2238     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2239     ;;
2240   thumb-*-elf)
2241     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2242     ;;
2243   thumb-*-pe)
2244     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2245     ;;
2246   arm-*-riscix*)
2247     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2248     ;;
2249   avr-*-*)
2250     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2251     ;;
2252   bfin-*-*)
2253     noconfigdirs="$noconfigdirs gdb"
2254     if test x${is_cross_compiler} != xno ; then
2255       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2256     fi
2257     ;;
2258   c4x-*-* | tic4x-*-*)
2259     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2260     ;;
2261   c54x*-*-* | tic54x-*-*)
2262     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2263     ;;
2264   cris-*-* | crisv32-*-*)
2265     unsupported_languages="$unsupported_languages java"
2266     case "${target}" in
2267       *-*-aout)
2268         unsupported_languages="$unsupported_languages fortran"
2269         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2270       *-*-elf)
2271         unsupported_languages="$unsupported_languages fortran"
2272         noconfigdirs="$noconfigdirs target-boehm-gc";;
2273       *-*-linux*)
2274         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2275       *)
2276         unsupported_languages="$unsupported_languages fortran"
2277         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2278     esac
2279     ;;
2280   crx-*-*)
2281     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2282     ;;
2283   d10v-*-*)
2284     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2285     ;;
2286   d30v-*-*)
2287     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2288     ;;
2289   fr30-*-elf*)
2290     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2291     ;;
2292   frv-*-*)
2293     noconfigdirs="$noconfigdirs ${libgcj}"
2294     ;;
2295   h8300*-*-*)
2296     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2297     ;;
2298   h8500-*-*)
2299     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2300     ;;
2301   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2302     ;;
2303   hppa*64*-*-linux* | parisc*64*-*-linux*)
2304     # In this case, it's because the hppa64-linux target is for
2305     # the kernel only at this point and has no libc, and thus no
2306     # headers, crt*.o, etc., all of which are needed by these.
2307     noconfigdirs="$noconfigdirs target-zlib"
2308     ;;
2309   parisc*-*-linux* | hppa*-*-linux*)
2310     ;;
2311   hppa*-*-*elf* | \
2312   hppa*-*-lites* | \
2313   hppa*-*-openbsd* | \
2314   hppa*64*-*-*)
2315     noconfigdirs="$noconfigdirs ${libgcj}"
2316     ;;
2317   hppa*-hp-hpux11*)
2318     noconfigdirs="$noconfigdirs ld shellutils"
2319     ;;
2320   hppa*-*-*)
2321     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2322     # build on HP-UX 10.20.
2323     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2324     ;;
2325   i960-*-*)
2326     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2327     ;;
2328   ia64*-*-elf*)
2329     # No gdb support yet.
2330     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2331     ;;
2332   ia64*-**-hpux*)
2333     # No gdb or ld support yet.
2334     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2335     ;;
2336   i370-*-opened*)
2337     ;;
2338   i[3456789]86-*-coff | i[3456789]86-*-elf)
2339     noconfigdirs="$noconfigdirs ${libgcj}"
2340     ;;
2341   i[3456789]86-*-linux*)
2342     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2343     # not build java stuff by default.
2344     case "${target}" in
2345       *-*-*libc1*)
2346         noconfigdirs="$noconfigdirs ${libgcj}";;
2347     esac
2348
2349     # This section makes it possible to build newlib natively on linux.
2350     # If we are using a cross compiler then don't configure newlib.
2351     if test x${is_cross_compiler} != xno ; then
2352       noconfigdirs="$noconfigdirs target-newlib"
2353     fi
2354     noconfigdirs="$noconfigdirs target-libgloss"
2355     # If we are not using a cross compiler, do configure newlib.
2356     # Note however, that newlib will only be configured in this situation
2357     # if the --with-newlib option has been given, because otherwise
2358     # 'target-newlib' will appear in skipdirs.
2359     ;;
2360   i[3456789]86-*-mingw32*)
2361     target_configdirs="$target_configdirs target-winsup"
2362     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2363     ;;
2364   x86_64-*-mingw*)
2365     target_configdirs="$target_configdirs target-winsup"
2366     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2367     ;;
2368   *-*-cygwin*)
2369     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2370     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2371     # always build newlib if winsup directory is present.
2372     if test -d "$srcdir/winsup/cygwin"; then
2373       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2374     elif test -d "$srcdir/newlib"; then
2375       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2376     fi
2377     ;;
2378   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2379   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2380     ;;
2381   i[3456789]86-*-pe)
2382     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2383     ;;
2384   i[3456789]86-*-sco3.2v5*)
2385     # The linker does not yet know about weak symbols in COFF,
2386     # and is not configured to handle mixed ELF and COFF.
2387     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2388     ;;
2389   i[3456789]86-*-sco*)
2390     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2391     ;;
2392   i[3456789]86-*-solaris2*)
2393     noconfigdirs="$noconfigdirs target-libgloss"
2394     ;;
2395   i[3456789]86-*-sysv4*)
2396     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2397     ;;
2398   i[3456789]86-*-beos*)
2399     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2400     ;;
2401   i[3456789]86-*-rdos*)
2402     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2403     ;;
2404   m32r-*-*)
2405     noconfigdirs="$noconfigdirs ${libgcj}"
2406     ;;
2407   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2408     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2409     ;;
2410   m68k-*-elf*)
2411     noconfigdirs="$noconfigdirs ${libgcj}"
2412     ;;
2413   m68k-*-coff*)
2414     noconfigdirs="$noconfigdirs ${libgcj}"
2415     ;;
2416   mcore-*-pe*)
2417   # The EPOC C++ environment does not support exceptions or rtti,
2418   # and so building libstdc++-v3 tends not to always work.
2419     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2420     ;;
2421   mmix-*-*)
2422     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2423     unsupported_languages="$unsupported_languages fortran java"
2424     ;;
2425   mn10200-*-*)
2426     noconfigdirs="$noconfigdirs ${libgcj}"
2427     ;;
2428   mn10300-*-*)
2429     noconfigdirs="$noconfigdirs ${libgcj}"
2430     ;;
2431   mt-*-*)
2432     noconfigdirs="$noconfigdirs sim"
2433     ;;
2434   powerpc-*-aix*)
2435     # copied from rs6000-*-* entry
2436     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2437     ;;
2438   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2439     target_configdirs="$target_configdirs target-winsup"
2440     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2441     # always build newlib.
2442     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2443     ;;
2444     # This is temporary until we can link against shared libraries
2445   powerpcle-*-solaris*)
2446     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2447     ;;
2448   powerpc-*-beos*)
2449     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2450     ;;
2451   powerpc-*-eabi)
2452     noconfigdirs="$noconfigdirs ${libgcj}"
2453     ;;
2454   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2455     ;;
2456   rs6000-*-lynxos*)
2457     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2458     ;;
2459   rs6000-*-aix*)
2460     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2461     ;;
2462   rs6000-*-*)
2463     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2464     ;;
2465   m68k-apollo-*)
2466     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2467     ;;
2468   mips*-*-irix5*)
2469     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2470     ;;
2471   mips*-*-irix6*)
2472     # Linking libjava exceeds command-line length limits on at least
2473     # IRIX 6.2, but not on IRIX 6.5.
2474     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2475     # <oldham@codesourcery.com>
2476     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2477     ;;
2478   mips*-*-bsd*)
2479     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2480     ;;
2481   mips64*-*-linux*)
2482     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2483     ;;
2484   mips*-*-linux*)
2485     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2486     ;;
2487   mips*-*-*)
2488     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2489     ;;
2490   romp-*-*)
2491     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2492     ;;
2493   sh-*-* | sh64-*-*)
2494     case "${host}" in
2495       i[3456789]86-*-vsta) ;; # don't add gprof back in
2496       i[3456789]86-*-go32*) ;; # don't add gprof back in
2497       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2498       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2499     esac
2500     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2501     ;;
2502   sparc-*-elf*)
2503     noconfigdirs="$noconfigdirs ${libgcj}"
2504     ;;
2505   sparc64-*-elf*)
2506     noconfigdirs="$noconfigdirs ${libgcj}"
2507     ;;
2508   sparclite-*-*)
2509     noconfigdirs="$noconfigdirs ${libgcj}"
2510     ;;
2511   sparc-*-sunos4*)
2512     noconfigdirs="$noconfigdirs ${libgcj}"
2513     if test x${is_cross_compiler} != xno ; then
2514            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2515     else
2516            use_gnu_ld=no
2517     fi
2518     ;;
2519   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2520     noconfigdirs="$noconfigdirs ${libgcj}"
2521     ;;
2522   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2523     ;;
2524   spu-*-*)
2525     skipdirs="target-libssp"
2526     ;;
2527   v810-*-*)
2528     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2529     ;;
2530   v850-*-*)
2531     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2532     ;;
2533   v850e-*-*)
2534     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2535     ;;
2536   v850ea-*-*)
2537     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2538     ;;
2539   vax-*-vms)
2540     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2541     ;;
2542   vax-*-*)
2543     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2544     ;;
2545   xtensa-*-*)
2546     noconfigdirs="$noconfigdirs ${libgcj}"
2547     ;;
2548   ip2k-*-*)
2549     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2550     ;;
2551   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2552     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2553     ;;
2554   *-*-lynxos*)
2555     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2556     ;;
2557   *-*-*)
2558     noconfigdirs="$noconfigdirs ${libgcj}"
2559     ;;
2560 esac
2561
2562 # If we aren't building newlib, then don't build libgloss, since libgloss
2563 # depends upon some newlib header files.
2564 case "${noconfigdirs}" in
2565   *target-libgloss*) ;;
2566   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2567 esac
2568
2569 # Work in distributions that contain no compiler tools, like Autoconf.
2570 tentative_cc=""
2571 host_makefile_frag=/dev/null
2572 if test -d ${srcdir}/config ; then
2573 case "${host}" in
2574   m68k-hp-hpux*)
2575     # Avoid "too much defining" errors from HPUX compiler.
2576     tentative_cc="cc -Wp,-H256000"
2577     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2578     # If it's HP/UX ar, this should be harmless.
2579     RANLIB="ar ts"
2580     ;;
2581   m68k-apollo-sysv*)
2582     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2583     ;;
2584   m68k-apollo-bsd*)
2585     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2586     # chokes on bfd, the compiler won't let you assign integers to enums, and
2587     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2588     # the apollo compiler" (the preferred version of GCC could be called cc,
2589     # or whatever), but I'm not sure leaving CC as cc is any better...
2590     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2591     # Used to have BISON=yacc.
2592     tentative_cc=gcc
2593     ;;
2594   m88k-dg-dgux*)
2595     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2596     ;;
2597   m88k-harris-cxux*)
2598     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2599     tentative_cc="cc -Xa"
2600     host_makefile_frag="config/mh-cxux"
2601     ;;
2602   m88k-motorola-sysv*)
2603     ;;
2604   mips*-dec-ultrix*)
2605     tentative_cc="cc -Wf,-XNg1000"
2606     host_makefile_frag="config/mh-decstation"
2607     ;;
2608   mips*-nec-sysv4*)
2609     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2610     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2611     host_makefile_frag="config/mh-necv4"
2612     ;;
2613   mips*-sgi-irix4*)
2614     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2615     # environment.  Also bump switch table size so that cp-parse will
2616     # compile.  Bump string length limit so linker builds.
2617     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2618     ;;
2619   mips*-*-sysv4*)
2620     host_makefile_frag="config/mh-sysv4"
2621     ;;
2622   mips*-*-sysv*)
2623     # This is for a MIPS running RISC/os 4.52C.
2624
2625     # This is needed for GDB, but needs to be in the top-level make because
2626     # if a library is compiled with the bsd headers and gets linked with the
2627     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2628     # a different size).
2629     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2630     # known except to select the sysv environment.  Could we use /proc instead?
2631     # These "sysv environments" and "bsd environments" often end up being a pain.
2632     #
2633     # This is not part of CFLAGS because perhaps not all C compilers have this
2634     # option.
2635     tentative_cc="cc -systype sysv"
2636     ;;
2637   i370-ibm-opened*)
2638     tentative_cc="c89"
2639     ;;
2640   i[3456789]86-*-sysv5*)
2641     host_makefile_frag="config/mh-sysv5"
2642     ;;
2643   i[3456789]86-*-dgux*)
2644     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2645     host_makefile_frag="config/mh-dgux386"
2646     ;;
2647   i[3456789]86-ncr-sysv4.3*)
2648     # The MetaWare compiler will generate a copyright message unless you
2649     # turn it off by adding the -Hnocopyr flag.
2650     tentative_cc="cc -Hnocopyr"
2651     ;;
2652   i[3456789]86-ncr-sysv4*)
2653     # for an NCR 3000 (i486/SVR4) system.
2654     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2655     # This compiler not only emits obnoxious copyright messages every time
2656     # you run it, but it chokes and dies on a whole bunch of GNU source
2657     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2658     tentative_cc="/usr/ccs/ATT/cc"
2659     host_makefile_frag="config/mh-ncr3000"
2660     ;;
2661   i[3456789]86-*-sco3.2v5*)
2662     ;;
2663   i[3456789]86-*-sco*)
2664     # The native C compiler botches some simple uses of const.  Unfortunately,
2665     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2666     tentative_cc="cc -Dconst="
2667     host_makefile_frag="config/mh-sco"
2668     ;;
2669   i[3456789]86-*-udk*)
2670     host_makefile_frag="config/mh-sysv5"
2671     ;;
2672   i[3456789]86-*-solaris2*)
2673     host_makefile_frag="config/mh-sysv4"
2674     ;;
2675   i[3456789]86-*-msdosdjgpp*)
2676     host_makefile_frag="config/mh-djgpp"
2677     ;;
2678   *-cygwin*)
2679     host_makefile_frag="config/mh-cygwin"
2680     ;;
2681   *-mingw32*)
2682     ;;
2683   *-mingw64*)
2684     ;;
2685   *-interix*)
2686     host_makefile_frag="config/mh-interix"
2687     ;;
2688   vax-*-ultrix2*)
2689     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2690     tentative_cc=gcc
2691     ;;
2692   *-*-solaris2*)
2693     host_makefile_frag="config/mh-solaris"
2694     ;;
2695   m68k-sun-sunos*)
2696     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2697     # without overflowing the jump tables (-J says to use a 32 bit table)
2698     tentative_cc="cc -J"
2699     ;;
2700   *-hp-hpux*)
2701     tentative_cc="cc -Wp,-H256000"
2702     ;;
2703   *-*-hiux*)
2704     tentative_cc="cc -Wp,-H256000"
2705     ;;
2706   rs6000-*-lynxos*)
2707     # /bin/cc is less than useful for our purposes.  Always use GCC
2708     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2709     host_makefile_frag="config/mh-lynxrs6k"
2710     ;;
2711   powerpc-*-darwin*)
2712     host_makefile_frag="config/mh-ppc-darwin"
2713     ;;
2714   powerpc-*-aix*)
2715     host_makefile_frag="config/mh-ppc-aix"
2716     ;;
2717   rs6000-*-aix*)
2718     host_makefile_frag="config/mh-ppc-aix"
2719     ;;
2720   *-*-lynxos*)
2721     # /bin/cc is less than useful for our purposes.  Always use GCC
2722     tentative_cc="/bin/gcc"
2723     ;;
2724   *-*-sysv4*)
2725     host_makefile_frag="config/mh-sysv4"
2726     ;;
2727   # This is placed last to prevent interfering with the cases above.
2728   i[3456789]86-*-*)
2729     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2730     host_makefile_frag="config/mh-x86omitfp"
2731     ;;
2732 esac
2733 fi
2734
2735 # If we aren't going to be using gcc, see if we can extract a definition
2736 # of CC from the fragment.
2737 # Actually, use the 'pre-extracted' version above.
2738 if test -z "${CC}" && test "${build}" = "${host}" ; then
2739   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2740   found=
2741   for dir in $PATH; do
2742     test -z "$dir" && dir=.
2743     if test -f $dir/gcc; then
2744       found=yes
2745       break
2746     fi
2747   done
2748   IFS="$save_ifs"
2749   if test -z "${found}" && test -n "${tentative_cc}" ; then
2750     CC=$tentative_cc
2751   fi
2752 fi
2753
2754 if test "${build}" != "${host}" ; then
2755   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2756 else
2757   CC_FOR_BUILD="\$(CC)"
2758 fi
2759
2760 ac_ext=c
2761 ac_cpp='$CPP $CPPFLAGS'
2762 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2763 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2764 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2765 if test -n "$ac_tool_prefix"; then
2766   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2767 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2768 echo "$as_me:$LINENO: checking for $ac_word" >&5
2769 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2770 if test "${ac_cv_prog_CC+set}" = set; then
2771   echo $ECHO_N "(cached) $ECHO_C" >&6
2772 else
2773   if test -n "$CC"; then
2774   ac_cv_prog_CC="$CC" # Let the user override the test.
2775 else
2776 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2777 for as_dir in $PATH
2778 do
2779   IFS=$as_save_IFS
2780   test -z "$as_dir" && as_dir=.
2781   for ac_exec_ext in '' $ac_executable_extensions; do
2782   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2783     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2784     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2785     break 2
2786   fi
2787 done
2788 done
2789
2790 fi
2791 fi
2792 CC=$ac_cv_prog_CC
2793 if test -n "$CC"; then
2794   echo "$as_me:$LINENO: result: $CC" >&5
2795 echo "${ECHO_T}$CC" >&6
2796 else
2797   echo "$as_me:$LINENO: result: no" >&5
2798 echo "${ECHO_T}no" >&6
2799 fi
2800
2801 fi
2802 if test -z "$ac_cv_prog_CC"; then
2803   ac_ct_CC=$CC
2804   # Extract the first word of "gcc", so it can be a program name with args.
2805 set dummy gcc; ac_word=$2
2806 echo "$as_me:$LINENO: checking for $ac_word" >&5
2807 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2808 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2809   echo $ECHO_N "(cached) $ECHO_C" >&6
2810 else
2811   if test -n "$ac_ct_CC"; then
2812   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2813 else
2814 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2815 for as_dir in $PATH
2816 do
2817   IFS=$as_save_IFS
2818   test -z "$as_dir" && as_dir=.
2819   for ac_exec_ext in '' $ac_executable_extensions; do
2820   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2821     ac_cv_prog_ac_ct_CC="gcc"
2822     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2823     break 2
2824   fi
2825 done
2826 done
2827
2828 fi
2829 fi
2830 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2831 if test -n "$ac_ct_CC"; then
2832   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2833 echo "${ECHO_T}$ac_ct_CC" >&6
2834 else
2835   echo "$as_me:$LINENO: result: no" >&5
2836 echo "${ECHO_T}no" >&6
2837 fi
2838
2839   CC=$ac_ct_CC
2840 else
2841   CC="$ac_cv_prog_CC"
2842 fi
2843
2844 if test -z "$CC"; then
2845   if test -n "$ac_tool_prefix"; then
2846   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2847 set dummy ${ac_tool_prefix}cc; ac_word=$2
2848 echo "$as_me:$LINENO: checking for $ac_word" >&5
2849 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2850 if test "${ac_cv_prog_CC+set}" = set; then
2851   echo $ECHO_N "(cached) $ECHO_C" >&6
2852 else
2853   if test -n "$CC"; then
2854   ac_cv_prog_CC="$CC" # Let the user override the test.
2855 else
2856 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2857 for as_dir in $PATH
2858 do
2859   IFS=$as_save_IFS
2860   test -z "$as_dir" && as_dir=.
2861   for ac_exec_ext in '' $ac_executable_extensions; do
2862   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2863     ac_cv_prog_CC="${ac_tool_prefix}cc"
2864     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2865     break 2
2866   fi
2867 done
2868 done
2869
2870 fi
2871 fi
2872 CC=$ac_cv_prog_CC
2873 if test -n "$CC"; then
2874   echo "$as_me:$LINENO: result: $CC" >&5
2875 echo "${ECHO_T}$CC" >&6
2876 else
2877   echo "$as_me:$LINENO: result: no" >&5
2878 echo "${ECHO_T}no" >&6
2879 fi
2880
2881 fi
2882 if test -z "$ac_cv_prog_CC"; then
2883   ac_ct_CC=$CC
2884   # Extract the first word of "cc", so it can be a program name with args.
2885 set dummy cc; ac_word=$2
2886 echo "$as_me:$LINENO: checking for $ac_word" >&5
2887 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2888 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2889   echo $ECHO_N "(cached) $ECHO_C" >&6
2890 else
2891   if test -n "$ac_ct_CC"; then
2892   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2893 else
2894 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2895 for as_dir in $PATH
2896 do
2897   IFS=$as_save_IFS
2898   test -z "$as_dir" && as_dir=.
2899   for ac_exec_ext in '' $ac_executable_extensions; do
2900   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2901     ac_cv_prog_ac_ct_CC="cc"
2902     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2903     break 2
2904   fi
2905 done
2906 done
2907
2908 fi
2909 fi
2910 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2911 if test -n "$ac_ct_CC"; then
2912   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2913 echo "${ECHO_T}$ac_ct_CC" >&6
2914 else
2915   echo "$as_me:$LINENO: result: no" >&5
2916 echo "${ECHO_T}no" >&6
2917 fi
2918
2919   CC=$ac_ct_CC
2920 else
2921   CC="$ac_cv_prog_CC"
2922 fi
2923
2924 fi
2925 if test -z "$CC"; then
2926   # Extract the first word of "cc", so it can be a program name with args.
2927 set dummy cc; ac_word=$2
2928 echo "$as_me:$LINENO: checking for $ac_word" >&5
2929 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2930 if test "${ac_cv_prog_CC+set}" = set; then
2931   echo $ECHO_N "(cached) $ECHO_C" >&6
2932 else
2933   if test -n "$CC"; then
2934   ac_cv_prog_CC="$CC" # Let the user override the test.
2935 else
2936   ac_prog_rejected=no
2937 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2938 for as_dir in $PATH
2939 do
2940   IFS=$as_save_IFS
2941   test -z "$as_dir" && as_dir=.
2942   for ac_exec_ext in '' $ac_executable_extensions; do
2943   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2944     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2945        ac_prog_rejected=yes
2946        continue
2947      fi
2948     ac_cv_prog_CC="cc"
2949     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2950     break 2
2951   fi
2952 done
2953 done
2954
2955 if test $ac_prog_rejected = yes; then
2956   # We found a bogon in the path, so make sure we never use it.
2957   set dummy $ac_cv_prog_CC
2958   shift
2959   if test $# != 0; then
2960     # We chose a different compiler from the bogus one.
2961     # However, it has the same basename, so the bogon will be chosen
2962     # first if we set CC to just the basename; use the full file name.
2963     shift
2964     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
2965   fi
2966 fi
2967 fi
2968 fi
2969 CC=$ac_cv_prog_CC
2970 if test -n "$CC"; then
2971   echo "$as_me:$LINENO: result: $CC" >&5
2972 echo "${ECHO_T}$CC" >&6
2973 else
2974   echo "$as_me:$LINENO: result: no" >&5
2975 echo "${ECHO_T}no" >&6
2976 fi
2977
2978 fi
2979 if test -z "$CC"; then
2980   if test -n "$ac_tool_prefix"; then
2981   for ac_prog in cl
2982   do
2983     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2984 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2985 echo "$as_me:$LINENO: checking for $ac_word" >&5
2986 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2987 if test "${ac_cv_prog_CC+set}" = set; then
2988   echo $ECHO_N "(cached) $ECHO_C" >&6
2989 else
2990   if test -n "$CC"; then
2991   ac_cv_prog_CC="$CC" # Let the user override the test.
2992 else
2993 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2994 for as_dir in $PATH
2995 do
2996   IFS=$as_save_IFS
2997   test -z "$as_dir" && as_dir=.
2998   for ac_exec_ext in '' $ac_executable_extensions; do
2999   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3000     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3001     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3002     break 2
3003   fi
3004 done
3005 done
3006
3007 fi
3008 fi
3009 CC=$ac_cv_prog_CC
3010 if test -n "$CC"; then
3011   echo "$as_me:$LINENO: result: $CC" >&5
3012 echo "${ECHO_T}$CC" >&6
3013 else
3014   echo "$as_me:$LINENO: result: no" >&5
3015 echo "${ECHO_T}no" >&6
3016 fi
3017
3018     test -n "$CC" && break
3019   done
3020 fi
3021 if test -z "$CC"; then
3022   ac_ct_CC=$CC
3023   for ac_prog in cl
3024 do
3025   # Extract the first word of "$ac_prog", so it can be a program name with args.
3026 set dummy $ac_prog; ac_word=$2
3027 echo "$as_me:$LINENO: checking for $ac_word" >&5
3028 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3029 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3030   echo $ECHO_N "(cached) $ECHO_C" >&6
3031 else
3032   if test -n "$ac_ct_CC"; then
3033   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3034 else
3035 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3036 for as_dir in $PATH
3037 do
3038   IFS=$as_save_IFS
3039   test -z "$as_dir" && as_dir=.
3040   for ac_exec_ext in '' $ac_executable_extensions; do
3041   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3042     ac_cv_prog_ac_ct_CC="$ac_prog"
3043     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3044     break 2
3045   fi
3046 done
3047 done
3048
3049 fi
3050 fi
3051 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3052 if test -n "$ac_ct_CC"; then
3053   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3054 echo "${ECHO_T}$ac_ct_CC" >&6
3055 else
3056   echo "$as_me:$LINENO: result: no" >&5
3057 echo "${ECHO_T}no" >&6
3058 fi
3059
3060   test -n "$ac_ct_CC" && break
3061 done
3062
3063   CC=$ac_ct_CC
3064 fi
3065
3066 fi
3067
3068
3069 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3070 See \`config.log' for more details." >&5
3071 echo "$as_me: error: no acceptable C compiler found in \$PATH
3072 See \`config.log' for more details." >&2;}
3073    { (exit 1); exit 1; }; }
3074
3075 # Provide some information about the compiler.
3076 echo "$as_me:$LINENO:" \
3077      "checking for C compiler version" >&5
3078 ac_compiler=`set X $ac_compile; echo $2`
3079 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3080   (eval $ac_compiler --version </dev/null >&5) 2>&5
3081   ac_status=$?
3082   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3083   (exit $ac_status); }
3084 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3085   (eval $ac_compiler -v </dev/null >&5) 2>&5
3086   ac_status=$?
3087   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3088   (exit $ac_status); }
3089 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3090   (eval $ac_compiler -V </dev/null >&5) 2>&5
3091   ac_status=$?
3092   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3093   (exit $ac_status); }
3094
3095 cat >conftest.$ac_ext <<_ACEOF
3096 /* confdefs.h.  */
3097 _ACEOF
3098 cat confdefs.h >>conftest.$ac_ext
3099 cat >>conftest.$ac_ext <<_ACEOF
3100 /* end confdefs.h.  */
3101
3102 int
3103 main ()
3104 {
3105
3106   ;
3107   return 0;
3108 }
3109 _ACEOF
3110 ac_clean_files_save=$ac_clean_files
3111 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3112 # Try to create an executable without -o first, disregard a.out.
3113 # It will help us diagnose broken compilers, and finding out an intuition
3114 # of exeext.
3115 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3116 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3117 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3118 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3119   (eval $ac_link_default) 2>&5
3120   ac_status=$?
3121   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3122   (exit $ac_status); }; then
3123   # Find the output, starting from the most likely.  This scheme is
3124 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3125 # resort.
3126
3127 # Be careful to initialize this variable, since it used to be cached.
3128 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3129 ac_cv_exeext=
3130 # b.out is created by i960 compilers.
3131 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3132 do
3133   test -f "$ac_file" || continue
3134   case $ac_file in
3135     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3136         ;;
3137     conftest.$ac_ext )
3138         # This is the source file.
3139         ;;
3140     [ab].out )
3141         # We found the default executable, but exeext='' is most
3142         # certainly right.
3143         break;;
3144     *.* )
3145         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3146         # FIXME: I believe we export ac_cv_exeext for Libtool,
3147         # but it would be cool to find out if it's true.  Does anybody
3148         # maintain Libtool? --akim.
3149         export ac_cv_exeext
3150         break;;
3151     * )
3152         break;;
3153   esac
3154 done
3155 else
3156   echo "$as_me: failed program was:" >&5
3157 sed 's/^/| /' conftest.$ac_ext >&5
3158
3159 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3160 See \`config.log' for more details." >&5
3161 echo "$as_me: error: C compiler cannot create executables
3162 See \`config.log' for more details." >&2;}
3163    { (exit 77); exit 77; }; }
3164 fi
3165
3166 ac_exeext=$ac_cv_exeext
3167 echo "$as_me:$LINENO: result: $ac_file" >&5
3168 echo "${ECHO_T}$ac_file" >&6
3169
3170 # Check the compiler produces executables we can run.  If not, either
3171 # the compiler is broken, or we cross compile.
3172 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3173 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3174 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3175 # If not cross compiling, check that we can run a simple program.
3176 if test "$cross_compiling" != yes; then
3177   if { ac_try='./$ac_file'
3178   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3179   (eval $ac_try) 2>&5
3180   ac_status=$?
3181   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3182   (exit $ac_status); }; }; then
3183     cross_compiling=no
3184   else
3185     if test "$cross_compiling" = maybe; then
3186         cross_compiling=yes
3187     else
3188         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3189 If you meant to cross compile, use \`--host'.
3190 See \`config.log' for more details." >&5
3191 echo "$as_me: error: cannot run C compiled programs.
3192 If you meant to cross compile, use \`--host'.
3193 See \`config.log' for more details." >&2;}
3194    { (exit 1); exit 1; }; }
3195     fi
3196   fi
3197 fi
3198 echo "$as_me:$LINENO: result: yes" >&5
3199 echo "${ECHO_T}yes" >&6
3200
3201 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3202 ac_clean_files=$ac_clean_files_save
3203 # Check the compiler produces executables we can run.  If not, either
3204 # the compiler is broken, or we cross compile.
3205 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3206 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3207 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3208 echo "${ECHO_T}$cross_compiling" >&6
3209
3210 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3211 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3212 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3213   (eval $ac_link) 2>&5
3214   ac_status=$?
3215   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3216   (exit $ac_status); }; then
3217   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3218 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3219 # work properly (i.e., refer to `conftest.exe'), while it won't with
3220 # `rm'.
3221 for ac_file in conftest.exe conftest conftest.*; do
3222   test -f "$ac_file" || continue
3223   case $ac_file in
3224     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3225     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3226           export ac_cv_exeext
3227           break;;
3228     * ) break;;
3229   esac
3230 done
3231 else
3232   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3233 See \`config.log' for more details." >&5
3234 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3235 See \`config.log' for more details." >&2;}
3236    { (exit 1); exit 1; }; }
3237 fi
3238
3239 rm -f conftest$ac_cv_exeext
3240 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3241 echo "${ECHO_T}$ac_cv_exeext" >&6
3242
3243 rm -f conftest.$ac_ext
3244 EXEEXT=$ac_cv_exeext
3245 ac_exeext=$EXEEXT
3246 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3247 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3248 if test "${ac_cv_objext+set}" = set; then
3249   echo $ECHO_N "(cached) $ECHO_C" >&6
3250 else
3251   cat >conftest.$ac_ext <<_ACEOF
3252 /* confdefs.h.  */
3253 _ACEOF
3254 cat confdefs.h >>conftest.$ac_ext
3255 cat >>conftest.$ac_ext <<_ACEOF
3256 /* end confdefs.h.  */
3257
3258 int
3259 main ()
3260 {
3261
3262   ;
3263   return 0;
3264 }
3265 _ACEOF
3266 rm -f conftest.o conftest.obj
3267 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3268   (eval $ac_compile) 2>&5
3269   ac_status=$?
3270   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3271   (exit $ac_status); }; then
3272   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3273   case $ac_file in
3274     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3275     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3276        break;;
3277   esac
3278 done
3279 else
3280   echo "$as_me: failed program was:" >&5
3281 sed 's/^/| /' conftest.$ac_ext >&5
3282
3283 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3284 See \`config.log' for more details." >&5
3285 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3286 See \`config.log' for more details." >&2;}
3287    { (exit 1); exit 1; }; }
3288 fi
3289
3290 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3291 fi
3292 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3293 echo "${ECHO_T}$ac_cv_objext" >&6
3294 OBJEXT=$ac_cv_objext
3295 ac_objext=$OBJEXT
3296 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3297 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3298 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3299   echo $ECHO_N "(cached) $ECHO_C" >&6
3300 else
3301   cat >conftest.$ac_ext <<_ACEOF
3302 /* confdefs.h.  */
3303 _ACEOF
3304 cat confdefs.h >>conftest.$ac_ext
3305 cat >>conftest.$ac_ext <<_ACEOF
3306 /* end confdefs.h.  */
3307
3308 int
3309 main ()
3310 {
3311 #ifndef __GNUC__
3312        choke me
3313 #endif
3314
3315   ;
3316   return 0;
3317 }
3318 _ACEOF
3319 rm -f conftest.$ac_objext
3320 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3321   (eval $ac_compile) 2>conftest.er1
3322   ac_status=$?
3323   grep -v '^ *+' conftest.er1 >conftest.err
3324   rm -f conftest.er1
3325   cat conftest.err >&5
3326   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3327   (exit $ac_status); } &&
3328          { ac_try='test -z "$ac_c_werror_flag"
3329                          || test ! -s conftest.err'
3330   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3331   (eval $ac_try) 2>&5
3332   ac_status=$?
3333   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3334   (exit $ac_status); }; } &&
3335          { ac_try='test -s conftest.$ac_objext'
3336   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3337   (eval $ac_try) 2>&5
3338   ac_status=$?
3339   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3340   (exit $ac_status); }; }; then
3341   ac_compiler_gnu=yes
3342 else
3343   echo "$as_me: failed program was:" >&5
3344 sed 's/^/| /' conftest.$ac_ext >&5
3345
3346 ac_compiler_gnu=no
3347 fi
3348 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3349 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3350
3351 fi
3352 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3353 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3354 GCC=`test $ac_compiler_gnu = yes && echo yes`
3355 ac_test_CFLAGS=${CFLAGS+set}
3356 ac_save_CFLAGS=$CFLAGS
3357 CFLAGS="-g"
3358 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3359 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3360 if test "${ac_cv_prog_cc_g+set}" = set; then
3361   echo $ECHO_N "(cached) $ECHO_C" >&6
3362 else
3363   cat >conftest.$ac_ext <<_ACEOF
3364 /* confdefs.h.  */
3365 _ACEOF
3366 cat confdefs.h >>conftest.$ac_ext
3367 cat >>conftest.$ac_ext <<_ACEOF
3368 /* end confdefs.h.  */
3369
3370 int
3371 main ()
3372 {
3373
3374   ;
3375   return 0;
3376 }
3377 _ACEOF
3378 rm -f conftest.$ac_objext
3379 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3380   (eval $ac_compile) 2>conftest.er1
3381   ac_status=$?
3382   grep -v '^ *+' conftest.er1 >conftest.err
3383   rm -f conftest.er1
3384   cat conftest.err >&5
3385   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3386   (exit $ac_status); } &&
3387          { ac_try='test -z "$ac_c_werror_flag"
3388                          || test ! -s conftest.err'
3389   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3390   (eval $ac_try) 2>&5
3391   ac_status=$?
3392   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3393   (exit $ac_status); }; } &&
3394          { ac_try='test -s conftest.$ac_objext'
3395   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3396   (eval $ac_try) 2>&5
3397   ac_status=$?
3398   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3399   (exit $ac_status); }; }; then
3400   ac_cv_prog_cc_g=yes
3401 else
3402   echo "$as_me: failed program was:" >&5
3403 sed 's/^/| /' conftest.$ac_ext >&5
3404
3405 ac_cv_prog_cc_g=no
3406 fi
3407 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3408 fi
3409 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3410 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3411 if test "$ac_test_CFLAGS" = set; then
3412   CFLAGS=$ac_save_CFLAGS
3413 elif test $ac_cv_prog_cc_g = yes; then
3414   if test "$GCC" = yes; then
3415     CFLAGS="-g -O2"
3416   else
3417     CFLAGS="-g"
3418   fi
3419 else
3420   if test "$GCC" = yes; then
3421     CFLAGS="-O2"
3422   else
3423     CFLAGS=
3424   fi
3425 fi
3426 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3427 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3428 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3429   echo $ECHO_N "(cached) $ECHO_C" >&6
3430 else
3431   ac_cv_prog_cc_stdc=no
3432 ac_save_CC=$CC
3433 cat >conftest.$ac_ext <<_ACEOF
3434 /* confdefs.h.  */
3435 _ACEOF
3436 cat confdefs.h >>conftest.$ac_ext
3437 cat >>conftest.$ac_ext <<_ACEOF
3438 /* end confdefs.h.  */
3439 #include <stdarg.h>
3440 #include <stdio.h>
3441 #include <sys/types.h>
3442 #include <sys/stat.h>
3443 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3444 struct buf { int x; };
3445 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3446 static char *e (p, i)
3447      char **p;
3448      int i;
3449 {
3450   return p[i];
3451 }
3452 static char *f (char * (*g) (char **, int), char **p, ...)
3453 {
3454   char *s;
3455   va_list v;
3456   va_start (v,p);
3457   s = g (p, va_arg (v,int));
3458   va_end (v);
3459   return s;
3460 }
3461
3462 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3463    function prototypes and stuff, but not '\xHH' hex character constants.
3464    These don't provoke an error unfortunately, instead are silently treated
3465    as 'x'.  The following induces an error, until -std1 is added to get
3466    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3467    array size at least.  It's necessary to write '\x00'==0 to get something
3468    that's true only with -std1.  */
3469 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3470
3471 int test (int i, double x);
3472 struct s1 {int (*f) (int a);};
3473 struct s2 {int (*f) (double a);};
3474 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3475 int argc;
3476 char **argv;
3477 int
3478 main ()
3479 {
3480 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3481   ;
3482   return 0;
3483 }
3484 _ACEOF
3485 # Don't try gcc -ansi; that turns off useful extensions and
3486 # breaks some systems' header files.
3487 # AIX                   -qlanglvl=ansi
3488 # Ultrix and OSF/1      -std1
3489 # HP-UX 10.20 and later -Ae
3490 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3491 # SVR4                  -Xc -D__EXTENSIONS__
3492 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3493 do
3494   CC="$ac_save_CC $ac_arg"
3495   rm -f conftest.$ac_objext
3496 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3497   (eval $ac_compile) 2>conftest.er1
3498   ac_status=$?
3499   grep -v '^ *+' conftest.er1 >conftest.err
3500   rm -f conftest.er1
3501   cat conftest.err >&5
3502   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3503   (exit $ac_status); } &&
3504          { ac_try='test -z "$ac_c_werror_flag"
3505                          || test ! -s conftest.err'
3506   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3507   (eval $ac_try) 2>&5
3508   ac_status=$?
3509   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3510   (exit $ac_status); }; } &&
3511          { ac_try='test -s conftest.$ac_objext'
3512   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3513   (eval $ac_try) 2>&5
3514   ac_status=$?
3515   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3516   (exit $ac_status); }; }; then
3517   ac_cv_prog_cc_stdc=$ac_arg
3518 break
3519 else
3520   echo "$as_me: failed program was:" >&5
3521 sed 's/^/| /' conftest.$ac_ext >&5
3522
3523 fi
3524 rm -f conftest.err conftest.$ac_objext
3525 done
3526 rm -f conftest.$ac_ext conftest.$ac_objext
3527 CC=$ac_save_CC
3528
3529 fi
3530
3531 case "x$ac_cv_prog_cc_stdc" in
3532   x|xno)
3533     echo "$as_me:$LINENO: result: none needed" >&5
3534 echo "${ECHO_T}none needed" >&6 ;;
3535   *)
3536     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3537 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3538     CC="$CC $ac_cv_prog_cc_stdc" ;;
3539 esac
3540
3541 # Some people use a C++ compiler to compile C.  Since we use `exit',
3542 # in C++ we need to declare it.  In case someone uses the same compiler
3543 # for both compiling C and C++ we need to have the C++ compiler decide
3544 # the declaration of exit, since it's the most demanding environment.
3545 cat >conftest.$ac_ext <<_ACEOF
3546 #ifndef __cplusplus
3547   choke me
3548 #endif
3549 _ACEOF
3550 rm -f conftest.$ac_objext
3551 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3552   (eval $ac_compile) 2>conftest.er1
3553   ac_status=$?
3554   grep -v '^ *+' conftest.er1 >conftest.err
3555   rm -f conftest.er1
3556   cat conftest.err >&5
3557   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3558   (exit $ac_status); } &&
3559          { ac_try='test -z "$ac_c_werror_flag"
3560                          || test ! -s conftest.err'
3561   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3562   (eval $ac_try) 2>&5
3563   ac_status=$?
3564   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3565   (exit $ac_status); }; } &&
3566          { ac_try='test -s conftest.$ac_objext'
3567   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3568   (eval $ac_try) 2>&5
3569   ac_status=$?
3570   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3571   (exit $ac_status); }; }; then
3572   for ac_declaration in \
3573    '' \
3574    'extern "C" void std::exit (int) throw (); using std::exit;' \
3575    'extern "C" void std::exit (int); using std::exit;' \
3576    'extern "C" void exit (int) throw ();' \
3577    'extern "C" void exit (int);' \
3578    'void exit (int);'
3579 do
3580   cat >conftest.$ac_ext <<_ACEOF
3581 /* confdefs.h.  */
3582 _ACEOF
3583 cat confdefs.h >>conftest.$ac_ext
3584 cat >>conftest.$ac_ext <<_ACEOF
3585 /* end confdefs.h.  */
3586 $ac_declaration
3587 #include <stdlib.h>
3588 int
3589 main ()
3590 {
3591 exit (42);
3592   ;
3593   return 0;
3594 }
3595 _ACEOF
3596 rm -f conftest.$ac_objext
3597 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3598   (eval $ac_compile) 2>conftest.er1
3599   ac_status=$?
3600   grep -v '^ *+' conftest.er1 >conftest.err
3601   rm -f conftest.er1
3602   cat conftest.err >&5
3603   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3604   (exit $ac_status); } &&
3605          { ac_try='test -z "$ac_c_werror_flag"
3606                          || test ! -s conftest.err'
3607   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3608   (eval $ac_try) 2>&5
3609   ac_status=$?
3610   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3611   (exit $ac_status); }; } &&
3612          { ac_try='test -s conftest.$ac_objext'
3613   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3614   (eval $ac_try) 2>&5
3615   ac_status=$?
3616   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3617   (exit $ac_status); }; }; then
3618   :
3619 else
3620   echo "$as_me: failed program was:" >&5
3621 sed 's/^/| /' conftest.$ac_ext >&5
3622
3623 continue
3624 fi
3625 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3626   cat >conftest.$ac_ext <<_ACEOF
3627 /* confdefs.h.  */
3628 _ACEOF
3629 cat confdefs.h >>conftest.$ac_ext
3630 cat >>conftest.$ac_ext <<_ACEOF
3631 /* end confdefs.h.  */
3632 $ac_declaration
3633 int
3634 main ()
3635 {
3636 exit (42);
3637   ;
3638   return 0;
3639 }
3640 _ACEOF
3641 rm -f conftest.$ac_objext
3642 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3643   (eval $ac_compile) 2>conftest.er1
3644   ac_status=$?
3645   grep -v '^ *+' conftest.er1 >conftest.err
3646   rm -f conftest.er1
3647   cat conftest.err >&5
3648   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3649   (exit $ac_status); } &&
3650          { ac_try='test -z "$ac_c_werror_flag"
3651                          || test ! -s conftest.err'
3652   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3653   (eval $ac_try) 2>&5
3654   ac_status=$?
3655   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3656   (exit $ac_status); }; } &&
3657          { ac_try='test -s conftest.$ac_objext'
3658   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3659   (eval $ac_try) 2>&5
3660   ac_status=$?
3661   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3662   (exit $ac_status); }; }; then
3663   break
3664 else
3665   echo "$as_me: failed program was:" >&5
3666 sed 's/^/| /' conftest.$ac_ext >&5
3667
3668 fi
3669 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3670 done
3671 rm -f conftest*
3672 if test -n "$ac_declaration"; then
3673   echo '#ifdef __cplusplus' >>confdefs.h
3674   echo $ac_declaration      >>confdefs.h
3675   echo '#endif'             >>confdefs.h
3676 fi
3677
3678 else
3679   echo "$as_me: failed program was:" >&5
3680 sed 's/^/| /' conftest.$ac_ext >&5
3681
3682 fi
3683 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3684 ac_ext=c
3685 ac_cpp='$CPP $CPPFLAGS'
3686 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3687 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3688 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3689
3690 ac_ext=cc
3691 ac_cpp='$CXXCPP $CPPFLAGS'
3692 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3693 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3694 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3695 if test -n "$ac_tool_prefix"; then
3696   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3697   do
3698     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3699 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3700 echo "$as_me:$LINENO: checking for $ac_word" >&5
3701 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3702 if test "${ac_cv_prog_CXX+set}" = set; then
3703   echo $ECHO_N "(cached) $ECHO_C" >&6
3704 else
3705   if test -n "$CXX"; then
3706   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3707 else
3708 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3709 for as_dir in $PATH
3710 do
3711   IFS=$as_save_IFS
3712   test -z "$as_dir" && as_dir=.
3713   for ac_exec_ext in '' $ac_executable_extensions; do
3714   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3715     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3716     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3717     break 2
3718   fi
3719 done
3720 done
3721
3722 fi
3723 fi
3724 CXX=$ac_cv_prog_CXX
3725 if test -n "$CXX"; then
3726   echo "$as_me:$LINENO: result: $CXX" >&5
3727 echo "${ECHO_T}$CXX" >&6
3728 else
3729   echo "$as_me:$LINENO: result: no" >&5
3730 echo "${ECHO_T}no" >&6
3731 fi
3732
3733     test -n "$CXX" && break
3734   done
3735 fi
3736 if test -z "$CXX"; then
3737   ac_ct_CXX=$CXX
3738   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3739 do
3740   # Extract the first word of "$ac_prog", so it can be a program name with args.
3741 set dummy $ac_prog; ac_word=$2
3742 echo "$as_me:$LINENO: checking for $ac_word" >&5
3743 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3744 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3745   echo $ECHO_N "(cached) $ECHO_C" >&6
3746 else
3747   if test -n "$ac_ct_CXX"; then
3748   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3749 else
3750 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3751 for as_dir in $PATH
3752 do
3753   IFS=$as_save_IFS
3754   test -z "$as_dir" && as_dir=.
3755   for ac_exec_ext in '' $ac_executable_extensions; do
3756   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3757     ac_cv_prog_ac_ct_CXX="$ac_prog"
3758     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3759     break 2
3760   fi
3761 done
3762 done
3763
3764 fi
3765 fi
3766 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3767 if test -n "$ac_ct_CXX"; then
3768   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3769 echo "${ECHO_T}$ac_ct_CXX" >&6
3770 else
3771   echo "$as_me:$LINENO: result: no" >&5
3772 echo "${ECHO_T}no" >&6
3773 fi
3774
3775   test -n "$ac_ct_CXX" && break
3776 done
3777 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3778
3779   CXX=$ac_ct_CXX
3780 fi
3781
3782
3783 # Provide some information about the compiler.
3784 echo "$as_me:$LINENO:" \
3785      "checking for C++ compiler version" >&5
3786 ac_compiler=`set X $ac_compile; echo $2`
3787 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3788   (eval $ac_compiler --version </dev/null >&5) 2>&5
3789   ac_status=$?
3790   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3791   (exit $ac_status); }
3792 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3793   (eval $ac_compiler -v </dev/null >&5) 2>&5
3794   ac_status=$?
3795   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3796   (exit $ac_status); }
3797 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3798   (eval $ac_compiler -V </dev/null >&5) 2>&5
3799   ac_status=$?
3800   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3801   (exit $ac_status); }
3802
3803 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3804 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3805 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3806   echo $ECHO_N "(cached) $ECHO_C" >&6
3807 else
3808   cat >conftest.$ac_ext <<_ACEOF
3809 /* confdefs.h.  */
3810 _ACEOF
3811 cat confdefs.h >>conftest.$ac_ext
3812 cat >>conftest.$ac_ext <<_ACEOF
3813 /* end confdefs.h.  */
3814
3815 int
3816 main ()
3817 {
3818 #ifndef __GNUC__
3819        choke me
3820 #endif
3821
3822   ;
3823   return 0;
3824 }
3825 _ACEOF
3826 rm -f conftest.$ac_objext
3827 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3828   (eval $ac_compile) 2>conftest.er1
3829   ac_status=$?
3830   grep -v '^ *+' conftest.er1 >conftest.err
3831   rm -f conftest.er1
3832   cat conftest.err >&5
3833   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3834   (exit $ac_status); } &&
3835          { ac_try='test -z "$ac_cxx_werror_flag"
3836                          || test ! -s conftest.err'
3837   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3838   (eval $ac_try) 2>&5
3839   ac_status=$?
3840   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3841   (exit $ac_status); }; } &&
3842          { ac_try='test -s conftest.$ac_objext'
3843   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3844   (eval $ac_try) 2>&5
3845   ac_status=$?
3846   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3847   (exit $ac_status); }; }; then
3848   ac_compiler_gnu=yes
3849 else
3850   echo "$as_me: failed program was:" >&5
3851 sed 's/^/| /' conftest.$ac_ext >&5
3852
3853 ac_compiler_gnu=no
3854 fi
3855 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3856 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3857
3858 fi
3859 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3860 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
3861 GXX=`test $ac_compiler_gnu = yes && echo yes`
3862 ac_test_CXXFLAGS=${CXXFLAGS+set}
3863 ac_save_CXXFLAGS=$CXXFLAGS
3864 CXXFLAGS="-g"
3865 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3866 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
3867 if test "${ac_cv_prog_cxx_g+set}" = set; then
3868   echo $ECHO_N "(cached) $ECHO_C" >&6
3869 else
3870   cat >conftest.$ac_ext <<_ACEOF
3871 /* confdefs.h.  */
3872 _ACEOF
3873 cat confdefs.h >>conftest.$ac_ext
3874 cat >>conftest.$ac_ext <<_ACEOF
3875 /* end confdefs.h.  */
3876
3877 int
3878 main ()
3879 {
3880
3881   ;
3882   return 0;
3883 }
3884 _ACEOF
3885 rm -f conftest.$ac_objext
3886 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3887   (eval $ac_compile) 2>conftest.er1
3888   ac_status=$?
3889   grep -v '^ *+' conftest.er1 >conftest.err
3890   rm -f conftest.er1
3891   cat conftest.err >&5
3892   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3893   (exit $ac_status); } &&
3894          { ac_try='test -z "$ac_cxx_werror_flag"
3895                          || test ! -s conftest.err'
3896   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3897   (eval $ac_try) 2>&5
3898   ac_status=$?
3899   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3900   (exit $ac_status); }; } &&
3901          { ac_try='test -s conftest.$ac_objext'
3902   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3903   (eval $ac_try) 2>&5
3904   ac_status=$?
3905   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3906   (exit $ac_status); }; }; then
3907   ac_cv_prog_cxx_g=yes
3908 else
3909   echo "$as_me: failed program was:" >&5
3910 sed 's/^/| /' conftest.$ac_ext >&5
3911
3912 ac_cv_prog_cxx_g=no
3913 fi
3914 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3915 fi
3916 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3917 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
3918 if test "$ac_test_CXXFLAGS" = set; then
3919   CXXFLAGS=$ac_save_CXXFLAGS
3920 elif test $ac_cv_prog_cxx_g = yes; then
3921   if test "$GXX" = yes; then
3922     CXXFLAGS="-g -O2"
3923   else
3924     CXXFLAGS="-g"
3925   fi
3926 else
3927   if test "$GXX" = yes; then
3928     CXXFLAGS="-O2"
3929   else
3930     CXXFLAGS=
3931   fi
3932 fi
3933 for ac_declaration in \
3934    '' \
3935    'extern "C" void std::exit (int) throw (); using std::exit;' \
3936    'extern "C" void std::exit (int); using std::exit;' \
3937    'extern "C" void exit (int) throw ();' \
3938    'extern "C" void exit (int);' \
3939    'void exit (int);'
3940 do
3941   cat >conftest.$ac_ext <<_ACEOF
3942 /* confdefs.h.  */
3943 _ACEOF
3944 cat confdefs.h >>conftest.$ac_ext
3945 cat >>conftest.$ac_ext <<_ACEOF
3946 /* end confdefs.h.  */
3947 $ac_declaration
3948 #include <stdlib.h>
3949 int
3950 main ()
3951 {
3952 exit (42);
3953   ;
3954   return 0;
3955 }
3956 _ACEOF
3957 rm -f conftest.$ac_objext
3958 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3959   (eval $ac_compile) 2>conftest.er1
3960   ac_status=$?
3961   grep -v '^ *+' conftest.er1 >conftest.err
3962   rm -f conftest.er1
3963   cat conftest.err >&5
3964   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3965   (exit $ac_status); } &&
3966          { ac_try='test -z "$ac_cxx_werror_flag"
3967                          || test ! -s conftest.err'
3968   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3969   (eval $ac_try) 2>&5
3970   ac_status=$?
3971   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3972   (exit $ac_status); }; } &&
3973          { ac_try='test -s conftest.$ac_objext'
3974   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3975   (eval $ac_try) 2>&5
3976   ac_status=$?
3977   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3978   (exit $ac_status); }; }; then
3979   :
3980 else
3981   echo "$as_me: failed program was:" >&5
3982 sed 's/^/| /' conftest.$ac_ext >&5
3983
3984 continue
3985 fi
3986 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3987   cat >conftest.$ac_ext <<_ACEOF
3988 /* confdefs.h.  */
3989 _ACEOF
3990 cat confdefs.h >>conftest.$ac_ext
3991 cat >>conftest.$ac_ext <<_ACEOF
3992 /* end confdefs.h.  */
3993 $ac_declaration
3994 int
3995 main ()
3996 {
3997 exit (42);
3998   ;
3999   return 0;
4000 }
4001 _ACEOF
4002 rm -f conftest.$ac_objext
4003 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4004   (eval $ac_compile) 2>conftest.er1
4005   ac_status=$?
4006   grep -v '^ *+' conftest.er1 >conftest.err
4007   rm -f conftest.er1
4008   cat conftest.err >&5
4009   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4010   (exit $ac_status); } &&
4011          { ac_try='test -z "$ac_cxx_werror_flag"
4012                          || test ! -s conftest.err'
4013   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4014   (eval $ac_try) 2>&5
4015   ac_status=$?
4016   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4017   (exit $ac_status); }; } &&
4018          { ac_try='test -s conftest.$ac_objext'
4019   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4020   (eval $ac_try) 2>&5
4021   ac_status=$?
4022   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4023   (exit $ac_status); }; }; then
4024   break
4025 else
4026   echo "$as_me: failed program was:" >&5
4027 sed 's/^/| /' conftest.$ac_ext >&5
4028
4029 fi
4030 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4031 done
4032 rm -f conftest*
4033 if test -n "$ac_declaration"; then
4034   echo '#ifdef __cplusplus' >>confdefs.h
4035   echo $ac_declaration      >>confdefs.h
4036   echo '#endif'             >>confdefs.h
4037 fi
4038
4039 ac_ext=c
4040 ac_cpp='$CPP $CPPFLAGS'
4041 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4042 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4043 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4044
4045
4046 # We must set the default linker to the linker used by gcc for the correct
4047 # operation of libtool.  If LD is not defined and we are using gcc, try to
4048 # set the LD default to the ld used by gcc.
4049 if test -z "$LD"; then
4050   if test "$GCC" = yes; then
4051     case $build in
4052     *-*-mingw*)
4053       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4054     *)
4055       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4056     esac
4057     case $gcc_prog_ld in
4058     # Accept absolute paths.
4059     [\\/]* | [A-Za-z]:[\\/]*)
4060       LD="$gcc_prog_ld" ;;
4061     esac
4062   fi
4063 fi
4064
4065
4066
4067
4068 if test -n "$ac_tool_prefix"; then
4069   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4070 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4071 echo "$as_me:$LINENO: checking for $ac_word" >&5
4072 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4073 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4074   echo $ECHO_N "(cached) $ECHO_C" >&6
4075 else
4076   if test -n "$GNATBIND"; then
4077   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4078 else
4079 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4080 for as_dir in $PATH
4081 do
4082   IFS=$as_save_IFS
4083   test -z "$as_dir" && as_dir=.
4084   for ac_exec_ext in '' $ac_executable_extensions; do
4085   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4086     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4087     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4088     break 2
4089   fi
4090 done
4091 done
4092
4093 fi
4094 fi
4095 GNATBIND=$ac_cv_prog_GNATBIND
4096 if test -n "$GNATBIND"; then
4097   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4098 echo "${ECHO_T}$GNATBIND" >&6
4099 else
4100   echo "$as_me:$LINENO: result: no" >&5
4101 echo "${ECHO_T}no" >&6
4102 fi
4103
4104 fi
4105 if test -z "$ac_cv_prog_GNATBIND"; then
4106   ac_ct_GNATBIND=$GNATBIND
4107   # Extract the first word of "gnatbind", so it can be a program name with args.
4108 set dummy gnatbind; ac_word=$2
4109 echo "$as_me:$LINENO: checking for $ac_word" >&5
4110 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4111 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4112   echo $ECHO_N "(cached) $ECHO_C" >&6
4113 else
4114   if test -n "$ac_ct_GNATBIND"; then
4115   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4116 else
4117 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4118 for as_dir in $PATH
4119 do
4120   IFS=$as_save_IFS
4121   test -z "$as_dir" && as_dir=.
4122   for ac_exec_ext in '' $ac_executable_extensions; do
4123   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4124     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4125     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4126     break 2
4127   fi
4128 done
4129 done
4130
4131   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4132 fi
4133 fi
4134 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4135 if test -n "$ac_ct_GNATBIND"; then
4136   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4137 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4138 else
4139   echo "$as_me:$LINENO: result: no" >&5
4140 echo "${ECHO_T}no" >&6
4141 fi
4142
4143   GNATBIND=$ac_ct_GNATBIND
4144 else
4145   GNATBIND="$ac_cv_prog_GNATBIND"
4146 fi
4147
4148 if test -n "$ac_tool_prefix"; then
4149   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4150 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4151 echo "$as_me:$LINENO: checking for $ac_word" >&5
4152 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4153 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4154   echo $ECHO_N "(cached) $ECHO_C" >&6
4155 else
4156   if test -n "$GNATMAKE"; then
4157   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4158 else
4159 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4160 for as_dir in $PATH
4161 do
4162   IFS=$as_save_IFS
4163   test -z "$as_dir" && as_dir=.
4164   for ac_exec_ext in '' $ac_executable_extensions; do
4165   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4166     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4167     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4168     break 2
4169   fi
4170 done
4171 done
4172
4173 fi
4174 fi
4175 GNATMAKE=$ac_cv_prog_GNATMAKE
4176 if test -n "$GNATMAKE"; then
4177   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4178 echo "${ECHO_T}$GNATMAKE" >&6
4179 else
4180   echo "$as_me:$LINENO: result: no" >&5
4181 echo "${ECHO_T}no" >&6
4182 fi
4183
4184 fi
4185 if test -z "$ac_cv_prog_GNATMAKE"; then
4186   ac_ct_GNATMAKE=$GNATMAKE
4187   # Extract the first word of "gnatmake", so it can be a program name with args.
4188 set dummy gnatmake; ac_word=$2
4189 echo "$as_me:$LINENO: checking for $ac_word" >&5
4190 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4191 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4192   echo $ECHO_N "(cached) $ECHO_C" >&6
4193 else
4194   if test -n "$ac_ct_GNATMAKE"; then
4195   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4196 else
4197 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4198 for as_dir in $PATH
4199 do
4200   IFS=$as_save_IFS
4201   test -z "$as_dir" && as_dir=.
4202   for ac_exec_ext in '' $ac_executable_extensions; do
4203   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4204     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4205     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4206     break 2
4207   fi
4208 done
4209 done
4210
4211   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4212 fi
4213 fi
4214 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4215 if test -n "$ac_ct_GNATMAKE"; then
4216   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4217 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4218 else
4219   echo "$as_me:$LINENO: result: no" >&5
4220 echo "${ECHO_T}no" >&6
4221 fi
4222
4223   GNATMAKE=$ac_ct_GNATMAKE
4224 else
4225   GNATMAKE="$ac_cv_prog_GNATMAKE"
4226 fi
4227
4228 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4229 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4230 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4231   echo $ECHO_N "(cached) $ECHO_C" >&6
4232 else
4233   cat >conftest.adb <<EOF
4234 procedure conftest is begin null; end conftest;
4235 EOF
4236 acx_cv_cc_gcc_supports_ada=no
4237 # There is a bug in old released versions of GCC which causes the
4238 # driver to exit successfully when the appropriate language module
4239 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4240 # Therefore we must check for the error message as well as an
4241 # unsuccessful exit.
4242 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4243 # given a .adb file, but produce no object file.  So we must check
4244 # if an object file was really produced to guard against this.
4245 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4246 if test x"$errors" = x && test -f conftest.$ac_objext; then
4247   acx_cv_cc_gcc_supports_ada=yes
4248 fi
4249 rm -f conftest.*
4250 fi
4251 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4252 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4253
4254 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4255   have_gnat=yes
4256 else
4257   have_gnat=no
4258 fi
4259
4260 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4261 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4262 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4263   echo $ECHO_N "(cached) $ECHO_C" >&6
4264 else
4265    echo abfoo >t1
4266   echo cdfoo >t2
4267   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4268   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4269     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4270       :
4271     else
4272       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4273     fi
4274   fi
4275   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4276     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4277       :
4278     else
4279       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4280     fi
4281   fi
4282   rm t1 t2
4283
4284 fi
4285 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4286 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4287 do_compare="$gcc_cv_prog_cmp_skip"
4288
4289
4290
4291 # Check for GMP and MPFR
4292 gmplibs="-lmpfr -lgmp"
4293 gmpinc=
4294 have_gmp=no
4295
4296 # Specify a location for mpfr
4297 # check for this first so it ends up on the link line before gmp.
4298
4299 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4300 if test "${with_mpfr_dir+set}" = set; then
4301   withval="$with_mpfr_dir"
4302   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4303 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4304 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4305 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4306    { (exit 1); exit 1; }; }
4307 fi;
4308
4309
4310 # Check whether --with-mpfr or --without-mpfr was given.
4311 if test "${with_mpfr+set}" = set; then
4312   withval="$with_mpfr"
4313
4314 fi;
4315
4316 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4317 if test "${with_mpfr_include+set}" = set; then
4318   withval="$with_mpfr_include"
4319
4320 fi;
4321
4322 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4323 if test "${with_mpfr_lib+set}" = set; then
4324   withval="$with_mpfr_lib"
4325
4326 fi;
4327
4328 if test "x$with_mpfr" != x; then
4329   gmplibs="-L$with_mpfr/lib $gmplibs"
4330   gmpinc="-I$with_mpfr/include"
4331 fi
4332 if test "x$with_mpfr_include" != x; then
4333   gmpinc="-I$with_mpfr_include"
4334 fi
4335 if test "x$with_mpfr_lib" != x; then
4336   gmplibs="-L$with_mpfr_lib $gmplibs"
4337 fi
4338 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4339   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4340   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4341   # Do not test the mpfr version.  Assume that it is sufficient, since
4342   # it is in the source tree, and the library has not been built yet
4343   # but it would be included on the link line in the version check below
4344   # hence making the test fail.
4345   have_gmp=yes
4346 fi
4347
4348 # Specify a location for gmp
4349
4350 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4351 if test "${with_gmp_dir+set}" = set; then
4352   withval="$with_gmp_dir"
4353   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4354 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4355 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4356 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4357    { (exit 1); exit 1; }; }
4358 fi;
4359
4360
4361 # Check whether --with-gmp or --without-gmp was given.
4362 if test "${with_gmp+set}" = set; then
4363   withval="$with_gmp"
4364
4365 fi;
4366
4367 # Check whether --with-gmp_include or --without-gmp_include was given.
4368 if test "${with_gmp_include+set}" = set; then
4369   withval="$with_gmp_include"
4370
4371 fi;
4372
4373 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4374 if test "${with_gmp_lib+set}" = set; then
4375   withval="$with_gmp_lib"
4376
4377 fi;
4378
4379
4380 if test "x$with_gmp" != x; then
4381   gmplibs="-L$with_gmp/lib $gmplibs"
4382   gmpinc="-I$with_gmp/include $gmpinc"
4383 fi
4384 if test "x$with_gmp_include" != x; then
4385   gmpinc="-I$with_gmp_include $gmpinc"
4386 fi
4387 if test "x$with_gmp_lib" != x; then
4388   gmplibs="-L$with_gmp_lib $gmplibs"
4389 fi
4390 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4391   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4392   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4393   # Do not test the gmp version.  Assume that it is sufficient, since
4394   # it is in the source tree, and the library has not been built yet
4395   # but it would be included on the link line in the version check below
4396   # hence making the test fail.
4397   have_gmp=yes
4398 fi
4399
4400 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4401   have_gmp=yes
4402   saved_CFLAGS="$CFLAGS"
4403   CFLAGS="$CFLAGS $gmpinc"
4404   # Check GMP actually works
4405   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4406 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4407
4408 cat >conftest.$ac_ext <<_ACEOF
4409 /* confdefs.h.  */
4410 _ACEOF
4411 cat confdefs.h >>conftest.$ac_ext
4412 cat >>conftest.$ac_ext <<_ACEOF
4413 /* end confdefs.h.  */
4414 #include "gmp.h"
4415 int
4416 main ()
4417 {
4418
4419   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4420   choke me
4421   #endif
4422
4423   ;
4424   return 0;
4425 }
4426 _ACEOF
4427 rm -f conftest.$ac_objext
4428 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4429   (eval $ac_compile) 2>conftest.er1
4430   ac_status=$?
4431   grep -v '^ *+' conftest.er1 >conftest.err
4432   rm -f conftest.er1
4433   cat conftest.err >&5
4434   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4435   (exit $ac_status); } &&
4436          { ac_try='test -z "$ac_c_werror_flag"
4437                          || test ! -s conftest.err'
4438   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4439   (eval $ac_try) 2>&5
4440   ac_status=$?
4441   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4442   (exit $ac_status); }; } &&
4443          { ac_try='test -s conftest.$ac_objext'
4444   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4445   (eval $ac_try) 2>&5
4446   ac_status=$?
4447   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4448   (exit $ac_status); }; }; then
4449   echo "$as_me:$LINENO: result: yes" >&5
4450 echo "${ECHO_T}yes" >&6
4451 else
4452   echo "$as_me: failed program was:" >&5
4453 sed 's/^/| /' conftest.$ac_ext >&5
4454
4455 echo "$as_me:$LINENO: result: no" >&5
4456 echo "${ECHO_T}no" >&6; have_gmp=no
4457 fi
4458 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4459
4460   if test x"$have_gmp" = xyes; then
4461     saved_LIBS="$LIBS"
4462     LIBS="$LIBS $gmplibs"
4463         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4464 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4465     cat >conftest.$ac_ext <<_ACEOF
4466 /* confdefs.h.  */
4467 _ACEOF
4468 cat confdefs.h >>conftest.$ac_ext
4469 cat >>conftest.$ac_ext <<_ACEOF
4470 /* end confdefs.h.  */
4471 #include <gmp.h>
4472     #include <mpfr.h>
4473 int
4474 main ()
4475 {
4476
4477     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,0)
4478     choke me
4479     #endif
4480     mpfr_t n;
4481     mpfr_t x;
4482     int t;
4483     mpfr_init (n);
4484     mpfr_init (x);
4485     mpfr_atan2 (n, n, x, GMP_RNDN);
4486     mpfr_erfc (n, x, GMP_RNDN);
4487     mpfr_subnormalize (x, t, GMP_RNDN);
4488
4489   ;
4490   return 0;
4491 }
4492 _ACEOF
4493 rm -f conftest.$ac_objext conftest$ac_exeext
4494 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4495   (eval $ac_link) 2>conftest.er1
4496   ac_status=$?
4497   grep -v '^ *+' conftest.er1 >conftest.err
4498   rm -f conftest.er1
4499   cat conftest.err >&5
4500   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4501   (exit $ac_status); } &&
4502          { ac_try='test -z "$ac_c_werror_flag"
4503                          || test ! -s conftest.err'
4504   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4505   (eval $ac_try) 2>&5
4506   ac_status=$?
4507   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4508   (exit $ac_status); }; } &&
4509          { ac_try='test -s conftest$ac_exeext'
4510   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4511   (eval $ac_try) 2>&5
4512   ac_status=$?
4513   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4514   (exit $ac_status); }; }; then
4515   cat >conftest.$ac_ext <<_ACEOF
4516 /* confdefs.h.  */
4517 _ACEOF
4518 cat confdefs.h >>conftest.$ac_ext
4519 cat >>conftest.$ac_ext <<_ACEOF
4520 /* end confdefs.h.  */
4521 #include <gmp.h>
4522     #include <mpfr.h>
4523 int
4524 main ()
4525 {
4526
4527     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4528     choke me
4529     #endif
4530     mpfr_t n; mpfr_init(n);
4531
4532   ;
4533   return 0;
4534 }
4535 _ACEOF
4536 rm -f conftest.$ac_objext conftest$ac_exeext
4537 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4538   (eval $ac_link) 2>conftest.er1
4539   ac_status=$?
4540   grep -v '^ *+' conftest.er1 >conftest.err
4541   rm -f conftest.er1
4542   cat conftest.err >&5
4543   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4544   (exit $ac_status); } &&
4545          { ac_try='test -z "$ac_c_werror_flag"
4546                          || test ! -s conftest.err'
4547   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4548   (eval $ac_try) 2>&5
4549   ac_status=$?
4550   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4551   (exit $ac_status); }; } &&
4552          { ac_try='test -s conftest$ac_exeext'
4553   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4554   (eval $ac_try) 2>&5
4555   ac_status=$?
4556   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4557   (exit $ac_status); }; }; then
4558   echo "$as_me:$LINENO: result: yes" >&5
4559 echo "${ECHO_T}yes" >&6
4560 else
4561   echo "$as_me: failed program was:" >&5
4562 sed 's/^/| /' conftest.$ac_ext >&5
4563
4564 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4565 echo "${ECHO_T}buggy but acceptable" >&6
4566 fi
4567 rm -f conftest.err conftest.$ac_objext \
4568       conftest$ac_exeext conftest.$ac_ext
4569 else
4570   echo "$as_me: failed program was:" >&5
4571 sed 's/^/| /' conftest.$ac_ext >&5
4572
4573 echo "$as_me:$LINENO: result: no" >&5
4574 echo "${ECHO_T}no" >&6; have_gmp=no
4575 fi
4576 rm -f conftest.err conftest.$ac_objext \
4577       conftest$ac_exeext conftest.$ac_ext
4578       LIBS="$saved_LIBS"
4579   fi
4580   CFLAGS="$saved_CFLAGS"
4581
4582   if test x$have_gmp != xyes; then
4583     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4584 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4585 Copies of these libraries' source code can be found at their respective
4586 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4587 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4588 If you obtained GMP and/or MPFR from a vendor distribution package, make
4589 sure that you have installed both the libraries and the header files.
4590 They may be located in separate packages." >&5
4591 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4592 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4593 Copies of these libraries' source code can be found at their respective
4594 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4595 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4596 If you obtained GMP and/or MPFR from a vendor distribution package, make
4597 sure that you have installed both the libraries and the header files.
4598 They may be located in separate packages." >&2;}
4599    { (exit 1); exit 1; }; }
4600   fi
4601 fi
4602
4603 # Flags needed for both GMP and/or MPFR
4604
4605
4606
4607 # By default, C is the only stage 1 language.
4608 stage1_languages=,c,
4609
4610 # Figure out what language subdirectories are present.
4611 # Look if the user specified --enable-languages="..."; if not, use
4612 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4613 # go away some day.
4614 # NB:  embedded tabs in this IF block -- do not untabify
4615 if test -d ${srcdir}/gcc; then
4616   if test x"${enable_languages+set}" != xset; then
4617     if test x"${LANGUAGES+set}" = xset; then
4618       enable_languages="${LANGUAGES}"
4619         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4620     else
4621       enable_languages=all
4622     fi
4623   else
4624     if test x"${enable_languages}" = x ||
4625        test x"${enable_languages}" = xyes;
4626        then
4627       echo configure.in: --enable-languages needs at least one language argument 1>&2
4628       exit 1
4629     fi
4630   fi
4631   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4632
4633   # 'f95' is the old name for the 'fortran' language. We issue a warning
4634   # and make the substitution.
4635   case ,${enable_languages}, in
4636     *,f95,*)
4637       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4638       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4639       ;;
4640   esac
4641
4642   # First scan to see if an enabled language requires some other language.
4643   # We assume that a given config-lang.in will list all the language
4644   # front ends it requires, even if some are required indirectly.
4645   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4646     case ${lang_frag} in
4647       ..) ;;
4648       # The odd quoting in the next line works around
4649       # an apparent bug in bash 1.12 on linux.
4650       ${srcdir}/gcc/[*]/config-lang.in) ;;
4651       *)
4652         # From the config-lang.in, get $language, $lang_requires
4653         language=
4654         lang_requires=
4655         . ${lang_frag}
4656         for other in ${lang_requires} ; do
4657           case ,${enable_languages}, in
4658             *,$other,*) ;;
4659             *,all,*) ;;
4660             *,$language,*)
4661               echo " \`$other' language required by \`$language'; enabling" 1>&2
4662               enable_languages="${enable_languages},${other}"
4663               ;;
4664           esac
4665         done
4666         ;;
4667     esac
4668   done
4669
4670   new_enable_languages=,c,
4671   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4672   potential_languages=,c,
4673
4674   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4675     case ${lang_frag} in
4676       ..) ;;
4677       # The odd quoting in the next line works around
4678       # an apparent bug in bash 1.12 on linux.
4679       ${srcdir}/gcc/[*]/config-lang.in) ;;
4680       *)
4681         # From the config-lang.in, get $language, $target_libs,
4682         # $lang_dirs, $boot_language, and $build_by_default
4683         language=
4684         target_libs=
4685         lang_dirs=
4686         subdir_requires=
4687         boot_language=no
4688         build_by_default=yes
4689         . ${lang_frag}
4690         if test x${language} = x; then
4691           echo "${lang_frag} doesn't set \$language." 1>&2
4692           exit 1
4693         fi
4694
4695         case ,${enable_languages}, in
4696           *,${language},*)
4697             # Language was explicitly selected; include it.
4698             add_this_lang=yes
4699             ;;
4700           *,all,*)
4701             # 'all' was selected, select it if it is a default language
4702             add_this_lang=${build_by_default}
4703             ;;
4704           *)
4705             add_this_lang=no
4706             ;;
4707         esac
4708
4709         # Disable languages that need other directories if these aren't available.
4710         for i in $subdir_requires; do
4711           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4712           case ,${enable_languages}, in
4713             *,${language},*)
4714               # Specifically requested language; tell them.
4715               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4716 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4717    { (exit 1); exit 1; }; }
4718               ;;
4719             *)
4720               # Silently disable.
4721               add_this_lang=unsupported
4722               ;;
4723           esac
4724         done
4725
4726         # Disable Ada if no preexisting GNAT is available.
4727         case ,${enable_languages},:${language}:${have_gnat} in
4728           *,${language},*:ada:no)
4729             # Specifically requested language; tell them.
4730             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4731 echo "$as_me: error: GNAT is required to build $language" >&2;}
4732    { (exit 1); exit 1; }; }
4733             ;;
4734           *:ada:no)
4735             # Silently disable.
4736             add_this_lang=unsupported
4737             ;;
4738         esac
4739
4740         # Disable a language that is unsupported by the target.
4741         case " $unsupported_languages " in
4742           *" $language "*)
4743             add_this_lang=unsupported
4744             ;;
4745         esac
4746
4747         case $add_this_lang in
4748           unsupported)
4749             # Remove language-dependent dirs.
4750             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4751             ;;
4752           no)
4753             # Remove language-dependent dirs; still show language as supported.
4754             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4755             potential_languages="${potential_languages}${language},"
4756             ;;
4757           yes)
4758             new_enable_languages="${new_enable_languages}${language},"
4759             potential_languages="${potential_languages}${language},"
4760             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4761             case ${boot_language} in
4762               yes)
4763                 # Add to (comma-separated) list of stage 1 languages.
4764                 stage1_languages="${stage1_languages}${language},"
4765                 ;;
4766             esac
4767             ;;
4768         esac
4769         ;;
4770     esac
4771   done
4772
4773   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4774 if test "${enable_stage1_languages+set}" = set; then
4775   enableval="$enable_stage1_languages"
4776   case ,${enable_stage1_languages}, in
4777     ,no,|,,)
4778       # Set it to something that will have no effect in the loop below
4779       enable_stage1_languages=c ;;
4780     ,yes,)
4781       enable_stage1_languages=`echo $new_enable_languages | \
4782         sed -e "s/^,//" -e "s/,$//" ` ;;
4783     *,all,*)
4784       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4785         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4786   esac
4787
4788   # Add "good" languages from enable_stage1_languages to stage1_languages,
4789   # while "bad" languages go in missing_languages.  Leave no duplicates.
4790   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4791     case $potential_languages in
4792       *,$i,*)
4793         case $stage1_languages in
4794           *,$i,*) ;;
4795           *) stage1_languages="$stage1_languages$i," ;;
4796         esac ;;
4797       *)
4798         case $missing_languages in
4799           *,$i,*) ;;
4800           *) missing_languages="$missing_languages$i," ;;
4801         esac ;;
4802      esac
4803   done
4804 fi;
4805
4806   # Remove leading/trailing commas that were added for simplicity
4807   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4808   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4809   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4810   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4811
4812   if test "x$missing_languages" != x; then
4813     { { echo "$as_me:$LINENO: error:
4814 The following requested languages could not be built: ${missing_languages}
4815 Supported languages are: ${potential_languages}" >&5
4816 echo "$as_me: error:
4817 The following requested languages could not be built: ${missing_languages}
4818 Supported languages are: ${potential_languages}" >&2;}
4819    { (exit 1); exit 1; }; }
4820   fi
4821   if test "x$new_enable_languages" != "x$enable_languages"; then
4822     echo The following languages will be built: ${new_enable_languages}
4823     enable_languages="$new_enable_languages"
4824   fi
4825
4826
4827   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4828 fi
4829
4830 # Handle --disable-<component> generically.
4831 for dir in $configdirs $build_configdirs $target_configdirs ; do
4832   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4833   if eval test x\${enable_${dirname}} "=" xno ; then
4834     noconfigdirs="$noconfigdirs $dir"
4835   fi
4836 done
4837
4838 # Check for Boehm's garbage collector
4839 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4840 if test "${enable_objc_gc+set}" = set; then
4841   enableval="$enable_objc_gc"
4842   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4843   *,objc,*:*:yes:*target-boehm-gc*)
4844     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4845 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4846    { (exit 1); exit 1; }; }
4847     ;;
4848 esac
4849 fi;
4850
4851 # Make sure we only build Boehm's garbage collector if required.
4852 case ,${enable_languages},:${enable_objc_gc} in
4853   *,objc,*:yes)
4854     # Keep target-boehm-gc if requested for Objective-C.
4855     ;;
4856   *)
4857     # Otherwise remove target-boehm-gc depending on target-libjava.
4858     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
4859       noconfigdirs="$noconfigdirs target-boehm-gc"
4860     fi
4861     ;;
4862 esac
4863
4864 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
4865 # $build_configdirs and $target_configdirs.
4866 # If we have the source for $noconfigdirs entries, add them to $notsupp.
4867
4868 notsupp=""
4869 for dir in . $skipdirs $noconfigdirs ; do
4870   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
4871   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4872     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
4873     if test -r $srcdir/$dirname/configure ; then
4874       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4875         true
4876       else
4877         notsupp="$notsupp $dir"
4878       fi
4879     fi
4880   fi
4881   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4882     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
4883     if test -r $srcdir/$dirname/configure ; then
4884       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4885         true
4886       else
4887         notsupp="$notsupp $dir"
4888       fi
4889     fi
4890   fi
4891   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4892     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
4893     if test -r $srcdir/$dirname/configure ; then
4894       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4895         true
4896       else
4897         notsupp="$notsupp $dir"
4898       fi
4899     fi
4900   fi
4901 done
4902
4903 # Sometimes the tools are distributed with libiberty but with no other
4904 # libraries.  In that case, we don't want to build target-libiberty.
4905 # Don't let libgcc imply libiberty either.
4906 if test -n "${target_configdirs}" ; then
4907   libgcc=
4908   others=
4909   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
4910     if test "$i" = "libgcc"; then
4911       libgcc=target-libgcc
4912     elif test "$i" != "libiberty" ; then
4913       if test -r $srcdir/$i/configure ; then
4914         others=yes;
4915         break;
4916       fi
4917     fi
4918   done
4919   if test -z "${others}" ; then
4920     target_configdirs=$libgcc
4921   fi
4922 fi
4923
4924 # Quietly strip out all directories which aren't configurable in this tree.
4925 # This relies on all configurable subdirectories being autoconfiscated, which
4926 # is now the case.
4927 build_configdirs_all="$build_configdirs"
4928 build_configdirs=
4929 for i in ${build_configdirs_all} ; do
4930   j=`echo $i | sed -e s/build-//g`
4931   if test -f ${srcdir}/$j/configure ; then
4932     build_configdirs="${build_configdirs} $i"
4933   fi
4934 done
4935
4936 configdirs_all="$configdirs"
4937 configdirs=
4938 for i in ${configdirs_all} ; do
4939   if test -f ${srcdir}/$i/configure ; then
4940     configdirs="${configdirs} $i"
4941   fi
4942 done
4943
4944 target_configdirs_all="$target_configdirs"
4945 target_configdirs=
4946 for i in ${target_configdirs_all} ; do
4947   j=`echo $i | sed -e s/target-//g`
4948   if test -f ${srcdir}/$j/configure ; then
4949     target_configdirs="${target_configdirs} $i"
4950   fi
4951 done
4952
4953 # Produce a warning message for the subdirs we can't configure.
4954 # This isn't especially interesting in the Cygnus tree, but in the individual
4955 # FSF releases, it's important to let people know when their machine isn't
4956 # supported by the one or two programs in a package.
4957
4958 if test -n "${notsupp}" && test -z "${norecursion}" ; then
4959   # If $appdirs is non-empty, at least one of those directories must still
4960   # be configured, or we error out.  (E.g., if the gas release supports a
4961   # specified target in some subdirs but not the gas subdir, we shouldn't
4962   # pretend that all is well.)
4963   if test -n "$appdirs" ; then
4964     for dir in $appdirs ; do
4965       if test -r $dir/Makefile.in ; then
4966         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4967           appdirs=""
4968           break
4969         fi
4970         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
4971           appdirs=""
4972           break
4973         fi
4974       fi
4975     done
4976     if test -n "$appdirs" ; then
4977       echo "*** This configuration is not supported by this package." 1>&2
4978       exit 1
4979     fi
4980   fi
4981   # Okay, some application will build, or we don't care to check.  Still
4982   # notify of subdirs not getting built.
4983   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
4984   echo "    ${notsupp}" 1>&2
4985   echo "    (Any other directories should still work fine.)" 1>&2
4986 fi
4987
4988 case "$host" in
4989   *msdosdjgpp*)
4990     enable_gdbtk=no ;;
4991 esac
4992
4993 # To find our prefix, in gcc_cv_tool_prefix.
4994
4995 # The user is always right.
4996 if test "${PATH_SEPARATOR+set}" != set; then
4997   echo "#! /bin/sh" >conf$$.sh
4998   echo  "exit 0"   >>conf$$.sh
4999   chmod +x conf$$.sh
5000   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5001     PATH_SEPARATOR=';'
5002   else
5003     PATH_SEPARATOR=:
5004   fi
5005   rm -f conf$$.sh
5006 fi
5007
5008
5009
5010 if test "x$exec_prefix" = xNONE; then
5011         if test "x$prefix" = xNONE; then
5012                 gcc_cv_tool_prefix=$ac_default_prefix
5013         else
5014                 gcc_cv_tool_prefix=$prefix
5015         fi
5016 else
5017         gcc_cv_tool_prefix=$exec_prefix
5018 fi
5019
5020 # If there is no compiler in the tree, use the PATH only.  In any
5021 # case, if there is no compiler in the tree nobody should use
5022 # AS_FOR_TARGET and LD_FOR_TARGET.
5023 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5024     gcc_version=`cat $srcdir/gcc/BASE-VER`
5025     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5026     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5027     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5028     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5029     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5030     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5031 else
5032     gcc_cv_tool_dirs=
5033 fi
5034
5035 if test x$build = x$target && test -n "$md_exec_prefix"; then
5036         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5037 fi
5038
5039
5040
5041 copy_dirs=
5042
5043
5044 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5045 if test "${with_build_sysroot+set}" = set; then
5046   withval="$with_build_sysroot"
5047   if test x"$withval" != x ; then
5048      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5049    fi
5050 else
5051   SYSROOT_CFLAGS_FOR_TARGET=
5052 fi;
5053
5054
5055 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5056 # the named directory are copied to $(tooldir)/sys-include.
5057 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5058   if test x${is_cross_compiler} = xno ; then
5059     echo 1>&2 '***' --with-headers is only supported when cross compiling
5060     exit 1
5061   fi
5062   if test x"${with_headers}" != xyes ; then
5063     x=${gcc_cv_tool_prefix}
5064     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5065   fi
5066 fi
5067
5068 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5069 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5070 # are permitted.
5071 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5072   if test x${is_cross_compiler} = xno ; then
5073     echo 1>&2 '***' --with-libs is only supported when cross compiling
5074     exit 1
5075   fi
5076   if test x"${with_libs}" != xyes ; then
5077     # Copy the libraries in reverse order, so that files in the first named
5078     # library override files in subsequent libraries.
5079     x=${gcc_cv_tool_prefix}
5080     for l in ${with_libs}; do
5081       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5082     done
5083   fi
5084 fi
5085
5086 # Set with_gnu_as and with_gnu_ld as appropriate.
5087 #
5088 # This is done by determining whether or not the appropriate directory
5089 # is available, and by checking whether or not specific configurations
5090 # have requested that this magic not happen.
5091 #
5092 # The command line options always override the explicit settings in
5093 # configure.in, and the settings in configure.in override this magic.
5094 #
5095 # If the default for a toolchain is to use GNU as and ld, and you don't
5096 # want to do that, then you should use the --without-gnu-as and
5097 # --without-gnu-ld options for the configure script.
5098
5099 if test x${use_gnu_as} = x &&
5100    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5101   with_gnu_as=yes
5102   extra_host_args="$extra_host_args --with-gnu-as"
5103 fi
5104
5105 if test x${use_gnu_ld} = x &&
5106    echo " ${configdirs} " | grep " ld " > /dev/null 2>&1 ; then
5107   with_gnu_ld=yes
5108   extra_host_args="$extra_host_args --with-gnu-ld"
5109 fi
5110
5111 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5112 # can detect this case.
5113
5114 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5115   with_newlib=yes
5116   extra_host_args="$extra_host_args --with-newlib"
5117 fi
5118
5119 # Handle ${copy_dirs}
5120 set fnord ${copy_dirs}
5121 shift
5122 while test $# != 0 ; do
5123   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5124     :
5125   else
5126     echo Copying $1 to $2
5127
5128     # Use the install script to create the directory and all required
5129     # parent directories.
5130     if test -d $2 ; then
5131       :
5132     else
5133       echo >config.temp
5134       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5135     fi
5136
5137     # Copy the directory, assuming we have tar.
5138     # FIXME: Should we use B in the second tar?  Not all systems support it.
5139     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5140
5141     # It is the responsibility of the user to correctly adjust all
5142     # symlinks.  If somebody can figure out how to handle them correctly
5143     # here, feel free to add the code.
5144
5145     echo $1 > $2/COPIED
5146   fi
5147   shift; shift
5148 done
5149
5150 # Determine a target-dependent exec_prefix that the installed
5151 # gcc will search in.  Keep this list sorted by triplet, with
5152 # the *-*-osname triplets last.
5153 md_exec_prefix=
5154 case "${target}" in
5155   alpha*-*-*vms*)
5156     md_exec_prefix=/gnu/lib/gcc-lib
5157     ;;
5158   i3456786-pc-msdosdjgpp*)
5159     md_exec_prefix=/dev/env/DJDIR/bin
5160     ;;
5161   i3456786-*-sco3.2v5*)
5162     if test $with_gnu_as = yes; then
5163       md_exec_prefix=/usr/gnu/bin
5164     else
5165       md_exec_prefix=/usr/ccs/bin/elf
5166     fi
5167     ;;
5168
5169   mn10300-*-* | \
5170   powerpc-*-chorusos* | \
5171   powerpc*-*-eabi* | \
5172   powerpc*-*-sysv* | \
5173   powerpc*-*-kaos* | \
5174   s390x-ibm-tpf*)
5175     md_exec_prefix=/usr/ccs/bin
5176     ;;
5177   sparc64-*-elf*)
5178     ;;
5179   v850*-*-*)
5180     md_exec_prefix=/usr/ccs/bin
5181     ;;
5182   xtensa-*-elf*)
5183     ;;
5184
5185   *-*-beos* | \
5186   *-*-elf* | \
5187   *-*-hpux* | \
5188   *-*-netware* | \
5189   *-*-nto-qnx* | \
5190   *-*-rtems* | \
5191   *-*-solaris2* | \
5192   *-*-sysv45* | \
5193   *-*-vxworks* | \
5194   *-wrs-windiss)
5195     md_exec_prefix=/usr/ccs/bin
5196     ;;
5197 esac
5198
5199 extra_arflags_for_target=
5200 extra_nmflags_for_target=
5201 extra_ranlibflags_for_target=
5202 target_makefile_frag=/dev/null
5203 case "${target}" in
5204   mep*-*-*)
5205     target_makefile_frag="config/mt-mep"
5206     ;;
5207   spu-*-*)
5208     target_makefile_frag="config/mt-spu"
5209     ;;
5210   *-*-netware*)
5211     target_makefile_frag="config/mt-netware"
5212     ;;
5213   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5214     target_makefile_frag="config/mt-gnu"
5215     ;;
5216   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5217     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5218     # commands to handle both 32-bit and 64-bit objects.  These flags are
5219     # harmless if we're using GNU nm or ar.
5220     extra_arflags_for_target=" -X32_64"
5221     extra_nmflags_for_target=" -B -X32_64"
5222     ;;
5223   *-*-darwin*)
5224     # ranlib from Darwin requires the -c flag to look at common symbols.
5225     extra_ranlibflags_for_target=" -c"
5226     ;;
5227   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5228     target_makefile_frag="config/mt-wince"
5229     ;;
5230 esac
5231
5232 alphaieee_frag=/dev/null
5233 case $target in
5234   alpha*-*-*)
5235     # This just makes sure to use the -mieee option to build target libs.
5236     # This should probably be set individually by each library.
5237     alphaieee_frag="config/mt-alphaieee"
5238     ;;
5239 esac
5240
5241 # If --enable-target-optspace always use -Os instead of -O2 to build
5242 # the target libraries, similarly if it is not specified, use -Os
5243 # on selected platforms.
5244 ospace_frag=/dev/null
5245 case "${enable_target_optspace}:${target}" in
5246   yes:*)
5247     ospace_frag="config/mt-ospace"
5248     ;;
5249   :d30v-*)
5250     ospace_frag="config/mt-d30v"
5251     ;;
5252   :m32r-* | :d10v-* | :fr30-*)
5253     ospace_frag="config/mt-ospace"
5254     ;;
5255   no:* | :*)
5256     ;;
5257   *)
5258     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5259     ;;
5260 esac
5261
5262 # Default to using --with-stabs for certain targets.
5263 if test x${with_stabs} = x ; then
5264   case "${target}" in
5265   mips*-*-irix[56]*)
5266     ;;
5267   mips*-*-* | alpha*-*-osf*)
5268     with_stabs=yes;
5269     extra_host_args="${extra_host_args} --with-stabs"
5270     ;;
5271   esac
5272 fi
5273
5274 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5275 # them automatically.
5276 case "${host}" in
5277   hppa*64*-*-hpux11*)
5278     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5279     ;;
5280 esac
5281
5282 # Some systems (e.g., one of the i386-aix systems the gas testers are
5283 # using) don't handle "\$" correctly, so don't use it here.
5284 tooldir='${exec_prefix}'/${target_noncanonical}
5285 build_tooldir=${tooldir}
5286
5287 # Create a .gdbinit file which runs the one in srcdir
5288 # and tells GDB to look there for source files.
5289
5290 if test -r ${srcdir}/.gdbinit ; then
5291   case ${srcdir} in
5292     .) ;;
5293     *) cat > ./.gdbinit <<EOF
5294 # ${NO_EDIT}
5295 dir ${srcdir}
5296 dir .
5297 source ${srcdir}/.gdbinit
5298 EOF
5299     ;;
5300   esac
5301 fi
5302
5303 # Make sure that the compiler is able to generate an executable.  If it
5304 # can't, we are probably in trouble.  We don't care whether we can run the
5305 # executable--we might be using a cross compiler--we only care whether it
5306 # can be created.  At this point the main configure script has set CC.
5307 we_are_ok=no
5308 echo "int main () { return 0; }" > conftest.c
5309 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5310 if test $? = 0 ; then
5311   if test -s conftest || test -s conftest.exe ; then
5312     we_are_ok=yes
5313   fi
5314 fi
5315 case $we_are_ok in
5316   no)
5317     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5318     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5319     rm -f conftest*
5320     exit 1
5321     ;;
5322 esac
5323 rm -f conftest*
5324
5325 # The Solaris /usr/ucb/cc compiler does not appear to work.
5326 case "${host}" in
5327   sparc-sun-solaris2*)
5328       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5329       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5330           could_use=
5331           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5332           if test -d /opt/cygnus/bin ; then
5333               if test "$could_use" = "" ; then
5334                   could_use="/opt/cygnus/bin"
5335               else
5336                   could_use="$could_use or /opt/cygnus/bin"
5337               fi
5338           fi
5339         if test "$could_use" = "" ; then
5340             echo "Warning: compilation may fail because you're using"
5341             echo "/usr/ucb/cc.  You should change your PATH or CC "
5342             echo "variable and rerun configure."
5343         else
5344             echo "Warning: compilation may fail because you're using"
5345             echo "/usr/ucb/cc, when you should use the C compiler from"
5346             echo "$could_use.  You should change your"
5347             echo "PATH or CC variable and rerun configure."
5348         fi
5349       fi
5350   ;;
5351 esac
5352
5353 case "${host}" in
5354   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5355   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5356   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5357 esac
5358
5359 # Record target_configdirs and the configure arguments for target and
5360 # build configuration in Makefile.
5361 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5362 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5363
5364 # Determine whether gdb needs tk/tcl or not.
5365 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5366 # and in that case we want gdb to be built without tk.  Ugh!
5367 # In fact I believe gdb is the *only* package directly dependent on tk,
5368 # so we should be able to put the 'maybe's in unconditionally and
5369 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5370 # 100% sure that that's safe though.
5371
5372 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5373 case "$enable_gdbtk" in
5374   no)
5375     GDB_TK="" ;;
5376   yes)
5377     GDB_TK="${gdb_tk}" ;;
5378   *)
5379     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5380     # distro.  Eventually someone will fix this and move Insight, nee
5381     # gdbtk to a separate directory.
5382     if test -d ${srcdir}/gdb/gdbtk ; then
5383       GDB_TK="${gdb_tk}"
5384     else
5385       GDB_TK=""
5386     fi
5387     ;;
5388 esac
5389 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5390 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5391
5392 # Strip out unwanted targets.
5393
5394 # While at that, we remove Makefiles if we were started for recursive
5395 # configuration, so that the top-level Makefile reconfigures them,
5396 # like we used to do when configure itself was recursive.
5397
5398 # Loop over modules.  $extrasub must be used with care, limiting as
5399 # much as possible the usage of range addresses.  That's because autoconf
5400 # splits the sed script to overcome limits in the number of commands,
5401 # and relying on carefully-timed sed passes may turn out to be very hard
5402 # to maintain later.  In this particular case, you just have to be careful
5403 # not to nest @if/@endif pairs, because configure will not warn you at all.
5404
5405 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5406 if test "${enable_bootstrap+set}" = set; then
5407   enableval="$enable_bootstrap"
5408
5409 else
5410   enable_bootstrap=default
5411 fi;
5412
5413 # Issue errors and warnings for invalid/strange bootstrap combinations.
5414 case "$configdirs" in
5415   *gcc*) have_compiler=yes ;;
5416   *) have_compiler=no ;;
5417 esac
5418
5419 case "$have_compiler:$host:$target:$enable_bootstrap" in
5420   *:*:*:no) ;;
5421
5422   # Default behavior.  Enable bootstrap if we have a compiler
5423   # and we are in a native configuration.
5424   yes:$build:$build:default)
5425     enable_bootstrap=yes ;;
5426
5427   *:*:*:default)
5428     enable_bootstrap=no ;;
5429
5430   # We have a compiler and we are in a native configuration, bootstrap is ok
5431   yes:$build:$build:yes)
5432     ;;
5433
5434   # Other configurations, but we have a compiler.  Assume the user knows
5435   # what he's doing.
5436   yes:*:*:yes)
5437     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5438 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5439     ;;
5440
5441   # No compiler: if they passed --enable-bootstrap explicitly, fail
5442   no:*:*:yes)
5443     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5444 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5445    { (exit 1); exit 1; }; } ;;
5446
5447   # Fail if wrong command line
5448   *)
5449     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5450 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5451    { (exit 1); exit 1; }; }
5452     ;;
5453 esac
5454
5455 # Adjust the toplevel makefile according to whether bootstrap was selected.
5456 case "$enable_bootstrap" in
5457   yes)
5458     bootstrap_suffix=bootstrap ;;
5459   no)
5460     bootstrap_suffix=no-bootstrap ;;
5461 esac
5462
5463 for module in ${build_configdirs} ; do
5464   if test -z "${no_recursion}" \
5465      && test -f ${build_subdir}/${module}/Makefile; then
5466     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5467     rm -f ${build_subdir}/${module}/Makefile
5468   fi
5469   extrasub="$extrasub
5470 /^@if build-$module\$/d
5471 /^@endif build-$module\$/d
5472 /^@if build-$module-$bootstrap_suffix\$/d
5473 /^@endif build-$module-$bootstrap_suffix\$/d"
5474 done
5475 for module in ${configdirs} ; do
5476   if test -z "${no_recursion}"; then
5477     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5478       if test -f ${file}; then
5479         echo 1>&2 "*** removing ${file} to force reconfigure"
5480         rm -f ${file}
5481       fi
5482     done
5483   fi
5484   extrasub="$extrasub
5485 /^@if $module\$/d
5486 /^@endif $module\$/d
5487 /^@if $module-$bootstrap_suffix\$/d
5488 /^@endif $module-$bootstrap_suffix\$/d"
5489 done
5490 for module in ${target_configdirs} ; do
5491   if test -z "${no_recursion}" \
5492      && test -f ${target_subdir}/${module}/Makefile; then
5493     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5494     rm -f ${target_subdir}/${module}/Makefile
5495   fi
5496   extrasub="$extrasub
5497 /^@if target-$module\$/d
5498 /^@endif target-$module\$/d
5499 /^@if target-$module-$bootstrap_suffix\$/d
5500 /^@endif target-$module-$bootstrap_suffix\$/d"
5501 done
5502
5503 extrasub="$extrasub
5504 /^@if /,/^@endif /d"
5505
5506 # Create the serialization dependencies.  This uses a temporary file.
5507
5508 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5509 if test "${enable_serial_configure+set}" = set; then
5510   enableval="$enable_serial_configure"
5511
5512 fi;
5513
5514 case ${enable_serial_configure} in
5515   yes)
5516     enable_serial_build_configure=yes
5517     enable_serial_host_configure=yes
5518     enable_serial_target_configure=yes
5519     ;;
5520 esac
5521
5522 # These force 'configure's to be done one at a time, to avoid problems
5523 # with contention over a shared config.cache.
5524 rm -f serdep.tmp
5525 echo '# serdep.tmp' > serdep.tmp
5526 olditem=
5527 test "x${enable_serial_build_configure}" = xyes &&
5528 for item in ${build_configdirs} ; do
5529   case ${olditem} in
5530     "") ;;
5531     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5532   esac
5533   olditem=${item}
5534 done
5535 olditem=
5536 test "x${enable_serial_host_configure}" = xyes &&
5537 for item in ${configdirs} ; do
5538   case ${olditem} in
5539     "") ;;
5540     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5541   esac
5542   olditem=${item}
5543 done
5544 olditem=
5545 test "x${enable_serial_target_configure}" = xyes &&
5546 for item in ${target_configdirs} ; do
5547   case ${olditem} in
5548     "") ;;
5549     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5550   esac
5551   olditem=${item}
5552 done
5553 serialization_dependencies=serdep.tmp
5554
5555
5556 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5557 # target, nonopt, and variable assignments.  These are the ones we
5558 # might not want to pass down to subconfigures.  Also strip
5559 # program-prefix, program-suffix, and program-transform-name, so that
5560 # we can pass down a consistent program-transform-name.
5561 baseargs=
5562 keep_next=no
5563 skip_next=no
5564 eval "set -- $ac_configure_args"
5565 for ac_arg
5566 do
5567   if test X"$skip_next" = X"yes"; then
5568     skip_next=no
5569     continue
5570   fi
5571   if test X"$keep_next" = X"yes"; then
5572     case $ac_arg in
5573       *\'*)
5574         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5575     esac
5576     baseargs="$baseargs '$ac_arg'"
5577     keep_next=no
5578     continue
5579   fi
5580
5581   # Handle separated arguments.  Based on the logic generated by
5582   # autoconf 2.59.
5583   case $ac_arg in
5584     *=* | --config-cache | -C | -disable-* | --disable-* \
5585       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5586       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5587       | -with-* | --with-* | -without-* | --without-* | --x)
5588       separate_arg=no
5589       ;;
5590     -*)
5591       separate_arg=yes
5592       ;;
5593     *)
5594       separate_arg=no
5595       ;;
5596   esac
5597
5598   case "$ac_arg" in
5599     --no*)
5600       continue
5601       ;;
5602     --c* | \
5603     --sr* | \
5604     --ho* | \
5605     --bu* | \
5606     --t* | \
5607     --program-* | \
5608     -cache_file* | \
5609     -srcdir* | \
5610     -host* | \
5611     -build* | \
5612     -target* | \
5613     -program-prefix* | \
5614     -program-suffix* | \
5615     -program-transform-name* )
5616       skip_next=$separate_arg
5617       continue
5618       ;;
5619     -*)
5620       # An option.  Add it.
5621       case $ac_arg in
5622         *\'*)
5623           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5624       esac
5625       baseargs="$baseargs '$ac_arg'"
5626       keep_next=$separate_arg
5627       ;;
5628     *)
5629       # Either a variable assignment, or a nonopt (triplet).  Don't
5630       # pass it down; let the Makefile handle this.
5631       continue
5632       ;;
5633   esac
5634 done
5635 # Remove the initial space we just introduced and, as these will be
5636 # expanded by make, quote '$'.
5637 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5638
5639 # Add in --program-transform-name, after --program-prefix and
5640 # --program-suffix have been applied to it.  Autoconf has already
5641 # doubled dollar signs and backslashes in program_transform_name; we want
5642 # the backslashes un-doubled, and then the entire thing wrapped in single
5643 # quotes, because this will be expanded first by make and then by the shell.
5644 # Also, because we want to override the logic in subdir configure scripts to
5645 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5646 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5647 ${program_transform_name}
5648 EOF_SED
5649 gcc_transform_name=`cat conftestsed.out`
5650 rm -f conftestsed.out
5651 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5652
5653 # For the build-side libraries, we just need to pretend we're native,
5654 # and not use the same cache file.  Multilibs are neither needed nor
5655 # desired.
5656 build_configargs="--cache-file=../config.cache ${baseargs}"
5657
5658 # For host modules, accept cache file option, or specification as blank.
5659 case "${cache_file}" in
5660 "") # empty
5661   cache_file_option="" ;;
5662 /* | [A-Za-z]:[\\/]* ) # absolute path
5663   cache_file_option="--cache-file=${cache_file}" ;;
5664 *) # relative path
5665   cache_file_option="--cache-file=../${cache_file}" ;;
5666 esac
5667
5668 # Host dirs don't like to share a cache file either, horribly enough.
5669 # This seems to be due to autoconf 2.5x stupidity.
5670 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5671
5672 target_configargs=${baseargs}
5673
5674 # Passing a --with-cross-host argument lets the target libraries know
5675 # whether they are being built with a cross-compiler or being built
5676 # native.  However, it would be better to use other mechanisms to make the
5677 # sorts of decisions they want to make on this basis.  Please consider
5678 # this option to be deprecated.  FIXME.
5679 if test x${is_cross_compiler} = xyes ; then
5680   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5681 fi
5682
5683 # Default to --enable-multilib.
5684 if test x${enable_multilib} = x ; then
5685   target_configargs="--enable-multilib ${target_configargs}"
5686 fi
5687
5688 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5689 # changed from the earlier setting of with_newlib.
5690 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5691   target_configargs="--with-newlib ${target_configargs}"
5692 fi
5693
5694 # Different target subdirs use different values of certain variables
5695 # (notably CXX).  Worse, multilibs use *lots* of different values.
5696 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5697 # it doesn't automatically accept command-line overrides of them.
5698 # This means it's not safe for target subdirs to share a cache file,
5699 # which is disgusting, but there you have it.  Hopefully this can be
5700 # fixed in future.  It's still worthwhile to use a cache file for each
5701 # directory.  I think.
5702
5703 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5704 # We need to pass --target, as newer autoconf's requires consistency
5705 # for target_alias and gcc doesn't manage it consistently.
5706 target_configargs="--cache-file=./config.cache ${target_configargs}"
5707
5708 FLAGS_FOR_TARGET=
5709 case " $target_configdirs " in
5710  *" newlib "*)
5711   case " $target_configargs " in
5712   *" --with-newlib "*)
5713    case "$target" in
5714    *-cygwin*)
5715      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' ;;
5716    esac
5717
5718    # If we're not building GCC, don't discard standard headers.
5719    if test -d ${srcdir}/gcc; then
5720      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5721
5722      if test "${build}" != "${host}"; then
5723        # On Canadian crosses, CC_FOR_TARGET will have already been set
5724        # by `configure', so we won't have an opportunity to add -Bgcc/
5725        # to it.  This is right: we don't want to search that directory
5726        # for binaries, but we want the header files in there, so add
5727        # them explicitly.
5728        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5729
5730        # Someone might think of using the pre-installed headers on
5731        # Canadian crosses, in case the installed compiler is not fully
5732        # compatible with the compiler being built.  In this case, it
5733        # would be better to flag an error than risking having
5734        # incompatible object files being constructed.  We can't
5735        # guarantee that an error will be flagged, but let's hope the
5736        # compiler will do it, when presented with incompatible header
5737        # files.
5738      fi
5739    fi
5740
5741    case "${target}-${is_cross_compiler}" in
5742    i[3456789]86-*-linux*-no)
5743       # Here host == target, so we don't need to build gcc,
5744       # so we don't want to discard standard headers.
5745       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5746       ;;
5747    *)
5748       # If we're building newlib, use its generic headers last, but search
5749       # for any libc-related directories first (so make it the last -B
5750       # switch).
5751       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5752       ;;
5753    esac
5754    ;;
5755   esac
5756   ;;
5757 esac
5758 case "$target" in
5759 *-mingw*)
5760   # Can't be handled as Cygwin above since Mingw does not use newlib.
5761   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' ;;
5762 esac
5763
5764 # Allow the user to override the flags for
5765 # our build compiler if desired.
5766 CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5767
5768 # On Canadian crosses, we'll be searching the right directories for
5769 # the previously-installed cross compiler, so don't bother to add
5770 # flags for directories within the install tree of the compiler
5771 # being built; programs in there won't even run.
5772 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5773   # Search for pre-installed headers if nothing else fits.
5774   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5775 fi
5776
5777 if test "x${use_gnu_ld}" = x &&
5778    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5779   # Arrange for us to find uninstalled linker scripts.
5780   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5781 fi
5782
5783 # Search for other target-specific linker scripts and such.
5784 case "${target}" in
5785   m32c-*-* )
5786     if test -d ${srcdir}/libgloss/m32c; then
5787       # This is for crt0.o
5788       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/m32c'
5789       # This is for r8c.ld
5790       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/m32c'
5791       # This is for libnosys.a
5792       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5793     fi
5794     ;;
5795   mep*)
5796     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5797     ;;
5798 esac
5799
5800 # Makefile fragments.
5801 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5802 do
5803   eval fragval=\$$frag
5804   if test $fragval != /dev/null; then
5805     eval $frag=${srcdir}/$fragval
5806   fi
5807 done
5808
5809
5810
5811
5812
5813 # Miscellanea: directories, flags, etc.
5814
5815
5816
5817
5818
5819
5820
5821 # Build module lists & subconfigure args.
5822
5823
5824
5825 # Host module lists & subconfigure args.
5826
5827
5828
5829 # Target module lists & subconfigure args.
5830
5831
5832
5833 # Build tools.
5834
5835
5836
5837 # Generate default definitions for YACC, M4, LEX and other programs that run
5838 # on the build machine.  These are used if the Makefile can't locate these
5839 # programs in objdir.
5840 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
5841
5842 for ac_prog in 'bison -y' byacc yacc
5843 do
5844   # Extract the first word of "$ac_prog", so it can be a program name with args.
5845 set dummy $ac_prog; ac_word=$2
5846 echo "$as_me:$LINENO: checking for $ac_word" >&5
5847 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5848 if test "${ac_cv_prog_YACC+set}" = set; then
5849   echo $ECHO_N "(cached) $ECHO_C" >&6
5850 else
5851   if test -n "$YACC"; then
5852   ac_cv_prog_YACC="$YACC" # Let the user override the test.
5853 else
5854 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5855 for as_dir in $PATH
5856 do
5857   IFS=$as_save_IFS
5858   test -z "$as_dir" && as_dir=.
5859   for ac_exec_ext in '' $ac_executable_extensions; do
5860   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5861     ac_cv_prog_YACC="$ac_prog"
5862     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5863     break 2
5864   fi
5865 done
5866 done
5867
5868 fi
5869 fi
5870 YACC=$ac_cv_prog_YACC
5871 if test -n "$YACC"; then
5872   echo "$as_me:$LINENO: result: $YACC" >&5
5873 echo "${ECHO_T}$YACC" >&6
5874 else
5875   echo "$as_me:$LINENO: result: no" >&5
5876 echo "${ECHO_T}no" >&6
5877 fi
5878
5879   test -n "$YACC" && break
5880 done
5881 test -n "$YACC" || YACC="$MISSING bison -y"
5882
5883 case " $build_configdirs " in
5884   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
5885   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
5886 esac
5887
5888 for ac_prog in bison
5889 do
5890   # Extract the first word of "$ac_prog", so it can be a program name with args.
5891 set dummy $ac_prog; ac_word=$2
5892 echo "$as_me:$LINENO: checking for $ac_word" >&5
5893 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5894 if test "${ac_cv_prog_BISON+set}" = set; then
5895   echo $ECHO_N "(cached) $ECHO_C" >&6
5896 else
5897   if test -n "$BISON"; then
5898   ac_cv_prog_BISON="$BISON" # Let the user override the test.
5899 else
5900 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5901 for as_dir in $PATH
5902 do
5903   IFS=$as_save_IFS
5904   test -z "$as_dir" && as_dir=.
5905   for ac_exec_ext in '' $ac_executable_extensions; do
5906   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5907     ac_cv_prog_BISON="$ac_prog"
5908     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5909     break 2
5910   fi
5911 done
5912 done
5913
5914 fi
5915 fi
5916 BISON=$ac_cv_prog_BISON
5917 if test -n "$BISON"; then
5918   echo "$as_me:$LINENO: result: $BISON" >&5
5919 echo "${ECHO_T}$BISON" >&6
5920 else
5921   echo "$as_me:$LINENO: result: no" >&5
5922 echo "${ECHO_T}no" >&6
5923 fi
5924
5925   test -n "$BISON" && break
5926 done
5927 test -n "$BISON" || BISON="$MISSING bison"
5928
5929 case " $build_configdirs " in
5930   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
5931 esac
5932
5933 for ac_prog in gm4 gnum4 m4
5934 do
5935   # Extract the first word of "$ac_prog", so it can be a program name with args.
5936 set dummy $ac_prog; ac_word=$2
5937 echo "$as_me:$LINENO: checking for $ac_word" >&5
5938 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5939 if test "${ac_cv_prog_M4+set}" = set; then
5940   echo $ECHO_N "(cached) $ECHO_C" >&6
5941 else
5942   if test -n "$M4"; then
5943   ac_cv_prog_M4="$M4" # Let the user override the test.
5944 else
5945 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5946 for as_dir in $PATH
5947 do
5948   IFS=$as_save_IFS
5949   test -z "$as_dir" && as_dir=.
5950   for ac_exec_ext in '' $ac_executable_extensions; do
5951   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5952     ac_cv_prog_M4="$ac_prog"
5953     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5954     break 2
5955   fi
5956 done
5957 done
5958
5959 fi
5960 fi
5961 M4=$ac_cv_prog_M4
5962 if test -n "$M4"; then
5963   echo "$as_me:$LINENO: result: $M4" >&5
5964 echo "${ECHO_T}$M4" >&6
5965 else
5966   echo "$as_me:$LINENO: result: no" >&5
5967 echo "${ECHO_T}no" >&6
5968 fi
5969
5970   test -n "$M4" && break
5971 done
5972 test -n "$M4" || M4="$MISSING m4"
5973
5974 case " $build_configdirs " in
5975   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
5976 esac
5977
5978 for ac_prog in flex lex
5979 do
5980   # Extract the first word of "$ac_prog", so it can be a program name with args.
5981 set dummy $ac_prog; ac_word=$2
5982 echo "$as_me:$LINENO: checking for $ac_word" >&5
5983 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5984 if test "${ac_cv_prog_LEX+set}" = set; then
5985   echo $ECHO_N "(cached) $ECHO_C" >&6
5986 else
5987   if test -n "$LEX"; then
5988   ac_cv_prog_LEX="$LEX" # Let the user override the test.
5989 else
5990 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5991 for as_dir in $PATH
5992 do
5993   IFS=$as_save_IFS
5994   test -z "$as_dir" && as_dir=.
5995   for ac_exec_ext in '' $ac_executable_extensions; do
5996   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5997     ac_cv_prog_LEX="$ac_prog"
5998     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5999     break 2
6000   fi
6001 done
6002 done
6003
6004 fi
6005 fi
6006 LEX=$ac_cv_prog_LEX
6007 if test -n "$LEX"; then
6008   echo "$as_me:$LINENO: result: $LEX" >&5
6009 echo "${ECHO_T}$LEX" >&6
6010 else
6011   echo "$as_me:$LINENO: result: no" >&5
6012 echo "${ECHO_T}no" >&6
6013 fi
6014
6015   test -n "$LEX" && break
6016 done
6017 test -n "$LEX" || LEX="$MISSING flex"
6018
6019 case " $build_configdirs " in
6020   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6021   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6022 esac
6023
6024 for ac_prog in flex
6025 do
6026   # Extract the first word of "$ac_prog", so it can be a program name with args.
6027 set dummy $ac_prog; ac_word=$2
6028 echo "$as_me:$LINENO: checking for $ac_word" >&5
6029 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6030 if test "${ac_cv_prog_FLEX+set}" = set; then
6031   echo $ECHO_N "(cached) $ECHO_C" >&6
6032 else
6033   if test -n "$FLEX"; then
6034   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6035 else
6036 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6037 for as_dir in $PATH
6038 do
6039   IFS=$as_save_IFS
6040   test -z "$as_dir" && as_dir=.
6041   for ac_exec_ext in '' $ac_executable_extensions; do
6042   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6043     ac_cv_prog_FLEX="$ac_prog"
6044     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6045     break 2
6046   fi
6047 done
6048 done
6049
6050 fi
6051 fi
6052 FLEX=$ac_cv_prog_FLEX
6053 if test -n "$FLEX"; then
6054   echo "$as_me:$LINENO: result: $FLEX" >&5
6055 echo "${ECHO_T}$FLEX" >&6
6056 else
6057   echo "$as_me:$LINENO: result: no" >&5
6058 echo "${ECHO_T}no" >&6
6059 fi
6060
6061   test -n "$FLEX" && break
6062 done
6063 test -n "$FLEX" || FLEX="$MISSING flex"
6064
6065 case " $build_configdirs " in
6066   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6067 esac
6068
6069 for ac_prog in makeinfo
6070 do
6071   # Extract the first word of "$ac_prog", so it can be a program name with args.
6072 set dummy $ac_prog; ac_word=$2
6073 echo "$as_me:$LINENO: checking for $ac_word" >&5
6074 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6075 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6076   echo $ECHO_N "(cached) $ECHO_C" >&6
6077 else
6078   if test -n "$MAKEINFO"; then
6079   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6080 else
6081 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6082 for as_dir in $PATH
6083 do
6084   IFS=$as_save_IFS
6085   test -z "$as_dir" && as_dir=.
6086   for ac_exec_ext in '' $ac_executable_extensions; do
6087   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6088     ac_cv_prog_MAKEINFO="$ac_prog"
6089     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6090     break 2
6091   fi
6092 done
6093 done
6094
6095 fi
6096 fi
6097 MAKEINFO=$ac_cv_prog_MAKEINFO
6098 if test -n "$MAKEINFO"; then
6099   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6100 echo "${ECHO_T}$MAKEINFO" >&6
6101 else
6102   echo "$as_me:$LINENO: result: no" >&5
6103 echo "${ECHO_T}no" >&6
6104 fi
6105
6106   test -n "$MAKEINFO" && break
6107 done
6108 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6109
6110 case " $build_configdirs " in
6111   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6112   *)
6113
6114     # For an installed makeinfo, we require it to be from texinfo 4.4 or
6115     # higher, else we use the "missing" dummy.
6116     if ${MAKEINFO} --version \
6117        | egrep 'texinfo[^0-9]*([1-3][0-9]|4\.[4-9]|[5-9])' >/dev/null 2>&1; then
6118       :
6119     else
6120       MAKEINFO="$MISSING makeinfo"
6121     fi
6122     ;;
6123
6124 esac
6125
6126 # FIXME: expect and dejagnu may become build tools?
6127
6128 for ac_prog in expect
6129 do
6130   # Extract the first word of "$ac_prog", so it can be a program name with args.
6131 set dummy $ac_prog; ac_word=$2
6132 echo "$as_me:$LINENO: checking for $ac_word" >&5
6133 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6134 if test "${ac_cv_prog_EXPECT+set}" = set; then
6135   echo $ECHO_N "(cached) $ECHO_C" >&6
6136 else
6137   if test -n "$EXPECT"; then
6138   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6139 else
6140 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6141 for as_dir in $PATH
6142 do
6143   IFS=$as_save_IFS
6144   test -z "$as_dir" && as_dir=.
6145   for ac_exec_ext in '' $ac_executable_extensions; do
6146   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6147     ac_cv_prog_EXPECT="$ac_prog"
6148     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6149     break 2
6150   fi
6151 done
6152 done
6153
6154 fi
6155 fi
6156 EXPECT=$ac_cv_prog_EXPECT
6157 if test -n "$EXPECT"; then
6158   echo "$as_me:$LINENO: result: $EXPECT" >&5
6159 echo "${ECHO_T}$EXPECT" >&6
6160 else
6161   echo "$as_me:$LINENO: result: no" >&5
6162 echo "${ECHO_T}no" >&6
6163 fi
6164
6165   test -n "$EXPECT" && break
6166 done
6167 test -n "$EXPECT" || EXPECT="expect"
6168
6169 case " $configdirs " in
6170   *" expect "*)
6171     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6172     ;;
6173 esac
6174
6175 for ac_prog in runtest
6176 do
6177   # Extract the first word of "$ac_prog", so it can be a program name with args.
6178 set dummy $ac_prog; ac_word=$2
6179 echo "$as_me:$LINENO: checking for $ac_word" >&5
6180 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6181 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6182   echo $ECHO_N "(cached) $ECHO_C" >&6
6183 else
6184   if test -n "$RUNTEST"; then
6185   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6186 else
6187 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6188 for as_dir in $PATH
6189 do
6190   IFS=$as_save_IFS
6191   test -z "$as_dir" && as_dir=.
6192   for ac_exec_ext in '' $ac_executable_extensions; do
6193   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6194     ac_cv_prog_RUNTEST="$ac_prog"
6195     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6196     break 2
6197   fi
6198 done
6199 done
6200
6201 fi
6202 fi
6203 RUNTEST=$ac_cv_prog_RUNTEST
6204 if test -n "$RUNTEST"; then
6205   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6206 echo "${ECHO_T}$RUNTEST" >&6
6207 else
6208   echo "$as_me:$LINENO: result: no" >&5
6209 echo "${ECHO_T}no" >&6
6210 fi
6211
6212   test -n "$RUNTEST" && break
6213 done
6214 test -n "$RUNTEST" || RUNTEST="runtest"
6215
6216 case " $configdirs " in
6217   *" dejagnu "*)
6218     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6219     ;;
6220 esac
6221
6222
6223 # Host tools.
6224 ncn_tool_prefix=
6225 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6226 ncn_target_tool_prefix=
6227 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6228
6229
6230
6231 if test -n "$AR"; then
6232   ac_cv_prog_AR=$AR
6233 elif test -n "$ac_cv_prog_AR"; then
6234   AR=$ac_cv_prog_AR
6235 fi
6236
6237 if test -n "$ac_cv_prog_AR"; then
6238   for ncn_progname in ar; do
6239     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6240 set dummy ${ncn_progname}; ac_word=$2
6241 echo "$as_me:$LINENO: checking for $ac_word" >&5
6242 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6243 if test "${ac_cv_prog_AR+set}" = set; then
6244   echo $ECHO_N "(cached) $ECHO_C" >&6
6245 else
6246   if test -n "$AR"; then
6247   ac_cv_prog_AR="$AR" # Let the user override the test.
6248 else
6249 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6250 for as_dir in $PATH
6251 do
6252   IFS=$as_save_IFS
6253   test -z "$as_dir" && as_dir=.
6254   for ac_exec_ext in '' $ac_executable_extensions; do
6255   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6256     ac_cv_prog_AR="${ncn_progname}"
6257     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6258     break 2
6259   fi
6260 done
6261 done
6262
6263 fi
6264 fi
6265 AR=$ac_cv_prog_AR
6266 if test -n "$AR"; then
6267   echo "$as_me:$LINENO: result: $AR" >&5
6268 echo "${ECHO_T}$AR" >&6
6269 else
6270   echo "$as_me:$LINENO: result: no" >&5
6271 echo "${ECHO_T}no" >&6
6272 fi
6273
6274   done
6275 fi
6276
6277 for ncn_progname in ar; do
6278   if test -n "$ncn_tool_prefix"; then
6279     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6280 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6281 echo "$as_me:$LINENO: checking for $ac_word" >&5
6282 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6283 if test "${ac_cv_prog_AR+set}" = set; then
6284   echo $ECHO_N "(cached) $ECHO_C" >&6
6285 else
6286   if test -n "$AR"; then
6287   ac_cv_prog_AR="$AR" # Let the user override the test.
6288 else
6289 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6290 for as_dir in $PATH
6291 do
6292   IFS=$as_save_IFS
6293   test -z "$as_dir" && as_dir=.
6294   for ac_exec_ext in '' $ac_executable_extensions; do
6295   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6296     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6297     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6298     break 2
6299   fi
6300 done
6301 done
6302
6303 fi
6304 fi
6305 AR=$ac_cv_prog_AR
6306 if test -n "$AR"; then
6307   echo "$as_me:$LINENO: result: $AR" >&5
6308 echo "${ECHO_T}$AR" >&6
6309 else
6310   echo "$as_me:$LINENO: result: no" >&5
6311 echo "${ECHO_T}no" >&6
6312 fi
6313
6314   fi
6315   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6316     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6317 set dummy ${ncn_progname}; ac_word=$2
6318 echo "$as_me:$LINENO: checking for $ac_word" >&5
6319 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6320 if test "${ac_cv_prog_AR+set}" = set; then
6321   echo $ECHO_N "(cached) $ECHO_C" >&6
6322 else
6323   if test -n "$AR"; then
6324   ac_cv_prog_AR="$AR" # Let the user override the test.
6325 else
6326 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6327 for as_dir in $PATH
6328 do
6329   IFS=$as_save_IFS
6330   test -z "$as_dir" && as_dir=.
6331   for ac_exec_ext in '' $ac_executable_extensions; do
6332   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6333     ac_cv_prog_AR="${ncn_progname}"
6334     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6335     break 2
6336   fi
6337 done
6338 done
6339
6340 fi
6341 fi
6342 AR=$ac_cv_prog_AR
6343 if test -n "$AR"; then
6344   echo "$as_me:$LINENO: result: $AR" >&5
6345 echo "${ECHO_T}$AR" >&6
6346 else
6347   echo "$as_me:$LINENO: result: no" >&5
6348 echo "${ECHO_T}no" >&6
6349 fi
6350
6351   fi
6352   test -n "$ac_cv_prog_AR" && break
6353 done
6354
6355 if test -z "$ac_cv_prog_AR" ; then
6356   set dummy ar
6357   if test $build = $host ; then
6358     AR="$2"
6359   else
6360     AR="${ncn_tool_prefix}$2"
6361   fi
6362 fi
6363
6364
6365
6366 if test -n "$AS"; then
6367   ac_cv_prog_AS=$AS
6368 elif test -n "$ac_cv_prog_AS"; then
6369   AS=$ac_cv_prog_AS
6370 fi
6371
6372 if test -n "$ac_cv_prog_AS"; then
6373   for ncn_progname in as; do
6374     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6375 set dummy ${ncn_progname}; ac_word=$2
6376 echo "$as_me:$LINENO: checking for $ac_word" >&5
6377 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6378 if test "${ac_cv_prog_AS+set}" = set; then
6379   echo $ECHO_N "(cached) $ECHO_C" >&6
6380 else
6381   if test -n "$AS"; then
6382   ac_cv_prog_AS="$AS" # Let the user override the test.
6383 else
6384 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6385 for as_dir in $PATH
6386 do
6387   IFS=$as_save_IFS
6388   test -z "$as_dir" && as_dir=.
6389   for ac_exec_ext in '' $ac_executable_extensions; do
6390   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6391     ac_cv_prog_AS="${ncn_progname}"
6392     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6393     break 2
6394   fi
6395 done
6396 done
6397
6398 fi
6399 fi
6400 AS=$ac_cv_prog_AS
6401 if test -n "$AS"; then
6402   echo "$as_me:$LINENO: result: $AS" >&5
6403 echo "${ECHO_T}$AS" >&6
6404 else
6405   echo "$as_me:$LINENO: result: no" >&5
6406 echo "${ECHO_T}no" >&6
6407 fi
6408
6409   done
6410 fi
6411
6412 for ncn_progname in as; do
6413   if test -n "$ncn_tool_prefix"; then
6414     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6415 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6416 echo "$as_me:$LINENO: checking for $ac_word" >&5
6417 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6418 if test "${ac_cv_prog_AS+set}" = set; then
6419   echo $ECHO_N "(cached) $ECHO_C" >&6
6420 else
6421   if test -n "$AS"; then
6422   ac_cv_prog_AS="$AS" # Let the user override the test.
6423 else
6424 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6425 for as_dir in $PATH
6426 do
6427   IFS=$as_save_IFS
6428   test -z "$as_dir" && as_dir=.
6429   for ac_exec_ext in '' $ac_executable_extensions; do
6430   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6431     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6432     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6433     break 2
6434   fi
6435 done
6436 done
6437
6438 fi
6439 fi
6440 AS=$ac_cv_prog_AS
6441 if test -n "$AS"; then
6442   echo "$as_me:$LINENO: result: $AS" >&5
6443 echo "${ECHO_T}$AS" >&6
6444 else
6445   echo "$as_me:$LINENO: result: no" >&5
6446 echo "${ECHO_T}no" >&6
6447 fi
6448
6449   fi
6450   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6451     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6452 set dummy ${ncn_progname}; ac_word=$2
6453 echo "$as_me:$LINENO: checking for $ac_word" >&5
6454 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6455 if test "${ac_cv_prog_AS+set}" = set; then
6456   echo $ECHO_N "(cached) $ECHO_C" >&6
6457 else
6458   if test -n "$AS"; then
6459   ac_cv_prog_AS="$AS" # Let the user override the test.
6460 else
6461 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6462 for as_dir in $PATH
6463 do
6464   IFS=$as_save_IFS
6465   test -z "$as_dir" && as_dir=.
6466   for ac_exec_ext in '' $ac_executable_extensions; do
6467   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6468     ac_cv_prog_AS="${ncn_progname}"
6469     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6470     break 2
6471   fi
6472 done
6473 done
6474
6475 fi
6476 fi
6477 AS=$ac_cv_prog_AS
6478 if test -n "$AS"; then
6479   echo "$as_me:$LINENO: result: $AS" >&5
6480 echo "${ECHO_T}$AS" >&6
6481 else
6482   echo "$as_me:$LINENO: result: no" >&5
6483 echo "${ECHO_T}no" >&6
6484 fi
6485
6486   fi
6487   test -n "$ac_cv_prog_AS" && break
6488 done
6489
6490 if test -z "$ac_cv_prog_AS" ; then
6491   set dummy as
6492   if test $build = $host ; then
6493     AS="$2"
6494   else
6495     AS="${ncn_tool_prefix}$2"
6496   fi
6497 fi
6498
6499
6500
6501 if test -n "$DLLTOOL"; then
6502   ac_cv_prog_DLLTOOL=$DLLTOOL
6503 elif test -n "$ac_cv_prog_DLLTOOL"; then
6504   DLLTOOL=$ac_cv_prog_DLLTOOL
6505 fi
6506
6507 if test -n "$ac_cv_prog_DLLTOOL"; then
6508   for ncn_progname in dlltool; do
6509     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6510 set dummy ${ncn_progname}; ac_word=$2
6511 echo "$as_me:$LINENO: checking for $ac_word" >&5
6512 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6513 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6514   echo $ECHO_N "(cached) $ECHO_C" >&6
6515 else
6516   if test -n "$DLLTOOL"; then
6517   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6518 else
6519 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6520 for as_dir in $PATH
6521 do
6522   IFS=$as_save_IFS
6523   test -z "$as_dir" && as_dir=.
6524   for ac_exec_ext in '' $ac_executable_extensions; do
6525   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6526     ac_cv_prog_DLLTOOL="${ncn_progname}"
6527     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6528     break 2
6529   fi
6530 done
6531 done
6532
6533 fi
6534 fi
6535 DLLTOOL=$ac_cv_prog_DLLTOOL
6536 if test -n "$DLLTOOL"; then
6537   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6538 echo "${ECHO_T}$DLLTOOL" >&6
6539 else
6540   echo "$as_me:$LINENO: result: no" >&5
6541 echo "${ECHO_T}no" >&6
6542 fi
6543
6544   done
6545 fi
6546
6547 for ncn_progname in dlltool; do
6548   if test -n "$ncn_tool_prefix"; then
6549     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6550 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6551 echo "$as_me:$LINENO: checking for $ac_word" >&5
6552 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6553 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6554   echo $ECHO_N "(cached) $ECHO_C" >&6
6555 else
6556   if test -n "$DLLTOOL"; then
6557   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6558 else
6559 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6560 for as_dir in $PATH
6561 do
6562   IFS=$as_save_IFS
6563   test -z "$as_dir" && as_dir=.
6564   for ac_exec_ext in '' $ac_executable_extensions; do
6565   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6566     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6567     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6568     break 2
6569   fi
6570 done
6571 done
6572
6573 fi
6574 fi
6575 DLLTOOL=$ac_cv_prog_DLLTOOL
6576 if test -n "$DLLTOOL"; then
6577   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6578 echo "${ECHO_T}$DLLTOOL" >&6
6579 else
6580   echo "$as_me:$LINENO: result: no" >&5
6581 echo "${ECHO_T}no" >&6
6582 fi
6583
6584   fi
6585   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6586     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6587 set dummy ${ncn_progname}; ac_word=$2
6588 echo "$as_me:$LINENO: checking for $ac_word" >&5
6589 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6590 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6591   echo $ECHO_N "(cached) $ECHO_C" >&6
6592 else
6593   if test -n "$DLLTOOL"; then
6594   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6595 else
6596 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6597 for as_dir in $PATH
6598 do
6599   IFS=$as_save_IFS
6600   test -z "$as_dir" && as_dir=.
6601   for ac_exec_ext in '' $ac_executable_extensions; do
6602   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6603     ac_cv_prog_DLLTOOL="${ncn_progname}"
6604     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6605     break 2
6606   fi
6607 done
6608 done
6609
6610 fi
6611 fi
6612 DLLTOOL=$ac_cv_prog_DLLTOOL
6613 if test -n "$DLLTOOL"; then
6614   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6615 echo "${ECHO_T}$DLLTOOL" >&6
6616 else
6617   echo "$as_me:$LINENO: result: no" >&5
6618 echo "${ECHO_T}no" >&6
6619 fi
6620
6621   fi
6622   test -n "$ac_cv_prog_DLLTOOL" && break
6623 done
6624
6625 if test -z "$ac_cv_prog_DLLTOOL" ; then
6626   set dummy dlltool
6627   if test $build = $host ; then
6628     DLLTOOL="$2"
6629   else
6630     DLLTOOL="${ncn_tool_prefix}$2"
6631   fi
6632 fi
6633
6634
6635
6636 if test -n "$LD"; then
6637   ac_cv_prog_LD=$LD
6638 elif test -n "$ac_cv_prog_LD"; then
6639   LD=$ac_cv_prog_LD
6640 fi
6641
6642 if test -n "$ac_cv_prog_LD"; then
6643   for ncn_progname in ld; do
6644     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6645 set dummy ${ncn_progname}; ac_word=$2
6646 echo "$as_me:$LINENO: checking for $ac_word" >&5
6647 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6648 if test "${ac_cv_prog_LD+set}" = set; then
6649   echo $ECHO_N "(cached) $ECHO_C" >&6
6650 else
6651   if test -n "$LD"; then
6652   ac_cv_prog_LD="$LD" # Let the user override the test.
6653 else
6654 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6655 for as_dir in $PATH
6656 do
6657   IFS=$as_save_IFS
6658   test -z "$as_dir" && as_dir=.
6659   for ac_exec_ext in '' $ac_executable_extensions; do
6660   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6661     ac_cv_prog_LD="${ncn_progname}"
6662     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6663     break 2
6664   fi
6665 done
6666 done
6667
6668 fi
6669 fi
6670 LD=$ac_cv_prog_LD
6671 if test -n "$LD"; then
6672   echo "$as_me:$LINENO: result: $LD" >&5
6673 echo "${ECHO_T}$LD" >&6
6674 else
6675   echo "$as_me:$LINENO: result: no" >&5
6676 echo "${ECHO_T}no" >&6
6677 fi
6678
6679   done
6680 fi
6681
6682 for ncn_progname in ld; do
6683   if test -n "$ncn_tool_prefix"; then
6684     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6685 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6686 echo "$as_me:$LINENO: checking for $ac_word" >&5
6687 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6688 if test "${ac_cv_prog_LD+set}" = set; then
6689   echo $ECHO_N "(cached) $ECHO_C" >&6
6690 else
6691   if test -n "$LD"; then
6692   ac_cv_prog_LD="$LD" # Let the user override the test.
6693 else
6694 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6695 for as_dir in $PATH
6696 do
6697   IFS=$as_save_IFS
6698   test -z "$as_dir" && as_dir=.
6699   for ac_exec_ext in '' $ac_executable_extensions; do
6700   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6701     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6702     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6703     break 2
6704   fi
6705 done
6706 done
6707
6708 fi
6709 fi
6710 LD=$ac_cv_prog_LD
6711 if test -n "$LD"; then
6712   echo "$as_me:$LINENO: result: $LD" >&5
6713 echo "${ECHO_T}$LD" >&6
6714 else
6715   echo "$as_me:$LINENO: result: no" >&5
6716 echo "${ECHO_T}no" >&6
6717 fi
6718
6719   fi
6720   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6721     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6722 set dummy ${ncn_progname}; ac_word=$2
6723 echo "$as_me:$LINENO: checking for $ac_word" >&5
6724 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6725 if test "${ac_cv_prog_LD+set}" = set; then
6726   echo $ECHO_N "(cached) $ECHO_C" >&6
6727 else
6728   if test -n "$LD"; then
6729   ac_cv_prog_LD="$LD" # Let the user override the test.
6730 else
6731 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6732 for as_dir in $PATH
6733 do
6734   IFS=$as_save_IFS
6735   test -z "$as_dir" && as_dir=.
6736   for ac_exec_ext in '' $ac_executable_extensions; do
6737   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6738     ac_cv_prog_LD="${ncn_progname}"
6739     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6740     break 2
6741   fi
6742 done
6743 done
6744
6745 fi
6746 fi
6747 LD=$ac_cv_prog_LD
6748 if test -n "$LD"; then
6749   echo "$as_me:$LINENO: result: $LD" >&5
6750 echo "${ECHO_T}$LD" >&6
6751 else
6752   echo "$as_me:$LINENO: result: no" >&5
6753 echo "${ECHO_T}no" >&6
6754 fi
6755
6756   fi
6757   test -n "$ac_cv_prog_LD" && break
6758 done
6759
6760 if test -z "$ac_cv_prog_LD" ; then
6761   set dummy ld
6762   if test $build = $host ; then
6763     LD="$2"
6764   else
6765     LD="${ncn_tool_prefix}$2"
6766   fi
6767 fi
6768
6769
6770
6771 if test -n "$LIPO"; then
6772   ac_cv_prog_LIPO=$LIPO
6773 elif test -n "$ac_cv_prog_LIPO"; then
6774   LIPO=$ac_cv_prog_LIPO
6775 fi
6776
6777 if test -n "$ac_cv_prog_LIPO"; then
6778   for ncn_progname in lipo; do
6779     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6780 set dummy ${ncn_progname}; ac_word=$2
6781 echo "$as_me:$LINENO: checking for $ac_word" >&5
6782 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6783 if test "${ac_cv_prog_LIPO+set}" = set; then
6784   echo $ECHO_N "(cached) $ECHO_C" >&6
6785 else
6786   if test -n "$LIPO"; then
6787   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6788 else
6789 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6790 for as_dir in $PATH
6791 do
6792   IFS=$as_save_IFS
6793   test -z "$as_dir" && as_dir=.
6794   for ac_exec_ext in '' $ac_executable_extensions; do
6795   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6796     ac_cv_prog_LIPO="${ncn_progname}"
6797     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6798     break 2
6799   fi
6800 done
6801 done
6802
6803 fi
6804 fi
6805 LIPO=$ac_cv_prog_LIPO
6806 if test -n "$LIPO"; then
6807   echo "$as_me:$LINENO: result: $LIPO" >&5
6808 echo "${ECHO_T}$LIPO" >&6
6809 else
6810   echo "$as_me:$LINENO: result: no" >&5
6811 echo "${ECHO_T}no" >&6
6812 fi
6813
6814   done
6815 fi
6816
6817 for ncn_progname in lipo; do
6818   if test -n "$ncn_tool_prefix"; then
6819     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6820 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6821 echo "$as_me:$LINENO: checking for $ac_word" >&5
6822 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6823 if test "${ac_cv_prog_LIPO+set}" = set; then
6824   echo $ECHO_N "(cached) $ECHO_C" >&6
6825 else
6826   if test -n "$LIPO"; then
6827   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6828 else
6829 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6830 for as_dir in $PATH
6831 do
6832   IFS=$as_save_IFS
6833   test -z "$as_dir" && as_dir=.
6834   for ac_exec_ext in '' $ac_executable_extensions; do
6835   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6836     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
6837     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6838     break 2
6839   fi
6840 done
6841 done
6842
6843 fi
6844 fi
6845 LIPO=$ac_cv_prog_LIPO
6846 if test -n "$LIPO"; then
6847   echo "$as_me:$LINENO: result: $LIPO" >&5
6848 echo "${ECHO_T}$LIPO" >&6
6849 else
6850   echo "$as_me:$LINENO: result: no" >&5
6851 echo "${ECHO_T}no" >&6
6852 fi
6853
6854   fi
6855   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
6856     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6857 set dummy ${ncn_progname}; ac_word=$2
6858 echo "$as_me:$LINENO: checking for $ac_word" >&5
6859 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6860 if test "${ac_cv_prog_LIPO+set}" = set; then
6861   echo $ECHO_N "(cached) $ECHO_C" >&6
6862 else
6863   if test -n "$LIPO"; then
6864   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6865 else
6866 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6867 for as_dir in $PATH
6868 do
6869   IFS=$as_save_IFS
6870   test -z "$as_dir" && as_dir=.
6871   for ac_exec_ext in '' $ac_executable_extensions; do
6872   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6873     ac_cv_prog_LIPO="${ncn_progname}"
6874     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6875     break 2
6876   fi
6877 done
6878 done
6879
6880 fi
6881 fi
6882 LIPO=$ac_cv_prog_LIPO
6883 if test -n "$LIPO"; then
6884   echo "$as_me:$LINENO: result: $LIPO" >&5
6885 echo "${ECHO_T}$LIPO" >&6
6886 else
6887   echo "$as_me:$LINENO: result: no" >&5
6888 echo "${ECHO_T}no" >&6
6889 fi
6890
6891   fi
6892   test -n "$ac_cv_prog_LIPO" && break
6893 done
6894
6895 if test -z "$ac_cv_prog_LIPO" ; then
6896   set dummy lipo
6897   if test $build = $host ; then
6898     LIPO="$2"
6899   else
6900     LIPO="${ncn_tool_prefix}$2"
6901   fi
6902 fi
6903
6904
6905
6906 if test -n "$NM"; then
6907   ac_cv_prog_NM=$NM
6908 elif test -n "$ac_cv_prog_NM"; then
6909   NM=$ac_cv_prog_NM
6910 fi
6911
6912 if test -n "$ac_cv_prog_NM"; then
6913   for ncn_progname in nm; do
6914     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6915 set dummy ${ncn_progname}; ac_word=$2
6916 echo "$as_me:$LINENO: checking for $ac_word" >&5
6917 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6918 if test "${ac_cv_prog_NM+set}" = set; then
6919   echo $ECHO_N "(cached) $ECHO_C" >&6
6920 else
6921   if test -n "$NM"; then
6922   ac_cv_prog_NM="$NM" # Let the user override the test.
6923 else
6924 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6925 for as_dir in $PATH
6926 do
6927   IFS=$as_save_IFS
6928   test -z "$as_dir" && as_dir=.
6929   for ac_exec_ext in '' $ac_executable_extensions; do
6930   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6931     ac_cv_prog_NM="${ncn_progname}"
6932     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6933     break 2
6934   fi
6935 done
6936 done
6937
6938 fi
6939 fi
6940 NM=$ac_cv_prog_NM
6941 if test -n "$NM"; then
6942   echo "$as_me:$LINENO: result: $NM" >&5
6943 echo "${ECHO_T}$NM" >&6
6944 else
6945   echo "$as_me:$LINENO: result: no" >&5
6946 echo "${ECHO_T}no" >&6
6947 fi
6948
6949   done
6950 fi
6951
6952 for ncn_progname in nm; do
6953   if test -n "$ncn_tool_prefix"; then
6954     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6955 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6956 echo "$as_me:$LINENO: checking for $ac_word" >&5
6957 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6958 if test "${ac_cv_prog_NM+set}" = set; then
6959   echo $ECHO_N "(cached) $ECHO_C" >&6
6960 else
6961   if test -n "$NM"; then
6962   ac_cv_prog_NM="$NM" # Let the user override the test.
6963 else
6964 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6965 for as_dir in $PATH
6966 do
6967   IFS=$as_save_IFS
6968   test -z "$as_dir" && as_dir=.
6969   for ac_exec_ext in '' $ac_executable_extensions; do
6970   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6971     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
6972     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6973     break 2
6974   fi
6975 done
6976 done
6977
6978 fi
6979 fi
6980 NM=$ac_cv_prog_NM
6981 if test -n "$NM"; then
6982   echo "$as_me:$LINENO: result: $NM" >&5
6983 echo "${ECHO_T}$NM" >&6
6984 else
6985   echo "$as_me:$LINENO: result: no" >&5
6986 echo "${ECHO_T}no" >&6
6987 fi
6988
6989   fi
6990   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
6991     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6992 set dummy ${ncn_progname}; ac_word=$2
6993 echo "$as_me:$LINENO: checking for $ac_word" >&5
6994 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6995 if test "${ac_cv_prog_NM+set}" = set; then
6996   echo $ECHO_N "(cached) $ECHO_C" >&6
6997 else
6998   if test -n "$NM"; then
6999   ac_cv_prog_NM="$NM" # Let the user override the test.
7000 else
7001 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7002 for as_dir in $PATH
7003 do
7004   IFS=$as_save_IFS
7005   test -z "$as_dir" && as_dir=.
7006   for ac_exec_ext in '' $ac_executable_extensions; do
7007   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7008     ac_cv_prog_NM="${ncn_progname}"
7009     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7010     break 2
7011   fi
7012 done
7013 done
7014
7015 fi
7016 fi
7017 NM=$ac_cv_prog_NM
7018 if test -n "$NM"; then
7019   echo "$as_me:$LINENO: result: $NM" >&5
7020 echo "${ECHO_T}$NM" >&6
7021 else
7022   echo "$as_me:$LINENO: result: no" >&5
7023 echo "${ECHO_T}no" >&6
7024 fi
7025
7026   fi
7027   test -n "$ac_cv_prog_NM" && break
7028 done
7029
7030 if test -z "$ac_cv_prog_NM" ; then
7031   set dummy nm
7032   if test $build = $host ; then
7033     NM="$2"
7034   else
7035     NM="${ncn_tool_prefix}$2"
7036   fi
7037 fi
7038
7039
7040
7041 if test -n "$RANLIB"; then
7042   ac_cv_prog_RANLIB=$RANLIB
7043 elif test -n "$ac_cv_prog_RANLIB"; then
7044   RANLIB=$ac_cv_prog_RANLIB
7045 fi
7046
7047 if test -n "$ac_cv_prog_RANLIB"; then
7048   for ncn_progname in ranlib; do
7049     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7050 set dummy ${ncn_progname}; ac_word=$2
7051 echo "$as_me:$LINENO: checking for $ac_word" >&5
7052 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7053 if test "${ac_cv_prog_RANLIB+set}" = set; then
7054   echo $ECHO_N "(cached) $ECHO_C" >&6
7055 else
7056   if test -n "$RANLIB"; then
7057   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7058 else
7059 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7060 for as_dir in $PATH
7061 do
7062   IFS=$as_save_IFS
7063   test -z "$as_dir" && as_dir=.
7064   for ac_exec_ext in '' $ac_executable_extensions; do
7065   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7066     ac_cv_prog_RANLIB="${ncn_progname}"
7067     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7068     break 2
7069   fi
7070 done
7071 done
7072
7073 fi
7074 fi
7075 RANLIB=$ac_cv_prog_RANLIB
7076 if test -n "$RANLIB"; then
7077   echo "$as_me:$LINENO: result: $RANLIB" >&5
7078 echo "${ECHO_T}$RANLIB" >&6
7079 else
7080   echo "$as_me:$LINENO: result: no" >&5
7081 echo "${ECHO_T}no" >&6
7082 fi
7083
7084   done
7085 fi
7086
7087 for ncn_progname in ranlib; do
7088   if test -n "$ncn_tool_prefix"; then
7089     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7090 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7091 echo "$as_me:$LINENO: checking for $ac_word" >&5
7092 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7093 if test "${ac_cv_prog_RANLIB+set}" = set; then
7094   echo $ECHO_N "(cached) $ECHO_C" >&6
7095 else
7096   if test -n "$RANLIB"; then
7097   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7098 else
7099 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7100 for as_dir in $PATH
7101 do
7102   IFS=$as_save_IFS
7103   test -z "$as_dir" && as_dir=.
7104   for ac_exec_ext in '' $ac_executable_extensions; do
7105   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7106     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7107     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7108     break 2
7109   fi
7110 done
7111 done
7112
7113 fi
7114 fi
7115 RANLIB=$ac_cv_prog_RANLIB
7116 if test -n "$RANLIB"; then
7117   echo "$as_me:$LINENO: result: $RANLIB" >&5
7118 echo "${ECHO_T}$RANLIB" >&6
7119 else
7120   echo "$as_me:$LINENO: result: no" >&5
7121 echo "${ECHO_T}no" >&6
7122 fi
7123
7124   fi
7125   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7126     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7127 set dummy ${ncn_progname}; ac_word=$2
7128 echo "$as_me:$LINENO: checking for $ac_word" >&5
7129 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7130 if test "${ac_cv_prog_RANLIB+set}" = set; then
7131   echo $ECHO_N "(cached) $ECHO_C" >&6
7132 else
7133   if test -n "$RANLIB"; then
7134   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7135 else
7136 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7137 for as_dir in $PATH
7138 do
7139   IFS=$as_save_IFS
7140   test -z "$as_dir" && as_dir=.
7141   for ac_exec_ext in '' $ac_executable_extensions; do
7142   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7143     ac_cv_prog_RANLIB="${ncn_progname}"
7144     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7145     break 2
7146   fi
7147 done
7148 done
7149
7150 fi
7151 fi
7152 RANLIB=$ac_cv_prog_RANLIB
7153 if test -n "$RANLIB"; then
7154   echo "$as_me:$LINENO: result: $RANLIB" >&5
7155 echo "${ECHO_T}$RANLIB" >&6
7156 else
7157   echo "$as_me:$LINENO: result: no" >&5
7158 echo "${ECHO_T}no" >&6
7159 fi
7160
7161   fi
7162   test -n "$ac_cv_prog_RANLIB" && break
7163 done
7164
7165 if test -z "$ac_cv_prog_RANLIB" ; then
7166   RANLIB=":"
7167 fi
7168
7169
7170
7171 if test -n "$STRIP"; then
7172   ac_cv_prog_STRIP=$STRIP
7173 elif test -n "$ac_cv_prog_STRIP"; then
7174   STRIP=$ac_cv_prog_STRIP
7175 fi
7176
7177 if test -n "$ac_cv_prog_STRIP"; then
7178   for ncn_progname in strip; do
7179     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7180 set dummy ${ncn_progname}; ac_word=$2
7181 echo "$as_me:$LINENO: checking for $ac_word" >&5
7182 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7183 if test "${ac_cv_prog_STRIP+set}" = set; then
7184   echo $ECHO_N "(cached) $ECHO_C" >&6
7185 else
7186   if test -n "$STRIP"; then
7187   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7188 else
7189 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7190 for as_dir in $PATH
7191 do
7192   IFS=$as_save_IFS
7193   test -z "$as_dir" && as_dir=.
7194   for ac_exec_ext in '' $ac_executable_extensions; do
7195   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7196     ac_cv_prog_STRIP="${ncn_progname}"
7197     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7198     break 2
7199   fi
7200 done
7201 done
7202
7203 fi
7204 fi
7205 STRIP=$ac_cv_prog_STRIP
7206 if test -n "$STRIP"; then
7207   echo "$as_me:$LINENO: result: $STRIP" >&5
7208 echo "${ECHO_T}$STRIP" >&6
7209 else
7210   echo "$as_me:$LINENO: result: no" >&5
7211 echo "${ECHO_T}no" >&6
7212 fi
7213
7214   done
7215 fi
7216
7217 for ncn_progname in strip; do
7218   if test -n "$ncn_tool_prefix"; then
7219     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7220 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7221 echo "$as_me:$LINENO: checking for $ac_word" >&5
7222 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7223 if test "${ac_cv_prog_STRIP+set}" = set; then
7224   echo $ECHO_N "(cached) $ECHO_C" >&6
7225 else
7226   if test -n "$STRIP"; then
7227   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7228 else
7229 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7230 for as_dir in $PATH
7231 do
7232   IFS=$as_save_IFS
7233   test -z "$as_dir" && as_dir=.
7234   for ac_exec_ext in '' $ac_executable_extensions; do
7235   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7236     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7237     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7238     break 2
7239   fi
7240 done
7241 done
7242
7243 fi
7244 fi
7245 STRIP=$ac_cv_prog_STRIP
7246 if test -n "$STRIP"; then
7247   echo "$as_me:$LINENO: result: $STRIP" >&5
7248 echo "${ECHO_T}$STRIP" >&6
7249 else
7250   echo "$as_me:$LINENO: result: no" >&5
7251 echo "${ECHO_T}no" >&6
7252 fi
7253
7254   fi
7255   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7256     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7257 set dummy ${ncn_progname}; ac_word=$2
7258 echo "$as_me:$LINENO: checking for $ac_word" >&5
7259 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7260 if test "${ac_cv_prog_STRIP+set}" = set; then
7261   echo $ECHO_N "(cached) $ECHO_C" >&6
7262 else
7263   if test -n "$STRIP"; then
7264   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7265 else
7266 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7267 for as_dir in $PATH
7268 do
7269   IFS=$as_save_IFS
7270   test -z "$as_dir" && as_dir=.
7271   for ac_exec_ext in '' $ac_executable_extensions; do
7272   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7273     ac_cv_prog_STRIP="${ncn_progname}"
7274     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7275     break 2
7276   fi
7277 done
7278 done
7279
7280 fi
7281 fi
7282 STRIP=$ac_cv_prog_STRIP
7283 if test -n "$STRIP"; then
7284   echo "$as_me:$LINENO: result: $STRIP" >&5
7285 echo "${ECHO_T}$STRIP" >&6
7286 else
7287   echo "$as_me:$LINENO: result: no" >&5
7288 echo "${ECHO_T}no" >&6
7289 fi
7290
7291   fi
7292   test -n "$ac_cv_prog_STRIP" && break
7293 done
7294
7295 if test -z "$ac_cv_prog_STRIP" ; then
7296   STRIP=":"
7297 fi
7298
7299
7300
7301 if test -n "$WINDRES"; then
7302   ac_cv_prog_WINDRES=$WINDRES
7303 elif test -n "$ac_cv_prog_WINDRES"; then
7304   WINDRES=$ac_cv_prog_WINDRES
7305 fi
7306
7307 if test -n "$ac_cv_prog_WINDRES"; then
7308   for ncn_progname in windres; do
7309     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7310 set dummy ${ncn_progname}; ac_word=$2
7311 echo "$as_me:$LINENO: checking for $ac_word" >&5
7312 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7313 if test "${ac_cv_prog_WINDRES+set}" = set; then
7314   echo $ECHO_N "(cached) $ECHO_C" >&6
7315 else
7316   if test -n "$WINDRES"; then
7317   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7318 else
7319 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7320 for as_dir in $PATH
7321 do
7322   IFS=$as_save_IFS
7323   test -z "$as_dir" && as_dir=.
7324   for ac_exec_ext in '' $ac_executable_extensions; do
7325   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7326     ac_cv_prog_WINDRES="${ncn_progname}"
7327     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7328     break 2
7329   fi
7330 done
7331 done
7332
7333 fi
7334 fi
7335 WINDRES=$ac_cv_prog_WINDRES
7336 if test -n "$WINDRES"; then
7337   echo "$as_me:$LINENO: result: $WINDRES" >&5
7338 echo "${ECHO_T}$WINDRES" >&6
7339 else
7340   echo "$as_me:$LINENO: result: no" >&5
7341 echo "${ECHO_T}no" >&6
7342 fi
7343
7344   done
7345 fi
7346
7347 for ncn_progname in windres; do
7348   if test -n "$ncn_tool_prefix"; then
7349     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7350 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7351 echo "$as_me:$LINENO: checking for $ac_word" >&5
7352 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7353 if test "${ac_cv_prog_WINDRES+set}" = set; then
7354   echo $ECHO_N "(cached) $ECHO_C" >&6
7355 else
7356   if test -n "$WINDRES"; then
7357   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7358 else
7359 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7360 for as_dir in $PATH
7361 do
7362   IFS=$as_save_IFS
7363   test -z "$as_dir" && as_dir=.
7364   for ac_exec_ext in '' $ac_executable_extensions; do
7365   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7366     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7367     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7368     break 2
7369   fi
7370 done
7371 done
7372
7373 fi
7374 fi
7375 WINDRES=$ac_cv_prog_WINDRES
7376 if test -n "$WINDRES"; then
7377   echo "$as_me:$LINENO: result: $WINDRES" >&5
7378 echo "${ECHO_T}$WINDRES" >&6
7379 else
7380   echo "$as_me:$LINENO: result: no" >&5
7381 echo "${ECHO_T}no" >&6
7382 fi
7383
7384   fi
7385   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7386     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7387 set dummy ${ncn_progname}; ac_word=$2
7388 echo "$as_me:$LINENO: checking for $ac_word" >&5
7389 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7390 if test "${ac_cv_prog_WINDRES+set}" = set; then
7391   echo $ECHO_N "(cached) $ECHO_C" >&6
7392 else
7393   if test -n "$WINDRES"; then
7394   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7395 else
7396 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7397 for as_dir in $PATH
7398 do
7399   IFS=$as_save_IFS
7400   test -z "$as_dir" && as_dir=.
7401   for ac_exec_ext in '' $ac_executable_extensions; do
7402   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7403     ac_cv_prog_WINDRES="${ncn_progname}"
7404     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7405     break 2
7406   fi
7407 done
7408 done
7409
7410 fi
7411 fi
7412 WINDRES=$ac_cv_prog_WINDRES
7413 if test -n "$WINDRES"; then
7414   echo "$as_me:$LINENO: result: $WINDRES" >&5
7415 echo "${ECHO_T}$WINDRES" >&6
7416 else
7417   echo "$as_me:$LINENO: result: no" >&5
7418 echo "${ECHO_T}no" >&6
7419 fi
7420
7421   fi
7422   test -n "$ac_cv_prog_WINDRES" && break
7423 done
7424
7425 if test -z "$ac_cv_prog_WINDRES" ; then
7426   set dummy windres
7427   if test $build = $host ; then
7428     WINDRES="$2"
7429   else
7430     WINDRES="${ncn_tool_prefix}$2"
7431   fi
7432 fi
7433
7434
7435
7436 if test -n "$OBJCOPY"; then
7437   ac_cv_prog_OBJCOPY=$OBJCOPY
7438 elif test -n "$ac_cv_prog_OBJCOPY"; then
7439   OBJCOPY=$ac_cv_prog_OBJCOPY
7440 fi
7441
7442 if test -n "$ac_cv_prog_OBJCOPY"; then
7443   for ncn_progname in objcopy; do
7444     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7445 set dummy ${ncn_progname}; ac_word=$2
7446 echo "$as_me:$LINENO: checking for $ac_word" >&5
7447 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7448 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7449   echo $ECHO_N "(cached) $ECHO_C" >&6
7450 else
7451   if test -n "$OBJCOPY"; then
7452   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7453 else
7454 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7455 for as_dir in $PATH
7456 do
7457   IFS=$as_save_IFS
7458   test -z "$as_dir" && as_dir=.
7459   for ac_exec_ext in '' $ac_executable_extensions; do
7460   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7461     ac_cv_prog_OBJCOPY="${ncn_progname}"
7462     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7463     break 2
7464   fi
7465 done
7466 done
7467
7468 fi
7469 fi
7470 OBJCOPY=$ac_cv_prog_OBJCOPY
7471 if test -n "$OBJCOPY"; then
7472   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7473 echo "${ECHO_T}$OBJCOPY" >&6
7474 else
7475   echo "$as_me:$LINENO: result: no" >&5
7476 echo "${ECHO_T}no" >&6
7477 fi
7478
7479   done
7480 fi
7481
7482 for ncn_progname in objcopy; do
7483   if test -n "$ncn_tool_prefix"; then
7484     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7485 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7486 echo "$as_me:$LINENO: checking for $ac_word" >&5
7487 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7488 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7489   echo $ECHO_N "(cached) $ECHO_C" >&6
7490 else
7491   if test -n "$OBJCOPY"; then
7492   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7493 else
7494 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7495 for as_dir in $PATH
7496 do
7497   IFS=$as_save_IFS
7498   test -z "$as_dir" && as_dir=.
7499   for ac_exec_ext in '' $ac_executable_extensions; do
7500   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7501     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7502     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7503     break 2
7504   fi
7505 done
7506 done
7507
7508 fi
7509 fi
7510 OBJCOPY=$ac_cv_prog_OBJCOPY
7511 if test -n "$OBJCOPY"; then
7512   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7513 echo "${ECHO_T}$OBJCOPY" >&6
7514 else
7515   echo "$as_me:$LINENO: result: no" >&5
7516 echo "${ECHO_T}no" >&6
7517 fi
7518
7519   fi
7520   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7521     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7522 set dummy ${ncn_progname}; ac_word=$2
7523 echo "$as_me:$LINENO: checking for $ac_word" >&5
7524 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7525 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7526   echo $ECHO_N "(cached) $ECHO_C" >&6
7527 else
7528   if test -n "$OBJCOPY"; then
7529   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7530 else
7531 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7532 for as_dir in $PATH
7533 do
7534   IFS=$as_save_IFS
7535   test -z "$as_dir" && as_dir=.
7536   for ac_exec_ext in '' $ac_executable_extensions; do
7537   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7538     ac_cv_prog_OBJCOPY="${ncn_progname}"
7539     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7540     break 2
7541   fi
7542 done
7543 done
7544
7545 fi
7546 fi
7547 OBJCOPY=$ac_cv_prog_OBJCOPY
7548 if test -n "$OBJCOPY"; then
7549   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7550 echo "${ECHO_T}$OBJCOPY" >&6
7551 else
7552   echo "$as_me:$LINENO: result: no" >&5
7553 echo "${ECHO_T}no" >&6
7554 fi
7555
7556   fi
7557   test -n "$ac_cv_prog_OBJCOPY" && break
7558 done
7559
7560 if test -z "$ac_cv_prog_OBJCOPY" ; then
7561   set dummy objcopy
7562   if test $build = $host ; then
7563     OBJCOPY="$2"
7564   else
7565     OBJCOPY="${ncn_tool_prefix}$2"
7566   fi
7567 fi
7568
7569
7570
7571 if test -n "$OBJDUMP"; then
7572   ac_cv_prog_OBJDUMP=$OBJDUMP
7573 elif test -n "$ac_cv_prog_OBJDUMP"; then
7574   OBJDUMP=$ac_cv_prog_OBJDUMP
7575 fi
7576
7577 if test -n "$ac_cv_prog_OBJDUMP"; then
7578   for ncn_progname in objdump; do
7579     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7580 set dummy ${ncn_progname}; ac_word=$2
7581 echo "$as_me:$LINENO: checking for $ac_word" >&5
7582 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7583 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7584   echo $ECHO_N "(cached) $ECHO_C" >&6
7585 else
7586   if test -n "$OBJDUMP"; then
7587   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7588 else
7589 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7590 for as_dir in $PATH
7591 do
7592   IFS=$as_save_IFS
7593   test -z "$as_dir" && as_dir=.
7594   for ac_exec_ext in '' $ac_executable_extensions; do
7595   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7596     ac_cv_prog_OBJDUMP="${ncn_progname}"
7597     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7598     break 2
7599   fi
7600 done
7601 done
7602
7603 fi
7604 fi
7605 OBJDUMP=$ac_cv_prog_OBJDUMP
7606 if test -n "$OBJDUMP"; then
7607   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7608 echo "${ECHO_T}$OBJDUMP" >&6
7609 else
7610   echo "$as_me:$LINENO: result: no" >&5
7611 echo "${ECHO_T}no" >&6
7612 fi
7613
7614   done
7615 fi
7616
7617 for ncn_progname in objdump; do
7618   if test -n "$ncn_tool_prefix"; then
7619     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7620 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7621 echo "$as_me:$LINENO: checking for $ac_word" >&5
7622 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7623 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7624   echo $ECHO_N "(cached) $ECHO_C" >&6
7625 else
7626   if test -n "$OBJDUMP"; then
7627   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7628 else
7629 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7630 for as_dir in $PATH
7631 do
7632   IFS=$as_save_IFS
7633   test -z "$as_dir" && as_dir=.
7634   for ac_exec_ext in '' $ac_executable_extensions; do
7635   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7636     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7637     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7638     break 2
7639   fi
7640 done
7641 done
7642
7643 fi
7644 fi
7645 OBJDUMP=$ac_cv_prog_OBJDUMP
7646 if test -n "$OBJDUMP"; then
7647   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7648 echo "${ECHO_T}$OBJDUMP" >&6
7649 else
7650   echo "$as_me:$LINENO: result: no" >&5
7651 echo "${ECHO_T}no" >&6
7652 fi
7653
7654   fi
7655   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7656     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7657 set dummy ${ncn_progname}; ac_word=$2
7658 echo "$as_me:$LINENO: checking for $ac_word" >&5
7659 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7660 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7661   echo $ECHO_N "(cached) $ECHO_C" >&6
7662 else
7663   if test -n "$OBJDUMP"; then
7664   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7665 else
7666 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7667 for as_dir in $PATH
7668 do
7669   IFS=$as_save_IFS
7670   test -z "$as_dir" && as_dir=.
7671   for ac_exec_ext in '' $ac_executable_extensions; do
7672   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7673     ac_cv_prog_OBJDUMP="${ncn_progname}"
7674     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7675     break 2
7676   fi
7677 done
7678 done
7679
7680 fi
7681 fi
7682 OBJDUMP=$ac_cv_prog_OBJDUMP
7683 if test -n "$OBJDUMP"; then
7684   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7685 echo "${ECHO_T}$OBJDUMP" >&6
7686 else
7687   echo "$as_me:$LINENO: result: no" >&5
7688 echo "${ECHO_T}no" >&6
7689 fi
7690
7691   fi
7692   test -n "$ac_cv_prog_OBJDUMP" && break
7693 done
7694
7695 if test -z "$ac_cv_prog_OBJDUMP" ; then
7696   set dummy objdump
7697   if test $build = $host ; then
7698     OBJDUMP="$2"
7699   else
7700     OBJDUMP="${ncn_tool_prefix}$2"
7701   fi
7702 fi
7703
7704
7705
7706
7707
7708
7709
7710 # Target tools.
7711
7712 # Check whether --with-build-time-tools or --without-build-time-tools was given.
7713 if test "${with_build_time_tools+set}" = set; then
7714   withval="$with_build_time_tools"
7715   case x"$withval" in
7716      x/*) ;;
7717      *)
7718        with_build_time_tools=
7719        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
7720 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
7721        ;;
7722    esac
7723 else
7724   with_build_time_tools=
7725 fi;
7726
7727
7728
7729 if test -n "$CC_FOR_TARGET"; then
7730   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
7731 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7732   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7733 fi
7734
7735 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7736   for ncn_progname in cc gcc; do
7737     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7738 set dummy ${ncn_progname}; ac_word=$2
7739 echo "$as_me:$LINENO: checking for $ac_word" >&5
7740 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7741 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7742   echo $ECHO_N "(cached) $ECHO_C" >&6
7743 else
7744   if test -n "$CC_FOR_TARGET"; then
7745   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7746 else
7747 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7748 for as_dir in $PATH
7749 do
7750   IFS=$as_save_IFS
7751   test -z "$as_dir" && as_dir=.
7752   for ac_exec_ext in '' $ac_executable_extensions; do
7753   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7754     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7755     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7756     break 2
7757   fi
7758 done
7759 done
7760
7761 fi
7762 fi
7763 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7764 if test -n "$CC_FOR_TARGET"; then
7765   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7766 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7767 else
7768   echo "$as_me:$LINENO: result: no" >&5
7769 echo "${ECHO_T}no" >&6
7770 fi
7771
7772   done
7773 fi
7774
7775 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
7776   for ncn_progname in cc gcc; do
7777     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
7778 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
7779     if test -x $with_build_time_tools/${ncn_progname}; then
7780       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
7781       echo "$as_me:$LINENO: result: yes" >&5
7782 echo "${ECHO_T}yes" >&6
7783       break
7784     else
7785       echo "$as_me:$LINENO: result: no" >&5
7786 echo "${ECHO_T}no" >&6
7787     fi
7788   done
7789 fi
7790
7791 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
7792   for ncn_progname in cc gcc; do
7793     if test -n "$ncn_target_tool_prefix"; then
7794       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
7795 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
7796 echo "$as_me:$LINENO: checking for $ac_word" >&5
7797 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7798 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7799   echo $ECHO_N "(cached) $ECHO_C" >&6
7800 else
7801   if test -n "$CC_FOR_TARGET"; then
7802   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7803 else
7804 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7805 for as_dir in $PATH
7806 do
7807   IFS=$as_save_IFS
7808   test -z "$as_dir" && as_dir=.
7809   for ac_exec_ext in '' $ac_executable_extensions; do
7810   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7811     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
7812     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7813     break 2
7814   fi
7815 done
7816 done
7817
7818 fi
7819 fi
7820 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7821 if test -n "$CC_FOR_TARGET"; then
7822   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7823 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7824 else
7825   echo "$as_me:$LINENO: result: no" >&5
7826 echo "${ECHO_T}no" >&6
7827 fi
7828
7829     fi
7830     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
7831       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7832 set dummy ${ncn_progname}; ac_word=$2
7833 echo "$as_me:$LINENO: checking for $ac_word" >&5
7834 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7835 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7836   echo $ECHO_N "(cached) $ECHO_C" >&6
7837 else
7838   if test -n "$CC_FOR_TARGET"; then
7839   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7840 else
7841 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7842 for as_dir in $PATH
7843 do
7844   IFS=$as_save_IFS
7845   test -z "$as_dir" && as_dir=.
7846   for ac_exec_ext in '' $ac_executable_extensions; do
7847   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7848     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7849     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7850     break 2
7851   fi
7852 done
7853 done
7854
7855 fi
7856 fi
7857 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7858 if test -n "$CC_FOR_TARGET"; then
7859   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7860 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7861 else
7862   echo "$as_me:$LINENO: result: no" >&5
7863 echo "${ECHO_T}no" >&6
7864 fi
7865
7866     fi
7867     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
7868   done
7869 fi
7870
7871 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
7872   set dummy cc gcc
7873   if test $build = $target ; then
7874     CC_FOR_TARGET="$2"
7875   else
7876     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
7877   fi
7878 else
7879   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
7880 fi
7881
7882
7883
7884 if test -n "$CXX_FOR_TARGET"; then
7885   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
7886 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
7887   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
7888 fi
7889
7890 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
7891   for ncn_progname in c++ g++ cxx gxx; do
7892     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7893 set dummy ${ncn_progname}; ac_word=$2
7894 echo "$as_me:$LINENO: checking for $ac_word" >&5
7895 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7896 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
7897   echo $ECHO_N "(cached) $ECHO_C" >&6
7898 else
7899   if test -n "$CXX_FOR_TARGET"; then
7900   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
7901 else
7902 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7903 for as_dir in $PATH
7904 do
7905   IFS=$as_save_IFS
7906   test -z "$as_dir" && as_dir=.
7907   for ac_exec_ext in '' $ac_executable_extensions; do
7908   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7909     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
7910     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7911     break 2
7912   fi
7913 done
7914 done
7915
7916 fi
7917 fi
7918 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
7919 if test -n "$CXX_FOR_TARGET"; then
7920   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
7921 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
7922 else
7923   echo "$as_me:$LINENO: result: no" >&5
7924 echo "${ECHO_T}no" >&6
7925 fi
7926
7927   done
7928 fi
7929
7930 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
7931   for ncn_progname in c++ g++ cxx gxx; do
7932     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
7933 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
7934     if test -x $with_build_time_tools/${ncn_progname}; then
7935       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
7936       echo "$as_me:$LINENO: result: yes" >&5
7937 echo "${ECHO_T}yes" >&6
7938       break
7939     else
7940       echo "$as_me:$LINENO: result: no" >&5
7941 echo "${ECHO_T}no" >&6
7942     fi
7943   done
7944 fi
7945
7946 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
7947   for ncn_progname in c++ g++ cxx gxx; do
7948     if test -n "$ncn_target_tool_prefix"; then
7949       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
7950 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
7951 echo "$as_me:$LINENO: checking for $ac_word" >&5
7952 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7953 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
7954   echo $ECHO_N "(cached) $ECHO_C" >&6
7955 else
7956   if test -n "$CXX_FOR_TARGET"; then
7957   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
7958 else
7959 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7960 for as_dir in $PATH
7961 do
7962   IFS=$as_save_IFS
7963   test -z "$as_dir" && as_dir=.
7964   for ac_exec_ext in '' $ac_executable_extensions; do
7965   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7966     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
7967     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7968     break 2
7969   fi
7970 done
7971 done
7972
7973 fi
7974 fi
7975 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
7976 if test -n "$CXX_FOR_TARGET"; then
7977   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
7978 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
7979 else
7980   echo "$as_me:$LINENO: result: no" >&5
7981 echo "${ECHO_T}no" >&6
7982 fi
7983
7984     fi
7985     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
7986       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7987 set dummy ${ncn_progname}; ac_word=$2
7988 echo "$as_me:$LINENO: checking for $ac_word" >&5
7989 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7990 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
7991   echo $ECHO_N "(cached) $ECHO_C" >&6
7992 else
7993   if test -n "$CXX_FOR_TARGET"; then
7994   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
7995 else
7996 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7997 for as_dir in $PATH
7998 do
7999   IFS=$as_save_IFS
8000   test -z "$as_dir" && as_dir=.
8001   for ac_exec_ext in '' $ac_executable_extensions; do
8002   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8003     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8004     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8005     break 2
8006   fi
8007 done
8008 done
8009
8010 fi
8011 fi
8012 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8013 if test -n "$CXX_FOR_TARGET"; then
8014   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8015 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8016 else
8017   echo "$as_me:$LINENO: result: no" >&5
8018 echo "${ECHO_T}no" >&6
8019 fi
8020
8021     fi
8022     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8023   done
8024 fi
8025
8026 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8027   set dummy c++ g++ cxx gxx
8028   if test $build = $target ; then
8029     CXX_FOR_TARGET="$2"
8030   else
8031     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8032   fi
8033 else
8034   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8035 fi
8036
8037
8038
8039 if test -n "$GCC_FOR_TARGET"; then
8040   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8041 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8042   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8043 fi
8044
8045 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8046   for ncn_progname in gcc; do
8047     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8048 set dummy ${ncn_progname}; ac_word=$2
8049 echo "$as_me:$LINENO: checking for $ac_word" >&5
8050 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8051 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8052   echo $ECHO_N "(cached) $ECHO_C" >&6
8053 else
8054   if test -n "$GCC_FOR_TARGET"; then
8055   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8056 else
8057 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8058 for as_dir in $PATH
8059 do
8060   IFS=$as_save_IFS
8061   test -z "$as_dir" && as_dir=.
8062   for ac_exec_ext in '' $ac_executable_extensions; do
8063   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8064     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8065     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8066     break 2
8067   fi
8068 done
8069 done
8070
8071 fi
8072 fi
8073 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8074 if test -n "$GCC_FOR_TARGET"; then
8075   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8076 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8077 else
8078   echo "$as_me:$LINENO: result: no" >&5
8079 echo "${ECHO_T}no" >&6
8080 fi
8081
8082   done
8083 fi
8084
8085 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8086   for ncn_progname in gcc; do
8087     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8088 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8089     if test -x $with_build_time_tools/${ncn_progname}; then
8090       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8091       echo "$as_me:$LINENO: result: yes" >&5
8092 echo "${ECHO_T}yes" >&6
8093       break
8094     else
8095       echo "$as_me:$LINENO: result: no" >&5
8096 echo "${ECHO_T}no" >&6
8097     fi
8098   done
8099 fi
8100
8101 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8102   for ncn_progname in gcc; do
8103     if test -n "$ncn_target_tool_prefix"; then
8104       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8105 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8106 echo "$as_me:$LINENO: checking for $ac_word" >&5
8107 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8108 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8109   echo $ECHO_N "(cached) $ECHO_C" >&6
8110 else
8111   if test -n "$GCC_FOR_TARGET"; then
8112   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8113 else
8114 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8115 for as_dir in $PATH
8116 do
8117   IFS=$as_save_IFS
8118   test -z "$as_dir" && as_dir=.
8119   for ac_exec_ext in '' $ac_executable_extensions; do
8120   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8121     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8122     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8123     break 2
8124   fi
8125 done
8126 done
8127
8128 fi
8129 fi
8130 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8131 if test -n "$GCC_FOR_TARGET"; then
8132   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8133 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8134 else
8135   echo "$as_me:$LINENO: result: no" >&5
8136 echo "${ECHO_T}no" >&6
8137 fi
8138
8139     fi
8140     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8141       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8142 set dummy ${ncn_progname}; ac_word=$2
8143 echo "$as_me:$LINENO: checking for $ac_word" >&5
8144 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8145 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8146   echo $ECHO_N "(cached) $ECHO_C" >&6
8147 else
8148   if test -n "$GCC_FOR_TARGET"; then
8149   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8150 else
8151 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8152 for as_dir in $PATH
8153 do
8154   IFS=$as_save_IFS
8155   test -z "$as_dir" && as_dir=.
8156   for ac_exec_ext in '' $ac_executable_extensions; do
8157   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8158     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8159     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8160     break 2
8161   fi
8162 done
8163 done
8164
8165 fi
8166 fi
8167 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8168 if test -n "$GCC_FOR_TARGET"; then
8169   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8170 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8171 else
8172   echo "$as_me:$LINENO: result: no" >&5
8173 echo "${ECHO_T}no" >&6
8174 fi
8175
8176     fi
8177     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8178   done
8179 fi
8180
8181 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8182   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8183 else
8184   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8185 fi
8186
8187
8188
8189 if test -n "$GCJ_FOR_TARGET"; then
8190   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8191 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8192   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8193 fi
8194
8195 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8196   for ncn_progname in gcj; do
8197     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8198 set dummy ${ncn_progname}; ac_word=$2
8199 echo "$as_me:$LINENO: checking for $ac_word" >&5
8200 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8201 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8202   echo $ECHO_N "(cached) $ECHO_C" >&6
8203 else
8204   if test -n "$GCJ_FOR_TARGET"; then
8205   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8206 else
8207 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8208 for as_dir in $PATH
8209 do
8210   IFS=$as_save_IFS
8211   test -z "$as_dir" && as_dir=.
8212   for ac_exec_ext in '' $ac_executable_extensions; do
8213   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8214     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8215     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8216     break 2
8217   fi
8218 done
8219 done
8220
8221 fi
8222 fi
8223 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8224 if test -n "$GCJ_FOR_TARGET"; then
8225   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8226 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8227 else
8228   echo "$as_me:$LINENO: result: no" >&5
8229 echo "${ECHO_T}no" >&6
8230 fi
8231
8232   done
8233 fi
8234
8235 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8236   for ncn_progname in gcj; do
8237     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8238 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8239     if test -x $with_build_time_tools/${ncn_progname}; then
8240       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8241       echo "$as_me:$LINENO: result: yes" >&5
8242 echo "${ECHO_T}yes" >&6
8243       break
8244     else
8245       echo "$as_me:$LINENO: result: no" >&5
8246 echo "${ECHO_T}no" >&6
8247     fi
8248   done
8249 fi
8250
8251 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8252   for ncn_progname in gcj; do
8253     if test -n "$ncn_target_tool_prefix"; then
8254       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8255 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8256 echo "$as_me:$LINENO: checking for $ac_word" >&5
8257 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8258 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8259   echo $ECHO_N "(cached) $ECHO_C" >&6
8260 else
8261   if test -n "$GCJ_FOR_TARGET"; then
8262   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8263 else
8264 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8265 for as_dir in $PATH
8266 do
8267   IFS=$as_save_IFS
8268   test -z "$as_dir" && as_dir=.
8269   for ac_exec_ext in '' $ac_executable_extensions; do
8270   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8271     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8272     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8273     break 2
8274   fi
8275 done
8276 done
8277
8278 fi
8279 fi
8280 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8281 if test -n "$GCJ_FOR_TARGET"; then
8282   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8283 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8284 else
8285   echo "$as_me:$LINENO: result: no" >&5
8286 echo "${ECHO_T}no" >&6
8287 fi
8288
8289     fi
8290     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8291       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8292 set dummy ${ncn_progname}; ac_word=$2
8293 echo "$as_me:$LINENO: checking for $ac_word" >&5
8294 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8295 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8296   echo $ECHO_N "(cached) $ECHO_C" >&6
8297 else
8298   if test -n "$GCJ_FOR_TARGET"; then
8299   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8300 else
8301 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8302 for as_dir in $PATH
8303 do
8304   IFS=$as_save_IFS
8305   test -z "$as_dir" && as_dir=.
8306   for ac_exec_ext in '' $ac_executable_extensions; do
8307   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8308     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8309     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8310     break 2
8311   fi
8312 done
8313 done
8314
8315 fi
8316 fi
8317 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8318 if test -n "$GCJ_FOR_TARGET"; then
8319   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8320 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8321 else
8322   echo "$as_me:$LINENO: result: no" >&5
8323 echo "${ECHO_T}no" >&6
8324 fi
8325
8326     fi
8327     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8328   done
8329 fi
8330
8331 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8332   set dummy gcj
8333   if test $build = $target ; then
8334     GCJ_FOR_TARGET="$2"
8335   else
8336     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8337   fi
8338 else
8339   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8340 fi
8341
8342
8343
8344 if test -n "$GFORTRAN_FOR_TARGET"; then
8345   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8346 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8347   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8348 fi
8349
8350 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8351   for ncn_progname in gfortran; do
8352     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8353 set dummy ${ncn_progname}; ac_word=$2
8354 echo "$as_me:$LINENO: checking for $ac_word" >&5
8355 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8356 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8357   echo $ECHO_N "(cached) $ECHO_C" >&6
8358 else
8359   if test -n "$GFORTRAN_FOR_TARGET"; then
8360   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8361 else
8362 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8363 for as_dir in $PATH
8364 do
8365   IFS=$as_save_IFS
8366   test -z "$as_dir" && as_dir=.
8367   for ac_exec_ext in '' $ac_executable_extensions; do
8368   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8369     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8370     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8371     break 2
8372   fi
8373 done
8374 done
8375
8376 fi
8377 fi
8378 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8379 if test -n "$GFORTRAN_FOR_TARGET"; then
8380   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8381 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8382 else
8383   echo "$as_me:$LINENO: result: no" >&5
8384 echo "${ECHO_T}no" >&6
8385 fi
8386
8387   done
8388 fi
8389
8390 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8391   for ncn_progname in gfortran; do
8392     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8393 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8394     if test -x $with_build_time_tools/${ncn_progname}; then
8395       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8396       echo "$as_me:$LINENO: result: yes" >&5
8397 echo "${ECHO_T}yes" >&6
8398       break
8399     else
8400       echo "$as_me:$LINENO: result: no" >&5
8401 echo "${ECHO_T}no" >&6
8402     fi
8403   done
8404 fi
8405
8406 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8407   for ncn_progname in gfortran; do
8408     if test -n "$ncn_target_tool_prefix"; then
8409       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8410 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8411 echo "$as_me:$LINENO: checking for $ac_word" >&5
8412 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8413 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8414   echo $ECHO_N "(cached) $ECHO_C" >&6
8415 else
8416   if test -n "$GFORTRAN_FOR_TARGET"; then
8417   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8418 else
8419 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8420 for as_dir in $PATH
8421 do
8422   IFS=$as_save_IFS
8423   test -z "$as_dir" && as_dir=.
8424   for ac_exec_ext in '' $ac_executable_extensions; do
8425   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8426     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8427     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8428     break 2
8429   fi
8430 done
8431 done
8432
8433 fi
8434 fi
8435 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8436 if test -n "$GFORTRAN_FOR_TARGET"; then
8437   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8438 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8439 else
8440   echo "$as_me:$LINENO: result: no" >&5
8441 echo "${ECHO_T}no" >&6
8442 fi
8443
8444     fi
8445     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8446       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8447 set dummy ${ncn_progname}; ac_word=$2
8448 echo "$as_me:$LINENO: checking for $ac_word" >&5
8449 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8450 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8451   echo $ECHO_N "(cached) $ECHO_C" >&6
8452 else
8453   if test -n "$GFORTRAN_FOR_TARGET"; then
8454   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8455 else
8456 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8457 for as_dir in $PATH
8458 do
8459   IFS=$as_save_IFS
8460   test -z "$as_dir" && as_dir=.
8461   for ac_exec_ext in '' $ac_executable_extensions; do
8462   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8463     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8464     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8465     break 2
8466   fi
8467 done
8468 done
8469
8470 fi
8471 fi
8472 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8473 if test -n "$GFORTRAN_FOR_TARGET"; then
8474   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8475 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8476 else
8477   echo "$as_me:$LINENO: result: no" >&5
8478 echo "${ECHO_T}no" >&6
8479 fi
8480
8481     fi
8482     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8483   done
8484 fi
8485
8486 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8487   set dummy gfortran
8488   if test $build = $target ; then
8489     GFORTRAN_FOR_TARGET="$2"
8490   else
8491     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8492   fi
8493 else
8494   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8495 fi
8496
8497
8498
8499 cat > conftest.c << \EOF
8500 #ifdef __GNUC__
8501   gcc_yay;
8502 #endif
8503 EOF
8504 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8505   have_gcc_for_target=yes
8506 else
8507   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8508   have_gcc_for_target=no
8509 fi
8510 rm conftest.c
8511
8512
8513
8514
8515 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8516   if test -n "$with_build_time_tools"; then
8517     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8518 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8519     if test -x $with_build_time_tools/ar; then
8520       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8521       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8522       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8523 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8524     else
8525       echo "$as_me:$LINENO: result: no" >&5
8526 echo "${ECHO_T}no" >&6
8527     fi
8528   elif test $build != $host && test $have_gcc_for_target = yes; then
8529     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8530     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8531     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8532   fi
8533 fi
8534 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8535   # Extract the first word of "ar", so it can be a program name with args.
8536 set dummy ar; ac_word=$2
8537 echo "$as_me:$LINENO: checking for $ac_word" >&5
8538 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8539 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8540   echo $ECHO_N "(cached) $ECHO_C" >&6
8541 else
8542   case $AR_FOR_TARGET in
8543   [\\/]* | ?:[\\/]*)
8544   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8545   ;;
8546   *)
8547   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8548 for as_dir in $gcc_cv_tool_dirs
8549 do
8550   IFS=$as_save_IFS
8551   test -z "$as_dir" && as_dir=.
8552   for ac_exec_ext in '' $ac_executable_extensions; do
8553   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8554     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8555     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8556     break 2
8557   fi
8558 done
8559 done
8560
8561   ;;
8562 esac
8563 fi
8564 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8565
8566 if test -n "$AR_FOR_TARGET"; then
8567   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8568 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8569 else
8570   echo "$as_me:$LINENO: result: no" >&5
8571 echo "${ECHO_T}no" >&6
8572 fi
8573
8574 fi
8575 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8576
8577
8578 if test -n "$AR_FOR_TARGET"; then
8579   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8580 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8581   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8582 fi
8583
8584 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8585   for ncn_progname in ar; do
8586     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8587 set dummy ${ncn_progname}; ac_word=$2
8588 echo "$as_me:$LINENO: checking for $ac_word" >&5
8589 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8590 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8591   echo $ECHO_N "(cached) $ECHO_C" >&6
8592 else
8593   if test -n "$AR_FOR_TARGET"; then
8594   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8595 else
8596 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8597 for as_dir in $PATH
8598 do
8599   IFS=$as_save_IFS
8600   test -z "$as_dir" && as_dir=.
8601   for ac_exec_ext in '' $ac_executable_extensions; do
8602   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8603     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8604     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8605     break 2
8606   fi
8607 done
8608 done
8609
8610 fi
8611 fi
8612 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8613 if test -n "$AR_FOR_TARGET"; then
8614   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8615 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8616 else
8617   echo "$as_me:$LINENO: result: no" >&5
8618 echo "${ECHO_T}no" >&6
8619 fi
8620
8621   done
8622 fi
8623
8624 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8625   for ncn_progname in ar; do
8626     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8627 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8628     if test -x $with_build_time_tools/${ncn_progname}; then
8629       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8630       echo "$as_me:$LINENO: result: yes" >&5
8631 echo "${ECHO_T}yes" >&6
8632       break
8633     else
8634       echo "$as_me:$LINENO: result: no" >&5
8635 echo "${ECHO_T}no" >&6
8636     fi
8637   done
8638 fi
8639
8640 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8641   for ncn_progname in ar; do
8642     if test -n "$ncn_target_tool_prefix"; then
8643       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8644 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8645 echo "$as_me:$LINENO: checking for $ac_word" >&5
8646 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8647 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8648   echo $ECHO_N "(cached) $ECHO_C" >&6
8649 else
8650   if test -n "$AR_FOR_TARGET"; then
8651   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8652 else
8653 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8654 for as_dir in $PATH
8655 do
8656   IFS=$as_save_IFS
8657   test -z "$as_dir" && as_dir=.
8658   for ac_exec_ext in '' $ac_executable_extensions; do
8659   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8660     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8661     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8662     break 2
8663   fi
8664 done
8665 done
8666
8667 fi
8668 fi
8669 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8670 if test -n "$AR_FOR_TARGET"; then
8671   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8672 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8673 else
8674   echo "$as_me:$LINENO: result: no" >&5
8675 echo "${ECHO_T}no" >&6
8676 fi
8677
8678     fi
8679     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
8680       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8681 set dummy ${ncn_progname}; ac_word=$2
8682 echo "$as_me:$LINENO: checking for $ac_word" >&5
8683 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8684 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8685   echo $ECHO_N "(cached) $ECHO_C" >&6
8686 else
8687   if test -n "$AR_FOR_TARGET"; then
8688   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8689 else
8690 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8691 for as_dir in $PATH
8692 do
8693   IFS=$as_save_IFS
8694   test -z "$as_dir" && as_dir=.
8695   for ac_exec_ext in '' $ac_executable_extensions; do
8696   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8697     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8698     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8699     break 2
8700   fi
8701 done
8702 done
8703
8704 fi
8705 fi
8706 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8707 if test -n "$AR_FOR_TARGET"; then
8708   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8709 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8710 else
8711   echo "$as_me:$LINENO: result: no" >&5
8712 echo "${ECHO_T}no" >&6
8713 fi
8714
8715     fi
8716     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
8717   done
8718 fi
8719
8720 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
8721   set dummy ar
8722   if test $build = $target ; then
8723     AR_FOR_TARGET="$2"
8724   else
8725     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
8726   fi
8727 else
8728   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
8729 fi
8730
8731 else
8732   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8733 fi
8734
8735
8736
8737
8738 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8739   if test -n "$with_build_time_tools"; then
8740     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
8741 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
8742     if test -x $with_build_time_tools/as; then
8743       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
8744       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8745       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
8746 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
8747     else
8748       echo "$as_me:$LINENO: result: no" >&5
8749 echo "${ECHO_T}no" >&6
8750     fi
8751   elif test $build != $host && test $have_gcc_for_target = yes; then
8752     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
8753     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
8754     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8755   fi
8756 fi
8757 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8758   # Extract the first word of "as", so it can be a program name with args.
8759 set dummy as; ac_word=$2
8760 echo "$as_me:$LINENO: checking for $ac_word" >&5
8761 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8762 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
8763   echo $ECHO_N "(cached) $ECHO_C" >&6
8764 else
8765   case $AS_FOR_TARGET in
8766   [\\/]* | ?:[\\/]*)
8767   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
8768   ;;
8769   *)
8770   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8771 for as_dir in $gcc_cv_tool_dirs
8772 do
8773   IFS=$as_save_IFS
8774   test -z "$as_dir" && as_dir=.
8775   for ac_exec_ext in '' $ac_executable_extensions; do
8776   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8777     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8778     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8779     break 2
8780   fi
8781 done
8782 done
8783
8784   ;;
8785 esac
8786 fi
8787 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
8788
8789 if test -n "$AS_FOR_TARGET"; then
8790   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8791 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8792 else
8793   echo "$as_me:$LINENO: result: no" >&5
8794 echo "${ECHO_T}no" >&6
8795 fi
8796
8797 fi
8798 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8799
8800
8801 if test -n "$AS_FOR_TARGET"; then
8802   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
8803 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
8804   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8805 fi
8806
8807 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
8808   for ncn_progname in as; do
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_AS_FOR_TARGET+set}" = set; then
8814   echo $ECHO_N "(cached) $ECHO_C" >&6
8815 else
8816   if test -n "$AS_FOR_TARGET"; then
8817   ac_cv_prog_AS_FOR_TARGET="$AS_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_AS_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 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8836 if test -n "$AS_FOR_TARGET"; then
8837   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8838 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8839 else
8840   echo "$as_me:$LINENO: result: no" >&5
8841 echo "${ECHO_T}no" >&6
8842 fi
8843
8844   done
8845 fi
8846
8847 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
8848   for ncn_progname in as; do
8849     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8850 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8851     if test -x $with_build_time_tools/${ncn_progname}; then
8852       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8853       echo "$as_me:$LINENO: result: yes" >&5
8854 echo "${ECHO_T}yes" >&6
8855       break
8856     else
8857       echo "$as_me:$LINENO: result: no" >&5
8858 echo "${ECHO_T}no" >&6
8859     fi
8860   done
8861 fi
8862
8863 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
8864   for ncn_progname in as; do
8865     if test -n "$ncn_target_tool_prefix"; then
8866       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8867 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8868 echo "$as_me:$LINENO: checking for $ac_word" >&5
8869 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8870 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8871   echo $ECHO_N "(cached) $ECHO_C" >&6
8872 else
8873   if test -n "$AS_FOR_TARGET"; then
8874   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8875 else
8876 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8877 for as_dir in $PATH
8878 do
8879   IFS=$as_save_IFS
8880   test -z "$as_dir" && as_dir=.
8881   for ac_exec_ext in '' $ac_executable_extensions; do
8882   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8883     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8884     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8885     break 2
8886   fi
8887 done
8888 done
8889
8890 fi
8891 fi
8892 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8893 if test -n "$AS_FOR_TARGET"; then
8894   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8895 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8896 else
8897   echo "$as_me:$LINENO: result: no" >&5
8898 echo "${ECHO_T}no" >&6
8899 fi
8900
8901     fi
8902     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
8903       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8904 set dummy ${ncn_progname}; ac_word=$2
8905 echo "$as_me:$LINENO: checking for $ac_word" >&5
8906 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8907 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8908   echo $ECHO_N "(cached) $ECHO_C" >&6
8909 else
8910   if test -n "$AS_FOR_TARGET"; then
8911   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8912 else
8913 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8914 for as_dir in $PATH
8915 do
8916   IFS=$as_save_IFS
8917   test -z "$as_dir" && as_dir=.
8918   for ac_exec_ext in '' $ac_executable_extensions; do
8919   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8920     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
8921     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8922     break 2
8923   fi
8924 done
8925 done
8926
8927 fi
8928 fi
8929 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8930 if test -n "$AS_FOR_TARGET"; then
8931   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8932 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8933 else
8934   echo "$as_me:$LINENO: result: no" >&5
8935 echo "${ECHO_T}no" >&6
8936 fi
8937
8938     fi
8939     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
8940   done
8941 fi
8942
8943 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
8944   set dummy as
8945   if test $build = $target ; then
8946     AS_FOR_TARGET="$2"
8947   else
8948     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
8949   fi
8950 else
8951   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
8952 fi
8953
8954 else
8955   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
8956 fi
8957
8958
8959
8960
8961 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
8962   if test -n "$with_build_time_tools"; then
8963     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
8964 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
8965     if test -x $with_build_time_tools/dlltool; then
8966       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
8967       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
8968       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
8969 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
8970     else
8971       echo "$as_me:$LINENO: result: no" >&5
8972 echo "${ECHO_T}no" >&6
8973     fi
8974   elif test $build != $host && test $have_gcc_for_target = yes; then
8975     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
8976     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
8977     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
8978   fi
8979 fi
8980 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8981   # Extract the first word of "dlltool", so it can be a program name with args.
8982 set dummy dlltool; ac_word=$2
8983 echo "$as_me:$LINENO: checking for $ac_word" >&5
8984 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8985 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
8986   echo $ECHO_N "(cached) $ECHO_C" >&6
8987 else
8988   case $DLLTOOL_FOR_TARGET in
8989   [\\/]* | ?:[\\/]*)
8990   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
8991   ;;
8992   *)
8993   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8994 for as_dir in $gcc_cv_tool_dirs
8995 do
8996   IFS=$as_save_IFS
8997   test -z "$as_dir" && as_dir=.
8998   for ac_exec_ext in '' $ac_executable_extensions; do
8999   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9000     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9001     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9002     break 2
9003   fi
9004 done
9005 done
9006
9007   ;;
9008 esac
9009 fi
9010 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9011
9012 if test -n "$DLLTOOL_FOR_TARGET"; then
9013   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9014 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9015 else
9016   echo "$as_me:$LINENO: result: no" >&5
9017 echo "${ECHO_T}no" >&6
9018 fi
9019
9020 fi
9021 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9022
9023
9024 if test -n "$DLLTOOL_FOR_TARGET"; then
9025   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9026 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9027   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9028 fi
9029
9030 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9031   for ncn_progname in dlltool; do
9032     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9033 set dummy ${ncn_progname}; ac_word=$2
9034 echo "$as_me:$LINENO: checking for $ac_word" >&5
9035 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9036 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9037   echo $ECHO_N "(cached) $ECHO_C" >&6
9038 else
9039   if test -n "$DLLTOOL_FOR_TARGET"; then
9040   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9041 else
9042 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9043 for as_dir in $PATH
9044 do
9045   IFS=$as_save_IFS
9046   test -z "$as_dir" && as_dir=.
9047   for ac_exec_ext in '' $ac_executable_extensions; do
9048   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9049     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9050     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9051     break 2
9052   fi
9053 done
9054 done
9055
9056 fi
9057 fi
9058 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9059 if test -n "$DLLTOOL_FOR_TARGET"; then
9060   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9061 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9062 else
9063   echo "$as_me:$LINENO: result: no" >&5
9064 echo "${ECHO_T}no" >&6
9065 fi
9066
9067   done
9068 fi
9069
9070 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9071   for ncn_progname in dlltool; do
9072     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9073 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9074     if test -x $with_build_time_tools/${ncn_progname}; then
9075       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9076       echo "$as_me:$LINENO: result: yes" >&5
9077 echo "${ECHO_T}yes" >&6
9078       break
9079     else
9080       echo "$as_me:$LINENO: result: no" >&5
9081 echo "${ECHO_T}no" >&6
9082     fi
9083   done
9084 fi
9085
9086 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9087   for ncn_progname in dlltool; do
9088     if test -n "$ncn_target_tool_prefix"; then
9089       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9090 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9091 echo "$as_me:$LINENO: checking for $ac_word" >&5
9092 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9093 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9094   echo $ECHO_N "(cached) $ECHO_C" >&6
9095 else
9096   if test -n "$DLLTOOL_FOR_TARGET"; then
9097   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9098 else
9099 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9100 for as_dir in $PATH
9101 do
9102   IFS=$as_save_IFS
9103   test -z "$as_dir" && as_dir=.
9104   for ac_exec_ext in '' $ac_executable_extensions; do
9105   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9106     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9107     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9108     break 2
9109   fi
9110 done
9111 done
9112
9113 fi
9114 fi
9115 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9116 if test -n "$DLLTOOL_FOR_TARGET"; then
9117   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9118 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9119 else
9120   echo "$as_me:$LINENO: result: no" >&5
9121 echo "${ECHO_T}no" >&6
9122 fi
9123
9124     fi
9125     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9126       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9127 set dummy ${ncn_progname}; ac_word=$2
9128 echo "$as_me:$LINENO: checking for $ac_word" >&5
9129 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9130 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9131   echo $ECHO_N "(cached) $ECHO_C" >&6
9132 else
9133   if test -n "$DLLTOOL_FOR_TARGET"; then
9134   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9135 else
9136 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9137 for as_dir in $PATH
9138 do
9139   IFS=$as_save_IFS
9140   test -z "$as_dir" && as_dir=.
9141   for ac_exec_ext in '' $ac_executable_extensions; do
9142   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9143     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9144     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9145     break 2
9146   fi
9147 done
9148 done
9149
9150 fi
9151 fi
9152 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9153 if test -n "$DLLTOOL_FOR_TARGET"; then
9154   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9155 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9156 else
9157   echo "$as_me:$LINENO: result: no" >&5
9158 echo "${ECHO_T}no" >&6
9159 fi
9160
9161     fi
9162     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9163   done
9164 fi
9165
9166 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9167   set dummy dlltool
9168   if test $build = $target ; then
9169     DLLTOOL_FOR_TARGET="$2"
9170   else
9171     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9172   fi
9173 else
9174   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9175 fi
9176
9177 else
9178   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9179 fi
9180
9181
9182
9183
9184 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9185   if test -n "$with_build_time_tools"; then
9186     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9187 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9188     if test -x $with_build_time_tools/ld; then
9189       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9190       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9191       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9192 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9193     else
9194       echo "$as_me:$LINENO: result: no" >&5
9195 echo "${ECHO_T}no" >&6
9196     fi
9197   elif test $build != $host && test $have_gcc_for_target = yes; then
9198     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9199     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9200     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9201   fi
9202 fi
9203 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9204   # Extract the first word of "ld", so it can be a program name with args.
9205 set dummy ld; ac_word=$2
9206 echo "$as_me:$LINENO: checking for $ac_word" >&5
9207 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9208 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9209   echo $ECHO_N "(cached) $ECHO_C" >&6
9210 else
9211   case $LD_FOR_TARGET in
9212   [\\/]* | ?:[\\/]*)
9213   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9214   ;;
9215   *)
9216   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9217 for as_dir in $gcc_cv_tool_dirs
9218 do
9219   IFS=$as_save_IFS
9220   test -z "$as_dir" && as_dir=.
9221   for ac_exec_ext in '' $ac_executable_extensions; do
9222   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9223     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9224     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9225     break 2
9226   fi
9227 done
9228 done
9229
9230   ;;
9231 esac
9232 fi
9233 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9234
9235 if test -n "$LD_FOR_TARGET"; then
9236   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9237 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9238 else
9239   echo "$as_me:$LINENO: result: no" >&5
9240 echo "${ECHO_T}no" >&6
9241 fi
9242
9243 fi
9244 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9245
9246
9247 if test -n "$LD_FOR_TARGET"; then
9248   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9249 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9250   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9251 fi
9252
9253 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9254   for ncn_progname in ld; do
9255     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9256 set dummy ${ncn_progname}; ac_word=$2
9257 echo "$as_me:$LINENO: checking for $ac_word" >&5
9258 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9259 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9260   echo $ECHO_N "(cached) $ECHO_C" >&6
9261 else
9262   if test -n "$LD_FOR_TARGET"; then
9263   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9264 else
9265 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9266 for as_dir in $PATH
9267 do
9268   IFS=$as_save_IFS
9269   test -z "$as_dir" && as_dir=.
9270   for ac_exec_ext in '' $ac_executable_extensions; do
9271   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9272     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9273     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9274     break 2
9275   fi
9276 done
9277 done
9278
9279 fi
9280 fi
9281 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9282 if test -n "$LD_FOR_TARGET"; then
9283   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9284 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9285 else
9286   echo "$as_me:$LINENO: result: no" >&5
9287 echo "${ECHO_T}no" >&6
9288 fi
9289
9290   done
9291 fi
9292
9293 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9294   for ncn_progname in ld; do
9295     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9296 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9297     if test -x $with_build_time_tools/${ncn_progname}; then
9298       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9299       echo "$as_me:$LINENO: result: yes" >&5
9300 echo "${ECHO_T}yes" >&6
9301       break
9302     else
9303       echo "$as_me:$LINENO: result: no" >&5
9304 echo "${ECHO_T}no" >&6
9305     fi
9306   done
9307 fi
9308
9309 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9310   for ncn_progname in ld; do
9311     if test -n "$ncn_target_tool_prefix"; then
9312       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9313 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9314 echo "$as_me:$LINENO: checking for $ac_word" >&5
9315 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9316 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9317   echo $ECHO_N "(cached) $ECHO_C" >&6
9318 else
9319   if test -n "$LD_FOR_TARGET"; then
9320   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9321 else
9322 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9323 for as_dir in $PATH
9324 do
9325   IFS=$as_save_IFS
9326   test -z "$as_dir" && as_dir=.
9327   for ac_exec_ext in '' $ac_executable_extensions; do
9328   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9329     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9330     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9331     break 2
9332   fi
9333 done
9334 done
9335
9336 fi
9337 fi
9338 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9339 if test -n "$LD_FOR_TARGET"; then
9340   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9341 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9342 else
9343   echo "$as_me:$LINENO: result: no" >&5
9344 echo "${ECHO_T}no" >&6
9345 fi
9346
9347     fi
9348     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9349       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9350 set dummy ${ncn_progname}; ac_word=$2
9351 echo "$as_me:$LINENO: checking for $ac_word" >&5
9352 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9353 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9354   echo $ECHO_N "(cached) $ECHO_C" >&6
9355 else
9356   if test -n "$LD_FOR_TARGET"; then
9357   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9358 else
9359 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9360 for as_dir in $PATH
9361 do
9362   IFS=$as_save_IFS
9363   test -z "$as_dir" && as_dir=.
9364   for ac_exec_ext in '' $ac_executable_extensions; do
9365   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9366     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9367     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9368     break 2
9369   fi
9370 done
9371 done
9372
9373 fi
9374 fi
9375 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9376 if test -n "$LD_FOR_TARGET"; then
9377   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9378 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9379 else
9380   echo "$as_me:$LINENO: result: no" >&5
9381 echo "${ECHO_T}no" >&6
9382 fi
9383
9384     fi
9385     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9386   done
9387 fi
9388
9389 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9390   set dummy ld
9391   if test $build = $target ; then
9392     LD_FOR_TARGET="$2"
9393   else
9394     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9395   fi
9396 else
9397   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9398 fi
9399
9400 else
9401   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9402 fi
9403
9404
9405
9406
9407 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9408   if test -n "$with_build_time_tools"; then
9409     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9410 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9411     if test -x $with_build_time_tools/lipo; then
9412       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9413       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9414       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9415 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9416     else
9417       echo "$as_me:$LINENO: result: no" >&5
9418 echo "${ECHO_T}no" >&6
9419     fi
9420   elif test $build != $host && test $have_gcc_for_target = yes; then
9421     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9422     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9423     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9424   fi
9425 fi
9426 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9427   # Extract the first word of "lipo", so it can be a program name with args.
9428 set dummy lipo; ac_word=$2
9429 echo "$as_me:$LINENO: checking for $ac_word" >&5
9430 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9431 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9432   echo $ECHO_N "(cached) $ECHO_C" >&6
9433 else
9434   case $LIPO_FOR_TARGET in
9435   [\\/]* | ?:[\\/]*)
9436   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9437   ;;
9438   *)
9439   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9440 for as_dir in $gcc_cv_tool_dirs
9441 do
9442   IFS=$as_save_IFS
9443   test -z "$as_dir" && as_dir=.
9444   for ac_exec_ext in '' $ac_executable_extensions; do
9445   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9446     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9447     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9448     break 2
9449   fi
9450 done
9451 done
9452
9453   ;;
9454 esac
9455 fi
9456 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9457
9458 if test -n "$LIPO_FOR_TARGET"; then
9459   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9460 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9461 else
9462   echo "$as_me:$LINENO: result: no" >&5
9463 echo "${ECHO_T}no" >&6
9464 fi
9465
9466 fi
9467 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9468
9469
9470 if test -n "$LIPO_FOR_TARGET"; then
9471   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9472 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9473   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9474 fi
9475
9476 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9477   for ncn_progname in lipo; do
9478     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9479 set dummy ${ncn_progname}; ac_word=$2
9480 echo "$as_me:$LINENO: checking for $ac_word" >&5
9481 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9482 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9483   echo $ECHO_N "(cached) $ECHO_C" >&6
9484 else
9485   if test -n "$LIPO_FOR_TARGET"; then
9486   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9487 else
9488 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9489 for as_dir in $PATH
9490 do
9491   IFS=$as_save_IFS
9492   test -z "$as_dir" && as_dir=.
9493   for ac_exec_ext in '' $ac_executable_extensions; do
9494   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9495     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9496     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9497     break 2
9498   fi
9499 done
9500 done
9501
9502 fi
9503 fi
9504 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9505 if test -n "$LIPO_FOR_TARGET"; then
9506   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9507 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9508 else
9509   echo "$as_me:$LINENO: result: no" >&5
9510 echo "${ECHO_T}no" >&6
9511 fi
9512
9513   done
9514 fi
9515
9516 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9517   for ncn_progname in lipo; do
9518     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9519 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9520     if test -x $with_build_time_tools/${ncn_progname}; then
9521       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9522       echo "$as_me:$LINENO: result: yes" >&5
9523 echo "${ECHO_T}yes" >&6
9524       break
9525     else
9526       echo "$as_me:$LINENO: result: no" >&5
9527 echo "${ECHO_T}no" >&6
9528     fi
9529   done
9530 fi
9531
9532 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9533   for ncn_progname in lipo; do
9534     if test -n "$ncn_target_tool_prefix"; then
9535       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9536 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9537 echo "$as_me:$LINENO: checking for $ac_word" >&5
9538 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9539 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9540   echo $ECHO_N "(cached) $ECHO_C" >&6
9541 else
9542   if test -n "$LIPO_FOR_TARGET"; then
9543   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9544 else
9545 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9546 for as_dir in $PATH
9547 do
9548   IFS=$as_save_IFS
9549   test -z "$as_dir" && as_dir=.
9550   for ac_exec_ext in '' $ac_executable_extensions; do
9551   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9552     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9553     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9554     break 2
9555   fi
9556 done
9557 done
9558
9559 fi
9560 fi
9561 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9562 if test -n "$LIPO_FOR_TARGET"; then
9563   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9564 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9565 else
9566   echo "$as_me:$LINENO: result: no" >&5
9567 echo "${ECHO_T}no" >&6
9568 fi
9569
9570     fi
9571     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9572       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9573 set dummy ${ncn_progname}; ac_word=$2
9574 echo "$as_me:$LINENO: checking for $ac_word" >&5
9575 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9576 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9577   echo $ECHO_N "(cached) $ECHO_C" >&6
9578 else
9579   if test -n "$LIPO_FOR_TARGET"; then
9580   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9581 else
9582 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9583 for as_dir in $PATH
9584 do
9585   IFS=$as_save_IFS
9586   test -z "$as_dir" && as_dir=.
9587   for ac_exec_ext in '' $ac_executable_extensions; do
9588   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9589     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9590     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9591     break 2
9592   fi
9593 done
9594 done
9595
9596 fi
9597 fi
9598 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9599 if test -n "$LIPO_FOR_TARGET"; then
9600   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9601 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9602 else
9603   echo "$as_me:$LINENO: result: no" >&5
9604 echo "${ECHO_T}no" >&6
9605 fi
9606
9607     fi
9608     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9609   done
9610 fi
9611
9612 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9613   set dummy lipo
9614   if test $build = $target ; then
9615     LIPO_FOR_TARGET="$2"
9616   else
9617     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9618   fi
9619 else
9620   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9621 fi
9622
9623 else
9624   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9625 fi
9626
9627
9628
9629
9630 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9631   if test -n "$with_build_time_tools"; then
9632     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9633 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9634     if test -x $with_build_time_tools/nm; then
9635       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9636       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9637       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9638 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9639     else
9640       echo "$as_me:$LINENO: result: no" >&5
9641 echo "${ECHO_T}no" >&6
9642     fi
9643   elif test $build != $host && test $have_gcc_for_target = yes; then
9644     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9645     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
9646     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9647   fi
9648 fi
9649 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9650   # Extract the first word of "nm", so it can be a program name with args.
9651 set dummy nm; ac_word=$2
9652 echo "$as_me:$LINENO: checking for $ac_word" >&5
9653 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9654 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9655   echo $ECHO_N "(cached) $ECHO_C" >&6
9656 else
9657   case $NM_FOR_TARGET in
9658   [\\/]* | ?:[\\/]*)
9659   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9660   ;;
9661   *)
9662   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9663 for as_dir in $gcc_cv_tool_dirs
9664 do
9665   IFS=$as_save_IFS
9666   test -z "$as_dir" && as_dir=.
9667   for ac_exec_ext in '' $ac_executable_extensions; do
9668   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9669     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9670     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9671     break 2
9672   fi
9673 done
9674 done
9675
9676   ;;
9677 esac
9678 fi
9679 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9680
9681 if test -n "$NM_FOR_TARGET"; then
9682   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9683 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9684 else
9685   echo "$as_me:$LINENO: result: no" >&5
9686 echo "${ECHO_T}no" >&6
9687 fi
9688
9689 fi
9690 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9691
9692
9693 if test -n "$NM_FOR_TARGET"; then
9694   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
9695 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9696   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9697 fi
9698
9699 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9700   for ncn_progname in nm; do
9701     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9702 set dummy ${ncn_progname}; ac_word=$2
9703 echo "$as_me:$LINENO: checking for $ac_word" >&5
9704 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9705 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9706   echo $ECHO_N "(cached) $ECHO_C" >&6
9707 else
9708   if test -n "$NM_FOR_TARGET"; then
9709   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9710 else
9711 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9712 for as_dir in $PATH
9713 do
9714   IFS=$as_save_IFS
9715   test -z "$as_dir" && as_dir=.
9716   for ac_exec_ext in '' $ac_executable_extensions; do
9717   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9718     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9719     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9720     break 2
9721   fi
9722 done
9723 done
9724
9725 fi
9726 fi
9727 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9728 if test -n "$NM_FOR_TARGET"; then
9729   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9730 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9731 else
9732   echo "$as_me:$LINENO: result: no" >&5
9733 echo "${ECHO_T}no" >&6
9734 fi
9735
9736   done
9737 fi
9738
9739 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
9740   for ncn_progname in nm; do
9741     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9742 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9743     if test -x $with_build_time_tools/${ncn_progname}; then
9744       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9745       echo "$as_me:$LINENO: result: yes" >&5
9746 echo "${ECHO_T}yes" >&6
9747       break
9748     else
9749       echo "$as_me:$LINENO: result: no" >&5
9750 echo "${ECHO_T}no" >&6
9751     fi
9752   done
9753 fi
9754
9755 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
9756   for ncn_progname in nm; do
9757     if test -n "$ncn_target_tool_prefix"; then
9758       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9759 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9760 echo "$as_me:$LINENO: checking for $ac_word" >&5
9761 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9762 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9763   echo $ECHO_N "(cached) $ECHO_C" >&6
9764 else
9765   if test -n "$NM_FOR_TARGET"; then
9766   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9767 else
9768 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9769 for as_dir in $PATH
9770 do
9771   IFS=$as_save_IFS
9772   test -z "$as_dir" && as_dir=.
9773   for ac_exec_ext in '' $ac_executable_extensions; do
9774   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9775     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9776     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9777     break 2
9778   fi
9779 done
9780 done
9781
9782 fi
9783 fi
9784 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9785 if test -n "$NM_FOR_TARGET"; then
9786   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9787 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9788 else
9789   echo "$as_me:$LINENO: result: no" >&5
9790 echo "${ECHO_T}no" >&6
9791 fi
9792
9793     fi
9794     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
9795       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9796 set dummy ${ncn_progname}; ac_word=$2
9797 echo "$as_me:$LINENO: checking for $ac_word" >&5
9798 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9799 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9800   echo $ECHO_N "(cached) $ECHO_C" >&6
9801 else
9802   if test -n "$NM_FOR_TARGET"; then
9803   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9804 else
9805 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9806 for as_dir in $PATH
9807 do
9808   IFS=$as_save_IFS
9809   test -z "$as_dir" && as_dir=.
9810   for ac_exec_ext in '' $ac_executable_extensions; do
9811   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9812     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9813     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9814     break 2
9815   fi
9816 done
9817 done
9818
9819 fi
9820 fi
9821 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9822 if test -n "$NM_FOR_TARGET"; then
9823   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9824 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9825 else
9826   echo "$as_me:$LINENO: result: no" >&5
9827 echo "${ECHO_T}no" >&6
9828 fi
9829
9830     fi
9831     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
9832   done
9833 fi
9834
9835 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
9836   set dummy nm
9837   if test $build = $target ; then
9838     NM_FOR_TARGET="$2"
9839   else
9840     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
9841   fi
9842 else
9843   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
9844 fi
9845
9846 else
9847   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9848 fi
9849
9850
9851
9852
9853 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
9854   if test -n "$with_build_time_tools"; then
9855     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
9856 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
9857     if test -x $with_build_time_tools/objdump; then
9858       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
9859       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
9860       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
9861 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
9862     else
9863       echo "$as_me:$LINENO: result: no" >&5
9864 echo "${ECHO_T}no" >&6
9865     fi
9866   elif test $build != $host && test $have_gcc_for_target = yes; then
9867     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
9868     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
9869     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
9870   fi
9871 fi
9872 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9873   # Extract the first word of "objdump", so it can be a program name with args.
9874 set dummy objdump; ac_word=$2
9875 echo "$as_me:$LINENO: checking for $ac_word" >&5
9876 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9877 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
9878   echo $ECHO_N "(cached) $ECHO_C" >&6
9879 else
9880   case $OBJDUMP_FOR_TARGET in
9881   [\\/]* | ?:[\\/]*)
9882   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
9883   ;;
9884   *)
9885   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9886 for as_dir in $gcc_cv_tool_dirs
9887 do
9888   IFS=$as_save_IFS
9889   test -z "$as_dir" && as_dir=.
9890   for ac_exec_ext in '' $ac_executable_extensions; do
9891   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9892     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9893     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9894     break 2
9895   fi
9896 done
9897 done
9898
9899   ;;
9900 esac
9901 fi
9902 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
9903
9904 if test -n "$OBJDUMP_FOR_TARGET"; then
9905   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
9906 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
9907 else
9908   echo "$as_me:$LINENO: result: no" >&5
9909 echo "${ECHO_T}no" >&6
9910 fi
9911
9912 fi
9913 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
9914
9915
9916 if test -n "$OBJDUMP_FOR_TARGET"; then
9917   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
9918 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
9919   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
9920 fi
9921
9922 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
9923   for ncn_progname in objdump; do
9924     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9925 set dummy ${ncn_progname}; ac_word=$2
9926 echo "$as_me:$LINENO: checking for $ac_word" >&5
9927 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9928 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
9929   echo $ECHO_N "(cached) $ECHO_C" >&6
9930 else
9931   if test -n "$OBJDUMP_FOR_TARGET"; then
9932   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
9933 else
9934 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9935 for as_dir in $PATH
9936 do
9937   IFS=$as_save_IFS
9938   test -z "$as_dir" && as_dir=.
9939   for ac_exec_ext in '' $ac_executable_extensions; do
9940   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9941     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
9942     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9943     break 2
9944   fi
9945 done
9946 done
9947
9948 fi
9949 fi
9950 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
9951 if test -n "$OBJDUMP_FOR_TARGET"; then
9952   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
9953 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
9954 else
9955   echo "$as_me:$LINENO: result: no" >&5
9956 echo "${ECHO_T}no" >&6
9957 fi
9958
9959   done
9960 fi
9961
9962 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
9963   for ncn_progname in objdump; do
9964     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9965 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9966     if test -x $with_build_time_tools/${ncn_progname}; then
9967       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9968       echo "$as_me:$LINENO: result: yes" >&5
9969 echo "${ECHO_T}yes" >&6
9970       break
9971     else
9972       echo "$as_me:$LINENO: result: no" >&5
9973 echo "${ECHO_T}no" >&6
9974     fi
9975   done
9976 fi
9977
9978 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
9979   for ncn_progname in objdump; do
9980     if test -n "$ncn_target_tool_prefix"; then
9981       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9982 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9983 echo "$as_me:$LINENO: checking for $ac_word" >&5
9984 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9985 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
9986   echo $ECHO_N "(cached) $ECHO_C" >&6
9987 else
9988   if test -n "$OBJDUMP_FOR_TARGET"; then
9989   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
9990 else
9991 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9992 for as_dir in $PATH
9993 do
9994   IFS=$as_save_IFS
9995   test -z "$as_dir" && as_dir=.
9996   for ac_exec_ext in '' $ac_executable_extensions; do
9997   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9998     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9999     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10000     break 2
10001   fi
10002 done
10003 done
10004
10005 fi
10006 fi
10007 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10008 if test -n "$OBJDUMP_FOR_TARGET"; then
10009   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10010 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10011 else
10012   echo "$as_me:$LINENO: result: no" >&5
10013 echo "${ECHO_T}no" >&6
10014 fi
10015
10016     fi
10017     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10018       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10019 set dummy ${ncn_progname}; ac_word=$2
10020 echo "$as_me:$LINENO: checking for $ac_word" >&5
10021 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10022 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10023   echo $ECHO_N "(cached) $ECHO_C" >&6
10024 else
10025   if test -n "$OBJDUMP_FOR_TARGET"; then
10026   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10027 else
10028 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10029 for as_dir in $PATH
10030 do
10031   IFS=$as_save_IFS
10032   test -z "$as_dir" && as_dir=.
10033   for ac_exec_ext in '' $ac_executable_extensions; do
10034   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10035     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10036     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10037     break 2
10038   fi
10039 done
10040 done
10041
10042 fi
10043 fi
10044 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10045 if test -n "$OBJDUMP_FOR_TARGET"; then
10046   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10047 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10048 else
10049   echo "$as_me:$LINENO: result: no" >&5
10050 echo "${ECHO_T}no" >&6
10051 fi
10052
10053     fi
10054     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10055   done
10056 fi
10057
10058 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10059   set dummy objdump
10060   if test $build = $target ; then
10061     OBJDUMP_FOR_TARGET="$2"
10062   else
10063     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10064   fi
10065 else
10066   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10067 fi
10068
10069 else
10070   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10071 fi
10072
10073
10074
10075
10076 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10077   if test -n "$with_build_time_tools"; then
10078     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10079 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10080     if test -x $with_build_time_tools/ranlib; then
10081       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10082       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10083       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10084 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10085     else
10086       echo "$as_me:$LINENO: result: no" >&5
10087 echo "${ECHO_T}no" >&6
10088     fi
10089   elif test $build != $host && test $have_gcc_for_target = yes; then
10090     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10091     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10092     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10093   fi
10094 fi
10095 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10096   # Extract the first word of "ranlib", so it can be a program name with args.
10097 set dummy ranlib; ac_word=$2
10098 echo "$as_me:$LINENO: checking for $ac_word" >&5
10099 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10100 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10101   echo $ECHO_N "(cached) $ECHO_C" >&6
10102 else
10103   case $RANLIB_FOR_TARGET in
10104   [\\/]* | ?:[\\/]*)
10105   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10106   ;;
10107   *)
10108   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10109 for as_dir in $gcc_cv_tool_dirs
10110 do
10111   IFS=$as_save_IFS
10112   test -z "$as_dir" && as_dir=.
10113   for ac_exec_ext in '' $ac_executable_extensions; do
10114   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10115     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10116     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10117     break 2
10118   fi
10119 done
10120 done
10121
10122   ;;
10123 esac
10124 fi
10125 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10126
10127 if test -n "$RANLIB_FOR_TARGET"; then
10128   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10129 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10130 else
10131   echo "$as_me:$LINENO: result: no" >&5
10132 echo "${ECHO_T}no" >&6
10133 fi
10134
10135 fi
10136 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10137
10138
10139 if test -n "$RANLIB_FOR_TARGET"; then
10140   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10141 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10142   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10143 fi
10144
10145 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10146   for ncn_progname in ranlib; do
10147     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10148 set dummy ${ncn_progname}; ac_word=$2
10149 echo "$as_me:$LINENO: checking for $ac_word" >&5
10150 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10151 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10152   echo $ECHO_N "(cached) $ECHO_C" >&6
10153 else
10154   if test -n "$RANLIB_FOR_TARGET"; then
10155   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10156 else
10157 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10158 for as_dir in $PATH
10159 do
10160   IFS=$as_save_IFS
10161   test -z "$as_dir" && as_dir=.
10162   for ac_exec_ext in '' $ac_executable_extensions; do
10163   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10164     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10165     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10166     break 2
10167   fi
10168 done
10169 done
10170
10171 fi
10172 fi
10173 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10174 if test -n "$RANLIB_FOR_TARGET"; then
10175   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10176 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10177 else
10178   echo "$as_me:$LINENO: result: no" >&5
10179 echo "${ECHO_T}no" >&6
10180 fi
10181
10182   done
10183 fi
10184
10185 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10186   for ncn_progname in ranlib; do
10187     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10188 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10189     if test -x $with_build_time_tools/${ncn_progname}; then
10190       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10191       echo "$as_me:$LINENO: result: yes" >&5
10192 echo "${ECHO_T}yes" >&6
10193       break
10194     else
10195       echo "$as_me:$LINENO: result: no" >&5
10196 echo "${ECHO_T}no" >&6
10197     fi
10198   done
10199 fi
10200
10201 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10202   for ncn_progname in ranlib; do
10203     if test -n "$ncn_target_tool_prefix"; then
10204       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10205 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10206 echo "$as_me:$LINENO: checking for $ac_word" >&5
10207 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10208 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10209   echo $ECHO_N "(cached) $ECHO_C" >&6
10210 else
10211   if test -n "$RANLIB_FOR_TARGET"; then
10212   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10213 else
10214 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10215 for as_dir in $PATH
10216 do
10217   IFS=$as_save_IFS
10218   test -z "$as_dir" && as_dir=.
10219   for ac_exec_ext in '' $ac_executable_extensions; do
10220   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10221     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10222     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10223     break 2
10224   fi
10225 done
10226 done
10227
10228 fi
10229 fi
10230 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10231 if test -n "$RANLIB_FOR_TARGET"; then
10232   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10233 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10234 else
10235   echo "$as_me:$LINENO: result: no" >&5
10236 echo "${ECHO_T}no" >&6
10237 fi
10238
10239     fi
10240     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10241       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10242 set dummy ${ncn_progname}; ac_word=$2
10243 echo "$as_me:$LINENO: checking for $ac_word" >&5
10244 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10245 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10246   echo $ECHO_N "(cached) $ECHO_C" >&6
10247 else
10248   if test -n "$RANLIB_FOR_TARGET"; then
10249   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10250 else
10251 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10252 for as_dir in $PATH
10253 do
10254   IFS=$as_save_IFS
10255   test -z "$as_dir" && as_dir=.
10256   for ac_exec_ext in '' $ac_executable_extensions; do
10257   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10258     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10259     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10260     break 2
10261   fi
10262 done
10263 done
10264
10265 fi
10266 fi
10267 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10268 if test -n "$RANLIB_FOR_TARGET"; then
10269   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10270 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10271 else
10272   echo "$as_me:$LINENO: result: no" >&5
10273 echo "${ECHO_T}no" >&6
10274 fi
10275
10276     fi
10277     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10278   done
10279 fi
10280
10281 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10282   set dummy ranlib
10283   if test $build = $target ; then
10284     RANLIB_FOR_TARGET="$2"
10285   else
10286     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10287   fi
10288 else
10289   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10290 fi
10291
10292 else
10293   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10294 fi
10295
10296
10297
10298
10299 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10300   if test -n "$with_build_time_tools"; then
10301     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10302 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10303     if test -x $with_build_time_tools/strip; then
10304       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10305       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10306       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10307 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10308     else
10309       echo "$as_me:$LINENO: result: no" >&5
10310 echo "${ECHO_T}no" >&6
10311     fi
10312   elif test $build != $host && test $have_gcc_for_target = yes; then
10313     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10314     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10315     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10316   fi
10317 fi
10318 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10319   # Extract the first word of "strip", so it can be a program name with args.
10320 set dummy strip; ac_word=$2
10321 echo "$as_me:$LINENO: checking for $ac_word" >&5
10322 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10323 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10324   echo $ECHO_N "(cached) $ECHO_C" >&6
10325 else
10326   case $STRIP_FOR_TARGET in
10327   [\\/]* | ?:[\\/]*)
10328   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10329   ;;
10330   *)
10331   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10332 for as_dir in $gcc_cv_tool_dirs
10333 do
10334   IFS=$as_save_IFS
10335   test -z "$as_dir" && as_dir=.
10336   for ac_exec_ext in '' $ac_executable_extensions; do
10337   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10338     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10339     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10340     break 2
10341   fi
10342 done
10343 done
10344
10345   ;;
10346 esac
10347 fi
10348 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10349
10350 if test -n "$STRIP_FOR_TARGET"; then
10351   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10352 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10353 else
10354   echo "$as_me:$LINENO: result: no" >&5
10355 echo "${ECHO_T}no" >&6
10356 fi
10357
10358 fi
10359 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10360
10361
10362 if test -n "$STRIP_FOR_TARGET"; then
10363   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10364 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10365   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10366 fi
10367
10368 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10369   for ncn_progname in strip; do
10370     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10371 set dummy ${ncn_progname}; ac_word=$2
10372 echo "$as_me:$LINENO: checking for $ac_word" >&5
10373 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10374 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10375   echo $ECHO_N "(cached) $ECHO_C" >&6
10376 else
10377   if test -n "$STRIP_FOR_TARGET"; then
10378   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10379 else
10380 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10381 for as_dir in $PATH
10382 do
10383   IFS=$as_save_IFS
10384   test -z "$as_dir" && as_dir=.
10385   for ac_exec_ext in '' $ac_executable_extensions; do
10386   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10387     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10388     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10389     break 2
10390   fi
10391 done
10392 done
10393
10394 fi
10395 fi
10396 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10397 if test -n "$STRIP_FOR_TARGET"; then
10398   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10399 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10400 else
10401   echo "$as_me:$LINENO: result: no" >&5
10402 echo "${ECHO_T}no" >&6
10403 fi
10404
10405   done
10406 fi
10407
10408 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10409   for ncn_progname in strip; do
10410     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10411 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10412     if test -x $with_build_time_tools/${ncn_progname}; then
10413       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10414       echo "$as_me:$LINENO: result: yes" >&5
10415 echo "${ECHO_T}yes" >&6
10416       break
10417     else
10418       echo "$as_me:$LINENO: result: no" >&5
10419 echo "${ECHO_T}no" >&6
10420     fi
10421   done
10422 fi
10423
10424 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10425   for ncn_progname in strip; do
10426     if test -n "$ncn_target_tool_prefix"; then
10427       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10428 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10429 echo "$as_me:$LINENO: checking for $ac_word" >&5
10430 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10431 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10432   echo $ECHO_N "(cached) $ECHO_C" >&6
10433 else
10434   if test -n "$STRIP_FOR_TARGET"; then
10435   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10436 else
10437 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10438 for as_dir in $PATH
10439 do
10440   IFS=$as_save_IFS
10441   test -z "$as_dir" && as_dir=.
10442   for ac_exec_ext in '' $ac_executable_extensions; do
10443   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10444     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10445     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10446     break 2
10447   fi
10448 done
10449 done
10450
10451 fi
10452 fi
10453 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10454 if test -n "$STRIP_FOR_TARGET"; then
10455   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10456 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10457 else
10458   echo "$as_me:$LINENO: result: no" >&5
10459 echo "${ECHO_T}no" >&6
10460 fi
10461
10462     fi
10463     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10464       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10465 set dummy ${ncn_progname}; ac_word=$2
10466 echo "$as_me:$LINENO: checking for $ac_word" >&5
10467 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10468 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10469   echo $ECHO_N "(cached) $ECHO_C" >&6
10470 else
10471   if test -n "$STRIP_FOR_TARGET"; then
10472   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10473 else
10474 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10475 for as_dir in $PATH
10476 do
10477   IFS=$as_save_IFS
10478   test -z "$as_dir" && as_dir=.
10479   for ac_exec_ext in '' $ac_executable_extensions; do
10480   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10481     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10482     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10483     break 2
10484   fi
10485 done
10486 done
10487
10488 fi
10489 fi
10490 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10491 if test -n "$STRIP_FOR_TARGET"; then
10492   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10493 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10494 else
10495   echo "$as_me:$LINENO: result: no" >&5
10496 echo "${ECHO_T}no" >&6
10497 fi
10498
10499     fi
10500     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10501   done
10502 fi
10503
10504 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10505   set dummy strip
10506   if test $build = $target ; then
10507     STRIP_FOR_TARGET="$2"
10508   else
10509     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10510   fi
10511 else
10512   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10513 fi
10514
10515 else
10516   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10517 fi
10518
10519
10520
10521
10522 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10523   if test -n "$with_build_time_tools"; then
10524     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10525 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10526     if test -x $with_build_time_tools/windres; then
10527       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10528       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10529       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10530 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10531     else
10532       echo "$as_me:$LINENO: result: no" >&5
10533 echo "${ECHO_T}no" >&6
10534     fi
10535   elif test $build != $host && test $have_gcc_for_target = yes; then
10536     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10537     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10538     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10539   fi
10540 fi
10541 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10542   # Extract the first word of "windres", so it can be a program name with args.
10543 set dummy windres; ac_word=$2
10544 echo "$as_me:$LINENO: checking for $ac_word" >&5
10545 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10546 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10547   echo $ECHO_N "(cached) $ECHO_C" >&6
10548 else
10549   case $WINDRES_FOR_TARGET in
10550   [\\/]* | ?:[\\/]*)
10551   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10552   ;;
10553   *)
10554   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10555 for as_dir in $gcc_cv_tool_dirs
10556 do
10557   IFS=$as_save_IFS
10558   test -z "$as_dir" && as_dir=.
10559   for ac_exec_ext in '' $ac_executable_extensions; do
10560   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10561     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10562     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10563     break 2
10564   fi
10565 done
10566 done
10567
10568   ;;
10569 esac
10570 fi
10571 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10572
10573 if test -n "$WINDRES_FOR_TARGET"; then
10574   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10575 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10576 else
10577   echo "$as_me:$LINENO: result: no" >&5
10578 echo "${ECHO_T}no" >&6
10579 fi
10580
10581 fi
10582 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10583
10584
10585 if test -n "$WINDRES_FOR_TARGET"; then
10586   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10587 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10588   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10589 fi
10590
10591 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10592   for ncn_progname in windres; do
10593     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10594 set dummy ${ncn_progname}; ac_word=$2
10595 echo "$as_me:$LINENO: checking for $ac_word" >&5
10596 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10597 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10598   echo $ECHO_N "(cached) $ECHO_C" >&6
10599 else
10600   if test -n "$WINDRES_FOR_TARGET"; then
10601   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10602 else
10603 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10604 for as_dir in $PATH
10605 do
10606   IFS=$as_save_IFS
10607   test -z "$as_dir" && as_dir=.
10608   for ac_exec_ext in '' $ac_executable_extensions; do
10609   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10610     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10611     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10612     break 2
10613   fi
10614 done
10615 done
10616
10617 fi
10618 fi
10619 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10620 if test -n "$WINDRES_FOR_TARGET"; then
10621   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10622 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10623 else
10624   echo "$as_me:$LINENO: result: no" >&5
10625 echo "${ECHO_T}no" >&6
10626 fi
10627
10628   done
10629 fi
10630
10631 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10632   for ncn_progname in windres; do
10633     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10634 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10635     if test -x $with_build_time_tools/${ncn_progname}; then
10636       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10637       echo "$as_me:$LINENO: result: yes" >&5
10638 echo "${ECHO_T}yes" >&6
10639       break
10640     else
10641       echo "$as_me:$LINENO: result: no" >&5
10642 echo "${ECHO_T}no" >&6
10643     fi
10644   done
10645 fi
10646
10647 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10648   for ncn_progname in windres; do
10649     if test -n "$ncn_target_tool_prefix"; then
10650       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10651 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10652 echo "$as_me:$LINENO: checking for $ac_word" >&5
10653 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10654 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10655   echo $ECHO_N "(cached) $ECHO_C" >&6
10656 else
10657   if test -n "$WINDRES_FOR_TARGET"; then
10658   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10659 else
10660 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10661 for as_dir in $PATH
10662 do
10663   IFS=$as_save_IFS
10664   test -z "$as_dir" && as_dir=.
10665   for ac_exec_ext in '' $ac_executable_extensions; do
10666   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10667     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10668     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10669     break 2
10670   fi
10671 done
10672 done
10673
10674 fi
10675 fi
10676 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10677 if test -n "$WINDRES_FOR_TARGET"; then
10678   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10679 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10680 else
10681   echo "$as_me:$LINENO: result: no" >&5
10682 echo "${ECHO_T}no" >&6
10683 fi
10684
10685     fi
10686     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
10687       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10688 set dummy ${ncn_progname}; ac_word=$2
10689 echo "$as_me:$LINENO: checking for $ac_word" >&5
10690 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10691 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10692   echo $ECHO_N "(cached) $ECHO_C" >&6
10693 else
10694   if test -n "$WINDRES_FOR_TARGET"; then
10695   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10696 else
10697 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10698 for as_dir in $PATH
10699 do
10700   IFS=$as_save_IFS
10701   test -z "$as_dir" && as_dir=.
10702   for ac_exec_ext in '' $ac_executable_extensions; do
10703   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10704     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10705     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10706     break 2
10707   fi
10708 done
10709 done
10710
10711 fi
10712 fi
10713 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10714 if test -n "$WINDRES_FOR_TARGET"; then
10715   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10716 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10717 else
10718   echo "$as_me:$LINENO: result: no" >&5
10719 echo "${ECHO_T}no" >&6
10720 fi
10721
10722     fi
10723     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
10724   done
10725 fi
10726
10727 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
10728   set dummy windres
10729   if test $build = $target ; then
10730     WINDRES_FOR_TARGET="$2"
10731   else
10732     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
10733   fi
10734 else
10735   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
10736 fi
10737
10738 else
10739   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10740 fi
10741
10742
10743 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
10744
10745 echo "$as_me:$LINENO: checking where to find the target ar" >&5
10746 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
10747 if test "x${build}" != "x${host}" ; then
10748   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
10749     # We already found the complete path
10750     ac_dir=`dirname $AR_FOR_TARGET`
10751     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10752 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10753   else
10754     # Canadian cross, just use what we found
10755     echo "$as_me:$LINENO: result: pre-installed" >&5
10756 echo "${ECHO_T}pre-installed" >&6
10757   fi
10758 else
10759   ok=yes
10760   case " ${configdirs} " in
10761     *" binutils "*) ;;
10762     *) ok=no ;;
10763   esac
10764
10765   if test $ok = yes; then
10766     # An in-tree tool is available and we can use it
10767     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
10768     echo "$as_me:$LINENO: result: just compiled" >&5
10769 echo "${ECHO_T}just compiled" >&6
10770   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
10771     # We already found the complete path
10772     ac_dir=`dirname $AR_FOR_TARGET`
10773     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10774 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10775   elif test "x$target" = "x$host"; then
10776     # We can use an host tool
10777     AR_FOR_TARGET='$(AR)'
10778     echo "$as_me:$LINENO: result: host tool" >&5
10779 echo "${ECHO_T}host tool" >&6
10780   else
10781     # We need a cross tool
10782     echo "$as_me:$LINENO: result: pre-installed" >&5
10783 echo "${ECHO_T}pre-installed" >&6
10784   fi
10785 fi
10786
10787 echo "$as_me:$LINENO: checking where to find the target as" >&5
10788 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
10789 if test "x${build}" != "x${host}" ; then
10790   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
10791     # We already found the complete path
10792     ac_dir=`dirname $AS_FOR_TARGET`
10793     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10794 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10795   else
10796     # Canadian cross, just use what we found
10797     echo "$as_me:$LINENO: result: pre-installed" >&5
10798 echo "${ECHO_T}pre-installed" >&6
10799   fi
10800 else
10801   ok=yes
10802   case " ${configdirs} " in
10803     *" gas "*) ;;
10804     *) ok=no ;;
10805   esac
10806
10807   if test $ok = yes; then
10808     # An in-tree tool is available and we can use it
10809     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
10810     echo "$as_me:$LINENO: result: just compiled" >&5
10811 echo "${ECHO_T}just compiled" >&6
10812   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
10813     # We already found the complete path
10814     ac_dir=`dirname $AS_FOR_TARGET`
10815     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10816 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10817   elif test "x$target" = "x$host"; then
10818     # We can use an host tool
10819     AS_FOR_TARGET='$(AS)'
10820     echo "$as_me:$LINENO: result: host tool" >&5
10821 echo "${ECHO_T}host tool" >&6
10822   else
10823     # We need a cross tool
10824     echo "$as_me:$LINENO: result: pre-installed" >&5
10825 echo "${ECHO_T}pre-installed" >&6
10826   fi
10827 fi
10828
10829 echo "$as_me:$LINENO: checking where to find the target cc" >&5
10830 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
10831 if test "x${build}" != "x${host}" ; then
10832   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
10833     # We already found the complete path
10834     ac_dir=`dirname $CC_FOR_TARGET`
10835     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10836 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10837   else
10838     # Canadian cross, just use what we found
10839     echo "$as_me:$LINENO: result: pre-installed" >&5
10840 echo "${ECHO_T}pre-installed" >&6
10841   fi
10842 else
10843   ok=yes
10844   case " ${configdirs} " in
10845     *" gcc "*) ;;
10846     *) ok=no ;;
10847   esac
10848
10849   if test $ok = yes; then
10850     # An in-tree tool is available and we can use it
10851     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
10852     echo "$as_me:$LINENO: result: just compiled" >&5
10853 echo "${ECHO_T}just compiled" >&6
10854   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
10855     # We already found the complete path
10856     ac_dir=`dirname $CC_FOR_TARGET`
10857     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10858 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10859   elif test "x$target" = "x$host"; then
10860     # We can use an host tool
10861     CC_FOR_TARGET='$(CC)'
10862     echo "$as_me:$LINENO: result: host tool" >&5
10863 echo "${ECHO_T}host tool" >&6
10864   else
10865     # We need a cross tool
10866     echo "$as_me:$LINENO: result: pre-installed" >&5
10867 echo "${ECHO_T}pre-installed" >&6
10868   fi
10869 fi
10870
10871 echo "$as_me:$LINENO: checking where to find the target c++" >&5
10872 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
10873 if test "x${build}" != "x${host}" ; then
10874   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
10875     # We already found the complete path
10876     ac_dir=`dirname $CXX_FOR_TARGET`
10877     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10878 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10879   else
10880     # Canadian cross, just use what we found
10881     echo "$as_me:$LINENO: result: pre-installed" >&5
10882 echo "${ECHO_T}pre-installed" >&6
10883   fi
10884 else
10885   ok=yes
10886   case " ${configdirs} " in
10887     *" gcc "*) ;;
10888     *) ok=no ;;
10889   esac
10890   case ,${enable_languages}, in
10891     *,c++,*) ;;
10892     *) ok=no ;;
10893   esac
10894   if test $ok = yes; then
10895     # An in-tree tool is available and we can use it
10896     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'
10897     echo "$as_me:$LINENO: result: just compiled" >&5
10898 echo "${ECHO_T}just compiled" >&6
10899   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
10900     # We already found the complete path
10901     ac_dir=`dirname $CXX_FOR_TARGET`
10902     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10903 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10904   elif test "x$target" = "x$host"; then
10905     # We can use an host tool
10906     CXX_FOR_TARGET='$(CXX)'
10907     echo "$as_me:$LINENO: result: host tool" >&5
10908 echo "${ECHO_T}host tool" >&6
10909   else
10910     # We need a cross tool
10911     echo "$as_me:$LINENO: result: pre-installed" >&5
10912 echo "${ECHO_T}pre-installed" >&6
10913   fi
10914 fi
10915
10916 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
10917 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
10918 if test "x${build}" != "x${host}" ; then
10919   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
10920     # We already found the complete path
10921     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
10922     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10923 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10924   else
10925     # Canadian cross, just use what we found
10926     echo "$as_me:$LINENO: result: pre-installed" >&5
10927 echo "${ECHO_T}pre-installed" >&6
10928   fi
10929 else
10930   ok=yes
10931   case " ${configdirs} " in
10932     *" gcc "*) ;;
10933     *) ok=no ;;
10934   esac
10935   case ,${enable_languages}, in
10936     *,c++,*) ;;
10937     *) ok=no ;;
10938   esac
10939   if test $ok = yes; then
10940     # An in-tree tool is available and we can use it
10941     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'
10942     echo "$as_me:$LINENO: result: just compiled" >&5
10943 echo "${ECHO_T}just compiled" >&6
10944   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
10945     # We already found the complete path
10946     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
10947     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10948 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10949   elif test "x$target" = "x$host"; then
10950     # We can use an host tool
10951     RAW_CXX_FOR_TARGET='$(CXX)'
10952     echo "$as_me:$LINENO: result: host tool" >&5
10953 echo "${ECHO_T}host tool" >&6
10954   else
10955     # We need a cross tool
10956     echo "$as_me:$LINENO: result: pre-installed" >&5
10957 echo "${ECHO_T}pre-installed" >&6
10958   fi
10959 fi
10960
10961 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
10962 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
10963 if test "x${build}" != "x${host}" ; then
10964   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
10965     # We already found the complete path
10966     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
10967     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10968 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10969   else
10970     # Canadian cross, just use what we found
10971     echo "$as_me:$LINENO: result: pre-installed" >&5
10972 echo "${ECHO_T}pre-installed" >&6
10973   fi
10974 else
10975   ok=yes
10976   case " ${configdirs} " in
10977     *" binutils "*) ;;
10978     *) ok=no ;;
10979   esac
10980
10981   if test $ok = yes; then
10982     # An in-tree tool is available and we can use it
10983     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
10984     echo "$as_me:$LINENO: result: just compiled" >&5
10985 echo "${ECHO_T}just compiled" >&6
10986   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
10987     # We already found the complete path
10988     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
10989     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10990 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10991   elif test "x$target" = "x$host"; then
10992     # We can use an host tool
10993     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
10994     echo "$as_me:$LINENO: result: host tool" >&5
10995 echo "${ECHO_T}host tool" >&6
10996   else
10997     # We need a cross tool
10998     echo "$as_me:$LINENO: result: pre-installed" >&5
10999 echo "${ECHO_T}pre-installed" >&6
11000   fi
11001 fi
11002
11003 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11004 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11005 if test "x${build}" != "x${host}" ; then
11006   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11007     # We already found the complete path
11008     ac_dir=`dirname $GCC_FOR_TARGET`
11009     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11010 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11011   else
11012     # Canadian cross, just use what we found
11013     echo "$as_me:$LINENO: result: pre-installed" >&5
11014 echo "${ECHO_T}pre-installed" >&6
11015   fi
11016 else
11017   ok=yes
11018   case " ${configdirs} " in
11019     *" gcc "*) ;;
11020     *) ok=no ;;
11021   esac
11022
11023   if test $ok = yes; then
11024     # An in-tree tool is available and we can use it
11025     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11026     echo "$as_me:$LINENO: result: just compiled" >&5
11027 echo "${ECHO_T}just compiled" >&6
11028   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11029     # We already found the complete path
11030     ac_dir=`dirname $GCC_FOR_TARGET`
11031     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11032 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11033   elif test "x$target" = "x$host"; then
11034     # We can use an host tool
11035     GCC_FOR_TARGET='$()'
11036     echo "$as_me:$LINENO: result: host tool" >&5
11037 echo "${ECHO_T}host tool" >&6
11038   else
11039     # We need a cross tool
11040     echo "$as_me:$LINENO: result: pre-installed" >&5
11041 echo "${ECHO_T}pre-installed" >&6
11042   fi
11043 fi
11044
11045 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11046 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11047 if test "x${build}" != "x${host}" ; then
11048   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11049     # We already found the complete path
11050     ac_dir=`dirname $GCJ_FOR_TARGET`
11051     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11052 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11053   else
11054     # Canadian cross, just use what we found
11055     echo "$as_me:$LINENO: result: pre-installed" >&5
11056 echo "${ECHO_T}pre-installed" >&6
11057   fi
11058 else
11059   ok=yes
11060   case " ${configdirs} " in
11061     *" gcc "*) ;;
11062     *) ok=no ;;
11063   esac
11064   case ,${enable_languages}, in
11065     *,java,*) ;;
11066     *) ok=no ;;
11067   esac
11068   if test $ok = yes; then
11069     # An in-tree tool is available and we can use it
11070     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11071     echo "$as_me:$LINENO: result: just compiled" >&5
11072 echo "${ECHO_T}just compiled" >&6
11073   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11074     # We already found the complete path
11075     ac_dir=`dirname $GCJ_FOR_TARGET`
11076     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11077 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11078   elif test "x$target" = "x$host"; then
11079     # We can use an host tool
11080     GCJ_FOR_TARGET='$(GCJ)'
11081     echo "$as_me:$LINENO: result: host tool" >&5
11082 echo "${ECHO_T}host tool" >&6
11083   else
11084     # We need a cross tool
11085     echo "$as_me:$LINENO: result: pre-installed" >&5
11086 echo "${ECHO_T}pre-installed" >&6
11087   fi
11088 fi
11089
11090 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11091 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11092 if test "x${build}" != "x${host}" ; then
11093   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11094     # We already found the complete path
11095     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11096     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11097 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11098   else
11099     # Canadian cross, just use what we found
11100     echo "$as_me:$LINENO: result: pre-installed" >&5
11101 echo "${ECHO_T}pre-installed" >&6
11102   fi
11103 else
11104   ok=yes
11105   case " ${configdirs} " in
11106     *" gcc "*) ;;
11107     *) ok=no ;;
11108   esac
11109   case ,${enable_languages}, in
11110     *,fortran,*) ;;
11111     *) ok=no ;;
11112   esac
11113   if test $ok = yes; then
11114     # An in-tree tool is available and we can use it
11115     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11116     echo "$as_me:$LINENO: result: just compiled" >&5
11117 echo "${ECHO_T}just compiled" >&6
11118   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11119     # We already found the complete path
11120     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11121     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11122 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11123   elif test "x$target" = "x$host"; then
11124     # We can use an host tool
11125     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11126     echo "$as_me:$LINENO: result: host tool" >&5
11127 echo "${ECHO_T}host tool" >&6
11128   else
11129     # We need a cross tool
11130     echo "$as_me:$LINENO: result: pre-installed" >&5
11131 echo "${ECHO_T}pre-installed" >&6
11132   fi
11133 fi
11134
11135 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11136 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11137 if test "x${build}" != "x${host}" ; then
11138   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11139     # We already found the complete path
11140     ac_dir=`dirname $LD_FOR_TARGET`
11141     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11142 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11143   else
11144     # Canadian cross, just use what we found
11145     echo "$as_me:$LINENO: result: pre-installed" >&5
11146 echo "${ECHO_T}pre-installed" >&6
11147   fi
11148 else
11149   ok=yes
11150   case " ${configdirs} " in
11151     *" ld "*) ;;
11152     *) ok=no ;;
11153   esac
11154
11155   if test $ok = yes; then
11156     # An in-tree tool is available and we can use it
11157     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11158     echo "$as_me:$LINENO: result: just compiled" >&5
11159 echo "${ECHO_T}just compiled" >&6
11160   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11161     # We already found the complete path
11162     ac_dir=`dirname $LD_FOR_TARGET`
11163     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11164 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11165   elif test "x$target" = "x$host"; then
11166     # We can use an host tool
11167     LD_FOR_TARGET='$(LD)'
11168     echo "$as_me:$LINENO: result: host tool" >&5
11169 echo "${ECHO_T}host tool" >&6
11170   else
11171     # We need a cross tool
11172     echo "$as_me:$LINENO: result: pre-installed" >&5
11173 echo "${ECHO_T}pre-installed" >&6
11174   fi
11175 fi
11176
11177 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11178 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11179 if test "x${build}" != "x${host}" ; then
11180   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11181     # We already found the complete path
11182     ac_dir=`dirname $LIPO_FOR_TARGET`
11183     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11184 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11185   else
11186     # Canadian cross, just use what we found
11187     echo "$as_me:$LINENO: result: pre-installed" >&5
11188 echo "${ECHO_T}pre-installed" >&6
11189   fi
11190 else
11191   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11192     # We already found the complete path
11193     ac_dir=`dirname $LIPO_FOR_TARGET`
11194     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11195 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11196   elif test "x$target" = "x$host"; then
11197     # We can use an host tool
11198     LIPO_FOR_TARGET='$(LIPO)'
11199     echo "$as_me:$LINENO: result: host tool" >&5
11200 echo "${ECHO_T}host tool" >&6
11201   else
11202     # We need a cross tool
11203     echo "$as_me:$LINENO: result: pre-installed" >&5
11204 echo "${ECHO_T}pre-installed" >&6
11205   fi
11206 fi
11207
11208 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11209 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11210 if test "x${build}" != "x${host}" ; then
11211   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11212     # We already found the complete path
11213     ac_dir=`dirname $NM_FOR_TARGET`
11214     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11215 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11216   else
11217     # Canadian cross, just use what we found
11218     echo "$as_me:$LINENO: result: pre-installed" >&5
11219 echo "${ECHO_T}pre-installed" >&6
11220   fi
11221 else
11222   ok=yes
11223   case " ${configdirs} " in
11224     *" binutils "*) ;;
11225     *) ok=no ;;
11226   esac
11227
11228   if test $ok = yes; then
11229     # An in-tree tool is available and we can use it
11230     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11231     echo "$as_me:$LINENO: result: just compiled" >&5
11232 echo "${ECHO_T}just compiled" >&6
11233   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11234     # We already found the complete path
11235     ac_dir=`dirname $NM_FOR_TARGET`
11236     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11237 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11238   elif test "x$target" = "x$host"; then
11239     # We can use an host tool
11240     NM_FOR_TARGET='$(NM)'
11241     echo "$as_me:$LINENO: result: host tool" >&5
11242 echo "${ECHO_T}host tool" >&6
11243   else
11244     # We need a cross tool
11245     echo "$as_me:$LINENO: result: pre-installed" >&5
11246 echo "${ECHO_T}pre-installed" >&6
11247   fi
11248 fi
11249
11250 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11251 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11252 if test "x${build}" != "x${host}" ; then
11253   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11254     # We already found the complete path
11255     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11256     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11257 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11258   else
11259     # Canadian cross, just use what we found
11260     echo "$as_me:$LINENO: result: pre-installed" >&5
11261 echo "${ECHO_T}pre-installed" >&6
11262   fi
11263 else
11264   ok=yes
11265   case " ${configdirs} " in
11266     *" binutils "*) ;;
11267     *) ok=no ;;
11268   esac
11269
11270   if test $ok = yes; then
11271     # An in-tree tool is available and we can use it
11272     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11273     echo "$as_me:$LINENO: result: just compiled" >&5
11274 echo "${ECHO_T}just compiled" >&6
11275   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11276     # We already found the complete path
11277     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11278     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11279 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11280   elif test "x$target" = "x$host"; then
11281     # We can use an host tool
11282     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11283     echo "$as_me:$LINENO: result: host tool" >&5
11284 echo "${ECHO_T}host tool" >&6
11285   else
11286     # We need a cross tool
11287     echo "$as_me:$LINENO: result: pre-installed" >&5
11288 echo "${ECHO_T}pre-installed" >&6
11289   fi
11290 fi
11291
11292 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11293 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11294 if test "x${build}" != "x${host}" ; then
11295   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11296     # We already found the complete path
11297     ac_dir=`dirname $RANLIB_FOR_TARGET`
11298     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11299 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11300   else
11301     # Canadian cross, just use what we found
11302     echo "$as_me:$LINENO: result: pre-installed" >&5
11303 echo "${ECHO_T}pre-installed" >&6
11304   fi
11305 else
11306   ok=yes
11307   case " ${configdirs} " in
11308     *" binutils "*) ;;
11309     *) ok=no ;;
11310   esac
11311
11312   if test $ok = yes; then
11313     # An in-tree tool is available and we can use it
11314     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11315     echo "$as_me:$LINENO: result: just compiled" >&5
11316 echo "${ECHO_T}just compiled" >&6
11317   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11318     # We already found the complete path
11319     ac_dir=`dirname $RANLIB_FOR_TARGET`
11320     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11321 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11322   elif test "x$target" = "x$host"; then
11323     # We can use an host tool
11324     RANLIB_FOR_TARGET='$(RANLIB)'
11325     echo "$as_me:$LINENO: result: host tool" >&5
11326 echo "${ECHO_T}host tool" >&6
11327   else
11328     # We need a cross tool
11329     echo "$as_me:$LINENO: result: pre-installed" >&5
11330 echo "${ECHO_T}pre-installed" >&6
11331   fi
11332 fi
11333
11334 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11335 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11336 if test "x${build}" != "x${host}" ; then
11337   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11338     # We already found the complete path
11339     ac_dir=`dirname $STRIP_FOR_TARGET`
11340     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11341 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11342   else
11343     # Canadian cross, just use what we found
11344     echo "$as_me:$LINENO: result: pre-installed" >&5
11345 echo "${ECHO_T}pre-installed" >&6
11346   fi
11347 else
11348   ok=yes
11349   case " ${configdirs} " in
11350     *" binutils "*) ;;
11351     *) ok=no ;;
11352   esac
11353
11354   if test $ok = yes; then
11355     # An in-tree tool is available and we can use it
11356     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11357     echo "$as_me:$LINENO: result: just compiled" >&5
11358 echo "${ECHO_T}just compiled" >&6
11359   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11360     # We already found the complete path
11361     ac_dir=`dirname $STRIP_FOR_TARGET`
11362     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11363 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11364   elif test "x$target" = "x$host"; then
11365     # We can use an host tool
11366     STRIP_FOR_TARGET='$(STRIP)'
11367     echo "$as_me:$LINENO: result: host tool" >&5
11368 echo "${ECHO_T}host tool" >&6
11369   else
11370     # We need a cross tool
11371     echo "$as_me:$LINENO: result: pre-installed" >&5
11372 echo "${ECHO_T}pre-installed" >&6
11373   fi
11374 fi
11375
11376 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11377 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11378 if test "x${build}" != "x${host}" ; then
11379   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11380     # We already found the complete path
11381     ac_dir=`dirname $WINDRES_FOR_TARGET`
11382     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11383 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11384   else
11385     # Canadian cross, just use what we found
11386     echo "$as_me:$LINENO: result: pre-installed" >&5
11387 echo "${ECHO_T}pre-installed" >&6
11388   fi
11389 else
11390   ok=yes
11391   case " ${configdirs} " in
11392     *" binutils "*) ;;
11393     *) ok=no ;;
11394   esac
11395
11396   if test $ok = yes; then
11397     # An in-tree tool is available and we can use it
11398     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11399     echo "$as_me:$LINENO: result: just compiled" >&5
11400 echo "${ECHO_T}just compiled" >&6
11401   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11402     # We already found the complete path
11403     ac_dir=`dirname $WINDRES_FOR_TARGET`
11404     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11405 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11406   elif test "x$target" = "x$host"; then
11407     # We can use an host tool
11408     WINDRES_FOR_TARGET='$(WINDRES)'
11409     echo "$as_me:$LINENO: result: host tool" >&5
11410 echo "${ECHO_T}host tool" >&6
11411   else
11412     # We need a cross tool
11413     echo "$as_me:$LINENO: result: pre-installed" >&5
11414 echo "${ECHO_T}pre-installed" >&6
11415   fi
11416 fi
11417
11418
11419
11420
11421
11422 # Certain tools may need extra flags.
11423 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
11424 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
11425 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
11426
11427 # When building target libraries, except in a Canadian cross, we use
11428 # the same toolchain as the compiler we just built.
11429 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
11430 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
11431 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
11432 if test $host = $build; then
11433   case " $configdirs " in
11434     *" gcc "*)
11435       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
11436       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
11437       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
11438       ;;
11439   esac
11440 fi
11441
11442
11443
11444
11445
11446 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
11447 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
11448 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
11449 if test "${enable_maintainer_mode+set}" = set; then
11450   enableval="$enable_maintainer_mode"
11451   USE_MAINTAINER_MODE=$enableval
11452 else
11453   USE_MAINTAINER_MODE=no
11454 fi;
11455 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
11456 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
11457
11458
11459 if test "$USE_MAINTAINER_MODE" = yes; then
11460   MAINTAINER_MODE_TRUE=
11461   MAINTAINER_MODE_FALSE='#'
11462 else
11463   MAINTAINER_MODE_TRUE='#'
11464   MAINTAINER_MODE_FALSE=
11465 fi
11466 MAINT=$MAINTAINER_MODE_TRUE
11467
11468 # ---------------------
11469 # GCC bootstrap support
11470 # ---------------------
11471
11472 # Stage specific cflags for build.
11473 stage1_cflags="-g"
11474 case $build in
11475   vax-*-*)
11476     case ${GCC} in
11477       yes) stage1_cflags="-g -Wa,-J" ;;
11478       *) stage1_cflags="-g -J" ;;
11479     esac ;;
11480 esac
11481
11482 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
11483 if test "$GCC" = yes; then
11484   saved_CFLAGS="$CFLAGS"
11485
11486   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
11487   CFLAGS="$CFLAGS -fkeep-inline-functions"
11488   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
11489 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
11490   cat >conftest.$ac_ext <<_ACEOF
11491 /* confdefs.h.  */
11492 _ACEOF
11493 cat confdefs.h >>conftest.$ac_ext
11494 cat >>conftest.$ac_ext <<_ACEOF
11495 /* end confdefs.h.  */
11496
11497 #if (__GNUC__ < 3) \
11498     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
11499                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
11500 #error http://gcc.gnu.org/PR29382
11501 #endif
11502
11503 int
11504 main ()
11505 {
11506
11507   ;
11508   return 0;
11509 }
11510 _ACEOF
11511 rm -f conftest.$ac_objext
11512 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11513   (eval $ac_compile) 2>conftest.er1
11514   ac_status=$?
11515   grep -v '^ *+' conftest.er1 >conftest.err
11516   rm -f conftest.er1
11517   cat conftest.err >&5
11518   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11519   (exit $ac_status); } &&
11520          { ac_try='test -z "$ac_c_werror_flag"
11521                          || test ! -s conftest.err'
11522   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11523   (eval $ac_try) 2>&5
11524   ac_status=$?
11525   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11526   (exit $ac_status); }; } &&
11527          { ac_try='test -s conftest.$ac_objext'
11528   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11529   (eval $ac_try) 2>&5
11530   ac_status=$?
11531   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11532   (exit $ac_status); }; }; then
11533   echo "$as_me:$LINENO: result: yes" >&5
11534 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
11535 else
11536   echo "$as_me: failed program was:" >&5
11537 sed 's/^/| /' conftest.$ac_ext >&5
11538
11539 echo "$as_me:$LINENO: result: no" >&5
11540 echo "${ECHO_T}no" >&6
11541 fi
11542 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11543
11544   CFLAGS="$saved_CFLAGS"
11545 fi
11546
11547
11548
11549 # Enable --enable-checking in stage1 of the compiler.
11550 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
11551 if test "${enable_stage1_checking+set}" = set; then
11552   enableval="$enable_stage1_checking"
11553   stage1_checking=--enable-checking=${enable_stage1_checking}
11554 else
11555   if test "x$enable_checking" = xno; then
11556   stage1_checking=--enable-checking
11557 else
11558   stage1_checking=--enable-checking${enable_checking+=}$enable_checking
11559 fi
11560 fi;
11561
11562
11563 # Enable -Werror in bootstrap stage2 and later.
11564 # Check whether --enable-werror or --disable-werror was given.
11565 if test "${enable_werror+set}" = set; then
11566   enableval="$enable_werror"
11567
11568 else
11569   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
11570   enable_werror=yes
11571 else
11572   enable_werror=no
11573 fi
11574 fi;
11575 case ${enable_werror} in
11576   yes) stage2_werror_flag="--enable-werror-always" ;;
11577   *) stage2_werror_flag="" ;;
11578 esac
11579
11580
11581 # Flags needed to enable html installing and building
11582
11583 # Check whether --with-datarootdir or --without-datarootdir was given.
11584 if test "${with_datarootdir+set}" = set; then
11585   withval="$with_datarootdir"
11586   datarootdir="\${prefix}/${withval}"
11587 else
11588   datarootdir="\${prefix}/share"
11589 fi;
11590
11591
11592 # Check whether --with-docdir or --without-docdir was given.
11593 if test "${with_docdir+set}" = set; then
11594   withval="$with_docdir"
11595   docdir="\${prefix}/${withval}"
11596 else
11597   docdir="\${datarootdir}/doc"
11598 fi;
11599
11600
11601 # Check whether --with-pdfdir or --without-pdfdir was given.
11602 if test "${with_pdfdir+set}" = set; then
11603   withval="$with_pdfdir"
11604   pdfdir="\${prefix}/${withval}"
11605 else
11606   pdfdir="\${docdir}"
11607 fi;
11608
11609
11610 # Check whether --with-htmldir or --without-htmldir was given.
11611 if test "${with_htmldir+set}" = set; then
11612   withval="$with_htmldir"
11613   htmldir="\${prefix}/${withval}"
11614 else
11615   htmldir="\${docdir}"
11616 fi;
11617
11618
11619
11620
11621
11622
11623           ac_config_files="$ac_config_files Makefile"
11624 cat >confcache <<\_ACEOF
11625 # This file is a shell script that caches the results of configure
11626 # tests run on this system so they can be shared between configure
11627 # scripts and configure runs, see configure's option --config-cache.
11628 # It is not useful on other systems.  If it contains results you don't
11629 # want to keep, you may remove or edit it.
11630 #
11631 # config.status only pays attention to the cache file if you give it
11632 # the --recheck option to rerun configure.
11633 #
11634 # `ac_cv_env_foo' variables (set or unset) will be overridden when
11635 # loading this file, other *unset* `ac_cv_foo' will be assigned the
11636 # following values.
11637
11638 _ACEOF
11639
11640 # The following way of writing the cache mishandles newlines in values,
11641 # but we know of no workaround that is simple, portable, and efficient.
11642 # So, don't put newlines in cache variables' values.
11643 # Ultrix sh set writes to stderr and can't be redirected directly,
11644 # and sets the high bit in the cache file unless we assign to the vars.
11645 {
11646   (set) 2>&1 |
11647     case `(ac_space=' '; set | grep ac_space) 2>&1` in
11648     *ac_space=\ *)
11649       # `set' does not quote correctly, so add quotes (double-quote
11650       # substitution turns \\\\ into \\, and sed turns \\ into \).
11651       sed -n \
11652         "s/'/'\\\\''/g;
11653           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
11654       ;;
11655     *)
11656       # `set' quotes correctly as required by POSIX, so do not add quotes.
11657       sed -n \
11658         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
11659       ;;
11660     esac;
11661 } |
11662   sed '
11663      t clear
11664      : clear
11665      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
11666      t end
11667      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
11668      : end' >>confcache
11669 if diff $cache_file confcache >/dev/null 2>&1; then :; else
11670   if test -w $cache_file; then
11671     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
11672     cat confcache >$cache_file
11673   else
11674     echo "not updating unwritable cache $cache_file"
11675   fi
11676 fi
11677 rm -f confcache
11678
11679 test "x$prefix" = xNONE && prefix=$ac_default_prefix
11680 # Let make expand exec_prefix.
11681 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
11682
11683 # VPATH may cause trouble with some makes, so we remove $(srcdir),
11684 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
11685 # trailing colons and then remove the whole line if VPATH becomes empty
11686 # (actually we leave an empty line to preserve line numbers).
11687 if test "x$srcdir" = x.; then
11688   ac_vpsub='/^[  ]*VPATH[        ]*=/{
11689 s/:*\$(srcdir):*/:/;
11690 s/:*\${srcdir}:*/:/;
11691 s/:*@srcdir@:*/:/;
11692 s/^\([^=]*=[     ]*\):*/\1/;
11693 s/:*$//;
11694 s/^[^=]*=[       ]*$//;
11695 }'
11696 fi
11697
11698 # Transform confdefs.h into DEFS.
11699 # Protect against shell expansion while executing Makefile rules.
11700 # Protect against Makefile macro expansion.
11701 #
11702 # If the first sed substitution is executed (which looks for macros that
11703 # take arguments), then we branch to the quote section.  Otherwise,
11704 # look for a macro that doesn't take arguments.
11705 cat >confdef2opt.sed <<\_ACEOF
11706 t clear
11707 : clear
11708 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
11709 t quote
11710 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
11711 t quote
11712 d
11713 : quote
11714 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
11715 s,\[,\\&,g
11716 s,\],\\&,g
11717 s,\$,$$,g
11718 p
11719 _ACEOF
11720 # We use echo to avoid assuming a particular line-breaking character.
11721 # The extra dot is to prevent the shell from consuming trailing
11722 # line-breaks from the sub-command output.  A line-break within
11723 # single-quotes doesn't work because, if this script is created in a
11724 # platform that uses two characters for line-breaks (e.g., DOS), tr
11725 # would break.
11726 ac_LF_and_DOT=`echo; echo .`
11727 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
11728 rm -f confdef2opt.sed
11729
11730
11731 ac_libobjs=
11732 ac_ltlibobjs=
11733 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
11734   # 1. Remove the extension, and $U if already installed.
11735   ac_i=`echo "$ac_i" |
11736          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
11737   # 2. Add them.
11738   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
11739   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
11740 done
11741 LIBOBJS=$ac_libobjs
11742
11743 LTLIBOBJS=$ac_ltlibobjs
11744
11745
11746
11747 : ${CONFIG_STATUS=./config.status}
11748 ac_clean_files_save=$ac_clean_files
11749 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
11750 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
11751 echo "$as_me: creating $CONFIG_STATUS" >&6;}
11752 cat >$CONFIG_STATUS <<_ACEOF
11753 #! $SHELL
11754 # Generated by $as_me.
11755 # Run this file to recreate the current configuration.
11756 # Compiler output produced by configure, useful for debugging
11757 # configure, is in config.log if it exists.
11758
11759 debug=false
11760 ac_cs_recheck=false
11761 ac_cs_silent=false
11762 SHELL=\${CONFIG_SHELL-$SHELL}
11763 _ACEOF
11764
11765 cat >>$CONFIG_STATUS <<\_ACEOF
11766 ## --------------------- ##
11767 ## M4sh Initialization.  ##
11768 ## --------------------- ##
11769
11770 # Be Bourne compatible
11771 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
11772   emulate sh
11773   NULLCMD=:
11774   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
11775   # is contrary to our usage.  Disable this feature.
11776   alias -g '${1+"$@"}'='"$@"'
11777 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
11778   set -o posix
11779 fi
11780 DUALCASE=1; export DUALCASE # for MKS sh
11781
11782 # Support unset when possible.
11783 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
11784   as_unset=unset
11785 else
11786   as_unset=false
11787 fi
11788
11789
11790 # Work around bugs in pre-3.0 UWIN ksh.
11791 $as_unset ENV MAIL MAILPATH
11792 PS1='$ '
11793 PS2='> '
11794 PS4='+ '
11795
11796 # NLS nuisances.
11797 for as_var in \
11798   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
11799   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
11800   LC_TELEPHONE LC_TIME
11801 do
11802   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
11803     eval $as_var=C; export $as_var
11804   else
11805     $as_unset $as_var
11806   fi
11807 done
11808
11809 # Required to use basename.
11810 if expr a : '\(a\)' >/dev/null 2>&1; then
11811   as_expr=expr
11812 else
11813   as_expr=false
11814 fi
11815
11816 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
11817   as_basename=basename
11818 else
11819   as_basename=false
11820 fi
11821
11822
11823 # Name of the executable.
11824 as_me=`$as_basename "$0" ||
11825 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
11826          X"$0" : 'X\(//\)$' \| \
11827          X"$0" : 'X\(/\)$' \| \
11828          .     : '\(.\)' 2>/dev/null ||
11829 echo X/"$0" |
11830     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
11831           /^X\/\(\/\/\)$/{ s//\1/; q; }
11832           /^X\/\(\/\).*/{ s//\1/; q; }
11833           s/.*/./; q'`
11834
11835
11836 # PATH needs CR, and LINENO needs CR and PATH.
11837 # Avoid depending upon Character Ranges.
11838 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
11839 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
11840 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
11841 as_cr_digits='0123456789'
11842 as_cr_alnum=$as_cr_Letters$as_cr_digits
11843
11844 # The user is always right.
11845 if test "${PATH_SEPARATOR+set}" != set; then
11846   echo "#! /bin/sh" >conf$$.sh
11847   echo  "exit 0"   >>conf$$.sh
11848   chmod +x conf$$.sh
11849   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
11850     PATH_SEPARATOR=';'
11851   else
11852     PATH_SEPARATOR=:
11853   fi
11854   rm -f conf$$.sh
11855 fi
11856
11857
11858   as_lineno_1=$LINENO
11859   as_lineno_2=$LINENO
11860   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
11861   test "x$as_lineno_1" != "x$as_lineno_2" &&
11862   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
11863   # Find who we are.  Look in the path if we contain no path at all
11864   # relative or not.
11865   case $0 in
11866     *[\\/]* ) as_myself=$0 ;;
11867     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11868 for as_dir in $PATH
11869 do
11870   IFS=$as_save_IFS
11871   test -z "$as_dir" && as_dir=.
11872   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
11873 done
11874
11875        ;;
11876   esac
11877   # We did not find ourselves, most probably we were run as `sh COMMAND'
11878   # in which case we are not to be found in the path.
11879   if test "x$as_myself" = x; then
11880     as_myself=$0
11881   fi
11882   if test ! -f "$as_myself"; then
11883     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
11884 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
11885    { (exit 1); exit 1; }; }
11886   fi
11887   case $CONFIG_SHELL in
11888   '')
11889     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11890 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
11891 do
11892   IFS=$as_save_IFS
11893   test -z "$as_dir" && as_dir=.
11894   for as_base in sh bash ksh sh5; do
11895          case $as_dir in
11896          /*)
11897            if ("$as_dir/$as_base" -c '
11898   as_lineno_1=$LINENO
11899   as_lineno_2=$LINENO
11900   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
11901   test "x$as_lineno_1" != "x$as_lineno_2" &&
11902   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
11903              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
11904              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
11905              CONFIG_SHELL=$as_dir/$as_base
11906              export CONFIG_SHELL
11907              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
11908            fi;;
11909          esac
11910        done
11911 done
11912 ;;
11913   esac
11914
11915   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
11916   # uniformly replaced by the line number.  The first 'sed' inserts a
11917   # line-number line before each line; the second 'sed' does the real
11918   # work.  The second script uses 'N' to pair each line-number line
11919   # with the numbered line, and appends trailing '-' during
11920   # substitution so that $LINENO is not a special case at line end.
11921   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
11922   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
11923   sed '=' <$as_myself |
11924     sed '
11925       N
11926       s,$,-,
11927       : loop
11928       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
11929       t loop
11930       s,-$,,
11931       s,^['$as_cr_digits']*\n,,
11932     ' >$as_me.lineno &&
11933   chmod +x $as_me.lineno ||
11934     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
11935 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
11936    { (exit 1); exit 1; }; }
11937
11938   # Don't try to exec as it changes $[0], causing all sort of problems
11939   # (the dirname of $[0] is not the place where we might find the
11940   # original and so on.  Autoconf is especially sensible to this).
11941   . ./$as_me.lineno
11942   # Exit status is that of the last command.
11943   exit
11944 }
11945
11946
11947 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
11948   *c*,-n*) ECHO_N= ECHO_C='
11949 ' ECHO_T='      ' ;;
11950   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
11951   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
11952 esac
11953
11954 if expr a : '\(a\)' >/dev/null 2>&1; then
11955   as_expr=expr
11956 else
11957   as_expr=false
11958 fi
11959
11960 rm -f conf$$ conf$$.exe conf$$.file
11961 echo >conf$$.file
11962 if ln -s conf$$.file conf$$ 2>/dev/null; then
11963   # We could just check for DJGPP; but this test a) works b) is more generic
11964   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
11965   if test -f conf$$.exe; then
11966     # Don't use ln at all; we don't have any links
11967     as_ln_s='cp -p'
11968   else
11969     as_ln_s='ln -s'
11970   fi
11971 elif ln conf$$.file conf$$ 2>/dev/null; then
11972   as_ln_s=ln
11973 else
11974   as_ln_s='cp -p'
11975 fi
11976 rm -f conf$$ conf$$.exe conf$$.file
11977
11978 if mkdir -p . 2>/dev/null; then
11979   as_mkdir_p=:
11980 else
11981   test -d ./-p && rmdir ./-p
11982   as_mkdir_p=false
11983 fi
11984
11985 as_executable_p="test -f"
11986
11987 # Sed expression to map a string onto a valid CPP name.
11988 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
11989
11990 # Sed expression to map a string onto a valid variable name.
11991 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
11992
11993
11994 # IFS
11995 # We need space, tab and new line, in precisely that order.
11996 as_nl='
11997 '
11998 IFS="   $as_nl"
11999
12000 # CDPATH.
12001 $as_unset CDPATH
12002
12003 exec 6>&1
12004
12005 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12006 # report actual input values of CONFIG_FILES etc. instead of their
12007 # values after options handling.  Logging --version etc. is OK.
12008 exec 5>>config.log
12009 {
12010   echo
12011   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12012 ## Running $as_me. ##
12013 _ASBOX
12014 } >&5
12015 cat >&5 <<_CSEOF
12016
12017 This file was extended by $as_me, which was
12018 generated by GNU Autoconf 2.59.  Invocation command line was
12019
12020   CONFIG_FILES    = $CONFIG_FILES
12021   CONFIG_HEADERS  = $CONFIG_HEADERS
12022   CONFIG_LINKS    = $CONFIG_LINKS
12023   CONFIG_COMMANDS = $CONFIG_COMMANDS
12024   $ $0 $@
12025
12026 _CSEOF
12027 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12028 echo >&5
12029 _ACEOF
12030
12031 # Files that config.status was made for.
12032 if test -n "$ac_config_files"; then
12033   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12034 fi
12035
12036 if test -n "$ac_config_headers"; then
12037   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12038 fi
12039
12040 if test -n "$ac_config_links"; then
12041   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12042 fi
12043
12044 if test -n "$ac_config_commands"; then
12045   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12046 fi
12047
12048 cat >>$CONFIG_STATUS <<\_ACEOF
12049
12050 ac_cs_usage="\
12051 \`$as_me' instantiates files from templates according to the
12052 current configuration.
12053
12054 Usage: $0 [OPTIONS] [FILE]...
12055
12056   -h, --help       print this help, then exit
12057   -V, --version    print version number, then exit
12058   -q, --quiet      do not print progress messages
12059   -d, --debug      don't remove temporary files
12060       --recheck    update $as_me by reconfiguring in the same conditions
12061   --file=FILE[:TEMPLATE]
12062                    instantiate the configuration file FILE
12063
12064 Configuration files:
12065 $config_files
12066
12067 Report bugs to <bug-autoconf@gnu.org>."
12068 _ACEOF
12069
12070 cat >>$CONFIG_STATUS <<_ACEOF
12071 ac_cs_version="\\
12072 config.status
12073 configured by $0, generated by GNU Autoconf 2.59,
12074   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12075
12076 Copyright (C) 2003 Free Software Foundation, Inc.
12077 This config.status script is free software; the Free Software Foundation
12078 gives unlimited permission to copy, distribute and modify it."
12079 srcdir=$srcdir
12080 INSTALL="$INSTALL"
12081 _ACEOF
12082
12083 cat >>$CONFIG_STATUS <<\_ACEOF
12084 # If no file are specified by the user, then we need to provide default
12085 # value.  By we need to know if files were specified by the user.
12086 ac_need_defaults=:
12087 while test $# != 0
12088 do
12089   case $1 in
12090   --*=*)
12091     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12092     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12093     ac_shift=:
12094     ;;
12095   -*)
12096     ac_option=$1
12097     ac_optarg=$2
12098     ac_shift=shift
12099     ;;
12100   *) # This is not an option, so the user has probably given explicit
12101      # arguments.
12102      ac_option=$1
12103      ac_need_defaults=false;;
12104   esac
12105
12106   case $ac_option in
12107   # Handling of the options.
12108 _ACEOF
12109 cat >>$CONFIG_STATUS <<\_ACEOF
12110   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12111     ac_cs_recheck=: ;;
12112   --version | --vers* | -V )
12113     echo "$ac_cs_version"; exit 0 ;;
12114   --he | --h)
12115     # Conflict between --help and --header
12116     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12117 Try \`$0 --help' for more information." >&5
12118 echo "$as_me: error: ambiguous option: $1
12119 Try \`$0 --help' for more information." >&2;}
12120    { (exit 1); exit 1; }; };;
12121   --help | --hel | -h )
12122     echo "$ac_cs_usage"; exit 0 ;;
12123   --debug | --d* | -d )
12124     debug=: ;;
12125   --file | --fil | --fi | --f )
12126     $ac_shift
12127     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12128     ac_need_defaults=false;;
12129   --header | --heade | --head | --hea )
12130     $ac_shift
12131     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12132     ac_need_defaults=false;;
12133   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12134   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12135     ac_cs_silent=: ;;
12136
12137   # This is an error.
12138   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12139 Try \`$0 --help' for more information." >&5
12140 echo "$as_me: error: unrecognized option: $1
12141 Try \`$0 --help' for more information." >&2;}
12142    { (exit 1); exit 1; }; } ;;
12143
12144   *) ac_config_targets="$ac_config_targets $1" ;;
12145
12146   esac
12147   shift
12148 done
12149
12150 ac_configure_extra_args=
12151
12152 if $ac_cs_silent; then
12153   exec 6>/dev/null
12154   ac_configure_extra_args="$ac_configure_extra_args --silent"
12155 fi
12156
12157 _ACEOF
12158 cat >>$CONFIG_STATUS <<_ACEOF
12159 if \$ac_cs_recheck; then
12160   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12161   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12162 fi
12163
12164 _ACEOF
12165
12166
12167
12168
12169
12170 cat >>$CONFIG_STATUS <<\_ACEOF
12171 for ac_config_target in $ac_config_targets
12172 do
12173   case "$ac_config_target" in
12174   # Handling of arguments.
12175   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12176   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12177 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12178    { (exit 1); exit 1; }; };;
12179   esac
12180 done
12181
12182 # If the user did not use the arguments to specify the items to instantiate,
12183 # then the envvar interface is used.  Set only those that are not.
12184 # We use the long form for the default assignment because of an extremely
12185 # bizarre bug on SunOS 4.1.3.
12186 if $ac_need_defaults; then
12187   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12188 fi
12189
12190 # Have a temporary directory for convenience.  Make it in the build tree
12191 # simply because there is no reason to put it here, and in addition,
12192 # creating and moving files from /tmp can sometimes cause problems.
12193 # Create a temporary directory, and hook for its removal unless debugging.
12194 $debug ||
12195 {
12196   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12197   trap '{ (exit 1); exit 1; }' 1 2 13 15
12198 }
12199
12200 # Create a (secure) tmp directory for tmp files.
12201
12202 {
12203   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12204   test -n "$tmp" && test -d "$tmp"
12205 }  ||
12206 {
12207   tmp=./confstat$$-$RANDOM
12208   (umask 077 && mkdir $tmp)
12209 } ||
12210 {
12211    echo "$me: cannot create a temporary directory in ." >&2
12212    { (exit 1); exit 1; }
12213 }
12214
12215 _ACEOF
12216
12217 cat >>$CONFIG_STATUS <<_ACEOF
12218
12219 #
12220 # CONFIG_FILES section.
12221 #
12222
12223 # No need to generate the scripts if there are no CONFIG_FILES.
12224 # This happens for instance when ./config.status config.h
12225 if test -n "\$CONFIG_FILES"; then
12226   # Protect against being on the right side of a sed subst in config.status.
12227   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12228    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12229 s,@SHELL@,$SHELL,;t t
12230 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12231 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12232 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12233 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12234 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12235 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12236 s,@exec_prefix@,$exec_prefix,;t t
12237 s,@prefix@,$prefix,;t t
12238 s,@program_transform_name@,$program_transform_name,;t t
12239 s,@bindir@,$bindir,;t t
12240 s,@sbindir@,$sbindir,;t t
12241 s,@libexecdir@,$libexecdir,;t t
12242 s,@datadir@,$datadir,;t t
12243 s,@sysconfdir@,$sysconfdir,;t t
12244 s,@sharedstatedir@,$sharedstatedir,;t t
12245 s,@localstatedir@,$localstatedir,;t t
12246 s,@libdir@,$libdir,;t t
12247 s,@includedir@,$includedir,;t t
12248 s,@oldincludedir@,$oldincludedir,;t t
12249 s,@infodir@,$infodir,;t t
12250 s,@mandir@,$mandir,;t t
12251 s,@build_alias@,$build_alias,;t t
12252 s,@host_alias@,$host_alias,;t t
12253 s,@target_alias@,$target_alias,;t t
12254 s,@DEFS@,$DEFS,;t t
12255 s,@ECHO_C@,$ECHO_C,;t t
12256 s,@ECHO_N@,$ECHO_N,;t t
12257 s,@ECHO_T@,$ECHO_T,;t t
12258 s,@LIBS@,$LIBS,;t t
12259 s,@build@,$build,;t t
12260 s,@build_cpu@,$build_cpu,;t t
12261 s,@build_vendor@,$build_vendor,;t t
12262 s,@build_os@,$build_os,;t t
12263 s,@build_noncanonical@,$build_noncanonical,;t t
12264 s,@host_noncanonical@,$host_noncanonical,;t t
12265 s,@target_noncanonical@,$target_noncanonical,;t t
12266 s,@host@,$host,;t t
12267 s,@host_cpu@,$host_cpu,;t t
12268 s,@host_vendor@,$host_vendor,;t t
12269 s,@host_os@,$host_os,;t t
12270 s,@target@,$target,;t t
12271 s,@target_cpu@,$target_cpu,;t t
12272 s,@target_vendor@,$target_vendor,;t t
12273 s,@target_os@,$target_os,;t t
12274 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12275 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12276 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12277 s,@LN@,$LN,;t t
12278 s,@LN_S@,$LN_S,;t t
12279 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12280 s,@build_libsubdir@,$build_libsubdir,;t t
12281 s,@build_subdir@,$build_subdir,;t t
12282 s,@host_subdir@,$host_subdir,;t t
12283 s,@target_subdir@,$target_subdir,;t t
12284 s,@CC@,$CC,;t t
12285 s,@CFLAGS@,$CFLAGS,;t t
12286 s,@LDFLAGS@,$LDFLAGS,;t t
12287 s,@CPPFLAGS@,$CPPFLAGS,;t t
12288 s,@ac_ct_CC@,$ac_ct_CC,;t t
12289 s,@EXEEXT@,$EXEEXT,;t t
12290 s,@OBJEXT@,$OBJEXT,;t t
12291 s,@CXX@,$CXX,;t t
12292 s,@CXXFLAGS@,$CXXFLAGS,;t t
12293 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12294 s,@GNATBIND@,$GNATBIND,;t t
12295 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12296 s,@GNATMAKE@,$GNATMAKE,;t t
12297 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12298 s,@do_compare@,$do_compare,;t t
12299 s,@gmplibs@,$gmplibs,;t t
12300 s,@gmpinc@,$gmpinc,;t t
12301 s,@stage1_languages@,$stage1_languages,;t t
12302 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12303 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12304 s,@tooldir@,$tooldir,;t t
12305 s,@build_tooldir@,$build_tooldir,;t t
12306 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12307 s,@GDB_TK@,$GDB_TK,;t t
12308 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12309 s,@build_configargs@,$build_configargs,;t t
12310 s,@build_configdirs@,$build_configdirs,;t t
12311 s,@host_configargs@,$host_configargs,;t t
12312 s,@configdirs@,$configdirs,;t t
12313 s,@target_configargs@,$target_configargs,;t t
12314 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12315 s,@config_shell@,$config_shell,;t t
12316 s,@YACC@,$YACC,;t t
12317 s,@BISON@,$BISON,;t t
12318 s,@M4@,$M4,;t t
12319 s,@LEX@,$LEX,;t t
12320 s,@FLEX@,$FLEX,;t t
12321 s,@MAKEINFO@,$MAKEINFO,;t t
12322 s,@EXPECT@,$EXPECT,;t t
12323 s,@RUNTEST@,$RUNTEST,;t t
12324 s,@AR@,$AR,;t t
12325 s,@AS@,$AS,;t t
12326 s,@DLLTOOL@,$DLLTOOL,;t t
12327 s,@LD@,$LD,;t t
12328 s,@LIPO@,$LIPO,;t t
12329 s,@NM@,$NM,;t t
12330 s,@RANLIB@,$RANLIB,;t t
12331 s,@STRIP@,$STRIP,;t t
12332 s,@WINDRES@,$WINDRES,;t t
12333 s,@OBJCOPY@,$OBJCOPY,;t t
12334 s,@OBJDUMP@,$OBJDUMP,;t t
12335 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12336 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12337 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12338 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12339 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12340 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12341 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12342 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12343 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12344 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12345 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12346 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12347 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12348 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12349 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12350 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12351 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12352 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12353 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12354 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12355 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12356 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12357 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12358 s,@MAINT@,$MAINT,;t t
12359 s,@stage1_cflags@,$stage1_cflags,;t t
12360 s,@stage1_checking@,$stage1_checking,;t t
12361 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12362 s,@datarootdir@,$datarootdir,;t t
12363 s,@docdir@,$docdir,;t t
12364 s,@pdfdir@,$pdfdir,;t t
12365 s,@htmldir@,$htmldir,;t t
12366 s,@LIBOBJS@,$LIBOBJS,;t t
12367 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12368 /@serialization_dependencies@/r $serialization_dependencies
12369 s,@serialization_dependencies@,,;t t
12370 /@host_makefile_frag@/r $host_makefile_frag
12371 s,@host_makefile_frag@,,;t t
12372 /@target_makefile_frag@/r $target_makefile_frag
12373 s,@target_makefile_frag@,,;t t
12374 /@alphaieee_frag@/r $alphaieee_frag
12375 s,@alphaieee_frag@,,;t t
12376 /@ospace_frag@/r $ospace_frag
12377 s,@ospace_frag@,,;t t
12378 CEOF
12379
12380 _ACEOF
12381
12382   cat >>$CONFIG_STATUS <<\_ACEOF
12383   # Split the substitutions into bite-sized pieces for seds with
12384   # small command number limits, like on Digital OSF/1 and HP-UX.
12385   ac_max_sed_lines=48
12386   ac_sed_frag=1 # Number of current file.
12387   ac_beg=1 # First line for current file.
12388   ac_end=$ac_max_sed_lines # Line after last line for current file.
12389   ac_more_lines=:
12390   ac_sed_cmds=
12391   while $ac_more_lines; do
12392     if test $ac_beg -gt 1; then
12393       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12394     else
12395       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12396     fi
12397     if test ! -s $tmp/subs.frag; then
12398       ac_more_lines=false
12399     else
12400       # The purpose of the label and of the branching condition is to
12401       # speed up the sed processing (if there are no `@' at all, there
12402       # is no need to browse any of the substitutions).
12403       # These are the two extra sed commands mentioned above.
12404       (echo ':t
12405   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
12406       if test -z "$ac_sed_cmds"; then
12407         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
12408       else
12409         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
12410       fi
12411       ac_sed_frag=`expr $ac_sed_frag + 1`
12412       ac_beg=$ac_end
12413       ac_end=`expr $ac_end + $ac_max_sed_lines`
12414     fi
12415   done
12416   if test -z "$ac_sed_cmds"; then
12417     ac_sed_cmds=cat
12418   fi
12419 fi # test -n "$CONFIG_FILES"
12420
12421 _ACEOF
12422 cat >>$CONFIG_STATUS <<\_ACEOF
12423 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
12424   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
12425   case $ac_file in
12426   - | *:- | *:-:* ) # input from stdin
12427         cat >$tmp/stdin
12428         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12429         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12430   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12431         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12432   * )   ac_file_in=$ac_file.in ;;
12433   esac
12434
12435   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
12436   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
12437 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12438          X"$ac_file" : 'X\(//\)[^/]' \| \
12439          X"$ac_file" : 'X\(//\)$' \| \
12440          X"$ac_file" : 'X\(/\)' \| \
12441          .     : '\(.\)' 2>/dev/null ||
12442 echo X"$ac_file" |
12443     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12444           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12445           /^X\(\/\/\)$/{ s//\1/; q; }
12446           /^X\(\/\).*/{ s//\1/; q; }
12447           s/.*/./; q'`
12448   { if $as_mkdir_p; then
12449     mkdir -p "$ac_dir"
12450   else
12451     as_dir="$ac_dir"
12452     as_dirs=
12453     while test ! -d "$as_dir"; do
12454       as_dirs="$as_dir $as_dirs"
12455       as_dir=`(dirname "$as_dir") 2>/dev/null ||
12456 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12457          X"$as_dir" : 'X\(//\)[^/]' \| \
12458          X"$as_dir" : 'X\(//\)$' \| \
12459          X"$as_dir" : 'X\(/\)' \| \
12460          .     : '\(.\)' 2>/dev/null ||
12461 echo X"$as_dir" |
12462     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12463           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12464           /^X\(\/\/\)$/{ s//\1/; q; }
12465           /^X\(\/\).*/{ s//\1/; q; }
12466           s/.*/./; q'`
12467     done
12468     test ! -n "$as_dirs" || mkdir $as_dirs
12469   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
12470 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
12471    { (exit 1); exit 1; }; }; }
12472
12473   ac_builddir=.
12474
12475 if test "$ac_dir" != .; then
12476   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
12477   # A "../" for each directory in $ac_dir_suffix.
12478   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
12479 else
12480   ac_dir_suffix= ac_top_builddir=
12481 fi
12482
12483 case $srcdir in
12484   .)  # No --srcdir option.  We are building in place.
12485     ac_srcdir=.
12486     if test -z "$ac_top_builddir"; then
12487        ac_top_srcdir=.
12488     else
12489        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
12490     fi ;;
12491   [\\/]* | ?:[\\/]* )  # Absolute path.
12492     ac_srcdir=$srcdir$ac_dir_suffix;
12493     ac_top_srcdir=$srcdir ;;
12494   *) # Relative path.
12495     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
12496     ac_top_srcdir=$ac_top_builddir$srcdir ;;
12497 esac
12498
12499 # Do not use `cd foo && pwd` to compute absolute paths, because
12500 # the directories may not exist.
12501 case `pwd` in
12502 .) ac_abs_builddir="$ac_dir";;
12503 *)
12504   case "$ac_dir" in
12505   .) ac_abs_builddir=`pwd`;;
12506   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
12507   *) ac_abs_builddir=`pwd`/"$ac_dir";;
12508   esac;;
12509 esac
12510 case $ac_abs_builddir in
12511 .) ac_abs_top_builddir=${ac_top_builddir}.;;
12512 *)
12513   case ${ac_top_builddir}. in
12514   .) ac_abs_top_builddir=$ac_abs_builddir;;
12515   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
12516   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
12517   esac;;
12518 esac
12519 case $ac_abs_builddir in
12520 .) ac_abs_srcdir=$ac_srcdir;;
12521 *)
12522   case $ac_srcdir in
12523   .) ac_abs_srcdir=$ac_abs_builddir;;
12524   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
12525   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
12526   esac;;
12527 esac
12528 case $ac_abs_builddir in
12529 .) ac_abs_top_srcdir=$ac_top_srcdir;;
12530 *)
12531   case $ac_top_srcdir in
12532   .) ac_abs_top_srcdir=$ac_abs_builddir;;
12533   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
12534   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
12535   esac;;
12536 esac
12537
12538
12539   case $INSTALL in
12540   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
12541   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
12542   esac
12543
12544   if test x"$ac_file" != x-; then
12545     { echo "$as_me:$LINENO: creating $ac_file" >&5
12546 echo "$as_me: creating $ac_file" >&6;}
12547     rm -f "$ac_file"
12548   fi
12549   # Let's still pretend it is `configure' which instantiates (i.e., don't
12550   # use $as_me), people would be surprised to read:
12551   #    /* config.h.  Generated by config.status.  */
12552   if test x"$ac_file" = x-; then
12553     configure_input=
12554   else
12555     configure_input="$ac_file.  "
12556   fi
12557   configure_input=$configure_input"Generated from `echo $ac_file_in |
12558                                      sed 's,.*/,,'` by configure."
12559
12560   # First look for the input files in the build tree, otherwise in the
12561   # src tree.
12562   ac_file_inputs=`IFS=:
12563     for f in $ac_file_in; do
12564       case $f in
12565       -) echo $tmp/stdin ;;
12566       [\\/$]*)
12567          # Absolute (can't be DOS-style, as IFS=:)
12568          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
12569 echo "$as_me: error: cannot find input file: $f" >&2;}
12570    { (exit 1); exit 1; }; }
12571          echo "$f";;
12572       *) # Relative
12573          if test -f "$f"; then
12574            # Build tree
12575            echo "$f"
12576          elif test -f "$srcdir/$f"; then
12577            # Source tree
12578            echo "$srcdir/$f"
12579          else
12580            # /dev/null tree
12581            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
12582 echo "$as_me: error: cannot find input file: $f" >&2;}
12583    { (exit 1); exit 1; }; }
12584          fi;;
12585       esac
12586     done` || { (exit 1); exit 1; }
12587 _ACEOF
12588 cat >>$CONFIG_STATUS <<_ACEOF
12589   sed "$ac_vpsub
12590 $extrasub
12591 _ACEOF
12592 cat >>$CONFIG_STATUS <<\_ACEOF
12593 :t
12594 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
12595 s,@configure_input@,$configure_input,;t t
12596 s,@srcdir@,$ac_srcdir,;t t
12597 s,@abs_srcdir@,$ac_abs_srcdir,;t t
12598 s,@top_srcdir@,$ac_top_srcdir,;t t
12599 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
12600 s,@builddir@,$ac_builddir,;t t
12601 s,@abs_builddir@,$ac_abs_builddir,;t t
12602 s,@top_builddir@,$ac_top_builddir,;t t
12603 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
12604 s,@INSTALL@,$ac_INSTALL,;t t
12605 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
12606   rm -f $tmp/stdin
12607   if test x"$ac_file" != x-; then
12608     mv $tmp/out $ac_file
12609   else
12610     cat $tmp/out
12611     rm -f $tmp/out
12612   fi
12613
12614 done
12615 _ACEOF
12616
12617 cat >>$CONFIG_STATUS <<\_ACEOF
12618
12619 { (exit 0); exit 0; }
12620 _ACEOF
12621 chmod +x $CONFIG_STATUS
12622 ac_clean_files=$ac_clean_files_save
12623
12624
12625 # configure is writing to config.log, and then calls config.status.
12626 # config.status does its own redirection, appending to config.log.
12627 # Unfortunately, on DOS this fails, as config.log is still kept open
12628 # by configure, so config.status won't be able to write to it; its
12629 # output is simply discarded.  So we exec the FD to /dev/null,
12630 # effectively closing config.log, so it can be properly (re)opened and
12631 # appended to by config.status.  When coming back to configure, we
12632 # need to make the FD available again.
12633 if test "$no_create" != yes; then
12634   ac_cs_success=:
12635   ac_config_status_args=
12636   test "$silent" = yes &&
12637     ac_config_status_args="$ac_config_status_args --quiet"
12638   exec 5>/dev/null
12639   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
12640   exec 5>>config.log
12641   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
12642   # would make configure fail if this is the last instruction.
12643   $ac_cs_success || { (exit 1); exit 1; }
12644 fi
12645