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 TOPLEVEL_CONFIGURE_ARGUMENTS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET CPPFLAGS_FOR_TARGET LDFLAGS_FOR_TARGET RPATH_ENVVAR GCC_SHLIB_SUBDIR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CPPFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277 ac_pwd=`pwd`
 278
 279 # Initialize some variables set by options.
 280 ac_init_help=
 281 ac_init_version=false
 282 # The variables have the same names as the options, with
 283 # dashes changed to underlines.
 284 cache_file=/dev/null
 285 exec_prefix=NONE
 286 no_create=
 287 no_recursion=
 288 prefix=NONE
 289 program_prefix=NONE
 290 program_suffix=NONE
 291 program_transform_name=s,x,x,
 292 silent=
 293 site=
 294 srcdir=
 295 verbose=
 296 x_includes=NONE
 297 x_libraries=NONE
 298
 299 # Installation directory options.
 300 # These are left unexpanded so users can "make install exec_prefix=/foo"
 301 # and all the variables that are supposed to be based on exec_prefix
 302 # by default will actually change.
 303 # Use braces instead of parens because sh, perl, etc. also accept them.
 304 bindir='${exec_prefix}/bin'
 305 sbindir='${exec_prefix}/sbin'
 306 libexecdir='${exec_prefix}/libexec'
 307 datadir='${prefix}/share'
 308 sysconfdir='${prefix}/etc'
 309 sharedstatedir='${prefix}/com'
 310 localstatedir='${prefix}/var'
 311 libdir='${exec_prefix}/lib'
 312 includedir='${prefix}/include'
 313 oldincludedir='/usr/include'
 314 infodir='${prefix}/info'
 315 mandir='${prefix}/man'
 316
 317 ac_prev=
 318 for ac_option
 319 do
 320   # If the previous option needs an argument, assign it.
 321   if test -n "$ac_prev"; then
 322     eval "$ac_prev=\$ac_option"
 323     ac_prev=
 324     continue
 325   fi
 326
 327   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 328
 329   # Accept the important Cygnus configure options, so we can diagnose typos.
 330
 331   case $ac_option in
 332
 333   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 334     ac_prev=bindir ;;
 335   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 336     bindir=$ac_optarg ;;
 337
 338   -build | --build | --buil | --bui | --bu)
 339     ac_prev=build_alias ;;
 340   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 341     build_alias=$ac_optarg ;;
 342
 343   -cache-file | --cache-file | --cache-fil | --cache-fi \
 344   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 345     ac_prev=cache_file ;;
 346   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 347   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 348     cache_file=$ac_optarg ;;
 349
 350   --config-cache | -C)
 351     cache_file=config.cache ;;
 352
 353   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 354     ac_prev=datadir ;;
 355   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 356   | --da=*)
 357     datadir=$ac_optarg ;;
 358
 359   -disable-* | --disable-*)
 360     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 361     # Reject names that are not valid shell variable names.
 362     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 363       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 364    { (exit 1); exit 1; }; }
 365     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 366     eval "enable_$ac_feature=no" ;;
 367
 368   -enable-* | --enable-*)
 369     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 370     # Reject names that are not valid shell variable names.
 371     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 372       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 373    { (exit 1); exit 1; }; }
 374     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 375     case $ac_option in
 376       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 377       *) ac_optarg=yes ;;
 378     esac
 379     eval "enable_$ac_feature='$ac_optarg'" ;;
 380
 381   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 382   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 383   | --exec | --exe | --ex)
 384     ac_prev=exec_prefix ;;
 385   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 386   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 387   | --exec=* | --exe=* | --ex=*)
 388     exec_prefix=$ac_optarg ;;
 389
 390   -gas | --gas | --ga | --g)
 391     # Obsolete; use --with-gas.
 392     with_gas=yes ;;
 393
 394   -help | --help | --hel | --he | -h)
 395     ac_init_help=long ;;
 396   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 397     ac_init_help=recursive ;;
 398   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 399     ac_init_help=short ;;
 400
 401   -host | --host | --hos | --ho)
 402     ac_prev=host_alias ;;
 403   -host=* | --host=* | --hos=* | --ho=*)
 404     host_alias=$ac_optarg ;;
 405
 406   -includedir | --includedir | --includedi | --included | --include \
 407   | --includ | --inclu | --incl | --inc)
 408     ac_prev=includedir ;;
 409   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 410   | --includ=* | --inclu=* | --incl=* | --inc=*)
 411     includedir=$ac_optarg ;;
 412
 413   -infodir | --infodir | --infodi | --infod | --info | --inf)
 414     ac_prev=infodir ;;
 415   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 416     infodir=$ac_optarg ;;
 417
 418   -libdir | --libdir | --libdi | --libd)
 419     ac_prev=libdir ;;
 420   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 421     libdir=$ac_optarg ;;
 422
 423   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 424   | --libexe | --libex | --libe)
 425     ac_prev=libexecdir ;;
 426   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 427   | --libexe=* | --libex=* | --libe=*)
 428     libexecdir=$ac_optarg ;;
 429
 430   -localstatedir | --localstatedir | --localstatedi | --localstated \
 431   | --localstate | --localstat | --localsta | --localst \
 432   | --locals | --local | --loca | --loc | --lo)
 433     ac_prev=localstatedir ;;
 434   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 435   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 436   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 437     localstatedir=$ac_optarg ;;
 438
 439   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 440     ac_prev=mandir ;;
 441   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 442     mandir=$ac_optarg ;;
 443
 444   -nfp | --nfp | --nf)
 445     # Obsolete; use --without-fp.
 446     with_fp=no ;;
 447
 448   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 449   | --no-cr | --no-c | -n)
 450     no_create=yes ;;
 451
 452   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 453   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 454     no_recursion=yes ;;
 455
 456   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 457   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 458   | --oldin | --oldi | --old | --ol | --o)
 459     ac_prev=oldincludedir ;;
 460   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 461   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 462   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 463     oldincludedir=$ac_optarg ;;
 464
 465   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 466     ac_prev=prefix ;;
 467   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 468     prefix=$ac_optarg ;;
 469
 470   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 471   | --program-pre | --program-pr | --program-p)
 472     ac_prev=program_prefix ;;
 473   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 474   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 475     program_prefix=$ac_optarg ;;
 476
 477   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 478   | --program-suf | --program-su | --program-s)
 479     ac_prev=program_suffix ;;
 480   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 481   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 482     program_suffix=$ac_optarg ;;
 483
 484   -program-transform-name | --program-transform-name \
 485   | --program-transform-nam | --program-transform-na \
 486   | --program-transform-n | --program-transform- \
 487   | --program-transform | --program-transfor \
 488   | --program-transfo | --program-transf \
 489   | --program-trans | --program-tran \
 490   | --progr-tra | --program-tr | --program-t)
 491     ac_prev=program_transform_name ;;
 492   -program-transform-name=* | --program-transform-name=* \
 493   | --program-transform-nam=* | --program-transform-na=* \
 494   | --program-transform-n=* | --program-transform-=* \
 495   | --program-transform=* | --program-transfor=* \
 496   | --program-transfo=* | --program-transf=* \
 497   | --program-trans=* | --program-tran=* \
 498   | --progr-tra=* | --program-tr=* | --program-t=*)
 499     program_transform_name=$ac_optarg ;;
 500
 501   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 502   | -silent | --silent | --silen | --sile | --sil)
 503     silent=yes ;;
 504
 505   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 506     ac_prev=sbindir ;;
 507   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 508   | --sbi=* | --sb=*)
 509     sbindir=$ac_optarg ;;
 510
 511   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 512   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 513   | --sharedst | --shareds | --shared | --share | --shar \
 514   | --sha | --sh)
 515     ac_prev=sharedstatedir ;;
 516   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 517   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 518   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 519   | --sha=* | --sh=*)
 520     sharedstatedir=$ac_optarg ;;
 521
 522   -site | --site | --sit)
 523     ac_prev=site ;;
 524   -site=* | --site=* | --sit=*)
 525     site=$ac_optarg ;;
 526
 527   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 528     ac_prev=srcdir ;;
 529   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 530     srcdir=$ac_optarg ;;
 531
 532   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 533   | --syscon | --sysco | --sysc | --sys | --sy)
 534     ac_prev=sysconfdir ;;
 535   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 536   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 537     sysconfdir=$ac_optarg ;;
 538
 539   -target | --target | --targe | --targ | --tar | --ta | --t)
 540     ac_prev=target_alias ;;
 541   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 542     target_alias=$ac_optarg ;;
 543
 544   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 545     verbose=yes ;;
 546
 547   -version | --version | --versio | --versi | --vers | -V)
 548     ac_init_version=: ;;
 549
 550   -with-* | --with-*)
 551     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 552     # Reject names that are not valid shell variable names.
 553     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 554       { echo "$as_me: error: invalid package name: $ac_package" >&2
 555    { (exit 1); exit 1; }; }
 556     ac_package=`echo $ac_package| sed 's/-/_/g'`
 557     case $ac_option in
 558       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 559       *) ac_optarg=yes ;;
 560     esac
 561     eval "with_$ac_package='$ac_optarg'" ;;
 562
 563   -without-* | --without-*)
 564     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 565     # Reject names that are not valid shell variable names.
 566     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 567       { echo "$as_me: error: invalid package name: $ac_package" >&2
 568    { (exit 1); exit 1; }; }
 569     ac_package=`echo $ac_package | sed 's/-/_/g'`
 570     eval "with_$ac_package=no" ;;
 571
 572   --x)
 573     # Obsolete; use --with-x.
 574     with_x=yes ;;
 575
 576   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 577   | --x-incl | --x-inc | --x-in | --x-i)
 578     ac_prev=x_includes ;;
 579   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 580   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 581     x_includes=$ac_optarg ;;
 582
 583   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 584   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 585     ac_prev=x_libraries ;;
 586   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 587   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 588     x_libraries=$ac_optarg ;;
 589
 590   -*) { echo "$as_me: error: unrecognized option: $ac_option
 591 Try \`$0 --help' for more information." >&2
 592    { (exit 1); exit 1; }; }
 593     ;;
 594
 595   *=*)
 596     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 597     # Reject names that are not valid shell variable names.
 598     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 599       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 600    { (exit 1); exit 1; }; }
 601     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 602     eval "$ac_envvar='$ac_optarg'"
 603     export $ac_envvar ;;
 604
 605   *)
 606     # FIXME: should be removed in autoconf 3.0.
 607     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 608     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 609       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 610     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 611     ;;
 612
 613   esac
 614 done
 615
 616 if test -n "$ac_prev"; then
 617   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 618   { echo "$as_me: error: missing argument to $ac_option" >&2
 619    { (exit 1); exit 1; }; }
 620 fi
 621
 622 # Be sure to have absolute paths.
 623 for ac_var in exec_prefix prefix
 624 do
 625   eval ac_val=$`echo $ac_var`
 626   case $ac_val in
 627     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 628     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 629    { (exit 1); exit 1; }; };;
 630   esac
 631 done
 632
 633 # Be sure to have absolute paths.
 634 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 635               localstatedir libdir includedir oldincludedir infodir mandir
 636 do
 637   eval ac_val=$`echo $ac_var`
 638   case $ac_val in
 639     [\\/$]* | ?:[\\/]* ) ;;
 640     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 641    { (exit 1); exit 1; }; };;
 642   esac
 643 done
 644
 645 # There might be people who depend on the old broken behavior: `$host'
 646 # used to hold the argument of --host etc.
 647 # FIXME: To remove some day.
 648 build=$build_alias
 649 host=$host_alias
 650 target=$target_alias
 651
 652 # FIXME: To remove some day.
 653 if test "x$host_alias" != x; then
 654   if test "x$build_alias" = x; then
 655     cross_compiling=maybe
 656     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 657     If a cross compiler is detected then cross compile mode will be used." >&2
 658   elif test "x$build_alias" != "x$host_alias"; then
 659     cross_compiling=yes
 660   fi
 661 fi
 662
 663 ac_tool_prefix=
 664 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 665
 666 test "$silent" = yes && exec 6>/dev/null
 667
 668
 669 # Find the source files, if location was not specified.
 670 if test -z "$srcdir"; then
 671   ac_srcdir_defaulted=yes
 672   # Try the directory containing this script, then its parent.
 673   ac_confdir=`(dirname "$0") 2>/dev/null ||
 674 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 675          X"$0" : 'X\(//\)[^/]' \| \
 676          X"$0" : 'X\(//\)$' \| \
 677          X"$0" : 'X\(/\)' \| \
 678          .     : '\(.\)' 2>/dev/null ||
 679 echo X"$0" |
 680     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 681           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 682           /^X\(\/\/\)$/{ s//\1/; q; }
 683           /^X\(\/\).*/{ s//\1/; q; }
 684           s/.*/./; q'`
 685   srcdir=$ac_confdir
 686   if test ! -r $srcdir/$ac_unique_file; then
 687     srcdir=..
 688   fi
 689 else
 690   ac_srcdir_defaulted=no
 691 fi
 692 if test ! -r $srcdir/$ac_unique_file; then
 693   if test "$ac_srcdir_defaulted" = yes; then
 694     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 695    { (exit 1); exit 1; }; }
 696   else
 697     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 698    { (exit 1); exit 1; }; }
 699   fi
 700 fi
 701 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 702   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 703    { (exit 1); exit 1; }; }
 704 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 705 ac_env_build_alias_set=${build_alias+set}
 706 ac_env_build_alias_value=$build_alias
 707 ac_cv_env_build_alias_set=${build_alias+set}
 708 ac_cv_env_build_alias_value=$build_alias
 709 ac_env_host_alias_set=${host_alias+set}
 710 ac_env_host_alias_value=$host_alias
 711 ac_cv_env_host_alias_set=${host_alias+set}
 712 ac_cv_env_host_alias_value=$host_alias
 713 ac_env_target_alias_set=${target_alias+set}
 714 ac_env_target_alias_value=$target_alias
 715 ac_cv_env_target_alias_set=${target_alias+set}
 716 ac_cv_env_target_alias_value=$target_alias
 717 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 718
 719 ac_env_CC_set=${CC+set}
 720 ac_env_CC_value=$CC
 721 ac_cv_env_CC_set=${CC+set}
 722 ac_cv_env_CC_value=$CC
 723 ac_env_CFLAGS_set=${CFLAGS+set}
 724 ac_env_CFLAGS_value=$CFLAGS
 725 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 726 ac_cv_env_CFLAGS_value=$CFLAGS
 727 ac_env_LDFLAGS_set=${LDFLAGS+set}
 728 ac_env_LDFLAGS_value=$LDFLAGS
 729 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 730 ac_cv_env_LDFLAGS_value=$LDFLAGS
 731 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 732 ac_env_CPPFLAGS_value=$CPPFLAGS
 733 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 734 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 735 ac_env_CXX_set=${CXX+set}
 736 ac_env_CXX_value=$CXX
 737 ac_cv_env_CXX_set=${CXX+set}
 738 ac_cv_env_CXX_value=$CXX
 739 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 740 ac_env_CXXFLAGS_value=$CXXFLAGS
 741 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 742 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 743 ac_env_AR_set=${AR+set}
 744 ac_env_AR_value=$AR
 745 ac_cv_env_AR_set=${AR+set}
 746 ac_cv_env_AR_value=$AR
 747 ac_env_AS_set=${AS+set}
 748 ac_env_AS_value=$AS
 749 ac_cv_env_AS_set=${AS+set}
 750 ac_cv_env_AS_value=$AS
 751 ac_env_DLLTOOL_set=${DLLTOOL+set}
 752 ac_env_DLLTOOL_value=$DLLTOOL
 753 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 754 ac_cv_env_DLLTOOL_value=$DLLTOOL
 755 ac_env_LD_set=${LD+set}
 756 ac_env_LD_value=$LD
 757 ac_cv_env_LD_set=${LD+set}
 758 ac_cv_env_LD_value=$LD
 759 ac_env_LIPO_set=${LIPO+set}
 760 ac_env_LIPO_value=$LIPO
 761 ac_cv_env_LIPO_set=${LIPO+set}
 762 ac_cv_env_LIPO_value=$LIPO
 763 ac_env_NM_set=${NM+set}
 764 ac_env_NM_value=$NM
 765 ac_cv_env_NM_set=${NM+set}
 766 ac_cv_env_NM_value=$NM
 767 ac_env_RANLIB_set=${RANLIB+set}
 768 ac_env_RANLIB_value=$RANLIB
 769 ac_cv_env_RANLIB_set=${RANLIB+set}
 770 ac_cv_env_RANLIB_value=$RANLIB
 771 ac_env_STRIP_set=${STRIP+set}
 772 ac_env_STRIP_value=$STRIP
 773 ac_cv_env_STRIP_set=${STRIP+set}
 774 ac_cv_env_STRIP_value=$STRIP
 775 ac_env_WINDRES_set=${WINDRES+set}
 776 ac_env_WINDRES_value=$WINDRES
 777 ac_cv_env_WINDRES_set=${WINDRES+set}
 778 ac_cv_env_WINDRES_value=$WINDRES
 779 ac_env_WINDMC_set=${WINDMC+set}
 780 ac_env_WINDMC_value=$WINDMC
 781 ac_cv_env_WINDMC_set=${WINDMC+set}
 782 ac_cv_env_WINDMC_value=$WINDMC
 783 ac_env_OBJCOPY_set=${OBJCOPY+set}
 784 ac_env_OBJCOPY_value=$OBJCOPY
 785 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 786 ac_cv_env_OBJCOPY_value=$OBJCOPY
 787 ac_env_OBJDUMP_set=${OBJDUMP+set}
 788 ac_env_OBJDUMP_value=$OBJDUMP
 789 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 790 ac_cv_env_OBJDUMP_value=$OBJDUMP
 791 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 792 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 793 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 794 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 795 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 796 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 797 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 798 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 799 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 800 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 801 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 802 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 803 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 804 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 805 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 806 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 807 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 808 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 809 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 810 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 811 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 812 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 813 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 814 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 815 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 816 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 817 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 818 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 819 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 820 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 821 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 822 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 823 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 824 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 825 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 826 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 827 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 828 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 829 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 830 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 831 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 832 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 833 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 834 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 835 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 836 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 837 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 838 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 839 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 840 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 841 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 842 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 843 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 844 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 845 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 846 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 847 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 848 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 849 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 850 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 851 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 852 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 853 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 854 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 855
 856 #
 857 # Report the --help message.
 858 #
 859 if test "$ac_init_help" = "long"; then
 860   # Omit some internal or obsolete options to make the list less imposing.
 861   # This message is too long to be a string in the A/UX 3.1 sh.
 862   cat <<_ACEOF
 863 \`configure' configures this package to adapt to many kinds of systems.
 864
 865 Usage: $0 [OPTION]... [VAR=VALUE]...
 866
 867 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 868 VAR=VALUE.  See below for descriptions of some of the useful variables.
 869
 870 Defaults for the options are specified in brackets.
 871
 872 Configuration:
 873   -h, --help              display this help and exit
 874       --help=short        display options specific to this package
 875       --help=recursive    display the short help of all the included packages
 876   -V, --version           display version information and exit
 877   -q, --quiet, --silent   do not print \`checking...' messages
 878       --cache-file=FILE   cache test results in FILE [disabled]
 879   -C, --config-cache      alias for \`--cache-file=config.cache'
 880   -n, --no-create         do not create output files
 881       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 882
 883 _ACEOF
 884
 885   cat <<_ACEOF
 886 Installation directories:
 887   --prefix=PREFIX         install architecture-independent files in PREFIX
 888                           [$ac_default_prefix]
 889   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 890                           [PREFIX]
 891
 892 By default, \`make install' will install all the files in
 893 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 894 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 895 for instance \`--prefix=\$HOME'.
 896
 897 For better control, use the options below.
 898
 899 Fine tuning of the installation directories:
 900   --bindir=DIR           user executables [EPREFIX/bin]
 901   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 902   --libexecdir=DIR       program executables [EPREFIX/libexec]
 903   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 904   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 905   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 906   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 907   --libdir=DIR           object code libraries [EPREFIX/lib]
 908   --includedir=DIR       C header files [PREFIX/include]
 909   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 910   --infodir=DIR          info documentation [PREFIX/info]
 911   --mandir=DIR           man documentation [PREFIX/man]
 912 _ACEOF
 913
 914   cat <<\_ACEOF
 915
 916 Program names:
 917   --program-prefix=PREFIX            prepend PREFIX to installed program names
 918   --program-suffix=SUFFIX            append SUFFIX to installed program names
 919   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 920
 921 System types:
 922   --build=BUILD     configure for building on BUILD [guessed]
 923   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 924   --target=TARGET   configure for building compilers for TARGET [HOST]
 925 _ACEOF
 926 fi
 927
 928 if test -n "$ac_init_help"; then
 929
 930   cat <<\_ACEOF
 931
 932 Optional Features:
 933   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 934   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 935   --enable-gold           use gold instead of ld
 936   --enable-libada         build libada directory
 937   --enable-libssp         build libssp directory
 938   --enable-stage1-languages[=all]   choose additional languages to build during
 939                           stage1.  Mostly useful for compiler development.
 940   --enable-objc-gc        enable use of Boehm's garbage collector with the
 941                           GNU Objective-C runtime
 942   --enable-bootstrap      enable bootstrapping [yes if native build]
 943   --enable-serial-[{host,target,build}-]configure
 944                           force sequential configuration of
 945                           sub-packages for the host, target or build
 946                           machine, or all sub-packages
 947   --enable-maintainer-mode enable make rules and dependencies not useful
 948                           (and sometimes confusing) to the casual installer
 949   --enable-stage1-checking[=all]   choose additional checking for stage1
 950                           of the compiler
 951   --enable-werror         enable -Werror in bootstrap stage2 and later
 952
 953 Optional Packages:
 954   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 955   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 956   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 957   --with-mpfr-dir=PATH    this option has been REMOVED
 958   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 959                           Equivalent to --with-mpfr-include=PATH/include
 960                           plus --with-mpfr-lib=PATH/lib
 961   --with-mpfr-include=PATH
 962                           specify directory for installed MPFR include files
 963   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 964   --with-gmp-dir=PATH     this option has been REMOVED
 965   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 966                           Equivalent to --with-gmp-include=PATH/include
 967                           plus --with-gmp-lib=PATH/lib
 968   --with-gmp-include=PATH specify directory for installed GMP include files
 969   --with-gmp-lib=PATH     specify directory for the installed GMP library
 970   --with-build-sysroot=SYSROOT
 971                           use sysroot as the system root during the build
 972   --with-debug-prefix-map='A=B C=D ...'
 973                              map A to B, C to D ... in debug information
 974   --with-build-time-tools=PATH
 975                           use given path to find target tools during the build
 976   --with-datarootdir      use datarootdir as the data root directory.
 977   --with-docdir           install documentation in this directory.
 978   --with-pdfdir           install pdf in this directory.
 979   --with-htmldir          install html in this directory.
 980
 981 Some influential environment variables:
 982   CC          C compiler command
 983   CFLAGS      C compiler flags
 984   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 985               nonstandard directory <lib dir>
 986   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 987               headers in a nonstandard directory <include dir>
 988   CXX         C++ compiler command
 989   CXXFLAGS    C++ compiler flags
 990   AR          AR for the host
 991   AS          AS for the host
 992   DLLTOOL     DLLTOOL for the host
 993   LD          LD for the host
 994   LIPO        LIPO for the host
 995   NM          NM for the host
 996   RANLIB      RANLIB for the host
 997   STRIP       STRIP for the host
 998   WINDRES     WINDRES for the host
 999   WINDMC      WINDMC for the host
1000   OBJCOPY     OBJCOPY for the host
1001   OBJDUMP     OBJDUMP for the host
1002   CC_FOR_TARGET
1003               CC for the target
1004   CXX_FOR_TARGET
1005               CXX for the target
1006   GCC_FOR_TARGET
1007               GCC for the target
1008   GCJ_FOR_TARGET
1009               GCJ for the target
1010   GFORTRAN_FOR_TARGET
1011               GFORTRAN for the target
1012   AR_FOR_TARGET
1013               AR for the target
1014   AS_FOR_TARGET
1015               AS for the target
1016   DLLTOOL_FOR_TARGET
1017               DLLTOOL for the target
1018   LD_FOR_TARGET
1019               LD for the target
1020   LIPO_FOR_TARGET
1021               LIPO for the target
1022   NM_FOR_TARGET
1023               NM for the target
1024   OBJDUMP_FOR_TARGET
1025               OBJDUMP for the target
1026   RANLIB_FOR_TARGET
1027               RANLIB for the target
1028   STRIP_FOR_TARGET
1029               STRIP for the target
1030   WINDRES_FOR_TARGET
1031               WINDRES for the target
1032   WINDMC_FOR_TARGET
1033               WINDMC for the target
1034
1035 Use these variables to override the choices made by `configure' or to help
1036 it to find libraries and programs with nonstandard names/locations.
1037
1038 _ACEOF
1039 fi
1040
1041 if test "$ac_init_help" = "recursive"; then
1042   # If there are subdirs, report their specific --help.
1043   ac_popdir=`pwd`
1044   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1045     test -d $ac_dir || continue
1046     ac_builddir=.
1047
1048 if test "$ac_dir" != .; then
1049   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1050   # A "../" for each directory in $ac_dir_suffix.
1051   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1052 else
1053   ac_dir_suffix= ac_top_builddir=
1054 fi
1055
1056 case $srcdir in
1057   .)  # No --srcdir option.  We are building in place.
1058     ac_srcdir=.
1059     if test -z "$ac_top_builddir"; then
1060        ac_top_srcdir=.
1061     else
1062        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1063     fi ;;
1064   [\\/]* | ?:[\\/]* )  # Absolute path.
1065     ac_srcdir=$srcdir$ac_dir_suffix;
1066     ac_top_srcdir=$srcdir ;;
1067   *) # Relative path.
1068     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1069     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1070 esac
1071
1072 # Do not use `cd foo && pwd` to compute absolute paths, because
1073 # the directories may not exist.
1074 case `pwd` in
1075 .) ac_abs_builddir="$ac_dir";;
1076 *)
1077   case "$ac_dir" in
1078   .) ac_abs_builddir=`pwd`;;
1079   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1080   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1081   esac;;
1082 esac
1083 case $ac_abs_builddir in
1084 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1085 *)
1086   case ${ac_top_builddir}. in
1087   .) ac_abs_top_builddir=$ac_abs_builddir;;
1088   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1089   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1090   esac;;
1091 esac
1092 case $ac_abs_builddir in
1093 .) ac_abs_srcdir=$ac_srcdir;;
1094 *)
1095   case $ac_srcdir in
1096   .) ac_abs_srcdir=$ac_abs_builddir;;
1097   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1098   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1099   esac;;
1100 esac
1101 case $ac_abs_builddir in
1102 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1103 *)
1104   case $ac_top_srcdir in
1105   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1106   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1107   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1108   esac;;
1109 esac
1110
1111     cd $ac_dir
1112     # Check for guested configure; otherwise get Cygnus style configure.
1113     if test -f $ac_srcdir/configure.gnu; then
1114       echo
1115       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1116     elif test -f $ac_srcdir/configure; then
1117       echo
1118       $SHELL $ac_srcdir/configure  --help=recursive
1119     elif test -f $ac_srcdir/configure.ac ||
1120            test -f $ac_srcdir/configure.in; then
1121       echo
1122       $ac_configure --help
1123     else
1124       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1125     fi
1126     cd $ac_popdir
1127   done
1128 fi
1129
1130 test -n "$ac_init_help" && exit 0
1131 if $ac_init_version; then
1132   cat <<\_ACEOF
1133
1134 Copyright (C) 2003 Free Software Foundation, Inc.
1135 This configure script is free software; the Free Software Foundation
1136 gives unlimited permission to copy, distribute and modify it.
1137 _ACEOF
1138   exit 0
1139 fi
1140 exec 5>config.log
1141 cat >&5 <<_ACEOF
1142 This file contains any messages produced by compilers while
1143 running configure, to aid debugging if configure makes a mistake.
1144
1145 It was created by $as_me, which was
1146 generated by GNU Autoconf 2.59.  Invocation command line was
1147
1148   $ $0 $@
1149
1150 _ACEOF
1151 {
1152 cat <<_ASUNAME
1153 ## --------- ##
1154 ## Platform. ##
1155 ## --------- ##
1156
1157 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1158 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1159 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1160 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1161 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1162
1163 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1164 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1165
1166 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1167 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1168 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1169 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1170 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1171 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1172 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1173
1174 _ASUNAME
1175
1176 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1177 for as_dir in $PATH
1178 do
1179   IFS=$as_save_IFS
1180   test -z "$as_dir" && as_dir=.
1181   echo "PATH: $as_dir"
1182 done
1183
1184 } >&5
1185
1186 cat >&5 <<_ACEOF
1187
1188
1189 ## ----------- ##
1190 ## Core tests. ##
1191 ## ----------- ##
1192
1193 _ACEOF
1194
1195
1196 # Keep a trace of the command line.
1197 # Strip out --no-create and --no-recursion so they do not pile up.
1198 # Strip out --silent because we don't want to record it for future runs.
1199 # Also quote any args containing shell meta-characters.
1200 # Make two passes to allow for proper duplicate-argument suppression.
1201 ac_configure_args=
1202 ac_configure_args0=
1203 ac_configure_args1=
1204 ac_sep=
1205 ac_must_keep_next=false
1206 for ac_pass in 1 2
1207 do
1208   for ac_arg
1209   do
1210     case $ac_arg in
1211     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1212     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1213     | -silent | --silent | --silen | --sile | --sil)
1214       continue ;;
1215     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1216       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1217     esac
1218     case $ac_pass in
1219     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1220     2)
1221       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1222       if test $ac_must_keep_next = true; then
1223         ac_must_keep_next=false # Got value, back to normal.
1224       else
1225         case $ac_arg in
1226           *=* | --config-cache | -C | -disable-* | --disable-* \
1227           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1228           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1229           | -with-* | --with-* | -without-* | --without-* | --x)
1230             case "$ac_configure_args0 " in
1231               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1232             esac
1233             ;;
1234           -* ) ac_must_keep_next=true ;;
1235         esac
1236       fi
1237       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1238       # Get rid of the leading space.
1239       ac_sep=" "
1240       ;;
1241     esac
1242   done
1243 done
1244 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1245 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1246
1247 # When interrupted or exit'd, cleanup temporary files, and complete
1248 # config.log.  We remove comments because anyway the quotes in there
1249 # would cause problems or look ugly.
1250 # WARNING: Be sure not to use single quotes in there, as some shells,
1251 # such as our DU 5.0 friend, will then `close' the trap.
1252 trap 'exit_status=$?
1253   # Save into config.log some information that might help in debugging.
1254   {
1255     echo
1256
1257     cat <<\_ASBOX
1258 ## ---------------- ##
1259 ## Cache variables. ##
1260 ## ---------------- ##
1261 _ASBOX
1262     echo
1263     # The following way of writing the cache mishandles newlines in values,
1264 {
1265   (set) 2>&1 |
1266     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1267     *ac_space=\ *)
1268       sed -n \
1269         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1270           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1271       ;;
1272     *)
1273       sed -n \
1274         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1275       ;;
1276     esac;
1277 }
1278     echo
1279
1280     cat <<\_ASBOX
1281 ## ----------------- ##
1282 ## Output variables. ##
1283 ## ----------------- ##
1284 _ASBOX
1285     echo
1286     for ac_var in $ac_subst_vars
1287     do
1288       eval ac_val=$`echo $ac_var`
1289       echo "$ac_var='"'"'$ac_val'"'"'"
1290     done | sort
1291     echo
1292
1293     if test -n "$ac_subst_files"; then
1294       cat <<\_ASBOX
1295 ## ------------- ##
1296 ## Output files. ##
1297 ## ------------- ##
1298 _ASBOX
1299       echo
1300       for ac_var in $ac_subst_files
1301       do
1302         eval ac_val=$`echo $ac_var`
1303         echo "$ac_var='"'"'$ac_val'"'"'"
1304       done | sort
1305       echo
1306     fi
1307
1308     if test -s confdefs.h; then
1309       cat <<\_ASBOX
1310 ## ----------- ##
1311 ## confdefs.h. ##
1312 ## ----------- ##
1313 _ASBOX
1314       echo
1315       sed "/^$/d" confdefs.h | sort
1316       echo
1317     fi
1318     test "$ac_signal" != 0 &&
1319       echo "$as_me: caught signal $ac_signal"
1320     echo "$as_me: exit $exit_status"
1321   } >&5
1322   rm -f core *.core &&
1323   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1324     exit $exit_status
1325      ' 0
1326 for ac_signal in 1 2 13 15; do
1327   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1328 done
1329 ac_signal=0
1330
1331 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1332 rm -rf conftest* confdefs.h
1333 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1334 echo >confdefs.h
1335
1336 # Predefined preprocessor variables.
1337
1338 cat >>confdefs.h <<_ACEOF
1339 #define PACKAGE_NAME "$PACKAGE_NAME"
1340 _ACEOF
1341
1342
1343 cat >>confdefs.h <<_ACEOF
1344 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1345 _ACEOF
1346
1347
1348 cat >>confdefs.h <<_ACEOF
1349 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1350 _ACEOF
1351
1352
1353 cat >>confdefs.h <<_ACEOF
1354 #define PACKAGE_STRING "$PACKAGE_STRING"
1355 _ACEOF
1356
1357
1358 cat >>confdefs.h <<_ACEOF
1359 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1360 _ACEOF
1361
1362
1363 # Let the site file select an alternate cache file if it wants to.
1364 # Prefer explicitly selected file to automatically selected ones.
1365 if test -z "$CONFIG_SITE"; then
1366   if test "x$prefix" != xNONE; then
1367     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1368   else
1369     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1370   fi
1371 fi
1372 for ac_site_file in $CONFIG_SITE; do
1373   if test -r "$ac_site_file"; then
1374     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1375 echo "$as_me: loading site script $ac_site_file" >&6;}
1376     sed 's/^/| /' "$ac_site_file" >&5
1377     . "$ac_site_file"
1378   fi
1379 done
1380
1381 if test -r "$cache_file"; then
1382   # Some versions of bash will fail to source /dev/null (special
1383   # files actually), so we avoid doing that.
1384   if test -f "$cache_file"; then
1385     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1386 echo "$as_me: loading cache $cache_file" >&6;}
1387     case $cache_file in
1388       [\\/]* | ?:[\\/]* ) . $cache_file;;
1389       *)                      . ./$cache_file;;
1390     esac
1391   fi
1392 else
1393   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1394 echo "$as_me: creating cache $cache_file" >&6;}
1395   >$cache_file
1396 fi
1397
1398 # Check that the precious variables saved in the cache have kept the same
1399 # value.
1400 ac_cache_corrupted=false
1401 for ac_var in `(set) 2>&1 |
1402                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1403   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1404   eval ac_new_set=\$ac_env_${ac_var}_set
1405   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1406   eval ac_new_val="\$ac_env_${ac_var}_value"
1407   case $ac_old_set,$ac_new_set in
1408     set,)
1409       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1410 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1411       ac_cache_corrupted=: ;;
1412     ,set)
1413       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1414 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1415       ac_cache_corrupted=: ;;
1416     ,);;
1417     *)
1418       if test "x$ac_old_val" != "x$ac_new_val"; then
1419         # differences in whitespace do not lead to failure.
1420         ac_old_val_w=`echo x $ac_old_val`
1421         ac_new_val_w=`echo x $ac_new_val`
1422         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1423           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1424 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1425           ac_cache_corrupted=:
1426         else
1427           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1428 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1429           eval $ac_var=\$ac_old_val
1430         fi
1431         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1432 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1433         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1434 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1435       fi;;
1436   esac
1437   # Pass precious variables to config.status.
1438   if test "$ac_new_set" = set; then
1439     case $ac_new_val in
1440     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1441       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1442     *) ac_arg=$ac_var=$ac_new_val ;;
1443     esac
1444     case " $ac_configure_args " in
1445       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1446       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1447     esac
1448   fi
1449 done
1450 if $ac_cache_corrupted; then
1451   { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1452 echo "$as_me: error: in \`$ac_pwd':" >&2;}
1453   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1454 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1455   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1456 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1457    { (exit 1); exit 1; }; }
1458 fi
1459
1460 ac_ext=c
1461 ac_cpp='$CPP $CPPFLAGS'
1462 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1463 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1464 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489 progname=$0
1490 # if PWD already has a value, it is probably wrong.
1491 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1492
1493 # Export original configure arguments for use by sub-configures.
1494 # Quote arguments with shell meta charatcers.
1495 TOPLEVEL_CONFIGURE_ARGUMENTS=
1496 set -- "$progname" "$@"
1497 for ac_arg
1498 do
1499   case "$ac_arg" in
1500   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1501     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1502     # if the argument is of the form -foo=baz, quote the baz part only
1503     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1504   *) ;;
1505   esac
1506   # Add the quoted argument to the list.
1507   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1508 done
1509 if test "$silent" = yes; then
1510   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1511 fi
1512 # Remove the initial space we just introduced and, as these will be
1513 # expanded by make, quote '$'.
1514 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1515
1516
1517 # Find the build, host, and target systems.
1518 ac_aux_dir=
1519 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1520   if test -f $ac_dir/install-sh; then
1521     ac_aux_dir=$ac_dir
1522     ac_install_sh="$ac_aux_dir/install-sh -c"
1523     break
1524   elif test -f $ac_dir/install.sh; then
1525     ac_aux_dir=$ac_dir
1526     ac_install_sh="$ac_aux_dir/install.sh -c"
1527     break
1528   elif test -f $ac_dir/shtool; then
1529     ac_aux_dir=$ac_dir
1530     ac_install_sh="$ac_aux_dir/shtool install -c"
1531     break
1532   fi
1533 done
1534 if test -z "$ac_aux_dir"; then
1535   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1536 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1537    { (exit 1); exit 1; }; }
1538 fi
1539 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1540 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1541 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1542
1543 # Make sure we can run config.sub.
1544 $ac_config_sub sun4 >/dev/null 2>&1 ||
1545   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1546 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1547    { (exit 1); exit 1; }; }
1548
1549 echo "$as_me:$LINENO: checking build system type" >&5
1550 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1551 if test "${ac_cv_build+set}" = set; then
1552   echo $ECHO_N "(cached) $ECHO_C" >&6
1553 else
1554   ac_cv_build_alias=$build_alias
1555 test -z "$ac_cv_build_alias" &&
1556   ac_cv_build_alias=`$ac_config_guess`
1557 test -z "$ac_cv_build_alias" &&
1558   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1559 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1560    { (exit 1); exit 1; }; }
1561 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1562   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1563 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1564    { (exit 1); exit 1; }; }
1565
1566 fi
1567 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1568 echo "${ECHO_T}$ac_cv_build" >&6
1569 build=$ac_cv_build
1570 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1571 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1572 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1573
1574
1575  case ${build_alias} in
1576   "") build_noncanonical=${build} ;;
1577   *) build_noncanonical=${build_alias} ;;
1578 esac
1579
1580
1581
1582  case ${host_alias} in
1583   "") host_noncanonical=${build_noncanonical} ;;
1584   *) host_noncanonical=${host_alias} ;;
1585 esac
1586
1587
1588
1589  case ${target_alias} in
1590   "") target_noncanonical=${host_noncanonical} ;;
1591   *) target_noncanonical=${target_alias} ;;
1592 esac
1593
1594
1595
1596
1597 test "$host_noncanonical" = "$target_noncanonical" &&
1598   test "$program_prefix$program_suffix$program_transform_name" = \
1599     NONENONEs,x,x, &&
1600   program_transform_name=s,y,y,
1601
1602 echo "$as_me:$LINENO: checking host system type" >&5
1603 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1604 if test "${ac_cv_host+set}" = set; then
1605   echo $ECHO_N "(cached) $ECHO_C" >&6
1606 else
1607   ac_cv_host_alias=$host_alias
1608 test -z "$ac_cv_host_alias" &&
1609   ac_cv_host_alias=$ac_cv_build_alias
1610 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1611   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1612 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1613    { (exit 1); exit 1; }; }
1614
1615 fi
1616 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1617 echo "${ECHO_T}$ac_cv_host" >&6
1618 host=$ac_cv_host
1619 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1620 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1621 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1622
1623
1624 echo "$as_me:$LINENO: checking target system type" >&5
1625 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1626 if test "${ac_cv_target+set}" = set; then
1627   echo $ECHO_N "(cached) $ECHO_C" >&6
1628 else
1629   ac_cv_target_alias=$target_alias
1630 test "x$ac_cv_target_alias" = "x" &&
1631   ac_cv_target_alias=$ac_cv_host_alias
1632 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1633   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1634 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1635    { (exit 1); exit 1; }; }
1636
1637 fi
1638 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1639 echo "${ECHO_T}$ac_cv_target" >&6
1640 target=$ac_cv_target
1641 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1642 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1643 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1644
1645
1646 # The aliases save the names the user supplied, while $host etc.
1647 # will get canonicalized.
1648 test -n "$target_alias" &&
1649   test "$program_prefix$program_suffix$program_transform_name" = \
1650     NONENONEs,x,x, &&
1651   program_prefix=${target_alias}-
1652 test "$program_prefix" != NONE &&
1653   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1654 # Use a double $ so make ignores it.
1655 test "$program_suffix" != NONE &&
1656   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1657 # Double any \ or $.  echo might interpret backslashes.
1658 # By default was `s,x,x', remove it if useless.
1659 cat <<\_ACEOF >conftest.sed
1660 s/[\\$]/&&/g;s/;s,x,x,$//
1661 _ACEOF
1662 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1663 rm conftest.sed
1664
1665
1666
1667 # Get 'install' or 'install-sh' and its variants.
1668 # Find a good install program.  We prefer a C program (faster),
1669 # so one script is as good as another.  But avoid the broken or
1670 # incompatible versions:
1671 # SysV /etc/install, /usr/sbin/install
1672 # SunOS /usr/etc/install
1673 # IRIX /sbin/install
1674 # AIX /bin/install
1675 # AmigaOS /C/install, which installs bootblocks on floppy discs
1676 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1677 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1678 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1679 # OS/2's system install, which has a completely different semantic
1680 # ./install, which can be erroneously created by make from ./install.sh.
1681 # Reject install programs that cannot install multiple files.
1682 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1683 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1684 if test -z "$INSTALL"; then
1685 if test "${ac_cv_path_install+set}" = set; then
1686   echo $ECHO_N "(cached) $ECHO_C" >&6
1687 else
1688   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1689 for as_dir in $PATH
1690 do
1691   IFS=$as_save_IFS
1692   test -z "$as_dir" && as_dir=.
1693   # Account for people who put trailing slashes in PATH elements.
1694 case $as_dir/ in
1695   ./ | .// | /cC/* | \
1696   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1697   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1698   /usr/ucb/* ) ;;
1699   *)
1700     # OSF1 and SCO ODT 3.0 have their own names for install.
1701     # Don't use installbsd from OSF since it installs stuff as root
1702     # by default.
1703     for ac_prog in ginstall scoinst install; do
1704       for ac_exec_ext in '' $ac_executable_extensions; do
1705         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1706           if test $ac_prog = install &&
1707             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1708             # AIX install.  It has an incompatible calling convention.
1709             :
1710           elif test $ac_prog = install &&
1711             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1712             # program-specific install script used by HP pwplus--don't use.
1713             :
1714           else
1715             rm -rf conftest.one conftest.two conftest.dir
1716             echo one > conftest.one
1717             echo two > conftest.two
1718             mkdir conftest.dir
1719             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1720               test -s conftest.one && test -s conftest.two &&
1721               test -s conftest.dir/conftest.one &&
1722               test -s conftest.dir/conftest.two
1723             then
1724               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1725               break 3
1726             fi
1727           fi
1728         fi
1729       done
1730     done
1731     ;;
1732 esac
1733 done
1734
1735 rm -rf conftest.one conftest.two conftest.dir
1736
1737 fi
1738   if test "${ac_cv_path_install+set}" = set; then
1739     INSTALL=$ac_cv_path_install
1740   else
1741     # As a last resort, use the slow shell script.  Don't cache a
1742     # value for INSTALL within a source directory, because that will
1743     # break other packages using the cache if that directory is
1744     # removed, or if the value is a relative name.
1745     INSTALL=$ac_install_sh
1746   fi
1747 fi
1748 echo "$as_me:$LINENO: result: $INSTALL" >&5
1749 echo "${ECHO_T}$INSTALL" >&6
1750
1751 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1752 # It thinks the first close brace ends the variable substitution.
1753 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1754
1755 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1756
1757 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1758
1759 echo "$as_me:$LINENO: checking whether ln works" >&5
1760 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1761 if test "${acx_cv_prog_LN+set}" = set; then
1762   echo $ECHO_N "(cached) $ECHO_C" >&6
1763 else
1764   rm -f conftestdata_t
1765 echo >conftestdata_f
1766 if ln conftestdata_f conftestdata_t 2>/dev/null
1767 then
1768   acx_cv_prog_LN=ln
1769 else
1770   acx_cv_prog_LN=no
1771 fi
1772 rm -f conftestdata_f conftestdata_t
1773
1774 fi
1775 if test $acx_cv_prog_LN = no; then
1776   LN="cp"
1777   echo "$as_me:$LINENO: result: no, using $LN" >&5
1778 echo "${ECHO_T}no, using $LN" >&6
1779 else
1780   LN="$acx_cv_prog_LN"
1781   echo "$as_me:$LINENO: result: yes" >&5
1782 echo "${ECHO_T}yes" >&6
1783 fi
1784
1785 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1786 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1787 LN_S=$as_ln_s
1788 if test "$LN_S" = "ln -s"; then
1789   echo "$as_me:$LINENO: result: yes" >&5
1790 echo "${ECHO_T}yes" >&6
1791 else
1792   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1793 echo "${ECHO_T}no, using $LN_S" >&6
1794 fi
1795
1796
1797 ### we might need to use some other shell than /bin/sh for running subshells
1798 ### If we are on Windows, search for the shell.  This will permit people
1799 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1800 ### without also having to set CONFIG_SHELL.  This code will work when
1801 ### using bash, which sets OSTYPE.
1802 case "${OSTYPE}" in
1803 *win32*)
1804   if test x${CONFIG_SHELL} = x ; then
1805     if test ! -f /bin/sh ; then
1806       if test x${SHELL} != x && test -f ${SHELL} ; then
1807         CONFIG_SHELL=${SHELL}
1808         export CONFIG_SHELL
1809       else
1810         for prog in sh sh.exe bash bash.exe; do
1811           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1812           for dir in $PATH; do
1813             test -z "$dir" && dir=.
1814             if test -f $dir/$prog; then
1815               CONFIG_SHELL=$dir/$prog
1816               export CONFIG_SHELL
1817               break
1818             fi
1819           done
1820           IFS="$save_ifs"
1821           test -n "${CONFIG_SHELL}" && break
1822         done
1823       fi
1824     fi
1825   fi
1826   ;;
1827 esac
1828
1829 config_shell=${CONFIG_SHELL-/bin/sh}
1830
1831 moveifchange=${srcdir}/move-if-change
1832
1833 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1834
1835 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1836 # a relative path.
1837 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1838   INSTALL="${srcpwd}/install-sh -c"
1839 fi
1840
1841 # Set srcdir to "." if that's what it is.
1842 # This is important for multilib support.
1843 pwd=`${PWDCMD-pwd}`
1844 if test "${pwd}" = "${srcpwd}" ; then
1845   srcdir=.
1846 fi
1847
1848 topsrcdir=$srcpwd
1849
1850 extra_host_args=
1851
1852 ### To add a new directory to the tree, first choose whether it is a target
1853 ### or a host dependent tool.  Then put it into the appropriate list
1854 ### (library or tools, host or target), doing a dependency sort.
1855
1856 # Subdirs will be configured in the order listed in build_configdirs,
1857 # configdirs, or target_configdirs; see the serialization section below.
1858
1859 # Dependency sorting is only needed when *configuration* must be done in
1860 # a particular order.  In all cases a dependency should be specified in
1861 # the Makefile, whether or not it's implicitly specified here.
1862
1863 # Double entries in build_configdirs, configdirs, or target_configdirs may
1864 # cause circular dependencies and break everything horribly.
1865
1866 # these library is used by various programs built for the build
1867 # environment
1868 #
1869 build_libs="build-libiberty"
1870
1871 # these tools are built for the build environment
1872 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1873
1874 # these libraries are used by various programs built for the host environment
1875 #
1876 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1877
1878 # these tools are built for the host environment
1879 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1880 # know that we are building the simulator.
1881 # binutils, gas and ld appear in that order because it makes sense to run
1882 # "make check" in that particular order.
1883 # If --enable-gold is used, "gold" will replace "ld".
1884 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"
1885
1886 # libgcj represents the runtime libraries only used by gcj.
1887 libgcj="target-libffi \
1888         target-zlib \
1889         target-qthreads \
1890         target-libjava"
1891
1892 # these libraries are built for the target environment, and are built after
1893 # the host libraries and the host tools (which may be a cross compiler)
1894 #
1895 target_libraries="target-libgcc \
1896                 target-libiberty \
1897                 target-libgloss \
1898                 target-newlib \
1899                 target-libgomp \
1900                 target-libstdc++-v3 \
1901                 target-libmudflap \
1902                 target-libssp \
1903                 target-libgfortran \
1904                 target-boehm-gc \
1905                 ${libgcj} \
1906                 target-libobjc \
1907                 target-libada"
1908
1909 # these tools are built using the target libraries, and are intended to
1910 # run only in the target environment
1911 #
1912 # note: any program that *uses* libraries that are in the "target_libraries"
1913 # list belongs in this list.  those programs are also very likely
1914 # candidates for the "native_only" list which follows
1915 #
1916 target_tools="target-examples target-groff target-gperf target-rda"
1917
1918 ################################################################################
1919
1920 ## All tools belong in one of the four categories, and are assigned above
1921 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1922 ## is important because configure will choke if they ever get through.
1923 ## ${configdirs} is directories we build using the host tools.
1924 ## ${target_configdirs} is directories we build using the target tools.
1925 configdirs=`echo ${host_libs} ${host_tools}`
1926 target_configdirs=`echo ${target_libraries} ${target_tools}`
1927 build_configdirs=`echo ${build_libs} ${build_tools}`
1928
1929
1930
1931 ################################################################################
1932
1933 srcname="gnu development package"
1934
1935 # This gets set non-empty for some net releases of packages.
1936 appdirs=""
1937
1938 # Define is_cross_compiler to save on calls to 'test'.
1939 is_cross_compiler=
1940 if test x"${host}" = x"${target}" ; then
1941   is_cross_compiler=no
1942 else
1943   is_cross_compiler=yes
1944 fi
1945
1946 # Find the build and target subdir names.
1947
1948 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1949 # have matching libraries, they should use host libraries: Makefile.tpl
1950 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1951 # However, they still use the build modules, because the corresponding
1952 # host modules (e.g. bison) are only built for the host when bootstrap
1953 # finishes. So:
1954 # - build_subdir is where we find build modules, and never changes.
1955 # - build_libsubdir is where we find build libraries, and can be overridden.
1956
1957 # Prefix 'build-' so this never conflicts with target_subdir.
1958 build_subdir="build-${build_noncanonical}"
1959
1960 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1961 if test "${with_build_libsubdir+set}" = set; then
1962   withval="$with_build_libsubdir"
1963   build_libsubdir="$withval"
1964 else
1965   build_libsubdir="$build_subdir"
1966 fi;
1967 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1968 if ( test $srcdir = . && test -d gcc ) \
1969    || test -d $srcdir/../host-${host_noncanonical}; then
1970   host_subdir="host-${host_noncanonical}"
1971 else
1972   host_subdir=.
1973 fi
1974 # No prefix.
1975 target_subdir=${target_noncanonical}
1976
1977
1978 # Skipdirs are removed silently.
1979 skipdirs=
1980 # Noconfigdirs are removed loudly.
1981 noconfigdirs=""
1982
1983 use_gnu_ld=
1984 # Make sure we don't let GNU ld be added if we didn't want it.
1985 if test x$with_gnu_ld = xno ; then
1986   use_gnu_ld=no
1987   noconfigdirs="$noconfigdirs ld gold"
1988 fi
1989
1990 use_gnu_as=
1991 # Make sure we don't let GNU as be added if we didn't want it.
1992 if test x$with_gnu_as = xno ; then
1993   use_gnu_as=no
1994   noconfigdirs="$noconfigdirs gas"
1995 fi
1996
1997 # some tools are so dependent upon X11 that if we're not building with X,
1998 # it's not even worth trying to configure, much less build, that tool.
1999
2000 case ${with_x} in
2001   yes | "") ;; # the default value for this tree is that X11 is available
2002   no)
2003     skipdirs="${skipdirs} tk itcl libgui"
2004     # We won't be able to build gdbtk without X.
2005     enable_gdbtk=no
2006     ;;
2007   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2008 esac
2009
2010 # Some tools are only suitable for building in a "native" situation.
2011 # Remove these if host!=target.
2012 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"
2013
2014 # Similarly, some are only suitable for cross toolchains.
2015 # Remove these if host=target.
2016 cross_only="target-libgloss target-newlib target-opcodes"
2017
2018 case $is_cross_compiler in
2019   no) skipdirs="${skipdirs} ${cross_only}" ;;
2020   yes) skipdirs="${skipdirs} ${native_only}" ;;
2021 esac
2022
2023 # If both --with-headers and --with-libs are specified, default to
2024 # --without-newlib.
2025 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2026    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2027   if test x"${with_newlib}" = x ; then
2028     with_newlib=no
2029   fi
2030 fi
2031
2032 # Recognize --with-newlib/--without-newlib.
2033 case ${with_newlib} in
2034   no) skipdirs="${skipdirs} target-newlib" ;;
2035   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2036 esac
2037
2038 # Handle --enable-gold.
2039
2040 # Check whether --enable-gold or --disable-gold was given.
2041 if test "${enable_gold+set}" = set; then
2042   enableval="$enable_gold"
2043   ENABLE_GOLD=$enableval
2044 else
2045   ENABLE_GOLD=no
2046 fi;
2047 if test "${ENABLE_GOLD}" = "yes"; then
2048   # Check for ELF target.
2049   is_elf=no
2050   case "${target}" in
2051     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2052     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2053     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2054       case "${target}" in
2055         *-*-linux*aout* | *-*-linux*oldld*)
2056           ;;
2057         *)
2058           is_elf=yes
2059           ;;
2060       esac
2061   esac
2062
2063   if test "$is_elf" = "yes"; then
2064     # Check for target supported by gold.
2065     case "${target}" in
2066       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-*)
2067         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2068         ;;
2069     esac
2070   fi
2071 fi
2072
2073 # Configure extra directories which are host specific
2074
2075 case "${host}" in
2076   *-cygwin*)
2077     configdirs="$configdirs libtermcap" ;;
2078 esac
2079
2080 # A target can indicate whether a language isn't supported for some reason.
2081 # Only spaces may be used in this macro; not newlines or tabs.
2082 unsupported_languages=
2083
2084 # Remove more programs from consideration, based on the host or
2085 # target this usually means that a port of the program doesn't
2086 # exist yet.
2087
2088 case "${host}" in
2089   hppa*64*-*-*)
2090     noconfigdirs="$noconfigdirs byacc"
2091     ;;
2092   i[3456789]86-*-vsta)
2093     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2094     ;;
2095   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2096     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2097     ;;
2098   x86_64-*-mingw*)
2099     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2100     ;;
2101   i[3456789]86-*-mingw32*)
2102     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2103     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2104     ;;
2105   i[3456789]86-*-beos*)
2106     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2107     ;;
2108   *-*-cygwin*)
2109     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2110     ;;
2111   *-*-netbsd*)
2112     noconfigdirs="$noconfigdirs rcs"
2113     ;;
2114   ppc*-*-pe)
2115     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2116     ;;
2117   powerpc-*-beos*)
2118     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2119     ;;
2120 esac
2121
2122
2123 # Check whether --enable-libada or --disable-libada was given.
2124 if test "${enable_libada+set}" = set; then
2125   enableval="$enable_libada"
2126   ENABLE_LIBADA=$enableval
2127 else
2128   ENABLE_LIBADA=yes
2129 fi;
2130 if test "${ENABLE_LIBADA}" != "yes" ; then
2131   noconfigdirs="$noconfigdirs gnattools"
2132 fi
2133
2134 # Check whether --enable-libssp or --disable-libssp was given.
2135 if test "${enable_libssp+set}" = set; then
2136   enableval="$enable_libssp"
2137   ENABLE_LIBSSP=$enableval
2138 else
2139   ENABLE_LIBSSP=yes
2140 fi;
2141
2142 # Save it here so that, even in case of --enable-libgcj, if the Java
2143 # front-end isn't enabled, we still get libgcj disabled.
2144 libgcj_saved=$libgcj
2145 case $enable_libgcj in
2146 yes)
2147   # If we reset it here, it won't get added to noconfigdirs in the
2148   # target-specific build rules, so it will be forcibly enabled
2149   # (unless the Java language itself isn't enabled).
2150   libgcj=
2151   ;;
2152 no)
2153   # Make sure we get it printed in the list of not supported target libs.
2154   noconfigdirs="$noconfigdirs ${libgcj}"
2155   ;;
2156 esac
2157
2158
2159 # Disable libmudflap on some systems.
2160 if test x$enable_libmudflap = x ; then
2161     case "${target}" in
2162     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2163         # Enable libmudflap by default in GNU and friends.
2164         ;;
2165     *-*-freebsd*)
2166         # Enable libmudflap by default in FreeBSD.
2167         ;;
2168     *)
2169         # Disable it by default everywhere else.
2170         noconfigdirs="$noconfigdirs target-libmudflap"
2171         ;;
2172     esac
2173 fi
2174
2175 # Disable libgomp on non POSIX hosted systems.
2176 if test x$enable_libgomp = x ; then
2177     # Enable libgomp by default on hosted POSIX systems.
2178     case "${target}" in
2179     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2180         ;;
2181     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2182         ;;
2183     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2184         ;;
2185     *-*-darwin* | *-*-aix*)
2186         ;;
2187     *)
2188         noconfigdirs="$noconfigdirs target-libgomp"
2189         ;;
2190     esac
2191 fi
2192
2193 # Default libgloss CPU subdirectory.
2194 libgloss_dir="$target_cpu"
2195
2196 case "${target}" in
2197   *-*-chorusos)
2198     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2199     ;;
2200   powerpc-*-darwin* | i[3456789]86-*-darwin* | x86_64-*-darwin9*)
2201     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2202     noconfigdirs="$noconfigdirs sim target-rda"
2203     ;;
2204   *-*-darwin*)
2205     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2206     noconfigdirs="$noconfigdirs sim target-rda"
2207     noconfigdirs="$noconfigdirs ${libgcj}"
2208     ;;
2209   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2210     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2211     ;;
2212   *-*-freebsd*)
2213     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2214     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2215         && test -f /usr/local/include/gmp.h; then
2216       with_gmp=/usr/local
2217     fi
2218
2219     # Skip some stuff that's unsupported on some FreeBSD configurations.
2220     case "${target}" in
2221       i*86-*-*) ;;
2222       alpha*-*-*) ;;
2223       *)
2224         noconfigdirs="$noconfigdirs ${libgcj}"
2225         ;;
2226     esac
2227     ;;
2228   *-*-kaos*)
2229     # Remove unsupported stuff on all kaOS configurations.
2230     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2231     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2232     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2233     noconfigdirs="$noconfigdirs target-libgloss"
2234     ;;
2235   *-*-netbsd*)
2236     # Skip some stuff on all NetBSD configurations.
2237     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2238
2239     # Skip some stuff that's unsupported on some NetBSD configurations.
2240     case "${target}" in
2241       i*86-*-netbsdelf*) ;;
2242       arm*-*-netbsdelf*) ;;
2243       *)
2244         noconfigdirs="$noconfigdirs ${libgcj}"
2245         ;;
2246     esac
2247     ;;
2248   *-*-netware*)
2249     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2250     ;;
2251   *-*-rtems*)
2252     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2253     ;;
2254     # The tpf target doesn't support gdb yet.
2255   *-*-tpf*)
2256     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2257     ;;
2258   *-*-uclinux*)
2259     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2260     ;;
2261   *-*-vxworks*)
2262     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2263     ;;
2264   alpha*-dec-osf*)
2265     # ld works, but does not support shared libraries.
2266     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2267     # gas doesn't generate exception information.
2268     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2269     ;;
2270   alpha*-*-*vms*)
2271     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2272     ;;
2273   alpha*-*-linux*)
2274     # newlib is not 64 bit ready
2275     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2276     ;;
2277   alpha*-*-*)
2278     # newlib is not 64 bit ready
2279     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2280     ;;
2281   am33_2.0-*-linux*)
2282     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2283     ;;
2284   sh-*-linux*)
2285     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2286     ;;
2287   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2288     noconfigdirs="$noconfigdirs ${libgcj}"
2289     noconfigdirs="$noconfigdirs target-examples"
2290     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2291     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2292     noconfigdirs="$noconfigdirs expect dejagnu"
2293     # the C++ libraries don't build on top of CE's C libraries
2294     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2295     noconfigdirs="$noconfigdirs target-newlib"
2296     case "${host}" in
2297       *-*-cygwin*) ;; # keep gdb and readline
2298       *) noconfigdirs="$noconfigdirs gdb readline"
2299          ;;
2300     esac
2301     libgloss_dir=wince
2302     ;;
2303   arc-*-*)
2304     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2305     ;;
2306   arm-semi-aof )
2307     ;;
2308   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2309     noconfigdirs="$noconfigdirs ${libgcj}"
2310     libgloss_dir=arm
2311     ;;
2312   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2313     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2314     libgloss_dir=arm
2315     ;;
2316   arm*-*-linux-gnueabi)
2317     noconfigdirs="$noconfigdirs target-qthreads"
2318     case ${with_newlib} in
2319       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2320     esac
2321     libgloss_dir=arm
2322     ;;
2323   arm*-*-symbianelf*)
2324     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2325     libgloss_dir=arm
2326     ;;
2327   arm-*-pe*)
2328     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2329     ;;
2330   thumb-*-coff)
2331     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2332     ;;
2333   thumb-*-elf)
2334     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2335     ;;
2336   thumb-*-pe)
2337     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2338     ;;
2339   arm-*-riscix*)
2340     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2341     ;;
2342   avr-*-*)
2343     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2344     ;;
2345   bfin-*-*)
2346     noconfigdirs="$noconfigdirs gdb"
2347     if test x${is_cross_compiler} != xno ; then
2348       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2349     fi
2350     ;;
2351   c4x-*-* | tic4x-*-*)
2352     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2353     ;;
2354   c54x*-*-* | tic54x-*-*)
2355     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2356     ;;
2357   cr16-*-*)
2358     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2359     ;;
2360   cris-*-* | crisv32-*-*)
2361     unsupported_languages="$unsupported_languages java"
2362     case "${target}" in
2363       *-*-aout)
2364         unsupported_languages="$unsupported_languages fortran"
2365         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2366       *-*-elf)
2367         noconfigdirs="$noconfigdirs target-boehm-gc";;
2368       *-*-linux*)
2369         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2370       *)
2371         unsupported_languages="$unsupported_languages fortran"
2372         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2373     esac
2374     libgloss_dir=cris
2375     ;;
2376   crx-*-*)
2377     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2378     ;;
2379   d10v-*-*)
2380     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2381     ;;
2382   d30v-*-*)
2383     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2384     ;;
2385   ep9312-*-elf | ep9312-*-coff)
2386     libgloss_dir=arm
2387     ;;
2388   fr30-*-elf*)
2389     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2390     ;;
2391   frv-*-*)
2392     noconfigdirs="$noconfigdirs ${libgcj}"
2393     ;;
2394   h8300*-*-*)
2395     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2396     ;;
2397   h8500-*-*)
2398     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2399     ;;
2400   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2401     ;;
2402   hppa*64*-*-linux* | parisc*64*-*-linux*)
2403     # In this case, it's because the hppa64-linux target is for
2404     # the kernel only at this point and has no libc, and thus no
2405     # headers, crt*.o, etc., all of which are needed by these.
2406     noconfigdirs="$noconfigdirs target-zlib"
2407     ;;
2408   parisc*-*-linux* | hppa*-*-linux*)
2409     ;;
2410   hppa*-*-*elf* | \
2411   hppa*-*-lites* | \
2412   hppa*-*-openbsd* | \
2413   hppa*64*-*-*)
2414     noconfigdirs="$noconfigdirs ${libgcj}"
2415     ;;
2416   hppa*-hp-hpux11*)
2417     noconfigdirs="$noconfigdirs ld shellutils"
2418     ;;
2419   hppa*-*-pro*)
2420     libgloss_dir=pa
2421     ;;
2422   hppa*-*-*)
2423     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2424     # build on HP-UX 10.20.
2425     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2426     ;;
2427   i960-*-*)
2428     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2429     ;;
2430   ia64*-*-elf*)
2431     # No gdb support yet.
2432     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2433     ;;
2434   ia64*-**-hpux*)
2435     # No gdb or ld support yet.
2436     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2437     ;;
2438   i370-*-opened*)
2439     ;;
2440   i[3456789]86-*-coff | i[3456789]86-*-elf)
2441     noconfigdirs="$noconfigdirs ${libgcj}"
2442     libgloss_dir=i386
2443     ;;
2444   i[3456789]86-*-linux*)
2445     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2446     # not build java stuff by default.
2447     case "${target}" in
2448       *-*-*libc1*)
2449         noconfigdirs="$noconfigdirs ${libgcj}";;
2450     esac
2451
2452     # This section makes it possible to build newlib natively on linux.
2453     # If we are using a cross compiler then don't configure newlib.
2454     if test x${is_cross_compiler} != xno ; then
2455       noconfigdirs="$noconfigdirs target-newlib"
2456     fi
2457     noconfigdirs="$noconfigdirs target-libgloss"
2458     # If we are not using a cross compiler, do configure newlib.
2459     # Note however, that newlib will only be configured in this situation
2460     # if the --with-newlib option has been given, because otherwise
2461     # 'target-newlib' will appear in skipdirs.
2462     ;;
2463   i[3456789]86-*-mingw32*)
2464     target_configdirs="$target_configdirs target-winsup"
2465     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2466     ;;
2467   x86_64-*-mingw*)
2468     target_configdirs="$target_configdirs target-winsup"
2469     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2470     ;;
2471   *-*-cygwin*)
2472     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2473     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2474     # always build newlib if winsup directory is present.
2475     if test -d "$srcdir/winsup/cygwin"; then
2476       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2477     elif test -d "$srcdir/newlib"; then
2478       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2479     fi
2480     ;;
2481   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2482   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2483     ;;
2484   i[3456789]86-*-pe)
2485     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2486     ;;
2487   i[3456789]86-*-sco3.2v5*)
2488     # The linker does not yet know about weak symbols in COFF,
2489     # and is not configured to handle mixed ELF and COFF.
2490     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2491     ;;
2492   i[3456789]86-*-sco*)
2493     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2494     ;;
2495   i[3456789]86-*-solaris2*)
2496     noconfigdirs="$noconfigdirs target-libgloss"
2497     ;;
2498   i[3456789]86-*-sysv4*)
2499     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2500     ;;
2501   i[3456789]86-*-beos*)
2502     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2503     ;;
2504   i[3456789]86-*-rdos*)
2505     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2506     ;;
2507   m32r-*-*)
2508     noconfigdirs="$noconfigdirs ${libgcj}"
2509     ;;
2510   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2511     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2512     libgloss_dir=m68hc11
2513     ;;
2514   m68k-*-elf*)
2515     noconfigdirs="$noconfigdirs ${libgcj}"
2516     ;;
2517   m68k-*-coff*)
2518     noconfigdirs="$noconfigdirs ${libgcj}"
2519     ;;
2520   m68*-*-* | fido-*-*)
2521     libgloss_dir=m68k
2522     ;;
2523   mcore-*-pe*)
2524   # The EPOC C++ environment does not support exceptions or rtti,
2525   # and so building libstdc++-v3 tends not to always work.
2526     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2527     ;;
2528   mmix-*-*)
2529     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2530     unsupported_languages="$unsupported_languages fortran java"
2531     ;;
2532   mn10200-*-*)
2533     noconfigdirs="$noconfigdirs ${libgcj}"
2534     ;;
2535   mn10300-*-*)
2536     noconfigdirs="$noconfigdirs ${libgcj}"
2537     ;;
2538   mt-*-*)
2539     noconfigdirs="$noconfigdirs sim"
2540     ;;
2541   powerpc-*-aix*)
2542     # copied from rs6000-*-* entry
2543     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2544     ;;
2545   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2546     target_configdirs="$target_configdirs target-winsup"
2547     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2548     # always build newlib.
2549     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2550     ;;
2551     # This is temporary until we can link against shared libraries
2552   powerpcle-*-solaris*)
2553     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2554     libgloss_dir=rs6000
2555     ;;
2556   powerpc-*-beos*)
2557     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2558     ;;
2559   powerpc-*-eabi)
2560     noconfigdirs="$noconfigdirs ${libgcj}"
2561     libgloss_dir=rs6000
2562     ;;
2563   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2564     libgloss_dir=rs6000
2565     ;;
2566   rs6000-*-lynxos*)
2567     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2568     ;;
2569   rs6000-*-aix*)
2570     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2571     ;;
2572   rs6000-*-*)
2573     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2574     ;;
2575   m68k-apollo-*)
2576     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2577     ;;
2578   mips*-sde-elf*)
2579     skipdirs="$skipdirs target-libiberty"
2580     noconfigdirs="$noconfigdirs ${libgcj}"
2581     if test x$with_newlib = xyes; then
2582       noconfigdirs="$noconfigdirs gprof"
2583     fi
2584     libgloss_dir=mips
2585     ;;
2586   mips*-*-irix5*)
2587     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2588     ;;
2589   mips*-*-irix6*)
2590     # Linking libjava exceeds command-line length limits on at least
2591     # IRIX 6.2, but not on IRIX 6.5.
2592     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2593     # <oldham@codesourcery.com>
2594     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2595     ;;
2596   mips*-*-bsd*)
2597     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2598     ;;
2599   mips*-*-linux*)
2600     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2601     ;;
2602   mips*-*-*)
2603     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2604     libgloss_dir=mips
2605     ;;
2606   romp-*-*)
2607     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2608     ;;
2609   sh-*-* | sh64-*-*)
2610     case "${host}" in
2611       i[3456789]86-*-vsta) ;; # don't add gprof back in
2612       i[3456789]86-*-go32*) ;; # don't add gprof back in
2613       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2614       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2615     esac
2616     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2617     ;;
2618   sparclet-*-aout* | sparc86x-*-*)
2619     libgloss_dir=sparc
2620     ;;
2621   sparc-*-elf*)
2622     noconfigdirs="$noconfigdirs ${libgcj}"
2623     ;;
2624   sparc64-*-elf*)
2625     noconfigdirs="$noconfigdirs ${libgcj}"
2626     libgloss_dir=sparc
2627     ;;
2628   sparclite-*-*)
2629     noconfigdirs="$noconfigdirs ${libgcj}"
2630     libgloss_dir=sparc
2631     ;;
2632   sparc-*-sunos4*)
2633     noconfigdirs="$noconfigdirs ${libgcj}"
2634     if test x${is_cross_compiler} != xno ; then
2635            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2636     else
2637            use_gnu_ld=no
2638     fi
2639     ;;
2640   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2641     noconfigdirs="$noconfigdirs ${libgcj}"
2642     ;;
2643   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2644     ;;
2645   spu-*-*)
2646     skipdirs="target-libssp"
2647     ;;
2648   v810-*-*)
2649     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2650     ;;
2651   v850-*-*)
2652     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2653     ;;
2654   v850e-*-*)
2655     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2656     ;;
2657   v850ea-*-*)
2658     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2659     ;;
2660   vax-*-vms)
2661     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2662     ;;
2663   vax-*-*)
2664     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2665     ;;
2666   xtensa*-*-*)
2667     noconfigdirs="$noconfigdirs ${libgcj}"
2668     ;;
2669   ip2k-*-*)
2670     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2671     ;;
2672   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2673     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2674     ;;
2675   *-*-lynxos*)
2676     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2677     ;;
2678   *-*-*)
2679     noconfigdirs="$noconfigdirs ${libgcj}"
2680     ;;
2681 esac
2682
2683 # If we aren't building newlib, then don't build libgloss, since libgloss
2684 # depends upon some newlib header files.
2685 case "${noconfigdirs}" in
2686   *target-libgloss*) ;;
2687   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2688 esac
2689
2690 # Work in distributions that contain no compiler tools, like Autoconf.
2691 tentative_cc=""
2692 host_makefile_frag=/dev/null
2693 if test -d ${srcdir}/config ; then
2694 case "${host}" in
2695   m68k-hp-hpux*)
2696     # Avoid "too much defining" errors from HPUX compiler.
2697     tentative_cc="cc -Wp,-H256000"
2698     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2699     # If it's HP/UX ar, this should be harmless.
2700     RANLIB="ar ts"
2701     ;;
2702   m68k-apollo-sysv*)
2703     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2704     ;;
2705   m68k-apollo-bsd*)
2706     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2707     # chokes on bfd, the compiler won't let you assign integers to enums, and
2708     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2709     # the apollo compiler" (the preferred version of GCC could be called cc,
2710     # or whatever), but I'm not sure leaving CC as cc is any better...
2711     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2712     # Used to have BISON=yacc.
2713     tentative_cc=gcc
2714     ;;
2715   m88k-dg-dgux*)
2716     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2717     ;;
2718   m88k-harris-cxux*)
2719     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2720     tentative_cc="cc -Xa"
2721     host_makefile_frag="config/mh-cxux"
2722     ;;
2723   m88k-motorola-sysv*)
2724     ;;
2725   mips*-dec-ultrix*)
2726     tentative_cc="cc -Wf,-XNg1000"
2727     host_makefile_frag="config/mh-decstation"
2728     ;;
2729   mips*-nec-sysv4*)
2730     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2731     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2732     host_makefile_frag="config/mh-necv4"
2733     ;;
2734   mips*-sgi-irix4*)
2735     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2736     # environment.  Also bump switch table size so that cp-parse will
2737     # compile.  Bump string length limit so linker builds.
2738     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2739     ;;
2740   mips*-*-sysv4*)
2741     host_makefile_frag="config/mh-sysv4"
2742     ;;
2743   mips*-*-sysv*)
2744     # This is for a MIPS running RISC/os 4.52C.
2745
2746     # This is needed for GDB, but needs to be in the top-level make because
2747     # if a library is compiled with the bsd headers and gets linked with the
2748     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2749     # a different size).
2750     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2751     # known except to select the sysv environment.  Could we use /proc instead?
2752     # These "sysv environments" and "bsd environments" often end up being a pain.
2753     #
2754     # This is not part of CFLAGS because perhaps not all C compilers have this
2755     # option.
2756     tentative_cc="cc -systype sysv"
2757     ;;
2758   i370-ibm-opened*)
2759     tentative_cc="c89"
2760     ;;
2761   i[3456789]86-*-sysv5*)
2762     host_makefile_frag="config/mh-sysv5"
2763     ;;
2764   i[3456789]86-*-dgux*)
2765     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2766     host_makefile_frag="config/mh-dgux386"
2767     ;;
2768   i[3456789]86-ncr-sysv4.3*)
2769     # The MetaWare compiler will generate a copyright message unless you
2770     # turn it off by adding the -Hnocopyr flag.
2771     tentative_cc="cc -Hnocopyr"
2772     ;;
2773   i[3456789]86-ncr-sysv4*)
2774     # for an NCR 3000 (i486/SVR4) system.
2775     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2776     # This compiler not only emits obnoxious copyright messages every time
2777     # you run it, but it chokes and dies on a whole bunch of GNU source
2778     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2779     tentative_cc="/usr/ccs/ATT/cc"
2780     host_makefile_frag="config/mh-ncr3000"
2781     ;;
2782   i[3456789]86-*-sco3.2v5*)
2783     ;;
2784   i[3456789]86-*-sco*)
2785     # The native C compiler botches some simple uses of const.  Unfortunately,
2786     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2787     tentative_cc="cc -Dconst="
2788     host_makefile_frag="config/mh-sco"
2789     ;;
2790   i[3456789]86-*-udk*)
2791     host_makefile_frag="config/mh-sysv5"
2792     ;;
2793   i[3456789]86-*-solaris2*)
2794     host_makefile_frag="config/mh-sysv4"
2795     ;;
2796   i[3456789]86-*-msdosdjgpp*)
2797     host_makefile_frag="config/mh-djgpp"
2798     ;;
2799   *-cygwin*)
2800
2801 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2802 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2803 echo a >cygwin-cat-check
2804 if test `cat cygwin-cat-check` == a ; then
2805   rm cygwin-cat-check
2806   echo "$as_me:$LINENO: result: yes" >&5
2807 echo "${ECHO_T}yes" >&6
2808 else
2809   rm cygwin-cat-check
2810   echo "$as_me:$LINENO: result: no" >&5
2811 echo "${ECHO_T}no" >&6
2812   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2813   Please either mount the build directory in binary mode or run the following
2814   commands before running any configure script:
2815 set -o igncr
2816 export SHELLOPTS
2817   " >&5
2818 echo "$as_me: error: The cat command does not ignore carriage return characters.
2819   Please either mount the build directory in binary mode or run the following
2820   commands before running any configure script:
2821 set -o igncr
2822 export SHELLOPTS
2823   " >&2;}
2824    { (exit 1); exit 1; }; }
2825 fi
2826
2827     host_makefile_frag="config/mh-cygwin"
2828     ;;
2829   *-mingw*)
2830     host_makefile_frag="config/mh-mingw"
2831     ;;
2832   *-interix*)
2833     host_makefile_frag="config/mh-interix"
2834     ;;
2835   vax-*-ultrix2*)
2836     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2837     tentative_cc=gcc
2838     ;;
2839   *-*-solaris2*)
2840     host_makefile_frag="config/mh-solaris"
2841     ;;
2842   m68k-sun-sunos*)
2843     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2844     # without overflowing the jump tables (-J says to use a 32 bit table)
2845     tentative_cc="cc -J"
2846     ;;
2847   hppa*-hp-hpux10*)
2848     tentative_cc="cc -Wp,-H256000"
2849     host_makefile_frag="config/mh-pa-hpux10"
2850     ;;
2851   hppa*-hp-hpux* | hppa*-*-hiux*)
2852     tentative_cc="cc -Wp,-H256000"
2853     host_makefile_frag="config/mh-pa"
2854     ;;
2855   hppa*-*)
2856     host_makefile_frag="config/mh-pa"
2857     ;;
2858   *-hp-hpux* | *-*-hiux*)
2859     tentative_cc="cc -Wp,-H256000"
2860     ;;
2861   rs6000-*-lynxos*)
2862     # /bin/cc is less than useful for our purposes.  Always use GCC
2863     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2864     host_makefile_frag="config/mh-lynxrs6k"
2865     ;;
2866   powerpc-*-darwin*)
2867     host_makefile_frag="config/mh-ppc-darwin"
2868     ;;
2869   powerpc-*-aix*)
2870     host_makefile_frag="config/mh-ppc-aix"
2871     ;;
2872   rs6000-*-aix*)
2873     host_makefile_frag="config/mh-ppc-aix"
2874     ;;
2875   *-*-lynxos*)
2876     # /bin/cc is less than useful for our purposes.  Always use GCC
2877     tentative_cc="/bin/gcc"
2878     ;;
2879   *-*-sysv4*)
2880     host_makefile_frag="config/mh-sysv4"
2881     ;;
2882   # This is placed last to prevent interfering with the cases above.
2883   i[3456789]86-*-*)
2884     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2885     host_makefile_frag="config/mh-x86omitfp"
2886     ;;
2887 esac
2888 fi
2889
2890 # If we aren't going to be using gcc, see if we can extract a definition
2891 # of CC from the fragment.
2892 # Actually, use the 'pre-extracted' version above.
2893 if test -z "${CC}" && test "${build}" = "${host}" ; then
2894   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2895   found=
2896   for dir in $PATH; do
2897     test -z "$dir" && dir=.
2898     if test -f $dir/gcc; then
2899       found=yes
2900       break
2901     fi
2902   done
2903   IFS="$save_ifs"
2904   if test -z "${found}" && test -n "${tentative_cc}" ; then
2905     CC=$tentative_cc
2906   fi
2907 fi
2908
2909 if test "${build}" != "${host}" ; then
2910   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2911   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2912   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2913   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2914   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2915   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2916   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2917   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2918   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2919   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2920   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2921   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2922 else
2923   AR_FOR_BUILD="\$(AR)"
2924   AS_FOR_BUILD="\$(AS)"
2925   CC_FOR_BUILD="\$(CC)"
2926   CXX_FOR_BUILD="\$(CXX)"
2927   GCJ_FOR_BUILD="\$(GCJ)"
2928   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2929   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2930   LD_FOR_BUILD="\$(LD)"
2931   NM_FOR_BUILD="\$(NM)"
2932   RANLIB_FOR_BUILD="\$(RANLIB)"
2933   WINDRES_FOR_BUILD="\$(WINDRES)"
2934   WINDMC_FOR_BUILD="\$(WINDMC)"
2935 fi
2936
2937 ac_ext=c
2938 ac_cpp='$CPP $CPPFLAGS'
2939 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2940 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2941 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2942 if test -n "$ac_tool_prefix"; then
2943   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2944 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2945 echo "$as_me:$LINENO: checking for $ac_word" >&5
2946 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2947 if test "${ac_cv_prog_CC+set}" = set; then
2948   echo $ECHO_N "(cached) $ECHO_C" >&6
2949 else
2950   if test -n "$CC"; then
2951   ac_cv_prog_CC="$CC" # Let the user override the test.
2952 else
2953 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2954 for as_dir in $PATH
2955 do
2956   IFS=$as_save_IFS
2957   test -z "$as_dir" && as_dir=.
2958   for ac_exec_ext in '' $ac_executable_extensions; do
2959   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2960     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2961     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2962     break 2
2963   fi
2964 done
2965 done
2966
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 "$ac_cv_prog_CC"; then
2980   ac_ct_CC=$CC
2981   # Extract the first word of "gcc", so it can be a program name with args.
2982 set dummy gcc; ac_word=$2
2983 echo "$as_me:$LINENO: checking for $ac_word" >&5
2984 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2985 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2986   echo $ECHO_N "(cached) $ECHO_C" >&6
2987 else
2988   if test -n "$ac_ct_CC"; then
2989   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2990 else
2991 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2992 for as_dir in $PATH
2993 do
2994   IFS=$as_save_IFS
2995   test -z "$as_dir" && as_dir=.
2996   for ac_exec_ext in '' $ac_executable_extensions; do
2997   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2998     ac_cv_prog_ac_ct_CC="gcc"
2999     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3000     break 2
3001   fi
3002 done
3003 done
3004
3005 fi
3006 fi
3007 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3008 if test -n "$ac_ct_CC"; then
3009   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3010 echo "${ECHO_T}$ac_ct_CC" >&6
3011 else
3012   echo "$as_me:$LINENO: result: no" >&5
3013 echo "${ECHO_T}no" >&6
3014 fi
3015
3016   CC=$ac_ct_CC
3017 else
3018   CC="$ac_cv_prog_CC"
3019 fi
3020
3021 if test -z "$CC"; then
3022   if test -n "$ac_tool_prefix"; then
3023   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3024 set dummy ${ac_tool_prefix}cc; ac_word=$2
3025 echo "$as_me:$LINENO: checking for $ac_word" >&5
3026 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3027 if test "${ac_cv_prog_CC+set}" = set; then
3028   echo $ECHO_N "(cached) $ECHO_C" >&6
3029 else
3030   if test -n "$CC"; then
3031   ac_cv_prog_CC="$CC" # Let the user override the test.
3032 else
3033 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3034 for as_dir in $PATH
3035 do
3036   IFS=$as_save_IFS
3037   test -z "$as_dir" && as_dir=.
3038   for ac_exec_ext in '' $ac_executable_extensions; do
3039   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3040     ac_cv_prog_CC="${ac_tool_prefix}cc"
3041     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3042     break 2
3043   fi
3044 done
3045 done
3046
3047 fi
3048 fi
3049 CC=$ac_cv_prog_CC
3050 if test -n "$CC"; then
3051   echo "$as_me:$LINENO: result: $CC" >&5
3052 echo "${ECHO_T}$CC" >&6
3053 else
3054   echo "$as_me:$LINENO: result: no" >&5
3055 echo "${ECHO_T}no" >&6
3056 fi
3057
3058 fi
3059 if test -z "$ac_cv_prog_CC"; then
3060   ac_ct_CC=$CC
3061   # Extract the first word of "cc", so it can be a program name with args.
3062 set dummy cc; ac_word=$2
3063 echo "$as_me:$LINENO: checking for $ac_word" >&5
3064 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3065 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3066   echo $ECHO_N "(cached) $ECHO_C" >&6
3067 else
3068   if test -n "$ac_ct_CC"; then
3069   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3070 else
3071 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3072 for as_dir in $PATH
3073 do
3074   IFS=$as_save_IFS
3075   test -z "$as_dir" && as_dir=.
3076   for ac_exec_ext in '' $ac_executable_extensions; do
3077   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3078     ac_cv_prog_ac_ct_CC="cc"
3079     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3080     break 2
3081   fi
3082 done
3083 done
3084
3085 fi
3086 fi
3087 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3088 if test -n "$ac_ct_CC"; then
3089   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3090 echo "${ECHO_T}$ac_ct_CC" >&6
3091 else
3092   echo "$as_me:$LINENO: result: no" >&5
3093 echo "${ECHO_T}no" >&6
3094 fi
3095
3096   CC=$ac_ct_CC
3097 else
3098   CC="$ac_cv_prog_CC"
3099 fi
3100
3101 fi
3102 if test -z "$CC"; then
3103   # Extract the first word of "cc", so it can be a program name with args.
3104 set dummy cc; ac_word=$2
3105 echo "$as_me:$LINENO: checking for $ac_word" >&5
3106 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3107 if test "${ac_cv_prog_CC+set}" = set; then
3108   echo $ECHO_N "(cached) $ECHO_C" >&6
3109 else
3110   if test -n "$CC"; then
3111   ac_cv_prog_CC="$CC" # Let the user override the test.
3112 else
3113   ac_prog_rejected=no
3114 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3115 for as_dir in $PATH
3116 do
3117   IFS=$as_save_IFS
3118   test -z "$as_dir" && as_dir=.
3119   for ac_exec_ext in '' $ac_executable_extensions; do
3120   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3121     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3122        ac_prog_rejected=yes
3123        continue
3124      fi
3125     ac_cv_prog_CC="cc"
3126     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3127     break 2
3128   fi
3129 done
3130 done
3131
3132 if test $ac_prog_rejected = yes; then
3133   # We found a bogon in the path, so make sure we never use it.
3134   set dummy $ac_cv_prog_CC
3135   shift
3136   if test $# != 0; then
3137     # We chose a different compiler from the bogus one.
3138     # However, it has the same basename, so the bogon will be chosen
3139     # first if we set CC to just the basename; use the full file name.
3140     shift
3141     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3142   fi
3143 fi
3144 fi
3145 fi
3146 CC=$ac_cv_prog_CC
3147 if test -n "$CC"; then
3148   echo "$as_me:$LINENO: result: $CC" >&5
3149 echo "${ECHO_T}$CC" >&6
3150 else
3151   echo "$as_me:$LINENO: result: no" >&5
3152 echo "${ECHO_T}no" >&6
3153 fi
3154
3155 fi
3156 if test -z "$CC"; then
3157   if test -n "$ac_tool_prefix"; then
3158   for ac_prog in cl
3159   do
3160     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3161 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3162 echo "$as_me:$LINENO: checking for $ac_word" >&5
3163 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3164 if test "${ac_cv_prog_CC+set}" = set; then
3165   echo $ECHO_N "(cached) $ECHO_C" >&6
3166 else
3167   if test -n "$CC"; then
3168   ac_cv_prog_CC="$CC" # Let the user override the test.
3169 else
3170 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3171 for as_dir in $PATH
3172 do
3173   IFS=$as_save_IFS
3174   test -z "$as_dir" && as_dir=.
3175   for ac_exec_ext in '' $ac_executable_extensions; do
3176   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3177     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3178     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3179     break 2
3180   fi
3181 done
3182 done
3183
3184 fi
3185 fi
3186 CC=$ac_cv_prog_CC
3187 if test -n "$CC"; then
3188   echo "$as_me:$LINENO: result: $CC" >&5
3189 echo "${ECHO_T}$CC" >&6
3190 else
3191   echo "$as_me:$LINENO: result: no" >&5
3192 echo "${ECHO_T}no" >&6
3193 fi
3194
3195     test -n "$CC" && break
3196   done
3197 fi
3198 if test -z "$CC"; then
3199   ac_ct_CC=$CC
3200   for ac_prog in cl
3201 do
3202   # Extract the first word of "$ac_prog", so it can be a program name with args.
3203 set dummy $ac_prog; ac_word=$2
3204 echo "$as_me:$LINENO: checking for $ac_word" >&5
3205 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3206 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3207   echo $ECHO_N "(cached) $ECHO_C" >&6
3208 else
3209   if test -n "$ac_ct_CC"; then
3210   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3211 else
3212 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3213 for as_dir in $PATH
3214 do
3215   IFS=$as_save_IFS
3216   test -z "$as_dir" && as_dir=.
3217   for ac_exec_ext in '' $ac_executable_extensions; do
3218   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3219     ac_cv_prog_ac_ct_CC="$ac_prog"
3220     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3221     break 2
3222   fi
3223 done
3224 done
3225
3226 fi
3227 fi
3228 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3229 if test -n "$ac_ct_CC"; then
3230   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3231 echo "${ECHO_T}$ac_ct_CC" >&6
3232 else
3233   echo "$as_me:$LINENO: result: no" >&5
3234 echo "${ECHO_T}no" >&6
3235 fi
3236
3237   test -n "$ac_ct_CC" && break
3238 done
3239
3240   CC=$ac_ct_CC
3241 fi
3242
3243 fi
3244
3245
3246 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3247 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3248 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3249 See \`config.log' for more details." >&5
3250 echo "$as_me: error: no acceptable C compiler found in \$PATH
3251 See \`config.log' for more details." >&2;}
3252    { (exit 1); exit 1; }; }; }
3253
3254 # Provide some information about the compiler.
3255 echo "$as_me:$LINENO:" \
3256      "checking for C compiler version" >&5
3257 ac_compiler=`set X $ac_compile; echo $2`
3258 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3259   (eval $ac_compiler --version </dev/null >&5) 2>&5
3260   ac_status=$?
3261   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3262   (exit $ac_status); }
3263 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3264   (eval $ac_compiler -v </dev/null >&5) 2>&5
3265   ac_status=$?
3266   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3267   (exit $ac_status); }
3268 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3269   (eval $ac_compiler -V </dev/null >&5) 2>&5
3270   ac_status=$?
3271   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3272   (exit $ac_status); }
3273
3274 cat >conftest.$ac_ext <<_ACEOF
3275 /* confdefs.h.  */
3276 _ACEOF
3277 cat confdefs.h >>conftest.$ac_ext
3278 cat >>conftest.$ac_ext <<_ACEOF
3279 /* end confdefs.h.  */
3280
3281 int
3282 main ()
3283 {
3284
3285   ;
3286   return 0;
3287 }
3288 _ACEOF
3289 ac_clean_files_save=$ac_clean_files
3290 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3291 # Try to create an executable without -o first, disregard a.out.
3292 # It will help us diagnose broken compilers, and finding out an intuition
3293 # of exeext.
3294 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3295 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3296 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3297 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3298   (eval $ac_link_default) 2>&5
3299   ac_status=$?
3300   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3301   (exit $ac_status); }; then
3302   # Find the output, starting from the most likely.  This scheme is
3303 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3304 # resort.
3305
3306 # Be careful to initialize this variable, since it used to be cached.
3307 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3308 ac_cv_exeext=
3309 # b.out is created by i960 compilers.
3310 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3311 do
3312   test -f "$ac_file" || continue
3313   case $ac_file in
3314     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3315         ;;
3316     conftest.$ac_ext )
3317         # This is the source file.
3318         ;;
3319     [ab].out )
3320         # We found the default executable, but exeext='' is most
3321         # certainly right.
3322         break;;
3323     *.* )
3324         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3325         # FIXME: I believe we export ac_cv_exeext for Libtool,
3326         # but it would be cool to find out if it's true.  Does anybody
3327         # maintain Libtool? --akim.
3328         export ac_cv_exeext
3329         break;;
3330     * )
3331         break;;
3332   esac
3333 done
3334 else
3335   echo "$as_me: failed program was:" >&5
3336 sed 's/^/| /' conftest.$ac_ext >&5
3337
3338 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3339 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3340 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3341 See \`config.log' for more details." >&5
3342 echo "$as_me: error: C compiler cannot create executables
3343 See \`config.log' for more details." >&2;}
3344    { (exit 77); exit 77; }; }; }
3345 fi
3346
3347 ac_exeext=$ac_cv_exeext
3348 echo "$as_me:$LINENO: result: $ac_file" >&5
3349 echo "${ECHO_T}$ac_file" >&6
3350
3351 # Check the compiler produces executables we can run.  If not, either
3352 # the compiler is broken, or we cross compile.
3353 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3354 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3355 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3356 # If not cross compiling, check that we can run a simple program.
3357 if test "$cross_compiling" != yes; then
3358   if { ac_try='./$ac_file'
3359   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3360   (eval $ac_try) 2>&5
3361   ac_status=$?
3362   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3363   (exit $ac_status); }; }; then
3364     cross_compiling=no
3365   else
3366     if test "$cross_compiling" = maybe; then
3367         cross_compiling=yes
3368     else
3369         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3370 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3371 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3372 If you meant to cross compile, use \`--host'.
3373 See \`config.log' for more details." >&5
3374 echo "$as_me: error: cannot run C compiled programs.
3375 If you meant to cross compile, use \`--host'.
3376 See \`config.log' for more details." >&2;}
3377    { (exit 1); exit 1; }; }; }
3378     fi
3379   fi
3380 fi
3381 echo "$as_me:$LINENO: result: yes" >&5
3382 echo "${ECHO_T}yes" >&6
3383
3384 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3385 ac_clean_files=$ac_clean_files_save
3386 # Check the compiler produces executables we can run.  If not, either
3387 # the compiler is broken, or we cross compile.
3388 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3389 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3390 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3391 echo "${ECHO_T}$cross_compiling" >&6
3392
3393 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3394 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3395 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3396   (eval $ac_link) 2>&5
3397   ac_status=$?
3398   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3399   (exit $ac_status); }; then
3400   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3401 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3402 # work properly (i.e., refer to `conftest.exe'), while it won't with
3403 # `rm'.
3404 for ac_file in conftest.exe conftest conftest.*; do
3405   test -f "$ac_file" || continue
3406   case $ac_file in
3407     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3408     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3409           export ac_cv_exeext
3410           break;;
3411     * ) break;;
3412   esac
3413 done
3414 else
3415   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3416 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3417 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3418 See \`config.log' for more details." >&5
3419 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3420 See \`config.log' for more details." >&2;}
3421    { (exit 1); exit 1; }; }; }
3422 fi
3423
3424 rm -f conftest$ac_cv_exeext
3425 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3426 echo "${ECHO_T}$ac_cv_exeext" >&6
3427
3428 rm -f conftest.$ac_ext
3429 EXEEXT=$ac_cv_exeext
3430 ac_exeext=$EXEEXT
3431 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3432 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3433 if test "${ac_cv_objext+set}" = set; then
3434   echo $ECHO_N "(cached) $ECHO_C" >&6
3435 else
3436   cat >conftest.$ac_ext <<_ACEOF
3437 /* confdefs.h.  */
3438 _ACEOF
3439 cat confdefs.h >>conftest.$ac_ext
3440 cat >>conftest.$ac_ext <<_ACEOF
3441 /* end confdefs.h.  */
3442
3443 int
3444 main ()
3445 {
3446
3447   ;
3448   return 0;
3449 }
3450 _ACEOF
3451 rm -f conftest.o conftest.obj
3452 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3453   (eval $ac_compile) 2>&5
3454   ac_status=$?
3455   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3456   (exit $ac_status); }; then
3457   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3458   case $ac_file in
3459     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3460     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3461        break;;
3462   esac
3463 done
3464 else
3465   echo "$as_me: failed program was:" >&5
3466 sed 's/^/| /' conftest.$ac_ext >&5
3467
3468 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3469 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3470 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3471 See \`config.log' for more details." >&5
3472 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3473 See \`config.log' for more details." >&2;}
3474    { (exit 1); exit 1; }; }; }
3475 fi
3476
3477 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3478 fi
3479 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3480 echo "${ECHO_T}$ac_cv_objext" >&6
3481 OBJEXT=$ac_cv_objext
3482 ac_objext=$OBJEXT
3483 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3484 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3485 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3486   echo $ECHO_N "(cached) $ECHO_C" >&6
3487 else
3488   cat >conftest.$ac_ext <<_ACEOF
3489 /* confdefs.h.  */
3490 _ACEOF
3491 cat confdefs.h >>conftest.$ac_ext
3492 cat >>conftest.$ac_ext <<_ACEOF
3493 /* end confdefs.h.  */
3494
3495 int
3496 main ()
3497 {
3498 #ifndef __GNUC__
3499        choke me
3500 #endif
3501
3502   ;
3503   return 0;
3504 }
3505 _ACEOF
3506 rm -f conftest.$ac_objext
3507 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3508   (eval $ac_compile) 2>conftest.er1
3509   ac_status=$?
3510   grep -v '^ *+' conftest.er1 >conftest.err
3511   rm -f conftest.er1
3512   cat conftest.err >&5
3513   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3514   (exit $ac_status); } &&
3515          { ac_try='test -z "$ac_c_werror_flag"
3516                          || test ! -s conftest.err'
3517   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3518   (eval $ac_try) 2>&5
3519   ac_status=$?
3520   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3521   (exit $ac_status); }; } &&
3522          { ac_try='test -s conftest.$ac_objext'
3523   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3524   (eval $ac_try) 2>&5
3525   ac_status=$?
3526   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3527   (exit $ac_status); }; }; then
3528   ac_compiler_gnu=yes
3529 else
3530   echo "$as_me: failed program was:" >&5
3531 sed 's/^/| /' conftest.$ac_ext >&5
3532
3533 ac_compiler_gnu=no
3534 fi
3535 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3536 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3537
3538 fi
3539 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3540 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3541 GCC=`test $ac_compiler_gnu = yes && echo yes`
3542 ac_test_CFLAGS=${CFLAGS+set}
3543 ac_save_CFLAGS=$CFLAGS
3544 CFLAGS="-g"
3545 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3546 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3547 if test "${ac_cv_prog_cc_g+set}" = set; then
3548   echo $ECHO_N "(cached) $ECHO_C" >&6
3549 else
3550   cat >conftest.$ac_ext <<_ACEOF
3551 /* confdefs.h.  */
3552 _ACEOF
3553 cat confdefs.h >>conftest.$ac_ext
3554 cat >>conftest.$ac_ext <<_ACEOF
3555 /* end confdefs.h.  */
3556
3557 int
3558 main ()
3559 {
3560
3561   ;
3562   return 0;
3563 }
3564 _ACEOF
3565 rm -f conftest.$ac_objext
3566 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3567   (eval $ac_compile) 2>conftest.er1
3568   ac_status=$?
3569   grep -v '^ *+' conftest.er1 >conftest.err
3570   rm -f conftest.er1
3571   cat conftest.err >&5
3572   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3573   (exit $ac_status); } &&
3574          { ac_try='test -z "$ac_c_werror_flag"
3575                          || test ! -s conftest.err'
3576   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3577   (eval $ac_try) 2>&5
3578   ac_status=$?
3579   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3580   (exit $ac_status); }; } &&
3581          { ac_try='test -s conftest.$ac_objext'
3582   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3583   (eval $ac_try) 2>&5
3584   ac_status=$?
3585   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3586   (exit $ac_status); }; }; then
3587   ac_cv_prog_cc_g=yes
3588 else
3589   echo "$as_me: failed program was:" >&5
3590 sed 's/^/| /' conftest.$ac_ext >&5
3591
3592 ac_cv_prog_cc_g=no
3593 fi
3594 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3595 fi
3596 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3597 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3598 if test "$ac_test_CFLAGS" = set; then
3599   CFLAGS=$ac_save_CFLAGS
3600 elif test $ac_cv_prog_cc_g = yes; then
3601   if test "$GCC" = yes; then
3602     CFLAGS="-g -O2"
3603   else
3604     CFLAGS="-g"
3605   fi
3606 else
3607   if test "$GCC" = yes; then
3608     CFLAGS="-O2"
3609   else
3610     CFLAGS=
3611   fi
3612 fi
3613 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3614 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3615 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3616   echo $ECHO_N "(cached) $ECHO_C" >&6
3617 else
3618   ac_cv_prog_cc_stdc=no
3619 ac_save_CC=$CC
3620 cat >conftest.$ac_ext <<_ACEOF
3621 /* confdefs.h.  */
3622 _ACEOF
3623 cat confdefs.h >>conftest.$ac_ext
3624 cat >>conftest.$ac_ext <<_ACEOF
3625 /* end confdefs.h.  */
3626 #include <stdarg.h>
3627 #include <stdio.h>
3628 #include <sys/types.h>
3629 #include <sys/stat.h>
3630 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3631 struct buf { int x; };
3632 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3633 static char *e (p, i)
3634      char **p;
3635      int i;
3636 {
3637   return p[i];
3638 }
3639 static char *f (char * (*g) (char **, int), char **p, ...)
3640 {
3641   char *s;
3642   va_list v;
3643   va_start (v,p);
3644   s = g (p, va_arg (v,int));
3645   va_end (v);
3646   return s;
3647 }
3648
3649 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3650    function prototypes and stuff, but not '\xHH' hex character constants.
3651    These don't provoke an error unfortunately, instead are silently treated
3652    as 'x'.  The following induces an error, until -std1 is added to get
3653    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3654    array size at least.  It's necessary to write '\x00'==0 to get something
3655    that's true only with -std1.  */
3656 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3657
3658 int test (int i, double x);
3659 struct s1 {int (*f) (int a);};
3660 struct s2 {int (*f) (double a);};
3661 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3662 int argc;
3663 char **argv;
3664 int
3665 main ()
3666 {
3667 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3668   ;
3669   return 0;
3670 }
3671 _ACEOF
3672 # Don't try gcc -ansi; that turns off useful extensions and
3673 # breaks some systems' header files.
3674 # AIX                   -qlanglvl=ansi
3675 # Ultrix and OSF/1      -std1
3676 # HP-UX 10.20 and later -Ae
3677 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3678 # SVR4                  -Xc -D__EXTENSIONS__
3679 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3680 do
3681   CC="$ac_save_CC $ac_arg"
3682   rm -f conftest.$ac_objext
3683 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3684   (eval $ac_compile) 2>conftest.er1
3685   ac_status=$?
3686   grep -v '^ *+' conftest.er1 >conftest.err
3687   rm -f conftest.er1
3688   cat conftest.err >&5
3689   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3690   (exit $ac_status); } &&
3691          { ac_try='test -z "$ac_c_werror_flag"
3692                          || test ! -s conftest.err'
3693   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3694   (eval $ac_try) 2>&5
3695   ac_status=$?
3696   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3697   (exit $ac_status); }; } &&
3698          { ac_try='test -s conftest.$ac_objext'
3699   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3700   (eval $ac_try) 2>&5
3701   ac_status=$?
3702   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3703   (exit $ac_status); }; }; then
3704   ac_cv_prog_cc_stdc=$ac_arg
3705 break
3706 else
3707   echo "$as_me: failed program was:" >&5
3708 sed 's/^/| /' conftest.$ac_ext >&5
3709
3710 fi
3711 rm -f conftest.err conftest.$ac_objext
3712 done
3713 rm -f conftest.$ac_ext conftest.$ac_objext
3714 CC=$ac_save_CC
3715
3716 fi
3717
3718 case "x$ac_cv_prog_cc_stdc" in
3719   x|xno)
3720     echo "$as_me:$LINENO: result: none needed" >&5
3721 echo "${ECHO_T}none needed" >&6 ;;
3722   *)
3723     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3724 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3725     CC="$CC $ac_cv_prog_cc_stdc" ;;
3726 esac
3727
3728 # Some people use a C++ compiler to compile C.  Since we use `exit',
3729 # in C++ we need to declare it.  In case someone uses the same compiler
3730 # for both compiling C and C++ we need to have the C++ compiler decide
3731 # the declaration of exit, since it's the most demanding environment.
3732 cat >conftest.$ac_ext <<_ACEOF
3733 #ifndef __cplusplus
3734   choke me
3735 #endif
3736 _ACEOF
3737 rm -f conftest.$ac_objext
3738 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3739   (eval $ac_compile) 2>conftest.er1
3740   ac_status=$?
3741   grep -v '^ *+' conftest.er1 >conftest.err
3742   rm -f conftest.er1
3743   cat conftest.err >&5
3744   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3745   (exit $ac_status); } &&
3746          { ac_try='test -z "$ac_c_werror_flag"
3747                          || test ! -s conftest.err'
3748   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3749   (eval $ac_try) 2>&5
3750   ac_status=$?
3751   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3752   (exit $ac_status); }; } &&
3753          { ac_try='test -s conftest.$ac_objext'
3754   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3755   (eval $ac_try) 2>&5
3756   ac_status=$?
3757   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3758   (exit $ac_status); }; }; then
3759   for ac_declaration in \
3760    '' \
3761    'extern "C" void std::exit (int) throw (); using std::exit;' \
3762    'extern "C" void std::exit (int); using std::exit;' \
3763    'extern "C" void exit (int) throw ();' \
3764    'extern "C" void exit (int);' \
3765    'void exit (int);'
3766 do
3767   cat >conftest.$ac_ext <<_ACEOF
3768 /* confdefs.h.  */
3769 _ACEOF
3770 cat confdefs.h >>conftest.$ac_ext
3771 cat >>conftest.$ac_ext <<_ACEOF
3772 /* end confdefs.h.  */
3773 $ac_declaration
3774 #include <stdlib.h>
3775 int
3776 main ()
3777 {
3778 exit (42);
3779   ;
3780   return 0;
3781 }
3782 _ACEOF
3783 rm -f conftest.$ac_objext
3784 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3785   (eval $ac_compile) 2>conftest.er1
3786   ac_status=$?
3787   grep -v '^ *+' conftest.er1 >conftest.err
3788   rm -f conftest.er1
3789   cat conftest.err >&5
3790   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3791   (exit $ac_status); } &&
3792          { ac_try='test -z "$ac_c_werror_flag"
3793                          || test ! -s conftest.err'
3794   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3795   (eval $ac_try) 2>&5
3796   ac_status=$?
3797   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3798   (exit $ac_status); }; } &&
3799          { ac_try='test -s conftest.$ac_objext'
3800   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3801   (eval $ac_try) 2>&5
3802   ac_status=$?
3803   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3804   (exit $ac_status); }; }; then
3805   :
3806 else
3807   echo "$as_me: failed program was:" >&5
3808 sed 's/^/| /' conftest.$ac_ext >&5
3809
3810 continue
3811 fi
3812 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3813   cat >conftest.$ac_ext <<_ACEOF
3814 /* confdefs.h.  */
3815 _ACEOF
3816 cat confdefs.h >>conftest.$ac_ext
3817 cat >>conftest.$ac_ext <<_ACEOF
3818 /* end confdefs.h.  */
3819 $ac_declaration
3820 int
3821 main ()
3822 {
3823 exit (42);
3824   ;
3825   return 0;
3826 }
3827 _ACEOF
3828 rm -f conftest.$ac_objext
3829 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3830   (eval $ac_compile) 2>conftest.er1
3831   ac_status=$?
3832   grep -v '^ *+' conftest.er1 >conftest.err
3833   rm -f conftest.er1
3834   cat conftest.err >&5
3835   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3836   (exit $ac_status); } &&
3837          { ac_try='test -z "$ac_c_werror_flag"
3838                          || test ! -s conftest.err'
3839   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3840   (eval $ac_try) 2>&5
3841   ac_status=$?
3842   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3843   (exit $ac_status); }; } &&
3844          { ac_try='test -s conftest.$ac_objext'
3845   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3846   (eval $ac_try) 2>&5
3847   ac_status=$?
3848   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3849   (exit $ac_status); }; }; then
3850   break
3851 else
3852   echo "$as_me: failed program was:" >&5
3853 sed 's/^/| /' conftest.$ac_ext >&5
3854
3855 fi
3856 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3857 done
3858 rm -f conftest*
3859 if test -n "$ac_declaration"; then
3860   echo '#ifdef __cplusplus' >>confdefs.h
3861   echo $ac_declaration      >>confdefs.h
3862   echo '#endif'             >>confdefs.h
3863 fi
3864
3865 else
3866   echo "$as_me: failed program was:" >&5
3867 sed 's/^/| /' conftest.$ac_ext >&5
3868
3869 fi
3870 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3871 ac_ext=c
3872 ac_cpp='$CPP $CPPFLAGS'
3873 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3874 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3875 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3876
3877 ac_ext=cc
3878 ac_cpp='$CXXCPP $CPPFLAGS'
3879 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3880 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3881 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3882 if test -n "$ac_tool_prefix"; then
3883   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3884   do
3885     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3886 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3887 echo "$as_me:$LINENO: checking for $ac_word" >&5
3888 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3889 if test "${ac_cv_prog_CXX+set}" = set; then
3890   echo $ECHO_N "(cached) $ECHO_C" >&6
3891 else
3892   if test -n "$CXX"; then
3893   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3894 else
3895 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3896 for as_dir in $PATH
3897 do
3898   IFS=$as_save_IFS
3899   test -z "$as_dir" && as_dir=.
3900   for ac_exec_ext in '' $ac_executable_extensions; do
3901   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3902     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3903     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3904     break 2
3905   fi
3906 done
3907 done
3908
3909 fi
3910 fi
3911 CXX=$ac_cv_prog_CXX
3912 if test -n "$CXX"; then
3913   echo "$as_me:$LINENO: result: $CXX" >&5
3914 echo "${ECHO_T}$CXX" >&6
3915 else
3916   echo "$as_me:$LINENO: result: no" >&5
3917 echo "${ECHO_T}no" >&6
3918 fi
3919
3920     test -n "$CXX" && break
3921   done
3922 fi
3923 if test -z "$CXX"; then
3924   ac_ct_CXX=$CXX
3925   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3926 do
3927   # Extract the first word of "$ac_prog", so it can be a program name with args.
3928 set dummy $ac_prog; ac_word=$2
3929 echo "$as_me:$LINENO: checking for $ac_word" >&5
3930 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3931 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3932   echo $ECHO_N "(cached) $ECHO_C" >&6
3933 else
3934   if test -n "$ac_ct_CXX"; then
3935   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3936 else
3937 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3938 for as_dir in $PATH
3939 do
3940   IFS=$as_save_IFS
3941   test -z "$as_dir" && as_dir=.
3942   for ac_exec_ext in '' $ac_executable_extensions; do
3943   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3944     ac_cv_prog_ac_ct_CXX="$ac_prog"
3945     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3946     break 2
3947   fi
3948 done
3949 done
3950
3951 fi
3952 fi
3953 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3954 if test -n "$ac_ct_CXX"; then
3955   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3956 echo "${ECHO_T}$ac_ct_CXX" >&6
3957 else
3958   echo "$as_me:$LINENO: result: no" >&5
3959 echo "${ECHO_T}no" >&6
3960 fi
3961
3962   test -n "$ac_ct_CXX" && break
3963 done
3964 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3965
3966   CXX=$ac_ct_CXX
3967 fi
3968
3969
3970 # Provide some information about the compiler.
3971 echo "$as_me:$LINENO:" \
3972      "checking for C++ compiler version" >&5
3973 ac_compiler=`set X $ac_compile; echo $2`
3974 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3975   (eval $ac_compiler --version </dev/null >&5) 2>&5
3976   ac_status=$?
3977   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3978   (exit $ac_status); }
3979 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3980   (eval $ac_compiler -v </dev/null >&5) 2>&5
3981   ac_status=$?
3982   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3983   (exit $ac_status); }
3984 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3985   (eval $ac_compiler -V </dev/null >&5) 2>&5
3986   ac_status=$?
3987   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3988   (exit $ac_status); }
3989
3990 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3991 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3992 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3993   echo $ECHO_N "(cached) $ECHO_C" >&6
3994 else
3995   cat >conftest.$ac_ext <<_ACEOF
3996 /* confdefs.h.  */
3997 _ACEOF
3998 cat confdefs.h >>conftest.$ac_ext
3999 cat >>conftest.$ac_ext <<_ACEOF
4000 /* end confdefs.h.  */
4001
4002 int
4003 main ()
4004 {
4005 #ifndef __GNUC__
4006        choke me
4007 #endif
4008
4009   ;
4010   return 0;
4011 }
4012 _ACEOF
4013 rm -f conftest.$ac_objext
4014 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4015   (eval $ac_compile) 2>conftest.er1
4016   ac_status=$?
4017   grep -v '^ *+' conftest.er1 >conftest.err
4018   rm -f conftest.er1
4019   cat conftest.err >&5
4020   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4021   (exit $ac_status); } &&
4022          { ac_try='test -z "$ac_cxx_werror_flag"
4023                          || test ! -s conftest.err'
4024   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4025   (eval $ac_try) 2>&5
4026   ac_status=$?
4027   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4028   (exit $ac_status); }; } &&
4029          { ac_try='test -s conftest.$ac_objext'
4030   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4031   (eval $ac_try) 2>&5
4032   ac_status=$?
4033   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4034   (exit $ac_status); }; }; then
4035   ac_compiler_gnu=yes
4036 else
4037   echo "$as_me: failed program was:" >&5
4038 sed 's/^/| /' conftest.$ac_ext >&5
4039
4040 ac_compiler_gnu=no
4041 fi
4042 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4043 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4044
4045 fi
4046 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4047 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4048 GXX=`test $ac_compiler_gnu = yes && echo yes`
4049 ac_test_CXXFLAGS=${CXXFLAGS+set}
4050 ac_save_CXXFLAGS=$CXXFLAGS
4051 CXXFLAGS="-g"
4052 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4053 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4054 if test "${ac_cv_prog_cxx_g+set}" = set; then
4055   echo $ECHO_N "(cached) $ECHO_C" >&6
4056 else
4057   cat >conftest.$ac_ext <<_ACEOF
4058 /* confdefs.h.  */
4059 _ACEOF
4060 cat confdefs.h >>conftest.$ac_ext
4061 cat >>conftest.$ac_ext <<_ACEOF
4062 /* end confdefs.h.  */
4063
4064 int
4065 main ()
4066 {
4067
4068   ;
4069   return 0;
4070 }
4071 _ACEOF
4072 rm -f conftest.$ac_objext
4073 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4074   (eval $ac_compile) 2>conftest.er1
4075   ac_status=$?
4076   grep -v '^ *+' conftest.er1 >conftest.err
4077   rm -f conftest.er1
4078   cat conftest.err >&5
4079   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4080   (exit $ac_status); } &&
4081          { ac_try='test -z "$ac_cxx_werror_flag"
4082                          || test ! -s conftest.err'
4083   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4084   (eval $ac_try) 2>&5
4085   ac_status=$?
4086   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4087   (exit $ac_status); }; } &&
4088          { ac_try='test -s conftest.$ac_objext'
4089   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4090   (eval $ac_try) 2>&5
4091   ac_status=$?
4092   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4093   (exit $ac_status); }; }; then
4094   ac_cv_prog_cxx_g=yes
4095 else
4096   echo "$as_me: failed program was:" >&5
4097 sed 's/^/| /' conftest.$ac_ext >&5
4098
4099 ac_cv_prog_cxx_g=no
4100 fi
4101 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4102 fi
4103 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4104 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4105 if test "$ac_test_CXXFLAGS" = set; then
4106   CXXFLAGS=$ac_save_CXXFLAGS
4107 elif test $ac_cv_prog_cxx_g = yes; then
4108   if test "$GXX" = yes; then
4109     CXXFLAGS="-g -O2"
4110   else
4111     CXXFLAGS="-g"
4112   fi
4113 else
4114   if test "$GXX" = yes; then
4115     CXXFLAGS="-O2"
4116   else
4117     CXXFLAGS=
4118   fi
4119 fi
4120 for ac_declaration in \
4121    '' \
4122    'extern "C" void std::exit (int) throw (); using std::exit;' \
4123    'extern "C" void std::exit (int); using std::exit;' \
4124    'extern "C" void exit (int) throw ();' \
4125    'extern "C" void exit (int);' \
4126    'void exit (int);'
4127 do
4128   cat >conftest.$ac_ext <<_ACEOF
4129 /* confdefs.h.  */
4130 _ACEOF
4131 cat confdefs.h >>conftest.$ac_ext
4132 cat >>conftest.$ac_ext <<_ACEOF
4133 /* end confdefs.h.  */
4134 $ac_declaration
4135 #include <stdlib.h>
4136 int
4137 main ()
4138 {
4139 exit (42);
4140   ;
4141   return 0;
4142 }
4143 _ACEOF
4144 rm -f conftest.$ac_objext
4145 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4146   (eval $ac_compile) 2>conftest.er1
4147   ac_status=$?
4148   grep -v '^ *+' conftest.er1 >conftest.err
4149   rm -f conftest.er1
4150   cat conftest.err >&5
4151   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4152   (exit $ac_status); } &&
4153          { ac_try='test -z "$ac_cxx_werror_flag"
4154                          || test ! -s conftest.err'
4155   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4156   (eval $ac_try) 2>&5
4157   ac_status=$?
4158   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4159   (exit $ac_status); }; } &&
4160          { ac_try='test -s conftest.$ac_objext'
4161   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4162   (eval $ac_try) 2>&5
4163   ac_status=$?
4164   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4165   (exit $ac_status); }; }; then
4166   :
4167 else
4168   echo "$as_me: failed program was:" >&5
4169 sed 's/^/| /' conftest.$ac_ext >&5
4170
4171 continue
4172 fi
4173 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4174   cat >conftest.$ac_ext <<_ACEOF
4175 /* confdefs.h.  */
4176 _ACEOF
4177 cat confdefs.h >>conftest.$ac_ext
4178 cat >>conftest.$ac_ext <<_ACEOF
4179 /* end confdefs.h.  */
4180 $ac_declaration
4181 int
4182 main ()
4183 {
4184 exit (42);
4185   ;
4186   return 0;
4187 }
4188 _ACEOF
4189 rm -f conftest.$ac_objext
4190 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4191   (eval $ac_compile) 2>conftest.er1
4192   ac_status=$?
4193   grep -v '^ *+' conftest.er1 >conftest.err
4194   rm -f conftest.er1
4195   cat conftest.err >&5
4196   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4197   (exit $ac_status); } &&
4198          { ac_try='test -z "$ac_cxx_werror_flag"
4199                          || test ! -s conftest.err'
4200   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4201   (eval $ac_try) 2>&5
4202   ac_status=$?
4203   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4204   (exit $ac_status); }; } &&
4205          { ac_try='test -s conftest.$ac_objext'
4206   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4207   (eval $ac_try) 2>&5
4208   ac_status=$?
4209   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4210   (exit $ac_status); }; }; then
4211   break
4212 else
4213   echo "$as_me: failed program was:" >&5
4214 sed 's/^/| /' conftest.$ac_ext >&5
4215
4216 fi
4217 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4218 done
4219 rm -f conftest*
4220 if test -n "$ac_declaration"; then
4221   echo '#ifdef __cplusplus' >>confdefs.h
4222   echo $ac_declaration      >>confdefs.h
4223   echo '#endif'             >>confdefs.h
4224 fi
4225
4226 ac_ext=c
4227 ac_cpp='$CPP $CPPFLAGS'
4228 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4229 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4230 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4231
4232
4233 # We must set the default linker to the linker used by gcc for the correct
4234 # operation of libtool.  If LD is not defined and we are using gcc, try to
4235 # set the LD default to the ld used by gcc.
4236 if test -z "$LD"; then
4237   if test "$GCC" = yes; then
4238     case $build in
4239     *-*-mingw*)
4240       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4241     *)
4242       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4243     esac
4244     case $gcc_prog_ld in
4245     # Accept absolute paths.
4246     [\\/]* | [A-Za-z]:[\\/]*)
4247       LD="$gcc_prog_ld" ;;
4248     esac
4249   fi
4250 fi
4251
4252
4253
4254
4255 if test -n "$ac_tool_prefix"; then
4256   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4257 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4258 echo "$as_me:$LINENO: checking for $ac_word" >&5
4259 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4260 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4261   echo $ECHO_N "(cached) $ECHO_C" >&6
4262 else
4263   if test -n "$GNATBIND"; then
4264   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4265 else
4266 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4267 for as_dir in $PATH
4268 do
4269   IFS=$as_save_IFS
4270   test -z "$as_dir" && as_dir=.
4271   for ac_exec_ext in '' $ac_executable_extensions; do
4272   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4273     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4274     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4275     break 2
4276   fi
4277 done
4278 done
4279
4280 fi
4281 fi
4282 GNATBIND=$ac_cv_prog_GNATBIND
4283 if test -n "$GNATBIND"; then
4284   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4285 echo "${ECHO_T}$GNATBIND" >&6
4286 else
4287   echo "$as_me:$LINENO: result: no" >&5
4288 echo "${ECHO_T}no" >&6
4289 fi
4290
4291 fi
4292 if test -z "$ac_cv_prog_GNATBIND"; then
4293   ac_ct_GNATBIND=$GNATBIND
4294   # Extract the first word of "gnatbind", so it can be a program name with args.
4295 set dummy gnatbind; ac_word=$2
4296 echo "$as_me:$LINENO: checking for $ac_word" >&5
4297 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4298 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4299   echo $ECHO_N "(cached) $ECHO_C" >&6
4300 else
4301   if test -n "$ac_ct_GNATBIND"; then
4302   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4303 else
4304 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4305 for as_dir in $PATH
4306 do
4307   IFS=$as_save_IFS
4308   test -z "$as_dir" && as_dir=.
4309   for ac_exec_ext in '' $ac_executable_extensions; do
4310   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4311     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4312     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4313     break 2
4314   fi
4315 done
4316 done
4317
4318   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4319 fi
4320 fi
4321 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4322 if test -n "$ac_ct_GNATBIND"; then
4323   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4324 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4325 else
4326   echo "$as_me:$LINENO: result: no" >&5
4327 echo "${ECHO_T}no" >&6
4328 fi
4329
4330   GNATBIND=$ac_ct_GNATBIND
4331 else
4332   GNATBIND="$ac_cv_prog_GNATBIND"
4333 fi
4334
4335 if test -n "$ac_tool_prefix"; then
4336   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4337 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4338 echo "$as_me:$LINENO: checking for $ac_word" >&5
4339 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4340 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4341   echo $ECHO_N "(cached) $ECHO_C" >&6
4342 else
4343   if test -n "$GNATMAKE"; then
4344   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4345 else
4346 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4347 for as_dir in $PATH
4348 do
4349   IFS=$as_save_IFS
4350   test -z "$as_dir" && as_dir=.
4351   for ac_exec_ext in '' $ac_executable_extensions; do
4352   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4353     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4354     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4355     break 2
4356   fi
4357 done
4358 done
4359
4360 fi
4361 fi
4362 GNATMAKE=$ac_cv_prog_GNATMAKE
4363 if test -n "$GNATMAKE"; then
4364   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4365 echo "${ECHO_T}$GNATMAKE" >&6
4366 else
4367   echo "$as_me:$LINENO: result: no" >&5
4368 echo "${ECHO_T}no" >&6
4369 fi
4370
4371 fi
4372 if test -z "$ac_cv_prog_GNATMAKE"; then
4373   ac_ct_GNATMAKE=$GNATMAKE
4374   # Extract the first word of "gnatmake", so it can be a program name with args.
4375 set dummy gnatmake; ac_word=$2
4376 echo "$as_me:$LINENO: checking for $ac_word" >&5
4377 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4378 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4379   echo $ECHO_N "(cached) $ECHO_C" >&6
4380 else
4381   if test -n "$ac_ct_GNATMAKE"; then
4382   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4383 else
4384 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4385 for as_dir in $PATH
4386 do
4387   IFS=$as_save_IFS
4388   test -z "$as_dir" && as_dir=.
4389   for ac_exec_ext in '' $ac_executable_extensions; do
4390   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4391     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4392     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4393     break 2
4394   fi
4395 done
4396 done
4397
4398   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4399 fi
4400 fi
4401 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4402 if test -n "$ac_ct_GNATMAKE"; then
4403   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4404 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4405 else
4406   echo "$as_me:$LINENO: result: no" >&5
4407 echo "${ECHO_T}no" >&6
4408 fi
4409
4410   GNATMAKE=$ac_ct_GNATMAKE
4411 else
4412   GNATMAKE="$ac_cv_prog_GNATMAKE"
4413 fi
4414
4415 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4416 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4417 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4418   echo $ECHO_N "(cached) $ECHO_C" >&6
4419 else
4420   cat >conftest.adb <<EOF
4421 procedure conftest is begin null; end conftest;
4422 EOF
4423 acx_cv_cc_gcc_supports_ada=no
4424 # There is a bug in old released versions of GCC which causes the
4425 # driver to exit successfully when the appropriate language module
4426 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4427 # Therefore we must check for the error message as well as an
4428 # unsuccessful exit.
4429 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4430 # given a .adb file, but produce no object file.  So we must check
4431 # if an object file was really produced to guard against this.
4432 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4433 if test x"$errors" = x && test -f conftest.$ac_objext; then
4434   acx_cv_cc_gcc_supports_ada=yes
4435 fi
4436 rm -f conftest.*
4437 fi
4438 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4439 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4440
4441 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4442   have_gnat=yes
4443 else
4444   have_gnat=no
4445 fi
4446
4447 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4448 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4449 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4450   echo $ECHO_N "(cached) $ECHO_C" >&6
4451 else
4452    echo abfoo >t1
4453   echo cdfoo >t2
4454   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4455   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4456     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4457       :
4458     else
4459       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4460     fi
4461   fi
4462   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4463     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4464       :
4465     else
4466       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4467     fi
4468   fi
4469   rm t1 t2
4470
4471 fi
4472 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4473 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4474 do_compare="$gcc_cv_prog_cmp_skip"
4475
4476
4477
4478 # Check for GMP and MPFR
4479 gmplibs="-lmpfr -lgmp"
4480 gmpinc=
4481 have_gmp=no
4482
4483 # Specify a location for mpfr
4484 # check for this first so it ends up on the link line before gmp.
4485
4486 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4487 if test "${with_mpfr_dir+set}" = set; then
4488   withval="$with_mpfr_dir"
4489   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4490 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4491 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4492 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4493    { (exit 1); exit 1; }; }
4494 fi;
4495
4496
4497 # Check whether --with-mpfr or --without-mpfr was given.
4498 if test "${with_mpfr+set}" = set; then
4499   withval="$with_mpfr"
4500
4501 fi;
4502
4503 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4504 if test "${with_mpfr_include+set}" = set; then
4505   withval="$with_mpfr_include"
4506
4507 fi;
4508
4509 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4510 if test "${with_mpfr_lib+set}" = set; then
4511   withval="$with_mpfr_lib"
4512
4513 fi;
4514
4515 if test "x$with_mpfr" != x; then
4516   gmplibs="-L$with_mpfr/lib $gmplibs"
4517   gmpinc="-I$with_mpfr/include"
4518 fi
4519 if test "x$with_mpfr_include" != x; then
4520   gmpinc="-I$with_mpfr_include"
4521 fi
4522 if test "x$with_mpfr_lib" != x; then
4523   gmplibs="-L$with_mpfr_lib $gmplibs"
4524 fi
4525 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4526   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4527   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4528   # Do not test the mpfr version.  Assume that it is sufficient, since
4529   # it is in the source tree, and the library has not been built yet
4530   # but it would be included on the link line in the version check below
4531   # hence making the test fail.
4532   have_gmp=yes
4533 fi
4534
4535 # Specify a location for gmp
4536
4537 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4538 if test "${with_gmp_dir+set}" = set; then
4539   withval="$with_gmp_dir"
4540   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4541 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4542 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4543 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4544    { (exit 1); exit 1; }; }
4545 fi;
4546
4547
4548 # Check whether --with-gmp or --without-gmp was given.
4549 if test "${with_gmp+set}" = set; then
4550   withval="$with_gmp"
4551
4552 fi;
4553
4554 # Check whether --with-gmp_include or --without-gmp_include was given.
4555 if test "${with_gmp_include+set}" = set; then
4556   withval="$with_gmp_include"
4557
4558 fi;
4559
4560 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4561 if test "${with_gmp_lib+set}" = set; then
4562   withval="$with_gmp_lib"
4563
4564 fi;
4565
4566
4567 if test "x$with_gmp" != x; then
4568   gmplibs="-L$with_gmp/lib $gmplibs"
4569   gmpinc="-I$with_gmp/include $gmpinc"
4570 fi
4571 if test "x$with_gmp_include" != x; then
4572   gmpinc="-I$with_gmp_include $gmpinc"
4573 fi
4574 if test "x$with_gmp_lib" != x; then
4575   gmplibs="-L$with_gmp_lib $gmplibs"
4576 fi
4577 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4578   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4579   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4580   # Do not test the gmp version.  Assume that it is sufficient, since
4581   # it is in the source tree, and the library has not been built yet
4582   # but it would be included on the link line in the version check below
4583   # hence making the test fail.
4584   have_gmp=yes
4585 fi
4586
4587 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4588   have_gmp=yes
4589   saved_CFLAGS="$CFLAGS"
4590   CFLAGS="$CFLAGS $gmpinc"
4591   # Check GMP actually works
4592   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4593 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4594
4595 cat >conftest.$ac_ext <<_ACEOF
4596 /* confdefs.h.  */
4597 _ACEOF
4598 cat confdefs.h >>conftest.$ac_ext
4599 cat >>conftest.$ac_ext <<_ACEOF
4600 /* end confdefs.h.  */
4601 #include "gmp.h"
4602 int
4603 main ()
4604 {
4605
4606   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4607   choke me
4608   #endif
4609
4610   ;
4611   return 0;
4612 }
4613 _ACEOF
4614 rm -f conftest.$ac_objext
4615 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4616   (eval $ac_compile) 2>conftest.er1
4617   ac_status=$?
4618   grep -v '^ *+' conftest.er1 >conftest.err
4619   rm -f conftest.er1
4620   cat conftest.err >&5
4621   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4622   (exit $ac_status); } &&
4623          { ac_try='test -z "$ac_c_werror_flag"
4624                          || test ! -s conftest.err'
4625   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4626   (eval $ac_try) 2>&5
4627   ac_status=$?
4628   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4629   (exit $ac_status); }; } &&
4630          { ac_try='test -s conftest.$ac_objext'
4631   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4632   (eval $ac_try) 2>&5
4633   ac_status=$?
4634   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4635   (exit $ac_status); }; }; then
4636   echo "$as_me:$LINENO: result: yes" >&5
4637 echo "${ECHO_T}yes" >&6
4638 else
4639   echo "$as_me: failed program was:" >&5
4640 sed 's/^/| /' conftest.$ac_ext >&5
4641
4642 echo "$as_me:$LINENO: result: no" >&5
4643 echo "${ECHO_T}no" >&6; have_gmp=no
4644 fi
4645 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4646
4647   if test x"$have_gmp" = xyes; then
4648     saved_LIBS="$LIBS"
4649     LIBS="$LIBS $gmplibs"
4650         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4651 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4652     cat >conftest.$ac_ext <<_ACEOF
4653 /* confdefs.h.  */
4654 _ACEOF
4655 cat confdefs.h >>conftest.$ac_ext
4656 cat >>conftest.$ac_ext <<_ACEOF
4657 /* end confdefs.h.  */
4658 #include <gmp.h>
4659     #include <mpfr.h>
4660 int
4661 main ()
4662 {
4663
4664     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4665     choke me
4666     #endif
4667     mpfr_t n;
4668     mpfr_t x;
4669     int t;
4670     mpfr_init (n);
4671     mpfr_init (x);
4672     mpfr_atan2 (n, n, x, GMP_RNDN);
4673     mpfr_erfc (n, x, GMP_RNDN);
4674     mpfr_subnormalize (x, t, GMP_RNDN);
4675
4676   ;
4677   return 0;
4678 }
4679 _ACEOF
4680 rm -f conftest.$ac_objext conftest$ac_exeext
4681 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4682   (eval $ac_link) 2>conftest.er1
4683   ac_status=$?
4684   grep -v '^ *+' conftest.er1 >conftest.err
4685   rm -f conftest.er1
4686   cat conftest.err >&5
4687   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4688   (exit $ac_status); } &&
4689          { ac_try='test -z "$ac_c_werror_flag"
4690                          || test ! -s conftest.err'
4691   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4692   (eval $ac_try) 2>&5
4693   ac_status=$?
4694   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4695   (exit $ac_status); }; } &&
4696          { ac_try='test -s conftest$ac_exeext'
4697   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4698   (eval $ac_try) 2>&5
4699   ac_status=$?
4700   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4701   (exit $ac_status); }; }; then
4702   cat >conftest.$ac_ext <<_ACEOF
4703 /* confdefs.h.  */
4704 _ACEOF
4705 cat confdefs.h >>conftest.$ac_ext
4706 cat >>conftest.$ac_ext <<_ACEOF
4707 /* end confdefs.h.  */
4708 #include <gmp.h>
4709     #include <mpfr.h>
4710 int
4711 main ()
4712 {
4713
4714     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4715     choke me
4716     #endif
4717     mpfr_t n; mpfr_init(n);
4718
4719   ;
4720   return 0;
4721 }
4722 _ACEOF
4723 rm -f conftest.$ac_objext conftest$ac_exeext
4724 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4725   (eval $ac_link) 2>conftest.er1
4726   ac_status=$?
4727   grep -v '^ *+' conftest.er1 >conftest.err
4728   rm -f conftest.er1
4729   cat conftest.err >&5
4730   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4731   (exit $ac_status); } &&
4732          { ac_try='test -z "$ac_c_werror_flag"
4733                          || test ! -s conftest.err'
4734   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4735   (eval $ac_try) 2>&5
4736   ac_status=$?
4737   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4738   (exit $ac_status); }; } &&
4739          { ac_try='test -s conftest$ac_exeext'
4740   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4741   (eval $ac_try) 2>&5
4742   ac_status=$?
4743   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4744   (exit $ac_status); }; }; then
4745   echo "$as_me:$LINENO: result: yes" >&5
4746 echo "${ECHO_T}yes" >&6
4747 else
4748   echo "$as_me: failed program was:" >&5
4749 sed 's/^/| /' conftest.$ac_ext >&5
4750
4751 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4752 echo "${ECHO_T}buggy but acceptable" >&6
4753 fi
4754 rm -f conftest.err conftest.$ac_objext \
4755       conftest$ac_exeext conftest.$ac_ext
4756 else
4757   echo "$as_me: failed program was:" >&5
4758 sed 's/^/| /' conftest.$ac_ext >&5
4759
4760 echo "$as_me:$LINENO: result: no" >&5
4761 echo "${ECHO_T}no" >&6; have_gmp=no
4762 fi
4763 rm -f conftest.err conftest.$ac_objext \
4764       conftest$ac_exeext conftest.$ac_ext
4765       LIBS="$saved_LIBS"
4766   fi
4767   CFLAGS="$saved_CFLAGS"
4768
4769   if test x$have_gmp != xyes; then
4770     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4771 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4772 Copies of these libraries' source code can be found at their respective
4773 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4774 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4775 If you obtained GMP and/or MPFR from a vendor distribution package, make
4776 sure that you have installed both the libraries and the header files.
4777 They may be located in separate packages." >&5
4778 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4779 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4780 Copies of these libraries' source code can be found at their respective
4781 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4782 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4783 If you obtained GMP and/or MPFR from a vendor distribution package, make
4784 sure that you have installed both the libraries and the header files.
4785 They may be located in separate packages." >&2;}
4786    { (exit 1); exit 1; }; }
4787   fi
4788 fi
4789
4790 # Flags needed for both GMP and/or MPFR
4791
4792
4793
4794 # By default, C is the only stage 1 language.
4795 stage1_languages=,c,
4796
4797 # Figure out what language subdirectories are present.
4798 # Look if the user specified --enable-languages="..."; if not, use
4799 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4800 # go away some day.
4801 # NB:  embedded tabs in this IF block -- do not untabify
4802 if test -d ${srcdir}/gcc; then
4803   if test x"${enable_languages+set}" != xset; then
4804     if test x"${LANGUAGES+set}" = xset; then
4805       enable_languages="${LANGUAGES}"
4806         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4807     else
4808       enable_languages=all
4809     fi
4810   else
4811     if test x"${enable_languages}" = x ||
4812        test x"${enable_languages}" = xyes;
4813        then
4814       echo configure.in: --enable-languages needs at least one language argument 1>&2
4815       exit 1
4816     fi
4817   fi
4818   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4819
4820   # 'f95' is the old name for the 'fortran' language. We issue a warning
4821   # and make the substitution.
4822   case ,${enable_languages}, in
4823     *,f95,*)
4824       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4825       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4826       ;;
4827   esac
4828
4829   # First scan to see if an enabled language requires some other language.
4830   # We assume that a given config-lang.in will list all the language
4831   # front ends it requires, even if some are required indirectly.
4832   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4833     case ${lang_frag} in
4834       ..) ;;
4835       # The odd quoting in the next line works around
4836       # an apparent bug in bash 1.12 on linux.
4837       ${srcdir}/gcc/[*]/config-lang.in) ;;
4838       *)
4839         # From the config-lang.in, get $language, $lang_requires
4840         language=
4841         lang_requires=
4842         . ${lang_frag}
4843         for other in ${lang_requires} ; do
4844           case ,${enable_languages}, in
4845             *,$other,*) ;;
4846             *,all,*) ;;
4847             *,$language,*)
4848               echo " \`$other' language required by \`$language'; enabling" 1>&2
4849               enable_languages="${enable_languages},${other}"
4850               ;;
4851           esac
4852         done
4853         ;;
4854     esac
4855   done
4856
4857   new_enable_languages=,c,
4858   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4859   potential_languages=,c,
4860
4861   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4862     case ${lang_frag} in
4863       ..) ;;
4864       # The odd quoting in the next line works around
4865       # an apparent bug in bash 1.12 on linux.
4866       ${srcdir}/gcc/[*]/config-lang.in) ;;
4867       *)
4868         # From the config-lang.in, get $language, $target_libs,
4869         # $lang_dirs, $boot_language, and $build_by_default
4870         language=
4871         target_libs=
4872         lang_dirs=
4873         subdir_requires=
4874         boot_language=no
4875         build_by_default=yes
4876         . ${lang_frag}
4877         if test x${language} = x; then
4878           echo "${lang_frag} doesn't set \$language." 1>&2
4879           exit 1
4880         fi
4881
4882         case ,${enable_languages}, in
4883           *,${language},*)
4884             # Language was explicitly selected; include it.
4885             add_this_lang=yes
4886             ;;
4887           *,all,*)
4888             # 'all' was selected, select it if it is a default language
4889             add_this_lang=${build_by_default}
4890             ;;
4891           *)
4892             add_this_lang=no
4893             ;;
4894         esac
4895
4896         # Disable languages that need other directories if these aren't available.
4897         for i in $subdir_requires; do
4898           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4899           case ,${enable_languages}, in
4900             *,${language},*)
4901               # Specifically requested language; tell them.
4902               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4903 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4904    { (exit 1); exit 1; }; }
4905               ;;
4906             *)
4907               # Silently disable.
4908               add_this_lang=unsupported
4909               ;;
4910           esac
4911         done
4912
4913         # Disable Ada if no preexisting GNAT is available.
4914         case ,${enable_languages},:${language}:${have_gnat} in
4915           *,${language},*:ada:no)
4916             # Specifically requested language; tell them.
4917             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4918 echo "$as_me: error: GNAT is required to build $language" >&2;}
4919    { (exit 1); exit 1; }; }
4920             ;;
4921           *:ada:no)
4922             # Silently disable.
4923             add_this_lang=unsupported
4924             ;;
4925         esac
4926
4927         # Disable a language that is unsupported by the target.
4928         case " $unsupported_languages " in
4929           *" $language "*)
4930             add_this_lang=unsupported
4931             ;;
4932         esac
4933
4934         case $add_this_lang in
4935           unsupported)
4936             # Remove language-dependent dirs.
4937             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4938             ;;
4939           no)
4940             # Remove language-dependent dirs; still show language as supported.
4941             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4942             potential_languages="${potential_languages}${language},"
4943             ;;
4944           yes)
4945             new_enable_languages="${new_enable_languages}${language},"
4946             potential_languages="${potential_languages}${language},"
4947             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4948             case ${boot_language} in
4949               yes)
4950                 # Add to (comma-separated) list of stage 1 languages.
4951                 stage1_languages="${stage1_languages}${language},"
4952                 ;;
4953             esac
4954             ;;
4955         esac
4956         ;;
4957     esac
4958   done
4959
4960   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4961 if test "${enable_stage1_languages+set}" = set; then
4962   enableval="$enable_stage1_languages"
4963   case ,${enable_stage1_languages}, in
4964     ,no,|,,)
4965       # Set it to something that will have no effect in the loop below
4966       enable_stage1_languages=c ;;
4967     ,yes,)
4968       enable_stage1_languages=`echo $new_enable_languages | \
4969         sed -e "s/^,//" -e "s/,$//" ` ;;
4970     *,all,*)
4971       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4972         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4973   esac
4974
4975   # Add "good" languages from enable_stage1_languages to stage1_languages,
4976   # while "bad" languages go in missing_languages.  Leave no duplicates.
4977   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4978     case $potential_languages in
4979       *,$i,*)
4980         case $stage1_languages in
4981           *,$i,*) ;;
4982           *) stage1_languages="$stage1_languages$i," ;;
4983         esac ;;
4984       *)
4985         case $missing_languages in
4986           *,$i,*) ;;
4987           *) missing_languages="$missing_languages$i," ;;
4988         esac ;;
4989      esac
4990   done
4991 fi;
4992
4993   # Remove leading/trailing commas that were added for simplicity
4994   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4995   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4996   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4997   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4998
4999   if test "x$missing_languages" != x; then
5000     { { echo "$as_me:$LINENO: error:
5001 The following requested languages could not be built: ${missing_languages}
5002 Supported languages are: ${potential_languages}" >&5
5003 echo "$as_me: error:
5004 The following requested languages could not be built: ${missing_languages}
5005 Supported languages are: ${potential_languages}" >&2;}
5006    { (exit 1); exit 1; }; }
5007   fi
5008   if test "x$new_enable_languages" != "x$enable_languages"; then
5009     echo The following languages will be built: ${new_enable_languages}
5010     enable_languages="$new_enable_languages"
5011   fi
5012
5013
5014   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5015 fi
5016
5017 # Handle --disable-<component> generically.
5018 for dir in $configdirs $build_configdirs $target_configdirs ; do
5019   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5020   varname=`echo $dirname | sed -e s/+/_/g`
5021   if eval test x\${enable_${varname}} "=" xno ; then
5022     noconfigdirs="$noconfigdirs $dir"
5023   fi
5024 done
5025
5026 # Check for Boehm's garbage collector
5027 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5028 if test "${enable_objc_gc+set}" = set; then
5029   enableval="$enable_objc_gc"
5030   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5031   *,objc,*:*:yes:*target-boehm-gc*)
5032     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5033 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5034    { (exit 1); exit 1; }; }
5035     ;;
5036 esac
5037 fi;
5038
5039 # Make sure we only build Boehm's garbage collector if required.
5040 case ,${enable_languages},:${enable_objc_gc} in
5041   *,objc,*:yes)
5042     # Keep target-boehm-gc if requested for Objective-C.
5043     ;;
5044   *)
5045     # Otherwise remove target-boehm-gc depending on target-libjava.
5046     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5047       noconfigdirs="$noconfigdirs target-boehm-gc"
5048     fi
5049     ;;
5050 esac
5051
5052 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5053 # $build_configdirs and $target_configdirs.
5054 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5055
5056 notsupp=""
5057 for dir in . $skipdirs $noconfigdirs ; do
5058   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5059   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5060     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5061     if test -r $srcdir/$dirname/configure ; then
5062       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5063         true
5064       else
5065         notsupp="$notsupp $dir"
5066       fi
5067     fi
5068   fi
5069   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5070     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5071     if test -r $srcdir/$dirname/configure ; then
5072       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5073         true
5074       else
5075         notsupp="$notsupp $dir"
5076       fi
5077     fi
5078   fi
5079   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5080     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5081     if test -r $srcdir/$dirname/configure ; then
5082       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5083         true
5084       else
5085         notsupp="$notsupp $dir"
5086       fi
5087     fi
5088   fi
5089 done
5090
5091 # Sometimes the tools are distributed with libiberty but with no other
5092 # libraries.  In that case, we don't want to build target-libiberty.
5093 # Don't let libgcc imply libiberty either.
5094 if test -n "${target_configdirs}" ; then
5095   libgcc=
5096   others=
5097   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5098     if test "$i" = "libgcc"; then
5099       libgcc=target-libgcc
5100     elif test "$i" != "libiberty" ; then
5101       if test -r $srcdir/$i/configure ; then
5102         others=yes;
5103         break;
5104       fi
5105     fi
5106   done
5107   if test -z "${others}" ; then
5108     target_configdirs=$libgcc
5109   fi
5110 fi
5111
5112 # Quietly strip out all directories which aren't configurable in this tree.
5113 # This relies on all configurable subdirectories being autoconfiscated, which
5114 # is now the case.
5115 build_configdirs_all="$build_configdirs"
5116 build_configdirs=
5117 for i in ${build_configdirs_all} ; do
5118   j=`echo $i | sed -e s/build-//g`
5119   if test -f ${srcdir}/$j/configure ; then
5120     build_configdirs="${build_configdirs} $i"
5121   fi
5122 done
5123
5124 configdirs_all="$configdirs"
5125 configdirs=
5126 for i in ${configdirs_all} ; do
5127   if test -f ${srcdir}/$i/configure ; then
5128     configdirs="${configdirs} $i"
5129   fi
5130 done
5131
5132 target_configdirs_all="$target_configdirs"
5133 target_configdirs=
5134 for i in ${target_configdirs_all} ; do
5135   j=`echo $i | sed -e s/target-//g`
5136   if test -f ${srcdir}/$j/configure ; then
5137     target_configdirs="${target_configdirs} $i"
5138   fi
5139 done
5140
5141 # Produce a warning message for the subdirs we can't configure.
5142 # This isn't especially interesting in the Cygnus tree, but in the individual
5143 # FSF releases, it's important to let people know when their machine isn't
5144 # supported by the one or two programs in a package.
5145
5146 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5147   # If $appdirs is non-empty, at least one of those directories must still
5148   # be configured, or we error out.  (E.g., if the gas release supports a
5149   # specified target in some subdirs but not the gas subdir, we shouldn't
5150   # pretend that all is well.)
5151   if test -n "$appdirs" ; then
5152     for dir in $appdirs ; do
5153       if test -r $dir/Makefile.in ; then
5154         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5155           appdirs=""
5156           break
5157         fi
5158         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5159           appdirs=""
5160           break
5161         fi
5162       fi
5163     done
5164     if test -n "$appdirs" ; then
5165       echo "*** This configuration is not supported by this package." 1>&2
5166       exit 1
5167     fi
5168   fi
5169   # Okay, some application will build, or we don't care to check.  Still
5170   # notify of subdirs not getting built.
5171   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5172   echo "    ${notsupp}" 1>&2
5173   echo "    (Any other directories should still work fine.)" 1>&2
5174 fi
5175
5176 case "$host" in
5177   *msdosdjgpp*)
5178     enable_gdbtk=no ;;
5179 esac
5180
5181 # To find our prefix, in gcc_cv_tool_prefix.
5182
5183 # The user is always right.
5184 if test "${PATH_SEPARATOR+set}" != set; then
5185   echo "#! /bin/sh" >conf$$.sh
5186   echo  "exit 0"   >>conf$$.sh
5187   chmod +x conf$$.sh
5188   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5189     PATH_SEPARATOR=';'
5190   else
5191     PATH_SEPARATOR=:
5192   fi
5193   rm -f conf$$.sh
5194 fi
5195
5196
5197
5198 if test "x$exec_prefix" = xNONE; then
5199         if test "x$prefix" = xNONE; then
5200                 gcc_cv_tool_prefix=$ac_default_prefix
5201         else
5202                 gcc_cv_tool_prefix=$prefix
5203         fi
5204 else
5205         gcc_cv_tool_prefix=$exec_prefix
5206 fi
5207
5208 # If there is no compiler in the tree, use the PATH only.  In any
5209 # case, if there is no compiler in the tree nobody should use
5210 # AS_FOR_TARGET and LD_FOR_TARGET.
5211 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5212     gcc_version=`cat $srcdir/gcc/BASE-VER`
5213     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5214     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5215     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5216     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5217     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5218     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5219 else
5220     gcc_cv_tool_dirs=
5221 fi
5222
5223 if test x$build = x$target && test -n "$md_exec_prefix"; then
5224         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5225 fi
5226
5227
5228
5229 copy_dirs=
5230
5231
5232 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5233 if test "${with_build_sysroot+set}" = set; then
5234   withval="$with_build_sysroot"
5235   if test x"$withval" != x ; then
5236      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5237    fi
5238 else
5239   SYSROOT_CFLAGS_FOR_TARGET=
5240 fi;
5241
5242
5243
5244 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5245 if test "${with_debug_prefix_map+set}" = set; then
5246   withval="$with_debug_prefix_map"
5247   if test x"$withval" != x; then
5248      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5249      for debug_map in $withval; do
5250        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5251      done
5252    fi
5253 else
5254   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5255 fi;
5256
5257
5258 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5259 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5260 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5261 # We want to ensure that TARGET libraries (which we know are built with
5262 # gcc) are built with "-O2 -g", so include those options when setting
5263 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5264 if test "x$CFLAGS_FOR_TARGET" = x; then
5265   CFLAGS_FOR_TARGET=$CFLAGS
5266   case " $CFLAGS " in
5267     *" -O2 "*) ;;
5268     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5269   esac
5270   case " $CFLAGS " in
5271     *" -g "* | *" -g3 "*) ;;
5272     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5273   esac
5274 fi
5275
5276
5277 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5278   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5279   case " $CXXFLAGS " in
5280     *" -O2 "*) ;;
5281     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5282   esac
5283   case " $CXXFLAGS " in
5284     *" -g "* | *" -g3 "*) ;;
5285     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5286   esac
5287 fi
5288
5289
5290 # Other target tools.
5291 CPPFLAGS_FOR_TARGET=${CPPFLAGS_FOR_TARGET-${CPPFLAGS}}
5292
5293 LDFLAGS_FOR_TARGET=${LDFLAGS_FOR_TARGET-${LDFLAGS}}
5294
5295
5296 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5297 # the named directory are copied to $(tooldir)/sys-include.
5298 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5299   if test x${is_cross_compiler} = xno ; then
5300     echo 1>&2 '***' --with-headers is only supported when cross compiling
5301     exit 1
5302   fi
5303   if test x"${with_headers}" != xyes ; then
5304     x=${gcc_cv_tool_prefix}
5305     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5306   fi
5307 fi
5308
5309 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5310 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5311 # are permitted.
5312 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5313   if test x${is_cross_compiler} = xno ; then
5314     echo 1>&2 '***' --with-libs is only supported when cross compiling
5315     exit 1
5316   fi
5317   if test x"${with_libs}" != xyes ; then
5318     # Copy the libraries in reverse order, so that files in the first named
5319     # library override files in subsequent libraries.
5320     x=${gcc_cv_tool_prefix}
5321     for l in ${with_libs}; do
5322       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5323     done
5324   fi
5325 fi
5326
5327 # Set with_gnu_as and with_gnu_ld as appropriate.
5328 #
5329 # This is done by determining whether or not the appropriate directory
5330 # is available, and by checking whether or not specific configurations
5331 # have requested that this magic not happen.
5332 #
5333 # The command line options always override the explicit settings in
5334 # configure.in, and the settings in configure.in override this magic.
5335 #
5336 # If the default for a toolchain is to use GNU as and ld, and you don't
5337 # want to do that, then you should use the --without-gnu-as and
5338 # --without-gnu-ld options for the configure script.
5339
5340 if test x${use_gnu_as} = x &&
5341    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5342   with_gnu_as=yes
5343   extra_host_args="$extra_host_args --with-gnu-as"
5344 fi
5345
5346 if test x${use_gnu_ld} = x &&
5347    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5348   with_gnu_ld=yes
5349   extra_host_args="$extra_host_args --with-gnu-ld"
5350 fi
5351
5352 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5353 # can detect this case.
5354
5355 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5356   with_newlib=yes
5357   extra_host_args="$extra_host_args --with-newlib"
5358 fi
5359
5360 # Handle ${copy_dirs}
5361 set fnord ${copy_dirs}
5362 shift
5363 while test $# != 0 ; do
5364   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5365     :
5366   else
5367     echo Copying $1 to $2
5368
5369     # Use the install script to create the directory and all required
5370     # parent directories.
5371     if test -d $2 ; then
5372       :
5373     else
5374       echo >config.temp
5375       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5376     fi
5377
5378     # Copy the directory, assuming we have tar.
5379     # FIXME: Should we use B in the second tar?  Not all systems support it.
5380     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5381
5382     # It is the responsibility of the user to correctly adjust all
5383     # symlinks.  If somebody can figure out how to handle them correctly
5384     # here, feel free to add the code.
5385
5386     echo $1 > $2/COPIED
5387   fi
5388   shift; shift
5389 done
5390
5391 # Determine a target-dependent exec_prefix that the installed
5392 # gcc will search in.  Keep this list sorted by triplet, with
5393 # the *-*-osname triplets last.
5394 md_exec_prefix=
5395 case "${target}" in
5396   alpha*-*-*vms*)
5397     md_exec_prefix=/gnu/lib/gcc-lib
5398     ;;
5399   i[34567]86-pc-msdosdjgpp*)
5400     md_exec_prefix=/dev/env/DJDIR/bin
5401     ;;
5402   i[34567]86-*-sco3.2v5*)
5403     if test $with_gnu_as = yes; then
5404       md_exec_prefix=/usr/gnu/bin
5405     else
5406       md_exec_prefix=/usr/ccs/bin/elf
5407     fi
5408     ;;
5409
5410   mn10300-*-* | \
5411   powerpc-*-chorusos* | \
5412   powerpc*-*-eabi* | \
5413   powerpc*-*-sysv* | \
5414   powerpc*-*-kaos* | \
5415   s390x-ibm-tpf*)
5416     md_exec_prefix=/usr/ccs/bin
5417     ;;
5418   sparc64-*-elf*)
5419     ;;
5420   v850*-*-*)
5421     md_exec_prefix=/usr/ccs/bin
5422     ;;
5423   xtensa*-*-elf*)
5424     ;;
5425
5426   *-*-beos* | \
5427   *-*-elf* | \
5428   *-*-hpux* | \
5429   *-*-netware* | \
5430   *-*-nto-qnx* | \
5431   *-*-rtems* | \
5432   *-*-solaris2* | \
5433   *-*-sysv[45]* | \
5434   *-*-vxworks* | \
5435   *-wrs-windiss)
5436     md_exec_prefix=/usr/ccs/bin
5437     ;;
5438 esac
5439
5440 extra_arflags_for_target=
5441 extra_nmflags_for_target=
5442 extra_ranlibflags_for_target=
5443 target_makefile_frag=/dev/null
5444 case "${target}" in
5445   mep*-*-*)
5446     target_makefile_frag="config/mt-mep"
5447     ;;
5448   spu-*-*)
5449     target_makefile_frag="config/mt-spu"
5450     ;;
5451   mips*-sde-elf*)
5452     target_makefile_frag="config/mt-sde"
5453     ;;
5454   mipsisa*-*-elfoabi*)
5455     target_makefile_frag="config/mt-mips-elfoabi"
5456     ;;
5457   mips*-*-*linux* | mips*-*-gnu*)
5458     target_makefile_frag="config/mt-mips-gnu"
5459     ;;
5460   *-*-netware*)
5461     target_makefile_frag="config/mt-netware"
5462     ;;
5463   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5464     target_makefile_frag="config/mt-gnu"
5465     ;;
5466   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5467     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5468     # commands to handle both 32-bit and 64-bit objects.  These flags are
5469     # harmless if we're using GNU nm or ar.
5470     extra_arflags_for_target=" -X32_64"
5471     extra_nmflags_for_target=" -B -X32_64"
5472     ;;
5473   *-*-darwin*)
5474     # ranlib from Darwin requires the -c flag to look at common symbols.
5475     extra_ranlibflags_for_target=" -c"
5476     ;;
5477   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5478     target_makefile_frag="config/mt-wince"
5479     ;;
5480 esac
5481
5482 alphaieee_frag=/dev/null
5483 case $target in
5484   alpha*-*-*)
5485     # This just makes sure to use the -mieee option to build target libs.
5486     # This should probably be set individually by each library.
5487     alphaieee_frag="config/mt-alphaieee"
5488     ;;
5489 esac
5490
5491 # If --enable-target-optspace always use -Os instead of -O2 to build
5492 # the target libraries, similarly if it is not specified, use -Os
5493 # on selected platforms.
5494 ospace_frag=/dev/null
5495 case "${enable_target_optspace}:${target}" in
5496   yes:*)
5497     ospace_frag="config/mt-ospace"
5498     ;;
5499   :d30v-*)
5500     ospace_frag="config/mt-d30v"
5501     ;;
5502   :m32r-* | :d10v-* | :fr30-*)
5503     ospace_frag="config/mt-ospace"
5504     ;;
5505   no:* | :*)
5506     ;;
5507   *)
5508     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5509     ;;
5510 esac
5511
5512 # Default to using --with-stabs for certain targets.
5513 if test x${with_stabs} = x ; then
5514   case "${target}" in
5515   mips*-*-irix[56]*)
5516     ;;
5517   mips*-*-* | alpha*-*-osf*)
5518     with_stabs=yes;
5519     extra_host_args="${extra_host_args} --with-stabs"
5520     ;;
5521   esac
5522 fi
5523
5524 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5525 # them automatically.
5526 case "${host}" in
5527   hppa*64*-*-hpux11*)
5528     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5529     ;;
5530 esac
5531
5532 # Some systems (e.g., one of the i386-aix systems the gas testers are
5533 # using) don't handle "\$" correctly, so don't use it here.
5534 tooldir='${exec_prefix}'/${target_noncanonical}
5535 build_tooldir=${tooldir}
5536
5537 # Create a .gdbinit file which runs the one in srcdir
5538 # and tells GDB to look there for source files.
5539
5540 if test -r ${srcdir}/.gdbinit ; then
5541   case ${srcdir} in
5542     .) ;;
5543     *) cat > ./.gdbinit <<EOF
5544 # ${NO_EDIT}
5545 dir ${srcdir}
5546 dir .
5547 source ${srcdir}/.gdbinit
5548 EOF
5549     ;;
5550   esac
5551 fi
5552
5553 # Make sure that the compiler is able to generate an executable.  If it
5554 # can't, we are probably in trouble.  We don't care whether we can run the
5555 # executable--we might be using a cross compiler--we only care whether it
5556 # can be created.  At this point the main configure script has set CC.
5557 we_are_ok=no
5558 echo "int main () { return 0; }" > conftest.c
5559 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5560 if test $? = 0 ; then
5561   if test -s conftest || test -s conftest.exe ; then
5562     we_are_ok=yes
5563   fi
5564 fi
5565 case $we_are_ok in
5566   no)
5567     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5568     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5569     rm -f conftest*
5570     exit 1
5571     ;;
5572 esac
5573 rm -f conftest*
5574
5575 # The Solaris /usr/ucb/cc compiler does not appear to work.
5576 case "${host}" in
5577   sparc-sun-solaris2*)
5578       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5579       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5580           could_use=
5581           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5582           if test -d /opt/cygnus/bin ; then
5583               if test "$could_use" = "" ; then
5584                   could_use="/opt/cygnus/bin"
5585               else
5586                   could_use="$could_use or /opt/cygnus/bin"
5587               fi
5588           fi
5589         if test "$could_use" = "" ; then
5590             echo "Warning: compilation may fail because you're using"
5591             echo "/usr/ucb/cc.  You should change your PATH or CC "
5592             echo "variable and rerun configure."
5593         else
5594             echo "Warning: compilation may fail because you're using"
5595             echo "/usr/ucb/cc, when you should use the C compiler from"
5596             echo "$could_use.  You should change your"
5597             echo "PATH or CC variable and rerun configure."
5598         fi
5599       fi
5600   ;;
5601 esac
5602
5603 # Decide which environment variable is used to find dynamic libraries.
5604 case "${host}" in
5605   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5606   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5607   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
5608   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5609 esac
5610
5611 # On systems where the dynamic library environment variable is PATH,
5612 if test "$RPATH_ENVVAR" = PATH; then
5613   GCC_SHLIB_SUBDIR=/shlib
5614 else
5615   GCC_SHLIB_SUBDIR=
5616 fi
5617
5618 # Record target_configdirs and the configure arguments for target and
5619 # build configuration in Makefile.
5620 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5621 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5622
5623 # Determine whether gdb needs tk/tcl or not.
5624 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5625 # and in that case we want gdb to be built without tk.  Ugh!
5626 # In fact I believe gdb is the *only* package directly dependent on tk,
5627 # so we should be able to put the 'maybe's in unconditionally and
5628 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5629 # 100% sure that that's safe though.
5630
5631 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5632 case "$enable_gdbtk" in
5633   no)
5634     GDB_TK="" ;;
5635   yes)
5636     GDB_TK="${gdb_tk}" ;;
5637   *)
5638     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5639     # distro.  Eventually someone will fix this and move Insight, nee
5640     # gdbtk to a separate directory.
5641     if test -d ${srcdir}/gdb/gdbtk ; then
5642       GDB_TK="${gdb_tk}"
5643     else
5644       GDB_TK=""
5645     fi
5646     ;;
5647 esac
5648 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5649 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5650
5651 # Strip out unwanted targets.
5652
5653 # While at that, we remove Makefiles if we were started for recursive
5654 # configuration, so that the top-level Makefile reconfigures them,
5655 # like we used to do when configure itself was recursive.
5656
5657 # Loop over modules.  $extrasub must be used with care, limiting as
5658 # much as possible the usage of range addresses.  That's because autoconf
5659 # splits the sed script to overcome limits in the number of commands,
5660 # and relying on carefully-timed sed passes may turn out to be very hard
5661 # to maintain later.  In this particular case, you just have to be careful
5662 # not to nest @if/@endif pairs, because configure will not warn you at all.
5663
5664 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5665 if test "${enable_bootstrap+set}" = set; then
5666   enableval="$enable_bootstrap"
5667
5668 else
5669   enable_bootstrap=default
5670 fi;
5671
5672 # Issue errors and warnings for invalid/strange bootstrap combinations.
5673 case "$configdirs" in
5674   *gcc*) have_compiler=yes ;;
5675   *) have_compiler=no ;;
5676 esac
5677
5678 case "$have_compiler:$host:$target:$enable_bootstrap" in
5679   *:*:*:no) ;;
5680
5681   # Default behavior.  Enable bootstrap if we have a compiler
5682   # and we are in a native configuration.
5683   yes:$build:$build:default)
5684     enable_bootstrap=yes ;;
5685
5686   *:*:*:default)
5687     enable_bootstrap=no ;;
5688
5689   # We have a compiler and we are in a native configuration, bootstrap is ok
5690   yes:$build:$build:yes)
5691     ;;
5692
5693   # Other configurations, but we have a compiler.  Assume the user knows
5694   # what he's doing.
5695   yes:*:*:yes)
5696     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5697 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5698     ;;
5699
5700   # No compiler: if they passed --enable-bootstrap explicitly, fail
5701   no:*:*:yes)
5702     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5703 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5704    { (exit 1); exit 1; }; } ;;
5705
5706   # Fail if wrong command line
5707   *)
5708     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5709 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5710    { (exit 1); exit 1; }; }
5711     ;;
5712 esac
5713
5714 # Adjust the toplevel makefile according to whether bootstrap was selected.
5715 case "$enable_bootstrap" in
5716   yes)
5717     bootstrap_suffix=bootstrap ;;
5718   no)
5719     bootstrap_suffix=no-bootstrap ;;
5720 esac
5721
5722 for module in ${build_configdirs} ; do
5723   if test -z "${no_recursion}" \
5724      && test -f ${build_subdir}/${module}/Makefile; then
5725     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5726     rm -f ${build_subdir}/${module}/Makefile
5727   fi
5728   extrasub="$extrasub
5729 /^@if build-$module\$/d
5730 /^@endif build-$module\$/d
5731 /^@if build-$module-$bootstrap_suffix\$/d
5732 /^@endif build-$module-$bootstrap_suffix\$/d"
5733 done
5734 for module in ${configdirs} ; do
5735   if test -z "${no_recursion}"; then
5736     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5737       if test -f ${file}; then
5738         echo 1>&2 "*** removing ${file} to force reconfigure"
5739         rm -f ${file}
5740       fi
5741     done
5742   fi
5743   extrasub="$extrasub
5744 /^@if $module\$/d
5745 /^@endif $module\$/d
5746 /^@if $module-$bootstrap_suffix\$/d
5747 /^@endif $module-$bootstrap_suffix\$/d"
5748 done
5749 for module in ${target_configdirs} ; do
5750   if test -z "${no_recursion}" \
5751      && test -f ${target_subdir}/${module}/Makefile; then
5752     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5753     rm -f ${target_subdir}/${module}/Makefile
5754   fi
5755   extrasub="$extrasub
5756 /^@if target-$module\$/d
5757 /^@endif target-$module\$/d
5758 /^@if target-$module-$bootstrap_suffix\$/d
5759 /^@endif target-$module-$bootstrap_suffix\$/d"
5760 done
5761
5762 extrasub="$extrasub
5763 /^@if /,/^@endif /d"
5764
5765 # Create the serialization dependencies.  This uses a temporary file.
5766
5767 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5768 if test "${enable_serial_configure+set}" = set; then
5769   enableval="$enable_serial_configure"
5770
5771 fi;
5772
5773 case ${enable_serial_configure} in
5774   yes)
5775     enable_serial_build_configure=yes
5776     enable_serial_host_configure=yes
5777     enable_serial_target_configure=yes
5778     ;;
5779 esac
5780
5781 # These force 'configure's to be done one at a time, to avoid problems
5782 # with contention over a shared config.cache.
5783 rm -f serdep.tmp
5784 echo '# serdep.tmp' > serdep.tmp
5785 olditem=
5786 test "x${enable_serial_build_configure}" = xyes &&
5787 for item in ${build_configdirs} ; do
5788   case ${olditem} in
5789     "") ;;
5790     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5791   esac
5792   olditem=${item}
5793 done
5794 olditem=
5795 test "x${enable_serial_host_configure}" = xyes &&
5796 for item in ${configdirs} ; do
5797   case ${olditem} in
5798     "") ;;
5799     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5800   esac
5801   olditem=${item}
5802 done
5803 olditem=
5804 test "x${enable_serial_target_configure}" = xyes &&
5805 for item in ${target_configdirs} ; do
5806   case ${olditem} in
5807     "") ;;
5808     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5809   esac
5810   olditem=${item}
5811 done
5812 serialization_dependencies=serdep.tmp
5813
5814
5815 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5816 # target, nonopt, and variable assignments.  These are the ones we
5817 # might not want to pass down to subconfigures.  Also strip
5818 # program-prefix, program-suffix, and program-transform-name, so that
5819 # we can pass down a consistent program-transform-name.
5820 baseargs=
5821 keep_next=no
5822 skip_next=no
5823 eval "set -- $ac_configure_args"
5824 for ac_arg
5825 do
5826   if test X"$skip_next" = X"yes"; then
5827     skip_next=no
5828     continue
5829   fi
5830   if test X"$keep_next" = X"yes"; then
5831     case $ac_arg in
5832       *\'*)
5833         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5834     esac
5835     baseargs="$baseargs '$ac_arg'"
5836     keep_next=no
5837     continue
5838   fi
5839
5840   # Handle separated arguments.  Based on the logic generated by
5841   # autoconf 2.59.
5842   case $ac_arg in
5843     *=* | --config-cache | -C | -disable-* | --disable-* \
5844       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5845       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5846       | -with-* | --with-* | -without-* | --without-* | --x)
5847       separate_arg=no
5848       ;;
5849     -*)
5850       separate_arg=yes
5851       ;;
5852     *)
5853       separate_arg=no
5854       ;;
5855   esac
5856
5857   case "$ac_arg" in
5858     --no*)
5859       continue
5860       ;;
5861     --c* | \
5862     --sr* | \
5863     --ho* | \
5864     --bu* | \
5865     --t* | \
5866     --program-* | \
5867     -cache_file* | \
5868     -srcdir* | \
5869     -host* | \
5870     -build* | \
5871     -target* | \
5872     -program-prefix* | \
5873     -program-suffix* | \
5874     -program-transform-name* )
5875       skip_next=$separate_arg
5876       continue
5877       ;;
5878     -*)
5879       # An option.  Add it.
5880       case $ac_arg in
5881         *\'*)
5882           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5883       esac
5884       baseargs="$baseargs '$ac_arg'"
5885       keep_next=$separate_arg
5886       ;;
5887     *)
5888       # Either a variable assignment, or a nonopt (triplet).  Don't
5889       # pass it down; let the Makefile handle this.
5890       continue
5891       ;;
5892   esac
5893 done
5894 # Remove the initial space we just introduced and, as these will be
5895 # expanded by make, quote '$'.
5896 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5897
5898 # Add in --program-transform-name, after --program-prefix and
5899 # --program-suffix have been applied to it.  Autoconf has already
5900 # doubled dollar signs and backslashes in program_transform_name; we want
5901 # the backslashes un-doubled, and then the entire thing wrapped in single
5902 # quotes, because this will be expanded first by make and then by the shell.
5903 # Also, because we want to override the logic in subdir configure scripts to
5904 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5905 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5906 ${program_transform_name}
5907 EOF_SED
5908 gcc_transform_name=`cat conftestsed.out`
5909 rm -f conftestsed.out
5910 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5911 if test "$silent" = yes; then
5912   baseargs="$baseargs --silent"
5913 fi
5914
5915 # For the build-side libraries, we just need to pretend we're native,
5916 # and not use the same cache file.  Multilibs are neither needed nor
5917 # desired.
5918 build_configargs="--cache-file=../config.cache ${baseargs}"
5919
5920 # For host modules, accept cache file option, or specification as blank.
5921 case "${cache_file}" in
5922 "") # empty
5923   cache_file_option="" ;;
5924 /* | [A-Za-z]:[\\/]* ) # absolute path
5925   cache_file_option="--cache-file=${cache_file}" ;;
5926 *) # relative path
5927   cache_file_option="--cache-file=../${cache_file}" ;;
5928 esac
5929
5930 # Host dirs don't like to share a cache file either, horribly enough.
5931 # This seems to be due to autoconf 2.5x stupidity.
5932 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5933
5934 target_configargs=${baseargs}
5935
5936 # Passing a --with-cross-host argument lets the target libraries know
5937 # whether they are being built with a cross-compiler or being built
5938 # native.  However, it would be better to use other mechanisms to make the
5939 # sorts of decisions they want to make on this basis.  Please consider
5940 # this option to be deprecated.  FIXME.
5941 if test x${is_cross_compiler} = xyes ; then
5942   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5943 fi
5944
5945 # Default to --enable-multilib.
5946 if test x${enable_multilib} = x ; then
5947   target_configargs="--enable-multilib ${target_configargs}"
5948 fi
5949
5950 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5951 # changed from the earlier setting of with_newlib.
5952 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5953   target_configargs="--with-newlib ${target_configargs}"
5954 fi
5955
5956 # Different target subdirs use different values of certain variables
5957 # (notably CXX).  Worse, multilibs use *lots* of different values.
5958 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5959 # it doesn't automatically accept command-line overrides of them.
5960 # This means it's not safe for target subdirs to share a cache file,
5961 # which is disgusting, but there you have it.  Hopefully this can be
5962 # fixed in future.  It's still worthwhile to use a cache file for each
5963 # directory.  I think.
5964
5965 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5966 # We need to pass --target, as newer autoconf's requires consistency
5967 # for target_alias and gcc doesn't manage it consistently.
5968 target_configargs="--cache-file=./config.cache ${target_configargs}"
5969
5970 FLAGS_FOR_TARGET=
5971 case " $target_configdirs " in
5972  *" newlib "*)
5973   case " $target_configargs " in
5974   *" --with-newlib "*)
5975    case "$target" in
5976    *-cygwin*)
5977      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' ;;
5978    esac
5979
5980    # If we're not building GCC, don't discard standard headers.
5981    if test -d ${srcdir}/gcc; then
5982      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5983
5984      if test "${build}" != "${host}"; then
5985        # On Canadian crosses, CC_FOR_TARGET will have already been set
5986        # by `configure', so we won't have an opportunity to add -Bgcc/
5987        # to it.  This is right: we don't want to search that directory
5988        # for binaries, but we want the header files in there, so add
5989        # them explicitly.
5990        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5991
5992        # Someone might think of using the pre-installed headers on
5993        # Canadian crosses, in case the installed compiler is not fully
5994        # compatible with the compiler being built.  In this case, it
5995        # would be better to flag an error than risking having
5996        # incompatible object files being constructed.  We can't
5997        # guarantee that an error will be flagged, but let's hope the
5998        # compiler will do it, when presented with incompatible header
5999        # files.
6000      fi
6001    fi
6002
6003    case "${target}-${is_cross_compiler}" in
6004    i[3456789]86-*-linux*-no)
6005       # Here host == target, so we don't need to build gcc,
6006       # so we don't want to discard standard headers.
6007       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6008       ;;
6009    *)
6010       # If we're building newlib, use its generic headers last, but search
6011       # for any libc-related directories first (so make it the last -B
6012       # switch).
6013       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6014
6015       # If we're building libgloss, find the startup file, simulator library
6016       # and linker script.
6017       case " $target_configdirs " in
6018         *" libgloss "*)
6019         # Look for startup file, simulator library and maybe linker script.
6020         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6021         # Look for libnosys.a in case the target needs it.
6022         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6023         # Most targets have the linker script in the source directory.
6024         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6025         ;;
6026       esac
6027       ;;
6028    esac
6029    ;;
6030   esac
6031   ;;
6032 esac
6033 case "$target" in
6034 *-mingw*)
6035   # Can't be handled as Cygwin above since Mingw does not use newlib.
6036   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' ;;
6037 esac
6038
6039 # Allow the user to override the flags for
6040 # our build compiler if desired.
6041 if test x"${build}" = x"${host}" ; then
6042   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6043   CPPFLAGS_FOR_BUILD=${CPPFLAGS_FOR_BUILD-${CPPFLAGS}}
6044   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6045   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6046 fi
6047
6048 # On Canadian crosses, we'll be searching the right directories for
6049 # the previously-installed cross compiler, so don't bother to add
6050 # flags for directories within the install tree of the compiler
6051 # being built; programs in there won't even run.
6052 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6053   # Search for pre-installed headers if nothing else fits.
6054   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6055 fi
6056
6057 if test "x${use_gnu_ld}" = x &&
6058    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6059   # Arrange for us to find uninstalled linker scripts.
6060   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6061 fi
6062
6063 # Search for other target-specific linker scripts and such.
6064 case "${target}" in
6065   mep*)
6066     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6067     ;;
6068 esac
6069
6070 # Makefile fragments.
6071 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6072 do
6073   eval fragval=\$$frag
6074   if test $fragval != /dev/null; then
6075     eval $frag=${srcdir}/$fragval
6076   fi
6077 done
6078
6079
6080
6081
6082
6083 # Miscellanea: directories, flags, etc.
6084
6085
6086
6087
6088
6089
6090
6091
6092 # Build module lists & subconfigure args.
6093
6094
6095
6096 # Host module lists & subconfigure args.
6097
6098
6099
6100 # Target module lists & subconfigure args.
6101
6102
6103
6104 # Build tools.
6105
6106
6107
6108
6109
6110
6111
6112
6113
6114
6115
6116
6117
6118
6119
6120
6121
6122
6123 # Generate default definitions for YACC, M4, LEX and other programs that run
6124 # on the build machine.  These are used if the Makefile can't locate these
6125 # programs in objdir.
6126 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6127
6128 for ac_prog in 'bison -y' byacc yacc
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_YACC+set}" = set; then
6135   echo $ECHO_N "(cached) $ECHO_C" >&6
6136 else
6137   if test -n "$YACC"; then
6138   ac_cv_prog_YACC="$YACC" # 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_YACC="$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 YACC=$ac_cv_prog_YACC
6157 if test -n "$YACC"; then
6158   echo "$as_me:$LINENO: result: $YACC" >&5
6159 echo "${ECHO_T}$YACC" >&6
6160 else
6161   echo "$as_me:$LINENO: result: no" >&5
6162 echo "${ECHO_T}no" >&6
6163 fi
6164
6165   test -n "$YACC" && break
6166 done
6167 test -n "$YACC" || YACC="$MISSING bison -y"
6168
6169 case " $build_configdirs " in
6170   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6171   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6172 esac
6173
6174 for ac_prog in bison
6175 do
6176   # Extract the first word of "$ac_prog", so it can be a program name with args.
6177 set dummy $ac_prog; ac_word=$2
6178 echo "$as_me:$LINENO: checking for $ac_word" >&5
6179 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6180 if test "${ac_cv_prog_BISON+set}" = set; then
6181   echo $ECHO_N "(cached) $ECHO_C" >&6
6182 else
6183   if test -n "$BISON"; then
6184   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6185 else
6186 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6187 for as_dir in $PATH
6188 do
6189   IFS=$as_save_IFS
6190   test -z "$as_dir" && as_dir=.
6191   for ac_exec_ext in '' $ac_executable_extensions; do
6192   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6193     ac_cv_prog_BISON="$ac_prog"
6194     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6195     break 2
6196   fi
6197 done
6198 done
6199
6200 fi
6201 fi
6202 BISON=$ac_cv_prog_BISON
6203 if test -n "$BISON"; then
6204   echo "$as_me:$LINENO: result: $BISON" >&5
6205 echo "${ECHO_T}$BISON" >&6
6206 else
6207   echo "$as_me:$LINENO: result: no" >&5
6208 echo "${ECHO_T}no" >&6
6209 fi
6210
6211   test -n "$BISON" && break
6212 done
6213 test -n "$BISON" || BISON="$MISSING bison"
6214
6215 case " $build_configdirs " in
6216   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6217 esac
6218
6219 for ac_prog in gm4 gnum4 m4
6220 do
6221   # Extract the first word of "$ac_prog", so it can be a program name with args.
6222 set dummy $ac_prog; ac_word=$2
6223 echo "$as_me:$LINENO: checking for $ac_word" >&5
6224 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6225 if test "${ac_cv_prog_M4+set}" = set; then
6226   echo $ECHO_N "(cached) $ECHO_C" >&6
6227 else
6228   if test -n "$M4"; then
6229   ac_cv_prog_M4="$M4" # Let the user override the test.
6230 else
6231 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6232 for as_dir in $PATH
6233 do
6234   IFS=$as_save_IFS
6235   test -z "$as_dir" && as_dir=.
6236   for ac_exec_ext in '' $ac_executable_extensions; do
6237   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6238     ac_cv_prog_M4="$ac_prog"
6239     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6240     break 2
6241   fi
6242 done
6243 done
6244
6245 fi
6246 fi
6247 M4=$ac_cv_prog_M4
6248 if test -n "$M4"; then
6249   echo "$as_me:$LINENO: result: $M4" >&5
6250 echo "${ECHO_T}$M4" >&6
6251 else
6252   echo "$as_me:$LINENO: result: no" >&5
6253 echo "${ECHO_T}no" >&6
6254 fi
6255
6256   test -n "$M4" && break
6257 done
6258 test -n "$M4" || M4="$MISSING m4"
6259
6260 case " $build_configdirs " in
6261   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6262 esac
6263
6264 for ac_prog in flex lex
6265 do
6266   # Extract the first word of "$ac_prog", so it can be a program name with args.
6267 set dummy $ac_prog; ac_word=$2
6268 echo "$as_me:$LINENO: checking for $ac_word" >&5
6269 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6270 if test "${ac_cv_prog_LEX+set}" = set; then
6271   echo $ECHO_N "(cached) $ECHO_C" >&6
6272 else
6273   if test -n "$LEX"; then
6274   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6275 else
6276 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6277 for as_dir in $PATH
6278 do
6279   IFS=$as_save_IFS
6280   test -z "$as_dir" && as_dir=.
6281   for ac_exec_ext in '' $ac_executable_extensions; do
6282   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6283     ac_cv_prog_LEX="$ac_prog"
6284     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6285     break 2
6286   fi
6287 done
6288 done
6289
6290 fi
6291 fi
6292 LEX=$ac_cv_prog_LEX
6293 if test -n "$LEX"; then
6294   echo "$as_me:$LINENO: result: $LEX" >&5
6295 echo "${ECHO_T}$LEX" >&6
6296 else
6297   echo "$as_me:$LINENO: result: no" >&5
6298 echo "${ECHO_T}no" >&6
6299 fi
6300
6301   test -n "$LEX" && break
6302 done
6303 test -n "$LEX" || LEX="$MISSING flex"
6304
6305 case " $build_configdirs " in
6306   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6307   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6308 esac
6309
6310 for ac_prog in flex
6311 do
6312   # Extract the first word of "$ac_prog", so it can be a program name with args.
6313 set dummy $ac_prog; ac_word=$2
6314 echo "$as_me:$LINENO: checking for $ac_word" >&5
6315 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6316 if test "${ac_cv_prog_FLEX+set}" = set; then
6317   echo $ECHO_N "(cached) $ECHO_C" >&6
6318 else
6319   if test -n "$FLEX"; then
6320   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6321 else
6322 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6323 for as_dir in $PATH
6324 do
6325   IFS=$as_save_IFS
6326   test -z "$as_dir" && as_dir=.
6327   for ac_exec_ext in '' $ac_executable_extensions; do
6328   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6329     ac_cv_prog_FLEX="$ac_prog"
6330     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6331     break 2
6332   fi
6333 done
6334 done
6335
6336 fi
6337 fi
6338 FLEX=$ac_cv_prog_FLEX
6339 if test -n "$FLEX"; then
6340   echo "$as_me:$LINENO: result: $FLEX" >&5
6341 echo "${ECHO_T}$FLEX" >&6
6342 else
6343   echo "$as_me:$LINENO: result: no" >&5
6344 echo "${ECHO_T}no" >&6
6345 fi
6346
6347   test -n "$FLEX" && break
6348 done
6349 test -n "$FLEX" || FLEX="$MISSING flex"
6350
6351 case " $build_configdirs " in
6352   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6353 esac
6354
6355 for ac_prog in makeinfo
6356 do
6357   # Extract the first word of "$ac_prog", so it can be a program name with args.
6358 set dummy $ac_prog; ac_word=$2
6359 echo "$as_me:$LINENO: checking for $ac_word" >&5
6360 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6361 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6362   echo $ECHO_N "(cached) $ECHO_C" >&6
6363 else
6364   if test -n "$MAKEINFO"; then
6365   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6366 else
6367 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6368 for as_dir in $PATH
6369 do
6370   IFS=$as_save_IFS
6371   test -z "$as_dir" && as_dir=.
6372   for ac_exec_ext in '' $ac_executable_extensions; do
6373   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6374     ac_cv_prog_MAKEINFO="$ac_prog"
6375     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6376     break 2
6377   fi
6378 done
6379 done
6380
6381 fi
6382 fi
6383 MAKEINFO=$ac_cv_prog_MAKEINFO
6384 if test -n "$MAKEINFO"; then
6385   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6386 echo "${ECHO_T}$MAKEINFO" >&6
6387 else
6388   echo "$as_me:$LINENO: result: no" >&5
6389 echo "${ECHO_T}no" >&6
6390 fi
6391
6392   test -n "$MAKEINFO" && break
6393 done
6394 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6395
6396 case " $build_configdirs " in
6397   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6398   *)
6399
6400     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6401     # higher, else we use the "missing" dummy.
6402     if ${MAKEINFO} --version \
6403        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6404       :
6405     else
6406       MAKEINFO="$MISSING makeinfo"
6407     fi
6408     ;;
6409
6410 esac
6411
6412 # FIXME: expect and dejagnu may become build tools?
6413
6414 for ac_prog in expect
6415 do
6416   # Extract the first word of "$ac_prog", so it can be a program name with args.
6417 set dummy $ac_prog; ac_word=$2
6418 echo "$as_me:$LINENO: checking for $ac_word" >&5
6419 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6420 if test "${ac_cv_prog_EXPECT+set}" = set; then
6421   echo $ECHO_N "(cached) $ECHO_C" >&6
6422 else
6423   if test -n "$EXPECT"; then
6424   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6425 else
6426 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6427 for as_dir in $PATH
6428 do
6429   IFS=$as_save_IFS
6430   test -z "$as_dir" && as_dir=.
6431   for ac_exec_ext in '' $ac_executable_extensions; do
6432   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6433     ac_cv_prog_EXPECT="$ac_prog"
6434     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6435     break 2
6436   fi
6437 done
6438 done
6439
6440 fi
6441 fi
6442 EXPECT=$ac_cv_prog_EXPECT
6443 if test -n "$EXPECT"; then
6444   echo "$as_me:$LINENO: result: $EXPECT" >&5
6445 echo "${ECHO_T}$EXPECT" >&6
6446 else
6447   echo "$as_me:$LINENO: result: no" >&5
6448 echo "${ECHO_T}no" >&6
6449 fi
6450
6451   test -n "$EXPECT" && break
6452 done
6453 test -n "$EXPECT" || EXPECT="expect"
6454
6455 case " $configdirs " in
6456   *" expect "*)
6457     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6458     ;;
6459 esac
6460
6461 for ac_prog in runtest
6462 do
6463   # Extract the first word of "$ac_prog", so it can be a program name with args.
6464 set dummy $ac_prog; ac_word=$2
6465 echo "$as_me:$LINENO: checking for $ac_word" >&5
6466 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6467 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6468   echo $ECHO_N "(cached) $ECHO_C" >&6
6469 else
6470   if test -n "$RUNTEST"; then
6471   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6472 else
6473 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6474 for as_dir in $PATH
6475 do
6476   IFS=$as_save_IFS
6477   test -z "$as_dir" && as_dir=.
6478   for ac_exec_ext in '' $ac_executable_extensions; do
6479   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6480     ac_cv_prog_RUNTEST="$ac_prog"
6481     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6482     break 2
6483   fi
6484 done
6485 done
6486
6487 fi
6488 fi
6489 RUNTEST=$ac_cv_prog_RUNTEST
6490 if test -n "$RUNTEST"; then
6491   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6492 echo "${ECHO_T}$RUNTEST" >&6
6493 else
6494   echo "$as_me:$LINENO: result: no" >&5
6495 echo "${ECHO_T}no" >&6
6496 fi
6497
6498   test -n "$RUNTEST" && break
6499 done
6500 test -n "$RUNTEST" || RUNTEST="runtest"
6501
6502 case " $configdirs " in
6503   *" dejagnu "*)
6504     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6505     ;;
6506 esac
6507
6508
6509 # Host tools.
6510 ncn_tool_prefix=
6511 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6512 ncn_target_tool_prefix=
6513 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6514
6515
6516
6517 if test -n "$AR"; then
6518   ac_cv_prog_AR=$AR
6519 elif test -n "$ac_cv_prog_AR"; then
6520   AR=$ac_cv_prog_AR
6521 fi
6522
6523 if test -n "$ac_cv_prog_AR"; then
6524   for ncn_progname in ar; do
6525     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6526 set dummy ${ncn_progname}; ac_word=$2
6527 echo "$as_me:$LINENO: checking for $ac_word" >&5
6528 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6529 if test "${ac_cv_prog_AR+set}" = set; then
6530   echo $ECHO_N "(cached) $ECHO_C" >&6
6531 else
6532   if test -n "$AR"; then
6533   ac_cv_prog_AR="$AR" # Let the user override the test.
6534 else
6535 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6536 for as_dir in $PATH
6537 do
6538   IFS=$as_save_IFS
6539   test -z "$as_dir" && as_dir=.
6540   for ac_exec_ext in '' $ac_executable_extensions; do
6541   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6542     ac_cv_prog_AR="${ncn_progname}"
6543     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6544     break 2
6545   fi
6546 done
6547 done
6548
6549 fi
6550 fi
6551 AR=$ac_cv_prog_AR
6552 if test -n "$AR"; then
6553   echo "$as_me:$LINENO: result: $AR" >&5
6554 echo "${ECHO_T}$AR" >&6
6555 else
6556   echo "$as_me:$LINENO: result: no" >&5
6557 echo "${ECHO_T}no" >&6
6558 fi
6559
6560   done
6561 fi
6562
6563 for ncn_progname in ar; do
6564   if test -n "$ncn_tool_prefix"; then
6565     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6566 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6567 echo "$as_me:$LINENO: checking for $ac_word" >&5
6568 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6569 if test "${ac_cv_prog_AR+set}" = set; then
6570   echo $ECHO_N "(cached) $ECHO_C" >&6
6571 else
6572   if test -n "$AR"; then
6573   ac_cv_prog_AR="$AR" # Let the user override the test.
6574 else
6575 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6576 for as_dir in $PATH
6577 do
6578   IFS=$as_save_IFS
6579   test -z "$as_dir" && as_dir=.
6580   for ac_exec_ext in '' $ac_executable_extensions; do
6581   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6582     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6583     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6584     break 2
6585   fi
6586 done
6587 done
6588
6589 fi
6590 fi
6591 AR=$ac_cv_prog_AR
6592 if test -n "$AR"; then
6593   echo "$as_me:$LINENO: result: $AR" >&5
6594 echo "${ECHO_T}$AR" >&6
6595 else
6596   echo "$as_me:$LINENO: result: no" >&5
6597 echo "${ECHO_T}no" >&6
6598 fi
6599
6600   fi
6601   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6602     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6603 set dummy ${ncn_progname}; ac_word=$2
6604 echo "$as_me:$LINENO: checking for $ac_word" >&5
6605 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6606 if test "${ac_cv_prog_AR+set}" = set; then
6607   echo $ECHO_N "(cached) $ECHO_C" >&6
6608 else
6609   if test -n "$AR"; then
6610   ac_cv_prog_AR="$AR" # Let the user override the test.
6611 else
6612 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6613 for as_dir in $PATH
6614 do
6615   IFS=$as_save_IFS
6616   test -z "$as_dir" && as_dir=.
6617   for ac_exec_ext in '' $ac_executable_extensions; do
6618   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6619     ac_cv_prog_AR="${ncn_progname}"
6620     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6621     break 2
6622   fi
6623 done
6624 done
6625
6626 fi
6627 fi
6628 AR=$ac_cv_prog_AR
6629 if test -n "$AR"; then
6630   echo "$as_me:$LINENO: result: $AR" >&5
6631 echo "${ECHO_T}$AR" >&6
6632 else
6633   echo "$as_me:$LINENO: result: no" >&5
6634 echo "${ECHO_T}no" >&6
6635 fi
6636
6637   fi
6638   test -n "$ac_cv_prog_AR" && break
6639 done
6640
6641 if test -z "$ac_cv_prog_AR" ; then
6642   set dummy ar
6643   if test $build = $host ; then
6644     AR="$2"
6645   else
6646     AR="${ncn_tool_prefix}$2"
6647   fi
6648 fi
6649
6650
6651
6652 if test -n "$AS"; then
6653   ac_cv_prog_AS=$AS
6654 elif test -n "$ac_cv_prog_AS"; then
6655   AS=$ac_cv_prog_AS
6656 fi
6657
6658 if test -n "$ac_cv_prog_AS"; then
6659   for ncn_progname in as; do
6660     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6661 set dummy ${ncn_progname}; ac_word=$2
6662 echo "$as_me:$LINENO: checking for $ac_word" >&5
6663 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6664 if test "${ac_cv_prog_AS+set}" = set; then
6665   echo $ECHO_N "(cached) $ECHO_C" >&6
6666 else
6667   if test -n "$AS"; then
6668   ac_cv_prog_AS="$AS" # Let the user override the test.
6669 else
6670 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6671 for as_dir in $PATH
6672 do
6673   IFS=$as_save_IFS
6674   test -z "$as_dir" && as_dir=.
6675   for ac_exec_ext in '' $ac_executable_extensions; do
6676   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6677     ac_cv_prog_AS="${ncn_progname}"
6678     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6679     break 2
6680   fi
6681 done
6682 done
6683
6684 fi
6685 fi
6686 AS=$ac_cv_prog_AS
6687 if test -n "$AS"; then
6688   echo "$as_me:$LINENO: result: $AS" >&5
6689 echo "${ECHO_T}$AS" >&6
6690 else
6691   echo "$as_me:$LINENO: result: no" >&5
6692 echo "${ECHO_T}no" >&6
6693 fi
6694
6695   done
6696 fi
6697
6698 for ncn_progname in as; do
6699   if test -n "$ncn_tool_prefix"; then
6700     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6701 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6702 echo "$as_me:$LINENO: checking for $ac_word" >&5
6703 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6704 if test "${ac_cv_prog_AS+set}" = set; then
6705   echo $ECHO_N "(cached) $ECHO_C" >&6
6706 else
6707   if test -n "$AS"; then
6708   ac_cv_prog_AS="$AS" # Let the user override the test.
6709 else
6710 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6711 for as_dir in $PATH
6712 do
6713   IFS=$as_save_IFS
6714   test -z "$as_dir" && as_dir=.
6715   for ac_exec_ext in '' $ac_executable_extensions; do
6716   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6717     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6718     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6719     break 2
6720   fi
6721 done
6722 done
6723
6724 fi
6725 fi
6726 AS=$ac_cv_prog_AS
6727 if test -n "$AS"; then
6728   echo "$as_me:$LINENO: result: $AS" >&5
6729 echo "${ECHO_T}$AS" >&6
6730 else
6731   echo "$as_me:$LINENO: result: no" >&5
6732 echo "${ECHO_T}no" >&6
6733 fi
6734
6735   fi
6736   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6737     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6738 set dummy ${ncn_progname}; ac_word=$2
6739 echo "$as_me:$LINENO: checking for $ac_word" >&5
6740 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6741 if test "${ac_cv_prog_AS+set}" = set; then
6742   echo $ECHO_N "(cached) $ECHO_C" >&6
6743 else
6744   if test -n "$AS"; then
6745   ac_cv_prog_AS="$AS" # Let the user override the test.
6746 else
6747 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6748 for as_dir in $PATH
6749 do
6750   IFS=$as_save_IFS
6751   test -z "$as_dir" && as_dir=.
6752   for ac_exec_ext in '' $ac_executable_extensions; do
6753   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6754     ac_cv_prog_AS="${ncn_progname}"
6755     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6756     break 2
6757   fi
6758 done
6759 done
6760
6761 fi
6762 fi
6763 AS=$ac_cv_prog_AS
6764 if test -n "$AS"; then
6765   echo "$as_me:$LINENO: result: $AS" >&5
6766 echo "${ECHO_T}$AS" >&6
6767 else
6768   echo "$as_me:$LINENO: result: no" >&5
6769 echo "${ECHO_T}no" >&6
6770 fi
6771
6772   fi
6773   test -n "$ac_cv_prog_AS" && break
6774 done
6775
6776 if test -z "$ac_cv_prog_AS" ; then
6777   set dummy as
6778   if test $build = $host ; then
6779     AS="$2"
6780   else
6781     AS="${ncn_tool_prefix}$2"
6782   fi
6783 fi
6784
6785
6786
6787 if test -n "$DLLTOOL"; then
6788   ac_cv_prog_DLLTOOL=$DLLTOOL
6789 elif test -n "$ac_cv_prog_DLLTOOL"; then
6790   DLLTOOL=$ac_cv_prog_DLLTOOL
6791 fi
6792
6793 if test -n "$ac_cv_prog_DLLTOOL"; then
6794   for ncn_progname in dlltool; do
6795     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6796 set dummy ${ncn_progname}; ac_word=$2
6797 echo "$as_me:$LINENO: checking for $ac_word" >&5
6798 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6799 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6800   echo $ECHO_N "(cached) $ECHO_C" >&6
6801 else
6802   if test -n "$DLLTOOL"; then
6803   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6804 else
6805 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6806 for as_dir in $PATH
6807 do
6808   IFS=$as_save_IFS
6809   test -z "$as_dir" && as_dir=.
6810   for ac_exec_ext in '' $ac_executable_extensions; do
6811   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6812     ac_cv_prog_DLLTOOL="${ncn_progname}"
6813     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6814     break 2
6815   fi
6816 done
6817 done
6818
6819 fi
6820 fi
6821 DLLTOOL=$ac_cv_prog_DLLTOOL
6822 if test -n "$DLLTOOL"; then
6823   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6824 echo "${ECHO_T}$DLLTOOL" >&6
6825 else
6826   echo "$as_me:$LINENO: result: no" >&5
6827 echo "${ECHO_T}no" >&6
6828 fi
6829
6830   done
6831 fi
6832
6833 for ncn_progname in dlltool; do
6834   if test -n "$ncn_tool_prefix"; then
6835     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6836 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6837 echo "$as_me:$LINENO: checking for $ac_word" >&5
6838 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6839 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6840   echo $ECHO_N "(cached) $ECHO_C" >&6
6841 else
6842   if test -n "$DLLTOOL"; then
6843   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6844 else
6845 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6846 for as_dir in $PATH
6847 do
6848   IFS=$as_save_IFS
6849   test -z "$as_dir" && as_dir=.
6850   for ac_exec_ext in '' $ac_executable_extensions; do
6851   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6852     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6853     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6854     break 2
6855   fi
6856 done
6857 done
6858
6859 fi
6860 fi
6861 DLLTOOL=$ac_cv_prog_DLLTOOL
6862 if test -n "$DLLTOOL"; then
6863   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6864 echo "${ECHO_T}$DLLTOOL" >&6
6865 else
6866   echo "$as_me:$LINENO: result: no" >&5
6867 echo "${ECHO_T}no" >&6
6868 fi
6869
6870   fi
6871   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6872     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6873 set dummy ${ncn_progname}; ac_word=$2
6874 echo "$as_me:$LINENO: checking for $ac_word" >&5
6875 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6876 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6877   echo $ECHO_N "(cached) $ECHO_C" >&6
6878 else
6879   if test -n "$DLLTOOL"; then
6880   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6881 else
6882 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6883 for as_dir in $PATH
6884 do
6885   IFS=$as_save_IFS
6886   test -z "$as_dir" && as_dir=.
6887   for ac_exec_ext in '' $ac_executable_extensions; do
6888   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6889     ac_cv_prog_DLLTOOL="${ncn_progname}"
6890     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6891     break 2
6892   fi
6893 done
6894 done
6895
6896 fi
6897 fi
6898 DLLTOOL=$ac_cv_prog_DLLTOOL
6899 if test -n "$DLLTOOL"; then
6900   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6901 echo "${ECHO_T}$DLLTOOL" >&6
6902 else
6903   echo "$as_me:$LINENO: result: no" >&5
6904 echo "${ECHO_T}no" >&6
6905 fi
6906
6907   fi
6908   test -n "$ac_cv_prog_DLLTOOL" && break
6909 done
6910
6911 if test -z "$ac_cv_prog_DLLTOOL" ; then
6912   set dummy dlltool
6913   if test $build = $host ; then
6914     DLLTOOL="$2"
6915   else
6916     DLLTOOL="${ncn_tool_prefix}$2"
6917   fi
6918 fi
6919
6920
6921
6922 if test -n "$LD"; then
6923   ac_cv_prog_LD=$LD
6924 elif test -n "$ac_cv_prog_LD"; then
6925   LD=$ac_cv_prog_LD
6926 fi
6927
6928 if test -n "$ac_cv_prog_LD"; then
6929   for ncn_progname in ld; do
6930     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6931 set dummy ${ncn_progname}; ac_word=$2
6932 echo "$as_me:$LINENO: checking for $ac_word" >&5
6933 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6934 if test "${ac_cv_prog_LD+set}" = set; then
6935   echo $ECHO_N "(cached) $ECHO_C" >&6
6936 else
6937   if test -n "$LD"; then
6938   ac_cv_prog_LD="$LD" # Let the user override the test.
6939 else
6940 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6941 for as_dir in $PATH
6942 do
6943   IFS=$as_save_IFS
6944   test -z "$as_dir" && as_dir=.
6945   for ac_exec_ext in '' $ac_executable_extensions; do
6946   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6947     ac_cv_prog_LD="${ncn_progname}"
6948     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6949     break 2
6950   fi
6951 done
6952 done
6953
6954 fi
6955 fi
6956 LD=$ac_cv_prog_LD
6957 if test -n "$LD"; then
6958   echo "$as_me:$LINENO: result: $LD" >&5
6959 echo "${ECHO_T}$LD" >&6
6960 else
6961   echo "$as_me:$LINENO: result: no" >&5
6962 echo "${ECHO_T}no" >&6
6963 fi
6964
6965   done
6966 fi
6967
6968 for ncn_progname in ld; do
6969   if test -n "$ncn_tool_prefix"; then
6970     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6971 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6972 echo "$as_me:$LINENO: checking for $ac_word" >&5
6973 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6974 if test "${ac_cv_prog_LD+set}" = set; then
6975   echo $ECHO_N "(cached) $ECHO_C" >&6
6976 else
6977   if test -n "$LD"; then
6978   ac_cv_prog_LD="$LD" # Let the user override the test.
6979 else
6980 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6981 for as_dir in $PATH
6982 do
6983   IFS=$as_save_IFS
6984   test -z "$as_dir" && as_dir=.
6985   for ac_exec_ext in '' $ac_executable_extensions; do
6986   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6987     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6988     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6989     break 2
6990   fi
6991 done
6992 done
6993
6994 fi
6995 fi
6996 LD=$ac_cv_prog_LD
6997 if test -n "$LD"; then
6998   echo "$as_me:$LINENO: result: $LD" >&5
6999 echo "${ECHO_T}$LD" >&6
7000 else
7001   echo "$as_me:$LINENO: result: no" >&5
7002 echo "${ECHO_T}no" >&6
7003 fi
7004
7005   fi
7006   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7007     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7008 set dummy ${ncn_progname}; ac_word=$2
7009 echo "$as_me:$LINENO: checking for $ac_word" >&5
7010 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7011 if test "${ac_cv_prog_LD+set}" = set; then
7012   echo $ECHO_N "(cached) $ECHO_C" >&6
7013 else
7014   if test -n "$LD"; then
7015   ac_cv_prog_LD="$LD" # Let the user override the test.
7016 else
7017 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7018 for as_dir in $PATH
7019 do
7020   IFS=$as_save_IFS
7021   test -z "$as_dir" && as_dir=.
7022   for ac_exec_ext in '' $ac_executable_extensions; do
7023   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7024     ac_cv_prog_LD="${ncn_progname}"
7025     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7026     break 2
7027   fi
7028 done
7029 done
7030
7031 fi
7032 fi
7033 LD=$ac_cv_prog_LD
7034 if test -n "$LD"; then
7035   echo "$as_me:$LINENO: result: $LD" >&5
7036 echo "${ECHO_T}$LD" >&6
7037 else
7038   echo "$as_me:$LINENO: result: no" >&5
7039 echo "${ECHO_T}no" >&6
7040 fi
7041
7042   fi
7043   test -n "$ac_cv_prog_LD" && break
7044 done
7045
7046 if test -z "$ac_cv_prog_LD" ; then
7047   set dummy ld
7048   if test $build = $host ; then
7049     LD="$2"
7050   else
7051     LD="${ncn_tool_prefix}$2"
7052   fi
7053 fi
7054
7055
7056
7057 if test -n "$LIPO"; then
7058   ac_cv_prog_LIPO=$LIPO
7059 elif test -n "$ac_cv_prog_LIPO"; then
7060   LIPO=$ac_cv_prog_LIPO
7061 fi
7062
7063 if test -n "$ac_cv_prog_LIPO"; then
7064   for ncn_progname in lipo; do
7065     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7066 set dummy ${ncn_progname}; ac_word=$2
7067 echo "$as_me:$LINENO: checking for $ac_word" >&5
7068 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7069 if test "${ac_cv_prog_LIPO+set}" = set; then
7070   echo $ECHO_N "(cached) $ECHO_C" >&6
7071 else
7072   if test -n "$LIPO"; then
7073   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7074 else
7075 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7076 for as_dir in $PATH
7077 do
7078   IFS=$as_save_IFS
7079   test -z "$as_dir" && as_dir=.
7080   for ac_exec_ext in '' $ac_executable_extensions; do
7081   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7082     ac_cv_prog_LIPO="${ncn_progname}"
7083     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7084     break 2
7085   fi
7086 done
7087 done
7088
7089 fi
7090 fi
7091 LIPO=$ac_cv_prog_LIPO
7092 if test -n "$LIPO"; then
7093   echo "$as_me:$LINENO: result: $LIPO" >&5
7094 echo "${ECHO_T}$LIPO" >&6
7095 else
7096   echo "$as_me:$LINENO: result: no" >&5
7097 echo "${ECHO_T}no" >&6
7098 fi
7099
7100   done
7101 fi
7102
7103 for ncn_progname in lipo; do
7104   if test -n "$ncn_tool_prefix"; then
7105     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7106 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7107 echo "$as_me:$LINENO: checking for $ac_word" >&5
7108 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7109 if test "${ac_cv_prog_LIPO+set}" = set; then
7110   echo $ECHO_N "(cached) $ECHO_C" >&6
7111 else
7112   if test -n "$LIPO"; then
7113   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7114 else
7115 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7116 for as_dir in $PATH
7117 do
7118   IFS=$as_save_IFS
7119   test -z "$as_dir" && as_dir=.
7120   for ac_exec_ext in '' $ac_executable_extensions; do
7121   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7122     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7123     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7124     break 2
7125   fi
7126 done
7127 done
7128
7129 fi
7130 fi
7131 LIPO=$ac_cv_prog_LIPO
7132 if test -n "$LIPO"; then
7133   echo "$as_me:$LINENO: result: $LIPO" >&5
7134 echo "${ECHO_T}$LIPO" >&6
7135 else
7136   echo "$as_me:$LINENO: result: no" >&5
7137 echo "${ECHO_T}no" >&6
7138 fi
7139
7140   fi
7141   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7142     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7143 set dummy ${ncn_progname}; ac_word=$2
7144 echo "$as_me:$LINENO: checking for $ac_word" >&5
7145 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7146 if test "${ac_cv_prog_LIPO+set}" = set; then
7147   echo $ECHO_N "(cached) $ECHO_C" >&6
7148 else
7149   if test -n "$LIPO"; then
7150   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7151 else
7152 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7153 for as_dir in $PATH
7154 do
7155   IFS=$as_save_IFS
7156   test -z "$as_dir" && as_dir=.
7157   for ac_exec_ext in '' $ac_executable_extensions; do
7158   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7159     ac_cv_prog_LIPO="${ncn_progname}"
7160     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7161     break 2
7162   fi
7163 done
7164 done
7165
7166 fi
7167 fi
7168 LIPO=$ac_cv_prog_LIPO
7169 if test -n "$LIPO"; then
7170   echo "$as_me:$LINENO: result: $LIPO" >&5
7171 echo "${ECHO_T}$LIPO" >&6
7172 else
7173   echo "$as_me:$LINENO: result: no" >&5
7174 echo "${ECHO_T}no" >&6
7175 fi
7176
7177   fi
7178   test -n "$ac_cv_prog_LIPO" && break
7179 done
7180
7181 if test -z "$ac_cv_prog_LIPO" ; then
7182   set dummy lipo
7183   if test $build = $host ; then
7184     LIPO="$2"
7185   else
7186     LIPO="${ncn_tool_prefix}$2"
7187   fi
7188 fi
7189
7190
7191
7192 if test -n "$NM"; then
7193   ac_cv_prog_NM=$NM
7194 elif test -n "$ac_cv_prog_NM"; then
7195   NM=$ac_cv_prog_NM
7196 fi
7197
7198 if test -n "$ac_cv_prog_NM"; then
7199   for ncn_progname in nm; do
7200     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7201 set dummy ${ncn_progname}; ac_word=$2
7202 echo "$as_me:$LINENO: checking for $ac_word" >&5
7203 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7204 if test "${ac_cv_prog_NM+set}" = set; then
7205   echo $ECHO_N "(cached) $ECHO_C" >&6
7206 else
7207   if test -n "$NM"; then
7208   ac_cv_prog_NM="$NM" # Let the user override the test.
7209 else
7210 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7211 for as_dir in $PATH
7212 do
7213   IFS=$as_save_IFS
7214   test -z "$as_dir" && as_dir=.
7215   for ac_exec_ext in '' $ac_executable_extensions; do
7216   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7217     ac_cv_prog_NM="${ncn_progname}"
7218     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7219     break 2
7220   fi
7221 done
7222 done
7223
7224 fi
7225 fi
7226 NM=$ac_cv_prog_NM
7227 if test -n "$NM"; then
7228   echo "$as_me:$LINENO: result: $NM" >&5
7229 echo "${ECHO_T}$NM" >&6
7230 else
7231   echo "$as_me:$LINENO: result: no" >&5
7232 echo "${ECHO_T}no" >&6
7233 fi
7234
7235   done
7236 fi
7237
7238 for ncn_progname in nm; do
7239   if test -n "$ncn_tool_prefix"; then
7240     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7241 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7242 echo "$as_me:$LINENO: checking for $ac_word" >&5
7243 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7244 if test "${ac_cv_prog_NM+set}" = set; then
7245   echo $ECHO_N "(cached) $ECHO_C" >&6
7246 else
7247   if test -n "$NM"; then
7248   ac_cv_prog_NM="$NM" # Let the user override the test.
7249 else
7250 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7251 for as_dir in $PATH
7252 do
7253   IFS=$as_save_IFS
7254   test -z "$as_dir" && as_dir=.
7255   for ac_exec_ext in '' $ac_executable_extensions; do
7256   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7257     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7258     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7259     break 2
7260   fi
7261 done
7262 done
7263
7264 fi
7265 fi
7266 NM=$ac_cv_prog_NM
7267 if test -n "$NM"; then
7268   echo "$as_me:$LINENO: result: $NM" >&5
7269 echo "${ECHO_T}$NM" >&6
7270 else
7271   echo "$as_me:$LINENO: result: no" >&5
7272 echo "${ECHO_T}no" >&6
7273 fi
7274
7275   fi
7276   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7277     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7278 set dummy ${ncn_progname}; ac_word=$2
7279 echo "$as_me:$LINENO: checking for $ac_word" >&5
7280 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7281 if test "${ac_cv_prog_NM+set}" = set; then
7282   echo $ECHO_N "(cached) $ECHO_C" >&6
7283 else
7284   if test -n "$NM"; then
7285   ac_cv_prog_NM="$NM" # Let the user override the test.
7286 else
7287 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7288 for as_dir in $PATH
7289 do
7290   IFS=$as_save_IFS
7291   test -z "$as_dir" && as_dir=.
7292   for ac_exec_ext in '' $ac_executable_extensions; do
7293   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7294     ac_cv_prog_NM="${ncn_progname}"
7295     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7296     break 2
7297   fi
7298 done
7299 done
7300
7301 fi
7302 fi
7303 NM=$ac_cv_prog_NM
7304 if test -n "$NM"; then
7305   echo "$as_me:$LINENO: result: $NM" >&5
7306 echo "${ECHO_T}$NM" >&6
7307 else
7308   echo "$as_me:$LINENO: result: no" >&5
7309 echo "${ECHO_T}no" >&6
7310 fi
7311
7312   fi
7313   test -n "$ac_cv_prog_NM" && break
7314 done
7315
7316 if test -z "$ac_cv_prog_NM" ; then
7317   set dummy nm
7318   if test $build = $host ; then
7319     NM="$2"
7320   else
7321     NM="${ncn_tool_prefix}$2"
7322   fi
7323 fi
7324
7325
7326
7327 if test -n "$RANLIB"; then
7328   ac_cv_prog_RANLIB=$RANLIB
7329 elif test -n "$ac_cv_prog_RANLIB"; then
7330   RANLIB=$ac_cv_prog_RANLIB
7331 fi
7332
7333 if test -n "$ac_cv_prog_RANLIB"; then
7334   for ncn_progname in ranlib; do
7335     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7336 set dummy ${ncn_progname}; ac_word=$2
7337 echo "$as_me:$LINENO: checking for $ac_word" >&5
7338 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7339 if test "${ac_cv_prog_RANLIB+set}" = set; then
7340   echo $ECHO_N "(cached) $ECHO_C" >&6
7341 else
7342   if test -n "$RANLIB"; then
7343   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7344 else
7345 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7346 for as_dir in $PATH
7347 do
7348   IFS=$as_save_IFS
7349   test -z "$as_dir" && as_dir=.
7350   for ac_exec_ext in '' $ac_executable_extensions; do
7351   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7352     ac_cv_prog_RANLIB="${ncn_progname}"
7353     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7354     break 2
7355   fi
7356 done
7357 done
7358
7359 fi
7360 fi
7361 RANLIB=$ac_cv_prog_RANLIB
7362 if test -n "$RANLIB"; then
7363   echo "$as_me:$LINENO: result: $RANLIB" >&5
7364 echo "${ECHO_T}$RANLIB" >&6
7365 else
7366   echo "$as_me:$LINENO: result: no" >&5
7367 echo "${ECHO_T}no" >&6
7368 fi
7369
7370   done
7371 fi
7372
7373 for ncn_progname in ranlib; do
7374   if test -n "$ncn_tool_prefix"; then
7375     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7376 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7377 echo "$as_me:$LINENO: checking for $ac_word" >&5
7378 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7379 if test "${ac_cv_prog_RANLIB+set}" = set; then
7380   echo $ECHO_N "(cached) $ECHO_C" >&6
7381 else
7382   if test -n "$RANLIB"; then
7383   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7384 else
7385 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7386 for as_dir in $PATH
7387 do
7388   IFS=$as_save_IFS
7389   test -z "$as_dir" && as_dir=.
7390   for ac_exec_ext in '' $ac_executable_extensions; do
7391   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7392     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7393     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7394     break 2
7395   fi
7396 done
7397 done
7398
7399 fi
7400 fi
7401 RANLIB=$ac_cv_prog_RANLIB
7402 if test -n "$RANLIB"; then
7403   echo "$as_me:$LINENO: result: $RANLIB" >&5
7404 echo "${ECHO_T}$RANLIB" >&6
7405 else
7406   echo "$as_me:$LINENO: result: no" >&5
7407 echo "${ECHO_T}no" >&6
7408 fi
7409
7410   fi
7411   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7412     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7413 set dummy ${ncn_progname}; ac_word=$2
7414 echo "$as_me:$LINENO: checking for $ac_word" >&5
7415 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7416 if test "${ac_cv_prog_RANLIB+set}" = set; then
7417   echo $ECHO_N "(cached) $ECHO_C" >&6
7418 else
7419   if test -n "$RANLIB"; then
7420   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7421 else
7422 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7423 for as_dir in $PATH
7424 do
7425   IFS=$as_save_IFS
7426   test -z "$as_dir" && as_dir=.
7427   for ac_exec_ext in '' $ac_executable_extensions; do
7428   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7429     ac_cv_prog_RANLIB="${ncn_progname}"
7430     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7431     break 2
7432   fi
7433 done
7434 done
7435
7436 fi
7437 fi
7438 RANLIB=$ac_cv_prog_RANLIB
7439 if test -n "$RANLIB"; then
7440   echo "$as_me:$LINENO: result: $RANLIB" >&5
7441 echo "${ECHO_T}$RANLIB" >&6
7442 else
7443   echo "$as_me:$LINENO: result: no" >&5
7444 echo "${ECHO_T}no" >&6
7445 fi
7446
7447   fi
7448   test -n "$ac_cv_prog_RANLIB" && break
7449 done
7450
7451 if test -z "$ac_cv_prog_RANLIB" ; then
7452   RANLIB=":"
7453 fi
7454
7455
7456
7457 if test -n "$STRIP"; then
7458   ac_cv_prog_STRIP=$STRIP
7459 elif test -n "$ac_cv_prog_STRIP"; then
7460   STRIP=$ac_cv_prog_STRIP
7461 fi
7462
7463 if test -n "$ac_cv_prog_STRIP"; then
7464   for ncn_progname in strip; do
7465     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7466 set dummy ${ncn_progname}; ac_word=$2
7467 echo "$as_me:$LINENO: checking for $ac_word" >&5
7468 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7469 if test "${ac_cv_prog_STRIP+set}" = set; then
7470   echo $ECHO_N "(cached) $ECHO_C" >&6
7471 else
7472   if test -n "$STRIP"; then
7473   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7474 else
7475 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7476 for as_dir in $PATH
7477 do
7478   IFS=$as_save_IFS
7479   test -z "$as_dir" && as_dir=.
7480   for ac_exec_ext in '' $ac_executable_extensions; do
7481   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7482     ac_cv_prog_STRIP="${ncn_progname}"
7483     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7484     break 2
7485   fi
7486 done
7487 done
7488
7489 fi
7490 fi
7491 STRIP=$ac_cv_prog_STRIP
7492 if test -n "$STRIP"; then
7493   echo "$as_me:$LINENO: result: $STRIP" >&5
7494 echo "${ECHO_T}$STRIP" >&6
7495 else
7496   echo "$as_me:$LINENO: result: no" >&5
7497 echo "${ECHO_T}no" >&6
7498 fi
7499
7500   done
7501 fi
7502
7503 for ncn_progname in strip; do
7504   if test -n "$ncn_tool_prefix"; then
7505     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7506 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7507 echo "$as_me:$LINENO: checking for $ac_word" >&5
7508 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7509 if test "${ac_cv_prog_STRIP+set}" = set; then
7510   echo $ECHO_N "(cached) $ECHO_C" >&6
7511 else
7512   if test -n "$STRIP"; then
7513   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7514 else
7515 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7516 for as_dir in $PATH
7517 do
7518   IFS=$as_save_IFS
7519   test -z "$as_dir" && as_dir=.
7520   for ac_exec_ext in '' $ac_executable_extensions; do
7521   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7522     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7523     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7524     break 2
7525   fi
7526 done
7527 done
7528
7529 fi
7530 fi
7531 STRIP=$ac_cv_prog_STRIP
7532 if test -n "$STRIP"; then
7533   echo "$as_me:$LINENO: result: $STRIP" >&5
7534 echo "${ECHO_T}$STRIP" >&6
7535 else
7536   echo "$as_me:$LINENO: result: no" >&5
7537 echo "${ECHO_T}no" >&6
7538 fi
7539
7540   fi
7541   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7542     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7543 set dummy ${ncn_progname}; ac_word=$2
7544 echo "$as_me:$LINENO: checking for $ac_word" >&5
7545 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7546 if test "${ac_cv_prog_STRIP+set}" = set; then
7547   echo $ECHO_N "(cached) $ECHO_C" >&6
7548 else
7549   if test -n "$STRIP"; then
7550   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7551 else
7552 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7553 for as_dir in $PATH
7554 do
7555   IFS=$as_save_IFS
7556   test -z "$as_dir" && as_dir=.
7557   for ac_exec_ext in '' $ac_executable_extensions; do
7558   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7559     ac_cv_prog_STRIP="${ncn_progname}"
7560     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7561     break 2
7562   fi
7563 done
7564 done
7565
7566 fi
7567 fi
7568 STRIP=$ac_cv_prog_STRIP
7569 if test -n "$STRIP"; then
7570   echo "$as_me:$LINENO: result: $STRIP" >&5
7571 echo "${ECHO_T}$STRIP" >&6
7572 else
7573   echo "$as_me:$LINENO: result: no" >&5
7574 echo "${ECHO_T}no" >&6
7575 fi
7576
7577   fi
7578   test -n "$ac_cv_prog_STRIP" && break
7579 done
7580
7581 if test -z "$ac_cv_prog_STRIP" ; then
7582   STRIP=":"
7583 fi
7584
7585
7586
7587 if test -n "$WINDRES"; then
7588   ac_cv_prog_WINDRES=$WINDRES
7589 elif test -n "$ac_cv_prog_WINDRES"; then
7590   WINDRES=$ac_cv_prog_WINDRES
7591 fi
7592
7593 if test -n "$ac_cv_prog_WINDRES"; then
7594   for ncn_progname in windres; do
7595     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7596 set dummy ${ncn_progname}; ac_word=$2
7597 echo "$as_me:$LINENO: checking for $ac_word" >&5
7598 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7599 if test "${ac_cv_prog_WINDRES+set}" = set; then
7600   echo $ECHO_N "(cached) $ECHO_C" >&6
7601 else
7602   if test -n "$WINDRES"; then
7603   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7604 else
7605 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7606 for as_dir in $PATH
7607 do
7608   IFS=$as_save_IFS
7609   test -z "$as_dir" && as_dir=.
7610   for ac_exec_ext in '' $ac_executable_extensions; do
7611   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7612     ac_cv_prog_WINDRES="${ncn_progname}"
7613     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7614     break 2
7615   fi
7616 done
7617 done
7618
7619 fi
7620 fi
7621 WINDRES=$ac_cv_prog_WINDRES
7622 if test -n "$WINDRES"; then
7623   echo "$as_me:$LINENO: result: $WINDRES" >&5
7624 echo "${ECHO_T}$WINDRES" >&6
7625 else
7626   echo "$as_me:$LINENO: result: no" >&5
7627 echo "${ECHO_T}no" >&6
7628 fi
7629
7630   done
7631 fi
7632
7633 for ncn_progname in windres; do
7634   if test -n "$ncn_tool_prefix"; then
7635     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7636 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7637 echo "$as_me:$LINENO: checking for $ac_word" >&5
7638 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7639 if test "${ac_cv_prog_WINDRES+set}" = set; then
7640   echo $ECHO_N "(cached) $ECHO_C" >&6
7641 else
7642   if test -n "$WINDRES"; then
7643   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7644 else
7645 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7646 for as_dir in $PATH
7647 do
7648   IFS=$as_save_IFS
7649   test -z "$as_dir" && as_dir=.
7650   for ac_exec_ext in '' $ac_executable_extensions; do
7651   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7652     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7653     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7654     break 2
7655   fi
7656 done
7657 done
7658
7659 fi
7660 fi
7661 WINDRES=$ac_cv_prog_WINDRES
7662 if test -n "$WINDRES"; then
7663   echo "$as_me:$LINENO: result: $WINDRES" >&5
7664 echo "${ECHO_T}$WINDRES" >&6
7665 else
7666   echo "$as_me:$LINENO: result: no" >&5
7667 echo "${ECHO_T}no" >&6
7668 fi
7669
7670   fi
7671   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7672     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7673 set dummy ${ncn_progname}; ac_word=$2
7674 echo "$as_me:$LINENO: checking for $ac_word" >&5
7675 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7676 if test "${ac_cv_prog_WINDRES+set}" = set; then
7677   echo $ECHO_N "(cached) $ECHO_C" >&6
7678 else
7679   if test -n "$WINDRES"; then
7680   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7681 else
7682 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7683 for as_dir in $PATH
7684 do
7685   IFS=$as_save_IFS
7686   test -z "$as_dir" && as_dir=.
7687   for ac_exec_ext in '' $ac_executable_extensions; do
7688   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7689     ac_cv_prog_WINDRES="${ncn_progname}"
7690     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7691     break 2
7692   fi
7693 done
7694 done
7695
7696 fi
7697 fi
7698 WINDRES=$ac_cv_prog_WINDRES
7699 if test -n "$WINDRES"; then
7700   echo "$as_me:$LINENO: result: $WINDRES" >&5
7701 echo "${ECHO_T}$WINDRES" >&6
7702 else
7703   echo "$as_me:$LINENO: result: no" >&5
7704 echo "${ECHO_T}no" >&6
7705 fi
7706
7707   fi
7708   test -n "$ac_cv_prog_WINDRES" && break
7709 done
7710
7711 if test -z "$ac_cv_prog_WINDRES" ; then
7712   set dummy windres
7713   if test $build = $host ; then
7714     WINDRES="$2"
7715   else
7716     WINDRES="${ncn_tool_prefix}$2"
7717   fi
7718 fi
7719
7720
7721
7722 if test -n "$WINDMC"; then
7723   ac_cv_prog_WINDMC=$WINDMC
7724 elif test -n "$ac_cv_prog_WINDMC"; then
7725   WINDMC=$ac_cv_prog_WINDMC
7726 fi
7727
7728 if test -n "$ac_cv_prog_WINDMC"; then
7729   for ncn_progname in windmc; do
7730     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7731 set dummy ${ncn_progname}; ac_word=$2
7732 echo "$as_me:$LINENO: checking for $ac_word" >&5
7733 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7734 if test "${ac_cv_prog_WINDMC+set}" = set; then
7735   echo $ECHO_N "(cached) $ECHO_C" >&6
7736 else
7737   if test -n "$WINDMC"; then
7738   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7739 else
7740 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7741 for as_dir in $PATH
7742 do
7743   IFS=$as_save_IFS
7744   test -z "$as_dir" && as_dir=.
7745   for ac_exec_ext in '' $ac_executable_extensions; do
7746   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7747     ac_cv_prog_WINDMC="${ncn_progname}"
7748     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7749     break 2
7750   fi
7751 done
7752 done
7753
7754 fi
7755 fi
7756 WINDMC=$ac_cv_prog_WINDMC
7757 if test -n "$WINDMC"; then
7758   echo "$as_me:$LINENO: result: $WINDMC" >&5
7759 echo "${ECHO_T}$WINDMC" >&6
7760 else
7761   echo "$as_me:$LINENO: result: no" >&5
7762 echo "${ECHO_T}no" >&6
7763 fi
7764
7765   done
7766 fi
7767
7768 for ncn_progname in windmc; do
7769   if test -n "$ncn_tool_prefix"; then
7770     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7771 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7772 echo "$as_me:$LINENO: checking for $ac_word" >&5
7773 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7774 if test "${ac_cv_prog_WINDMC+set}" = set; then
7775   echo $ECHO_N "(cached) $ECHO_C" >&6
7776 else
7777   if test -n "$WINDMC"; then
7778   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7779 else
7780 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7781 for as_dir in $PATH
7782 do
7783   IFS=$as_save_IFS
7784   test -z "$as_dir" && as_dir=.
7785   for ac_exec_ext in '' $ac_executable_extensions; do
7786   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7787     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7788     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7789     break 2
7790   fi
7791 done
7792 done
7793
7794 fi
7795 fi
7796 WINDMC=$ac_cv_prog_WINDMC
7797 if test -n "$WINDMC"; then
7798   echo "$as_me:$LINENO: result: $WINDMC" >&5
7799 echo "${ECHO_T}$WINDMC" >&6
7800 else
7801   echo "$as_me:$LINENO: result: no" >&5
7802 echo "${ECHO_T}no" >&6
7803 fi
7804
7805   fi
7806   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7807     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7808 set dummy ${ncn_progname}; ac_word=$2
7809 echo "$as_me:$LINENO: checking for $ac_word" >&5
7810 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7811 if test "${ac_cv_prog_WINDMC+set}" = set; then
7812   echo $ECHO_N "(cached) $ECHO_C" >&6
7813 else
7814   if test -n "$WINDMC"; then
7815   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7816 else
7817 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7818 for as_dir in $PATH
7819 do
7820   IFS=$as_save_IFS
7821   test -z "$as_dir" && as_dir=.
7822   for ac_exec_ext in '' $ac_executable_extensions; do
7823   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7824     ac_cv_prog_WINDMC="${ncn_progname}"
7825     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7826     break 2
7827   fi
7828 done
7829 done
7830
7831 fi
7832 fi
7833 WINDMC=$ac_cv_prog_WINDMC
7834 if test -n "$WINDMC"; then
7835   echo "$as_me:$LINENO: result: $WINDMC" >&5
7836 echo "${ECHO_T}$WINDMC" >&6
7837 else
7838   echo "$as_me:$LINENO: result: no" >&5
7839 echo "${ECHO_T}no" >&6
7840 fi
7841
7842   fi
7843   test -n "$ac_cv_prog_WINDMC" && break
7844 done
7845
7846 if test -z "$ac_cv_prog_WINDMC" ; then
7847   set dummy windmc
7848   if test $build = $host ; then
7849     WINDMC="$2"
7850   else
7851     WINDMC="${ncn_tool_prefix}$2"
7852   fi
7853 fi
7854
7855
7856
7857 if test -n "$OBJCOPY"; then
7858   ac_cv_prog_OBJCOPY=$OBJCOPY
7859 elif test -n "$ac_cv_prog_OBJCOPY"; then
7860   OBJCOPY=$ac_cv_prog_OBJCOPY
7861 fi
7862
7863 if test -n "$ac_cv_prog_OBJCOPY"; then
7864   for ncn_progname in objcopy; do
7865     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7866 set dummy ${ncn_progname}; ac_word=$2
7867 echo "$as_me:$LINENO: checking for $ac_word" >&5
7868 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7869 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7870   echo $ECHO_N "(cached) $ECHO_C" >&6
7871 else
7872   if test -n "$OBJCOPY"; then
7873   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7874 else
7875 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7876 for as_dir in $PATH
7877 do
7878   IFS=$as_save_IFS
7879   test -z "$as_dir" && as_dir=.
7880   for ac_exec_ext in '' $ac_executable_extensions; do
7881   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7882     ac_cv_prog_OBJCOPY="${ncn_progname}"
7883     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7884     break 2
7885   fi
7886 done
7887 done
7888
7889 fi
7890 fi
7891 OBJCOPY=$ac_cv_prog_OBJCOPY
7892 if test -n "$OBJCOPY"; then
7893   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7894 echo "${ECHO_T}$OBJCOPY" >&6
7895 else
7896   echo "$as_me:$LINENO: result: no" >&5
7897 echo "${ECHO_T}no" >&6
7898 fi
7899
7900   done
7901 fi
7902
7903 for ncn_progname in objcopy; do
7904   if test -n "$ncn_tool_prefix"; then
7905     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7906 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7907 echo "$as_me:$LINENO: checking for $ac_word" >&5
7908 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7909 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7910   echo $ECHO_N "(cached) $ECHO_C" >&6
7911 else
7912   if test -n "$OBJCOPY"; then
7913   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7914 else
7915 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7916 for as_dir in $PATH
7917 do
7918   IFS=$as_save_IFS
7919   test -z "$as_dir" && as_dir=.
7920   for ac_exec_ext in '' $ac_executable_extensions; do
7921   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7922     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7923     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7924     break 2
7925   fi
7926 done
7927 done
7928
7929 fi
7930 fi
7931 OBJCOPY=$ac_cv_prog_OBJCOPY
7932 if test -n "$OBJCOPY"; then
7933   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7934 echo "${ECHO_T}$OBJCOPY" >&6
7935 else
7936   echo "$as_me:$LINENO: result: no" >&5
7937 echo "${ECHO_T}no" >&6
7938 fi
7939
7940   fi
7941   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7942     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7943 set dummy ${ncn_progname}; ac_word=$2
7944 echo "$as_me:$LINENO: checking for $ac_word" >&5
7945 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7946 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7947   echo $ECHO_N "(cached) $ECHO_C" >&6
7948 else
7949   if test -n "$OBJCOPY"; then
7950   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7951 else
7952 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7953 for as_dir in $PATH
7954 do
7955   IFS=$as_save_IFS
7956   test -z "$as_dir" && as_dir=.
7957   for ac_exec_ext in '' $ac_executable_extensions; do
7958   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7959     ac_cv_prog_OBJCOPY="${ncn_progname}"
7960     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7961     break 2
7962   fi
7963 done
7964 done
7965
7966 fi
7967 fi
7968 OBJCOPY=$ac_cv_prog_OBJCOPY
7969 if test -n "$OBJCOPY"; then
7970   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7971 echo "${ECHO_T}$OBJCOPY" >&6
7972 else
7973   echo "$as_me:$LINENO: result: no" >&5
7974 echo "${ECHO_T}no" >&6
7975 fi
7976
7977   fi
7978   test -n "$ac_cv_prog_OBJCOPY" && break
7979 done
7980
7981 if test -z "$ac_cv_prog_OBJCOPY" ; then
7982   set dummy objcopy
7983   if test $build = $host ; then
7984     OBJCOPY="$2"
7985   else
7986     OBJCOPY="${ncn_tool_prefix}$2"
7987   fi
7988 fi
7989
7990
7991
7992 if test -n "$OBJDUMP"; then
7993   ac_cv_prog_OBJDUMP=$OBJDUMP
7994 elif test -n "$ac_cv_prog_OBJDUMP"; then
7995   OBJDUMP=$ac_cv_prog_OBJDUMP
7996 fi
7997
7998 if test -n "$ac_cv_prog_OBJDUMP"; then
7999   for ncn_progname in objdump; do
8000     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8001 set dummy ${ncn_progname}; ac_word=$2
8002 echo "$as_me:$LINENO: checking for $ac_word" >&5
8003 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8004 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8005   echo $ECHO_N "(cached) $ECHO_C" >&6
8006 else
8007   if test -n "$OBJDUMP"; then
8008   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8009 else
8010 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8011 for as_dir in $PATH
8012 do
8013   IFS=$as_save_IFS
8014   test -z "$as_dir" && as_dir=.
8015   for ac_exec_ext in '' $ac_executable_extensions; do
8016   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8017     ac_cv_prog_OBJDUMP="${ncn_progname}"
8018     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8019     break 2
8020   fi
8021 done
8022 done
8023
8024 fi
8025 fi
8026 OBJDUMP=$ac_cv_prog_OBJDUMP
8027 if test -n "$OBJDUMP"; then
8028   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8029 echo "${ECHO_T}$OBJDUMP" >&6
8030 else
8031   echo "$as_me:$LINENO: result: no" >&5
8032 echo "${ECHO_T}no" >&6
8033 fi
8034
8035   done
8036 fi
8037
8038 for ncn_progname in objdump; do
8039   if test -n "$ncn_tool_prefix"; then
8040     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8041 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8042 echo "$as_me:$LINENO: checking for $ac_word" >&5
8043 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8044 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8045   echo $ECHO_N "(cached) $ECHO_C" >&6
8046 else
8047   if test -n "$OBJDUMP"; then
8048   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8049 else
8050 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8051 for as_dir in $PATH
8052 do
8053   IFS=$as_save_IFS
8054   test -z "$as_dir" && as_dir=.
8055   for ac_exec_ext in '' $ac_executable_extensions; do
8056   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8057     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8058     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8059     break 2
8060   fi
8061 done
8062 done
8063
8064 fi
8065 fi
8066 OBJDUMP=$ac_cv_prog_OBJDUMP
8067 if test -n "$OBJDUMP"; then
8068   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8069 echo "${ECHO_T}$OBJDUMP" >&6
8070 else
8071   echo "$as_me:$LINENO: result: no" >&5
8072 echo "${ECHO_T}no" >&6
8073 fi
8074
8075   fi
8076   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8077     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8078 set dummy ${ncn_progname}; ac_word=$2
8079 echo "$as_me:$LINENO: checking for $ac_word" >&5
8080 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8081 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8082   echo $ECHO_N "(cached) $ECHO_C" >&6
8083 else
8084   if test -n "$OBJDUMP"; then
8085   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8086 else
8087 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8088 for as_dir in $PATH
8089 do
8090   IFS=$as_save_IFS
8091   test -z "$as_dir" && as_dir=.
8092   for ac_exec_ext in '' $ac_executable_extensions; do
8093   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8094     ac_cv_prog_OBJDUMP="${ncn_progname}"
8095     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8096     break 2
8097   fi
8098 done
8099 done
8100
8101 fi
8102 fi
8103 OBJDUMP=$ac_cv_prog_OBJDUMP
8104 if test -n "$OBJDUMP"; then
8105   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8106 echo "${ECHO_T}$OBJDUMP" >&6
8107 else
8108   echo "$as_me:$LINENO: result: no" >&5
8109 echo "${ECHO_T}no" >&6
8110 fi
8111
8112   fi
8113   test -n "$ac_cv_prog_OBJDUMP" && break
8114 done
8115
8116 if test -z "$ac_cv_prog_OBJDUMP" ; then
8117   set dummy objdump
8118   if test $build = $host ; then
8119     OBJDUMP="$2"
8120   else
8121     OBJDUMP="${ncn_tool_prefix}$2"
8122   fi
8123 fi
8124
8125
8126
8127
8128
8129
8130 # Target tools.
8131
8132 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8133 if test "${with_build_time_tools+set}" = set; then
8134   withval="$with_build_time_tools"
8135   case x"$withval" in
8136      x/*) ;;
8137      *)
8138        with_build_time_tools=
8139        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8140 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8141        ;;
8142    esac
8143 else
8144   with_build_time_tools=
8145 fi;
8146
8147
8148
8149 if test -n "$CC_FOR_TARGET"; then
8150   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8151 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8152   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8153 fi
8154
8155 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8156   for ncn_progname in cc gcc; do
8157     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8158 set dummy ${ncn_progname}; ac_word=$2
8159 echo "$as_me:$LINENO: checking for $ac_word" >&5
8160 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8161 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8162   echo $ECHO_N "(cached) $ECHO_C" >&6
8163 else
8164   if test -n "$CC_FOR_TARGET"; then
8165   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8166 else
8167 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8168 for as_dir in $PATH
8169 do
8170   IFS=$as_save_IFS
8171   test -z "$as_dir" && as_dir=.
8172   for ac_exec_ext in '' $ac_executable_extensions; do
8173   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8174     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8175     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8176     break 2
8177   fi
8178 done
8179 done
8180
8181 fi
8182 fi
8183 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8184 if test -n "$CC_FOR_TARGET"; then
8185   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8186 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8187 else
8188   echo "$as_me:$LINENO: result: no" >&5
8189 echo "${ECHO_T}no" >&6
8190 fi
8191
8192   done
8193 fi
8194
8195 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8196   for ncn_progname in cc gcc; do
8197     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8198 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8199     if test -x $with_build_time_tools/${ncn_progname}; then
8200       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8201       echo "$as_me:$LINENO: result: yes" >&5
8202 echo "${ECHO_T}yes" >&6
8203       break
8204     else
8205       echo "$as_me:$LINENO: result: no" >&5
8206 echo "${ECHO_T}no" >&6
8207     fi
8208   done
8209 fi
8210
8211 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8212   for ncn_progname in cc gcc; do
8213     if test -n "$ncn_target_tool_prefix"; then
8214       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8215 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8216 echo "$as_me:$LINENO: checking for $ac_word" >&5
8217 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8218 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8219   echo $ECHO_N "(cached) $ECHO_C" >&6
8220 else
8221   if test -n "$CC_FOR_TARGET"; then
8222   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8223 else
8224 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8225 for as_dir in $PATH
8226 do
8227   IFS=$as_save_IFS
8228   test -z "$as_dir" && as_dir=.
8229   for ac_exec_ext in '' $ac_executable_extensions; do
8230   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8231     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8232     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8233     break 2
8234   fi
8235 done
8236 done
8237
8238 fi
8239 fi
8240 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8241 if test -n "$CC_FOR_TARGET"; then
8242   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8243 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8244 else
8245   echo "$as_me:$LINENO: result: no" >&5
8246 echo "${ECHO_T}no" >&6
8247 fi
8248
8249     fi
8250     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8251       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8252 set dummy ${ncn_progname}; ac_word=$2
8253 echo "$as_me:$LINENO: checking for $ac_word" >&5
8254 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8255 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8256   echo $ECHO_N "(cached) $ECHO_C" >&6
8257 else
8258   if test -n "$CC_FOR_TARGET"; then
8259   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8260 else
8261 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8262 for as_dir in $PATH
8263 do
8264   IFS=$as_save_IFS
8265   test -z "$as_dir" && as_dir=.
8266   for ac_exec_ext in '' $ac_executable_extensions; do
8267   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8268     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8269     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8270     break 2
8271   fi
8272 done
8273 done
8274
8275 fi
8276 fi
8277 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8278 if test -n "$CC_FOR_TARGET"; then
8279   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8280 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8281 else
8282   echo "$as_me:$LINENO: result: no" >&5
8283 echo "${ECHO_T}no" >&6
8284 fi
8285
8286     fi
8287     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8288   done
8289 fi
8290
8291 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8292   set dummy cc gcc
8293   if test $build = $target ; then
8294     CC_FOR_TARGET="$2"
8295   else
8296     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8297   fi
8298 else
8299   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8300 fi
8301
8302
8303
8304 if test -n "$CXX_FOR_TARGET"; then
8305   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8306 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8307   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8308 fi
8309
8310 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8311   for ncn_progname in c++ g++ cxx gxx; do
8312     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8313 set dummy ${ncn_progname}; ac_word=$2
8314 echo "$as_me:$LINENO: checking for $ac_word" >&5
8315 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8316 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8317   echo $ECHO_N "(cached) $ECHO_C" >&6
8318 else
8319   if test -n "$CXX_FOR_TARGET"; then
8320   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8321 else
8322 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8323 for as_dir in $PATH
8324 do
8325   IFS=$as_save_IFS
8326   test -z "$as_dir" && as_dir=.
8327   for ac_exec_ext in '' $ac_executable_extensions; do
8328   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8329     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8330     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8331     break 2
8332   fi
8333 done
8334 done
8335
8336 fi
8337 fi
8338 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8339 if test -n "$CXX_FOR_TARGET"; then
8340   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8341 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8342 else
8343   echo "$as_me:$LINENO: result: no" >&5
8344 echo "${ECHO_T}no" >&6
8345 fi
8346
8347   done
8348 fi
8349
8350 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8351   for ncn_progname in c++ g++ cxx gxx; do
8352     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8353 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8354     if test -x $with_build_time_tools/${ncn_progname}; then
8355       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8356       echo "$as_me:$LINENO: result: yes" >&5
8357 echo "${ECHO_T}yes" >&6
8358       break
8359     else
8360       echo "$as_me:$LINENO: result: no" >&5
8361 echo "${ECHO_T}no" >&6
8362     fi
8363   done
8364 fi
8365
8366 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8367   for ncn_progname in c++ g++ cxx gxx; do
8368     if test -n "$ncn_target_tool_prefix"; then
8369       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8370 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8371 echo "$as_me:$LINENO: checking for $ac_word" >&5
8372 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8373 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8374   echo $ECHO_N "(cached) $ECHO_C" >&6
8375 else
8376   if test -n "$CXX_FOR_TARGET"; then
8377   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8378 else
8379 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8380 for as_dir in $PATH
8381 do
8382   IFS=$as_save_IFS
8383   test -z "$as_dir" && as_dir=.
8384   for ac_exec_ext in '' $ac_executable_extensions; do
8385   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8386     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8387     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8388     break 2
8389   fi
8390 done
8391 done
8392
8393 fi
8394 fi
8395 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8396 if test -n "$CXX_FOR_TARGET"; then
8397   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8398 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8399 else
8400   echo "$as_me:$LINENO: result: no" >&5
8401 echo "${ECHO_T}no" >&6
8402 fi
8403
8404     fi
8405     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8406       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8407 set dummy ${ncn_progname}; ac_word=$2
8408 echo "$as_me:$LINENO: checking for $ac_word" >&5
8409 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8410 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8411   echo $ECHO_N "(cached) $ECHO_C" >&6
8412 else
8413   if test -n "$CXX_FOR_TARGET"; then
8414   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8415 else
8416 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8417 for as_dir in $PATH
8418 do
8419   IFS=$as_save_IFS
8420   test -z "$as_dir" && as_dir=.
8421   for ac_exec_ext in '' $ac_executable_extensions; do
8422   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8423     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8424     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8425     break 2
8426   fi
8427 done
8428 done
8429
8430 fi
8431 fi
8432 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8433 if test -n "$CXX_FOR_TARGET"; then
8434   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8435 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8436 else
8437   echo "$as_me:$LINENO: result: no" >&5
8438 echo "${ECHO_T}no" >&6
8439 fi
8440
8441     fi
8442     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8443   done
8444 fi
8445
8446 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8447   set dummy c++ g++ cxx gxx
8448   if test $build = $target ; then
8449     CXX_FOR_TARGET="$2"
8450   else
8451     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8452   fi
8453 else
8454   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8455 fi
8456
8457
8458
8459 if test -n "$GCC_FOR_TARGET"; then
8460   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8461 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8462   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8463 fi
8464
8465 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8466   for ncn_progname in gcc; do
8467     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8468 set dummy ${ncn_progname}; ac_word=$2
8469 echo "$as_me:$LINENO: checking for $ac_word" >&5
8470 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8471 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8472   echo $ECHO_N "(cached) $ECHO_C" >&6
8473 else
8474   if test -n "$GCC_FOR_TARGET"; then
8475   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8476 else
8477 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8478 for as_dir in $PATH
8479 do
8480   IFS=$as_save_IFS
8481   test -z "$as_dir" && as_dir=.
8482   for ac_exec_ext in '' $ac_executable_extensions; do
8483   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8484     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8485     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8486     break 2
8487   fi
8488 done
8489 done
8490
8491 fi
8492 fi
8493 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8494 if test -n "$GCC_FOR_TARGET"; then
8495   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8496 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8497 else
8498   echo "$as_me:$LINENO: result: no" >&5
8499 echo "${ECHO_T}no" >&6
8500 fi
8501
8502   done
8503 fi
8504
8505 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8506   for ncn_progname in gcc; do
8507     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8508 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8509     if test -x $with_build_time_tools/${ncn_progname}; then
8510       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8511       echo "$as_me:$LINENO: result: yes" >&5
8512 echo "${ECHO_T}yes" >&6
8513       break
8514     else
8515       echo "$as_me:$LINENO: result: no" >&5
8516 echo "${ECHO_T}no" >&6
8517     fi
8518   done
8519 fi
8520
8521 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8522   for ncn_progname in gcc; do
8523     if test -n "$ncn_target_tool_prefix"; then
8524       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8525 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8526 echo "$as_me:$LINENO: checking for $ac_word" >&5
8527 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8528 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8529   echo $ECHO_N "(cached) $ECHO_C" >&6
8530 else
8531   if test -n "$GCC_FOR_TARGET"; then
8532   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8533 else
8534 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8535 for as_dir in $PATH
8536 do
8537   IFS=$as_save_IFS
8538   test -z "$as_dir" && as_dir=.
8539   for ac_exec_ext in '' $ac_executable_extensions; do
8540   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8541     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8542     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8543     break 2
8544   fi
8545 done
8546 done
8547
8548 fi
8549 fi
8550 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8551 if test -n "$GCC_FOR_TARGET"; then
8552   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8553 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8554 else
8555   echo "$as_me:$LINENO: result: no" >&5
8556 echo "${ECHO_T}no" >&6
8557 fi
8558
8559     fi
8560     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8561       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8562 set dummy ${ncn_progname}; ac_word=$2
8563 echo "$as_me:$LINENO: checking for $ac_word" >&5
8564 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8565 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8566   echo $ECHO_N "(cached) $ECHO_C" >&6
8567 else
8568   if test -n "$GCC_FOR_TARGET"; then
8569   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8570 else
8571 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8572 for as_dir in $PATH
8573 do
8574   IFS=$as_save_IFS
8575   test -z "$as_dir" && as_dir=.
8576   for ac_exec_ext in '' $ac_executable_extensions; do
8577   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8578     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8579     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8580     break 2
8581   fi
8582 done
8583 done
8584
8585 fi
8586 fi
8587 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8588 if test -n "$GCC_FOR_TARGET"; then
8589   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8590 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8591 else
8592   echo "$as_me:$LINENO: result: no" >&5
8593 echo "${ECHO_T}no" >&6
8594 fi
8595
8596     fi
8597     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8598   done
8599 fi
8600
8601 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8602   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8603 else
8604   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8605 fi
8606
8607
8608
8609 if test -n "$GCJ_FOR_TARGET"; then
8610   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8611 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8612   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8613 fi
8614
8615 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8616   for ncn_progname in gcj; do
8617     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8618 set dummy ${ncn_progname}; ac_word=$2
8619 echo "$as_me:$LINENO: checking for $ac_word" >&5
8620 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8621 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8622   echo $ECHO_N "(cached) $ECHO_C" >&6
8623 else
8624   if test -n "$GCJ_FOR_TARGET"; then
8625   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8626 else
8627 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8628 for as_dir in $PATH
8629 do
8630   IFS=$as_save_IFS
8631   test -z "$as_dir" && as_dir=.
8632   for ac_exec_ext in '' $ac_executable_extensions; do
8633   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8634     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8635     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8636     break 2
8637   fi
8638 done
8639 done
8640
8641 fi
8642 fi
8643 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8644 if test -n "$GCJ_FOR_TARGET"; then
8645   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8646 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8647 else
8648   echo "$as_me:$LINENO: result: no" >&5
8649 echo "${ECHO_T}no" >&6
8650 fi
8651
8652   done
8653 fi
8654
8655 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8656   for ncn_progname in gcj; do
8657     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8658 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8659     if test -x $with_build_time_tools/${ncn_progname}; then
8660       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8661       echo "$as_me:$LINENO: result: yes" >&5
8662 echo "${ECHO_T}yes" >&6
8663       break
8664     else
8665       echo "$as_me:$LINENO: result: no" >&5
8666 echo "${ECHO_T}no" >&6
8667     fi
8668   done
8669 fi
8670
8671 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8672   for ncn_progname in gcj; do
8673     if test -n "$ncn_target_tool_prefix"; then
8674       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8675 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8676 echo "$as_me:$LINENO: checking for $ac_word" >&5
8677 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8678 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8679   echo $ECHO_N "(cached) $ECHO_C" >&6
8680 else
8681   if test -n "$GCJ_FOR_TARGET"; then
8682   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8683 else
8684 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8685 for as_dir in $PATH
8686 do
8687   IFS=$as_save_IFS
8688   test -z "$as_dir" && as_dir=.
8689   for ac_exec_ext in '' $ac_executable_extensions; do
8690   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8691     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8692     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8693     break 2
8694   fi
8695 done
8696 done
8697
8698 fi
8699 fi
8700 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8701 if test -n "$GCJ_FOR_TARGET"; then
8702   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8703 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8704 else
8705   echo "$as_me:$LINENO: result: no" >&5
8706 echo "${ECHO_T}no" >&6
8707 fi
8708
8709     fi
8710     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8711       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8712 set dummy ${ncn_progname}; ac_word=$2
8713 echo "$as_me:$LINENO: checking for $ac_word" >&5
8714 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8715 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8716   echo $ECHO_N "(cached) $ECHO_C" >&6
8717 else
8718   if test -n "$GCJ_FOR_TARGET"; then
8719   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8720 else
8721 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8722 for as_dir in $PATH
8723 do
8724   IFS=$as_save_IFS
8725   test -z "$as_dir" && as_dir=.
8726   for ac_exec_ext in '' $ac_executable_extensions; do
8727   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8728     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8729     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8730     break 2
8731   fi
8732 done
8733 done
8734
8735 fi
8736 fi
8737 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8738 if test -n "$GCJ_FOR_TARGET"; then
8739   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8740 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8741 else
8742   echo "$as_me:$LINENO: result: no" >&5
8743 echo "${ECHO_T}no" >&6
8744 fi
8745
8746     fi
8747     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8748   done
8749 fi
8750
8751 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8752   set dummy gcj
8753   if test $build = $target ; then
8754     GCJ_FOR_TARGET="$2"
8755   else
8756     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8757   fi
8758 else
8759   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8760 fi
8761
8762
8763
8764 if test -n "$GFORTRAN_FOR_TARGET"; then
8765   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8766 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8767   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8768 fi
8769
8770 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8771   for ncn_progname in gfortran; do
8772     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8773 set dummy ${ncn_progname}; ac_word=$2
8774 echo "$as_me:$LINENO: checking for $ac_word" >&5
8775 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8776 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8777   echo $ECHO_N "(cached) $ECHO_C" >&6
8778 else
8779   if test -n "$GFORTRAN_FOR_TARGET"; then
8780   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8781 else
8782 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8783 for as_dir in $PATH
8784 do
8785   IFS=$as_save_IFS
8786   test -z "$as_dir" && as_dir=.
8787   for ac_exec_ext in '' $ac_executable_extensions; do
8788   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8789     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8790     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8791     break 2
8792   fi
8793 done
8794 done
8795
8796 fi
8797 fi
8798 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8799 if test -n "$GFORTRAN_FOR_TARGET"; then
8800   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8801 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8802 else
8803   echo "$as_me:$LINENO: result: no" >&5
8804 echo "${ECHO_T}no" >&6
8805 fi
8806
8807   done
8808 fi
8809
8810 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8811   for ncn_progname in gfortran; do
8812     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8813 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8814     if test -x $with_build_time_tools/${ncn_progname}; then
8815       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8816       echo "$as_me:$LINENO: result: yes" >&5
8817 echo "${ECHO_T}yes" >&6
8818       break
8819     else
8820       echo "$as_me:$LINENO: result: no" >&5
8821 echo "${ECHO_T}no" >&6
8822     fi
8823   done
8824 fi
8825
8826 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8827   for ncn_progname in gfortran; do
8828     if test -n "$ncn_target_tool_prefix"; then
8829       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8830 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8831 echo "$as_me:$LINENO: checking for $ac_word" >&5
8832 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8833 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8834   echo $ECHO_N "(cached) $ECHO_C" >&6
8835 else
8836   if test -n "$GFORTRAN_FOR_TARGET"; then
8837   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8838 else
8839 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8840 for as_dir in $PATH
8841 do
8842   IFS=$as_save_IFS
8843   test -z "$as_dir" && as_dir=.
8844   for ac_exec_ext in '' $ac_executable_extensions; do
8845   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8846     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8847     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8848     break 2
8849   fi
8850 done
8851 done
8852
8853 fi
8854 fi
8855 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8856 if test -n "$GFORTRAN_FOR_TARGET"; then
8857   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8858 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8859 else
8860   echo "$as_me:$LINENO: result: no" >&5
8861 echo "${ECHO_T}no" >&6
8862 fi
8863
8864     fi
8865     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8866       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8867 set dummy ${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_GFORTRAN_FOR_TARGET+set}" = set; then
8871   echo $ECHO_N "(cached) $ECHO_C" >&6
8872 else
8873   if test -n "$GFORTRAN_FOR_TARGET"; then
8874   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_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_GFORTRAN_FOR_TARGET="${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 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8893 if test -n "$GFORTRAN_FOR_TARGET"; then
8894   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8895 echo "${ECHO_T}$GFORTRAN_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     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8903   done
8904 fi
8905
8906 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8907   set dummy gfortran
8908   if test $build = $target ; then
8909     GFORTRAN_FOR_TARGET="$2"
8910   else
8911     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8912   fi
8913 else
8914   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8915 fi
8916
8917
8918
8919 cat > conftest.c << \EOF
8920 #ifdef __GNUC__
8921   gcc_yay;
8922 #endif
8923 EOF
8924 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8925   have_gcc_for_target=yes
8926 else
8927   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8928   have_gcc_for_target=no
8929 fi
8930 rm conftest.c
8931
8932
8933
8934
8935 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8936   if test -n "$with_build_time_tools"; then
8937     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8938 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8939     if test -x $with_build_time_tools/ar; then
8940       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8941       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8942       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8943 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8944     else
8945       echo "$as_me:$LINENO: result: no" >&5
8946 echo "${ECHO_T}no" >&6
8947     fi
8948   elif test $build != $host && test $have_gcc_for_target = yes; then
8949     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8950     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8951     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8952   fi
8953 fi
8954 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8955   # Extract the first word of "ar", so it can be a program name with args.
8956 set dummy ar; ac_word=$2
8957 echo "$as_me:$LINENO: checking for $ac_word" >&5
8958 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8959 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8960   echo $ECHO_N "(cached) $ECHO_C" >&6
8961 else
8962   case $AR_FOR_TARGET in
8963   [\\/]* | ?:[\\/]*)
8964   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8965   ;;
8966   *)
8967   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8968 for as_dir in $gcc_cv_tool_dirs
8969 do
8970   IFS=$as_save_IFS
8971   test -z "$as_dir" && as_dir=.
8972   for ac_exec_ext in '' $ac_executable_extensions; do
8973   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8974     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8975     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8976     break 2
8977   fi
8978 done
8979 done
8980
8981   ;;
8982 esac
8983 fi
8984 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8985
8986 if test -n "$AR_FOR_TARGET"; then
8987   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8988 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8989 else
8990   echo "$as_me:$LINENO: result: no" >&5
8991 echo "${ECHO_T}no" >&6
8992 fi
8993
8994 fi
8995 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8996
8997
8998 if test -n "$AR_FOR_TARGET"; then
8999   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9000 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9001   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9002 fi
9003
9004 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9005   for ncn_progname in ar; do
9006     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9007 set dummy ${ncn_progname}; ac_word=$2
9008 echo "$as_me:$LINENO: checking for $ac_word" >&5
9009 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9010 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9011   echo $ECHO_N "(cached) $ECHO_C" >&6
9012 else
9013   if test -n "$AR_FOR_TARGET"; then
9014   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9015 else
9016 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9017 for as_dir in $PATH
9018 do
9019   IFS=$as_save_IFS
9020   test -z "$as_dir" && as_dir=.
9021   for ac_exec_ext in '' $ac_executable_extensions; do
9022   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9023     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9024     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9025     break 2
9026   fi
9027 done
9028 done
9029
9030 fi
9031 fi
9032 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9033 if test -n "$AR_FOR_TARGET"; then
9034   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9035 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9036 else
9037   echo "$as_me:$LINENO: result: no" >&5
9038 echo "${ECHO_T}no" >&6
9039 fi
9040
9041   done
9042 fi
9043
9044 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9045   for ncn_progname in ar; do
9046     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9047 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9048     if test -x $with_build_time_tools/${ncn_progname}; then
9049       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9050       echo "$as_me:$LINENO: result: yes" >&5
9051 echo "${ECHO_T}yes" >&6
9052       break
9053     else
9054       echo "$as_me:$LINENO: result: no" >&5
9055 echo "${ECHO_T}no" >&6
9056     fi
9057   done
9058 fi
9059
9060 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9061   for ncn_progname in ar; do
9062     if test -n "$ncn_target_tool_prefix"; then
9063       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9064 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9065 echo "$as_me:$LINENO: checking for $ac_word" >&5
9066 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9067 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9068   echo $ECHO_N "(cached) $ECHO_C" >&6
9069 else
9070   if test -n "$AR_FOR_TARGET"; then
9071   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9072 else
9073 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9074 for as_dir in $PATH
9075 do
9076   IFS=$as_save_IFS
9077   test -z "$as_dir" && as_dir=.
9078   for ac_exec_ext in '' $ac_executable_extensions; do
9079   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9080     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9081     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9082     break 2
9083   fi
9084 done
9085 done
9086
9087 fi
9088 fi
9089 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9090 if test -n "$AR_FOR_TARGET"; then
9091   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9092 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9093 else
9094   echo "$as_me:$LINENO: result: no" >&5
9095 echo "${ECHO_T}no" >&6
9096 fi
9097
9098     fi
9099     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9100       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9101 set dummy ${ncn_progname}; ac_word=$2
9102 echo "$as_me:$LINENO: checking for $ac_word" >&5
9103 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9104 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9105   echo $ECHO_N "(cached) $ECHO_C" >&6
9106 else
9107   if test -n "$AR_FOR_TARGET"; then
9108   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9109 else
9110 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9111 for as_dir in $PATH
9112 do
9113   IFS=$as_save_IFS
9114   test -z "$as_dir" && as_dir=.
9115   for ac_exec_ext in '' $ac_executable_extensions; do
9116   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9117     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9118     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9119     break 2
9120   fi
9121 done
9122 done
9123
9124 fi
9125 fi
9126 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9127 if test -n "$AR_FOR_TARGET"; then
9128   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9129 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9130 else
9131   echo "$as_me:$LINENO: result: no" >&5
9132 echo "${ECHO_T}no" >&6
9133 fi
9134
9135     fi
9136     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9137   done
9138 fi
9139
9140 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9141   set dummy ar
9142   if test $build = $target ; then
9143     AR_FOR_TARGET="$2"
9144   else
9145     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9146   fi
9147 else
9148   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9149 fi
9150
9151 else
9152   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9153 fi
9154
9155
9156
9157
9158 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9159   if test -n "$with_build_time_tools"; then
9160     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9161 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9162     if test -x $with_build_time_tools/as; then
9163       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9164       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9165       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9166 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9167     else
9168       echo "$as_me:$LINENO: result: no" >&5
9169 echo "${ECHO_T}no" >&6
9170     fi
9171   elif test $build != $host && test $have_gcc_for_target = yes; then
9172     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9173     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9174     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9175   fi
9176 fi
9177 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9178   # Extract the first word of "as", so it can be a program name with args.
9179 set dummy as; ac_word=$2
9180 echo "$as_me:$LINENO: checking for $ac_word" >&5
9181 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9182 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9183   echo $ECHO_N "(cached) $ECHO_C" >&6
9184 else
9185   case $AS_FOR_TARGET in
9186   [\\/]* | ?:[\\/]*)
9187   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9188   ;;
9189   *)
9190   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9191 for as_dir in $gcc_cv_tool_dirs
9192 do
9193   IFS=$as_save_IFS
9194   test -z "$as_dir" && as_dir=.
9195   for ac_exec_ext in '' $ac_executable_extensions; do
9196   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9197     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9198     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9199     break 2
9200   fi
9201 done
9202 done
9203
9204   ;;
9205 esac
9206 fi
9207 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9208
9209 if test -n "$AS_FOR_TARGET"; then
9210   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9211 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9212 else
9213   echo "$as_me:$LINENO: result: no" >&5
9214 echo "${ECHO_T}no" >&6
9215 fi
9216
9217 fi
9218 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9219
9220
9221 if test -n "$AS_FOR_TARGET"; then
9222   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9223 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9224   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9225 fi
9226
9227 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9228   for ncn_progname in as; do
9229     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9230 set dummy ${ncn_progname}; ac_word=$2
9231 echo "$as_me:$LINENO: checking for $ac_word" >&5
9232 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9233 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9234   echo $ECHO_N "(cached) $ECHO_C" >&6
9235 else
9236   if test -n "$AS_FOR_TARGET"; then
9237   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9238 else
9239 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9240 for as_dir in $PATH
9241 do
9242   IFS=$as_save_IFS
9243   test -z "$as_dir" && as_dir=.
9244   for ac_exec_ext in '' $ac_executable_extensions; do
9245   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9246     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9247     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9248     break 2
9249   fi
9250 done
9251 done
9252
9253 fi
9254 fi
9255 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9256 if test -n "$AS_FOR_TARGET"; then
9257   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9258 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9259 else
9260   echo "$as_me:$LINENO: result: no" >&5
9261 echo "${ECHO_T}no" >&6
9262 fi
9263
9264   done
9265 fi
9266
9267 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9268   for ncn_progname in as; do
9269     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9270 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9271     if test -x $with_build_time_tools/${ncn_progname}; then
9272       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9273       echo "$as_me:$LINENO: result: yes" >&5
9274 echo "${ECHO_T}yes" >&6
9275       break
9276     else
9277       echo "$as_me:$LINENO: result: no" >&5
9278 echo "${ECHO_T}no" >&6
9279     fi
9280   done
9281 fi
9282
9283 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9284   for ncn_progname in as; do
9285     if test -n "$ncn_target_tool_prefix"; then
9286       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9287 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9288 echo "$as_me:$LINENO: checking for $ac_word" >&5
9289 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9290 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9291   echo $ECHO_N "(cached) $ECHO_C" >&6
9292 else
9293   if test -n "$AS_FOR_TARGET"; then
9294   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9295 else
9296 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9297 for as_dir in $PATH
9298 do
9299   IFS=$as_save_IFS
9300   test -z "$as_dir" && as_dir=.
9301   for ac_exec_ext in '' $ac_executable_extensions; do
9302   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9303     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9304     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9305     break 2
9306   fi
9307 done
9308 done
9309
9310 fi
9311 fi
9312 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9313 if test -n "$AS_FOR_TARGET"; then
9314   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9315 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9316 else
9317   echo "$as_me:$LINENO: result: no" >&5
9318 echo "${ECHO_T}no" >&6
9319 fi
9320
9321     fi
9322     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9323       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9324 set dummy ${ncn_progname}; ac_word=$2
9325 echo "$as_me:$LINENO: checking for $ac_word" >&5
9326 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9327 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9328   echo $ECHO_N "(cached) $ECHO_C" >&6
9329 else
9330   if test -n "$AS_FOR_TARGET"; then
9331   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9332 else
9333 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9334 for as_dir in $PATH
9335 do
9336   IFS=$as_save_IFS
9337   test -z "$as_dir" && as_dir=.
9338   for ac_exec_ext in '' $ac_executable_extensions; do
9339   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9340     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9341     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9342     break 2
9343   fi
9344 done
9345 done
9346
9347 fi
9348 fi
9349 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9350 if test -n "$AS_FOR_TARGET"; then
9351   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9352 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9353 else
9354   echo "$as_me:$LINENO: result: no" >&5
9355 echo "${ECHO_T}no" >&6
9356 fi
9357
9358     fi
9359     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9360   done
9361 fi
9362
9363 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9364   set dummy as
9365   if test $build = $target ; then
9366     AS_FOR_TARGET="$2"
9367   else
9368     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9369   fi
9370 else
9371   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9372 fi
9373
9374 else
9375   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9376 fi
9377
9378
9379
9380
9381 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9382   if test -n "$with_build_time_tools"; then
9383     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9384 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9385     if test -x $with_build_time_tools/dlltool; then
9386       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9387       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9388       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9389 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9390     else
9391       echo "$as_me:$LINENO: result: no" >&5
9392 echo "${ECHO_T}no" >&6
9393     fi
9394   elif test $build != $host && test $have_gcc_for_target = yes; then
9395     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9396     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9397     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9398   fi
9399 fi
9400 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9401   # Extract the first word of "dlltool", so it can be a program name with args.
9402 set dummy dlltool; ac_word=$2
9403 echo "$as_me:$LINENO: checking for $ac_word" >&5
9404 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9405 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9406   echo $ECHO_N "(cached) $ECHO_C" >&6
9407 else
9408   case $DLLTOOL_FOR_TARGET in
9409   [\\/]* | ?:[\\/]*)
9410   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9411   ;;
9412   *)
9413   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9414 for as_dir in $gcc_cv_tool_dirs
9415 do
9416   IFS=$as_save_IFS
9417   test -z "$as_dir" && as_dir=.
9418   for ac_exec_ext in '' $ac_executable_extensions; do
9419   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9420     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9421     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9422     break 2
9423   fi
9424 done
9425 done
9426
9427   ;;
9428 esac
9429 fi
9430 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9431
9432 if test -n "$DLLTOOL_FOR_TARGET"; then
9433   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9434 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9435 else
9436   echo "$as_me:$LINENO: result: no" >&5
9437 echo "${ECHO_T}no" >&6
9438 fi
9439
9440 fi
9441 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9442
9443
9444 if test -n "$DLLTOOL_FOR_TARGET"; then
9445   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9446 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9447   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9448 fi
9449
9450 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9451   for ncn_progname in dlltool; do
9452     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9453 set dummy ${ncn_progname}; ac_word=$2
9454 echo "$as_me:$LINENO: checking for $ac_word" >&5
9455 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9456 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9457   echo $ECHO_N "(cached) $ECHO_C" >&6
9458 else
9459   if test -n "$DLLTOOL_FOR_TARGET"; then
9460   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9461 else
9462 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9463 for as_dir in $PATH
9464 do
9465   IFS=$as_save_IFS
9466   test -z "$as_dir" && as_dir=.
9467   for ac_exec_ext in '' $ac_executable_extensions; do
9468   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9469     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9470     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9471     break 2
9472   fi
9473 done
9474 done
9475
9476 fi
9477 fi
9478 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9479 if test -n "$DLLTOOL_FOR_TARGET"; then
9480   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9481 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9482 else
9483   echo "$as_me:$LINENO: result: no" >&5
9484 echo "${ECHO_T}no" >&6
9485 fi
9486
9487   done
9488 fi
9489
9490 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9491   for ncn_progname in dlltool; do
9492     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9493 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9494     if test -x $with_build_time_tools/${ncn_progname}; then
9495       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9496       echo "$as_me:$LINENO: result: yes" >&5
9497 echo "${ECHO_T}yes" >&6
9498       break
9499     else
9500       echo "$as_me:$LINENO: result: no" >&5
9501 echo "${ECHO_T}no" >&6
9502     fi
9503   done
9504 fi
9505
9506 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9507   for ncn_progname in dlltool; do
9508     if test -n "$ncn_target_tool_prefix"; then
9509       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9510 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9511 echo "$as_me:$LINENO: checking for $ac_word" >&5
9512 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9513 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9514   echo $ECHO_N "(cached) $ECHO_C" >&6
9515 else
9516   if test -n "$DLLTOOL_FOR_TARGET"; then
9517   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9518 else
9519 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9520 for as_dir in $PATH
9521 do
9522   IFS=$as_save_IFS
9523   test -z "$as_dir" && as_dir=.
9524   for ac_exec_ext in '' $ac_executable_extensions; do
9525   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9526     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9527     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9528     break 2
9529   fi
9530 done
9531 done
9532
9533 fi
9534 fi
9535 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9536 if test -n "$DLLTOOL_FOR_TARGET"; then
9537   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9538 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9539 else
9540   echo "$as_me:$LINENO: result: no" >&5
9541 echo "${ECHO_T}no" >&6
9542 fi
9543
9544     fi
9545     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9546       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9547 set dummy ${ncn_progname}; ac_word=$2
9548 echo "$as_me:$LINENO: checking for $ac_word" >&5
9549 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9550 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9551   echo $ECHO_N "(cached) $ECHO_C" >&6
9552 else
9553   if test -n "$DLLTOOL_FOR_TARGET"; then
9554   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9555 else
9556 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9557 for as_dir in $PATH
9558 do
9559   IFS=$as_save_IFS
9560   test -z "$as_dir" && as_dir=.
9561   for ac_exec_ext in '' $ac_executable_extensions; do
9562   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9563     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9564     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9565     break 2
9566   fi
9567 done
9568 done
9569
9570 fi
9571 fi
9572 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9573 if test -n "$DLLTOOL_FOR_TARGET"; then
9574   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9575 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9576 else
9577   echo "$as_me:$LINENO: result: no" >&5
9578 echo "${ECHO_T}no" >&6
9579 fi
9580
9581     fi
9582     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9583   done
9584 fi
9585
9586 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9587   set dummy dlltool
9588   if test $build = $target ; then
9589     DLLTOOL_FOR_TARGET="$2"
9590   else
9591     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9592   fi
9593 else
9594   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9595 fi
9596
9597 else
9598   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9599 fi
9600
9601
9602
9603
9604 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9605   if test -n "$with_build_time_tools"; then
9606     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9607 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9608     if test -x $with_build_time_tools/ld; then
9609       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9610       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9611       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9612 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9613     else
9614       echo "$as_me:$LINENO: result: no" >&5
9615 echo "${ECHO_T}no" >&6
9616     fi
9617   elif test $build != $host && test $have_gcc_for_target = yes; then
9618     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9619     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9620     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9621   fi
9622 fi
9623 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9624   # Extract the first word of "ld", so it can be a program name with args.
9625 set dummy ld; ac_word=$2
9626 echo "$as_me:$LINENO: checking for $ac_word" >&5
9627 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9628 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9629   echo $ECHO_N "(cached) $ECHO_C" >&6
9630 else
9631   case $LD_FOR_TARGET in
9632   [\\/]* | ?:[\\/]*)
9633   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9634   ;;
9635   *)
9636   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9637 for as_dir in $gcc_cv_tool_dirs
9638 do
9639   IFS=$as_save_IFS
9640   test -z "$as_dir" && as_dir=.
9641   for ac_exec_ext in '' $ac_executable_extensions; do
9642   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9643     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9644     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9645     break 2
9646   fi
9647 done
9648 done
9649
9650   ;;
9651 esac
9652 fi
9653 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9654
9655 if test -n "$LD_FOR_TARGET"; then
9656   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9657 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9658 else
9659   echo "$as_me:$LINENO: result: no" >&5
9660 echo "${ECHO_T}no" >&6
9661 fi
9662
9663 fi
9664 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9665
9666
9667 if test -n "$LD_FOR_TARGET"; then
9668   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9669 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9670   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9671 fi
9672
9673 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9674   for ncn_progname in ld; do
9675     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9676 set dummy ${ncn_progname}; ac_word=$2
9677 echo "$as_me:$LINENO: checking for $ac_word" >&5
9678 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9679 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9680   echo $ECHO_N "(cached) $ECHO_C" >&6
9681 else
9682   if test -n "$LD_FOR_TARGET"; then
9683   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9684 else
9685 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9686 for as_dir in $PATH
9687 do
9688   IFS=$as_save_IFS
9689   test -z "$as_dir" && as_dir=.
9690   for ac_exec_ext in '' $ac_executable_extensions; do
9691   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9692     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9693     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9694     break 2
9695   fi
9696 done
9697 done
9698
9699 fi
9700 fi
9701 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9702 if test -n "$LD_FOR_TARGET"; then
9703   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9704 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9705 else
9706   echo "$as_me:$LINENO: result: no" >&5
9707 echo "${ECHO_T}no" >&6
9708 fi
9709
9710   done
9711 fi
9712
9713 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9714   for ncn_progname in ld; do
9715     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9716 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9717     if test -x $with_build_time_tools/${ncn_progname}; then
9718       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9719       echo "$as_me:$LINENO: result: yes" >&5
9720 echo "${ECHO_T}yes" >&6
9721       break
9722     else
9723       echo "$as_me:$LINENO: result: no" >&5
9724 echo "${ECHO_T}no" >&6
9725     fi
9726   done
9727 fi
9728
9729 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9730   for ncn_progname in ld; do
9731     if test -n "$ncn_target_tool_prefix"; then
9732       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9733 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9734 echo "$as_me:$LINENO: checking for $ac_word" >&5
9735 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9736 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9737   echo $ECHO_N "(cached) $ECHO_C" >&6
9738 else
9739   if test -n "$LD_FOR_TARGET"; then
9740   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9741 else
9742 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9743 for as_dir in $PATH
9744 do
9745   IFS=$as_save_IFS
9746   test -z "$as_dir" && as_dir=.
9747   for ac_exec_ext in '' $ac_executable_extensions; do
9748   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9749     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9750     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9751     break 2
9752   fi
9753 done
9754 done
9755
9756 fi
9757 fi
9758 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9759 if test -n "$LD_FOR_TARGET"; then
9760   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9761 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9762 else
9763   echo "$as_me:$LINENO: result: no" >&5
9764 echo "${ECHO_T}no" >&6
9765 fi
9766
9767     fi
9768     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9769       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9770 set dummy ${ncn_progname}; ac_word=$2
9771 echo "$as_me:$LINENO: checking for $ac_word" >&5
9772 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9773 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9774   echo $ECHO_N "(cached) $ECHO_C" >&6
9775 else
9776   if test -n "$LD_FOR_TARGET"; then
9777   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9778 else
9779 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9780 for as_dir in $PATH
9781 do
9782   IFS=$as_save_IFS
9783   test -z "$as_dir" && as_dir=.
9784   for ac_exec_ext in '' $ac_executable_extensions; do
9785   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9786     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9787     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9788     break 2
9789   fi
9790 done
9791 done
9792
9793 fi
9794 fi
9795 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9796 if test -n "$LD_FOR_TARGET"; then
9797   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9798 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9799 else
9800   echo "$as_me:$LINENO: result: no" >&5
9801 echo "${ECHO_T}no" >&6
9802 fi
9803
9804     fi
9805     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9806   done
9807 fi
9808
9809 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9810   set dummy ld
9811   if test $build = $target ; then
9812     LD_FOR_TARGET="$2"
9813   else
9814     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9815   fi
9816 else
9817   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9818 fi
9819
9820 else
9821   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9822 fi
9823
9824
9825
9826
9827 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9828   if test -n "$with_build_time_tools"; then
9829     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9830 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9831     if test -x $with_build_time_tools/lipo; then
9832       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9833       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9834       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9835 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9836     else
9837       echo "$as_me:$LINENO: result: no" >&5
9838 echo "${ECHO_T}no" >&6
9839     fi
9840   elif test $build != $host && test $have_gcc_for_target = yes; then
9841     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9842     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9843     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9844   fi
9845 fi
9846 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9847   # Extract the first word of "lipo", so it can be a program name with args.
9848 set dummy lipo; ac_word=$2
9849 echo "$as_me:$LINENO: checking for $ac_word" >&5
9850 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9851 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9852   echo $ECHO_N "(cached) $ECHO_C" >&6
9853 else
9854   case $LIPO_FOR_TARGET in
9855   [\\/]* | ?:[\\/]*)
9856   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9857   ;;
9858   *)
9859   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9860 for as_dir in $gcc_cv_tool_dirs
9861 do
9862   IFS=$as_save_IFS
9863   test -z "$as_dir" && as_dir=.
9864   for ac_exec_ext in '' $ac_executable_extensions; do
9865   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9866     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9867     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9868     break 2
9869   fi
9870 done
9871 done
9872
9873   ;;
9874 esac
9875 fi
9876 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9877
9878 if test -n "$LIPO_FOR_TARGET"; then
9879   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9880 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9881 else
9882   echo "$as_me:$LINENO: result: no" >&5
9883 echo "${ECHO_T}no" >&6
9884 fi
9885
9886 fi
9887 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9888
9889
9890 if test -n "$LIPO_FOR_TARGET"; then
9891   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9892 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9893   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9894 fi
9895
9896 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9897   for ncn_progname in lipo; do
9898     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9899 set dummy ${ncn_progname}; ac_word=$2
9900 echo "$as_me:$LINENO: checking for $ac_word" >&5
9901 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9902 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9903   echo $ECHO_N "(cached) $ECHO_C" >&6
9904 else
9905   if test -n "$LIPO_FOR_TARGET"; then
9906   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9907 else
9908 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9909 for as_dir in $PATH
9910 do
9911   IFS=$as_save_IFS
9912   test -z "$as_dir" && as_dir=.
9913   for ac_exec_ext in '' $ac_executable_extensions; do
9914   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9915     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9916     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9917     break 2
9918   fi
9919 done
9920 done
9921
9922 fi
9923 fi
9924 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9925 if test -n "$LIPO_FOR_TARGET"; then
9926   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9927 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9928 else
9929   echo "$as_me:$LINENO: result: no" >&5
9930 echo "${ECHO_T}no" >&6
9931 fi
9932
9933   done
9934 fi
9935
9936 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9937   for ncn_progname in lipo; do
9938     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9939 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9940     if test -x $with_build_time_tools/${ncn_progname}; then
9941       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9942       echo "$as_me:$LINENO: result: yes" >&5
9943 echo "${ECHO_T}yes" >&6
9944       break
9945     else
9946       echo "$as_me:$LINENO: result: no" >&5
9947 echo "${ECHO_T}no" >&6
9948     fi
9949   done
9950 fi
9951
9952 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9953   for ncn_progname in lipo; do
9954     if test -n "$ncn_target_tool_prefix"; then
9955       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9956 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9957 echo "$as_me:$LINENO: checking for $ac_word" >&5
9958 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9959 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9960   echo $ECHO_N "(cached) $ECHO_C" >&6
9961 else
9962   if test -n "$LIPO_FOR_TARGET"; then
9963   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9964 else
9965 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9966 for as_dir in $PATH
9967 do
9968   IFS=$as_save_IFS
9969   test -z "$as_dir" && as_dir=.
9970   for ac_exec_ext in '' $ac_executable_extensions; do
9971   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9972     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9973     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9974     break 2
9975   fi
9976 done
9977 done
9978
9979 fi
9980 fi
9981 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9982 if test -n "$LIPO_FOR_TARGET"; then
9983   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9984 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9985 else
9986   echo "$as_me:$LINENO: result: no" >&5
9987 echo "${ECHO_T}no" >&6
9988 fi
9989
9990     fi
9991     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9992       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9993 set dummy ${ncn_progname}; ac_word=$2
9994 echo "$as_me:$LINENO: checking for $ac_word" >&5
9995 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9996 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9997   echo $ECHO_N "(cached) $ECHO_C" >&6
9998 else
9999   if test -n "$LIPO_FOR_TARGET"; then
10000   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10001 else
10002 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10003 for as_dir in $PATH
10004 do
10005   IFS=$as_save_IFS
10006   test -z "$as_dir" && as_dir=.
10007   for ac_exec_ext in '' $ac_executable_extensions; do
10008   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10009     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10010     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10011     break 2
10012   fi
10013 done
10014 done
10015
10016 fi
10017 fi
10018 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10019 if test -n "$LIPO_FOR_TARGET"; then
10020   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10021 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10022 else
10023   echo "$as_me:$LINENO: result: no" >&5
10024 echo "${ECHO_T}no" >&6
10025 fi
10026
10027     fi
10028     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10029   done
10030 fi
10031
10032 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10033   set dummy lipo
10034   if test $build = $target ; then
10035     LIPO_FOR_TARGET="$2"
10036   else
10037     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10038   fi
10039 else
10040   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10041 fi
10042
10043 else
10044   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10045 fi
10046
10047
10048
10049
10050 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10051   if test -n "$with_build_time_tools"; then
10052     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10053 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10054     if test -x $with_build_time_tools/nm; then
10055       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10056       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10057       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10058 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10059     else
10060       echo "$as_me:$LINENO: result: no" >&5
10061 echo "${ECHO_T}no" >&6
10062     fi
10063   elif test $build != $host && test $have_gcc_for_target = yes; then
10064     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10065     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10066     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10067   fi
10068 fi
10069 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10070   # Extract the first word of "nm", so it can be a program name with args.
10071 set dummy nm; ac_word=$2
10072 echo "$as_me:$LINENO: checking for $ac_word" >&5
10073 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10074 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10075   echo $ECHO_N "(cached) $ECHO_C" >&6
10076 else
10077   case $NM_FOR_TARGET in
10078   [\\/]* | ?:[\\/]*)
10079   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10080   ;;
10081   *)
10082   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10083 for as_dir in $gcc_cv_tool_dirs
10084 do
10085   IFS=$as_save_IFS
10086   test -z "$as_dir" && as_dir=.
10087   for ac_exec_ext in '' $ac_executable_extensions; do
10088   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10089     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10090     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10091     break 2
10092   fi
10093 done
10094 done
10095
10096   ;;
10097 esac
10098 fi
10099 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10100
10101 if test -n "$NM_FOR_TARGET"; then
10102   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10103 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10104 else
10105   echo "$as_me:$LINENO: result: no" >&5
10106 echo "${ECHO_T}no" >&6
10107 fi
10108
10109 fi
10110 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10111
10112
10113 if test -n "$NM_FOR_TARGET"; then
10114   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10115 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10116   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10117 fi
10118
10119 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10120   for ncn_progname in nm; do
10121     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10122 set dummy ${ncn_progname}; ac_word=$2
10123 echo "$as_me:$LINENO: checking for $ac_word" >&5
10124 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10125 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10126   echo $ECHO_N "(cached) $ECHO_C" >&6
10127 else
10128   if test -n "$NM_FOR_TARGET"; then
10129   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10130 else
10131 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10132 for as_dir in $PATH
10133 do
10134   IFS=$as_save_IFS
10135   test -z "$as_dir" && as_dir=.
10136   for ac_exec_ext in '' $ac_executable_extensions; do
10137   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10138     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10139     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10140     break 2
10141   fi
10142 done
10143 done
10144
10145 fi
10146 fi
10147 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10148 if test -n "$NM_FOR_TARGET"; then
10149   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10150 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10151 else
10152   echo "$as_me:$LINENO: result: no" >&5
10153 echo "${ECHO_T}no" >&6
10154 fi
10155
10156   done
10157 fi
10158
10159 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10160   for ncn_progname in nm; do
10161     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10162 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10163     if test -x $with_build_time_tools/${ncn_progname}; then
10164       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10165       echo "$as_me:$LINENO: result: yes" >&5
10166 echo "${ECHO_T}yes" >&6
10167       break
10168     else
10169       echo "$as_me:$LINENO: result: no" >&5
10170 echo "${ECHO_T}no" >&6
10171     fi
10172   done
10173 fi
10174
10175 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10176   for ncn_progname in nm; do
10177     if test -n "$ncn_target_tool_prefix"; then
10178       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10179 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10180 echo "$as_me:$LINENO: checking for $ac_word" >&5
10181 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10182 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10183   echo $ECHO_N "(cached) $ECHO_C" >&6
10184 else
10185   if test -n "$NM_FOR_TARGET"; then
10186   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10187 else
10188 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10189 for as_dir in $PATH
10190 do
10191   IFS=$as_save_IFS
10192   test -z "$as_dir" && as_dir=.
10193   for ac_exec_ext in '' $ac_executable_extensions; do
10194   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10195     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10196     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10197     break 2
10198   fi
10199 done
10200 done
10201
10202 fi
10203 fi
10204 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10205 if test -n "$NM_FOR_TARGET"; then
10206   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10207 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10208 else
10209   echo "$as_me:$LINENO: result: no" >&5
10210 echo "${ECHO_T}no" >&6
10211 fi
10212
10213     fi
10214     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10215       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10216 set dummy ${ncn_progname}; ac_word=$2
10217 echo "$as_me:$LINENO: checking for $ac_word" >&5
10218 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10219 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10220   echo $ECHO_N "(cached) $ECHO_C" >&6
10221 else
10222   if test -n "$NM_FOR_TARGET"; then
10223   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10224 else
10225 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10226 for as_dir in $PATH
10227 do
10228   IFS=$as_save_IFS
10229   test -z "$as_dir" && as_dir=.
10230   for ac_exec_ext in '' $ac_executable_extensions; do
10231   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10232     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10233     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10234     break 2
10235   fi
10236 done
10237 done
10238
10239 fi
10240 fi
10241 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10242 if test -n "$NM_FOR_TARGET"; then
10243   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10244 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10245 else
10246   echo "$as_me:$LINENO: result: no" >&5
10247 echo "${ECHO_T}no" >&6
10248 fi
10249
10250     fi
10251     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10252   done
10253 fi
10254
10255 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10256   set dummy nm
10257   if test $build = $target ; then
10258     NM_FOR_TARGET="$2"
10259   else
10260     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10261   fi
10262 else
10263   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10264 fi
10265
10266 else
10267   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10268 fi
10269
10270
10271
10272
10273 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10274   if test -n "$with_build_time_tools"; then
10275     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10276 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10277     if test -x $with_build_time_tools/objdump; then
10278       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10279       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10280       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10281 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10282     else
10283       echo "$as_me:$LINENO: result: no" >&5
10284 echo "${ECHO_T}no" >&6
10285     fi
10286   elif test $build != $host && test $have_gcc_for_target = yes; then
10287     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10288     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10289     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10290   fi
10291 fi
10292 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10293   # Extract the first word of "objdump", so it can be a program name with args.
10294 set dummy objdump; ac_word=$2
10295 echo "$as_me:$LINENO: checking for $ac_word" >&5
10296 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10297 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10298   echo $ECHO_N "(cached) $ECHO_C" >&6
10299 else
10300   case $OBJDUMP_FOR_TARGET in
10301   [\\/]* | ?:[\\/]*)
10302   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10303   ;;
10304   *)
10305   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10306 for as_dir in $gcc_cv_tool_dirs
10307 do
10308   IFS=$as_save_IFS
10309   test -z "$as_dir" && as_dir=.
10310   for ac_exec_ext in '' $ac_executable_extensions; do
10311   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10312     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10313     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10314     break 2
10315   fi
10316 done
10317 done
10318
10319   ;;
10320 esac
10321 fi
10322 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10323
10324 if test -n "$OBJDUMP_FOR_TARGET"; then
10325   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10326 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10327 else
10328   echo "$as_me:$LINENO: result: no" >&5
10329 echo "${ECHO_T}no" >&6
10330 fi
10331
10332 fi
10333 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10334
10335
10336 if test -n "$OBJDUMP_FOR_TARGET"; then
10337   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10338 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10339   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10340 fi
10341
10342 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10343   for ncn_progname in objdump; do
10344     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10345 set dummy ${ncn_progname}; ac_word=$2
10346 echo "$as_me:$LINENO: checking for $ac_word" >&5
10347 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10348 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10349   echo $ECHO_N "(cached) $ECHO_C" >&6
10350 else
10351   if test -n "$OBJDUMP_FOR_TARGET"; then
10352   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10353 else
10354 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10355 for as_dir in $PATH
10356 do
10357   IFS=$as_save_IFS
10358   test -z "$as_dir" && as_dir=.
10359   for ac_exec_ext in '' $ac_executable_extensions; do
10360   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10361     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10362     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10363     break 2
10364   fi
10365 done
10366 done
10367
10368 fi
10369 fi
10370 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10371 if test -n "$OBJDUMP_FOR_TARGET"; then
10372   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10373 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10374 else
10375   echo "$as_me:$LINENO: result: no" >&5
10376 echo "${ECHO_T}no" >&6
10377 fi
10378
10379   done
10380 fi
10381
10382 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10383   for ncn_progname in objdump; do
10384     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10385 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10386     if test -x $with_build_time_tools/${ncn_progname}; then
10387       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10388       echo "$as_me:$LINENO: result: yes" >&5
10389 echo "${ECHO_T}yes" >&6
10390       break
10391     else
10392       echo "$as_me:$LINENO: result: no" >&5
10393 echo "${ECHO_T}no" >&6
10394     fi
10395   done
10396 fi
10397
10398 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10399   for ncn_progname in objdump; do
10400     if test -n "$ncn_target_tool_prefix"; then
10401       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10402 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10403 echo "$as_me:$LINENO: checking for $ac_word" >&5
10404 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10405 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10406   echo $ECHO_N "(cached) $ECHO_C" >&6
10407 else
10408   if test -n "$OBJDUMP_FOR_TARGET"; then
10409   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10410 else
10411 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10412 for as_dir in $PATH
10413 do
10414   IFS=$as_save_IFS
10415   test -z "$as_dir" && as_dir=.
10416   for ac_exec_ext in '' $ac_executable_extensions; do
10417   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10418     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10419     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10420     break 2
10421   fi
10422 done
10423 done
10424
10425 fi
10426 fi
10427 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10428 if test -n "$OBJDUMP_FOR_TARGET"; then
10429   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10430 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10431 else
10432   echo "$as_me:$LINENO: result: no" >&5
10433 echo "${ECHO_T}no" >&6
10434 fi
10435
10436     fi
10437     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10438       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10439 set dummy ${ncn_progname}; ac_word=$2
10440 echo "$as_me:$LINENO: checking for $ac_word" >&5
10441 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10442 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10443   echo $ECHO_N "(cached) $ECHO_C" >&6
10444 else
10445   if test -n "$OBJDUMP_FOR_TARGET"; then
10446   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10447 else
10448 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10449 for as_dir in $PATH
10450 do
10451   IFS=$as_save_IFS
10452   test -z "$as_dir" && as_dir=.
10453   for ac_exec_ext in '' $ac_executable_extensions; do
10454   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10455     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10456     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10457     break 2
10458   fi
10459 done
10460 done
10461
10462 fi
10463 fi
10464 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10465 if test -n "$OBJDUMP_FOR_TARGET"; then
10466   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10467 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10468 else
10469   echo "$as_me:$LINENO: result: no" >&5
10470 echo "${ECHO_T}no" >&6
10471 fi
10472
10473     fi
10474     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10475   done
10476 fi
10477
10478 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10479   set dummy objdump
10480   if test $build = $target ; then
10481     OBJDUMP_FOR_TARGET="$2"
10482   else
10483     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10484   fi
10485 else
10486   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10487 fi
10488
10489 else
10490   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10491 fi
10492
10493
10494
10495
10496 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10497   if test -n "$with_build_time_tools"; then
10498     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10499 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10500     if test -x $with_build_time_tools/ranlib; then
10501       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10502       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10503       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10504 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10505     else
10506       echo "$as_me:$LINENO: result: no" >&5
10507 echo "${ECHO_T}no" >&6
10508     fi
10509   elif test $build != $host && test $have_gcc_for_target = yes; then
10510     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10511     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10512     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10513   fi
10514 fi
10515 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10516   # Extract the first word of "ranlib", so it can be a program name with args.
10517 set dummy ranlib; ac_word=$2
10518 echo "$as_me:$LINENO: checking for $ac_word" >&5
10519 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10520 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10521   echo $ECHO_N "(cached) $ECHO_C" >&6
10522 else
10523   case $RANLIB_FOR_TARGET in
10524   [\\/]* | ?:[\\/]*)
10525   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10526   ;;
10527   *)
10528   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10529 for as_dir in $gcc_cv_tool_dirs
10530 do
10531   IFS=$as_save_IFS
10532   test -z "$as_dir" && as_dir=.
10533   for ac_exec_ext in '' $ac_executable_extensions; do
10534   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10535     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10536     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10537     break 2
10538   fi
10539 done
10540 done
10541
10542   ;;
10543 esac
10544 fi
10545 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10546
10547 if test -n "$RANLIB_FOR_TARGET"; then
10548   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10549 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10550 else
10551   echo "$as_me:$LINENO: result: no" >&5
10552 echo "${ECHO_T}no" >&6
10553 fi
10554
10555 fi
10556 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10557
10558
10559 if test -n "$RANLIB_FOR_TARGET"; then
10560   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10561 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10562   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10563 fi
10564
10565 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10566   for ncn_progname in ranlib; do
10567     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10568 set dummy ${ncn_progname}; ac_word=$2
10569 echo "$as_me:$LINENO: checking for $ac_word" >&5
10570 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10571 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10572   echo $ECHO_N "(cached) $ECHO_C" >&6
10573 else
10574   if test -n "$RANLIB_FOR_TARGET"; then
10575   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10576 else
10577 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10578 for as_dir in $PATH
10579 do
10580   IFS=$as_save_IFS
10581   test -z "$as_dir" && as_dir=.
10582   for ac_exec_ext in '' $ac_executable_extensions; do
10583   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10584     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10585     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10586     break 2
10587   fi
10588 done
10589 done
10590
10591 fi
10592 fi
10593 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10594 if test -n "$RANLIB_FOR_TARGET"; then
10595   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10596 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10597 else
10598   echo "$as_me:$LINENO: result: no" >&5
10599 echo "${ECHO_T}no" >&6
10600 fi
10601
10602   done
10603 fi
10604
10605 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10606   for ncn_progname in ranlib; do
10607     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10608 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10609     if test -x $with_build_time_tools/${ncn_progname}; then
10610       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10611       echo "$as_me:$LINENO: result: yes" >&5
10612 echo "${ECHO_T}yes" >&6
10613       break
10614     else
10615       echo "$as_me:$LINENO: result: no" >&5
10616 echo "${ECHO_T}no" >&6
10617     fi
10618   done
10619 fi
10620
10621 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10622   for ncn_progname in ranlib; do
10623     if test -n "$ncn_target_tool_prefix"; then
10624       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10625 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10626 echo "$as_me:$LINENO: checking for $ac_word" >&5
10627 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10628 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10629   echo $ECHO_N "(cached) $ECHO_C" >&6
10630 else
10631   if test -n "$RANLIB_FOR_TARGET"; then
10632   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10633 else
10634 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10635 for as_dir in $PATH
10636 do
10637   IFS=$as_save_IFS
10638   test -z "$as_dir" && as_dir=.
10639   for ac_exec_ext in '' $ac_executable_extensions; do
10640   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10641     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10642     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10643     break 2
10644   fi
10645 done
10646 done
10647
10648 fi
10649 fi
10650 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10651 if test -n "$RANLIB_FOR_TARGET"; then
10652   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10653 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10654 else
10655   echo "$as_me:$LINENO: result: no" >&5
10656 echo "${ECHO_T}no" >&6
10657 fi
10658
10659     fi
10660     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10661       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10662 set dummy ${ncn_progname}; ac_word=$2
10663 echo "$as_me:$LINENO: checking for $ac_word" >&5
10664 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10665 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10666   echo $ECHO_N "(cached) $ECHO_C" >&6
10667 else
10668   if test -n "$RANLIB_FOR_TARGET"; then
10669   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10670 else
10671 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10672 for as_dir in $PATH
10673 do
10674   IFS=$as_save_IFS
10675   test -z "$as_dir" && as_dir=.
10676   for ac_exec_ext in '' $ac_executable_extensions; do
10677   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10678     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10679     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10680     break 2
10681   fi
10682 done
10683 done
10684
10685 fi
10686 fi
10687 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10688 if test -n "$RANLIB_FOR_TARGET"; then
10689   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10690 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10691 else
10692   echo "$as_me:$LINENO: result: no" >&5
10693 echo "${ECHO_T}no" >&6
10694 fi
10695
10696     fi
10697     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10698   done
10699 fi
10700
10701 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10702   set dummy ranlib
10703   if test $build = $target ; then
10704     RANLIB_FOR_TARGET="$2"
10705   else
10706     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10707   fi
10708 else
10709   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10710 fi
10711
10712 else
10713   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10714 fi
10715
10716
10717
10718
10719 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10720   if test -n "$with_build_time_tools"; then
10721     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10722 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10723     if test -x $with_build_time_tools/strip; then
10724       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10725       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10726       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10727 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10728     else
10729       echo "$as_me:$LINENO: result: no" >&5
10730 echo "${ECHO_T}no" >&6
10731     fi
10732   elif test $build != $host && test $have_gcc_for_target = yes; then
10733     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10734     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10735     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10736   fi
10737 fi
10738 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10739   # Extract the first word of "strip", so it can be a program name with args.
10740 set dummy strip; ac_word=$2
10741 echo "$as_me:$LINENO: checking for $ac_word" >&5
10742 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10743 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10744   echo $ECHO_N "(cached) $ECHO_C" >&6
10745 else
10746   case $STRIP_FOR_TARGET in
10747   [\\/]* | ?:[\\/]*)
10748   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10749   ;;
10750   *)
10751   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10752 for as_dir in $gcc_cv_tool_dirs
10753 do
10754   IFS=$as_save_IFS
10755   test -z "$as_dir" && as_dir=.
10756   for ac_exec_ext in '' $ac_executable_extensions; do
10757   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10758     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10759     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10760     break 2
10761   fi
10762 done
10763 done
10764
10765   ;;
10766 esac
10767 fi
10768 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10769
10770 if test -n "$STRIP_FOR_TARGET"; then
10771   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10772 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10773 else
10774   echo "$as_me:$LINENO: result: no" >&5
10775 echo "${ECHO_T}no" >&6
10776 fi
10777
10778 fi
10779 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10780
10781
10782 if test -n "$STRIP_FOR_TARGET"; then
10783   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10784 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10785   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10786 fi
10787
10788 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10789   for ncn_progname in strip; do
10790     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10791 set dummy ${ncn_progname}; ac_word=$2
10792 echo "$as_me:$LINENO: checking for $ac_word" >&5
10793 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10794 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10795   echo $ECHO_N "(cached) $ECHO_C" >&6
10796 else
10797   if test -n "$STRIP_FOR_TARGET"; then
10798   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10799 else
10800 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10801 for as_dir in $PATH
10802 do
10803   IFS=$as_save_IFS
10804   test -z "$as_dir" && as_dir=.
10805   for ac_exec_ext in '' $ac_executable_extensions; do
10806   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10807     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10808     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10809     break 2
10810   fi
10811 done
10812 done
10813
10814 fi
10815 fi
10816 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10817 if test -n "$STRIP_FOR_TARGET"; then
10818   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10819 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10820 else
10821   echo "$as_me:$LINENO: result: no" >&5
10822 echo "${ECHO_T}no" >&6
10823 fi
10824
10825   done
10826 fi
10827
10828 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10829   for ncn_progname in strip; do
10830     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10831 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10832     if test -x $with_build_time_tools/${ncn_progname}; then
10833       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10834       echo "$as_me:$LINENO: result: yes" >&5
10835 echo "${ECHO_T}yes" >&6
10836       break
10837     else
10838       echo "$as_me:$LINENO: result: no" >&5
10839 echo "${ECHO_T}no" >&6
10840     fi
10841   done
10842 fi
10843
10844 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10845   for ncn_progname in strip; do
10846     if test -n "$ncn_target_tool_prefix"; then
10847       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10848 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10849 echo "$as_me:$LINENO: checking for $ac_word" >&5
10850 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10851 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10852   echo $ECHO_N "(cached) $ECHO_C" >&6
10853 else
10854   if test -n "$STRIP_FOR_TARGET"; then
10855   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10856 else
10857 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10858 for as_dir in $PATH
10859 do
10860   IFS=$as_save_IFS
10861   test -z "$as_dir" && as_dir=.
10862   for ac_exec_ext in '' $ac_executable_extensions; do
10863   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10864     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10865     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10866     break 2
10867   fi
10868 done
10869 done
10870
10871 fi
10872 fi
10873 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10874 if test -n "$STRIP_FOR_TARGET"; then
10875   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10876 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10877 else
10878   echo "$as_me:$LINENO: result: no" >&5
10879 echo "${ECHO_T}no" >&6
10880 fi
10881
10882     fi
10883     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10884       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10885 set dummy ${ncn_progname}; ac_word=$2
10886 echo "$as_me:$LINENO: checking for $ac_word" >&5
10887 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10888 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10889   echo $ECHO_N "(cached) $ECHO_C" >&6
10890 else
10891   if test -n "$STRIP_FOR_TARGET"; then
10892   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10893 else
10894 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10895 for as_dir in $PATH
10896 do
10897   IFS=$as_save_IFS
10898   test -z "$as_dir" && as_dir=.
10899   for ac_exec_ext in '' $ac_executable_extensions; do
10900   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10901     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10902     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10903     break 2
10904   fi
10905 done
10906 done
10907
10908 fi
10909 fi
10910 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10911 if test -n "$STRIP_FOR_TARGET"; then
10912   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10913 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10914 else
10915   echo "$as_me:$LINENO: result: no" >&5
10916 echo "${ECHO_T}no" >&6
10917 fi
10918
10919     fi
10920     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10921   done
10922 fi
10923
10924 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10925   set dummy strip
10926   if test $build = $target ; then
10927     STRIP_FOR_TARGET="$2"
10928   else
10929     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10930   fi
10931 else
10932   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10933 fi
10934
10935 else
10936   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10937 fi
10938
10939
10940
10941
10942 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10943   if test -n "$with_build_time_tools"; then
10944     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10945 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10946     if test -x $with_build_time_tools/windres; then
10947       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10948       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10949       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10950 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10951     else
10952       echo "$as_me:$LINENO: result: no" >&5
10953 echo "${ECHO_T}no" >&6
10954     fi
10955   elif test $build != $host && test $have_gcc_for_target = yes; then
10956     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10957     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10958     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10959   fi
10960 fi
10961 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10962   # Extract the first word of "windres", so it can be a program name with args.
10963 set dummy windres; ac_word=$2
10964 echo "$as_me:$LINENO: checking for $ac_word" >&5
10965 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10966 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10967   echo $ECHO_N "(cached) $ECHO_C" >&6
10968 else
10969   case $WINDRES_FOR_TARGET in
10970   [\\/]* | ?:[\\/]*)
10971   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10972   ;;
10973   *)
10974   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10975 for as_dir in $gcc_cv_tool_dirs
10976 do
10977   IFS=$as_save_IFS
10978   test -z "$as_dir" && as_dir=.
10979   for ac_exec_ext in '' $ac_executable_extensions; do
10980   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10981     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10982     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10983     break 2
10984   fi
10985 done
10986 done
10987
10988   ;;
10989 esac
10990 fi
10991 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10992
10993 if test -n "$WINDRES_FOR_TARGET"; then
10994   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10995 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10996 else
10997   echo "$as_me:$LINENO: result: no" >&5
10998 echo "${ECHO_T}no" >&6
10999 fi
11000
11001 fi
11002 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11003
11004
11005 if test -n "$WINDRES_FOR_TARGET"; then
11006   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11007 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11008   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11009 fi
11010
11011 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11012   for ncn_progname in windres; do
11013     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11014 set dummy ${ncn_progname}; ac_word=$2
11015 echo "$as_me:$LINENO: checking for $ac_word" >&5
11016 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11017 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11018   echo $ECHO_N "(cached) $ECHO_C" >&6
11019 else
11020   if test -n "$WINDRES_FOR_TARGET"; then
11021   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11022 else
11023 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11024 for as_dir in $PATH
11025 do
11026   IFS=$as_save_IFS
11027   test -z "$as_dir" && as_dir=.
11028   for ac_exec_ext in '' $ac_executable_extensions; do
11029   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11030     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11031     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11032     break 2
11033   fi
11034 done
11035 done
11036
11037 fi
11038 fi
11039 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11040 if test -n "$WINDRES_FOR_TARGET"; then
11041   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11042 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11043 else
11044   echo "$as_me:$LINENO: result: no" >&5
11045 echo "${ECHO_T}no" >&6
11046 fi
11047
11048   done
11049 fi
11050
11051 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11052   for ncn_progname in windres; do
11053     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11054 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11055     if test -x $with_build_time_tools/${ncn_progname}; then
11056       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11057       echo "$as_me:$LINENO: result: yes" >&5
11058 echo "${ECHO_T}yes" >&6
11059       break
11060     else
11061       echo "$as_me:$LINENO: result: no" >&5
11062 echo "${ECHO_T}no" >&6
11063     fi
11064   done
11065 fi
11066
11067 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11068   for ncn_progname in windres; do
11069     if test -n "$ncn_target_tool_prefix"; then
11070       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11071 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11072 echo "$as_me:$LINENO: checking for $ac_word" >&5
11073 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11074 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11075   echo $ECHO_N "(cached) $ECHO_C" >&6
11076 else
11077   if test -n "$WINDRES_FOR_TARGET"; then
11078   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11079 else
11080 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11081 for as_dir in $PATH
11082 do
11083   IFS=$as_save_IFS
11084   test -z "$as_dir" && as_dir=.
11085   for ac_exec_ext in '' $ac_executable_extensions; do
11086   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11087     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11088     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11089     break 2
11090   fi
11091 done
11092 done
11093
11094 fi
11095 fi
11096 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11097 if test -n "$WINDRES_FOR_TARGET"; then
11098   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11099 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11100 else
11101   echo "$as_me:$LINENO: result: no" >&5
11102 echo "${ECHO_T}no" >&6
11103 fi
11104
11105     fi
11106     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11107       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11108 set dummy ${ncn_progname}; ac_word=$2
11109 echo "$as_me:$LINENO: checking for $ac_word" >&5
11110 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11111 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11112   echo $ECHO_N "(cached) $ECHO_C" >&6
11113 else
11114   if test -n "$WINDRES_FOR_TARGET"; then
11115   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11116 else
11117 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11118 for as_dir in $PATH
11119 do
11120   IFS=$as_save_IFS
11121   test -z "$as_dir" && as_dir=.
11122   for ac_exec_ext in '' $ac_executable_extensions; do
11123   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11124     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11125     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11126     break 2
11127   fi
11128 done
11129 done
11130
11131 fi
11132 fi
11133 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11134 if test -n "$WINDRES_FOR_TARGET"; then
11135   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11136 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11137 else
11138   echo "$as_me:$LINENO: result: no" >&5
11139 echo "${ECHO_T}no" >&6
11140 fi
11141
11142     fi
11143     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11144   done
11145 fi
11146
11147 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11148   set dummy windres
11149   if test $build = $target ; then
11150     WINDRES_FOR_TARGET="$2"
11151   else
11152     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11153   fi
11154 else
11155   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11156 fi
11157
11158 else
11159   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11160 fi
11161
11162
11163
11164
11165 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11166   if test -n "$with_build_time_tools"; then
11167     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11168 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11169     if test -x $with_build_time_tools/windmc; then
11170       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11171       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11172       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11173 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11174     else
11175       echo "$as_me:$LINENO: result: no" >&5
11176 echo "${ECHO_T}no" >&6
11177     fi
11178   elif test $build != $host && test $have_gcc_for_target = yes; then
11179     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11180     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11181     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11182   fi
11183 fi
11184 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11185   # Extract the first word of "windmc", so it can be a program name with args.
11186 set dummy windmc; ac_word=$2
11187 echo "$as_me:$LINENO: checking for $ac_word" >&5
11188 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11189 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11190   echo $ECHO_N "(cached) $ECHO_C" >&6
11191 else
11192   case $WINDMC_FOR_TARGET in
11193   [\\/]* | ?:[\\/]*)
11194   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11195   ;;
11196   *)
11197   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11198 for as_dir in $gcc_cv_tool_dirs
11199 do
11200   IFS=$as_save_IFS
11201   test -z "$as_dir" && as_dir=.
11202   for ac_exec_ext in '' $ac_executable_extensions; do
11203   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11204     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11205     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11206     break 2
11207   fi
11208 done
11209 done
11210
11211   ;;
11212 esac
11213 fi
11214 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11215
11216 if test -n "$WINDMC_FOR_TARGET"; then
11217   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11218 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11219 else
11220   echo "$as_me:$LINENO: result: no" >&5
11221 echo "${ECHO_T}no" >&6
11222 fi
11223
11224 fi
11225 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11226
11227
11228 if test -n "$WINDMC_FOR_TARGET"; then
11229   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11230 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11231   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11232 fi
11233
11234 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11235   for ncn_progname in windmc; do
11236     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11237 set dummy ${ncn_progname}; ac_word=$2
11238 echo "$as_me:$LINENO: checking for $ac_word" >&5
11239 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11240 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11241   echo $ECHO_N "(cached) $ECHO_C" >&6
11242 else
11243   if test -n "$WINDMC_FOR_TARGET"; then
11244   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11245 else
11246 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11247 for as_dir in $PATH
11248 do
11249   IFS=$as_save_IFS
11250   test -z "$as_dir" && as_dir=.
11251   for ac_exec_ext in '' $ac_executable_extensions; do
11252   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11253     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11254     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11255     break 2
11256   fi
11257 done
11258 done
11259
11260 fi
11261 fi
11262 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11263 if test -n "$WINDMC_FOR_TARGET"; then
11264   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11265 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11266 else
11267   echo "$as_me:$LINENO: result: no" >&5
11268 echo "${ECHO_T}no" >&6
11269 fi
11270
11271   done
11272 fi
11273
11274 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11275   for ncn_progname in windmc; do
11276     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11277 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11278     if test -x $with_build_time_tools/${ncn_progname}; then
11279       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11280       echo "$as_me:$LINENO: result: yes" >&5
11281 echo "${ECHO_T}yes" >&6
11282       break
11283     else
11284       echo "$as_me:$LINENO: result: no" >&5
11285 echo "${ECHO_T}no" >&6
11286     fi
11287   done
11288 fi
11289
11290 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11291   for ncn_progname in windmc; do
11292     if test -n "$ncn_target_tool_prefix"; then
11293       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11294 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11295 echo "$as_me:$LINENO: checking for $ac_word" >&5
11296 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11297 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11298   echo $ECHO_N "(cached) $ECHO_C" >&6
11299 else
11300   if test -n "$WINDMC_FOR_TARGET"; then
11301   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11302 else
11303 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11304 for as_dir in $PATH
11305 do
11306   IFS=$as_save_IFS
11307   test -z "$as_dir" && as_dir=.
11308   for ac_exec_ext in '' $ac_executable_extensions; do
11309   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11310     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11311     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11312     break 2
11313   fi
11314 done
11315 done
11316
11317 fi
11318 fi
11319 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11320 if test -n "$WINDMC_FOR_TARGET"; then
11321   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11322 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11323 else
11324   echo "$as_me:$LINENO: result: no" >&5
11325 echo "${ECHO_T}no" >&6
11326 fi
11327
11328     fi
11329     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11330       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11331 set dummy ${ncn_progname}; ac_word=$2
11332 echo "$as_me:$LINENO: checking for $ac_word" >&5
11333 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11334 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11335   echo $ECHO_N "(cached) $ECHO_C" >&6
11336 else
11337   if test -n "$WINDMC_FOR_TARGET"; then
11338   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11339 else
11340 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11341 for as_dir in $PATH
11342 do
11343   IFS=$as_save_IFS
11344   test -z "$as_dir" && as_dir=.
11345   for ac_exec_ext in '' $ac_executable_extensions; do
11346   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11347     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11348     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11349     break 2
11350   fi
11351 done
11352 done
11353
11354 fi
11355 fi
11356 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11357 if test -n "$WINDMC_FOR_TARGET"; then
11358   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11359 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11360 else
11361   echo "$as_me:$LINENO: result: no" >&5
11362 echo "${ECHO_T}no" >&6
11363 fi
11364
11365     fi
11366     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11367   done
11368 fi
11369
11370 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11371   set dummy windmc
11372   if test $build = $target ; then
11373     WINDMC_FOR_TARGET="$2"
11374   else
11375     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11376   fi
11377 else
11378   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11379 fi
11380
11381 else
11382   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11383 fi
11384
11385
11386 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11387
11388 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11389 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11390 if test "x${build}" != "x${host}" ; then
11391   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11392     # We already found the complete path
11393     ac_dir=`dirname $AR_FOR_TARGET`
11394     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11395 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11396   else
11397     # Canadian cross, just use what we found
11398     echo "$as_me:$LINENO: result: pre-installed" >&5
11399 echo "${ECHO_T}pre-installed" >&6
11400   fi
11401 else
11402   ok=yes
11403   case " ${configdirs} " in
11404     *" binutils "*) ;;
11405     *) ok=no ;;
11406   esac
11407
11408   if test $ok = yes; then
11409     # An in-tree tool is available and we can use it
11410     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11411     echo "$as_me:$LINENO: result: just compiled" >&5
11412 echo "${ECHO_T}just compiled" >&6
11413   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11414     # We already found the complete path
11415     ac_dir=`dirname $AR_FOR_TARGET`
11416     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11417 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11418   elif test "x$target" = "x$host"; then
11419     # We can use an host tool
11420     AR_FOR_TARGET='$(AR)'
11421     echo "$as_me:$LINENO: result: host tool" >&5
11422 echo "${ECHO_T}host tool" >&6
11423   else
11424     # We need a cross tool
11425     echo "$as_me:$LINENO: result: pre-installed" >&5
11426 echo "${ECHO_T}pre-installed" >&6
11427   fi
11428 fi
11429
11430 echo "$as_me:$LINENO: checking where to find the target as" >&5
11431 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11432 if test "x${build}" != "x${host}" ; then
11433   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11434     # We already found the complete path
11435     ac_dir=`dirname $AS_FOR_TARGET`
11436     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11437 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11438   else
11439     # Canadian cross, just use what we found
11440     echo "$as_me:$LINENO: result: pre-installed" >&5
11441 echo "${ECHO_T}pre-installed" >&6
11442   fi
11443 else
11444   ok=yes
11445   case " ${configdirs} " in
11446     *" gas "*) ;;
11447     *) ok=no ;;
11448   esac
11449
11450   if test $ok = yes; then
11451     # An in-tree tool is available and we can use it
11452     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11453     echo "$as_me:$LINENO: result: just compiled" >&5
11454 echo "${ECHO_T}just compiled" >&6
11455   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11456     # We already found the complete path
11457     ac_dir=`dirname $AS_FOR_TARGET`
11458     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11459 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11460   elif test "x$target" = "x$host"; then
11461     # We can use an host tool
11462     AS_FOR_TARGET='$(AS)'
11463     echo "$as_me:$LINENO: result: host tool" >&5
11464 echo "${ECHO_T}host tool" >&6
11465   else
11466     # We need a cross tool
11467     echo "$as_me:$LINENO: result: pre-installed" >&5
11468 echo "${ECHO_T}pre-installed" >&6
11469   fi
11470 fi
11471
11472 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11473 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11474 if test "x${build}" != "x${host}" ; then
11475   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11476     # We already found the complete path
11477     ac_dir=`dirname $CC_FOR_TARGET`
11478     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11479 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11480   else
11481     # Canadian cross, just use what we found
11482     echo "$as_me:$LINENO: result: pre-installed" >&5
11483 echo "${ECHO_T}pre-installed" >&6
11484   fi
11485 else
11486   ok=yes
11487   case " ${configdirs} " in
11488     *" gcc "*) ;;
11489     *) ok=no ;;
11490   esac
11491
11492   if test $ok = yes; then
11493     # An in-tree tool is available and we can use it
11494     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11495     echo "$as_me:$LINENO: result: just compiled" >&5
11496 echo "${ECHO_T}just compiled" >&6
11497   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11498     # We already found the complete path
11499     ac_dir=`dirname $CC_FOR_TARGET`
11500     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11501 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11502   elif test "x$target" = "x$host"; then
11503     # We can use an host tool
11504     CC_FOR_TARGET='$(CC)'
11505     echo "$as_me:$LINENO: result: host tool" >&5
11506 echo "${ECHO_T}host tool" >&6
11507   else
11508     # We need a cross tool
11509     echo "$as_me:$LINENO: result: pre-installed" >&5
11510 echo "${ECHO_T}pre-installed" >&6
11511   fi
11512 fi
11513
11514 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11515 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11516 if test "x${build}" != "x${host}" ; then
11517   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11518     # We already found the complete path
11519     ac_dir=`dirname $CXX_FOR_TARGET`
11520     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11521 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11522   else
11523     # Canadian cross, just use what we found
11524     echo "$as_me:$LINENO: result: pre-installed" >&5
11525 echo "${ECHO_T}pre-installed" >&6
11526   fi
11527 else
11528   ok=yes
11529   case " ${configdirs} " in
11530     *" gcc "*) ;;
11531     *) ok=no ;;
11532   esac
11533   case ,${enable_languages}, in
11534     *,c++,*) ;;
11535     *) ok=no ;;
11536   esac
11537   if test $ok = yes; then
11538     # An in-tree tool is available and we can use it
11539     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'
11540     echo "$as_me:$LINENO: result: just compiled" >&5
11541 echo "${ECHO_T}just compiled" >&6
11542   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11543     # We already found the complete path
11544     ac_dir=`dirname $CXX_FOR_TARGET`
11545     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11546 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11547   elif test "x$target" = "x$host"; then
11548     # We can use an host tool
11549     CXX_FOR_TARGET='$(CXX)'
11550     echo "$as_me:$LINENO: result: host tool" >&5
11551 echo "${ECHO_T}host tool" >&6
11552   else
11553     # We need a cross tool
11554     echo "$as_me:$LINENO: result: pre-installed" >&5
11555 echo "${ECHO_T}pre-installed" >&6
11556   fi
11557 fi
11558
11559 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11560 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11561 if test "x${build}" != "x${host}" ; then
11562   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11563     # We already found the complete path
11564     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11565     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11566 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11567   else
11568     # Canadian cross, just use what we found
11569     echo "$as_me:$LINENO: result: pre-installed" >&5
11570 echo "${ECHO_T}pre-installed" >&6
11571   fi
11572 else
11573   ok=yes
11574   case " ${configdirs} " in
11575     *" gcc "*) ;;
11576     *) ok=no ;;
11577   esac
11578   case ,${enable_languages}, in
11579     *,c++,*) ;;
11580     *) ok=no ;;
11581   esac
11582   if test $ok = yes; then
11583     # An in-tree tool is available and we can use it
11584     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'
11585     echo "$as_me:$LINENO: result: just compiled" >&5
11586 echo "${ECHO_T}just compiled" >&6
11587   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11588     # We already found the complete path
11589     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11590     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11591 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11592   elif test "x$target" = "x$host"; then
11593     # We can use an host tool
11594     RAW_CXX_FOR_TARGET='$(CXX)'
11595     echo "$as_me:$LINENO: result: host tool" >&5
11596 echo "${ECHO_T}host tool" >&6
11597   else
11598     # We need a cross tool
11599     echo "$as_me:$LINENO: result: pre-installed" >&5
11600 echo "${ECHO_T}pre-installed" >&6
11601   fi
11602 fi
11603
11604 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11605 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11606 if test "x${build}" != "x${host}" ; then
11607   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11608     # We already found the complete path
11609     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11610     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11611 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11612   else
11613     # Canadian cross, just use what we found
11614     echo "$as_me:$LINENO: result: pre-installed" >&5
11615 echo "${ECHO_T}pre-installed" >&6
11616   fi
11617 else
11618   ok=yes
11619   case " ${configdirs} " in
11620     *" binutils "*) ;;
11621     *) ok=no ;;
11622   esac
11623
11624   if test $ok = yes; then
11625     # An in-tree tool is available and we can use it
11626     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11627     echo "$as_me:$LINENO: result: just compiled" >&5
11628 echo "${ECHO_T}just compiled" >&6
11629   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11630     # We already found the complete path
11631     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11632     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11633 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11634   elif test "x$target" = "x$host"; then
11635     # We can use an host tool
11636     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11637     echo "$as_me:$LINENO: result: host tool" >&5
11638 echo "${ECHO_T}host tool" >&6
11639   else
11640     # We need a cross tool
11641     echo "$as_me:$LINENO: result: pre-installed" >&5
11642 echo "${ECHO_T}pre-installed" >&6
11643   fi
11644 fi
11645
11646 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11647 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11648 if test "x${build}" != "x${host}" ; then
11649   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11650     # We already found the complete path
11651     ac_dir=`dirname $GCC_FOR_TARGET`
11652     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11653 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11654   else
11655     # Canadian cross, just use what we found
11656     echo "$as_me:$LINENO: result: pre-installed" >&5
11657 echo "${ECHO_T}pre-installed" >&6
11658   fi
11659 else
11660   ok=yes
11661   case " ${configdirs} " in
11662     *" gcc "*) ;;
11663     *) ok=no ;;
11664   esac
11665
11666   if test $ok = yes; then
11667     # An in-tree tool is available and we can use it
11668     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11669     echo "$as_me:$LINENO: result: just compiled" >&5
11670 echo "${ECHO_T}just compiled" >&6
11671   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11672     # We already found the complete path
11673     ac_dir=`dirname $GCC_FOR_TARGET`
11674     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11675 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11676   elif test "x$target" = "x$host"; then
11677     # We can use an host tool
11678     GCC_FOR_TARGET='$()'
11679     echo "$as_me:$LINENO: result: host tool" >&5
11680 echo "${ECHO_T}host tool" >&6
11681   else
11682     # We need a cross tool
11683     echo "$as_me:$LINENO: result: pre-installed" >&5
11684 echo "${ECHO_T}pre-installed" >&6
11685   fi
11686 fi
11687
11688 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11689 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11690 if test "x${build}" != "x${host}" ; then
11691   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11692     # We already found the complete path
11693     ac_dir=`dirname $GCJ_FOR_TARGET`
11694     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11695 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11696   else
11697     # Canadian cross, just use what we found
11698     echo "$as_me:$LINENO: result: pre-installed" >&5
11699 echo "${ECHO_T}pre-installed" >&6
11700   fi
11701 else
11702   ok=yes
11703   case " ${configdirs} " in
11704     *" gcc "*) ;;
11705     *) ok=no ;;
11706   esac
11707   case ,${enable_languages}, in
11708     *,java,*) ;;
11709     *) ok=no ;;
11710   esac
11711   if test $ok = yes; then
11712     # An in-tree tool is available and we can use it
11713     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11714     echo "$as_me:$LINENO: result: just compiled" >&5
11715 echo "${ECHO_T}just compiled" >&6
11716   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11717     # We already found the complete path
11718     ac_dir=`dirname $GCJ_FOR_TARGET`
11719     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11720 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11721   elif test "x$target" = "x$host"; then
11722     # We can use an host tool
11723     GCJ_FOR_TARGET='$(GCJ)'
11724     echo "$as_me:$LINENO: result: host tool" >&5
11725 echo "${ECHO_T}host tool" >&6
11726   else
11727     # We need a cross tool
11728     echo "$as_me:$LINENO: result: pre-installed" >&5
11729 echo "${ECHO_T}pre-installed" >&6
11730   fi
11731 fi
11732
11733 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11734 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11735 if test "x${build}" != "x${host}" ; then
11736   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11737     # We already found the complete path
11738     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11739     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11740 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11741   else
11742     # Canadian cross, just use what we found
11743     echo "$as_me:$LINENO: result: pre-installed" >&5
11744 echo "${ECHO_T}pre-installed" >&6
11745   fi
11746 else
11747   ok=yes
11748   case " ${configdirs} " in
11749     *" gcc "*) ;;
11750     *) ok=no ;;
11751   esac
11752   case ,${enable_languages}, in
11753     *,fortran,*) ;;
11754     *) ok=no ;;
11755   esac
11756   if test $ok = yes; then
11757     # An in-tree tool is available and we can use it
11758     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11759     echo "$as_me:$LINENO: result: just compiled" >&5
11760 echo "${ECHO_T}just compiled" >&6
11761   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11762     # We already found the complete path
11763     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11764     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11765 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11766   elif test "x$target" = "x$host"; then
11767     # We can use an host tool
11768     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11769     echo "$as_me:$LINENO: result: host tool" >&5
11770 echo "${ECHO_T}host tool" >&6
11771   else
11772     # We need a cross tool
11773     echo "$as_me:$LINENO: result: pre-installed" >&5
11774 echo "${ECHO_T}pre-installed" >&6
11775   fi
11776 fi
11777
11778 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11779 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11780 if test "x${build}" != "x${host}" ; then
11781   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11782     # We already found the complete path
11783     ac_dir=`dirname $LD_FOR_TARGET`
11784     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11785 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11786   else
11787     # Canadian cross, just use what we found
11788     echo "$as_me:$LINENO: result: pre-installed" >&5
11789 echo "${ECHO_T}pre-installed" >&6
11790   fi
11791 else
11792   ok=yes
11793   case " ${configdirs} " in
11794     *" ld "*) ;;
11795     *) ok=no ;;
11796   esac
11797
11798   if test $ok = yes; then
11799     # An in-tree tool is available and we can use it
11800     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11801     echo "$as_me:$LINENO: result: just compiled" >&5
11802 echo "${ECHO_T}just compiled" >&6
11803   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11804     # We already found the complete path
11805     ac_dir=`dirname $LD_FOR_TARGET`
11806     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11807 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11808   elif test "x$target" = "x$host"; then
11809     # We can use an host tool
11810     LD_FOR_TARGET='$(LD)'
11811     echo "$as_me:$LINENO: result: host tool" >&5
11812 echo "${ECHO_T}host tool" >&6
11813   else
11814     # We need a cross tool
11815     echo "$as_me:$LINENO: result: pre-installed" >&5
11816 echo "${ECHO_T}pre-installed" >&6
11817   fi
11818 fi
11819
11820 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11821 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11822 if test "x${build}" != "x${host}" ; then
11823   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11824     # We already found the complete path
11825     ac_dir=`dirname $LIPO_FOR_TARGET`
11826     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11827 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11828   else
11829     # Canadian cross, just use what we found
11830     echo "$as_me:$LINENO: result: pre-installed" >&5
11831 echo "${ECHO_T}pre-installed" >&6
11832   fi
11833 else
11834   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11835     # We already found the complete path
11836     ac_dir=`dirname $LIPO_FOR_TARGET`
11837     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11838 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11839   elif test "x$target" = "x$host"; then
11840     # We can use an host tool
11841     LIPO_FOR_TARGET='$(LIPO)'
11842     echo "$as_me:$LINENO: result: host tool" >&5
11843 echo "${ECHO_T}host tool" >&6
11844   else
11845     # We need a cross tool
11846     echo "$as_me:$LINENO: result: pre-installed" >&5
11847 echo "${ECHO_T}pre-installed" >&6
11848   fi
11849 fi
11850
11851 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11852 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11853 if test "x${build}" != "x${host}" ; then
11854   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11855     # We already found the complete path
11856     ac_dir=`dirname $NM_FOR_TARGET`
11857     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11858 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11859   else
11860     # Canadian cross, just use what we found
11861     echo "$as_me:$LINENO: result: pre-installed" >&5
11862 echo "${ECHO_T}pre-installed" >&6
11863   fi
11864 else
11865   ok=yes
11866   case " ${configdirs} " in
11867     *" binutils "*) ;;
11868     *) ok=no ;;
11869   esac
11870
11871   if test $ok = yes; then
11872     # An in-tree tool is available and we can use it
11873     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11874     echo "$as_me:$LINENO: result: just compiled" >&5
11875 echo "${ECHO_T}just compiled" >&6
11876   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11877     # We already found the complete path
11878     ac_dir=`dirname $NM_FOR_TARGET`
11879     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11880 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11881   elif test "x$target" = "x$host"; then
11882     # We can use an host tool
11883     NM_FOR_TARGET='$(NM)'
11884     echo "$as_me:$LINENO: result: host tool" >&5
11885 echo "${ECHO_T}host tool" >&6
11886   else
11887     # We need a cross tool
11888     echo "$as_me:$LINENO: result: pre-installed" >&5
11889 echo "${ECHO_T}pre-installed" >&6
11890   fi
11891 fi
11892
11893 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11894 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11895 if test "x${build}" != "x${host}" ; then
11896   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11897     # We already found the complete path
11898     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11899     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11900 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11901   else
11902     # Canadian cross, just use what we found
11903     echo "$as_me:$LINENO: result: pre-installed" >&5
11904 echo "${ECHO_T}pre-installed" >&6
11905   fi
11906 else
11907   ok=yes
11908   case " ${configdirs} " in
11909     *" binutils "*) ;;
11910     *) ok=no ;;
11911   esac
11912
11913   if test $ok = yes; then
11914     # An in-tree tool is available and we can use it
11915     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11916     echo "$as_me:$LINENO: result: just compiled" >&5
11917 echo "${ECHO_T}just compiled" >&6
11918   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11919     # We already found the complete path
11920     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11921     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11922 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11923   elif test "x$target" = "x$host"; then
11924     # We can use an host tool
11925     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11926     echo "$as_me:$LINENO: result: host tool" >&5
11927 echo "${ECHO_T}host tool" >&6
11928   else
11929     # We need a cross tool
11930     echo "$as_me:$LINENO: result: pre-installed" >&5
11931 echo "${ECHO_T}pre-installed" >&6
11932   fi
11933 fi
11934
11935 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11936 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11937 if test "x${build}" != "x${host}" ; then
11938   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11939     # We already found the complete path
11940     ac_dir=`dirname $RANLIB_FOR_TARGET`
11941     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11942 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11943   else
11944     # Canadian cross, just use what we found
11945     echo "$as_me:$LINENO: result: pre-installed" >&5
11946 echo "${ECHO_T}pre-installed" >&6
11947   fi
11948 else
11949   ok=yes
11950   case " ${configdirs} " in
11951     *" binutils "*) ;;
11952     *) ok=no ;;
11953   esac
11954
11955   if test $ok = yes; then
11956     # An in-tree tool is available and we can use it
11957     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11958     echo "$as_me:$LINENO: result: just compiled" >&5
11959 echo "${ECHO_T}just compiled" >&6
11960   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11961     # We already found the complete path
11962     ac_dir=`dirname $RANLIB_FOR_TARGET`
11963     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11964 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11965   elif test "x$target" = "x$host"; then
11966     # We can use an host tool
11967     RANLIB_FOR_TARGET='$(RANLIB)'
11968     echo "$as_me:$LINENO: result: host tool" >&5
11969 echo "${ECHO_T}host tool" >&6
11970   else
11971     # We need a cross tool
11972     echo "$as_me:$LINENO: result: pre-installed" >&5
11973 echo "${ECHO_T}pre-installed" >&6
11974   fi
11975 fi
11976
11977 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11978 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11979 if test "x${build}" != "x${host}" ; then
11980   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11981     # We already found the complete path
11982     ac_dir=`dirname $STRIP_FOR_TARGET`
11983     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11984 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11985   else
11986     # Canadian cross, just use what we found
11987     echo "$as_me:$LINENO: result: pre-installed" >&5
11988 echo "${ECHO_T}pre-installed" >&6
11989   fi
11990 else
11991   ok=yes
11992   case " ${configdirs} " in
11993     *" binutils "*) ;;
11994     *) ok=no ;;
11995   esac
11996
11997   if test $ok = yes; then
11998     # An in-tree tool is available and we can use it
11999     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12000     echo "$as_me:$LINENO: result: just compiled" >&5
12001 echo "${ECHO_T}just compiled" >&6
12002   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12003     # We already found the complete path
12004     ac_dir=`dirname $STRIP_FOR_TARGET`
12005     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12006 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12007   elif test "x$target" = "x$host"; then
12008     # We can use an host tool
12009     STRIP_FOR_TARGET='$(STRIP)'
12010     echo "$as_me:$LINENO: result: host tool" >&5
12011 echo "${ECHO_T}host tool" >&6
12012   else
12013     # We need a cross tool
12014     echo "$as_me:$LINENO: result: pre-installed" >&5
12015 echo "${ECHO_T}pre-installed" >&6
12016   fi
12017 fi
12018
12019 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12020 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12021 if test "x${build}" != "x${host}" ; then
12022   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12023     # We already found the complete path
12024     ac_dir=`dirname $WINDRES_FOR_TARGET`
12025     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12026 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12027   else
12028     # Canadian cross, just use what we found
12029     echo "$as_me:$LINENO: result: pre-installed" >&5
12030 echo "${ECHO_T}pre-installed" >&6
12031   fi
12032 else
12033   ok=yes
12034   case " ${configdirs} " in
12035     *" binutils "*) ;;
12036     *) ok=no ;;
12037   esac
12038
12039   if test $ok = yes; then
12040     # An in-tree tool is available and we can use it
12041     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12042     echo "$as_me:$LINENO: result: just compiled" >&5
12043 echo "${ECHO_T}just compiled" >&6
12044   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12045     # We already found the complete path
12046     ac_dir=`dirname $WINDRES_FOR_TARGET`
12047     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12048 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12049   elif test "x$target" = "x$host"; then
12050     # We can use an host tool
12051     WINDRES_FOR_TARGET='$(WINDRES)'
12052     echo "$as_me:$LINENO: result: host tool" >&5
12053 echo "${ECHO_T}host tool" >&6
12054   else
12055     # We need a cross tool
12056     echo "$as_me:$LINENO: result: pre-installed" >&5
12057 echo "${ECHO_T}pre-installed" >&6
12058   fi
12059 fi
12060
12061 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12062 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12063 if test "x${build}" != "x${host}" ; then
12064   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12065     # We already found the complete path
12066     ac_dir=`dirname $WINDMC_FOR_TARGET`
12067     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12068 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12069   else
12070     # Canadian cross, just use what we found
12071     echo "$as_me:$LINENO: result: pre-installed" >&5
12072 echo "${ECHO_T}pre-installed" >&6
12073   fi
12074 else
12075   ok=yes
12076   case " ${configdirs} " in
12077     *" binutils "*) ;;
12078     *) ok=no ;;
12079   esac
12080
12081   if test $ok = yes; then
12082     # An in-tree tool is available and we can use it
12083     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12084     echo "$as_me:$LINENO: result: just compiled" >&5
12085 echo "${ECHO_T}just compiled" >&6
12086   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12087     # We already found the complete path
12088     ac_dir=`dirname $WINDMC_FOR_TARGET`
12089     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12090 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12091   elif test "x$target" = "x$host"; then
12092     # We can use an host tool
12093     WINDMC_FOR_TARGET='$(WINDMC)'
12094     echo "$as_me:$LINENO: result: host tool" >&5
12095 echo "${ECHO_T}host tool" >&6
12096   else
12097     # We need a cross tool
12098     echo "$as_me:$LINENO: result: pre-installed" >&5
12099 echo "${ECHO_T}pre-installed" >&6
12100   fi
12101 fi
12102
12103
12104
12105
12106
12107 # Certain tools may need extra flags.
12108 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12109 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12110 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12111
12112 # When building target libraries, except in a Canadian cross, we use
12113 # the same toolchain as the compiler we just built.
12114 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12115 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12116 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12117 if test $host = $build; then
12118   case " $configdirs " in
12119     *" gcc "*)
12120       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12121       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12122       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12123       ;;
12124   esac
12125 fi
12126
12127
12128
12129
12130
12131 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12132 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12133 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12134 if test "${enable_maintainer_mode+set}" = set; then
12135   enableval="$enable_maintainer_mode"
12136   USE_MAINTAINER_MODE=$enableval
12137 else
12138   USE_MAINTAINER_MODE=no
12139 fi;
12140 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12141 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12142
12143
12144 if test "$USE_MAINTAINER_MODE" = yes; then
12145   MAINTAINER_MODE_TRUE=
12146   MAINTAINER_MODE_FALSE='#'
12147 else
12148   MAINTAINER_MODE_TRUE='#'
12149   MAINTAINER_MODE_FALSE=
12150 fi
12151 MAINT=$MAINTAINER_MODE_TRUE
12152
12153 # ---------------------
12154 # GCC bootstrap support
12155 # ---------------------
12156
12157 # Stage specific cflags for build.
12158 stage1_cflags="-g"
12159 case $build in
12160   vax-*-*)
12161     case ${GCC} in
12162       yes) stage1_cflags="-g -Wa,-J" ;;
12163       *) stage1_cflags="-g -J" ;;
12164     esac ;;
12165 esac
12166
12167 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12168 if test "$GCC" = yes; then
12169   saved_CFLAGS="$CFLAGS"
12170
12171   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12172   CFLAGS="$CFLAGS -fkeep-inline-functions"
12173   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12174 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12175   cat >conftest.$ac_ext <<_ACEOF
12176 /* confdefs.h.  */
12177 _ACEOF
12178 cat confdefs.h >>conftest.$ac_ext
12179 cat >>conftest.$ac_ext <<_ACEOF
12180 /* end confdefs.h.  */
12181
12182 #if (__GNUC__ < 3) \
12183     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12184                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12185 #error http://gcc.gnu.org/PR29382
12186 #endif
12187
12188 int
12189 main ()
12190 {
12191
12192   ;
12193   return 0;
12194 }
12195 _ACEOF
12196 rm -f conftest.$ac_objext
12197 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12198   (eval $ac_compile) 2>conftest.er1
12199   ac_status=$?
12200   grep -v '^ *+' conftest.er1 >conftest.err
12201   rm -f conftest.er1
12202   cat conftest.err >&5
12203   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12204   (exit $ac_status); } &&
12205          { ac_try='test -z "$ac_c_werror_flag"
12206                          || test ! -s conftest.err'
12207   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12208   (eval $ac_try) 2>&5
12209   ac_status=$?
12210   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12211   (exit $ac_status); }; } &&
12212          { ac_try='test -s conftest.$ac_objext'
12213   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12214   (eval $ac_try) 2>&5
12215   ac_status=$?
12216   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12217   (exit $ac_status); }; }; then
12218   echo "$as_me:$LINENO: result: yes" >&5
12219 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12220 else
12221   echo "$as_me: failed program was:" >&5
12222 sed 's/^/| /' conftest.$ac_ext >&5
12223
12224 echo "$as_me:$LINENO: result: no" >&5
12225 echo "${ECHO_T}no" >&6
12226 fi
12227 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12228
12229   CFLAGS="$saved_CFLAGS"
12230 fi
12231
12232
12233
12234 # Enable --enable-checking in stage1 of the compiler.
12235 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12236 if test "${enable_stage1_checking+set}" = set; then
12237   enableval="$enable_stage1_checking"
12238   stage1_checking=--enable-checking=${enable_stage1_checking}
12239 else
12240   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12241   stage1_checking=--enable-checking=yes,types
12242 else
12243   stage1_checking=--enable-checking=$enable_checking,types
12244 fi
12245 fi;
12246
12247
12248 # Enable -Werror in bootstrap stage2 and later.
12249 # Check whether --enable-werror or --disable-werror was given.
12250 if test "${enable_werror+set}" = set; then
12251   enableval="$enable_werror"
12252
12253 else
12254   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12255   enable_werror=yes
12256 else
12257   enable_werror=no
12258 fi
12259 fi;
12260 case ${enable_werror} in
12261   yes) stage2_werror_flag="--enable-werror-always" ;;
12262   *) stage2_werror_flag="" ;;
12263 esac
12264
12265
12266 # Flags needed to enable html installing and building
12267
12268 # Check whether --with-datarootdir or --without-datarootdir was given.
12269 if test "${with_datarootdir+set}" = set; then
12270   withval="$with_datarootdir"
12271   datarootdir="\${prefix}/${withval}"
12272 else
12273   datarootdir="\${prefix}/share"
12274 fi;
12275
12276
12277 # Check whether --with-docdir or --without-docdir was given.
12278 if test "${with_docdir+set}" = set; then
12279   withval="$with_docdir"
12280   docdir="\${prefix}/${withval}"
12281 else
12282   docdir="\${datarootdir}/doc"
12283 fi;
12284
12285
12286 # Check whether --with-pdfdir or --without-pdfdir was given.
12287 if test "${with_pdfdir+set}" = set; then
12288   withval="$with_pdfdir"
12289   pdfdir="\${prefix}/${withval}"
12290 else
12291   pdfdir="\${docdir}"
12292 fi;
12293
12294
12295 # Check whether --with-htmldir or --without-htmldir was given.
12296 if test "${with_htmldir+set}" = set; then
12297   withval="$with_htmldir"
12298   htmldir="\${prefix}/${withval}"
12299 else
12300   htmldir="\${docdir}"
12301 fi;
12302
12303
12304
12305
12306
12307
12308           ac_config_files="$ac_config_files Makefile"
12309 cat >confcache <<\_ACEOF
12310 # This file is a shell script that caches the results of configure
12311 # tests run on this system so they can be shared between configure
12312 # scripts and configure runs, see configure's option --config-cache.
12313 # It is not useful on other systems.  If it contains results you don't
12314 # want to keep, you may remove or edit it.
12315 #
12316 # config.status only pays attention to the cache file if you give it
12317 # the --recheck option to rerun configure.
12318 #
12319 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12320 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12321 # following values.
12322
12323 _ACEOF
12324
12325 # The following way of writing the cache mishandles newlines in values,
12326 # but we know of no workaround that is simple, portable, and efficient.
12327 # So, don't put newlines in cache variables' values.
12328 # Ultrix sh set writes to stderr and can't be redirected directly,
12329 # and sets the high bit in the cache file unless we assign to the vars.
12330 {
12331   (set) 2>&1 |
12332     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12333     *ac_space=\ *)
12334       # `set' does not quote correctly, so add quotes (double-quote
12335       # substitution turns \\\\ into \\, and sed turns \\ into \).
12336       sed -n \
12337         "s/'/'\\\\''/g;
12338           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12339       ;;
12340     *)
12341       # `set' quotes correctly as required by POSIX, so do not add quotes.
12342       sed -n \
12343         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12344       ;;
12345     esac;
12346 } |
12347   sed '
12348      t clear
12349      : clear
12350      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12351      t end
12352      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12353      : end' >>confcache
12354 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12355   if test -w $cache_file; then
12356     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12357     cat confcache >$cache_file
12358   else
12359     echo "not updating unwritable cache $cache_file"
12360   fi
12361 fi
12362 rm -f confcache
12363
12364 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12365 # Let make expand exec_prefix.
12366 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12367
12368 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12369 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12370 # trailing colons and then remove the whole line if VPATH becomes empty
12371 # (actually we leave an empty line to preserve line numbers).
12372 if test "x$srcdir" = x.; then
12373   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12374 s/:*\$(srcdir):*/:/;
12375 s/:*\${srcdir}:*/:/;
12376 s/:*@srcdir@:*/:/;
12377 s/^\([^=]*=[     ]*\):*/\1/;
12378 s/:*$//;
12379 s/^[^=]*=[       ]*$//;
12380 }'
12381 fi
12382
12383 # Transform confdefs.h into DEFS.
12384 # Protect against shell expansion while executing Makefile rules.
12385 # Protect against Makefile macro expansion.
12386 #
12387 # If the first sed substitution is executed (which looks for macros that
12388 # take arguments), then we branch to the quote section.  Otherwise,
12389 # look for a macro that doesn't take arguments.
12390 cat >confdef2opt.sed <<\_ACEOF
12391 t clear
12392 : clear
12393 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12394 t quote
12395 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12396 t quote
12397 d
12398 : quote
12399 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12400 s,\[,\\&,g
12401 s,\],\\&,g
12402 s,\$,$$,g
12403 p
12404 _ACEOF
12405 # We use echo to avoid assuming a particular line-breaking character.
12406 # The extra dot is to prevent the shell from consuming trailing
12407 # line-breaks from the sub-command output.  A line-break within
12408 # single-quotes doesn't work because, if this script is created in a
12409 # platform that uses two characters for line-breaks (e.g., DOS), tr
12410 # would break.
12411 ac_LF_and_DOT=`echo; echo .`
12412 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12413 rm -f confdef2opt.sed
12414
12415
12416 ac_libobjs=
12417 ac_ltlibobjs=
12418 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12419   # 1. Remove the extension, and $U if already installed.
12420   ac_i=`echo "$ac_i" |
12421          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12422   # 2. Add them.
12423   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12424   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12425 done
12426 LIBOBJS=$ac_libobjs
12427
12428 LTLIBOBJS=$ac_ltlibobjs
12429
12430
12431
12432 : ${CONFIG_STATUS=./config.status}
12433 ac_clean_files_save=$ac_clean_files
12434 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12435 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12436 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12437 cat >$CONFIG_STATUS <<_ACEOF
12438 #! $SHELL
12439 # Generated by $as_me.
12440 # Run this file to recreate the current configuration.
12441 # Compiler output produced by configure, useful for debugging
12442 # configure, is in config.log if it exists.
12443
12444 debug=false
12445 ac_cs_recheck=false
12446 ac_cs_silent=false
12447 SHELL=\${CONFIG_SHELL-$SHELL}
12448 _ACEOF
12449
12450 cat >>$CONFIG_STATUS <<\_ACEOF
12451 ## --------------------- ##
12452 ## M4sh Initialization.  ##
12453 ## --------------------- ##
12454
12455 # Be Bourne compatible
12456 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12457   emulate sh
12458   NULLCMD=:
12459   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12460   # is contrary to our usage.  Disable this feature.
12461   alias -g '${1+"$@"}'='"$@"'
12462 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12463   set -o posix
12464 fi
12465 DUALCASE=1; export DUALCASE # for MKS sh
12466
12467 # Support unset when possible.
12468 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12469   as_unset=unset
12470 else
12471   as_unset=false
12472 fi
12473
12474
12475 # Work around bugs in pre-3.0 UWIN ksh.
12476 $as_unset ENV MAIL MAILPATH
12477 PS1='$ '
12478 PS2='> '
12479 PS4='+ '
12480
12481 # NLS nuisances.
12482 for as_var in \
12483   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12484   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12485   LC_TELEPHONE LC_TIME
12486 do
12487   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12488     eval $as_var=C; export $as_var
12489   else
12490     $as_unset $as_var
12491   fi
12492 done
12493
12494 # Required to use basename.
12495 if expr a : '\(a\)' >/dev/null 2>&1; then
12496   as_expr=expr
12497 else
12498   as_expr=false
12499 fi
12500
12501 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12502   as_basename=basename
12503 else
12504   as_basename=false
12505 fi
12506
12507
12508 # Name of the executable.
12509 as_me=`$as_basename "$0" ||
12510 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12511          X"$0" : 'X\(//\)$' \| \
12512          X"$0" : 'X\(/\)$' \| \
12513          .     : '\(.\)' 2>/dev/null ||
12514 echo X/"$0" |
12515     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12516           /^X\/\(\/\/\)$/{ s//\1/; q; }
12517           /^X\/\(\/\).*/{ s//\1/; q; }
12518           s/.*/./; q'`
12519
12520
12521 # PATH needs CR, and LINENO needs CR and PATH.
12522 # Avoid depending upon Character Ranges.
12523 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12524 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12525 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12526 as_cr_digits='0123456789'
12527 as_cr_alnum=$as_cr_Letters$as_cr_digits
12528
12529 # The user is always right.
12530 if test "${PATH_SEPARATOR+set}" != set; then
12531   echo "#! /bin/sh" >conf$$.sh
12532   echo  "exit 0"   >>conf$$.sh
12533   chmod +x conf$$.sh
12534   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12535     PATH_SEPARATOR=';'
12536   else
12537     PATH_SEPARATOR=:
12538   fi
12539   rm -f conf$$.sh
12540 fi
12541
12542
12543   as_lineno_1=$LINENO
12544   as_lineno_2=$LINENO
12545   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12546   test "x$as_lineno_1" != "x$as_lineno_2" &&
12547   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12548   # Find who we are.  Look in the path if we contain no path at all
12549   # relative or not.
12550   case $0 in
12551     *[\\/]* ) as_myself=$0 ;;
12552     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12553 for as_dir in $PATH
12554 do
12555   IFS=$as_save_IFS
12556   test -z "$as_dir" && as_dir=.
12557   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12558 done
12559
12560        ;;
12561   esac
12562   # We did not find ourselves, most probably we were run as `sh COMMAND'
12563   # in which case we are not to be found in the path.
12564   if test "x$as_myself" = x; then
12565     as_myself=$0
12566   fi
12567   if test ! -f "$as_myself"; then
12568     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12569 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12570    { (exit 1); exit 1; }; }
12571   fi
12572   case $CONFIG_SHELL in
12573   '')
12574     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12575 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12576 do
12577   IFS=$as_save_IFS
12578   test -z "$as_dir" && as_dir=.
12579   for as_base in sh bash ksh sh5; do
12580          case $as_dir in
12581          /*)
12582            if ("$as_dir/$as_base" -c '
12583   as_lineno_1=$LINENO
12584   as_lineno_2=$LINENO
12585   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12586   test "x$as_lineno_1" != "x$as_lineno_2" &&
12587   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12588              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12589              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12590              CONFIG_SHELL=$as_dir/$as_base
12591              export CONFIG_SHELL
12592              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12593            fi;;
12594          esac
12595        done
12596 done
12597 ;;
12598   esac
12599
12600   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12601   # uniformly replaced by the line number.  The first 'sed' inserts a
12602   # line-number line before each line; the second 'sed' does the real
12603   # work.  The second script uses 'N' to pair each line-number line
12604   # with the numbered line, and appends trailing '-' during
12605   # substitution so that $LINENO is not a special case at line end.
12606   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12607   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12608   sed '=' <$as_myself |
12609     sed '
12610       N
12611       s,$,-,
12612       : loop
12613       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12614       t loop
12615       s,-$,,
12616       s,^['$as_cr_digits']*\n,,
12617     ' >$as_me.lineno &&
12618   chmod +x $as_me.lineno ||
12619     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12620 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12621    { (exit 1); exit 1; }; }
12622
12623   # Don't try to exec as it changes $[0], causing all sort of problems
12624   # (the dirname of $[0] is not the place where we might find the
12625   # original and so on.  Autoconf is especially sensible to this).
12626   . ./$as_me.lineno
12627   # Exit status is that of the last command.
12628   exit
12629 }
12630
12631
12632 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12633   *c*,-n*) ECHO_N= ECHO_C='
12634 ' ECHO_T='      ' ;;
12635   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12636   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12637 esac
12638
12639 if expr a : '\(a\)' >/dev/null 2>&1; then
12640   as_expr=expr
12641 else
12642   as_expr=false
12643 fi
12644
12645 rm -f conf$$ conf$$.exe conf$$.file
12646 echo >conf$$.file
12647 if ln -s conf$$.file conf$$ 2>/dev/null; then
12648   # We could just check for DJGPP; but this test a) works b) is more generic
12649   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12650   if test -f conf$$.exe; then
12651     # Don't use ln at all; we don't have any links
12652     as_ln_s='cp -p'
12653   else
12654     as_ln_s='ln -s'
12655   fi
12656 elif ln conf$$.file conf$$ 2>/dev/null; then
12657   as_ln_s=ln
12658 else
12659   as_ln_s='cp -p'
12660 fi
12661 rm -f conf$$ conf$$.exe conf$$.file
12662
12663 if mkdir -p . 2>/dev/null; then
12664   as_mkdir_p=:
12665 else
12666   test -d ./-p && rmdir ./-p
12667   as_mkdir_p=false
12668 fi
12669
12670 as_executable_p="test -f"
12671
12672 # Sed expression to map a string onto a valid CPP name.
12673 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12674
12675 # Sed expression to map a string onto a valid variable name.
12676 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12677
12678
12679 # IFS
12680 # We need space, tab and new line, in precisely that order.
12681 as_nl='
12682 '
12683 IFS="   $as_nl"
12684
12685 # CDPATH.
12686 $as_unset CDPATH
12687
12688 exec 6>&1
12689
12690 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12691 # report actual input values of CONFIG_FILES etc. instead of their
12692 # values after options handling.  Logging --version etc. is OK.
12693 exec 5>>config.log
12694 {
12695   echo
12696   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12697 ## Running $as_me. ##
12698 _ASBOX
12699 } >&5
12700 cat >&5 <<_CSEOF
12701
12702 This file was extended by $as_me, which was
12703 generated by GNU Autoconf 2.59.  Invocation command line was
12704
12705   CONFIG_FILES    = $CONFIG_FILES
12706   CONFIG_HEADERS  = $CONFIG_HEADERS
12707   CONFIG_LINKS    = $CONFIG_LINKS
12708   CONFIG_COMMANDS = $CONFIG_COMMANDS
12709   $ $0 $@
12710
12711 _CSEOF
12712 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12713 echo >&5
12714 _ACEOF
12715
12716 # Files that config.status was made for.
12717 if test -n "$ac_config_files"; then
12718   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12719 fi
12720
12721 if test -n "$ac_config_headers"; then
12722   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12723 fi
12724
12725 if test -n "$ac_config_links"; then
12726   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12727 fi
12728
12729 if test -n "$ac_config_commands"; then
12730   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12731 fi
12732
12733 cat >>$CONFIG_STATUS <<\_ACEOF
12734
12735 ac_cs_usage="\
12736 \`$as_me' instantiates files from templates according to the
12737 current configuration.
12738
12739 Usage: $0 [OPTIONS] [FILE]...
12740
12741   -h, --help       print this help, then exit
12742   -V, --version    print version number, then exit
12743   -q, --quiet      do not print progress messages
12744   -d, --debug      don't remove temporary files
12745       --recheck    update $as_me by reconfiguring in the same conditions
12746   --file=FILE[:TEMPLATE]
12747                    instantiate the configuration file FILE
12748
12749 Configuration files:
12750 $config_files
12751
12752 Report bugs to <bug-autoconf@gnu.org>."
12753 _ACEOF
12754
12755 cat >>$CONFIG_STATUS <<_ACEOF
12756 ac_cs_version="\\
12757 config.status
12758 configured by $0, generated by GNU Autoconf 2.59,
12759   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12760
12761 Copyright (C) 2003 Free Software Foundation, Inc.
12762 This config.status script is free software; the Free Software Foundation
12763 gives unlimited permission to copy, distribute and modify it."
12764 srcdir=$srcdir
12765 INSTALL="$INSTALL"
12766 _ACEOF
12767
12768 cat >>$CONFIG_STATUS <<\_ACEOF
12769 # If no file are specified by the user, then we need to provide default
12770 # value.  By we need to know if files were specified by the user.
12771 ac_need_defaults=:
12772 while test $# != 0
12773 do
12774   case $1 in
12775   --*=*)
12776     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12777     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12778     ac_shift=:
12779     ;;
12780   -*)
12781     ac_option=$1
12782     ac_optarg=$2
12783     ac_shift=shift
12784     ;;
12785   *) # This is not an option, so the user has probably given explicit
12786      # arguments.
12787      ac_option=$1
12788      ac_need_defaults=false;;
12789   esac
12790
12791   case $ac_option in
12792   # Handling of the options.
12793 _ACEOF
12794 cat >>$CONFIG_STATUS <<\_ACEOF
12795   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12796     ac_cs_recheck=: ;;
12797   --version | --vers* | -V )
12798     echo "$ac_cs_version"; exit 0 ;;
12799   --he | --h)
12800     # Conflict between --help and --header
12801     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12802 Try \`$0 --help' for more information." >&5
12803 echo "$as_me: error: ambiguous option: $1
12804 Try \`$0 --help' for more information." >&2;}
12805    { (exit 1); exit 1; }; };;
12806   --help | --hel | -h )
12807     echo "$ac_cs_usage"; exit 0 ;;
12808   --debug | --d* | -d )
12809     debug=: ;;
12810   --file | --fil | --fi | --f )
12811     $ac_shift
12812     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12813     ac_need_defaults=false;;
12814   --header | --heade | --head | --hea )
12815     $ac_shift
12816     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12817     ac_need_defaults=false;;
12818   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12819   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12820     ac_cs_silent=: ;;
12821
12822   # This is an error.
12823   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12824 Try \`$0 --help' for more information." >&5
12825 echo "$as_me: error: unrecognized option: $1
12826 Try \`$0 --help' for more information." >&2;}
12827    { (exit 1); exit 1; }; } ;;
12828
12829   *) ac_config_targets="$ac_config_targets $1" ;;
12830
12831   esac
12832   shift
12833 done
12834
12835 ac_configure_extra_args=
12836
12837 if $ac_cs_silent; then
12838   exec 6>/dev/null
12839   ac_configure_extra_args="$ac_configure_extra_args --silent"
12840 fi
12841
12842 _ACEOF
12843 cat >>$CONFIG_STATUS <<_ACEOF
12844 if \$ac_cs_recheck; then
12845   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12846   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12847 fi
12848
12849 _ACEOF
12850
12851
12852
12853
12854
12855 cat >>$CONFIG_STATUS <<\_ACEOF
12856 for ac_config_target in $ac_config_targets
12857 do
12858   case "$ac_config_target" in
12859   # Handling of arguments.
12860   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12861   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12862 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12863    { (exit 1); exit 1; }; };;
12864   esac
12865 done
12866
12867 # If the user did not use the arguments to specify the items to instantiate,
12868 # then the envvar interface is used.  Set only those that are not.
12869 # We use the long form for the default assignment because of an extremely
12870 # bizarre bug on SunOS 4.1.3.
12871 if $ac_need_defaults; then
12872   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12873 fi
12874
12875 # Have a temporary directory for convenience.  Make it in the build tree
12876 # simply because there is no reason to put it here, and in addition,
12877 # creating and moving files from /tmp can sometimes cause problems.
12878 # Create a temporary directory, and hook for its removal unless debugging.
12879 $debug ||
12880 {
12881   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12882   trap '{ (exit 1); exit 1; }' 1 2 13 15
12883 }
12884
12885 # Create a (secure) tmp directory for tmp files.
12886
12887 {
12888   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12889   test -n "$tmp" && test -d "$tmp"
12890 }  ||
12891 {
12892   tmp=./confstat$$-$RANDOM
12893   (umask 077 && mkdir $tmp)
12894 } ||
12895 {
12896    echo "$me: cannot create a temporary directory in ." >&2
12897    { (exit 1); exit 1; }
12898 }
12899
12900 _ACEOF
12901
12902 cat >>$CONFIG_STATUS <<_ACEOF
12903
12904 #
12905 # CONFIG_FILES section.
12906 #
12907
12908 # No need to generate the scripts if there are no CONFIG_FILES.
12909 # This happens for instance when ./config.status config.h
12910 if test -n "\$CONFIG_FILES"; then
12911   # Protect against being on the right side of a sed subst in config.status.
12912   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12913    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12914 s,@SHELL@,$SHELL,;t t
12915 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12916 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12917 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12918 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12919 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12920 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12921 s,@exec_prefix@,$exec_prefix,;t t
12922 s,@prefix@,$prefix,;t t
12923 s,@program_transform_name@,$program_transform_name,;t t
12924 s,@bindir@,$bindir,;t t
12925 s,@sbindir@,$sbindir,;t t
12926 s,@libexecdir@,$libexecdir,;t t
12927 s,@datadir@,$datadir,;t t
12928 s,@sysconfdir@,$sysconfdir,;t t
12929 s,@sharedstatedir@,$sharedstatedir,;t t
12930 s,@localstatedir@,$localstatedir,;t t
12931 s,@libdir@,$libdir,;t t
12932 s,@includedir@,$includedir,;t t
12933 s,@oldincludedir@,$oldincludedir,;t t
12934 s,@infodir@,$infodir,;t t
12935 s,@mandir@,$mandir,;t t
12936 s,@build_alias@,$build_alias,;t t
12937 s,@host_alias@,$host_alias,;t t
12938 s,@target_alias@,$target_alias,;t t
12939 s,@DEFS@,$DEFS,;t t
12940 s,@ECHO_C@,$ECHO_C,;t t
12941 s,@ECHO_N@,$ECHO_N,;t t
12942 s,@ECHO_T@,$ECHO_T,;t t
12943 s,@LIBS@,$LIBS,;t t
12944 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12945 s,@build@,$build,;t t
12946 s,@build_cpu@,$build_cpu,;t t
12947 s,@build_vendor@,$build_vendor,;t t
12948 s,@build_os@,$build_os,;t t
12949 s,@build_noncanonical@,$build_noncanonical,;t t
12950 s,@host_noncanonical@,$host_noncanonical,;t t
12951 s,@target_noncanonical@,$target_noncanonical,;t t
12952 s,@host@,$host,;t t
12953 s,@host_cpu@,$host_cpu,;t t
12954 s,@host_vendor@,$host_vendor,;t t
12955 s,@host_os@,$host_os,;t t
12956 s,@target@,$target,;t t
12957 s,@target_cpu@,$target_cpu,;t t
12958 s,@target_vendor@,$target_vendor,;t t
12959 s,@target_os@,$target_os,;t t
12960 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12961 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12962 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12963 s,@LN@,$LN,;t t
12964 s,@LN_S@,$LN_S,;t t
12965 s,@build_libsubdir@,$build_libsubdir,;t t
12966 s,@build_subdir@,$build_subdir,;t t
12967 s,@host_subdir@,$host_subdir,;t t
12968 s,@target_subdir@,$target_subdir,;t t
12969 s,@CC@,$CC,;t t
12970 s,@CFLAGS@,$CFLAGS,;t t
12971 s,@LDFLAGS@,$LDFLAGS,;t t
12972 s,@CPPFLAGS@,$CPPFLAGS,;t t
12973 s,@ac_ct_CC@,$ac_ct_CC,;t t
12974 s,@EXEEXT@,$EXEEXT,;t t
12975 s,@OBJEXT@,$OBJEXT,;t t
12976 s,@CXX@,$CXX,;t t
12977 s,@CXXFLAGS@,$CXXFLAGS,;t t
12978 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12979 s,@GNATBIND@,$GNATBIND,;t t
12980 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12981 s,@GNATMAKE@,$GNATMAKE,;t t
12982 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12983 s,@do_compare@,$do_compare,;t t
12984 s,@gmplibs@,$gmplibs,;t t
12985 s,@gmpinc@,$gmpinc,;t t
12986 s,@stage1_languages@,$stage1_languages,;t t
12987 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12988 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12989 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
12990 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
12991 s,@CPPFLAGS_FOR_TARGET@,$CPPFLAGS_FOR_TARGET,;t t
12992 s,@LDFLAGS_FOR_TARGET@,$LDFLAGS_FOR_TARGET,;t t
12993 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12994 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
12995 s,@tooldir@,$tooldir,;t t
12996 s,@build_tooldir@,$build_tooldir,;t t
12997 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12998 s,@GDB_TK@,$GDB_TK,;t t
12999 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13000 s,@build_configargs@,$build_configargs,;t t
13001 s,@build_configdirs@,$build_configdirs,;t t
13002 s,@host_configargs@,$host_configargs,;t t
13003 s,@configdirs@,$configdirs,;t t
13004 s,@target_configargs@,$target_configargs,;t t
13005 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13006 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13007 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13008 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13009 s,@CPPFLAGS_FOR_BUILD@,$CPPFLAGS_FOR_BUILD,;t t
13010 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13011 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13012 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13013 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13014 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13015 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13016 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13017 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13018 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13019 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13020 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13021 s,@config_shell@,$config_shell,;t t
13022 s,@YACC@,$YACC,;t t
13023 s,@BISON@,$BISON,;t t
13024 s,@M4@,$M4,;t t
13025 s,@LEX@,$LEX,;t t
13026 s,@FLEX@,$FLEX,;t t
13027 s,@MAKEINFO@,$MAKEINFO,;t t
13028 s,@EXPECT@,$EXPECT,;t t
13029 s,@RUNTEST@,$RUNTEST,;t t
13030 s,@AR@,$AR,;t t
13031 s,@AS@,$AS,;t t
13032 s,@DLLTOOL@,$DLLTOOL,;t t
13033 s,@LD@,$LD,;t t
13034 s,@LIPO@,$LIPO,;t t
13035 s,@NM@,$NM,;t t
13036 s,@RANLIB@,$RANLIB,;t t
13037 s,@STRIP@,$STRIP,;t t
13038 s,@WINDRES@,$WINDRES,;t t
13039 s,@WINDMC@,$WINDMC,;t t
13040 s,@OBJCOPY@,$OBJCOPY,;t t
13041 s,@OBJDUMP@,$OBJDUMP,;t t
13042 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13043 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13044 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13045 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13046 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13047 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13048 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13049 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13050 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13051 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13052 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13053 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13054 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13055 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13056 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13057 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13058 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13059 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13060 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13061 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13062 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13063 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13064 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13065 s,@MAINT@,$MAINT,;t t
13066 s,@stage1_cflags@,$stage1_cflags,;t t
13067 s,@stage1_checking@,$stage1_checking,;t t
13068 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13069 s,@datarootdir@,$datarootdir,;t t
13070 s,@docdir@,$docdir,;t t
13071 s,@pdfdir@,$pdfdir,;t t
13072 s,@htmldir@,$htmldir,;t t
13073 s,@LIBOBJS@,$LIBOBJS,;t t
13074 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13075 /@serialization_dependencies@/r $serialization_dependencies
13076 s,@serialization_dependencies@,,;t t
13077 /@host_makefile_frag@/r $host_makefile_frag
13078 s,@host_makefile_frag@,,;t t
13079 /@target_makefile_frag@/r $target_makefile_frag
13080 s,@target_makefile_frag@,,;t t
13081 /@alphaieee_frag@/r $alphaieee_frag
13082 s,@alphaieee_frag@,,;t t
13083 /@ospace_frag@/r $ospace_frag
13084 s,@ospace_frag@,,;t t
13085 CEOF
13086
13087 _ACEOF
13088
13089   cat >>$CONFIG_STATUS <<\_ACEOF
13090   # Split the substitutions into bite-sized pieces for seds with
13091   # small command number limits, like on Digital OSF/1 and HP-UX.
13092   ac_max_sed_lines=48
13093   ac_sed_frag=1 # Number of current file.
13094   ac_beg=1 # First line for current file.
13095   ac_end=$ac_max_sed_lines # Line after last line for current file.
13096   ac_more_lines=:
13097   ac_sed_cmds=
13098   while $ac_more_lines; do
13099     if test $ac_beg -gt 1; then
13100       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13101     else
13102       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13103     fi
13104     if test ! -s $tmp/subs.frag; then
13105       ac_more_lines=false
13106     else
13107       # The purpose of the label and of the branching condition is to
13108       # speed up the sed processing (if there are no `@' at all, there
13109       # is no need to browse any of the substitutions).
13110       # These are the two extra sed commands mentioned above.
13111       (echo ':t
13112   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13113       if test -z "$ac_sed_cmds"; then
13114         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13115       else
13116         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13117       fi
13118       ac_sed_frag=`expr $ac_sed_frag + 1`
13119       ac_beg=$ac_end
13120       ac_end=`expr $ac_end + $ac_max_sed_lines`
13121     fi
13122   done
13123   if test -z "$ac_sed_cmds"; then
13124     ac_sed_cmds=cat
13125   fi
13126 fi # test -n "$CONFIG_FILES"
13127
13128 _ACEOF
13129 cat >>$CONFIG_STATUS <<\_ACEOF
13130 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13131   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13132   case $ac_file in
13133   - | *:- | *:-:* ) # input from stdin
13134         cat >$tmp/stdin
13135         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13136         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13137   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13138         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13139   * )   ac_file_in=$ac_file.in ;;
13140   esac
13141
13142   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13143   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13144 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13145          X"$ac_file" : 'X\(//\)[^/]' \| \
13146          X"$ac_file" : 'X\(//\)$' \| \
13147          X"$ac_file" : 'X\(/\)' \| \
13148          .     : '\(.\)' 2>/dev/null ||
13149 echo X"$ac_file" |
13150     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13151           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13152           /^X\(\/\/\)$/{ s//\1/; q; }
13153           /^X\(\/\).*/{ s//\1/; q; }
13154           s/.*/./; q'`
13155   { if $as_mkdir_p; then
13156     mkdir -p "$ac_dir"
13157   else
13158     as_dir="$ac_dir"
13159     as_dirs=
13160     while test ! -d "$as_dir"; do
13161       as_dirs="$as_dir $as_dirs"
13162       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13163 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13164          X"$as_dir" : 'X\(//\)[^/]' \| \
13165          X"$as_dir" : 'X\(//\)$' \| \
13166          X"$as_dir" : 'X\(/\)' \| \
13167          .     : '\(.\)' 2>/dev/null ||
13168 echo X"$as_dir" |
13169     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13170           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13171           /^X\(\/\/\)$/{ s//\1/; q; }
13172           /^X\(\/\).*/{ s//\1/; q; }
13173           s/.*/./; q'`
13174     done
13175     test ! -n "$as_dirs" || mkdir $as_dirs
13176   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13177 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13178    { (exit 1); exit 1; }; }; }
13179
13180   ac_builddir=.
13181
13182 if test "$ac_dir" != .; then
13183   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13184   # A "../" for each directory in $ac_dir_suffix.
13185   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13186 else
13187   ac_dir_suffix= ac_top_builddir=
13188 fi
13189
13190 case $srcdir in
13191   .)  # No --srcdir option.  We are building in place.
13192     ac_srcdir=.
13193     if test -z "$ac_top_builddir"; then
13194        ac_top_srcdir=.
13195     else
13196        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13197     fi ;;
13198   [\\/]* | ?:[\\/]* )  # Absolute path.
13199     ac_srcdir=$srcdir$ac_dir_suffix;
13200     ac_top_srcdir=$srcdir ;;
13201   *) # Relative path.
13202     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13203     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13204 esac
13205
13206 # Do not use `cd foo && pwd` to compute absolute paths, because
13207 # the directories may not exist.
13208 case `pwd` in
13209 .) ac_abs_builddir="$ac_dir";;
13210 *)
13211   case "$ac_dir" in
13212   .) ac_abs_builddir=`pwd`;;
13213   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13214   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13215   esac;;
13216 esac
13217 case $ac_abs_builddir in
13218 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13219 *)
13220   case ${ac_top_builddir}. in
13221   .) ac_abs_top_builddir=$ac_abs_builddir;;
13222   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13223   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13224   esac;;
13225 esac
13226 case $ac_abs_builddir in
13227 .) ac_abs_srcdir=$ac_srcdir;;
13228 *)
13229   case $ac_srcdir in
13230   .) ac_abs_srcdir=$ac_abs_builddir;;
13231   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13232   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13233   esac;;
13234 esac
13235 case $ac_abs_builddir in
13236 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13237 *)
13238   case $ac_top_srcdir in
13239   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13240   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13241   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13242   esac;;
13243 esac
13244
13245
13246   case $INSTALL in
13247   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13248   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13249   esac
13250
13251   if test x"$ac_file" != x-; then
13252     { echo "$as_me:$LINENO: creating $ac_file" >&5
13253 echo "$as_me: creating $ac_file" >&6;}
13254     rm -f "$ac_file"
13255   fi
13256   # Let's still pretend it is `configure' which instantiates (i.e., don't
13257   # use $as_me), people would be surprised to read:
13258   #    /* config.h.  Generated by config.status.  */
13259   if test x"$ac_file" = x-; then
13260     configure_input=
13261   else
13262     configure_input="$ac_file.  "
13263   fi
13264   configure_input=$configure_input"Generated from `echo $ac_file_in |
13265                                      sed 's,.*/,,'` by configure."
13266
13267   # First look for the input files in the build tree, otherwise in the
13268   # src tree.
13269   ac_file_inputs=`IFS=:
13270     for f in $ac_file_in; do
13271       case $f in
13272       -) echo $tmp/stdin ;;
13273       [\\/$]*)
13274          # Absolute (can't be DOS-style, as IFS=:)
13275          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13276 echo "$as_me: error: cannot find input file: $f" >&2;}
13277    { (exit 1); exit 1; }; }
13278          echo "$f";;
13279       *) # Relative
13280          if test -f "$f"; then
13281            # Build tree
13282            echo "$f"
13283          elif test -f "$srcdir/$f"; then
13284            # Source tree
13285            echo "$srcdir/$f"
13286          else
13287            # /dev/null tree
13288            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13289 echo "$as_me: error: cannot find input file: $f" >&2;}
13290    { (exit 1); exit 1; }; }
13291          fi;;
13292       esac
13293     done` || { (exit 1); exit 1; }
13294 _ACEOF
13295 cat >>$CONFIG_STATUS <<_ACEOF
13296   sed "$ac_vpsub
13297 $extrasub
13298 _ACEOF
13299 cat >>$CONFIG_STATUS <<\_ACEOF
13300 :t
13301 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13302 s,@configure_input@,$configure_input,;t t
13303 s,@srcdir@,$ac_srcdir,;t t
13304 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13305 s,@top_srcdir@,$ac_top_srcdir,;t t
13306 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13307 s,@builddir@,$ac_builddir,;t t
13308 s,@abs_builddir@,$ac_abs_builddir,;t t
13309 s,@top_builddir@,$ac_top_builddir,;t t
13310 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13311 s,@INSTALL@,$ac_INSTALL,;t t
13312 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13313   rm -f $tmp/stdin
13314   if test x"$ac_file" != x-; then
13315     mv $tmp/out $ac_file
13316   else
13317     cat $tmp/out
13318     rm -f $tmp/out
13319   fi
13320
13321 done
13322 _ACEOF
13323
13324 cat >>$CONFIG_STATUS <<\_ACEOF
13325
13326 { (exit 0); exit 0; }
13327 _ACEOF
13328 chmod +x $CONFIG_STATUS
13329 ac_clean_files=$ac_clean_files_save
13330
13331
13332 # configure is writing to config.log, and then calls config.status.
13333 # config.status does its own redirection, appending to config.log.
13334 # Unfortunately, on DOS this fails, as config.log is still kept open
13335 # by configure, so config.status won't be able to write to it; its
13336 # output is simply discarded.  So we exec the FD to /dev/null,
13337 # effectively closing config.log, so it can be properly (re)opened and
13338 # appended to by config.status.  When coming back to configure, we
13339 # need to make the FD available again.
13340 if test "$no_create" != yes; then
13341   ac_cs_success=:
13342   ac_config_status_args=
13343   test "$silent" = yes &&
13344     ac_config_status_args="$ac_config_status_args --quiet"
13345   exec 5>/dev/null
13346   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13347   exec 5>>config.log
13348   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13349   # would make configure fail if this is the last instruction.
13350   $ac_cs_success || { (exit 1); exit 1; }
13351 fi
13352