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 RPATH_ENVVAR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277 ac_pwd=`pwd`
 278
 279 # Initialize some variables set by options.
 280 ac_init_help=
 281 ac_init_version=false
 282 # The variables have the same names as the options, with
 283 # dashes changed to underlines.
 284 cache_file=/dev/null
 285 exec_prefix=NONE
 286 no_create=
 287 no_recursion=
 288 prefix=NONE
 289 program_prefix=NONE
 290 program_suffix=NONE
 291 program_transform_name=s,x,x,
 292 silent=
 293 site=
 294 srcdir=
 295 verbose=
 296 x_includes=NONE
 297 x_libraries=NONE
 298
 299 # Installation directory options.
 300 # These are left unexpanded so users can "make install exec_prefix=/foo"
 301 # and all the variables that are supposed to be based on exec_prefix
 302 # by default will actually change.
 303 # Use braces instead of parens because sh, perl, etc. also accept them.
 304 bindir='${exec_prefix}/bin'
 305 sbindir='${exec_prefix}/sbin'
 306 libexecdir='${exec_prefix}/libexec'
 307 datadir='${prefix}/share'
 308 sysconfdir='${prefix}/etc'
 309 sharedstatedir='${prefix}/com'
 310 localstatedir='${prefix}/var'
 311 libdir='${exec_prefix}/lib'
 312 includedir='${prefix}/include'
 313 oldincludedir='/usr/include'
 314 infodir='${prefix}/info'
 315 mandir='${prefix}/man'
 316
 317 ac_prev=
 318 for ac_option
 319 do
 320   # If the previous option needs an argument, assign it.
 321   if test -n "$ac_prev"; then
 322     eval "$ac_prev=\$ac_option"
 323     ac_prev=
 324     continue
 325   fi
 326
 327   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 328
 329   # Accept the important Cygnus configure options, so we can diagnose typos.
 330
 331   case $ac_option in
 332
 333   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 334     ac_prev=bindir ;;
 335   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 336     bindir=$ac_optarg ;;
 337
 338   -build | --build | --buil | --bui | --bu)
 339     ac_prev=build_alias ;;
 340   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 341     build_alias=$ac_optarg ;;
 342
 343   -cache-file | --cache-file | --cache-fil | --cache-fi \
 344   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 345     ac_prev=cache_file ;;
 346   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 347   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 348     cache_file=$ac_optarg ;;
 349
 350   --config-cache | -C)
 351     cache_file=config.cache ;;
 352
 353   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 354     ac_prev=datadir ;;
 355   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 356   | --da=*)
 357     datadir=$ac_optarg ;;
 358
 359   -disable-* | --disable-*)
 360     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 361     # Reject names that are not valid shell variable names.
 362     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 363       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 364    { (exit 1); exit 1; }; }
 365     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 366     eval "enable_$ac_feature=no" ;;
 367
 368   -enable-* | --enable-*)
 369     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 370     # Reject names that are not valid shell variable names.
 371     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 372       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 373    { (exit 1); exit 1; }; }
 374     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 375     case $ac_option in
 376       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 377       *) ac_optarg=yes ;;
 378     esac
 379     eval "enable_$ac_feature='$ac_optarg'" ;;
 380
 381   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 382   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 383   | --exec | --exe | --ex)
 384     ac_prev=exec_prefix ;;
 385   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 386   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 387   | --exec=* | --exe=* | --ex=*)
 388     exec_prefix=$ac_optarg ;;
 389
 390   -gas | --gas | --ga | --g)
 391     # Obsolete; use --with-gas.
 392     with_gas=yes ;;
 393
 394   -help | --help | --hel | --he | -h)
 395     ac_init_help=long ;;
 396   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 397     ac_init_help=recursive ;;
 398   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 399     ac_init_help=short ;;
 400
 401   -host | --host | --hos | --ho)
 402     ac_prev=host_alias ;;
 403   -host=* | --host=* | --hos=* | --ho=*)
 404     host_alias=$ac_optarg ;;
 405
 406   -includedir | --includedir | --includedi | --included | --include \
 407   | --includ | --inclu | --incl | --inc)
 408     ac_prev=includedir ;;
 409   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 410   | --includ=* | --inclu=* | --incl=* | --inc=*)
 411     includedir=$ac_optarg ;;
 412
 413   -infodir | --infodir | --infodi | --infod | --info | --inf)
 414     ac_prev=infodir ;;
 415   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 416     infodir=$ac_optarg ;;
 417
 418   -libdir | --libdir | --libdi | --libd)
 419     ac_prev=libdir ;;
 420   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 421     libdir=$ac_optarg ;;
 422
 423   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 424   | --libexe | --libex | --libe)
 425     ac_prev=libexecdir ;;
 426   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 427   | --libexe=* | --libex=* | --libe=*)
 428     libexecdir=$ac_optarg ;;
 429
 430   -localstatedir | --localstatedir | --localstatedi | --localstated \
 431   | --localstate | --localstat | --localsta | --localst \
 432   | --locals | --local | --loca | --loc | --lo)
 433     ac_prev=localstatedir ;;
 434   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 435   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 436   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 437     localstatedir=$ac_optarg ;;
 438
 439   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 440     ac_prev=mandir ;;
 441   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 442     mandir=$ac_optarg ;;
 443
 444   -nfp | --nfp | --nf)
 445     # Obsolete; use --without-fp.
 446     with_fp=no ;;
 447
 448   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 449   | --no-cr | --no-c | -n)
 450     no_create=yes ;;
 451
 452   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 453   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 454     no_recursion=yes ;;
 455
 456   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 457   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 458   | --oldin | --oldi | --old | --ol | --o)
 459     ac_prev=oldincludedir ;;
 460   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 461   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 462   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 463     oldincludedir=$ac_optarg ;;
 464
 465   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 466     ac_prev=prefix ;;
 467   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 468     prefix=$ac_optarg ;;
 469
 470   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 471   | --program-pre | --program-pr | --program-p)
 472     ac_prev=program_prefix ;;
 473   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 474   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 475     program_prefix=$ac_optarg ;;
 476
 477   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 478   | --program-suf | --program-su | --program-s)
 479     ac_prev=program_suffix ;;
 480   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 481   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 482     program_suffix=$ac_optarg ;;
 483
 484   -program-transform-name | --program-transform-name \
 485   | --program-transform-nam | --program-transform-na \
 486   | --program-transform-n | --program-transform- \
 487   | --program-transform | --program-transfor \
 488   | --program-transfo | --program-transf \
 489   | --program-trans | --program-tran \
 490   | --progr-tra | --program-tr | --program-t)
 491     ac_prev=program_transform_name ;;
 492   -program-transform-name=* | --program-transform-name=* \
 493   | --program-transform-nam=* | --program-transform-na=* \
 494   | --program-transform-n=* | --program-transform-=* \
 495   | --program-transform=* | --program-transfor=* \
 496   | --program-transfo=* | --program-transf=* \
 497   | --program-trans=* | --program-tran=* \
 498   | --progr-tra=* | --program-tr=* | --program-t=*)
 499     program_transform_name=$ac_optarg ;;
 500
 501   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 502   | -silent | --silent | --silen | --sile | --sil)
 503     silent=yes ;;
 504
 505   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 506     ac_prev=sbindir ;;
 507   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 508   | --sbi=* | --sb=*)
 509     sbindir=$ac_optarg ;;
 510
 511   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 512   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 513   | --sharedst | --shareds | --shared | --share | --shar \
 514   | --sha | --sh)
 515     ac_prev=sharedstatedir ;;
 516   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 517   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 518   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 519   | --sha=* | --sh=*)
 520     sharedstatedir=$ac_optarg ;;
 521
 522   -site | --site | --sit)
 523     ac_prev=site ;;
 524   -site=* | --site=* | --sit=*)
 525     site=$ac_optarg ;;
 526
 527   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 528     ac_prev=srcdir ;;
 529   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 530     srcdir=$ac_optarg ;;
 531
 532   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 533   | --syscon | --sysco | --sysc | --sys | --sy)
 534     ac_prev=sysconfdir ;;
 535   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 536   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 537     sysconfdir=$ac_optarg ;;
 538
 539   -target | --target | --targe | --targ | --tar | --ta | --t)
 540     ac_prev=target_alias ;;
 541   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 542     target_alias=$ac_optarg ;;
 543
 544   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 545     verbose=yes ;;
 546
 547   -version | --version | --versio | --versi | --vers | -V)
 548     ac_init_version=: ;;
 549
 550   -with-* | --with-*)
 551     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 552     # Reject names that are not valid shell variable names.
 553     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 554       { echo "$as_me: error: invalid package name: $ac_package" >&2
 555    { (exit 1); exit 1; }; }
 556     ac_package=`echo $ac_package| sed 's/-/_/g'`
 557     case $ac_option in
 558       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 559       *) ac_optarg=yes ;;
 560     esac
 561     eval "with_$ac_package='$ac_optarg'" ;;
 562
 563   -without-* | --without-*)
 564     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 565     # Reject names that are not valid shell variable names.
 566     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 567       { echo "$as_me: error: invalid package name: $ac_package" >&2
 568    { (exit 1); exit 1; }; }
 569     ac_package=`echo $ac_package | sed 's/-/_/g'`
 570     eval "with_$ac_package=no" ;;
 571
 572   --x)
 573     # Obsolete; use --with-x.
 574     with_x=yes ;;
 575
 576   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 577   | --x-incl | --x-inc | --x-in | --x-i)
 578     ac_prev=x_includes ;;
 579   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 580   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 581     x_includes=$ac_optarg ;;
 582
 583   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 584   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 585     ac_prev=x_libraries ;;
 586   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 587   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 588     x_libraries=$ac_optarg ;;
 589
 590   -*) { echo "$as_me: error: unrecognized option: $ac_option
 591 Try \`$0 --help' for more information." >&2
 592    { (exit 1); exit 1; }; }
 593     ;;
 594
 595   *=*)
 596     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 597     # Reject names that are not valid shell variable names.
 598     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 599       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 600    { (exit 1); exit 1; }; }
 601     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 602     eval "$ac_envvar='$ac_optarg'"
 603     export $ac_envvar ;;
 604
 605   *)
 606     # FIXME: should be removed in autoconf 3.0.
 607     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 608     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 609       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 610     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 611     ;;
 612
 613   esac
 614 done
 615
 616 if test -n "$ac_prev"; then
 617   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 618   { echo "$as_me: error: missing argument to $ac_option" >&2
 619    { (exit 1); exit 1; }; }
 620 fi
 621
 622 # Be sure to have absolute paths.
 623 for ac_var in exec_prefix prefix
 624 do
 625   eval ac_val=$`echo $ac_var`
 626   case $ac_val in
 627     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 628     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 629    { (exit 1); exit 1; }; };;
 630   esac
 631 done
 632
 633 # Be sure to have absolute paths.
 634 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 635               localstatedir libdir includedir oldincludedir infodir mandir
 636 do
 637   eval ac_val=$`echo $ac_var`
 638   case $ac_val in
 639     [\\/$]* | ?:[\\/]* ) ;;
 640     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 641    { (exit 1); exit 1; }; };;
 642   esac
 643 done
 644
 645 # There might be people who depend on the old broken behavior: `$host'
 646 # used to hold the argument of --host etc.
 647 # FIXME: To remove some day.
 648 build=$build_alias
 649 host=$host_alias
 650 target=$target_alias
 651
 652 # FIXME: To remove some day.
 653 if test "x$host_alias" != x; then
 654   if test "x$build_alias" = x; then
 655     cross_compiling=maybe
 656     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 657     If a cross compiler is detected then cross compile mode will be used." >&2
 658   elif test "x$build_alias" != "x$host_alias"; then
 659     cross_compiling=yes
 660   fi
 661 fi
 662
 663 ac_tool_prefix=
 664 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 665
 666 test "$silent" = yes && exec 6>/dev/null
 667
 668
 669 # Find the source files, if location was not specified.
 670 if test -z "$srcdir"; then
 671   ac_srcdir_defaulted=yes
 672   # Try the directory containing this script, then its parent.
 673   ac_confdir=`(dirname "$0") 2>/dev/null ||
 674 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 675          X"$0" : 'X\(//\)[^/]' \| \
 676          X"$0" : 'X\(//\)$' \| \
 677          X"$0" : 'X\(/\)' \| \
 678          .     : '\(.\)' 2>/dev/null ||
 679 echo X"$0" |
 680     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 681           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 682           /^X\(\/\/\)$/{ s//\1/; q; }
 683           /^X\(\/\).*/{ s//\1/; q; }
 684           s/.*/./; q'`
 685   srcdir=$ac_confdir
 686   if test ! -r $srcdir/$ac_unique_file; then
 687     srcdir=..
 688   fi
 689 else
 690   ac_srcdir_defaulted=no
 691 fi
 692 if test ! -r $srcdir/$ac_unique_file; then
 693   if test "$ac_srcdir_defaulted" = yes; then
 694     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 695    { (exit 1); exit 1; }; }
 696   else
 697     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 698    { (exit 1); exit 1; }; }
 699   fi
 700 fi
 701 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 702   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 703    { (exit 1); exit 1; }; }
 704 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 705 ac_env_build_alias_set=${build_alias+set}
 706 ac_env_build_alias_value=$build_alias
 707 ac_cv_env_build_alias_set=${build_alias+set}
 708 ac_cv_env_build_alias_value=$build_alias
 709 ac_env_host_alias_set=${host_alias+set}
 710 ac_env_host_alias_value=$host_alias
 711 ac_cv_env_host_alias_set=${host_alias+set}
 712 ac_cv_env_host_alias_value=$host_alias
 713 ac_env_target_alias_set=${target_alias+set}
 714 ac_env_target_alias_value=$target_alias
 715 ac_cv_env_target_alias_set=${target_alias+set}
 716 ac_cv_env_target_alias_value=$target_alias
 717 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 718
 719 ac_env_CC_set=${CC+set}
 720 ac_env_CC_value=$CC
 721 ac_cv_env_CC_set=${CC+set}
 722 ac_cv_env_CC_value=$CC
 723 ac_env_CFLAGS_set=${CFLAGS+set}
 724 ac_env_CFLAGS_value=$CFLAGS
 725 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 726 ac_cv_env_CFLAGS_value=$CFLAGS
 727 ac_env_LDFLAGS_set=${LDFLAGS+set}
 728 ac_env_LDFLAGS_value=$LDFLAGS
 729 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 730 ac_cv_env_LDFLAGS_value=$LDFLAGS
 731 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 732 ac_env_CPPFLAGS_value=$CPPFLAGS
 733 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 734 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 735 ac_env_CXX_set=${CXX+set}
 736 ac_env_CXX_value=$CXX
 737 ac_cv_env_CXX_set=${CXX+set}
 738 ac_cv_env_CXX_value=$CXX
 739 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 740 ac_env_CXXFLAGS_value=$CXXFLAGS
 741 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 742 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 743 ac_env_AR_set=${AR+set}
 744 ac_env_AR_value=$AR
 745 ac_cv_env_AR_set=${AR+set}
 746 ac_cv_env_AR_value=$AR
 747 ac_env_AS_set=${AS+set}
 748 ac_env_AS_value=$AS
 749 ac_cv_env_AS_set=${AS+set}
 750 ac_cv_env_AS_value=$AS
 751 ac_env_DLLTOOL_set=${DLLTOOL+set}
 752 ac_env_DLLTOOL_value=$DLLTOOL
 753 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 754 ac_cv_env_DLLTOOL_value=$DLLTOOL
 755 ac_env_LD_set=${LD+set}
 756 ac_env_LD_value=$LD
 757 ac_cv_env_LD_set=${LD+set}
 758 ac_cv_env_LD_value=$LD
 759 ac_env_LIPO_set=${LIPO+set}
 760 ac_env_LIPO_value=$LIPO
 761 ac_cv_env_LIPO_set=${LIPO+set}
 762 ac_cv_env_LIPO_value=$LIPO
 763 ac_env_NM_set=${NM+set}
 764 ac_env_NM_value=$NM
 765 ac_cv_env_NM_set=${NM+set}
 766 ac_cv_env_NM_value=$NM
 767 ac_env_RANLIB_set=${RANLIB+set}
 768 ac_env_RANLIB_value=$RANLIB
 769 ac_cv_env_RANLIB_set=${RANLIB+set}
 770 ac_cv_env_RANLIB_value=$RANLIB
 771 ac_env_STRIP_set=${STRIP+set}
 772 ac_env_STRIP_value=$STRIP
 773 ac_cv_env_STRIP_set=${STRIP+set}
 774 ac_cv_env_STRIP_value=$STRIP
 775 ac_env_WINDRES_set=${WINDRES+set}
 776 ac_env_WINDRES_value=$WINDRES
 777 ac_cv_env_WINDRES_set=${WINDRES+set}
 778 ac_cv_env_WINDRES_value=$WINDRES
 779 ac_env_WINDMC_set=${WINDMC+set}
 780 ac_env_WINDMC_value=$WINDMC
 781 ac_cv_env_WINDMC_set=${WINDMC+set}
 782 ac_cv_env_WINDMC_value=$WINDMC
 783 ac_env_OBJCOPY_set=${OBJCOPY+set}
 784 ac_env_OBJCOPY_value=$OBJCOPY
 785 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 786 ac_cv_env_OBJCOPY_value=$OBJCOPY
 787 ac_env_OBJDUMP_set=${OBJDUMP+set}
 788 ac_env_OBJDUMP_value=$OBJDUMP
 789 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 790 ac_cv_env_OBJDUMP_value=$OBJDUMP
 791 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 792 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 793 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 794 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 795 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 796 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 797 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 798 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 799 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 800 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 801 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 802 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 803 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 804 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 805 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 806 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 807 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 808 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 809 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 810 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 811 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 812 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 813 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 814 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 815 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 816 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 817 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 818 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 819 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 820 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 821 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 822 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 823 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 824 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 825 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 826 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 827 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 828 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 829 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 830 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 831 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 832 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 833 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 834 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 835 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 836 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 837 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 838 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 839 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 840 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 841 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 842 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 843 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 844 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 845 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 846 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 847 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 848 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 849 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 850 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 851 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 852 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 853 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 854 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 855
 856 #
 857 # Report the --help message.
 858 #
 859 if test "$ac_init_help" = "long"; then
 860   # Omit some internal or obsolete options to make the list less imposing.
 861   # This message is too long to be a string in the A/UX 3.1 sh.
 862   cat <<_ACEOF
 863 \`configure' configures this package to adapt to many kinds of systems.
 864
 865 Usage: $0 [OPTION]... [VAR=VALUE]...
 866
 867 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 868 VAR=VALUE.  See below for descriptions of some of the useful variables.
 869
 870 Defaults for the options are specified in brackets.
 871
 872 Configuration:
 873   -h, --help              display this help and exit
 874       --help=short        display options specific to this package
 875       --help=recursive    display the short help of all the included packages
 876   -V, --version           display version information and exit
 877   -q, --quiet, --silent   do not print \`checking...' messages
 878       --cache-file=FILE   cache test results in FILE [disabled]
 879   -C, --config-cache      alias for \`--cache-file=config.cache'
 880   -n, --no-create         do not create output files
 881       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 882
 883 _ACEOF
 884
 885   cat <<_ACEOF
 886 Installation directories:
 887   --prefix=PREFIX         install architecture-independent files in PREFIX
 888                           [$ac_default_prefix]
 889   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 890                           [PREFIX]
 891
 892 By default, \`make install' will install all the files in
 893 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 894 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 895 for instance \`--prefix=\$HOME'.
 896
 897 For better control, use the options below.
 898
 899 Fine tuning of the installation directories:
 900   --bindir=DIR           user executables [EPREFIX/bin]
 901   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 902   --libexecdir=DIR       program executables [EPREFIX/libexec]
 903   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 904   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 905   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 906   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 907   --libdir=DIR           object code libraries [EPREFIX/lib]
 908   --includedir=DIR       C header files [PREFIX/include]
 909   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 910   --infodir=DIR          info documentation [PREFIX/info]
 911   --mandir=DIR           man documentation [PREFIX/man]
 912 _ACEOF
 913
 914   cat <<\_ACEOF
 915
 916 Program names:
 917   --program-prefix=PREFIX            prepend PREFIX to installed program names
 918   --program-suffix=SUFFIX            append SUFFIX to installed program names
 919   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 920
 921 System types:
 922   --build=BUILD     configure for building on BUILD [guessed]
 923   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 924   --target=TARGET   configure for building compilers for TARGET [HOST]
 925 _ACEOF
 926 fi
 927
 928 if test -n "$ac_init_help"; then
 929
 930   cat <<\_ACEOF
 931
 932 Optional Features:
 933   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 934   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 935   --enable-gold           use gold instead of ld
 936   --enable-libada         build libada directory
 937   --enable-libssp         build libssp directory
 938   --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 bfd binutils ld gas opcodes 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   *-hp-hpux*)
2848     tentative_cc="cc -Wp,-H256000"
2849     ;;
2850   *-*-hiux*)
2851     tentative_cc="cc -Wp,-H256000"
2852     ;;
2853   rs6000-*-lynxos*)
2854     # /bin/cc is less than useful for our purposes.  Always use GCC
2855     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2856     host_makefile_frag="config/mh-lynxrs6k"
2857     ;;
2858   powerpc-*-darwin*)
2859     host_makefile_frag="config/mh-ppc-darwin"
2860     ;;
2861   powerpc-*-aix*)
2862     host_makefile_frag="config/mh-ppc-aix"
2863     ;;
2864   rs6000-*-aix*)
2865     host_makefile_frag="config/mh-ppc-aix"
2866     ;;
2867   *-*-lynxos*)
2868     # /bin/cc is less than useful for our purposes.  Always use GCC
2869     tentative_cc="/bin/gcc"
2870     ;;
2871   *-*-sysv4*)
2872     host_makefile_frag="config/mh-sysv4"
2873     ;;
2874   # This is placed last to prevent interfering with the cases above.
2875   i[3456789]86-*-*)
2876     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2877     host_makefile_frag="config/mh-x86omitfp"
2878     ;;
2879 esac
2880 fi
2881
2882 # If we aren't going to be using gcc, see if we can extract a definition
2883 # of CC from the fragment.
2884 # Actually, use the 'pre-extracted' version above.
2885 if test -z "${CC}" && test "${build}" = "${host}" ; then
2886   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2887   found=
2888   for dir in $PATH; do
2889     test -z "$dir" && dir=.
2890     if test -f $dir/gcc; then
2891       found=yes
2892       break
2893     fi
2894   done
2895   IFS="$save_ifs"
2896   if test -z "${found}" && test -n "${tentative_cc}" ; then
2897     CC=$tentative_cc
2898   fi
2899 fi
2900
2901 if test "${build}" != "${host}" ; then
2902   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2903   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2904   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2905   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2906   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2907   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2908   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2909   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2910   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2911   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2912   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2913   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2914 else
2915   AR_FOR_BUILD="\$(AR)"
2916   AS_FOR_BUILD="\$(AS)"
2917   CC_FOR_BUILD="\$(CC)"
2918   CXX_FOR_BUILD="\$(CXX)"
2919   GCJ_FOR_BUILD="\$(GCJ)"
2920   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2921   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2922   LD_FOR_BUILD="\$(LD)"
2923   NM_FOR_BUILD="\$(NM)"
2924   RANLIB_FOR_BUILD="\$(RANLIB)"
2925   WINDRES_FOR_BUILD="\$(WINDRES)"
2926   WINDMC_FOR_BUILD="\$(WINDMC)"
2927 fi
2928
2929 ac_ext=c
2930 ac_cpp='$CPP $CPPFLAGS'
2931 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2932 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2933 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2934 if test -n "$ac_tool_prefix"; then
2935   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2936 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2937 echo "$as_me:$LINENO: checking for $ac_word" >&5
2938 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2939 if test "${ac_cv_prog_CC+set}" = set; then
2940   echo $ECHO_N "(cached) $ECHO_C" >&6
2941 else
2942   if test -n "$CC"; then
2943   ac_cv_prog_CC="$CC" # Let the user override the test.
2944 else
2945 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2946 for as_dir in $PATH
2947 do
2948   IFS=$as_save_IFS
2949   test -z "$as_dir" && as_dir=.
2950   for ac_exec_ext in '' $ac_executable_extensions; do
2951   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2952     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2953     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2954     break 2
2955   fi
2956 done
2957 done
2958
2959 fi
2960 fi
2961 CC=$ac_cv_prog_CC
2962 if test -n "$CC"; then
2963   echo "$as_me:$LINENO: result: $CC" >&5
2964 echo "${ECHO_T}$CC" >&6
2965 else
2966   echo "$as_me:$LINENO: result: no" >&5
2967 echo "${ECHO_T}no" >&6
2968 fi
2969
2970 fi
2971 if test -z "$ac_cv_prog_CC"; then
2972   ac_ct_CC=$CC
2973   # Extract the first word of "gcc", so it can be a program name with args.
2974 set dummy gcc; ac_word=$2
2975 echo "$as_me:$LINENO: checking for $ac_word" >&5
2976 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2977 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2978   echo $ECHO_N "(cached) $ECHO_C" >&6
2979 else
2980   if test -n "$ac_ct_CC"; then
2981   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2982 else
2983 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2984 for as_dir in $PATH
2985 do
2986   IFS=$as_save_IFS
2987   test -z "$as_dir" && as_dir=.
2988   for ac_exec_ext in '' $ac_executable_extensions; do
2989   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2990     ac_cv_prog_ac_ct_CC="gcc"
2991     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2992     break 2
2993   fi
2994 done
2995 done
2996
2997 fi
2998 fi
2999 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3000 if test -n "$ac_ct_CC"; then
3001   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3002 echo "${ECHO_T}$ac_ct_CC" >&6
3003 else
3004   echo "$as_me:$LINENO: result: no" >&5
3005 echo "${ECHO_T}no" >&6
3006 fi
3007
3008   CC=$ac_ct_CC
3009 else
3010   CC="$ac_cv_prog_CC"
3011 fi
3012
3013 if test -z "$CC"; then
3014   if test -n "$ac_tool_prefix"; then
3015   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3016 set dummy ${ac_tool_prefix}cc; ac_word=$2
3017 echo "$as_me:$LINENO: checking for $ac_word" >&5
3018 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3019 if test "${ac_cv_prog_CC+set}" = set; then
3020   echo $ECHO_N "(cached) $ECHO_C" >&6
3021 else
3022   if test -n "$CC"; then
3023   ac_cv_prog_CC="$CC" # Let the user override the test.
3024 else
3025 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3026 for as_dir in $PATH
3027 do
3028   IFS=$as_save_IFS
3029   test -z "$as_dir" && as_dir=.
3030   for ac_exec_ext in '' $ac_executable_extensions; do
3031   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3032     ac_cv_prog_CC="${ac_tool_prefix}cc"
3033     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3034     break 2
3035   fi
3036 done
3037 done
3038
3039 fi
3040 fi
3041 CC=$ac_cv_prog_CC
3042 if test -n "$CC"; then
3043   echo "$as_me:$LINENO: result: $CC" >&5
3044 echo "${ECHO_T}$CC" >&6
3045 else
3046   echo "$as_me:$LINENO: result: no" >&5
3047 echo "${ECHO_T}no" >&6
3048 fi
3049
3050 fi
3051 if test -z "$ac_cv_prog_CC"; then
3052   ac_ct_CC=$CC
3053   # Extract the first word of "cc", so it can be a program name with args.
3054 set dummy cc; ac_word=$2
3055 echo "$as_me:$LINENO: checking for $ac_word" >&5
3056 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3057 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3058   echo $ECHO_N "(cached) $ECHO_C" >&6
3059 else
3060   if test -n "$ac_ct_CC"; then
3061   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3062 else
3063 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3064 for as_dir in $PATH
3065 do
3066   IFS=$as_save_IFS
3067   test -z "$as_dir" && as_dir=.
3068   for ac_exec_ext in '' $ac_executable_extensions; do
3069   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3070     ac_cv_prog_ac_ct_CC="cc"
3071     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3072     break 2
3073   fi
3074 done
3075 done
3076
3077 fi
3078 fi
3079 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3080 if test -n "$ac_ct_CC"; then
3081   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3082 echo "${ECHO_T}$ac_ct_CC" >&6
3083 else
3084   echo "$as_me:$LINENO: result: no" >&5
3085 echo "${ECHO_T}no" >&6
3086 fi
3087
3088   CC=$ac_ct_CC
3089 else
3090   CC="$ac_cv_prog_CC"
3091 fi
3092
3093 fi
3094 if test -z "$CC"; then
3095   # Extract the first word of "cc", so it can be a program name with args.
3096 set dummy cc; ac_word=$2
3097 echo "$as_me:$LINENO: checking for $ac_word" >&5
3098 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3099 if test "${ac_cv_prog_CC+set}" = set; then
3100   echo $ECHO_N "(cached) $ECHO_C" >&6
3101 else
3102   if test -n "$CC"; then
3103   ac_cv_prog_CC="$CC" # Let the user override the test.
3104 else
3105   ac_prog_rejected=no
3106 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3107 for as_dir in $PATH
3108 do
3109   IFS=$as_save_IFS
3110   test -z "$as_dir" && as_dir=.
3111   for ac_exec_ext in '' $ac_executable_extensions; do
3112   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3113     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3114        ac_prog_rejected=yes
3115        continue
3116      fi
3117     ac_cv_prog_CC="cc"
3118     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3119     break 2
3120   fi
3121 done
3122 done
3123
3124 if test $ac_prog_rejected = yes; then
3125   # We found a bogon in the path, so make sure we never use it.
3126   set dummy $ac_cv_prog_CC
3127   shift
3128   if test $# != 0; then
3129     # We chose a different compiler from the bogus one.
3130     # However, it has the same basename, so the bogon will be chosen
3131     # first if we set CC to just the basename; use the full file name.
3132     shift
3133     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3134   fi
3135 fi
3136 fi
3137 fi
3138 CC=$ac_cv_prog_CC
3139 if test -n "$CC"; then
3140   echo "$as_me:$LINENO: result: $CC" >&5
3141 echo "${ECHO_T}$CC" >&6
3142 else
3143   echo "$as_me:$LINENO: result: no" >&5
3144 echo "${ECHO_T}no" >&6
3145 fi
3146
3147 fi
3148 if test -z "$CC"; then
3149   if test -n "$ac_tool_prefix"; then
3150   for ac_prog in cl
3151   do
3152     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3153 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3154 echo "$as_me:$LINENO: checking for $ac_word" >&5
3155 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3156 if test "${ac_cv_prog_CC+set}" = set; then
3157   echo $ECHO_N "(cached) $ECHO_C" >&6
3158 else
3159   if test -n "$CC"; then
3160   ac_cv_prog_CC="$CC" # Let the user override the test.
3161 else
3162 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3163 for as_dir in $PATH
3164 do
3165   IFS=$as_save_IFS
3166   test -z "$as_dir" && as_dir=.
3167   for ac_exec_ext in '' $ac_executable_extensions; do
3168   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3169     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3170     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3171     break 2
3172   fi
3173 done
3174 done
3175
3176 fi
3177 fi
3178 CC=$ac_cv_prog_CC
3179 if test -n "$CC"; then
3180   echo "$as_me:$LINENO: result: $CC" >&5
3181 echo "${ECHO_T}$CC" >&6
3182 else
3183   echo "$as_me:$LINENO: result: no" >&5
3184 echo "${ECHO_T}no" >&6
3185 fi
3186
3187     test -n "$CC" && break
3188   done
3189 fi
3190 if test -z "$CC"; then
3191   ac_ct_CC=$CC
3192   for ac_prog in cl
3193 do
3194   # Extract the first word of "$ac_prog", so it can be a program name with args.
3195 set dummy $ac_prog; ac_word=$2
3196 echo "$as_me:$LINENO: checking for $ac_word" >&5
3197 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3198 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3199   echo $ECHO_N "(cached) $ECHO_C" >&6
3200 else
3201   if test -n "$ac_ct_CC"; then
3202   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3203 else
3204 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3205 for as_dir in $PATH
3206 do
3207   IFS=$as_save_IFS
3208   test -z "$as_dir" && as_dir=.
3209   for ac_exec_ext in '' $ac_executable_extensions; do
3210   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3211     ac_cv_prog_ac_ct_CC="$ac_prog"
3212     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3213     break 2
3214   fi
3215 done
3216 done
3217
3218 fi
3219 fi
3220 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3221 if test -n "$ac_ct_CC"; then
3222   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3223 echo "${ECHO_T}$ac_ct_CC" >&6
3224 else
3225   echo "$as_me:$LINENO: result: no" >&5
3226 echo "${ECHO_T}no" >&6
3227 fi
3228
3229   test -n "$ac_ct_CC" && break
3230 done
3231
3232   CC=$ac_ct_CC
3233 fi
3234
3235 fi
3236
3237
3238 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3239 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3240 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3241 See \`config.log' for more details." >&5
3242 echo "$as_me: error: no acceptable C compiler found in \$PATH
3243 See \`config.log' for more details." >&2;}
3244    { (exit 1); exit 1; }; }; }
3245
3246 # Provide some information about the compiler.
3247 echo "$as_me:$LINENO:" \
3248      "checking for C compiler version" >&5
3249 ac_compiler=`set X $ac_compile; echo $2`
3250 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3251   (eval $ac_compiler --version </dev/null >&5) 2>&5
3252   ac_status=$?
3253   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3254   (exit $ac_status); }
3255 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3256   (eval $ac_compiler -v </dev/null >&5) 2>&5
3257   ac_status=$?
3258   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3259   (exit $ac_status); }
3260 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3261   (eval $ac_compiler -V </dev/null >&5) 2>&5
3262   ac_status=$?
3263   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3264   (exit $ac_status); }
3265
3266 cat >conftest.$ac_ext <<_ACEOF
3267 /* confdefs.h.  */
3268 _ACEOF
3269 cat confdefs.h >>conftest.$ac_ext
3270 cat >>conftest.$ac_ext <<_ACEOF
3271 /* end confdefs.h.  */
3272
3273 int
3274 main ()
3275 {
3276
3277   ;
3278   return 0;
3279 }
3280 _ACEOF
3281 ac_clean_files_save=$ac_clean_files
3282 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3283 # Try to create an executable without -o first, disregard a.out.
3284 # It will help us diagnose broken compilers, and finding out an intuition
3285 # of exeext.
3286 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3287 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3288 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3289 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3290   (eval $ac_link_default) 2>&5
3291   ac_status=$?
3292   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3293   (exit $ac_status); }; then
3294   # Find the output, starting from the most likely.  This scheme is
3295 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3296 # resort.
3297
3298 # Be careful to initialize this variable, since it used to be cached.
3299 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3300 ac_cv_exeext=
3301 # b.out is created by i960 compilers.
3302 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3303 do
3304   test -f "$ac_file" || continue
3305   case $ac_file in
3306     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3307         ;;
3308     conftest.$ac_ext )
3309         # This is the source file.
3310         ;;
3311     [ab].out )
3312         # We found the default executable, but exeext='' is most
3313         # certainly right.
3314         break;;
3315     *.* )
3316         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3317         # FIXME: I believe we export ac_cv_exeext for Libtool,
3318         # but it would be cool to find out if it's true.  Does anybody
3319         # maintain Libtool? --akim.
3320         export ac_cv_exeext
3321         break;;
3322     * )
3323         break;;
3324   esac
3325 done
3326 else
3327   echo "$as_me: failed program was:" >&5
3328 sed 's/^/| /' conftest.$ac_ext >&5
3329
3330 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3331 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3332 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3333 See \`config.log' for more details." >&5
3334 echo "$as_me: error: C compiler cannot create executables
3335 See \`config.log' for more details." >&2;}
3336    { (exit 77); exit 77; }; }; }
3337 fi
3338
3339 ac_exeext=$ac_cv_exeext
3340 echo "$as_me:$LINENO: result: $ac_file" >&5
3341 echo "${ECHO_T}$ac_file" >&6
3342
3343 # Check the compiler produces executables we can run.  If not, either
3344 # the compiler is broken, or we cross compile.
3345 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3346 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3347 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3348 # If not cross compiling, check that we can run a simple program.
3349 if test "$cross_compiling" != yes; then
3350   if { ac_try='./$ac_file'
3351   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3352   (eval $ac_try) 2>&5
3353   ac_status=$?
3354   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3355   (exit $ac_status); }; }; then
3356     cross_compiling=no
3357   else
3358     if test "$cross_compiling" = maybe; then
3359         cross_compiling=yes
3360     else
3361         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3362 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3363 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3364 If you meant to cross compile, use \`--host'.
3365 See \`config.log' for more details." >&5
3366 echo "$as_me: error: cannot run C compiled programs.
3367 If you meant to cross compile, use \`--host'.
3368 See \`config.log' for more details." >&2;}
3369    { (exit 1); exit 1; }; }; }
3370     fi
3371   fi
3372 fi
3373 echo "$as_me:$LINENO: result: yes" >&5
3374 echo "${ECHO_T}yes" >&6
3375
3376 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3377 ac_clean_files=$ac_clean_files_save
3378 # Check the compiler produces executables we can run.  If not, either
3379 # the compiler is broken, or we cross compile.
3380 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3381 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3382 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3383 echo "${ECHO_T}$cross_compiling" >&6
3384
3385 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3386 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3387 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3388   (eval $ac_link) 2>&5
3389   ac_status=$?
3390   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3391   (exit $ac_status); }; then
3392   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3393 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3394 # work properly (i.e., refer to `conftest.exe'), while it won't with
3395 # `rm'.
3396 for ac_file in conftest.exe conftest conftest.*; do
3397   test -f "$ac_file" || continue
3398   case $ac_file in
3399     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3400     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3401           export ac_cv_exeext
3402           break;;
3403     * ) break;;
3404   esac
3405 done
3406 else
3407   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3408 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3409 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3410 See \`config.log' for more details." >&5
3411 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3412 See \`config.log' for more details." >&2;}
3413    { (exit 1); exit 1; }; }; }
3414 fi
3415
3416 rm -f conftest$ac_cv_exeext
3417 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3418 echo "${ECHO_T}$ac_cv_exeext" >&6
3419
3420 rm -f conftest.$ac_ext
3421 EXEEXT=$ac_cv_exeext
3422 ac_exeext=$EXEEXT
3423 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3424 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3425 if test "${ac_cv_objext+set}" = set; then
3426   echo $ECHO_N "(cached) $ECHO_C" >&6
3427 else
3428   cat >conftest.$ac_ext <<_ACEOF
3429 /* confdefs.h.  */
3430 _ACEOF
3431 cat confdefs.h >>conftest.$ac_ext
3432 cat >>conftest.$ac_ext <<_ACEOF
3433 /* end confdefs.h.  */
3434
3435 int
3436 main ()
3437 {
3438
3439   ;
3440   return 0;
3441 }
3442 _ACEOF
3443 rm -f conftest.o conftest.obj
3444 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3445   (eval $ac_compile) 2>&5
3446   ac_status=$?
3447   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3448   (exit $ac_status); }; then
3449   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3450   case $ac_file in
3451     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3452     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3453        break;;
3454   esac
3455 done
3456 else
3457   echo "$as_me: failed program was:" >&5
3458 sed 's/^/| /' conftest.$ac_ext >&5
3459
3460 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3461 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3462 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3463 See \`config.log' for more details." >&5
3464 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3465 See \`config.log' for more details." >&2;}
3466    { (exit 1); exit 1; }; }; }
3467 fi
3468
3469 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3470 fi
3471 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3472 echo "${ECHO_T}$ac_cv_objext" >&6
3473 OBJEXT=$ac_cv_objext
3474 ac_objext=$OBJEXT
3475 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3476 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3477 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3478   echo $ECHO_N "(cached) $ECHO_C" >&6
3479 else
3480   cat >conftest.$ac_ext <<_ACEOF
3481 /* confdefs.h.  */
3482 _ACEOF
3483 cat confdefs.h >>conftest.$ac_ext
3484 cat >>conftest.$ac_ext <<_ACEOF
3485 /* end confdefs.h.  */
3486
3487 int
3488 main ()
3489 {
3490 #ifndef __GNUC__
3491        choke me
3492 #endif
3493
3494   ;
3495   return 0;
3496 }
3497 _ACEOF
3498 rm -f conftest.$ac_objext
3499 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3500   (eval $ac_compile) 2>conftest.er1
3501   ac_status=$?
3502   grep -v '^ *+' conftest.er1 >conftest.err
3503   rm -f conftest.er1
3504   cat conftest.err >&5
3505   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3506   (exit $ac_status); } &&
3507          { ac_try='test -z "$ac_c_werror_flag"
3508                          || test ! -s conftest.err'
3509   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3510   (eval $ac_try) 2>&5
3511   ac_status=$?
3512   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3513   (exit $ac_status); }; } &&
3514          { ac_try='test -s conftest.$ac_objext'
3515   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3516   (eval $ac_try) 2>&5
3517   ac_status=$?
3518   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3519   (exit $ac_status); }; }; then
3520   ac_compiler_gnu=yes
3521 else
3522   echo "$as_me: failed program was:" >&5
3523 sed 's/^/| /' conftest.$ac_ext >&5
3524
3525 ac_compiler_gnu=no
3526 fi
3527 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3528 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3529
3530 fi
3531 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3532 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3533 GCC=`test $ac_compiler_gnu = yes && echo yes`
3534 ac_test_CFLAGS=${CFLAGS+set}
3535 ac_save_CFLAGS=$CFLAGS
3536 CFLAGS="-g"
3537 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3538 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3539 if test "${ac_cv_prog_cc_g+set}" = set; then
3540   echo $ECHO_N "(cached) $ECHO_C" >&6
3541 else
3542   cat >conftest.$ac_ext <<_ACEOF
3543 /* confdefs.h.  */
3544 _ACEOF
3545 cat confdefs.h >>conftest.$ac_ext
3546 cat >>conftest.$ac_ext <<_ACEOF
3547 /* end confdefs.h.  */
3548
3549 int
3550 main ()
3551 {
3552
3553   ;
3554   return 0;
3555 }
3556 _ACEOF
3557 rm -f conftest.$ac_objext
3558 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3559   (eval $ac_compile) 2>conftest.er1
3560   ac_status=$?
3561   grep -v '^ *+' conftest.er1 >conftest.err
3562   rm -f conftest.er1
3563   cat conftest.err >&5
3564   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3565   (exit $ac_status); } &&
3566          { ac_try='test -z "$ac_c_werror_flag"
3567                          || test ! -s conftest.err'
3568   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3569   (eval $ac_try) 2>&5
3570   ac_status=$?
3571   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3572   (exit $ac_status); }; } &&
3573          { ac_try='test -s conftest.$ac_objext'
3574   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3575   (eval $ac_try) 2>&5
3576   ac_status=$?
3577   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3578   (exit $ac_status); }; }; then
3579   ac_cv_prog_cc_g=yes
3580 else
3581   echo "$as_me: failed program was:" >&5
3582 sed 's/^/| /' conftest.$ac_ext >&5
3583
3584 ac_cv_prog_cc_g=no
3585 fi
3586 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3587 fi
3588 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3589 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3590 if test "$ac_test_CFLAGS" = set; then
3591   CFLAGS=$ac_save_CFLAGS
3592 elif test $ac_cv_prog_cc_g = yes; then
3593   if test "$GCC" = yes; then
3594     CFLAGS="-g -O2"
3595   else
3596     CFLAGS="-g"
3597   fi
3598 else
3599   if test "$GCC" = yes; then
3600     CFLAGS="-O2"
3601   else
3602     CFLAGS=
3603   fi
3604 fi
3605 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3606 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3607 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3608   echo $ECHO_N "(cached) $ECHO_C" >&6
3609 else
3610   ac_cv_prog_cc_stdc=no
3611 ac_save_CC=$CC
3612 cat >conftest.$ac_ext <<_ACEOF
3613 /* confdefs.h.  */
3614 _ACEOF
3615 cat confdefs.h >>conftest.$ac_ext
3616 cat >>conftest.$ac_ext <<_ACEOF
3617 /* end confdefs.h.  */
3618 #include <stdarg.h>
3619 #include <stdio.h>
3620 #include <sys/types.h>
3621 #include <sys/stat.h>
3622 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3623 struct buf { int x; };
3624 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3625 static char *e (p, i)
3626      char **p;
3627      int i;
3628 {
3629   return p[i];
3630 }
3631 static char *f (char * (*g) (char **, int), char **p, ...)
3632 {
3633   char *s;
3634   va_list v;
3635   va_start (v,p);
3636   s = g (p, va_arg (v,int));
3637   va_end (v);
3638   return s;
3639 }
3640
3641 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3642    function prototypes and stuff, but not '\xHH' hex character constants.
3643    These don't provoke an error unfortunately, instead are silently treated
3644    as 'x'.  The following induces an error, until -std1 is added to get
3645    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3646    array size at least.  It's necessary to write '\x00'==0 to get something
3647    that's true only with -std1.  */
3648 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3649
3650 int test (int i, double x);
3651 struct s1 {int (*f) (int a);};
3652 struct s2 {int (*f) (double a);};
3653 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3654 int argc;
3655 char **argv;
3656 int
3657 main ()
3658 {
3659 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3660   ;
3661   return 0;
3662 }
3663 _ACEOF
3664 # Don't try gcc -ansi; that turns off useful extensions and
3665 # breaks some systems' header files.
3666 # AIX                   -qlanglvl=ansi
3667 # Ultrix and OSF/1      -std1
3668 # HP-UX 10.20 and later -Ae
3669 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3670 # SVR4                  -Xc -D__EXTENSIONS__
3671 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3672 do
3673   CC="$ac_save_CC $ac_arg"
3674   rm -f conftest.$ac_objext
3675 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3676   (eval $ac_compile) 2>conftest.er1
3677   ac_status=$?
3678   grep -v '^ *+' conftest.er1 >conftest.err
3679   rm -f conftest.er1
3680   cat conftest.err >&5
3681   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3682   (exit $ac_status); } &&
3683          { ac_try='test -z "$ac_c_werror_flag"
3684                          || test ! -s conftest.err'
3685   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3686   (eval $ac_try) 2>&5
3687   ac_status=$?
3688   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3689   (exit $ac_status); }; } &&
3690          { ac_try='test -s conftest.$ac_objext'
3691   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3692   (eval $ac_try) 2>&5
3693   ac_status=$?
3694   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3695   (exit $ac_status); }; }; then
3696   ac_cv_prog_cc_stdc=$ac_arg
3697 break
3698 else
3699   echo "$as_me: failed program was:" >&5
3700 sed 's/^/| /' conftest.$ac_ext >&5
3701
3702 fi
3703 rm -f conftest.err conftest.$ac_objext
3704 done
3705 rm -f conftest.$ac_ext conftest.$ac_objext
3706 CC=$ac_save_CC
3707
3708 fi
3709
3710 case "x$ac_cv_prog_cc_stdc" in
3711   x|xno)
3712     echo "$as_me:$LINENO: result: none needed" >&5
3713 echo "${ECHO_T}none needed" >&6 ;;
3714   *)
3715     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3716 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3717     CC="$CC $ac_cv_prog_cc_stdc" ;;
3718 esac
3719
3720 # Some people use a C++ compiler to compile C.  Since we use `exit',
3721 # in C++ we need to declare it.  In case someone uses the same compiler
3722 # for both compiling C and C++ we need to have the C++ compiler decide
3723 # the declaration of exit, since it's the most demanding environment.
3724 cat >conftest.$ac_ext <<_ACEOF
3725 #ifndef __cplusplus
3726   choke me
3727 #endif
3728 _ACEOF
3729 rm -f conftest.$ac_objext
3730 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3731   (eval $ac_compile) 2>conftest.er1
3732   ac_status=$?
3733   grep -v '^ *+' conftest.er1 >conftest.err
3734   rm -f conftest.er1
3735   cat conftest.err >&5
3736   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3737   (exit $ac_status); } &&
3738          { ac_try='test -z "$ac_c_werror_flag"
3739                          || test ! -s conftest.err'
3740   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3741   (eval $ac_try) 2>&5
3742   ac_status=$?
3743   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3744   (exit $ac_status); }; } &&
3745          { ac_try='test -s conftest.$ac_objext'
3746   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3747   (eval $ac_try) 2>&5
3748   ac_status=$?
3749   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3750   (exit $ac_status); }; }; then
3751   for ac_declaration in \
3752    '' \
3753    'extern "C" void std::exit (int) throw (); using std::exit;' \
3754    'extern "C" void std::exit (int); using std::exit;' \
3755    'extern "C" void exit (int) throw ();' \
3756    'extern "C" void exit (int);' \
3757    'void exit (int);'
3758 do
3759   cat >conftest.$ac_ext <<_ACEOF
3760 /* confdefs.h.  */
3761 _ACEOF
3762 cat confdefs.h >>conftest.$ac_ext
3763 cat >>conftest.$ac_ext <<_ACEOF
3764 /* end confdefs.h.  */
3765 $ac_declaration
3766 #include <stdlib.h>
3767 int
3768 main ()
3769 {
3770 exit (42);
3771   ;
3772   return 0;
3773 }
3774 _ACEOF
3775 rm -f conftest.$ac_objext
3776 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3777   (eval $ac_compile) 2>conftest.er1
3778   ac_status=$?
3779   grep -v '^ *+' conftest.er1 >conftest.err
3780   rm -f conftest.er1
3781   cat conftest.err >&5
3782   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3783   (exit $ac_status); } &&
3784          { ac_try='test -z "$ac_c_werror_flag"
3785                          || test ! -s conftest.err'
3786   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3787   (eval $ac_try) 2>&5
3788   ac_status=$?
3789   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3790   (exit $ac_status); }; } &&
3791          { ac_try='test -s conftest.$ac_objext'
3792   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3793   (eval $ac_try) 2>&5
3794   ac_status=$?
3795   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3796   (exit $ac_status); }; }; then
3797   :
3798 else
3799   echo "$as_me: failed program was:" >&5
3800 sed 's/^/| /' conftest.$ac_ext >&5
3801
3802 continue
3803 fi
3804 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3805   cat >conftest.$ac_ext <<_ACEOF
3806 /* confdefs.h.  */
3807 _ACEOF
3808 cat confdefs.h >>conftest.$ac_ext
3809 cat >>conftest.$ac_ext <<_ACEOF
3810 /* end confdefs.h.  */
3811 $ac_declaration
3812 int
3813 main ()
3814 {
3815 exit (42);
3816   ;
3817   return 0;
3818 }
3819 _ACEOF
3820 rm -f conftest.$ac_objext
3821 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3822   (eval $ac_compile) 2>conftest.er1
3823   ac_status=$?
3824   grep -v '^ *+' conftest.er1 >conftest.err
3825   rm -f conftest.er1
3826   cat conftest.err >&5
3827   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3828   (exit $ac_status); } &&
3829          { ac_try='test -z "$ac_c_werror_flag"
3830                          || test ! -s conftest.err'
3831   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3832   (eval $ac_try) 2>&5
3833   ac_status=$?
3834   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3835   (exit $ac_status); }; } &&
3836          { ac_try='test -s conftest.$ac_objext'
3837   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3838   (eval $ac_try) 2>&5
3839   ac_status=$?
3840   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3841   (exit $ac_status); }; }; then
3842   break
3843 else
3844   echo "$as_me: failed program was:" >&5
3845 sed 's/^/| /' conftest.$ac_ext >&5
3846
3847 fi
3848 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3849 done
3850 rm -f conftest*
3851 if test -n "$ac_declaration"; then
3852   echo '#ifdef __cplusplus' >>confdefs.h
3853   echo $ac_declaration      >>confdefs.h
3854   echo '#endif'             >>confdefs.h
3855 fi
3856
3857 else
3858   echo "$as_me: failed program was:" >&5
3859 sed 's/^/| /' conftest.$ac_ext >&5
3860
3861 fi
3862 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3863 ac_ext=c
3864 ac_cpp='$CPP $CPPFLAGS'
3865 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3866 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3867 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3868
3869 ac_ext=cc
3870 ac_cpp='$CXXCPP $CPPFLAGS'
3871 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3872 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3873 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3874 if test -n "$ac_tool_prefix"; then
3875   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3876   do
3877     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3878 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3879 echo "$as_me:$LINENO: checking for $ac_word" >&5
3880 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3881 if test "${ac_cv_prog_CXX+set}" = set; then
3882   echo $ECHO_N "(cached) $ECHO_C" >&6
3883 else
3884   if test -n "$CXX"; then
3885   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3886 else
3887 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3888 for as_dir in $PATH
3889 do
3890   IFS=$as_save_IFS
3891   test -z "$as_dir" && as_dir=.
3892   for ac_exec_ext in '' $ac_executable_extensions; do
3893   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3894     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3895     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3896     break 2
3897   fi
3898 done
3899 done
3900
3901 fi
3902 fi
3903 CXX=$ac_cv_prog_CXX
3904 if test -n "$CXX"; then
3905   echo "$as_me:$LINENO: result: $CXX" >&5
3906 echo "${ECHO_T}$CXX" >&6
3907 else
3908   echo "$as_me:$LINENO: result: no" >&5
3909 echo "${ECHO_T}no" >&6
3910 fi
3911
3912     test -n "$CXX" && break
3913   done
3914 fi
3915 if test -z "$CXX"; then
3916   ac_ct_CXX=$CXX
3917   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3918 do
3919   # Extract the first word of "$ac_prog", so it can be a program name with args.
3920 set dummy $ac_prog; ac_word=$2
3921 echo "$as_me:$LINENO: checking for $ac_word" >&5
3922 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3923 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3924   echo $ECHO_N "(cached) $ECHO_C" >&6
3925 else
3926   if test -n "$ac_ct_CXX"; then
3927   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3928 else
3929 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3930 for as_dir in $PATH
3931 do
3932   IFS=$as_save_IFS
3933   test -z "$as_dir" && as_dir=.
3934   for ac_exec_ext in '' $ac_executable_extensions; do
3935   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3936     ac_cv_prog_ac_ct_CXX="$ac_prog"
3937     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3938     break 2
3939   fi
3940 done
3941 done
3942
3943 fi
3944 fi
3945 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3946 if test -n "$ac_ct_CXX"; then
3947   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3948 echo "${ECHO_T}$ac_ct_CXX" >&6
3949 else
3950   echo "$as_me:$LINENO: result: no" >&5
3951 echo "${ECHO_T}no" >&6
3952 fi
3953
3954   test -n "$ac_ct_CXX" && break
3955 done
3956 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3957
3958   CXX=$ac_ct_CXX
3959 fi
3960
3961
3962 # Provide some information about the compiler.
3963 echo "$as_me:$LINENO:" \
3964      "checking for C++ compiler version" >&5
3965 ac_compiler=`set X $ac_compile; echo $2`
3966 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3967   (eval $ac_compiler --version </dev/null >&5) 2>&5
3968   ac_status=$?
3969   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3970   (exit $ac_status); }
3971 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3972   (eval $ac_compiler -v </dev/null >&5) 2>&5
3973   ac_status=$?
3974   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3975   (exit $ac_status); }
3976 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3977   (eval $ac_compiler -V </dev/null >&5) 2>&5
3978   ac_status=$?
3979   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3980   (exit $ac_status); }
3981
3982 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3983 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3984 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3985   echo $ECHO_N "(cached) $ECHO_C" >&6
3986 else
3987   cat >conftest.$ac_ext <<_ACEOF
3988 /* confdefs.h.  */
3989 _ACEOF
3990 cat confdefs.h >>conftest.$ac_ext
3991 cat >>conftest.$ac_ext <<_ACEOF
3992 /* end confdefs.h.  */
3993
3994 int
3995 main ()
3996 {
3997 #ifndef __GNUC__
3998        choke me
3999 #endif
4000
4001   ;
4002   return 0;
4003 }
4004 _ACEOF
4005 rm -f conftest.$ac_objext
4006 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4007   (eval $ac_compile) 2>conftest.er1
4008   ac_status=$?
4009   grep -v '^ *+' conftest.er1 >conftest.err
4010   rm -f conftest.er1
4011   cat conftest.err >&5
4012   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4013   (exit $ac_status); } &&
4014          { ac_try='test -z "$ac_cxx_werror_flag"
4015                          || test ! -s conftest.err'
4016   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4017   (eval $ac_try) 2>&5
4018   ac_status=$?
4019   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4020   (exit $ac_status); }; } &&
4021          { ac_try='test -s conftest.$ac_objext'
4022   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4023   (eval $ac_try) 2>&5
4024   ac_status=$?
4025   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4026   (exit $ac_status); }; }; then
4027   ac_compiler_gnu=yes
4028 else
4029   echo "$as_me: failed program was:" >&5
4030 sed 's/^/| /' conftest.$ac_ext >&5
4031
4032 ac_compiler_gnu=no
4033 fi
4034 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4035 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4036
4037 fi
4038 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4039 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4040 GXX=`test $ac_compiler_gnu = yes && echo yes`
4041 ac_test_CXXFLAGS=${CXXFLAGS+set}
4042 ac_save_CXXFLAGS=$CXXFLAGS
4043 CXXFLAGS="-g"
4044 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4045 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4046 if test "${ac_cv_prog_cxx_g+set}" = set; then
4047   echo $ECHO_N "(cached) $ECHO_C" >&6
4048 else
4049   cat >conftest.$ac_ext <<_ACEOF
4050 /* confdefs.h.  */
4051 _ACEOF
4052 cat confdefs.h >>conftest.$ac_ext
4053 cat >>conftest.$ac_ext <<_ACEOF
4054 /* end confdefs.h.  */
4055
4056 int
4057 main ()
4058 {
4059
4060   ;
4061   return 0;
4062 }
4063 _ACEOF
4064 rm -f conftest.$ac_objext
4065 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4066   (eval $ac_compile) 2>conftest.er1
4067   ac_status=$?
4068   grep -v '^ *+' conftest.er1 >conftest.err
4069   rm -f conftest.er1
4070   cat conftest.err >&5
4071   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4072   (exit $ac_status); } &&
4073          { ac_try='test -z "$ac_cxx_werror_flag"
4074                          || test ! -s conftest.err'
4075   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4076   (eval $ac_try) 2>&5
4077   ac_status=$?
4078   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4079   (exit $ac_status); }; } &&
4080          { ac_try='test -s conftest.$ac_objext'
4081   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4082   (eval $ac_try) 2>&5
4083   ac_status=$?
4084   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4085   (exit $ac_status); }; }; then
4086   ac_cv_prog_cxx_g=yes
4087 else
4088   echo "$as_me: failed program was:" >&5
4089 sed 's/^/| /' conftest.$ac_ext >&5
4090
4091 ac_cv_prog_cxx_g=no
4092 fi
4093 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4094 fi
4095 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4096 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4097 if test "$ac_test_CXXFLAGS" = set; then
4098   CXXFLAGS=$ac_save_CXXFLAGS
4099 elif test $ac_cv_prog_cxx_g = yes; then
4100   if test "$GXX" = yes; then
4101     CXXFLAGS="-g -O2"
4102   else
4103     CXXFLAGS="-g"
4104   fi
4105 else
4106   if test "$GXX" = yes; then
4107     CXXFLAGS="-O2"
4108   else
4109     CXXFLAGS=
4110   fi
4111 fi
4112 for ac_declaration in \
4113    '' \
4114    'extern "C" void std::exit (int) throw (); using std::exit;' \
4115    'extern "C" void std::exit (int); using std::exit;' \
4116    'extern "C" void exit (int) throw ();' \
4117    'extern "C" void exit (int);' \
4118    'void exit (int);'
4119 do
4120   cat >conftest.$ac_ext <<_ACEOF
4121 /* confdefs.h.  */
4122 _ACEOF
4123 cat confdefs.h >>conftest.$ac_ext
4124 cat >>conftest.$ac_ext <<_ACEOF
4125 /* end confdefs.h.  */
4126 $ac_declaration
4127 #include <stdlib.h>
4128 int
4129 main ()
4130 {
4131 exit (42);
4132   ;
4133   return 0;
4134 }
4135 _ACEOF
4136 rm -f conftest.$ac_objext
4137 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4138   (eval $ac_compile) 2>conftest.er1
4139   ac_status=$?
4140   grep -v '^ *+' conftest.er1 >conftest.err
4141   rm -f conftest.er1
4142   cat conftest.err >&5
4143   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4144   (exit $ac_status); } &&
4145          { ac_try='test -z "$ac_cxx_werror_flag"
4146                          || test ! -s conftest.err'
4147   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4148   (eval $ac_try) 2>&5
4149   ac_status=$?
4150   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4151   (exit $ac_status); }; } &&
4152          { ac_try='test -s conftest.$ac_objext'
4153   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4154   (eval $ac_try) 2>&5
4155   ac_status=$?
4156   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4157   (exit $ac_status); }; }; then
4158   :
4159 else
4160   echo "$as_me: failed program was:" >&5
4161 sed 's/^/| /' conftest.$ac_ext >&5
4162
4163 continue
4164 fi
4165 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4166   cat >conftest.$ac_ext <<_ACEOF
4167 /* confdefs.h.  */
4168 _ACEOF
4169 cat confdefs.h >>conftest.$ac_ext
4170 cat >>conftest.$ac_ext <<_ACEOF
4171 /* end confdefs.h.  */
4172 $ac_declaration
4173 int
4174 main ()
4175 {
4176 exit (42);
4177   ;
4178   return 0;
4179 }
4180 _ACEOF
4181 rm -f conftest.$ac_objext
4182 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4183   (eval $ac_compile) 2>conftest.er1
4184   ac_status=$?
4185   grep -v '^ *+' conftest.er1 >conftest.err
4186   rm -f conftest.er1
4187   cat conftest.err >&5
4188   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4189   (exit $ac_status); } &&
4190          { ac_try='test -z "$ac_cxx_werror_flag"
4191                          || test ! -s conftest.err'
4192   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4193   (eval $ac_try) 2>&5
4194   ac_status=$?
4195   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4196   (exit $ac_status); }; } &&
4197          { ac_try='test -s conftest.$ac_objext'
4198   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4199   (eval $ac_try) 2>&5
4200   ac_status=$?
4201   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4202   (exit $ac_status); }; }; then
4203   break
4204 else
4205   echo "$as_me: failed program was:" >&5
4206 sed 's/^/| /' conftest.$ac_ext >&5
4207
4208 fi
4209 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4210 done
4211 rm -f conftest*
4212 if test -n "$ac_declaration"; then
4213   echo '#ifdef __cplusplus' >>confdefs.h
4214   echo $ac_declaration      >>confdefs.h
4215   echo '#endif'             >>confdefs.h
4216 fi
4217
4218 ac_ext=c
4219 ac_cpp='$CPP $CPPFLAGS'
4220 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4221 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4222 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4223
4224
4225 # We must set the default linker to the linker used by gcc for the correct
4226 # operation of libtool.  If LD is not defined and we are using gcc, try to
4227 # set the LD default to the ld used by gcc.
4228 if test -z "$LD"; then
4229   if test "$GCC" = yes; then
4230     case $build in
4231     *-*-mingw*)
4232       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4233     *)
4234       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4235     esac
4236     case $gcc_prog_ld in
4237     # Accept absolute paths.
4238     [\\/]* | [A-Za-z]:[\\/]*)
4239       LD="$gcc_prog_ld" ;;
4240     esac
4241   fi
4242 fi
4243
4244
4245
4246
4247 if test -n "$ac_tool_prefix"; then
4248   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4249 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4250 echo "$as_me:$LINENO: checking for $ac_word" >&5
4251 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4252 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4253   echo $ECHO_N "(cached) $ECHO_C" >&6
4254 else
4255   if test -n "$GNATBIND"; then
4256   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4257 else
4258 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4259 for as_dir in $PATH
4260 do
4261   IFS=$as_save_IFS
4262   test -z "$as_dir" && as_dir=.
4263   for ac_exec_ext in '' $ac_executable_extensions; do
4264   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4265     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4266     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4267     break 2
4268   fi
4269 done
4270 done
4271
4272 fi
4273 fi
4274 GNATBIND=$ac_cv_prog_GNATBIND
4275 if test -n "$GNATBIND"; then
4276   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4277 echo "${ECHO_T}$GNATBIND" >&6
4278 else
4279   echo "$as_me:$LINENO: result: no" >&5
4280 echo "${ECHO_T}no" >&6
4281 fi
4282
4283 fi
4284 if test -z "$ac_cv_prog_GNATBIND"; then
4285   ac_ct_GNATBIND=$GNATBIND
4286   # Extract the first word of "gnatbind", so it can be a program name with args.
4287 set dummy gnatbind; ac_word=$2
4288 echo "$as_me:$LINENO: checking for $ac_word" >&5
4289 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4290 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4291   echo $ECHO_N "(cached) $ECHO_C" >&6
4292 else
4293   if test -n "$ac_ct_GNATBIND"; then
4294   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4295 else
4296 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4297 for as_dir in $PATH
4298 do
4299   IFS=$as_save_IFS
4300   test -z "$as_dir" && as_dir=.
4301   for ac_exec_ext in '' $ac_executable_extensions; do
4302   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4303     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4304     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4305     break 2
4306   fi
4307 done
4308 done
4309
4310   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4311 fi
4312 fi
4313 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4314 if test -n "$ac_ct_GNATBIND"; then
4315   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4316 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4317 else
4318   echo "$as_me:$LINENO: result: no" >&5
4319 echo "${ECHO_T}no" >&6
4320 fi
4321
4322   GNATBIND=$ac_ct_GNATBIND
4323 else
4324   GNATBIND="$ac_cv_prog_GNATBIND"
4325 fi
4326
4327 if test -n "$ac_tool_prefix"; then
4328   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4329 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4330 echo "$as_me:$LINENO: checking for $ac_word" >&5
4331 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4332 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4333   echo $ECHO_N "(cached) $ECHO_C" >&6
4334 else
4335   if test -n "$GNATMAKE"; then
4336   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4337 else
4338 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4339 for as_dir in $PATH
4340 do
4341   IFS=$as_save_IFS
4342   test -z "$as_dir" && as_dir=.
4343   for ac_exec_ext in '' $ac_executable_extensions; do
4344   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4345     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4346     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4347     break 2
4348   fi
4349 done
4350 done
4351
4352 fi
4353 fi
4354 GNATMAKE=$ac_cv_prog_GNATMAKE
4355 if test -n "$GNATMAKE"; then
4356   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4357 echo "${ECHO_T}$GNATMAKE" >&6
4358 else
4359   echo "$as_me:$LINENO: result: no" >&5
4360 echo "${ECHO_T}no" >&6
4361 fi
4362
4363 fi
4364 if test -z "$ac_cv_prog_GNATMAKE"; then
4365   ac_ct_GNATMAKE=$GNATMAKE
4366   # Extract the first word of "gnatmake", so it can be a program name with args.
4367 set dummy gnatmake; ac_word=$2
4368 echo "$as_me:$LINENO: checking for $ac_word" >&5
4369 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4370 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4371   echo $ECHO_N "(cached) $ECHO_C" >&6
4372 else
4373   if test -n "$ac_ct_GNATMAKE"; then
4374   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4375 else
4376 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4377 for as_dir in $PATH
4378 do
4379   IFS=$as_save_IFS
4380   test -z "$as_dir" && as_dir=.
4381   for ac_exec_ext in '' $ac_executable_extensions; do
4382   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4383     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4384     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4385     break 2
4386   fi
4387 done
4388 done
4389
4390   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4391 fi
4392 fi
4393 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4394 if test -n "$ac_ct_GNATMAKE"; then
4395   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4396 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4397 else
4398   echo "$as_me:$LINENO: result: no" >&5
4399 echo "${ECHO_T}no" >&6
4400 fi
4401
4402   GNATMAKE=$ac_ct_GNATMAKE
4403 else
4404   GNATMAKE="$ac_cv_prog_GNATMAKE"
4405 fi
4406
4407 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4408 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4409 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4410   echo $ECHO_N "(cached) $ECHO_C" >&6
4411 else
4412   cat >conftest.adb <<EOF
4413 procedure conftest is begin null; end conftest;
4414 EOF
4415 acx_cv_cc_gcc_supports_ada=no
4416 # There is a bug in old released versions of GCC which causes the
4417 # driver to exit successfully when the appropriate language module
4418 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4419 # Therefore we must check for the error message as well as an
4420 # unsuccessful exit.
4421 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4422 # given a .adb file, but produce no object file.  So we must check
4423 # if an object file was really produced to guard against this.
4424 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4425 if test x"$errors" = x && test -f conftest.$ac_objext; then
4426   acx_cv_cc_gcc_supports_ada=yes
4427 fi
4428 rm -f conftest.*
4429 fi
4430 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4431 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4432
4433 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4434   have_gnat=yes
4435 else
4436   have_gnat=no
4437 fi
4438
4439 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4440 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4441 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4442   echo $ECHO_N "(cached) $ECHO_C" >&6
4443 else
4444    echo abfoo >t1
4445   echo cdfoo >t2
4446   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4447   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4448     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4449       :
4450     else
4451       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4452     fi
4453   fi
4454   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4455     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4456       :
4457     else
4458       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4459     fi
4460   fi
4461   rm t1 t2
4462
4463 fi
4464 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4465 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4466 do_compare="$gcc_cv_prog_cmp_skip"
4467
4468
4469
4470 # Check for GMP and MPFR
4471 gmplibs="-lmpfr -lgmp"
4472 gmpinc=
4473 have_gmp=no
4474
4475 # Specify a location for mpfr
4476 # check for this first so it ends up on the link line before gmp.
4477
4478 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4479 if test "${with_mpfr_dir+set}" = set; then
4480   withval="$with_mpfr_dir"
4481   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4482 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4483 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4484 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4485    { (exit 1); exit 1; }; }
4486 fi;
4487
4488
4489 # Check whether --with-mpfr or --without-mpfr was given.
4490 if test "${with_mpfr+set}" = set; then
4491   withval="$with_mpfr"
4492
4493 fi;
4494
4495 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4496 if test "${with_mpfr_include+set}" = set; then
4497   withval="$with_mpfr_include"
4498
4499 fi;
4500
4501 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4502 if test "${with_mpfr_lib+set}" = set; then
4503   withval="$with_mpfr_lib"
4504
4505 fi;
4506
4507 if test "x$with_mpfr" != x; then
4508   gmplibs="-L$with_mpfr/lib $gmplibs"
4509   gmpinc="-I$with_mpfr/include"
4510 fi
4511 if test "x$with_mpfr_include" != x; then
4512   gmpinc="-I$with_mpfr_include"
4513 fi
4514 if test "x$with_mpfr_lib" != x; then
4515   gmplibs="-L$with_mpfr_lib $gmplibs"
4516 fi
4517 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4518   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4519   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4520   # Do not test the mpfr version.  Assume that it is sufficient, since
4521   # it is in the source tree, and the library has not been built yet
4522   # but it would be included on the link line in the version check below
4523   # hence making the test fail.
4524   have_gmp=yes
4525 fi
4526
4527 # Specify a location for gmp
4528
4529 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4530 if test "${with_gmp_dir+set}" = set; then
4531   withval="$with_gmp_dir"
4532   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4533 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4534 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4535 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4536    { (exit 1); exit 1; }; }
4537 fi;
4538
4539
4540 # Check whether --with-gmp or --without-gmp was given.
4541 if test "${with_gmp+set}" = set; then
4542   withval="$with_gmp"
4543
4544 fi;
4545
4546 # Check whether --with-gmp_include or --without-gmp_include was given.
4547 if test "${with_gmp_include+set}" = set; then
4548   withval="$with_gmp_include"
4549
4550 fi;
4551
4552 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4553 if test "${with_gmp_lib+set}" = set; then
4554   withval="$with_gmp_lib"
4555
4556 fi;
4557
4558
4559 if test "x$with_gmp" != x; then
4560   gmplibs="-L$with_gmp/lib $gmplibs"
4561   gmpinc="-I$with_gmp/include $gmpinc"
4562 fi
4563 if test "x$with_gmp_include" != x; then
4564   gmpinc="-I$with_gmp_include $gmpinc"
4565 fi
4566 if test "x$with_gmp_lib" != x; then
4567   gmplibs="-L$with_gmp_lib $gmplibs"
4568 fi
4569 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4570   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4571   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4572   # Do not test the gmp version.  Assume that it is sufficient, since
4573   # it is in the source tree, and the library has not been built yet
4574   # but it would be included on the link line in the version check below
4575   # hence making the test fail.
4576   have_gmp=yes
4577 fi
4578
4579 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4580   have_gmp=yes
4581   saved_CFLAGS="$CFLAGS"
4582   CFLAGS="$CFLAGS $gmpinc"
4583   # Check GMP actually works
4584   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4585 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4586
4587 cat >conftest.$ac_ext <<_ACEOF
4588 /* confdefs.h.  */
4589 _ACEOF
4590 cat confdefs.h >>conftest.$ac_ext
4591 cat >>conftest.$ac_ext <<_ACEOF
4592 /* end confdefs.h.  */
4593 #include "gmp.h"
4594 int
4595 main ()
4596 {
4597
4598   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4599   choke me
4600   #endif
4601
4602   ;
4603   return 0;
4604 }
4605 _ACEOF
4606 rm -f conftest.$ac_objext
4607 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4608   (eval $ac_compile) 2>conftest.er1
4609   ac_status=$?
4610   grep -v '^ *+' conftest.er1 >conftest.err
4611   rm -f conftest.er1
4612   cat conftest.err >&5
4613   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4614   (exit $ac_status); } &&
4615          { ac_try='test -z "$ac_c_werror_flag"
4616                          || test ! -s conftest.err'
4617   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4618   (eval $ac_try) 2>&5
4619   ac_status=$?
4620   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4621   (exit $ac_status); }; } &&
4622          { ac_try='test -s conftest.$ac_objext'
4623   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4624   (eval $ac_try) 2>&5
4625   ac_status=$?
4626   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4627   (exit $ac_status); }; }; then
4628   echo "$as_me:$LINENO: result: yes" >&5
4629 echo "${ECHO_T}yes" >&6
4630 else
4631   echo "$as_me: failed program was:" >&5
4632 sed 's/^/| /' conftest.$ac_ext >&5
4633
4634 echo "$as_me:$LINENO: result: no" >&5
4635 echo "${ECHO_T}no" >&6; have_gmp=no
4636 fi
4637 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4638
4639   if test x"$have_gmp" = xyes; then
4640     saved_LIBS="$LIBS"
4641     LIBS="$LIBS $gmplibs"
4642         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4643 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4644     cat >conftest.$ac_ext <<_ACEOF
4645 /* confdefs.h.  */
4646 _ACEOF
4647 cat confdefs.h >>conftest.$ac_ext
4648 cat >>conftest.$ac_ext <<_ACEOF
4649 /* end confdefs.h.  */
4650 #include <gmp.h>
4651     #include <mpfr.h>
4652 int
4653 main ()
4654 {
4655
4656     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4657     choke me
4658     #endif
4659     mpfr_t n;
4660     mpfr_t x;
4661     int t;
4662     mpfr_init (n);
4663     mpfr_init (x);
4664     mpfr_atan2 (n, n, x, GMP_RNDN);
4665     mpfr_erfc (n, x, GMP_RNDN);
4666     mpfr_subnormalize (x, t, GMP_RNDN);
4667
4668   ;
4669   return 0;
4670 }
4671 _ACEOF
4672 rm -f conftest.$ac_objext conftest$ac_exeext
4673 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4674   (eval $ac_link) 2>conftest.er1
4675   ac_status=$?
4676   grep -v '^ *+' conftest.er1 >conftest.err
4677   rm -f conftest.er1
4678   cat conftest.err >&5
4679   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4680   (exit $ac_status); } &&
4681          { ac_try='test -z "$ac_c_werror_flag"
4682                          || test ! -s conftest.err'
4683   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4684   (eval $ac_try) 2>&5
4685   ac_status=$?
4686   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4687   (exit $ac_status); }; } &&
4688          { ac_try='test -s conftest$ac_exeext'
4689   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4690   (eval $ac_try) 2>&5
4691   ac_status=$?
4692   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4693   (exit $ac_status); }; }; then
4694   cat >conftest.$ac_ext <<_ACEOF
4695 /* confdefs.h.  */
4696 _ACEOF
4697 cat confdefs.h >>conftest.$ac_ext
4698 cat >>conftest.$ac_ext <<_ACEOF
4699 /* end confdefs.h.  */
4700 #include <gmp.h>
4701     #include <mpfr.h>
4702 int
4703 main ()
4704 {
4705
4706     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4707     choke me
4708     #endif
4709     mpfr_t n; mpfr_init(n);
4710
4711   ;
4712   return 0;
4713 }
4714 _ACEOF
4715 rm -f conftest.$ac_objext conftest$ac_exeext
4716 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4717   (eval $ac_link) 2>conftest.er1
4718   ac_status=$?
4719   grep -v '^ *+' conftest.er1 >conftest.err
4720   rm -f conftest.er1
4721   cat conftest.err >&5
4722   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4723   (exit $ac_status); } &&
4724          { ac_try='test -z "$ac_c_werror_flag"
4725                          || test ! -s conftest.err'
4726   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4727   (eval $ac_try) 2>&5
4728   ac_status=$?
4729   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4730   (exit $ac_status); }; } &&
4731          { ac_try='test -s conftest$ac_exeext'
4732   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4733   (eval $ac_try) 2>&5
4734   ac_status=$?
4735   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4736   (exit $ac_status); }; }; then
4737   echo "$as_me:$LINENO: result: yes" >&5
4738 echo "${ECHO_T}yes" >&6
4739 else
4740   echo "$as_me: failed program was:" >&5
4741 sed 's/^/| /' conftest.$ac_ext >&5
4742
4743 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4744 echo "${ECHO_T}buggy but acceptable" >&6
4745 fi
4746 rm -f conftest.err conftest.$ac_objext \
4747       conftest$ac_exeext conftest.$ac_ext
4748 else
4749   echo "$as_me: failed program was:" >&5
4750 sed 's/^/| /' conftest.$ac_ext >&5
4751
4752 echo "$as_me:$LINENO: result: no" >&5
4753 echo "${ECHO_T}no" >&6; have_gmp=no
4754 fi
4755 rm -f conftest.err conftest.$ac_objext \
4756       conftest$ac_exeext conftest.$ac_ext
4757       LIBS="$saved_LIBS"
4758   fi
4759   CFLAGS="$saved_CFLAGS"
4760
4761   if test x$have_gmp != xyes; then
4762     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4763 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4764 Copies of these libraries' source code can be found at their respective
4765 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4766 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4767 If you obtained GMP and/or MPFR from a vendor distribution package, make
4768 sure that you have installed both the libraries and the header files.
4769 They may be located in separate packages." >&5
4770 echo "$as_me: 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." >&2;}
4778    { (exit 1); exit 1; }; }
4779   fi
4780 fi
4781
4782 # Flags needed for both GMP and/or MPFR
4783
4784
4785
4786 # By default, C is the only stage 1 language.
4787 stage1_languages=,c,
4788
4789 # Figure out what language subdirectories are present.
4790 # Look if the user specified --enable-languages="..."; if not, use
4791 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4792 # go away some day.
4793 # NB:  embedded tabs in this IF block -- do not untabify
4794 if test -d ${srcdir}/gcc; then
4795   if test x"${enable_languages+set}" != xset; then
4796     if test x"${LANGUAGES+set}" = xset; then
4797       enable_languages="${LANGUAGES}"
4798         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4799     else
4800       enable_languages=all
4801     fi
4802   else
4803     if test x"${enable_languages}" = x ||
4804        test x"${enable_languages}" = xyes;
4805        then
4806       echo configure.in: --enable-languages needs at least one language argument 1>&2
4807       exit 1
4808     fi
4809   fi
4810   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4811
4812   # 'f95' is the old name for the 'fortran' language. We issue a warning
4813   # and make the substitution.
4814   case ,${enable_languages}, in
4815     *,f95,*)
4816       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4817       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4818       ;;
4819   esac
4820
4821   # First scan to see if an enabled language requires some other language.
4822   # We assume that a given config-lang.in will list all the language
4823   # front ends it requires, even if some are required indirectly.
4824   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4825     case ${lang_frag} in
4826       ..) ;;
4827       # The odd quoting in the next line works around
4828       # an apparent bug in bash 1.12 on linux.
4829       ${srcdir}/gcc/[*]/config-lang.in) ;;
4830       *)
4831         # From the config-lang.in, get $language, $lang_requires
4832         language=
4833         lang_requires=
4834         . ${lang_frag}
4835         for other in ${lang_requires} ; do
4836           case ,${enable_languages}, in
4837             *,$other,*) ;;
4838             *,all,*) ;;
4839             *,$language,*)
4840               echo " \`$other' language required by \`$language'; enabling" 1>&2
4841               enable_languages="${enable_languages},${other}"
4842               ;;
4843           esac
4844         done
4845         ;;
4846     esac
4847   done
4848
4849   new_enable_languages=,c,
4850   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4851   potential_languages=,c,
4852
4853   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4854     case ${lang_frag} in
4855       ..) ;;
4856       # The odd quoting in the next line works around
4857       # an apparent bug in bash 1.12 on linux.
4858       ${srcdir}/gcc/[*]/config-lang.in) ;;
4859       *)
4860         # From the config-lang.in, get $language, $target_libs,
4861         # $lang_dirs, $boot_language, and $build_by_default
4862         language=
4863         target_libs=
4864         lang_dirs=
4865         subdir_requires=
4866         boot_language=no
4867         build_by_default=yes
4868         . ${lang_frag}
4869         if test x${language} = x; then
4870           echo "${lang_frag} doesn't set \$language." 1>&2
4871           exit 1
4872         fi
4873
4874         case ,${enable_languages}, in
4875           *,${language},*)
4876             # Language was explicitly selected; include it.
4877             add_this_lang=yes
4878             ;;
4879           *,all,*)
4880             # 'all' was selected, select it if it is a default language
4881             add_this_lang=${build_by_default}
4882             ;;
4883           *)
4884             add_this_lang=no
4885             ;;
4886         esac
4887
4888         # Disable languages that need other directories if these aren't available.
4889         for i in $subdir_requires; do
4890           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4891           case ,${enable_languages}, in
4892             *,${language},*)
4893               # Specifically requested language; tell them.
4894               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4895 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4896    { (exit 1); exit 1; }; }
4897               ;;
4898             *)
4899               # Silently disable.
4900               add_this_lang=unsupported
4901               ;;
4902           esac
4903         done
4904
4905         # Disable Ada if no preexisting GNAT is available.
4906         case ,${enable_languages},:${language}:${have_gnat} in
4907           *,${language},*:ada:no)
4908             # Specifically requested language; tell them.
4909             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4910 echo "$as_me: error: GNAT is required to build $language" >&2;}
4911    { (exit 1); exit 1; }; }
4912             ;;
4913           *:ada:no)
4914             # Silently disable.
4915             add_this_lang=unsupported
4916             ;;
4917         esac
4918
4919         # Disable a language that is unsupported by the target.
4920         case " $unsupported_languages " in
4921           *" $language "*)
4922             add_this_lang=unsupported
4923             ;;
4924         esac
4925
4926         case $add_this_lang in
4927           unsupported)
4928             # Remove language-dependent dirs.
4929             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4930             ;;
4931           no)
4932             # Remove language-dependent dirs; still show language as supported.
4933             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4934             potential_languages="${potential_languages}${language},"
4935             ;;
4936           yes)
4937             new_enable_languages="${new_enable_languages}${language},"
4938             potential_languages="${potential_languages}${language},"
4939             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4940             case ${boot_language} in
4941               yes)
4942                 # Add to (comma-separated) list of stage 1 languages.
4943                 stage1_languages="${stage1_languages}${language},"
4944                 ;;
4945             esac
4946             ;;
4947         esac
4948         ;;
4949     esac
4950   done
4951
4952   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4953 if test "${enable_stage1_languages+set}" = set; then
4954   enableval="$enable_stage1_languages"
4955   case ,${enable_stage1_languages}, in
4956     ,no,|,,)
4957       # Set it to something that will have no effect in the loop below
4958       enable_stage1_languages=c ;;
4959     ,yes,)
4960       enable_stage1_languages=`echo $new_enable_languages | \
4961         sed -e "s/^,//" -e "s/,$//" ` ;;
4962     *,all,*)
4963       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4964         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4965   esac
4966
4967   # Add "good" languages from enable_stage1_languages to stage1_languages,
4968   # while "bad" languages go in missing_languages.  Leave no duplicates.
4969   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4970     case $potential_languages in
4971       *,$i,*)
4972         case $stage1_languages in
4973           *,$i,*) ;;
4974           *) stage1_languages="$stage1_languages$i," ;;
4975         esac ;;
4976       *)
4977         case $missing_languages in
4978           *,$i,*) ;;
4979           *) missing_languages="$missing_languages$i," ;;
4980         esac ;;
4981      esac
4982   done
4983 fi;
4984
4985   # Remove leading/trailing commas that were added for simplicity
4986   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4987   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4988   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4989   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4990
4991   if test "x$missing_languages" != x; then
4992     { { echo "$as_me:$LINENO: error:
4993 The following requested languages could not be built: ${missing_languages}
4994 Supported languages are: ${potential_languages}" >&5
4995 echo "$as_me: error:
4996 The following requested languages could not be built: ${missing_languages}
4997 Supported languages are: ${potential_languages}" >&2;}
4998    { (exit 1); exit 1; }; }
4999   fi
5000   if test "x$new_enable_languages" != "x$enable_languages"; then
5001     echo The following languages will be built: ${new_enable_languages}
5002     enable_languages="$new_enable_languages"
5003   fi
5004
5005
5006   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5007 fi
5008
5009 # Handle --disable-<component> generically.
5010 for dir in $configdirs $build_configdirs $target_configdirs ; do
5011   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5012   varname=`echo $dirname | sed -e s/+/_/g`
5013   if eval test x\${enable_${varname}} "=" xno ; then
5014     noconfigdirs="$noconfigdirs $dir"
5015   fi
5016 done
5017
5018 # Check for Boehm's garbage collector
5019 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5020 if test "${enable_objc_gc+set}" = set; then
5021   enableval="$enable_objc_gc"
5022   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5023   *,objc,*:*:yes:*target-boehm-gc*)
5024     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5025 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5026    { (exit 1); exit 1; }; }
5027     ;;
5028 esac
5029 fi;
5030
5031 # Make sure we only build Boehm's garbage collector if required.
5032 case ,${enable_languages},:${enable_objc_gc} in
5033   *,objc,*:yes)
5034     # Keep target-boehm-gc if requested for Objective-C.
5035     ;;
5036   *)
5037     # Otherwise remove target-boehm-gc depending on target-libjava.
5038     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5039       noconfigdirs="$noconfigdirs target-boehm-gc"
5040     fi
5041     ;;
5042 esac
5043
5044 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5045 # $build_configdirs and $target_configdirs.
5046 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5047
5048 notsupp=""
5049 for dir in . $skipdirs $noconfigdirs ; do
5050   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5051   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5052     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5053     if test -r $srcdir/$dirname/configure ; then
5054       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5055         true
5056       else
5057         notsupp="$notsupp $dir"
5058       fi
5059     fi
5060   fi
5061   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5062     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5063     if test -r $srcdir/$dirname/configure ; then
5064       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5065         true
5066       else
5067         notsupp="$notsupp $dir"
5068       fi
5069     fi
5070   fi
5071   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5072     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5073     if test -r $srcdir/$dirname/configure ; then
5074       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5075         true
5076       else
5077         notsupp="$notsupp $dir"
5078       fi
5079     fi
5080   fi
5081 done
5082
5083 # Sometimes the tools are distributed with libiberty but with no other
5084 # libraries.  In that case, we don't want to build target-libiberty.
5085 # Don't let libgcc imply libiberty either.
5086 if test -n "${target_configdirs}" ; then
5087   libgcc=
5088   others=
5089   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5090     if test "$i" = "libgcc"; then
5091       libgcc=target-libgcc
5092     elif test "$i" != "libiberty" ; then
5093       if test -r $srcdir/$i/configure ; then
5094         others=yes;
5095         break;
5096       fi
5097     fi
5098   done
5099   if test -z "${others}" ; then
5100     target_configdirs=$libgcc
5101   fi
5102 fi
5103
5104 # Quietly strip out all directories which aren't configurable in this tree.
5105 # This relies on all configurable subdirectories being autoconfiscated, which
5106 # is now the case.
5107 build_configdirs_all="$build_configdirs"
5108 build_configdirs=
5109 for i in ${build_configdirs_all} ; do
5110   j=`echo $i | sed -e s/build-//g`
5111   if test -f ${srcdir}/$j/configure ; then
5112     build_configdirs="${build_configdirs} $i"
5113   fi
5114 done
5115
5116 configdirs_all="$configdirs"
5117 configdirs=
5118 for i in ${configdirs_all} ; do
5119   if test -f ${srcdir}/$i/configure ; then
5120     configdirs="${configdirs} $i"
5121   fi
5122 done
5123
5124 target_configdirs_all="$target_configdirs"
5125 target_configdirs=
5126 for i in ${target_configdirs_all} ; do
5127   j=`echo $i | sed -e s/target-//g`
5128   if test -f ${srcdir}/$j/configure ; then
5129     target_configdirs="${target_configdirs} $i"
5130   fi
5131 done
5132
5133 # Produce a warning message for the subdirs we can't configure.
5134 # This isn't especially interesting in the Cygnus tree, but in the individual
5135 # FSF releases, it's important to let people know when their machine isn't
5136 # supported by the one or two programs in a package.
5137
5138 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5139   # If $appdirs is non-empty, at least one of those directories must still
5140   # be configured, or we error out.  (E.g., if the gas release supports a
5141   # specified target in some subdirs but not the gas subdir, we shouldn't
5142   # pretend that all is well.)
5143   if test -n "$appdirs" ; then
5144     for dir in $appdirs ; do
5145       if test -r $dir/Makefile.in ; then
5146         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5147           appdirs=""
5148           break
5149         fi
5150         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5151           appdirs=""
5152           break
5153         fi
5154       fi
5155     done
5156     if test -n "$appdirs" ; then
5157       echo "*** This configuration is not supported by this package." 1>&2
5158       exit 1
5159     fi
5160   fi
5161   # Okay, some application will build, or we don't care to check.  Still
5162   # notify of subdirs not getting built.
5163   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5164   echo "    ${notsupp}" 1>&2
5165   echo "    (Any other directories should still work fine.)" 1>&2
5166 fi
5167
5168 case "$host" in
5169   *msdosdjgpp*)
5170     enable_gdbtk=no ;;
5171 esac
5172
5173 # To find our prefix, in gcc_cv_tool_prefix.
5174
5175 # The user is always right.
5176 if test "${PATH_SEPARATOR+set}" != set; then
5177   echo "#! /bin/sh" >conf$$.sh
5178   echo  "exit 0"   >>conf$$.sh
5179   chmod +x conf$$.sh
5180   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5181     PATH_SEPARATOR=';'
5182   else
5183     PATH_SEPARATOR=:
5184   fi
5185   rm -f conf$$.sh
5186 fi
5187
5188
5189
5190 if test "x$exec_prefix" = xNONE; then
5191         if test "x$prefix" = xNONE; then
5192                 gcc_cv_tool_prefix=$ac_default_prefix
5193         else
5194                 gcc_cv_tool_prefix=$prefix
5195         fi
5196 else
5197         gcc_cv_tool_prefix=$exec_prefix
5198 fi
5199
5200 # If there is no compiler in the tree, use the PATH only.  In any
5201 # case, if there is no compiler in the tree nobody should use
5202 # AS_FOR_TARGET and LD_FOR_TARGET.
5203 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5204     gcc_version=`cat $srcdir/gcc/BASE-VER`
5205     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5206     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5207     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5208     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5209     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5210     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5211 else
5212     gcc_cv_tool_dirs=
5213 fi
5214
5215 if test x$build = x$target && test -n "$md_exec_prefix"; then
5216         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5217 fi
5218
5219
5220
5221 copy_dirs=
5222
5223
5224 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5225 if test "${with_build_sysroot+set}" = set; then
5226   withval="$with_build_sysroot"
5227   if test x"$withval" != x ; then
5228      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5229    fi
5230 else
5231   SYSROOT_CFLAGS_FOR_TARGET=
5232 fi;
5233
5234
5235
5236 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5237 if test "${with_debug_prefix_map+set}" = set; then
5238   withval="$with_debug_prefix_map"
5239   if test x"$withval" != x; then
5240      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5241      for debug_map in $withval; do
5242        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5243      done
5244    fi
5245 else
5246   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5247 fi;
5248
5249
5250 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5251 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5252 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5253 # We want to ensure that TARGET libraries (which we know are built with
5254 # gcc) are built with "-O2 -g", so include those options when setting
5255 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5256 if test "x$CFLAGS_FOR_TARGET" = x; then
5257   CFLAGS_FOR_TARGET=$CFLAGS
5258   case " $CFLAGS " in
5259     *" -O2 "*) ;;
5260     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5261   esac
5262   case " $CFLAGS " in
5263     *" -g "* | *" -g3 "*) ;;
5264     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5265   esac
5266 fi
5267
5268
5269 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5270   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5271   case " $CXXFLAGS " in
5272     *" -O2 "*) ;;
5273     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5274   esac
5275   case " $CXXFLAGS " in
5276     *" -g "* | *" -g3 "*) ;;
5277     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5278   esac
5279 fi
5280
5281
5282 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5283 # the named directory are copied to $(tooldir)/sys-include.
5284 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5285   if test x${is_cross_compiler} = xno ; then
5286     echo 1>&2 '***' --with-headers is only supported when cross compiling
5287     exit 1
5288   fi
5289   if test x"${with_headers}" != xyes ; then
5290     x=${gcc_cv_tool_prefix}
5291     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5292   fi
5293 fi
5294
5295 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5296 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5297 # are permitted.
5298 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5299   if test x${is_cross_compiler} = xno ; then
5300     echo 1>&2 '***' --with-libs is only supported when cross compiling
5301     exit 1
5302   fi
5303   if test x"${with_libs}" != xyes ; then
5304     # Copy the libraries in reverse order, so that files in the first named
5305     # library override files in subsequent libraries.
5306     x=${gcc_cv_tool_prefix}
5307     for l in ${with_libs}; do
5308       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5309     done
5310   fi
5311 fi
5312
5313 # Set with_gnu_as and with_gnu_ld as appropriate.
5314 #
5315 # This is done by determining whether or not the appropriate directory
5316 # is available, and by checking whether or not specific configurations
5317 # have requested that this magic not happen.
5318 #
5319 # The command line options always override the explicit settings in
5320 # configure.in, and the settings in configure.in override this magic.
5321 #
5322 # If the default for a toolchain is to use GNU as and ld, and you don't
5323 # want to do that, then you should use the --without-gnu-as and
5324 # --without-gnu-ld options for the configure script.
5325
5326 if test x${use_gnu_as} = x &&
5327    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5328   with_gnu_as=yes
5329   extra_host_args="$extra_host_args --with-gnu-as"
5330 fi
5331
5332 if test x${use_gnu_ld} = x &&
5333    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5334   with_gnu_ld=yes
5335   extra_host_args="$extra_host_args --with-gnu-ld"
5336 fi
5337
5338 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5339 # can detect this case.
5340
5341 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5342   with_newlib=yes
5343   extra_host_args="$extra_host_args --with-newlib"
5344 fi
5345
5346 # Handle ${copy_dirs}
5347 set fnord ${copy_dirs}
5348 shift
5349 while test $# != 0 ; do
5350   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5351     :
5352   else
5353     echo Copying $1 to $2
5354
5355     # Use the install script to create the directory and all required
5356     # parent directories.
5357     if test -d $2 ; then
5358       :
5359     else
5360       echo >config.temp
5361       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5362     fi
5363
5364     # Copy the directory, assuming we have tar.
5365     # FIXME: Should we use B in the second tar?  Not all systems support it.
5366     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5367
5368     # It is the responsibility of the user to correctly adjust all
5369     # symlinks.  If somebody can figure out how to handle them correctly
5370     # here, feel free to add the code.
5371
5372     echo $1 > $2/COPIED
5373   fi
5374   shift; shift
5375 done
5376
5377 # Determine a target-dependent exec_prefix that the installed
5378 # gcc will search in.  Keep this list sorted by triplet, with
5379 # the *-*-osname triplets last.
5380 md_exec_prefix=
5381 case "${target}" in
5382   alpha*-*-*vms*)
5383     md_exec_prefix=/gnu/lib/gcc-lib
5384     ;;
5385   i[34567]86-pc-msdosdjgpp*)
5386     md_exec_prefix=/dev/env/DJDIR/bin
5387     ;;
5388   i[34567]86-*-sco3.2v5*)
5389     if test $with_gnu_as = yes; then
5390       md_exec_prefix=/usr/gnu/bin
5391     else
5392       md_exec_prefix=/usr/ccs/bin/elf
5393     fi
5394     ;;
5395
5396   mn10300-*-* | \
5397   powerpc-*-chorusos* | \
5398   powerpc*-*-eabi* | \
5399   powerpc*-*-sysv* | \
5400   powerpc*-*-kaos* | \
5401   s390x-ibm-tpf*)
5402     md_exec_prefix=/usr/ccs/bin
5403     ;;
5404   sparc64-*-elf*)
5405     ;;
5406   v850*-*-*)
5407     md_exec_prefix=/usr/ccs/bin
5408     ;;
5409   xtensa*-*-elf*)
5410     ;;
5411
5412   *-*-beos* | \
5413   *-*-elf* | \
5414   *-*-hpux* | \
5415   *-*-netware* | \
5416   *-*-nto-qnx* | \
5417   *-*-rtems* | \
5418   *-*-solaris2* | \
5419   *-*-sysv[45]* | \
5420   *-*-vxworks* | \
5421   *-wrs-windiss)
5422     md_exec_prefix=/usr/ccs/bin
5423     ;;
5424 esac
5425
5426 extra_arflags_for_target=
5427 extra_nmflags_for_target=
5428 extra_ranlibflags_for_target=
5429 target_makefile_frag=/dev/null
5430 case "${target}" in
5431   mep*-*-*)
5432     target_makefile_frag="config/mt-mep"
5433     ;;
5434   spu-*-*)
5435     target_makefile_frag="config/mt-spu"
5436     ;;
5437   mips*-sde-elf*)
5438     target_makefile_frag="config/mt-sde"
5439     ;;
5440   mipsisa*-*-elfoabi*)
5441     target_makefile_frag="config/mt-mips-elfoabi"
5442     ;;
5443   *-*-netware*)
5444     target_makefile_frag="config/mt-netware"
5445     ;;
5446   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5447     target_makefile_frag="config/mt-gnu"
5448     ;;
5449   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5450     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5451     # commands to handle both 32-bit and 64-bit objects.  These flags are
5452     # harmless if we're using GNU nm or ar.
5453     extra_arflags_for_target=" -X32_64"
5454     extra_nmflags_for_target=" -B -X32_64"
5455     ;;
5456   *-*-darwin*)
5457     # ranlib from Darwin requires the -c flag to look at common symbols.
5458     extra_ranlibflags_for_target=" -c"
5459     ;;
5460   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5461     target_makefile_frag="config/mt-wince"
5462     ;;
5463 esac
5464
5465 alphaieee_frag=/dev/null
5466 case $target in
5467   alpha*-*-*)
5468     # This just makes sure to use the -mieee option to build target libs.
5469     # This should probably be set individually by each library.
5470     alphaieee_frag="config/mt-alphaieee"
5471     ;;
5472 esac
5473
5474 # If --enable-target-optspace always use -Os instead of -O2 to build
5475 # the target libraries, similarly if it is not specified, use -Os
5476 # on selected platforms.
5477 ospace_frag=/dev/null
5478 case "${enable_target_optspace}:${target}" in
5479   yes:*)
5480     ospace_frag="config/mt-ospace"
5481     ;;
5482   :d30v-*)
5483     ospace_frag="config/mt-d30v"
5484     ;;
5485   :m32r-* | :d10v-* | :fr30-*)
5486     ospace_frag="config/mt-ospace"
5487     ;;
5488   no:* | :*)
5489     ;;
5490   *)
5491     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5492     ;;
5493 esac
5494
5495 # Default to using --with-stabs for certain targets.
5496 if test x${with_stabs} = x ; then
5497   case "${target}" in
5498   mips*-*-irix[56]*)
5499     ;;
5500   mips*-*-* | alpha*-*-osf*)
5501     with_stabs=yes;
5502     extra_host_args="${extra_host_args} --with-stabs"
5503     ;;
5504   esac
5505 fi
5506
5507 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5508 # them automatically.
5509 case "${host}" in
5510   hppa*64*-*-hpux11*)
5511     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5512     ;;
5513 esac
5514
5515 # Some systems (e.g., one of the i386-aix systems the gas testers are
5516 # using) don't handle "\$" correctly, so don't use it here.
5517 tooldir='${exec_prefix}'/${target_noncanonical}
5518 build_tooldir=${tooldir}
5519
5520 # Create a .gdbinit file which runs the one in srcdir
5521 # and tells GDB to look there for source files.
5522
5523 if test -r ${srcdir}/.gdbinit ; then
5524   case ${srcdir} in
5525     .) ;;
5526     *) cat > ./.gdbinit <<EOF
5527 # ${NO_EDIT}
5528 dir ${srcdir}
5529 dir .
5530 source ${srcdir}/.gdbinit
5531 EOF
5532     ;;
5533   esac
5534 fi
5535
5536 # Make sure that the compiler is able to generate an executable.  If it
5537 # can't, we are probably in trouble.  We don't care whether we can run the
5538 # executable--we might be using a cross compiler--we only care whether it
5539 # can be created.  At this point the main configure script has set CC.
5540 we_are_ok=no
5541 echo "int main () { return 0; }" > conftest.c
5542 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5543 if test $? = 0 ; then
5544   if test -s conftest || test -s conftest.exe ; then
5545     we_are_ok=yes
5546   fi
5547 fi
5548 case $we_are_ok in
5549   no)
5550     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5551     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5552     rm -f conftest*
5553     exit 1
5554     ;;
5555 esac
5556 rm -f conftest*
5557
5558 # The Solaris /usr/ucb/cc compiler does not appear to work.
5559 case "${host}" in
5560   sparc-sun-solaris2*)
5561       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5562       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5563           could_use=
5564           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5565           if test -d /opt/cygnus/bin ; then
5566               if test "$could_use" = "" ; then
5567                   could_use="/opt/cygnus/bin"
5568               else
5569                   could_use="$could_use or /opt/cygnus/bin"
5570               fi
5571           fi
5572         if test "$could_use" = "" ; then
5573             echo "Warning: compilation may fail because you're using"
5574             echo "/usr/ucb/cc.  You should change your PATH or CC "
5575             echo "variable and rerun configure."
5576         else
5577             echo "Warning: compilation may fail because you're using"
5578             echo "/usr/ucb/cc, when you should use the C compiler from"
5579             echo "$could_use.  You should change your"
5580             echo "PATH or CC variable and rerun configure."
5581         fi
5582       fi
5583   ;;
5584 esac
5585
5586 case "${host}" in
5587   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5588   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5589   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5590 esac
5591
5592 # Record target_configdirs and the configure arguments for target and
5593 # build configuration in Makefile.
5594 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5595 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5596
5597 # Determine whether gdb needs tk/tcl or not.
5598 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5599 # and in that case we want gdb to be built without tk.  Ugh!
5600 # In fact I believe gdb is the *only* package directly dependent on tk,
5601 # so we should be able to put the 'maybe's in unconditionally and
5602 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5603 # 100% sure that that's safe though.
5604
5605 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5606 case "$enable_gdbtk" in
5607   no)
5608     GDB_TK="" ;;
5609   yes)
5610     GDB_TK="${gdb_tk}" ;;
5611   *)
5612     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5613     # distro.  Eventually someone will fix this and move Insight, nee
5614     # gdbtk to a separate directory.
5615     if test -d ${srcdir}/gdb/gdbtk ; then
5616       GDB_TK="${gdb_tk}"
5617     else
5618       GDB_TK=""
5619     fi
5620     ;;
5621 esac
5622 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5623 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5624
5625 # Strip out unwanted targets.
5626
5627 # While at that, we remove Makefiles if we were started for recursive
5628 # configuration, so that the top-level Makefile reconfigures them,
5629 # like we used to do when configure itself was recursive.
5630
5631 # Loop over modules.  $extrasub must be used with care, limiting as
5632 # much as possible the usage of range addresses.  That's because autoconf
5633 # splits the sed script to overcome limits in the number of commands,
5634 # and relying on carefully-timed sed passes may turn out to be very hard
5635 # to maintain later.  In this particular case, you just have to be careful
5636 # not to nest @if/@endif pairs, because configure will not warn you at all.
5637
5638 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5639 if test "${enable_bootstrap+set}" = set; then
5640   enableval="$enable_bootstrap"
5641
5642 else
5643   enable_bootstrap=default
5644 fi;
5645
5646 # Issue errors and warnings for invalid/strange bootstrap combinations.
5647 case "$configdirs" in
5648   *gcc*) have_compiler=yes ;;
5649   *) have_compiler=no ;;
5650 esac
5651
5652 case "$have_compiler:$host:$target:$enable_bootstrap" in
5653   *:*:*:no) ;;
5654
5655   # Default behavior.  Enable bootstrap if we have a compiler
5656   # and we are in a native configuration.
5657   yes:$build:$build:default)
5658     enable_bootstrap=yes ;;
5659
5660   *:*:*:default)
5661     enable_bootstrap=no ;;
5662
5663   # We have a compiler and we are in a native configuration, bootstrap is ok
5664   yes:$build:$build:yes)
5665     ;;
5666
5667   # Other configurations, but we have a compiler.  Assume the user knows
5668   # what he's doing.
5669   yes:*:*:yes)
5670     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5671 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5672     ;;
5673
5674   # No compiler: if they passed --enable-bootstrap explicitly, fail
5675   no:*:*:yes)
5676     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5677 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5678    { (exit 1); exit 1; }; } ;;
5679
5680   # Fail if wrong command line
5681   *)
5682     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5683 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5684    { (exit 1); exit 1; }; }
5685     ;;
5686 esac
5687
5688 # Adjust the toplevel makefile according to whether bootstrap was selected.
5689 case "$enable_bootstrap" in
5690   yes)
5691     bootstrap_suffix=bootstrap ;;
5692   no)
5693     bootstrap_suffix=no-bootstrap ;;
5694 esac
5695
5696 for module in ${build_configdirs} ; do
5697   if test -z "${no_recursion}" \
5698      && test -f ${build_subdir}/${module}/Makefile; then
5699     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5700     rm -f ${build_subdir}/${module}/Makefile
5701   fi
5702   extrasub="$extrasub
5703 /^@if build-$module\$/d
5704 /^@endif build-$module\$/d
5705 /^@if build-$module-$bootstrap_suffix\$/d
5706 /^@endif build-$module-$bootstrap_suffix\$/d"
5707 done
5708 for module in ${configdirs} ; do
5709   if test -z "${no_recursion}"; then
5710     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5711       if test -f ${file}; then
5712         echo 1>&2 "*** removing ${file} to force reconfigure"
5713         rm -f ${file}
5714       fi
5715     done
5716   fi
5717   extrasub="$extrasub
5718 /^@if $module\$/d
5719 /^@endif $module\$/d
5720 /^@if $module-$bootstrap_suffix\$/d
5721 /^@endif $module-$bootstrap_suffix\$/d"
5722 done
5723 for module in ${target_configdirs} ; do
5724   if test -z "${no_recursion}" \
5725      && test -f ${target_subdir}/${module}/Makefile; then
5726     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5727     rm -f ${target_subdir}/${module}/Makefile
5728   fi
5729   extrasub="$extrasub
5730 /^@if target-$module\$/d
5731 /^@endif target-$module\$/d
5732 /^@if target-$module-$bootstrap_suffix\$/d
5733 /^@endif target-$module-$bootstrap_suffix\$/d"
5734 done
5735
5736 extrasub="$extrasub
5737 /^@if /,/^@endif /d"
5738
5739 # Create the serialization dependencies.  This uses a temporary file.
5740
5741 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5742 if test "${enable_serial_configure+set}" = set; then
5743   enableval="$enable_serial_configure"
5744
5745 fi;
5746
5747 case ${enable_serial_configure} in
5748   yes)
5749     enable_serial_build_configure=yes
5750     enable_serial_host_configure=yes
5751     enable_serial_target_configure=yes
5752     ;;
5753 esac
5754
5755 # These force 'configure's to be done one at a time, to avoid problems
5756 # with contention over a shared config.cache.
5757 rm -f serdep.tmp
5758 echo '# serdep.tmp' > serdep.tmp
5759 olditem=
5760 test "x${enable_serial_build_configure}" = xyes &&
5761 for item in ${build_configdirs} ; do
5762   case ${olditem} in
5763     "") ;;
5764     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5765   esac
5766   olditem=${item}
5767 done
5768 olditem=
5769 test "x${enable_serial_host_configure}" = xyes &&
5770 for item in ${configdirs} ; do
5771   case ${olditem} in
5772     "") ;;
5773     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5774   esac
5775   olditem=${item}
5776 done
5777 olditem=
5778 test "x${enable_serial_target_configure}" = xyes &&
5779 for item in ${target_configdirs} ; do
5780   case ${olditem} in
5781     "") ;;
5782     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5783   esac
5784   olditem=${item}
5785 done
5786 serialization_dependencies=serdep.tmp
5787
5788
5789 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5790 # target, nonopt, and variable assignments.  These are the ones we
5791 # might not want to pass down to subconfigures.  Also strip
5792 # program-prefix, program-suffix, and program-transform-name, so that
5793 # we can pass down a consistent program-transform-name.
5794 baseargs=
5795 keep_next=no
5796 skip_next=no
5797 eval "set -- $ac_configure_args"
5798 for ac_arg
5799 do
5800   if test X"$skip_next" = X"yes"; then
5801     skip_next=no
5802     continue
5803   fi
5804   if test X"$keep_next" = X"yes"; then
5805     case $ac_arg in
5806       *\'*)
5807         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5808     esac
5809     baseargs="$baseargs '$ac_arg'"
5810     keep_next=no
5811     continue
5812   fi
5813
5814   # Handle separated arguments.  Based on the logic generated by
5815   # autoconf 2.59.
5816   case $ac_arg in
5817     *=* | --config-cache | -C | -disable-* | --disable-* \
5818       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5819       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5820       | -with-* | --with-* | -without-* | --without-* | --x)
5821       separate_arg=no
5822       ;;
5823     -*)
5824       separate_arg=yes
5825       ;;
5826     *)
5827       separate_arg=no
5828       ;;
5829   esac
5830
5831   case "$ac_arg" in
5832     --no*)
5833       continue
5834       ;;
5835     --c* | \
5836     --sr* | \
5837     --ho* | \
5838     --bu* | \
5839     --t* | \
5840     --program-* | \
5841     -cache_file* | \
5842     -srcdir* | \
5843     -host* | \
5844     -build* | \
5845     -target* | \
5846     -program-prefix* | \
5847     -program-suffix* | \
5848     -program-transform-name* )
5849       skip_next=$separate_arg
5850       continue
5851       ;;
5852     -*)
5853       # An option.  Add it.
5854       case $ac_arg in
5855         *\'*)
5856           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5857       esac
5858       baseargs="$baseargs '$ac_arg'"
5859       keep_next=$separate_arg
5860       ;;
5861     *)
5862       # Either a variable assignment, or a nonopt (triplet).  Don't
5863       # pass it down; let the Makefile handle this.
5864       continue
5865       ;;
5866   esac
5867 done
5868 # Remove the initial space we just introduced and, as these will be
5869 # expanded by make, quote '$'.
5870 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5871
5872 # Add in --program-transform-name, after --program-prefix and
5873 # --program-suffix have been applied to it.  Autoconf has already
5874 # doubled dollar signs and backslashes in program_transform_name; we want
5875 # the backslashes un-doubled, and then the entire thing wrapped in single
5876 # quotes, because this will be expanded first by make and then by the shell.
5877 # Also, because we want to override the logic in subdir configure scripts to
5878 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5879 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5880 ${program_transform_name}
5881 EOF_SED
5882 gcc_transform_name=`cat conftestsed.out`
5883 rm -f conftestsed.out
5884 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5885 if test "$silent" = yes; then
5886   baseargs="$baseargs --silent"
5887 fi
5888
5889 # For the build-side libraries, we just need to pretend we're native,
5890 # and not use the same cache file.  Multilibs are neither needed nor
5891 # desired.
5892 build_configargs="--cache-file=../config.cache ${baseargs}"
5893
5894 # For host modules, accept cache file option, or specification as blank.
5895 case "${cache_file}" in
5896 "") # empty
5897   cache_file_option="" ;;
5898 /* | [A-Za-z]:[\\/]* ) # absolute path
5899   cache_file_option="--cache-file=${cache_file}" ;;
5900 *) # relative path
5901   cache_file_option="--cache-file=../${cache_file}" ;;
5902 esac
5903
5904 # Host dirs don't like to share a cache file either, horribly enough.
5905 # This seems to be due to autoconf 2.5x stupidity.
5906 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5907
5908 target_configargs=${baseargs}
5909
5910 # Passing a --with-cross-host argument lets the target libraries know
5911 # whether they are being built with a cross-compiler or being built
5912 # native.  However, it would be better to use other mechanisms to make the
5913 # sorts of decisions they want to make on this basis.  Please consider
5914 # this option to be deprecated.  FIXME.
5915 if test x${is_cross_compiler} = xyes ; then
5916   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5917 fi
5918
5919 # Default to --enable-multilib.
5920 if test x${enable_multilib} = x ; then
5921   target_configargs="--enable-multilib ${target_configargs}"
5922 fi
5923
5924 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5925 # changed from the earlier setting of with_newlib.
5926 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5927   target_configargs="--with-newlib ${target_configargs}"
5928 fi
5929
5930 # Different target subdirs use different values of certain variables
5931 # (notably CXX).  Worse, multilibs use *lots* of different values.
5932 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5933 # it doesn't automatically accept command-line overrides of them.
5934 # This means it's not safe for target subdirs to share a cache file,
5935 # which is disgusting, but there you have it.  Hopefully this can be
5936 # fixed in future.  It's still worthwhile to use a cache file for each
5937 # directory.  I think.
5938
5939 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5940 # We need to pass --target, as newer autoconf's requires consistency
5941 # for target_alias and gcc doesn't manage it consistently.
5942 target_configargs="--cache-file=./config.cache ${target_configargs}"
5943
5944 FLAGS_FOR_TARGET=
5945 case " $target_configdirs " in
5946  *" newlib "*)
5947   case " $target_configargs " in
5948   *" --with-newlib "*)
5949    case "$target" in
5950    *-cygwin*)
5951      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' ;;
5952    esac
5953
5954    # If we're not building GCC, don't discard standard headers.
5955    if test -d ${srcdir}/gcc; then
5956      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5957
5958      if test "${build}" != "${host}"; then
5959        # On Canadian crosses, CC_FOR_TARGET will have already been set
5960        # by `configure', so we won't have an opportunity to add -Bgcc/
5961        # to it.  This is right: we don't want to search that directory
5962        # for binaries, but we want the header files in there, so add
5963        # them explicitly.
5964        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5965
5966        # Someone might think of using the pre-installed headers on
5967        # Canadian crosses, in case the installed compiler is not fully
5968        # compatible with the compiler being built.  In this case, it
5969        # would be better to flag an error than risking having
5970        # incompatible object files being constructed.  We can't
5971        # guarantee that an error will be flagged, but let's hope the
5972        # compiler will do it, when presented with incompatible header
5973        # files.
5974      fi
5975    fi
5976
5977    case "${target}-${is_cross_compiler}" in
5978    i[3456789]86-*-linux*-no)
5979       # Here host == target, so we don't need to build gcc,
5980       # so we don't want to discard standard headers.
5981       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5982       ;;
5983    *)
5984       # If we're building newlib, use its generic headers last, but search
5985       # for any libc-related directories first (so make it the last -B
5986       # switch).
5987       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5988
5989       # If we're building libgloss, find the startup file, simulator library
5990       # and linker script.
5991       case " $target_configdirs " in
5992         *" libgloss "*)
5993         # Look for startup file, simulator library and maybe linker script.
5994         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
5995         # Look for libnosys.a in case the target needs it.
5996         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5997         # Most targets have the linker script in the source directory.
5998         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
5999         ;;
6000       esac
6001       ;;
6002    esac
6003    ;;
6004   esac
6005   ;;
6006 esac
6007 case "$target" in
6008 *-mingw*)
6009   # Can't be handled as Cygwin above since Mingw does not use newlib.
6010   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' ;;
6011 esac
6012
6013 # Allow the user to override the flags for
6014 # our build compiler if desired.
6015 if test x"${build}" = x"${host}" ; then
6016   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6017   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6018   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6019 fi
6020
6021 # On Canadian crosses, we'll be searching the right directories for
6022 # the previously-installed cross compiler, so don't bother to add
6023 # flags for directories within the install tree of the compiler
6024 # being built; programs in there won't even run.
6025 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6026   # Search for pre-installed headers if nothing else fits.
6027   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6028 fi
6029
6030 if test "x${use_gnu_ld}" = x &&
6031    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6032   # Arrange for us to find uninstalled linker scripts.
6033   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6034 fi
6035
6036 # Search for other target-specific linker scripts and such.
6037 case "${target}" in
6038   mep*)
6039     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6040     ;;
6041 esac
6042
6043 # Makefile fragments.
6044 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6045 do
6046   eval fragval=\$$frag
6047   if test $fragval != /dev/null; then
6048     eval $frag=${srcdir}/$fragval
6049   fi
6050 done
6051
6052
6053
6054
6055
6056 # Miscellanea: directories, flags, etc.
6057
6058
6059
6060
6061
6062
6063
6064 # Build module lists & subconfigure args.
6065
6066
6067
6068 # Host module lists & subconfigure args.
6069
6070
6071
6072 # Target module lists & subconfigure args.
6073
6074
6075
6076 # Build tools.
6077
6078
6079
6080
6081
6082
6083
6084
6085
6086
6087
6088
6089
6090
6091
6092
6093
6094 # Generate default definitions for YACC, M4, LEX and other programs that run
6095 # on the build machine.  These are used if the Makefile can't locate these
6096 # programs in objdir.
6097 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6098
6099 for ac_prog in 'bison -y' byacc yacc
6100 do
6101   # Extract the first word of "$ac_prog", so it can be a program name with args.
6102 set dummy $ac_prog; ac_word=$2
6103 echo "$as_me:$LINENO: checking for $ac_word" >&5
6104 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6105 if test "${ac_cv_prog_YACC+set}" = set; then
6106   echo $ECHO_N "(cached) $ECHO_C" >&6
6107 else
6108   if test -n "$YACC"; then
6109   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6110 else
6111 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6112 for as_dir in $PATH
6113 do
6114   IFS=$as_save_IFS
6115   test -z "$as_dir" && as_dir=.
6116   for ac_exec_ext in '' $ac_executable_extensions; do
6117   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6118     ac_cv_prog_YACC="$ac_prog"
6119     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6120     break 2
6121   fi
6122 done
6123 done
6124
6125 fi
6126 fi
6127 YACC=$ac_cv_prog_YACC
6128 if test -n "$YACC"; then
6129   echo "$as_me:$LINENO: result: $YACC" >&5
6130 echo "${ECHO_T}$YACC" >&6
6131 else
6132   echo "$as_me:$LINENO: result: no" >&5
6133 echo "${ECHO_T}no" >&6
6134 fi
6135
6136   test -n "$YACC" && break
6137 done
6138 test -n "$YACC" || YACC="$MISSING bison -y"
6139
6140 case " $build_configdirs " in
6141   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6142   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6143 esac
6144
6145 for ac_prog in bison
6146 do
6147   # Extract the first word of "$ac_prog", so it can be a program name with args.
6148 set dummy $ac_prog; ac_word=$2
6149 echo "$as_me:$LINENO: checking for $ac_word" >&5
6150 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6151 if test "${ac_cv_prog_BISON+set}" = set; then
6152   echo $ECHO_N "(cached) $ECHO_C" >&6
6153 else
6154   if test -n "$BISON"; then
6155   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6156 else
6157 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6158 for as_dir in $PATH
6159 do
6160   IFS=$as_save_IFS
6161   test -z "$as_dir" && as_dir=.
6162   for ac_exec_ext in '' $ac_executable_extensions; do
6163   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6164     ac_cv_prog_BISON="$ac_prog"
6165     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6166     break 2
6167   fi
6168 done
6169 done
6170
6171 fi
6172 fi
6173 BISON=$ac_cv_prog_BISON
6174 if test -n "$BISON"; then
6175   echo "$as_me:$LINENO: result: $BISON" >&5
6176 echo "${ECHO_T}$BISON" >&6
6177 else
6178   echo "$as_me:$LINENO: result: no" >&5
6179 echo "${ECHO_T}no" >&6
6180 fi
6181
6182   test -n "$BISON" && break
6183 done
6184 test -n "$BISON" || BISON="$MISSING bison"
6185
6186 case " $build_configdirs " in
6187   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6188 esac
6189
6190 for ac_prog in gm4 gnum4 m4
6191 do
6192   # Extract the first word of "$ac_prog", so it can be a program name with args.
6193 set dummy $ac_prog; ac_word=$2
6194 echo "$as_me:$LINENO: checking for $ac_word" >&5
6195 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6196 if test "${ac_cv_prog_M4+set}" = set; then
6197   echo $ECHO_N "(cached) $ECHO_C" >&6
6198 else
6199   if test -n "$M4"; then
6200   ac_cv_prog_M4="$M4" # Let the user override the test.
6201 else
6202 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6203 for as_dir in $PATH
6204 do
6205   IFS=$as_save_IFS
6206   test -z "$as_dir" && as_dir=.
6207   for ac_exec_ext in '' $ac_executable_extensions; do
6208   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6209     ac_cv_prog_M4="$ac_prog"
6210     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6211     break 2
6212   fi
6213 done
6214 done
6215
6216 fi
6217 fi
6218 M4=$ac_cv_prog_M4
6219 if test -n "$M4"; then
6220   echo "$as_me:$LINENO: result: $M4" >&5
6221 echo "${ECHO_T}$M4" >&6
6222 else
6223   echo "$as_me:$LINENO: result: no" >&5
6224 echo "${ECHO_T}no" >&6
6225 fi
6226
6227   test -n "$M4" && break
6228 done
6229 test -n "$M4" || M4="$MISSING m4"
6230
6231 case " $build_configdirs " in
6232   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6233 esac
6234
6235 for ac_prog in flex lex
6236 do
6237   # Extract the first word of "$ac_prog", so it can be a program name with args.
6238 set dummy $ac_prog; ac_word=$2
6239 echo "$as_me:$LINENO: checking for $ac_word" >&5
6240 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6241 if test "${ac_cv_prog_LEX+set}" = set; then
6242   echo $ECHO_N "(cached) $ECHO_C" >&6
6243 else
6244   if test -n "$LEX"; then
6245   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6246 else
6247 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6248 for as_dir in $PATH
6249 do
6250   IFS=$as_save_IFS
6251   test -z "$as_dir" && as_dir=.
6252   for ac_exec_ext in '' $ac_executable_extensions; do
6253   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6254     ac_cv_prog_LEX="$ac_prog"
6255     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6256     break 2
6257   fi
6258 done
6259 done
6260
6261 fi
6262 fi
6263 LEX=$ac_cv_prog_LEX
6264 if test -n "$LEX"; then
6265   echo "$as_me:$LINENO: result: $LEX" >&5
6266 echo "${ECHO_T}$LEX" >&6
6267 else
6268   echo "$as_me:$LINENO: result: no" >&5
6269 echo "${ECHO_T}no" >&6
6270 fi
6271
6272   test -n "$LEX" && break
6273 done
6274 test -n "$LEX" || LEX="$MISSING flex"
6275
6276 case " $build_configdirs " in
6277   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6278   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6279 esac
6280
6281 for ac_prog in flex
6282 do
6283   # Extract the first word of "$ac_prog", so it can be a program name with args.
6284 set dummy $ac_prog; ac_word=$2
6285 echo "$as_me:$LINENO: checking for $ac_word" >&5
6286 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6287 if test "${ac_cv_prog_FLEX+set}" = set; then
6288   echo $ECHO_N "(cached) $ECHO_C" >&6
6289 else
6290   if test -n "$FLEX"; then
6291   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6292 else
6293 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6294 for as_dir in $PATH
6295 do
6296   IFS=$as_save_IFS
6297   test -z "$as_dir" && as_dir=.
6298   for ac_exec_ext in '' $ac_executable_extensions; do
6299   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6300     ac_cv_prog_FLEX="$ac_prog"
6301     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6302     break 2
6303   fi
6304 done
6305 done
6306
6307 fi
6308 fi
6309 FLEX=$ac_cv_prog_FLEX
6310 if test -n "$FLEX"; then
6311   echo "$as_me:$LINENO: result: $FLEX" >&5
6312 echo "${ECHO_T}$FLEX" >&6
6313 else
6314   echo "$as_me:$LINENO: result: no" >&5
6315 echo "${ECHO_T}no" >&6
6316 fi
6317
6318   test -n "$FLEX" && break
6319 done
6320 test -n "$FLEX" || FLEX="$MISSING flex"
6321
6322 case " $build_configdirs " in
6323   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6324 esac
6325
6326 for ac_prog in makeinfo
6327 do
6328   # Extract the first word of "$ac_prog", so it can be a program name with args.
6329 set dummy $ac_prog; ac_word=$2
6330 echo "$as_me:$LINENO: checking for $ac_word" >&5
6331 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6332 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6333   echo $ECHO_N "(cached) $ECHO_C" >&6
6334 else
6335   if test -n "$MAKEINFO"; then
6336   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6337 else
6338 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6339 for as_dir in $PATH
6340 do
6341   IFS=$as_save_IFS
6342   test -z "$as_dir" && as_dir=.
6343   for ac_exec_ext in '' $ac_executable_extensions; do
6344   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6345     ac_cv_prog_MAKEINFO="$ac_prog"
6346     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6347     break 2
6348   fi
6349 done
6350 done
6351
6352 fi
6353 fi
6354 MAKEINFO=$ac_cv_prog_MAKEINFO
6355 if test -n "$MAKEINFO"; then
6356   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6357 echo "${ECHO_T}$MAKEINFO" >&6
6358 else
6359   echo "$as_me:$LINENO: result: no" >&5
6360 echo "${ECHO_T}no" >&6
6361 fi
6362
6363   test -n "$MAKEINFO" && break
6364 done
6365 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6366
6367 case " $build_configdirs " in
6368   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6369   *)
6370
6371     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6372     # higher, else we use the "missing" dummy.
6373     if ${MAKEINFO} --version \
6374        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6375       :
6376     else
6377       MAKEINFO="$MISSING makeinfo"
6378     fi
6379     ;;
6380
6381 esac
6382
6383 # FIXME: expect and dejagnu may become build tools?
6384
6385 for ac_prog in expect
6386 do
6387   # Extract the first word of "$ac_prog", so it can be a program name with args.
6388 set dummy $ac_prog; ac_word=$2
6389 echo "$as_me:$LINENO: checking for $ac_word" >&5
6390 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6391 if test "${ac_cv_prog_EXPECT+set}" = set; then
6392   echo $ECHO_N "(cached) $ECHO_C" >&6
6393 else
6394   if test -n "$EXPECT"; then
6395   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6396 else
6397 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6398 for as_dir in $PATH
6399 do
6400   IFS=$as_save_IFS
6401   test -z "$as_dir" && as_dir=.
6402   for ac_exec_ext in '' $ac_executable_extensions; do
6403   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6404     ac_cv_prog_EXPECT="$ac_prog"
6405     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6406     break 2
6407   fi
6408 done
6409 done
6410
6411 fi
6412 fi
6413 EXPECT=$ac_cv_prog_EXPECT
6414 if test -n "$EXPECT"; then
6415   echo "$as_me:$LINENO: result: $EXPECT" >&5
6416 echo "${ECHO_T}$EXPECT" >&6
6417 else
6418   echo "$as_me:$LINENO: result: no" >&5
6419 echo "${ECHO_T}no" >&6
6420 fi
6421
6422   test -n "$EXPECT" && break
6423 done
6424 test -n "$EXPECT" || EXPECT="expect"
6425
6426 case " $configdirs " in
6427   *" expect "*)
6428     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6429     ;;
6430 esac
6431
6432 for ac_prog in runtest
6433 do
6434   # Extract the first word of "$ac_prog", so it can be a program name with args.
6435 set dummy $ac_prog; ac_word=$2
6436 echo "$as_me:$LINENO: checking for $ac_word" >&5
6437 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6438 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6439   echo $ECHO_N "(cached) $ECHO_C" >&6
6440 else
6441   if test -n "$RUNTEST"; then
6442   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6443 else
6444 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6445 for as_dir in $PATH
6446 do
6447   IFS=$as_save_IFS
6448   test -z "$as_dir" && as_dir=.
6449   for ac_exec_ext in '' $ac_executable_extensions; do
6450   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6451     ac_cv_prog_RUNTEST="$ac_prog"
6452     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6453     break 2
6454   fi
6455 done
6456 done
6457
6458 fi
6459 fi
6460 RUNTEST=$ac_cv_prog_RUNTEST
6461 if test -n "$RUNTEST"; then
6462   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6463 echo "${ECHO_T}$RUNTEST" >&6
6464 else
6465   echo "$as_me:$LINENO: result: no" >&5
6466 echo "${ECHO_T}no" >&6
6467 fi
6468
6469   test -n "$RUNTEST" && break
6470 done
6471 test -n "$RUNTEST" || RUNTEST="runtest"
6472
6473 case " $configdirs " in
6474   *" dejagnu "*)
6475     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6476     ;;
6477 esac
6478
6479
6480 # Host tools.
6481 ncn_tool_prefix=
6482 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6483 ncn_target_tool_prefix=
6484 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6485
6486
6487
6488 if test -n "$AR"; then
6489   ac_cv_prog_AR=$AR
6490 elif test -n "$ac_cv_prog_AR"; then
6491   AR=$ac_cv_prog_AR
6492 fi
6493
6494 if test -n "$ac_cv_prog_AR"; then
6495   for ncn_progname in ar; do
6496     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6497 set dummy ${ncn_progname}; ac_word=$2
6498 echo "$as_me:$LINENO: checking for $ac_word" >&5
6499 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6500 if test "${ac_cv_prog_AR+set}" = set; then
6501   echo $ECHO_N "(cached) $ECHO_C" >&6
6502 else
6503   if test -n "$AR"; then
6504   ac_cv_prog_AR="$AR" # Let the user override the test.
6505 else
6506 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6507 for as_dir in $PATH
6508 do
6509   IFS=$as_save_IFS
6510   test -z "$as_dir" && as_dir=.
6511   for ac_exec_ext in '' $ac_executable_extensions; do
6512   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6513     ac_cv_prog_AR="${ncn_progname}"
6514     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6515     break 2
6516   fi
6517 done
6518 done
6519
6520 fi
6521 fi
6522 AR=$ac_cv_prog_AR
6523 if test -n "$AR"; then
6524   echo "$as_me:$LINENO: result: $AR" >&5
6525 echo "${ECHO_T}$AR" >&6
6526 else
6527   echo "$as_me:$LINENO: result: no" >&5
6528 echo "${ECHO_T}no" >&6
6529 fi
6530
6531   done
6532 fi
6533
6534 for ncn_progname in ar; do
6535   if test -n "$ncn_tool_prefix"; then
6536     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6537 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6538 echo "$as_me:$LINENO: checking for $ac_word" >&5
6539 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6540 if test "${ac_cv_prog_AR+set}" = set; then
6541   echo $ECHO_N "(cached) $ECHO_C" >&6
6542 else
6543   if test -n "$AR"; then
6544   ac_cv_prog_AR="$AR" # Let the user override the test.
6545 else
6546 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6547 for as_dir in $PATH
6548 do
6549   IFS=$as_save_IFS
6550   test -z "$as_dir" && as_dir=.
6551   for ac_exec_ext in '' $ac_executable_extensions; do
6552   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6553     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6554     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6555     break 2
6556   fi
6557 done
6558 done
6559
6560 fi
6561 fi
6562 AR=$ac_cv_prog_AR
6563 if test -n "$AR"; then
6564   echo "$as_me:$LINENO: result: $AR" >&5
6565 echo "${ECHO_T}$AR" >&6
6566 else
6567   echo "$as_me:$LINENO: result: no" >&5
6568 echo "${ECHO_T}no" >&6
6569 fi
6570
6571   fi
6572   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6573     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6574 set dummy ${ncn_progname}; ac_word=$2
6575 echo "$as_me:$LINENO: checking for $ac_word" >&5
6576 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6577 if test "${ac_cv_prog_AR+set}" = set; then
6578   echo $ECHO_N "(cached) $ECHO_C" >&6
6579 else
6580   if test -n "$AR"; then
6581   ac_cv_prog_AR="$AR" # Let the user override the test.
6582 else
6583 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6584 for as_dir in $PATH
6585 do
6586   IFS=$as_save_IFS
6587   test -z "$as_dir" && as_dir=.
6588   for ac_exec_ext in '' $ac_executable_extensions; do
6589   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6590     ac_cv_prog_AR="${ncn_progname}"
6591     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6592     break 2
6593   fi
6594 done
6595 done
6596
6597 fi
6598 fi
6599 AR=$ac_cv_prog_AR
6600 if test -n "$AR"; then
6601   echo "$as_me:$LINENO: result: $AR" >&5
6602 echo "${ECHO_T}$AR" >&6
6603 else
6604   echo "$as_me:$LINENO: result: no" >&5
6605 echo "${ECHO_T}no" >&6
6606 fi
6607
6608   fi
6609   test -n "$ac_cv_prog_AR" && break
6610 done
6611
6612 if test -z "$ac_cv_prog_AR" ; then
6613   set dummy ar
6614   if test $build = $host ; then
6615     AR="$2"
6616   else
6617     AR="${ncn_tool_prefix}$2"
6618   fi
6619 fi
6620
6621
6622
6623 if test -n "$AS"; then
6624   ac_cv_prog_AS=$AS
6625 elif test -n "$ac_cv_prog_AS"; then
6626   AS=$ac_cv_prog_AS
6627 fi
6628
6629 if test -n "$ac_cv_prog_AS"; then
6630   for ncn_progname in as; do
6631     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6632 set dummy ${ncn_progname}; ac_word=$2
6633 echo "$as_me:$LINENO: checking for $ac_word" >&5
6634 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6635 if test "${ac_cv_prog_AS+set}" = set; then
6636   echo $ECHO_N "(cached) $ECHO_C" >&6
6637 else
6638   if test -n "$AS"; then
6639   ac_cv_prog_AS="$AS" # Let the user override the test.
6640 else
6641 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6642 for as_dir in $PATH
6643 do
6644   IFS=$as_save_IFS
6645   test -z "$as_dir" && as_dir=.
6646   for ac_exec_ext in '' $ac_executable_extensions; do
6647   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6648     ac_cv_prog_AS="${ncn_progname}"
6649     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6650     break 2
6651   fi
6652 done
6653 done
6654
6655 fi
6656 fi
6657 AS=$ac_cv_prog_AS
6658 if test -n "$AS"; then
6659   echo "$as_me:$LINENO: result: $AS" >&5
6660 echo "${ECHO_T}$AS" >&6
6661 else
6662   echo "$as_me:$LINENO: result: no" >&5
6663 echo "${ECHO_T}no" >&6
6664 fi
6665
6666   done
6667 fi
6668
6669 for ncn_progname in as; do
6670   if test -n "$ncn_tool_prefix"; then
6671     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6672 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6673 echo "$as_me:$LINENO: checking for $ac_word" >&5
6674 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6675 if test "${ac_cv_prog_AS+set}" = set; then
6676   echo $ECHO_N "(cached) $ECHO_C" >&6
6677 else
6678   if test -n "$AS"; then
6679   ac_cv_prog_AS="$AS" # Let the user override the test.
6680 else
6681 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6682 for as_dir in $PATH
6683 do
6684   IFS=$as_save_IFS
6685   test -z "$as_dir" && as_dir=.
6686   for ac_exec_ext in '' $ac_executable_extensions; do
6687   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6688     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6689     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6690     break 2
6691   fi
6692 done
6693 done
6694
6695 fi
6696 fi
6697 AS=$ac_cv_prog_AS
6698 if test -n "$AS"; then
6699   echo "$as_me:$LINENO: result: $AS" >&5
6700 echo "${ECHO_T}$AS" >&6
6701 else
6702   echo "$as_me:$LINENO: result: no" >&5
6703 echo "${ECHO_T}no" >&6
6704 fi
6705
6706   fi
6707   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6708     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6709 set dummy ${ncn_progname}; ac_word=$2
6710 echo "$as_me:$LINENO: checking for $ac_word" >&5
6711 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6712 if test "${ac_cv_prog_AS+set}" = set; then
6713   echo $ECHO_N "(cached) $ECHO_C" >&6
6714 else
6715   if test -n "$AS"; then
6716   ac_cv_prog_AS="$AS" # Let the user override the test.
6717 else
6718 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6719 for as_dir in $PATH
6720 do
6721   IFS=$as_save_IFS
6722   test -z "$as_dir" && as_dir=.
6723   for ac_exec_ext in '' $ac_executable_extensions; do
6724   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6725     ac_cv_prog_AS="${ncn_progname}"
6726     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6727     break 2
6728   fi
6729 done
6730 done
6731
6732 fi
6733 fi
6734 AS=$ac_cv_prog_AS
6735 if test -n "$AS"; then
6736   echo "$as_me:$LINENO: result: $AS" >&5
6737 echo "${ECHO_T}$AS" >&6
6738 else
6739   echo "$as_me:$LINENO: result: no" >&5
6740 echo "${ECHO_T}no" >&6
6741 fi
6742
6743   fi
6744   test -n "$ac_cv_prog_AS" && break
6745 done
6746
6747 if test -z "$ac_cv_prog_AS" ; then
6748   set dummy as
6749   if test $build = $host ; then
6750     AS="$2"
6751   else
6752     AS="${ncn_tool_prefix}$2"
6753   fi
6754 fi
6755
6756
6757
6758 if test -n "$DLLTOOL"; then
6759   ac_cv_prog_DLLTOOL=$DLLTOOL
6760 elif test -n "$ac_cv_prog_DLLTOOL"; then
6761   DLLTOOL=$ac_cv_prog_DLLTOOL
6762 fi
6763
6764 if test -n "$ac_cv_prog_DLLTOOL"; then
6765   for ncn_progname in dlltool; do
6766     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6767 set dummy ${ncn_progname}; ac_word=$2
6768 echo "$as_me:$LINENO: checking for $ac_word" >&5
6769 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6770 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6771   echo $ECHO_N "(cached) $ECHO_C" >&6
6772 else
6773   if test -n "$DLLTOOL"; then
6774   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6775 else
6776 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6777 for as_dir in $PATH
6778 do
6779   IFS=$as_save_IFS
6780   test -z "$as_dir" && as_dir=.
6781   for ac_exec_ext in '' $ac_executable_extensions; do
6782   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6783     ac_cv_prog_DLLTOOL="${ncn_progname}"
6784     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6785     break 2
6786   fi
6787 done
6788 done
6789
6790 fi
6791 fi
6792 DLLTOOL=$ac_cv_prog_DLLTOOL
6793 if test -n "$DLLTOOL"; then
6794   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6795 echo "${ECHO_T}$DLLTOOL" >&6
6796 else
6797   echo "$as_me:$LINENO: result: no" >&5
6798 echo "${ECHO_T}no" >&6
6799 fi
6800
6801   done
6802 fi
6803
6804 for ncn_progname in dlltool; do
6805   if test -n "$ncn_tool_prefix"; then
6806     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6807 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6808 echo "$as_me:$LINENO: checking for $ac_word" >&5
6809 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6810 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6811   echo $ECHO_N "(cached) $ECHO_C" >&6
6812 else
6813   if test -n "$DLLTOOL"; then
6814   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6815 else
6816 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6817 for as_dir in $PATH
6818 do
6819   IFS=$as_save_IFS
6820   test -z "$as_dir" && as_dir=.
6821   for ac_exec_ext in '' $ac_executable_extensions; do
6822   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6823     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6824     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6825     break 2
6826   fi
6827 done
6828 done
6829
6830 fi
6831 fi
6832 DLLTOOL=$ac_cv_prog_DLLTOOL
6833 if test -n "$DLLTOOL"; then
6834   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6835 echo "${ECHO_T}$DLLTOOL" >&6
6836 else
6837   echo "$as_me:$LINENO: result: no" >&5
6838 echo "${ECHO_T}no" >&6
6839 fi
6840
6841   fi
6842   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6843     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6844 set dummy ${ncn_progname}; ac_word=$2
6845 echo "$as_me:$LINENO: checking for $ac_word" >&5
6846 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6847 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6848   echo $ECHO_N "(cached) $ECHO_C" >&6
6849 else
6850   if test -n "$DLLTOOL"; then
6851   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6852 else
6853 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6854 for as_dir in $PATH
6855 do
6856   IFS=$as_save_IFS
6857   test -z "$as_dir" && as_dir=.
6858   for ac_exec_ext in '' $ac_executable_extensions; do
6859   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6860     ac_cv_prog_DLLTOOL="${ncn_progname}"
6861     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6862     break 2
6863   fi
6864 done
6865 done
6866
6867 fi
6868 fi
6869 DLLTOOL=$ac_cv_prog_DLLTOOL
6870 if test -n "$DLLTOOL"; then
6871   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6872 echo "${ECHO_T}$DLLTOOL" >&6
6873 else
6874   echo "$as_me:$LINENO: result: no" >&5
6875 echo "${ECHO_T}no" >&6
6876 fi
6877
6878   fi
6879   test -n "$ac_cv_prog_DLLTOOL" && break
6880 done
6881
6882 if test -z "$ac_cv_prog_DLLTOOL" ; then
6883   set dummy dlltool
6884   if test $build = $host ; then
6885     DLLTOOL="$2"
6886   else
6887     DLLTOOL="${ncn_tool_prefix}$2"
6888   fi
6889 fi
6890
6891
6892
6893 if test -n "$LD"; then
6894   ac_cv_prog_LD=$LD
6895 elif test -n "$ac_cv_prog_LD"; then
6896   LD=$ac_cv_prog_LD
6897 fi
6898
6899 if test -n "$ac_cv_prog_LD"; then
6900   for ncn_progname in ld; do
6901     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6902 set dummy ${ncn_progname}; ac_word=$2
6903 echo "$as_me:$LINENO: checking for $ac_word" >&5
6904 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6905 if test "${ac_cv_prog_LD+set}" = set; then
6906   echo $ECHO_N "(cached) $ECHO_C" >&6
6907 else
6908   if test -n "$LD"; then
6909   ac_cv_prog_LD="$LD" # Let the user override the test.
6910 else
6911 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6912 for as_dir in $PATH
6913 do
6914   IFS=$as_save_IFS
6915   test -z "$as_dir" && as_dir=.
6916   for ac_exec_ext in '' $ac_executable_extensions; do
6917   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6918     ac_cv_prog_LD="${ncn_progname}"
6919     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6920     break 2
6921   fi
6922 done
6923 done
6924
6925 fi
6926 fi
6927 LD=$ac_cv_prog_LD
6928 if test -n "$LD"; then
6929   echo "$as_me:$LINENO: result: $LD" >&5
6930 echo "${ECHO_T}$LD" >&6
6931 else
6932   echo "$as_me:$LINENO: result: no" >&5
6933 echo "${ECHO_T}no" >&6
6934 fi
6935
6936   done
6937 fi
6938
6939 for ncn_progname in ld; do
6940   if test -n "$ncn_tool_prefix"; then
6941     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6942 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6943 echo "$as_me:$LINENO: checking for $ac_word" >&5
6944 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6945 if test "${ac_cv_prog_LD+set}" = set; then
6946   echo $ECHO_N "(cached) $ECHO_C" >&6
6947 else
6948   if test -n "$LD"; then
6949   ac_cv_prog_LD="$LD" # Let the user override the test.
6950 else
6951 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6952 for as_dir in $PATH
6953 do
6954   IFS=$as_save_IFS
6955   test -z "$as_dir" && as_dir=.
6956   for ac_exec_ext in '' $ac_executable_extensions; do
6957   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6958     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6959     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6960     break 2
6961   fi
6962 done
6963 done
6964
6965 fi
6966 fi
6967 LD=$ac_cv_prog_LD
6968 if test -n "$LD"; then
6969   echo "$as_me:$LINENO: result: $LD" >&5
6970 echo "${ECHO_T}$LD" >&6
6971 else
6972   echo "$as_me:$LINENO: result: no" >&5
6973 echo "${ECHO_T}no" >&6
6974 fi
6975
6976   fi
6977   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6978     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6979 set dummy ${ncn_progname}; ac_word=$2
6980 echo "$as_me:$LINENO: checking for $ac_word" >&5
6981 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6982 if test "${ac_cv_prog_LD+set}" = set; then
6983   echo $ECHO_N "(cached) $ECHO_C" >&6
6984 else
6985   if test -n "$LD"; then
6986   ac_cv_prog_LD="$LD" # Let the user override the test.
6987 else
6988 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6989 for as_dir in $PATH
6990 do
6991   IFS=$as_save_IFS
6992   test -z "$as_dir" && as_dir=.
6993   for ac_exec_ext in '' $ac_executable_extensions; do
6994   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6995     ac_cv_prog_LD="${ncn_progname}"
6996     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6997     break 2
6998   fi
6999 done
7000 done
7001
7002 fi
7003 fi
7004 LD=$ac_cv_prog_LD
7005 if test -n "$LD"; then
7006   echo "$as_me:$LINENO: result: $LD" >&5
7007 echo "${ECHO_T}$LD" >&6
7008 else
7009   echo "$as_me:$LINENO: result: no" >&5
7010 echo "${ECHO_T}no" >&6
7011 fi
7012
7013   fi
7014   test -n "$ac_cv_prog_LD" && break
7015 done
7016
7017 if test -z "$ac_cv_prog_LD" ; then
7018   set dummy ld
7019   if test $build = $host ; then
7020     LD="$2"
7021   else
7022     LD="${ncn_tool_prefix}$2"
7023   fi
7024 fi
7025
7026
7027
7028 if test -n "$LIPO"; then
7029   ac_cv_prog_LIPO=$LIPO
7030 elif test -n "$ac_cv_prog_LIPO"; then
7031   LIPO=$ac_cv_prog_LIPO
7032 fi
7033
7034 if test -n "$ac_cv_prog_LIPO"; then
7035   for ncn_progname in lipo; do
7036     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7037 set dummy ${ncn_progname}; ac_word=$2
7038 echo "$as_me:$LINENO: checking for $ac_word" >&5
7039 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7040 if test "${ac_cv_prog_LIPO+set}" = set; then
7041   echo $ECHO_N "(cached) $ECHO_C" >&6
7042 else
7043   if test -n "$LIPO"; then
7044   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7045 else
7046 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7047 for as_dir in $PATH
7048 do
7049   IFS=$as_save_IFS
7050   test -z "$as_dir" && as_dir=.
7051   for ac_exec_ext in '' $ac_executable_extensions; do
7052   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7053     ac_cv_prog_LIPO="${ncn_progname}"
7054     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7055     break 2
7056   fi
7057 done
7058 done
7059
7060 fi
7061 fi
7062 LIPO=$ac_cv_prog_LIPO
7063 if test -n "$LIPO"; then
7064   echo "$as_me:$LINENO: result: $LIPO" >&5
7065 echo "${ECHO_T}$LIPO" >&6
7066 else
7067   echo "$as_me:$LINENO: result: no" >&5
7068 echo "${ECHO_T}no" >&6
7069 fi
7070
7071   done
7072 fi
7073
7074 for ncn_progname in lipo; do
7075   if test -n "$ncn_tool_prefix"; then
7076     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7077 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7078 echo "$as_me:$LINENO: checking for $ac_word" >&5
7079 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7080 if test "${ac_cv_prog_LIPO+set}" = set; then
7081   echo $ECHO_N "(cached) $ECHO_C" >&6
7082 else
7083   if test -n "$LIPO"; then
7084   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7085 else
7086 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7087 for as_dir in $PATH
7088 do
7089   IFS=$as_save_IFS
7090   test -z "$as_dir" && as_dir=.
7091   for ac_exec_ext in '' $ac_executable_extensions; do
7092   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7093     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7094     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7095     break 2
7096   fi
7097 done
7098 done
7099
7100 fi
7101 fi
7102 LIPO=$ac_cv_prog_LIPO
7103 if test -n "$LIPO"; then
7104   echo "$as_me:$LINENO: result: $LIPO" >&5
7105 echo "${ECHO_T}$LIPO" >&6
7106 else
7107   echo "$as_me:$LINENO: result: no" >&5
7108 echo "${ECHO_T}no" >&6
7109 fi
7110
7111   fi
7112   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7113     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7114 set dummy ${ncn_progname}; ac_word=$2
7115 echo "$as_me:$LINENO: checking for $ac_word" >&5
7116 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7117 if test "${ac_cv_prog_LIPO+set}" = set; then
7118   echo $ECHO_N "(cached) $ECHO_C" >&6
7119 else
7120   if test -n "$LIPO"; then
7121   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7122 else
7123 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7124 for as_dir in $PATH
7125 do
7126   IFS=$as_save_IFS
7127   test -z "$as_dir" && as_dir=.
7128   for ac_exec_ext in '' $ac_executable_extensions; do
7129   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7130     ac_cv_prog_LIPO="${ncn_progname}"
7131     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7132     break 2
7133   fi
7134 done
7135 done
7136
7137 fi
7138 fi
7139 LIPO=$ac_cv_prog_LIPO
7140 if test -n "$LIPO"; then
7141   echo "$as_me:$LINENO: result: $LIPO" >&5
7142 echo "${ECHO_T}$LIPO" >&6
7143 else
7144   echo "$as_me:$LINENO: result: no" >&5
7145 echo "${ECHO_T}no" >&6
7146 fi
7147
7148   fi
7149   test -n "$ac_cv_prog_LIPO" && break
7150 done
7151
7152 if test -z "$ac_cv_prog_LIPO" ; then
7153   set dummy lipo
7154   if test $build = $host ; then
7155     LIPO="$2"
7156   else
7157     LIPO="${ncn_tool_prefix}$2"
7158   fi
7159 fi
7160
7161
7162
7163 if test -n "$NM"; then
7164   ac_cv_prog_NM=$NM
7165 elif test -n "$ac_cv_prog_NM"; then
7166   NM=$ac_cv_prog_NM
7167 fi
7168
7169 if test -n "$ac_cv_prog_NM"; then
7170   for ncn_progname in nm; do
7171     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7172 set dummy ${ncn_progname}; ac_word=$2
7173 echo "$as_me:$LINENO: checking for $ac_word" >&5
7174 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7175 if test "${ac_cv_prog_NM+set}" = set; then
7176   echo $ECHO_N "(cached) $ECHO_C" >&6
7177 else
7178   if test -n "$NM"; then
7179   ac_cv_prog_NM="$NM" # Let the user override the test.
7180 else
7181 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7182 for as_dir in $PATH
7183 do
7184   IFS=$as_save_IFS
7185   test -z "$as_dir" && as_dir=.
7186   for ac_exec_ext in '' $ac_executable_extensions; do
7187   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7188     ac_cv_prog_NM="${ncn_progname}"
7189     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7190     break 2
7191   fi
7192 done
7193 done
7194
7195 fi
7196 fi
7197 NM=$ac_cv_prog_NM
7198 if test -n "$NM"; then
7199   echo "$as_me:$LINENO: result: $NM" >&5
7200 echo "${ECHO_T}$NM" >&6
7201 else
7202   echo "$as_me:$LINENO: result: no" >&5
7203 echo "${ECHO_T}no" >&6
7204 fi
7205
7206   done
7207 fi
7208
7209 for ncn_progname in nm; do
7210   if test -n "$ncn_tool_prefix"; then
7211     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7212 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7213 echo "$as_me:$LINENO: checking for $ac_word" >&5
7214 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7215 if test "${ac_cv_prog_NM+set}" = set; then
7216   echo $ECHO_N "(cached) $ECHO_C" >&6
7217 else
7218   if test -n "$NM"; then
7219   ac_cv_prog_NM="$NM" # Let the user override the test.
7220 else
7221 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7222 for as_dir in $PATH
7223 do
7224   IFS=$as_save_IFS
7225   test -z "$as_dir" && as_dir=.
7226   for ac_exec_ext in '' $ac_executable_extensions; do
7227   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7228     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7229     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7230     break 2
7231   fi
7232 done
7233 done
7234
7235 fi
7236 fi
7237 NM=$ac_cv_prog_NM
7238 if test -n "$NM"; then
7239   echo "$as_me:$LINENO: result: $NM" >&5
7240 echo "${ECHO_T}$NM" >&6
7241 else
7242   echo "$as_me:$LINENO: result: no" >&5
7243 echo "${ECHO_T}no" >&6
7244 fi
7245
7246   fi
7247   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7248     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7249 set dummy ${ncn_progname}; ac_word=$2
7250 echo "$as_me:$LINENO: checking for $ac_word" >&5
7251 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7252 if test "${ac_cv_prog_NM+set}" = set; then
7253   echo $ECHO_N "(cached) $ECHO_C" >&6
7254 else
7255   if test -n "$NM"; then
7256   ac_cv_prog_NM="$NM" # Let the user override the test.
7257 else
7258 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7259 for as_dir in $PATH
7260 do
7261   IFS=$as_save_IFS
7262   test -z "$as_dir" && as_dir=.
7263   for ac_exec_ext in '' $ac_executable_extensions; do
7264   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7265     ac_cv_prog_NM="${ncn_progname}"
7266     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7267     break 2
7268   fi
7269 done
7270 done
7271
7272 fi
7273 fi
7274 NM=$ac_cv_prog_NM
7275 if test -n "$NM"; then
7276   echo "$as_me:$LINENO: result: $NM" >&5
7277 echo "${ECHO_T}$NM" >&6
7278 else
7279   echo "$as_me:$LINENO: result: no" >&5
7280 echo "${ECHO_T}no" >&6
7281 fi
7282
7283   fi
7284   test -n "$ac_cv_prog_NM" && break
7285 done
7286
7287 if test -z "$ac_cv_prog_NM" ; then
7288   set dummy nm
7289   if test $build = $host ; then
7290     NM="$2"
7291   else
7292     NM="${ncn_tool_prefix}$2"
7293   fi
7294 fi
7295
7296
7297
7298 if test -n "$RANLIB"; then
7299   ac_cv_prog_RANLIB=$RANLIB
7300 elif test -n "$ac_cv_prog_RANLIB"; then
7301   RANLIB=$ac_cv_prog_RANLIB
7302 fi
7303
7304 if test -n "$ac_cv_prog_RANLIB"; then
7305   for ncn_progname in ranlib; do
7306     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7307 set dummy ${ncn_progname}; ac_word=$2
7308 echo "$as_me:$LINENO: checking for $ac_word" >&5
7309 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7310 if test "${ac_cv_prog_RANLIB+set}" = set; then
7311   echo $ECHO_N "(cached) $ECHO_C" >&6
7312 else
7313   if test -n "$RANLIB"; then
7314   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7315 else
7316 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7317 for as_dir in $PATH
7318 do
7319   IFS=$as_save_IFS
7320   test -z "$as_dir" && as_dir=.
7321   for ac_exec_ext in '' $ac_executable_extensions; do
7322   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7323     ac_cv_prog_RANLIB="${ncn_progname}"
7324     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7325     break 2
7326   fi
7327 done
7328 done
7329
7330 fi
7331 fi
7332 RANLIB=$ac_cv_prog_RANLIB
7333 if test -n "$RANLIB"; then
7334   echo "$as_me:$LINENO: result: $RANLIB" >&5
7335 echo "${ECHO_T}$RANLIB" >&6
7336 else
7337   echo "$as_me:$LINENO: result: no" >&5
7338 echo "${ECHO_T}no" >&6
7339 fi
7340
7341   done
7342 fi
7343
7344 for ncn_progname in ranlib; do
7345   if test -n "$ncn_tool_prefix"; then
7346     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7347 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7348 echo "$as_me:$LINENO: checking for $ac_word" >&5
7349 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7350 if test "${ac_cv_prog_RANLIB+set}" = set; then
7351   echo $ECHO_N "(cached) $ECHO_C" >&6
7352 else
7353   if test -n "$RANLIB"; then
7354   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7355 else
7356 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7357 for as_dir in $PATH
7358 do
7359   IFS=$as_save_IFS
7360   test -z "$as_dir" && as_dir=.
7361   for ac_exec_ext in '' $ac_executable_extensions; do
7362   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7363     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7364     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7365     break 2
7366   fi
7367 done
7368 done
7369
7370 fi
7371 fi
7372 RANLIB=$ac_cv_prog_RANLIB
7373 if test -n "$RANLIB"; then
7374   echo "$as_me:$LINENO: result: $RANLIB" >&5
7375 echo "${ECHO_T}$RANLIB" >&6
7376 else
7377   echo "$as_me:$LINENO: result: no" >&5
7378 echo "${ECHO_T}no" >&6
7379 fi
7380
7381   fi
7382   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7383     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7384 set dummy ${ncn_progname}; ac_word=$2
7385 echo "$as_me:$LINENO: checking for $ac_word" >&5
7386 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7387 if test "${ac_cv_prog_RANLIB+set}" = set; then
7388   echo $ECHO_N "(cached) $ECHO_C" >&6
7389 else
7390   if test -n "$RANLIB"; then
7391   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7392 else
7393 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7394 for as_dir in $PATH
7395 do
7396   IFS=$as_save_IFS
7397   test -z "$as_dir" && as_dir=.
7398   for ac_exec_ext in '' $ac_executable_extensions; do
7399   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7400     ac_cv_prog_RANLIB="${ncn_progname}"
7401     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7402     break 2
7403   fi
7404 done
7405 done
7406
7407 fi
7408 fi
7409 RANLIB=$ac_cv_prog_RANLIB
7410 if test -n "$RANLIB"; then
7411   echo "$as_me:$LINENO: result: $RANLIB" >&5
7412 echo "${ECHO_T}$RANLIB" >&6
7413 else
7414   echo "$as_me:$LINENO: result: no" >&5
7415 echo "${ECHO_T}no" >&6
7416 fi
7417
7418   fi
7419   test -n "$ac_cv_prog_RANLIB" && break
7420 done
7421
7422 if test -z "$ac_cv_prog_RANLIB" ; then
7423   RANLIB=":"
7424 fi
7425
7426
7427
7428 if test -n "$STRIP"; then
7429   ac_cv_prog_STRIP=$STRIP
7430 elif test -n "$ac_cv_prog_STRIP"; then
7431   STRIP=$ac_cv_prog_STRIP
7432 fi
7433
7434 if test -n "$ac_cv_prog_STRIP"; then
7435   for ncn_progname in strip; do
7436     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7437 set dummy ${ncn_progname}; ac_word=$2
7438 echo "$as_me:$LINENO: checking for $ac_word" >&5
7439 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7440 if test "${ac_cv_prog_STRIP+set}" = set; then
7441   echo $ECHO_N "(cached) $ECHO_C" >&6
7442 else
7443   if test -n "$STRIP"; then
7444   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7445 else
7446 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7447 for as_dir in $PATH
7448 do
7449   IFS=$as_save_IFS
7450   test -z "$as_dir" && as_dir=.
7451   for ac_exec_ext in '' $ac_executable_extensions; do
7452   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7453     ac_cv_prog_STRIP="${ncn_progname}"
7454     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7455     break 2
7456   fi
7457 done
7458 done
7459
7460 fi
7461 fi
7462 STRIP=$ac_cv_prog_STRIP
7463 if test -n "$STRIP"; then
7464   echo "$as_me:$LINENO: result: $STRIP" >&5
7465 echo "${ECHO_T}$STRIP" >&6
7466 else
7467   echo "$as_me:$LINENO: result: no" >&5
7468 echo "${ECHO_T}no" >&6
7469 fi
7470
7471   done
7472 fi
7473
7474 for ncn_progname in strip; do
7475   if test -n "$ncn_tool_prefix"; then
7476     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7477 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7478 echo "$as_me:$LINENO: checking for $ac_word" >&5
7479 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7480 if test "${ac_cv_prog_STRIP+set}" = set; then
7481   echo $ECHO_N "(cached) $ECHO_C" >&6
7482 else
7483   if test -n "$STRIP"; then
7484   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7485 else
7486 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7487 for as_dir in $PATH
7488 do
7489   IFS=$as_save_IFS
7490   test -z "$as_dir" && as_dir=.
7491   for ac_exec_ext in '' $ac_executable_extensions; do
7492   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7493     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7494     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7495     break 2
7496   fi
7497 done
7498 done
7499
7500 fi
7501 fi
7502 STRIP=$ac_cv_prog_STRIP
7503 if test -n "$STRIP"; then
7504   echo "$as_me:$LINENO: result: $STRIP" >&5
7505 echo "${ECHO_T}$STRIP" >&6
7506 else
7507   echo "$as_me:$LINENO: result: no" >&5
7508 echo "${ECHO_T}no" >&6
7509 fi
7510
7511   fi
7512   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7513     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7514 set dummy ${ncn_progname}; ac_word=$2
7515 echo "$as_me:$LINENO: checking for $ac_word" >&5
7516 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7517 if test "${ac_cv_prog_STRIP+set}" = set; then
7518   echo $ECHO_N "(cached) $ECHO_C" >&6
7519 else
7520   if test -n "$STRIP"; then
7521   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7522 else
7523 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7524 for as_dir in $PATH
7525 do
7526   IFS=$as_save_IFS
7527   test -z "$as_dir" && as_dir=.
7528   for ac_exec_ext in '' $ac_executable_extensions; do
7529   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7530     ac_cv_prog_STRIP="${ncn_progname}"
7531     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7532     break 2
7533   fi
7534 done
7535 done
7536
7537 fi
7538 fi
7539 STRIP=$ac_cv_prog_STRIP
7540 if test -n "$STRIP"; then
7541   echo "$as_me:$LINENO: result: $STRIP" >&5
7542 echo "${ECHO_T}$STRIP" >&6
7543 else
7544   echo "$as_me:$LINENO: result: no" >&5
7545 echo "${ECHO_T}no" >&6
7546 fi
7547
7548   fi
7549   test -n "$ac_cv_prog_STRIP" && break
7550 done
7551
7552 if test -z "$ac_cv_prog_STRIP" ; then
7553   STRIP=":"
7554 fi
7555
7556
7557
7558 if test -n "$WINDRES"; then
7559   ac_cv_prog_WINDRES=$WINDRES
7560 elif test -n "$ac_cv_prog_WINDRES"; then
7561   WINDRES=$ac_cv_prog_WINDRES
7562 fi
7563
7564 if test -n "$ac_cv_prog_WINDRES"; then
7565   for ncn_progname in windres; do
7566     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7567 set dummy ${ncn_progname}; ac_word=$2
7568 echo "$as_me:$LINENO: checking for $ac_word" >&5
7569 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7570 if test "${ac_cv_prog_WINDRES+set}" = set; then
7571   echo $ECHO_N "(cached) $ECHO_C" >&6
7572 else
7573   if test -n "$WINDRES"; then
7574   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7575 else
7576 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7577 for as_dir in $PATH
7578 do
7579   IFS=$as_save_IFS
7580   test -z "$as_dir" && as_dir=.
7581   for ac_exec_ext in '' $ac_executable_extensions; do
7582   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7583     ac_cv_prog_WINDRES="${ncn_progname}"
7584     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7585     break 2
7586   fi
7587 done
7588 done
7589
7590 fi
7591 fi
7592 WINDRES=$ac_cv_prog_WINDRES
7593 if test -n "$WINDRES"; then
7594   echo "$as_me:$LINENO: result: $WINDRES" >&5
7595 echo "${ECHO_T}$WINDRES" >&6
7596 else
7597   echo "$as_me:$LINENO: result: no" >&5
7598 echo "${ECHO_T}no" >&6
7599 fi
7600
7601   done
7602 fi
7603
7604 for ncn_progname in windres; do
7605   if test -n "$ncn_tool_prefix"; then
7606     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7607 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7608 echo "$as_me:$LINENO: checking for $ac_word" >&5
7609 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7610 if test "${ac_cv_prog_WINDRES+set}" = set; then
7611   echo $ECHO_N "(cached) $ECHO_C" >&6
7612 else
7613   if test -n "$WINDRES"; then
7614   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7615 else
7616 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7617 for as_dir in $PATH
7618 do
7619   IFS=$as_save_IFS
7620   test -z "$as_dir" && as_dir=.
7621   for ac_exec_ext in '' $ac_executable_extensions; do
7622   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7623     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7624     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7625     break 2
7626   fi
7627 done
7628 done
7629
7630 fi
7631 fi
7632 WINDRES=$ac_cv_prog_WINDRES
7633 if test -n "$WINDRES"; then
7634   echo "$as_me:$LINENO: result: $WINDRES" >&5
7635 echo "${ECHO_T}$WINDRES" >&6
7636 else
7637   echo "$as_me:$LINENO: result: no" >&5
7638 echo "${ECHO_T}no" >&6
7639 fi
7640
7641   fi
7642   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7643     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7644 set dummy ${ncn_progname}; ac_word=$2
7645 echo "$as_me:$LINENO: checking for $ac_word" >&5
7646 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7647 if test "${ac_cv_prog_WINDRES+set}" = set; then
7648   echo $ECHO_N "(cached) $ECHO_C" >&6
7649 else
7650   if test -n "$WINDRES"; then
7651   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7652 else
7653 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7654 for as_dir in $PATH
7655 do
7656   IFS=$as_save_IFS
7657   test -z "$as_dir" && as_dir=.
7658   for ac_exec_ext in '' $ac_executable_extensions; do
7659   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7660     ac_cv_prog_WINDRES="${ncn_progname}"
7661     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7662     break 2
7663   fi
7664 done
7665 done
7666
7667 fi
7668 fi
7669 WINDRES=$ac_cv_prog_WINDRES
7670 if test -n "$WINDRES"; then
7671   echo "$as_me:$LINENO: result: $WINDRES" >&5
7672 echo "${ECHO_T}$WINDRES" >&6
7673 else
7674   echo "$as_me:$LINENO: result: no" >&5
7675 echo "${ECHO_T}no" >&6
7676 fi
7677
7678   fi
7679   test -n "$ac_cv_prog_WINDRES" && break
7680 done
7681
7682 if test -z "$ac_cv_prog_WINDRES" ; then
7683   set dummy windres
7684   if test $build = $host ; then
7685     WINDRES="$2"
7686   else
7687     WINDRES="${ncn_tool_prefix}$2"
7688   fi
7689 fi
7690
7691
7692
7693 if test -n "$WINDMC"; then
7694   ac_cv_prog_WINDMC=$WINDMC
7695 elif test -n "$ac_cv_prog_WINDMC"; then
7696   WINDMC=$ac_cv_prog_WINDMC
7697 fi
7698
7699 if test -n "$ac_cv_prog_WINDMC"; then
7700   for ncn_progname in windmc; do
7701     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7702 set dummy ${ncn_progname}; ac_word=$2
7703 echo "$as_me:$LINENO: checking for $ac_word" >&5
7704 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7705 if test "${ac_cv_prog_WINDMC+set}" = set; then
7706   echo $ECHO_N "(cached) $ECHO_C" >&6
7707 else
7708   if test -n "$WINDMC"; then
7709   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7710 else
7711 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7712 for as_dir in $PATH
7713 do
7714   IFS=$as_save_IFS
7715   test -z "$as_dir" && as_dir=.
7716   for ac_exec_ext in '' $ac_executable_extensions; do
7717   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7718     ac_cv_prog_WINDMC="${ncn_progname}"
7719     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7720     break 2
7721   fi
7722 done
7723 done
7724
7725 fi
7726 fi
7727 WINDMC=$ac_cv_prog_WINDMC
7728 if test -n "$WINDMC"; then
7729   echo "$as_me:$LINENO: result: $WINDMC" >&5
7730 echo "${ECHO_T}$WINDMC" >&6
7731 else
7732   echo "$as_me:$LINENO: result: no" >&5
7733 echo "${ECHO_T}no" >&6
7734 fi
7735
7736   done
7737 fi
7738
7739 for ncn_progname in windmc; do
7740   if test -n "$ncn_tool_prefix"; then
7741     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7742 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7743 echo "$as_me:$LINENO: checking for $ac_word" >&5
7744 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7745 if test "${ac_cv_prog_WINDMC+set}" = set; then
7746   echo $ECHO_N "(cached) $ECHO_C" >&6
7747 else
7748   if test -n "$WINDMC"; then
7749   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7750 else
7751 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7752 for as_dir in $PATH
7753 do
7754   IFS=$as_save_IFS
7755   test -z "$as_dir" && as_dir=.
7756   for ac_exec_ext in '' $ac_executable_extensions; do
7757   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7758     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7759     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7760     break 2
7761   fi
7762 done
7763 done
7764
7765 fi
7766 fi
7767 WINDMC=$ac_cv_prog_WINDMC
7768 if test -n "$WINDMC"; then
7769   echo "$as_me:$LINENO: result: $WINDMC" >&5
7770 echo "${ECHO_T}$WINDMC" >&6
7771 else
7772   echo "$as_me:$LINENO: result: no" >&5
7773 echo "${ECHO_T}no" >&6
7774 fi
7775
7776   fi
7777   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7778     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7779 set dummy ${ncn_progname}; ac_word=$2
7780 echo "$as_me:$LINENO: checking for $ac_word" >&5
7781 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7782 if test "${ac_cv_prog_WINDMC+set}" = set; then
7783   echo $ECHO_N "(cached) $ECHO_C" >&6
7784 else
7785   if test -n "$WINDMC"; then
7786   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7787 else
7788 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7789 for as_dir in $PATH
7790 do
7791   IFS=$as_save_IFS
7792   test -z "$as_dir" && as_dir=.
7793   for ac_exec_ext in '' $ac_executable_extensions; do
7794   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7795     ac_cv_prog_WINDMC="${ncn_progname}"
7796     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7797     break 2
7798   fi
7799 done
7800 done
7801
7802 fi
7803 fi
7804 WINDMC=$ac_cv_prog_WINDMC
7805 if test -n "$WINDMC"; then
7806   echo "$as_me:$LINENO: result: $WINDMC" >&5
7807 echo "${ECHO_T}$WINDMC" >&6
7808 else
7809   echo "$as_me:$LINENO: result: no" >&5
7810 echo "${ECHO_T}no" >&6
7811 fi
7812
7813   fi
7814   test -n "$ac_cv_prog_WINDMC" && break
7815 done
7816
7817 if test -z "$ac_cv_prog_WINDMC" ; then
7818   set dummy windmc
7819   if test $build = $host ; then
7820     WINDMC="$2"
7821   else
7822     WINDMC="${ncn_tool_prefix}$2"
7823   fi
7824 fi
7825
7826
7827
7828 if test -n "$OBJCOPY"; then
7829   ac_cv_prog_OBJCOPY=$OBJCOPY
7830 elif test -n "$ac_cv_prog_OBJCOPY"; then
7831   OBJCOPY=$ac_cv_prog_OBJCOPY
7832 fi
7833
7834 if test -n "$ac_cv_prog_OBJCOPY"; then
7835   for ncn_progname in objcopy; do
7836     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7837 set dummy ${ncn_progname}; ac_word=$2
7838 echo "$as_me:$LINENO: checking for $ac_word" >&5
7839 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7840 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7841   echo $ECHO_N "(cached) $ECHO_C" >&6
7842 else
7843   if test -n "$OBJCOPY"; then
7844   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7845 else
7846 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7847 for as_dir in $PATH
7848 do
7849   IFS=$as_save_IFS
7850   test -z "$as_dir" && as_dir=.
7851   for ac_exec_ext in '' $ac_executable_extensions; do
7852   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7853     ac_cv_prog_OBJCOPY="${ncn_progname}"
7854     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7855     break 2
7856   fi
7857 done
7858 done
7859
7860 fi
7861 fi
7862 OBJCOPY=$ac_cv_prog_OBJCOPY
7863 if test -n "$OBJCOPY"; then
7864   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7865 echo "${ECHO_T}$OBJCOPY" >&6
7866 else
7867   echo "$as_me:$LINENO: result: no" >&5
7868 echo "${ECHO_T}no" >&6
7869 fi
7870
7871   done
7872 fi
7873
7874 for ncn_progname in objcopy; do
7875   if test -n "$ncn_tool_prefix"; then
7876     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7877 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7878 echo "$as_me:$LINENO: checking for $ac_word" >&5
7879 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7880 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7881   echo $ECHO_N "(cached) $ECHO_C" >&6
7882 else
7883   if test -n "$OBJCOPY"; then
7884   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7885 else
7886 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7887 for as_dir in $PATH
7888 do
7889   IFS=$as_save_IFS
7890   test -z "$as_dir" && as_dir=.
7891   for ac_exec_ext in '' $ac_executable_extensions; do
7892   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7893     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7894     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7895     break 2
7896   fi
7897 done
7898 done
7899
7900 fi
7901 fi
7902 OBJCOPY=$ac_cv_prog_OBJCOPY
7903 if test -n "$OBJCOPY"; then
7904   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7905 echo "${ECHO_T}$OBJCOPY" >&6
7906 else
7907   echo "$as_me:$LINENO: result: no" >&5
7908 echo "${ECHO_T}no" >&6
7909 fi
7910
7911   fi
7912   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7913     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7914 set dummy ${ncn_progname}; ac_word=$2
7915 echo "$as_me:$LINENO: checking for $ac_word" >&5
7916 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7917 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7918   echo $ECHO_N "(cached) $ECHO_C" >&6
7919 else
7920   if test -n "$OBJCOPY"; then
7921   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7922 else
7923 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7924 for as_dir in $PATH
7925 do
7926   IFS=$as_save_IFS
7927   test -z "$as_dir" && as_dir=.
7928   for ac_exec_ext in '' $ac_executable_extensions; do
7929   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7930     ac_cv_prog_OBJCOPY="${ncn_progname}"
7931     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7932     break 2
7933   fi
7934 done
7935 done
7936
7937 fi
7938 fi
7939 OBJCOPY=$ac_cv_prog_OBJCOPY
7940 if test -n "$OBJCOPY"; then
7941   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7942 echo "${ECHO_T}$OBJCOPY" >&6
7943 else
7944   echo "$as_me:$LINENO: result: no" >&5
7945 echo "${ECHO_T}no" >&6
7946 fi
7947
7948   fi
7949   test -n "$ac_cv_prog_OBJCOPY" && break
7950 done
7951
7952 if test -z "$ac_cv_prog_OBJCOPY" ; then
7953   set dummy objcopy
7954   if test $build = $host ; then
7955     OBJCOPY="$2"
7956   else
7957     OBJCOPY="${ncn_tool_prefix}$2"
7958   fi
7959 fi
7960
7961
7962
7963 if test -n "$OBJDUMP"; then
7964   ac_cv_prog_OBJDUMP=$OBJDUMP
7965 elif test -n "$ac_cv_prog_OBJDUMP"; then
7966   OBJDUMP=$ac_cv_prog_OBJDUMP
7967 fi
7968
7969 if test -n "$ac_cv_prog_OBJDUMP"; then
7970   for ncn_progname in objdump; do
7971     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7972 set dummy ${ncn_progname}; ac_word=$2
7973 echo "$as_me:$LINENO: checking for $ac_word" >&5
7974 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7975 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7976   echo $ECHO_N "(cached) $ECHO_C" >&6
7977 else
7978   if test -n "$OBJDUMP"; then
7979   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7980 else
7981 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7982 for as_dir in $PATH
7983 do
7984   IFS=$as_save_IFS
7985   test -z "$as_dir" && as_dir=.
7986   for ac_exec_ext in '' $ac_executable_extensions; do
7987   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7988     ac_cv_prog_OBJDUMP="${ncn_progname}"
7989     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7990     break 2
7991   fi
7992 done
7993 done
7994
7995 fi
7996 fi
7997 OBJDUMP=$ac_cv_prog_OBJDUMP
7998 if test -n "$OBJDUMP"; then
7999   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8000 echo "${ECHO_T}$OBJDUMP" >&6
8001 else
8002   echo "$as_me:$LINENO: result: no" >&5
8003 echo "${ECHO_T}no" >&6
8004 fi
8005
8006   done
8007 fi
8008
8009 for ncn_progname in objdump; do
8010   if test -n "$ncn_tool_prefix"; then
8011     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8012 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8013 echo "$as_me:$LINENO: checking for $ac_word" >&5
8014 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8015 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8016   echo $ECHO_N "(cached) $ECHO_C" >&6
8017 else
8018   if test -n "$OBJDUMP"; then
8019   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8020 else
8021 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8022 for as_dir in $PATH
8023 do
8024   IFS=$as_save_IFS
8025   test -z "$as_dir" && as_dir=.
8026   for ac_exec_ext in '' $ac_executable_extensions; do
8027   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8028     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8029     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8030     break 2
8031   fi
8032 done
8033 done
8034
8035 fi
8036 fi
8037 OBJDUMP=$ac_cv_prog_OBJDUMP
8038 if test -n "$OBJDUMP"; then
8039   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8040 echo "${ECHO_T}$OBJDUMP" >&6
8041 else
8042   echo "$as_me:$LINENO: result: no" >&5
8043 echo "${ECHO_T}no" >&6
8044 fi
8045
8046   fi
8047   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8048     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8049 set dummy ${ncn_progname}; ac_word=$2
8050 echo "$as_me:$LINENO: checking for $ac_word" >&5
8051 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8052 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8053   echo $ECHO_N "(cached) $ECHO_C" >&6
8054 else
8055   if test -n "$OBJDUMP"; then
8056   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8057 else
8058 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8059 for as_dir in $PATH
8060 do
8061   IFS=$as_save_IFS
8062   test -z "$as_dir" && as_dir=.
8063   for ac_exec_ext in '' $ac_executable_extensions; do
8064   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8065     ac_cv_prog_OBJDUMP="${ncn_progname}"
8066     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8067     break 2
8068   fi
8069 done
8070 done
8071
8072 fi
8073 fi
8074 OBJDUMP=$ac_cv_prog_OBJDUMP
8075 if test -n "$OBJDUMP"; then
8076   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8077 echo "${ECHO_T}$OBJDUMP" >&6
8078 else
8079   echo "$as_me:$LINENO: result: no" >&5
8080 echo "${ECHO_T}no" >&6
8081 fi
8082
8083   fi
8084   test -n "$ac_cv_prog_OBJDUMP" && break
8085 done
8086
8087 if test -z "$ac_cv_prog_OBJDUMP" ; then
8088   set dummy objdump
8089   if test $build = $host ; then
8090     OBJDUMP="$2"
8091   else
8092     OBJDUMP="${ncn_tool_prefix}$2"
8093   fi
8094 fi
8095
8096
8097
8098
8099
8100
8101 # Target tools.
8102
8103 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8104 if test "${with_build_time_tools+set}" = set; then
8105   withval="$with_build_time_tools"
8106   case x"$withval" in
8107      x/*) ;;
8108      *)
8109        with_build_time_tools=
8110        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8111 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8112        ;;
8113    esac
8114 else
8115   with_build_time_tools=
8116 fi;
8117
8118
8119
8120 if test -n "$CC_FOR_TARGET"; then
8121   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8122 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8123   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8124 fi
8125
8126 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8127   for ncn_progname in cc gcc; do
8128     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8129 set dummy ${ncn_progname}; ac_word=$2
8130 echo "$as_me:$LINENO: checking for $ac_word" >&5
8131 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8132 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8133   echo $ECHO_N "(cached) $ECHO_C" >&6
8134 else
8135   if test -n "$CC_FOR_TARGET"; then
8136   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8137 else
8138 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8139 for as_dir in $PATH
8140 do
8141   IFS=$as_save_IFS
8142   test -z "$as_dir" && as_dir=.
8143   for ac_exec_ext in '' $ac_executable_extensions; do
8144   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8145     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8146     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8147     break 2
8148   fi
8149 done
8150 done
8151
8152 fi
8153 fi
8154 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8155 if test -n "$CC_FOR_TARGET"; then
8156   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8157 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8158 else
8159   echo "$as_me:$LINENO: result: no" >&5
8160 echo "${ECHO_T}no" >&6
8161 fi
8162
8163   done
8164 fi
8165
8166 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8167   for ncn_progname in cc gcc; do
8168     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8169 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8170     if test -x $with_build_time_tools/${ncn_progname}; then
8171       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8172       echo "$as_me:$LINENO: result: yes" >&5
8173 echo "${ECHO_T}yes" >&6
8174       break
8175     else
8176       echo "$as_me:$LINENO: result: no" >&5
8177 echo "${ECHO_T}no" >&6
8178     fi
8179   done
8180 fi
8181
8182 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8183   for ncn_progname in cc gcc; do
8184     if test -n "$ncn_target_tool_prefix"; then
8185       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8186 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8187 echo "$as_me:$LINENO: checking for $ac_word" >&5
8188 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8189 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8190   echo $ECHO_N "(cached) $ECHO_C" >&6
8191 else
8192   if test -n "$CC_FOR_TARGET"; then
8193   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8194 else
8195 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8196 for as_dir in $PATH
8197 do
8198   IFS=$as_save_IFS
8199   test -z "$as_dir" && as_dir=.
8200   for ac_exec_ext in '' $ac_executable_extensions; do
8201   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8202     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8203     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8204     break 2
8205   fi
8206 done
8207 done
8208
8209 fi
8210 fi
8211 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8212 if test -n "$CC_FOR_TARGET"; then
8213   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8214 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8215 else
8216   echo "$as_me:$LINENO: result: no" >&5
8217 echo "${ECHO_T}no" >&6
8218 fi
8219
8220     fi
8221     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8222       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8223 set dummy ${ncn_progname}; ac_word=$2
8224 echo "$as_me:$LINENO: checking for $ac_word" >&5
8225 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8226 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8227   echo $ECHO_N "(cached) $ECHO_C" >&6
8228 else
8229   if test -n "$CC_FOR_TARGET"; then
8230   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8231 else
8232 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8233 for as_dir in $PATH
8234 do
8235   IFS=$as_save_IFS
8236   test -z "$as_dir" && as_dir=.
8237   for ac_exec_ext in '' $ac_executable_extensions; do
8238   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8239     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8240     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8241     break 2
8242   fi
8243 done
8244 done
8245
8246 fi
8247 fi
8248 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8249 if test -n "$CC_FOR_TARGET"; then
8250   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8251 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8252 else
8253   echo "$as_me:$LINENO: result: no" >&5
8254 echo "${ECHO_T}no" >&6
8255 fi
8256
8257     fi
8258     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8259   done
8260 fi
8261
8262 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8263   set dummy cc gcc
8264   if test $build = $target ; then
8265     CC_FOR_TARGET="$2"
8266   else
8267     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8268   fi
8269 else
8270   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8271 fi
8272
8273
8274
8275 if test -n "$CXX_FOR_TARGET"; then
8276   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8277 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8278   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8279 fi
8280
8281 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8282   for ncn_progname in c++ g++ cxx gxx; do
8283     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8284 set dummy ${ncn_progname}; ac_word=$2
8285 echo "$as_me:$LINENO: checking for $ac_word" >&5
8286 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8287 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8288   echo $ECHO_N "(cached) $ECHO_C" >&6
8289 else
8290   if test -n "$CXX_FOR_TARGET"; then
8291   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8292 else
8293 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8294 for as_dir in $PATH
8295 do
8296   IFS=$as_save_IFS
8297   test -z "$as_dir" && as_dir=.
8298   for ac_exec_ext in '' $ac_executable_extensions; do
8299   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8300     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8301     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8302     break 2
8303   fi
8304 done
8305 done
8306
8307 fi
8308 fi
8309 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8310 if test -n "$CXX_FOR_TARGET"; then
8311   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8312 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8313 else
8314   echo "$as_me:$LINENO: result: no" >&5
8315 echo "${ECHO_T}no" >&6
8316 fi
8317
8318   done
8319 fi
8320
8321 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8322   for ncn_progname in c++ g++ cxx gxx; do
8323     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8324 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8325     if test -x $with_build_time_tools/${ncn_progname}; then
8326       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8327       echo "$as_me:$LINENO: result: yes" >&5
8328 echo "${ECHO_T}yes" >&6
8329       break
8330     else
8331       echo "$as_me:$LINENO: result: no" >&5
8332 echo "${ECHO_T}no" >&6
8333     fi
8334   done
8335 fi
8336
8337 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8338   for ncn_progname in c++ g++ cxx gxx; do
8339     if test -n "$ncn_target_tool_prefix"; then
8340       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8341 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8342 echo "$as_me:$LINENO: checking for $ac_word" >&5
8343 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8344 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8345   echo $ECHO_N "(cached) $ECHO_C" >&6
8346 else
8347   if test -n "$CXX_FOR_TARGET"; then
8348   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8349 else
8350 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8351 for as_dir in $PATH
8352 do
8353   IFS=$as_save_IFS
8354   test -z "$as_dir" && as_dir=.
8355   for ac_exec_ext in '' $ac_executable_extensions; do
8356   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8357     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8358     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8359     break 2
8360   fi
8361 done
8362 done
8363
8364 fi
8365 fi
8366 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8367 if test -n "$CXX_FOR_TARGET"; then
8368   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8369 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8370 else
8371   echo "$as_me:$LINENO: result: no" >&5
8372 echo "${ECHO_T}no" >&6
8373 fi
8374
8375     fi
8376     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8377       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8378 set dummy ${ncn_progname}; ac_word=$2
8379 echo "$as_me:$LINENO: checking for $ac_word" >&5
8380 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8381 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8382   echo $ECHO_N "(cached) $ECHO_C" >&6
8383 else
8384   if test -n "$CXX_FOR_TARGET"; then
8385   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8386 else
8387 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8388 for as_dir in $PATH
8389 do
8390   IFS=$as_save_IFS
8391   test -z "$as_dir" && as_dir=.
8392   for ac_exec_ext in '' $ac_executable_extensions; do
8393   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8394     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8395     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8396     break 2
8397   fi
8398 done
8399 done
8400
8401 fi
8402 fi
8403 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8404 if test -n "$CXX_FOR_TARGET"; then
8405   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8406 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8407 else
8408   echo "$as_me:$LINENO: result: no" >&5
8409 echo "${ECHO_T}no" >&6
8410 fi
8411
8412     fi
8413     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8414   done
8415 fi
8416
8417 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8418   set dummy c++ g++ cxx gxx
8419   if test $build = $target ; then
8420     CXX_FOR_TARGET="$2"
8421   else
8422     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8423   fi
8424 else
8425   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8426 fi
8427
8428
8429
8430 if test -n "$GCC_FOR_TARGET"; then
8431   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8432 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8433   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8434 fi
8435
8436 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8437   for ncn_progname in gcc; do
8438     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8439 set dummy ${ncn_progname}; ac_word=$2
8440 echo "$as_me:$LINENO: checking for $ac_word" >&5
8441 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8442 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8443   echo $ECHO_N "(cached) $ECHO_C" >&6
8444 else
8445   if test -n "$GCC_FOR_TARGET"; then
8446   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8447 else
8448 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8449 for as_dir in $PATH
8450 do
8451   IFS=$as_save_IFS
8452   test -z "$as_dir" && as_dir=.
8453   for ac_exec_ext in '' $ac_executable_extensions; do
8454   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8455     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8456     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8457     break 2
8458   fi
8459 done
8460 done
8461
8462 fi
8463 fi
8464 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8465 if test -n "$GCC_FOR_TARGET"; then
8466   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8467 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8468 else
8469   echo "$as_me:$LINENO: result: no" >&5
8470 echo "${ECHO_T}no" >&6
8471 fi
8472
8473   done
8474 fi
8475
8476 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8477   for ncn_progname in gcc; do
8478     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8479 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8480     if test -x $with_build_time_tools/${ncn_progname}; then
8481       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8482       echo "$as_me:$LINENO: result: yes" >&5
8483 echo "${ECHO_T}yes" >&6
8484       break
8485     else
8486       echo "$as_me:$LINENO: result: no" >&5
8487 echo "${ECHO_T}no" >&6
8488     fi
8489   done
8490 fi
8491
8492 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8493   for ncn_progname in gcc; do
8494     if test -n "$ncn_target_tool_prefix"; then
8495       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8496 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8497 echo "$as_me:$LINENO: checking for $ac_word" >&5
8498 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8499 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8500   echo $ECHO_N "(cached) $ECHO_C" >&6
8501 else
8502   if test -n "$GCC_FOR_TARGET"; then
8503   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8504 else
8505 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8506 for as_dir in $PATH
8507 do
8508   IFS=$as_save_IFS
8509   test -z "$as_dir" && as_dir=.
8510   for ac_exec_ext in '' $ac_executable_extensions; do
8511   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8512     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8513     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8514     break 2
8515   fi
8516 done
8517 done
8518
8519 fi
8520 fi
8521 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8522 if test -n "$GCC_FOR_TARGET"; then
8523   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8524 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8525 else
8526   echo "$as_me:$LINENO: result: no" >&5
8527 echo "${ECHO_T}no" >&6
8528 fi
8529
8530     fi
8531     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8532       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8533 set dummy ${ncn_progname}; ac_word=$2
8534 echo "$as_me:$LINENO: checking for $ac_word" >&5
8535 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8536 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8537   echo $ECHO_N "(cached) $ECHO_C" >&6
8538 else
8539   if test -n "$GCC_FOR_TARGET"; then
8540   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8541 else
8542 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8543 for as_dir in $PATH
8544 do
8545   IFS=$as_save_IFS
8546   test -z "$as_dir" && as_dir=.
8547   for ac_exec_ext in '' $ac_executable_extensions; do
8548   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8549     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8550     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8551     break 2
8552   fi
8553 done
8554 done
8555
8556 fi
8557 fi
8558 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8559 if test -n "$GCC_FOR_TARGET"; then
8560   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8561 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8562 else
8563   echo "$as_me:$LINENO: result: no" >&5
8564 echo "${ECHO_T}no" >&6
8565 fi
8566
8567     fi
8568     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8569   done
8570 fi
8571
8572 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8573   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8574 else
8575   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8576 fi
8577
8578
8579
8580 if test -n "$GCJ_FOR_TARGET"; then
8581   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8582 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8583   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8584 fi
8585
8586 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8587   for ncn_progname in gcj; do
8588     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8589 set dummy ${ncn_progname}; ac_word=$2
8590 echo "$as_me:$LINENO: checking for $ac_word" >&5
8591 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8592 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8593   echo $ECHO_N "(cached) $ECHO_C" >&6
8594 else
8595   if test -n "$GCJ_FOR_TARGET"; then
8596   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8597 else
8598 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8599 for as_dir in $PATH
8600 do
8601   IFS=$as_save_IFS
8602   test -z "$as_dir" && as_dir=.
8603   for ac_exec_ext in '' $ac_executable_extensions; do
8604   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8605     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8606     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8607     break 2
8608   fi
8609 done
8610 done
8611
8612 fi
8613 fi
8614 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8615 if test -n "$GCJ_FOR_TARGET"; then
8616   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8617 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8618 else
8619   echo "$as_me:$LINENO: result: no" >&5
8620 echo "${ECHO_T}no" >&6
8621 fi
8622
8623   done
8624 fi
8625
8626 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8627   for ncn_progname in gcj; do
8628     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8629 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8630     if test -x $with_build_time_tools/${ncn_progname}; then
8631       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8632       echo "$as_me:$LINENO: result: yes" >&5
8633 echo "${ECHO_T}yes" >&6
8634       break
8635     else
8636       echo "$as_me:$LINENO: result: no" >&5
8637 echo "${ECHO_T}no" >&6
8638     fi
8639   done
8640 fi
8641
8642 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8643   for ncn_progname in gcj; do
8644     if test -n "$ncn_target_tool_prefix"; then
8645       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8646 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8647 echo "$as_me:$LINENO: checking for $ac_word" >&5
8648 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8649 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8650   echo $ECHO_N "(cached) $ECHO_C" >&6
8651 else
8652   if test -n "$GCJ_FOR_TARGET"; then
8653   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8654 else
8655 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8656 for as_dir in $PATH
8657 do
8658   IFS=$as_save_IFS
8659   test -z "$as_dir" && as_dir=.
8660   for ac_exec_ext in '' $ac_executable_extensions; do
8661   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8662     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8663     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8664     break 2
8665   fi
8666 done
8667 done
8668
8669 fi
8670 fi
8671 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8672 if test -n "$GCJ_FOR_TARGET"; then
8673   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8674 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8675 else
8676   echo "$as_me:$LINENO: result: no" >&5
8677 echo "${ECHO_T}no" >&6
8678 fi
8679
8680     fi
8681     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8682       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8683 set dummy ${ncn_progname}; ac_word=$2
8684 echo "$as_me:$LINENO: checking for $ac_word" >&5
8685 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8686 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8687   echo $ECHO_N "(cached) $ECHO_C" >&6
8688 else
8689   if test -n "$GCJ_FOR_TARGET"; then
8690   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8691 else
8692 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8693 for as_dir in $PATH
8694 do
8695   IFS=$as_save_IFS
8696   test -z "$as_dir" && as_dir=.
8697   for ac_exec_ext in '' $ac_executable_extensions; do
8698   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8699     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8700     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8701     break 2
8702   fi
8703 done
8704 done
8705
8706 fi
8707 fi
8708 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8709 if test -n "$GCJ_FOR_TARGET"; then
8710   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8711 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8712 else
8713   echo "$as_me:$LINENO: result: no" >&5
8714 echo "${ECHO_T}no" >&6
8715 fi
8716
8717     fi
8718     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8719   done
8720 fi
8721
8722 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8723   set dummy gcj
8724   if test $build = $target ; then
8725     GCJ_FOR_TARGET="$2"
8726   else
8727     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8728   fi
8729 else
8730   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8731 fi
8732
8733
8734
8735 if test -n "$GFORTRAN_FOR_TARGET"; then
8736   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8737 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8738   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8739 fi
8740
8741 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8742   for ncn_progname in gfortran; do
8743     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8744 set dummy ${ncn_progname}; ac_word=$2
8745 echo "$as_me:$LINENO: checking for $ac_word" >&5
8746 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8747 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8748   echo $ECHO_N "(cached) $ECHO_C" >&6
8749 else
8750   if test -n "$GFORTRAN_FOR_TARGET"; then
8751   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8752 else
8753 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8754 for as_dir in $PATH
8755 do
8756   IFS=$as_save_IFS
8757   test -z "$as_dir" && as_dir=.
8758   for ac_exec_ext in '' $ac_executable_extensions; do
8759   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8760     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8761     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8762     break 2
8763   fi
8764 done
8765 done
8766
8767 fi
8768 fi
8769 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8770 if test -n "$GFORTRAN_FOR_TARGET"; then
8771   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8772 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8773 else
8774   echo "$as_me:$LINENO: result: no" >&5
8775 echo "${ECHO_T}no" >&6
8776 fi
8777
8778   done
8779 fi
8780
8781 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8782   for ncn_progname in gfortran; do
8783     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8784 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8785     if test -x $with_build_time_tools/${ncn_progname}; then
8786       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8787       echo "$as_me:$LINENO: result: yes" >&5
8788 echo "${ECHO_T}yes" >&6
8789       break
8790     else
8791       echo "$as_me:$LINENO: result: no" >&5
8792 echo "${ECHO_T}no" >&6
8793     fi
8794   done
8795 fi
8796
8797 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8798   for ncn_progname in gfortran; do
8799     if test -n "$ncn_target_tool_prefix"; then
8800       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8801 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8802 echo "$as_me:$LINENO: checking for $ac_word" >&5
8803 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8804 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8805   echo $ECHO_N "(cached) $ECHO_C" >&6
8806 else
8807   if test -n "$GFORTRAN_FOR_TARGET"; then
8808   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8809 else
8810 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8811 for as_dir in $PATH
8812 do
8813   IFS=$as_save_IFS
8814   test -z "$as_dir" && as_dir=.
8815   for ac_exec_ext in '' $ac_executable_extensions; do
8816   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8817     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8818     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8819     break 2
8820   fi
8821 done
8822 done
8823
8824 fi
8825 fi
8826 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8827 if test -n "$GFORTRAN_FOR_TARGET"; then
8828   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8829 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8830 else
8831   echo "$as_me:$LINENO: result: no" >&5
8832 echo "${ECHO_T}no" >&6
8833 fi
8834
8835     fi
8836     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8837       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8838 set dummy ${ncn_progname}; ac_word=$2
8839 echo "$as_me:$LINENO: checking for $ac_word" >&5
8840 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8841 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8842   echo $ECHO_N "(cached) $ECHO_C" >&6
8843 else
8844   if test -n "$GFORTRAN_FOR_TARGET"; then
8845   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8846 else
8847 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8848 for as_dir in $PATH
8849 do
8850   IFS=$as_save_IFS
8851   test -z "$as_dir" && as_dir=.
8852   for ac_exec_ext in '' $ac_executable_extensions; do
8853   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8854     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8855     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8856     break 2
8857   fi
8858 done
8859 done
8860
8861 fi
8862 fi
8863 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8864 if test -n "$GFORTRAN_FOR_TARGET"; then
8865   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8866 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8867 else
8868   echo "$as_me:$LINENO: result: no" >&5
8869 echo "${ECHO_T}no" >&6
8870 fi
8871
8872     fi
8873     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8874   done
8875 fi
8876
8877 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8878   set dummy gfortran
8879   if test $build = $target ; then
8880     GFORTRAN_FOR_TARGET="$2"
8881   else
8882     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8883   fi
8884 else
8885   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8886 fi
8887
8888
8889
8890 cat > conftest.c << \EOF
8891 #ifdef __GNUC__
8892   gcc_yay;
8893 #endif
8894 EOF
8895 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8896   have_gcc_for_target=yes
8897 else
8898   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8899   have_gcc_for_target=no
8900 fi
8901 rm conftest.c
8902
8903
8904
8905
8906 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8907   if test -n "$with_build_time_tools"; then
8908     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8909 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8910     if test -x $with_build_time_tools/ar; then
8911       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8912       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8913       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8914 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8915     else
8916       echo "$as_me:$LINENO: result: no" >&5
8917 echo "${ECHO_T}no" >&6
8918     fi
8919   elif test $build != $host && test $have_gcc_for_target = yes; then
8920     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8921     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8922     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8923   fi
8924 fi
8925 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8926   # Extract the first word of "ar", so it can be a program name with args.
8927 set dummy ar; ac_word=$2
8928 echo "$as_me:$LINENO: checking for $ac_word" >&5
8929 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8930 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8931   echo $ECHO_N "(cached) $ECHO_C" >&6
8932 else
8933   case $AR_FOR_TARGET in
8934   [\\/]* | ?:[\\/]*)
8935   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8936   ;;
8937   *)
8938   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8939 for as_dir in $gcc_cv_tool_dirs
8940 do
8941   IFS=$as_save_IFS
8942   test -z "$as_dir" && as_dir=.
8943   for ac_exec_ext in '' $ac_executable_extensions; do
8944   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8945     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8946     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8947     break 2
8948   fi
8949 done
8950 done
8951
8952   ;;
8953 esac
8954 fi
8955 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8956
8957 if test -n "$AR_FOR_TARGET"; then
8958   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8959 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8960 else
8961   echo "$as_me:$LINENO: result: no" >&5
8962 echo "${ECHO_T}no" >&6
8963 fi
8964
8965 fi
8966 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8967
8968
8969 if test -n "$AR_FOR_TARGET"; then
8970   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8971 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8972   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8973 fi
8974
8975 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8976   for ncn_progname in ar; do
8977     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8978 set dummy ${ncn_progname}; ac_word=$2
8979 echo "$as_me:$LINENO: checking for $ac_word" >&5
8980 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8981 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8982   echo $ECHO_N "(cached) $ECHO_C" >&6
8983 else
8984   if test -n "$AR_FOR_TARGET"; then
8985   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8986 else
8987 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8988 for as_dir in $PATH
8989 do
8990   IFS=$as_save_IFS
8991   test -z "$as_dir" && as_dir=.
8992   for ac_exec_ext in '' $ac_executable_extensions; do
8993   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8994     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8995     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8996     break 2
8997   fi
8998 done
8999 done
9000
9001 fi
9002 fi
9003 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9004 if test -n "$AR_FOR_TARGET"; then
9005   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9006 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9007 else
9008   echo "$as_me:$LINENO: result: no" >&5
9009 echo "${ECHO_T}no" >&6
9010 fi
9011
9012   done
9013 fi
9014
9015 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9016   for ncn_progname in ar; do
9017     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9018 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9019     if test -x $with_build_time_tools/${ncn_progname}; then
9020       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9021       echo "$as_me:$LINENO: result: yes" >&5
9022 echo "${ECHO_T}yes" >&6
9023       break
9024     else
9025       echo "$as_me:$LINENO: result: no" >&5
9026 echo "${ECHO_T}no" >&6
9027     fi
9028   done
9029 fi
9030
9031 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9032   for ncn_progname in ar; do
9033     if test -n "$ncn_target_tool_prefix"; then
9034       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9035 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9036 echo "$as_me:$LINENO: checking for $ac_word" >&5
9037 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9038 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9039   echo $ECHO_N "(cached) $ECHO_C" >&6
9040 else
9041   if test -n "$AR_FOR_TARGET"; then
9042   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9043 else
9044 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9045 for as_dir in $PATH
9046 do
9047   IFS=$as_save_IFS
9048   test -z "$as_dir" && as_dir=.
9049   for ac_exec_ext in '' $ac_executable_extensions; do
9050   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9051     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9052     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9053     break 2
9054   fi
9055 done
9056 done
9057
9058 fi
9059 fi
9060 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9061 if test -n "$AR_FOR_TARGET"; then
9062   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9063 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9064 else
9065   echo "$as_me:$LINENO: result: no" >&5
9066 echo "${ECHO_T}no" >&6
9067 fi
9068
9069     fi
9070     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9071       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9072 set dummy ${ncn_progname}; ac_word=$2
9073 echo "$as_me:$LINENO: checking for $ac_word" >&5
9074 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9075 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9076   echo $ECHO_N "(cached) $ECHO_C" >&6
9077 else
9078   if test -n "$AR_FOR_TARGET"; then
9079   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9080 else
9081 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9082 for as_dir in $PATH
9083 do
9084   IFS=$as_save_IFS
9085   test -z "$as_dir" && as_dir=.
9086   for ac_exec_ext in '' $ac_executable_extensions; do
9087   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9088     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9089     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9090     break 2
9091   fi
9092 done
9093 done
9094
9095 fi
9096 fi
9097 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9098 if test -n "$AR_FOR_TARGET"; then
9099   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9100 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9101 else
9102   echo "$as_me:$LINENO: result: no" >&5
9103 echo "${ECHO_T}no" >&6
9104 fi
9105
9106     fi
9107     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9108   done
9109 fi
9110
9111 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9112   set dummy ar
9113   if test $build = $target ; then
9114     AR_FOR_TARGET="$2"
9115   else
9116     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9117   fi
9118 else
9119   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9120 fi
9121
9122 else
9123   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9124 fi
9125
9126
9127
9128
9129 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9130   if test -n "$with_build_time_tools"; then
9131     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9132 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9133     if test -x $with_build_time_tools/as; then
9134       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9135       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9136       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9137 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9138     else
9139       echo "$as_me:$LINENO: result: no" >&5
9140 echo "${ECHO_T}no" >&6
9141     fi
9142   elif test $build != $host && test $have_gcc_for_target = yes; then
9143     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9144     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9145     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9146   fi
9147 fi
9148 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9149   # Extract the first word of "as", so it can be a program name with args.
9150 set dummy as; ac_word=$2
9151 echo "$as_me:$LINENO: checking for $ac_word" >&5
9152 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9153 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9154   echo $ECHO_N "(cached) $ECHO_C" >&6
9155 else
9156   case $AS_FOR_TARGET in
9157   [\\/]* | ?:[\\/]*)
9158   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9159   ;;
9160   *)
9161   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9162 for as_dir in $gcc_cv_tool_dirs
9163 do
9164   IFS=$as_save_IFS
9165   test -z "$as_dir" && as_dir=.
9166   for ac_exec_ext in '' $ac_executable_extensions; do
9167   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9168     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9169     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9170     break 2
9171   fi
9172 done
9173 done
9174
9175   ;;
9176 esac
9177 fi
9178 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9179
9180 if test -n "$AS_FOR_TARGET"; then
9181   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9182 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9183 else
9184   echo "$as_me:$LINENO: result: no" >&5
9185 echo "${ECHO_T}no" >&6
9186 fi
9187
9188 fi
9189 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9190
9191
9192 if test -n "$AS_FOR_TARGET"; then
9193   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9194 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9195   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9196 fi
9197
9198 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9199   for ncn_progname in as; do
9200     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9201 set dummy ${ncn_progname}; ac_word=$2
9202 echo "$as_me:$LINENO: checking for $ac_word" >&5
9203 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9204 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9205   echo $ECHO_N "(cached) $ECHO_C" >&6
9206 else
9207   if test -n "$AS_FOR_TARGET"; then
9208   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9209 else
9210 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9211 for as_dir in $PATH
9212 do
9213   IFS=$as_save_IFS
9214   test -z "$as_dir" && as_dir=.
9215   for ac_exec_ext in '' $ac_executable_extensions; do
9216   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9217     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9218     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9219     break 2
9220   fi
9221 done
9222 done
9223
9224 fi
9225 fi
9226 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9227 if test -n "$AS_FOR_TARGET"; then
9228   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9229 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9230 else
9231   echo "$as_me:$LINENO: result: no" >&5
9232 echo "${ECHO_T}no" >&6
9233 fi
9234
9235   done
9236 fi
9237
9238 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9239   for ncn_progname in as; do
9240     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9241 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9242     if test -x $with_build_time_tools/${ncn_progname}; then
9243       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9244       echo "$as_me:$LINENO: result: yes" >&5
9245 echo "${ECHO_T}yes" >&6
9246       break
9247     else
9248       echo "$as_me:$LINENO: result: no" >&5
9249 echo "${ECHO_T}no" >&6
9250     fi
9251   done
9252 fi
9253
9254 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9255   for ncn_progname in as; do
9256     if test -n "$ncn_target_tool_prefix"; then
9257       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9258 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9259 echo "$as_me:$LINENO: checking for $ac_word" >&5
9260 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9261 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9262   echo $ECHO_N "(cached) $ECHO_C" >&6
9263 else
9264   if test -n "$AS_FOR_TARGET"; then
9265   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9266 else
9267 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9268 for as_dir in $PATH
9269 do
9270   IFS=$as_save_IFS
9271   test -z "$as_dir" && as_dir=.
9272   for ac_exec_ext in '' $ac_executable_extensions; do
9273   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9274     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9275     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9276     break 2
9277   fi
9278 done
9279 done
9280
9281 fi
9282 fi
9283 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9284 if test -n "$AS_FOR_TARGET"; then
9285   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9286 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9287 else
9288   echo "$as_me:$LINENO: result: no" >&5
9289 echo "${ECHO_T}no" >&6
9290 fi
9291
9292     fi
9293     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9294       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9295 set dummy ${ncn_progname}; ac_word=$2
9296 echo "$as_me:$LINENO: checking for $ac_word" >&5
9297 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9298 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9299   echo $ECHO_N "(cached) $ECHO_C" >&6
9300 else
9301   if test -n "$AS_FOR_TARGET"; then
9302   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9303 else
9304 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9305 for as_dir in $PATH
9306 do
9307   IFS=$as_save_IFS
9308   test -z "$as_dir" && as_dir=.
9309   for ac_exec_ext in '' $ac_executable_extensions; do
9310   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9311     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9312     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9313     break 2
9314   fi
9315 done
9316 done
9317
9318 fi
9319 fi
9320 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9321 if test -n "$AS_FOR_TARGET"; then
9322   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9323 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9324 else
9325   echo "$as_me:$LINENO: result: no" >&5
9326 echo "${ECHO_T}no" >&6
9327 fi
9328
9329     fi
9330     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9331   done
9332 fi
9333
9334 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9335   set dummy as
9336   if test $build = $target ; then
9337     AS_FOR_TARGET="$2"
9338   else
9339     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9340   fi
9341 else
9342   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9343 fi
9344
9345 else
9346   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9347 fi
9348
9349
9350
9351
9352 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9353   if test -n "$with_build_time_tools"; then
9354     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9355 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9356     if test -x $with_build_time_tools/dlltool; then
9357       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9358       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9359       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9360 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9361     else
9362       echo "$as_me:$LINENO: result: no" >&5
9363 echo "${ECHO_T}no" >&6
9364     fi
9365   elif test $build != $host && test $have_gcc_for_target = yes; then
9366     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9367     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9368     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9369   fi
9370 fi
9371 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9372   # Extract the first word of "dlltool", so it can be a program name with args.
9373 set dummy dlltool; ac_word=$2
9374 echo "$as_me:$LINENO: checking for $ac_word" >&5
9375 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9376 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9377   echo $ECHO_N "(cached) $ECHO_C" >&6
9378 else
9379   case $DLLTOOL_FOR_TARGET in
9380   [\\/]* | ?:[\\/]*)
9381   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9382   ;;
9383   *)
9384   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9385 for as_dir in $gcc_cv_tool_dirs
9386 do
9387   IFS=$as_save_IFS
9388   test -z "$as_dir" && as_dir=.
9389   for ac_exec_ext in '' $ac_executable_extensions; do
9390   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9391     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9392     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9393     break 2
9394   fi
9395 done
9396 done
9397
9398   ;;
9399 esac
9400 fi
9401 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9402
9403 if test -n "$DLLTOOL_FOR_TARGET"; then
9404   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9405 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9406 else
9407   echo "$as_me:$LINENO: result: no" >&5
9408 echo "${ECHO_T}no" >&6
9409 fi
9410
9411 fi
9412 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9413
9414
9415 if test -n "$DLLTOOL_FOR_TARGET"; then
9416   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9417 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9418   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9419 fi
9420
9421 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9422   for ncn_progname in dlltool; do
9423     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9424 set dummy ${ncn_progname}; ac_word=$2
9425 echo "$as_me:$LINENO: checking for $ac_word" >&5
9426 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9427 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9428   echo $ECHO_N "(cached) $ECHO_C" >&6
9429 else
9430   if test -n "$DLLTOOL_FOR_TARGET"; then
9431   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9432 else
9433 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9434 for as_dir in $PATH
9435 do
9436   IFS=$as_save_IFS
9437   test -z "$as_dir" && as_dir=.
9438   for ac_exec_ext in '' $ac_executable_extensions; do
9439   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9440     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9441     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9442     break 2
9443   fi
9444 done
9445 done
9446
9447 fi
9448 fi
9449 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9450 if test -n "$DLLTOOL_FOR_TARGET"; then
9451   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9452 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9453 else
9454   echo "$as_me:$LINENO: result: no" >&5
9455 echo "${ECHO_T}no" >&6
9456 fi
9457
9458   done
9459 fi
9460
9461 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9462   for ncn_progname in dlltool; do
9463     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9464 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9465     if test -x $with_build_time_tools/${ncn_progname}; then
9466       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9467       echo "$as_me:$LINENO: result: yes" >&5
9468 echo "${ECHO_T}yes" >&6
9469       break
9470     else
9471       echo "$as_me:$LINENO: result: no" >&5
9472 echo "${ECHO_T}no" >&6
9473     fi
9474   done
9475 fi
9476
9477 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9478   for ncn_progname in dlltool; do
9479     if test -n "$ncn_target_tool_prefix"; then
9480       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9481 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9482 echo "$as_me:$LINENO: checking for $ac_word" >&5
9483 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9484 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9485   echo $ECHO_N "(cached) $ECHO_C" >&6
9486 else
9487   if test -n "$DLLTOOL_FOR_TARGET"; then
9488   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9489 else
9490 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9491 for as_dir in $PATH
9492 do
9493   IFS=$as_save_IFS
9494   test -z "$as_dir" && as_dir=.
9495   for ac_exec_ext in '' $ac_executable_extensions; do
9496   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9497     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9498     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9499     break 2
9500   fi
9501 done
9502 done
9503
9504 fi
9505 fi
9506 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9507 if test -n "$DLLTOOL_FOR_TARGET"; then
9508   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9509 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9510 else
9511   echo "$as_me:$LINENO: result: no" >&5
9512 echo "${ECHO_T}no" >&6
9513 fi
9514
9515     fi
9516     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9517       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9518 set dummy ${ncn_progname}; ac_word=$2
9519 echo "$as_me:$LINENO: checking for $ac_word" >&5
9520 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9521 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9522   echo $ECHO_N "(cached) $ECHO_C" >&6
9523 else
9524   if test -n "$DLLTOOL_FOR_TARGET"; then
9525   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9526 else
9527 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9528 for as_dir in $PATH
9529 do
9530   IFS=$as_save_IFS
9531   test -z "$as_dir" && as_dir=.
9532   for ac_exec_ext in '' $ac_executable_extensions; do
9533   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9534     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9535     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9536     break 2
9537   fi
9538 done
9539 done
9540
9541 fi
9542 fi
9543 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9544 if test -n "$DLLTOOL_FOR_TARGET"; then
9545   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9546 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9547 else
9548   echo "$as_me:$LINENO: result: no" >&5
9549 echo "${ECHO_T}no" >&6
9550 fi
9551
9552     fi
9553     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9554   done
9555 fi
9556
9557 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9558   set dummy dlltool
9559   if test $build = $target ; then
9560     DLLTOOL_FOR_TARGET="$2"
9561   else
9562     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9563   fi
9564 else
9565   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9566 fi
9567
9568 else
9569   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9570 fi
9571
9572
9573
9574
9575 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9576   if test -n "$with_build_time_tools"; then
9577     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9578 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9579     if test -x $with_build_time_tools/ld; then
9580       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9581       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9582       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9583 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9584     else
9585       echo "$as_me:$LINENO: result: no" >&5
9586 echo "${ECHO_T}no" >&6
9587     fi
9588   elif test $build != $host && test $have_gcc_for_target = yes; then
9589     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9590     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9591     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9592   fi
9593 fi
9594 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9595   # Extract the first word of "ld", so it can be a program name with args.
9596 set dummy ld; ac_word=$2
9597 echo "$as_me:$LINENO: checking for $ac_word" >&5
9598 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9599 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9600   echo $ECHO_N "(cached) $ECHO_C" >&6
9601 else
9602   case $LD_FOR_TARGET in
9603   [\\/]* | ?:[\\/]*)
9604   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9605   ;;
9606   *)
9607   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9608 for as_dir in $gcc_cv_tool_dirs
9609 do
9610   IFS=$as_save_IFS
9611   test -z "$as_dir" && as_dir=.
9612   for ac_exec_ext in '' $ac_executable_extensions; do
9613   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9614     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9615     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9616     break 2
9617   fi
9618 done
9619 done
9620
9621   ;;
9622 esac
9623 fi
9624 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9625
9626 if test -n "$LD_FOR_TARGET"; then
9627   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9628 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9629 else
9630   echo "$as_me:$LINENO: result: no" >&5
9631 echo "${ECHO_T}no" >&6
9632 fi
9633
9634 fi
9635 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9636
9637
9638 if test -n "$LD_FOR_TARGET"; then
9639   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9640 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9641   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9642 fi
9643
9644 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9645   for ncn_progname in ld; do
9646     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9647 set dummy ${ncn_progname}; ac_word=$2
9648 echo "$as_me:$LINENO: checking for $ac_word" >&5
9649 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9650 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9651   echo $ECHO_N "(cached) $ECHO_C" >&6
9652 else
9653   if test -n "$LD_FOR_TARGET"; then
9654   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9655 else
9656 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9657 for as_dir in $PATH
9658 do
9659   IFS=$as_save_IFS
9660   test -z "$as_dir" && as_dir=.
9661   for ac_exec_ext in '' $ac_executable_extensions; do
9662   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9663     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9664     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9665     break 2
9666   fi
9667 done
9668 done
9669
9670 fi
9671 fi
9672 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9673 if test -n "$LD_FOR_TARGET"; then
9674   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9675 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9676 else
9677   echo "$as_me:$LINENO: result: no" >&5
9678 echo "${ECHO_T}no" >&6
9679 fi
9680
9681   done
9682 fi
9683
9684 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9685   for ncn_progname in ld; do
9686     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9687 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9688     if test -x $with_build_time_tools/${ncn_progname}; then
9689       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9690       echo "$as_me:$LINENO: result: yes" >&5
9691 echo "${ECHO_T}yes" >&6
9692       break
9693     else
9694       echo "$as_me:$LINENO: result: no" >&5
9695 echo "${ECHO_T}no" >&6
9696     fi
9697   done
9698 fi
9699
9700 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9701   for ncn_progname in ld; do
9702     if test -n "$ncn_target_tool_prefix"; then
9703       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9704 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9705 echo "$as_me:$LINENO: checking for $ac_word" >&5
9706 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9707 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9708   echo $ECHO_N "(cached) $ECHO_C" >&6
9709 else
9710   if test -n "$LD_FOR_TARGET"; then
9711   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9712 else
9713 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9714 for as_dir in $PATH
9715 do
9716   IFS=$as_save_IFS
9717   test -z "$as_dir" && as_dir=.
9718   for ac_exec_ext in '' $ac_executable_extensions; do
9719   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9720     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9721     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9722     break 2
9723   fi
9724 done
9725 done
9726
9727 fi
9728 fi
9729 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9730 if test -n "$LD_FOR_TARGET"; then
9731   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9732 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9733 else
9734   echo "$as_me:$LINENO: result: no" >&5
9735 echo "${ECHO_T}no" >&6
9736 fi
9737
9738     fi
9739     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9740       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9741 set dummy ${ncn_progname}; ac_word=$2
9742 echo "$as_me:$LINENO: checking for $ac_word" >&5
9743 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9744 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9745   echo $ECHO_N "(cached) $ECHO_C" >&6
9746 else
9747   if test -n "$LD_FOR_TARGET"; then
9748   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9749 else
9750 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9751 for as_dir in $PATH
9752 do
9753   IFS=$as_save_IFS
9754   test -z "$as_dir" && as_dir=.
9755   for ac_exec_ext in '' $ac_executable_extensions; do
9756   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9757     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9758     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9759     break 2
9760   fi
9761 done
9762 done
9763
9764 fi
9765 fi
9766 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9767 if test -n "$LD_FOR_TARGET"; then
9768   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9769 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9770 else
9771   echo "$as_me:$LINENO: result: no" >&5
9772 echo "${ECHO_T}no" >&6
9773 fi
9774
9775     fi
9776     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9777   done
9778 fi
9779
9780 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9781   set dummy ld
9782   if test $build = $target ; then
9783     LD_FOR_TARGET="$2"
9784   else
9785     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9786   fi
9787 else
9788   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9789 fi
9790
9791 else
9792   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9793 fi
9794
9795
9796
9797
9798 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9799   if test -n "$with_build_time_tools"; then
9800     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9801 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9802     if test -x $with_build_time_tools/lipo; then
9803       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9804       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9805       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9806 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9807     else
9808       echo "$as_me:$LINENO: result: no" >&5
9809 echo "${ECHO_T}no" >&6
9810     fi
9811   elif test $build != $host && test $have_gcc_for_target = yes; then
9812     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9813     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9814     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9815   fi
9816 fi
9817 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9818   # Extract the first word of "lipo", so it can be a program name with args.
9819 set dummy lipo; ac_word=$2
9820 echo "$as_me:$LINENO: checking for $ac_word" >&5
9821 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9822 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9823   echo $ECHO_N "(cached) $ECHO_C" >&6
9824 else
9825   case $LIPO_FOR_TARGET in
9826   [\\/]* | ?:[\\/]*)
9827   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9828   ;;
9829   *)
9830   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9831 for as_dir in $gcc_cv_tool_dirs
9832 do
9833   IFS=$as_save_IFS
9834   test -z "$as_dir" && as_dir=.
9835   for ac_exec_ext in '' $ac_executable_extensions; do
9836   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9837     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9838     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9839     break 2
9840   fi
9841 done
9842 done
9843
9844   ;;
9845 esac
9846 fi
9847 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9848
9849 if test -n "$LIPO_FOR_TARGET"; then
9850   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9851 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9852 else
9853   echo "$as_me:$LINENO: result: no" >&5
9854 echo "${ECHO_T}no" >&6
9855 fi
9856
9857 fi
9858 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9859
9860
9861 if test -n "$LIPO_FOR_TARGET"; then
9862   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9863 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9864   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9865 fi
9866
9867 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9868   for ncn_progname in lipo; do
9869     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9870 set dummy ${ncn_progname}; ac_word=$2
9871 echo "$as_me:$LINENO: checking for $ac_word" >&5
9872 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9873 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9874   echo $ECHO_N "(cached) $ECHO_C" >&6
9875 else
9876   if test -n "$LIPO_FOR_TARGET"; then
9877   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9878 else
9879 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9880 for as_dir in $PATH
9881 do
9882   IFS=$as_save_IFS
9883   test -z "$as_dir" && as_dir=.
9884   for ac_exec_ext in '' $ac_executable_extensions; do
9885   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9886     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9887     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9888     break 2
9889   fi
9890 done
9891 done
9892
9893 fi
9894 fi
9895 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9896 if test -n "$LIPO_FOR_TARGET"; then
9897   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9898 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9899 else
9900   echo "$as_me:$LINENO: result: no" >&5
9901 echo "${ECHO_T}no" >&6
9902 fi
9903
9904   done
9905 fi
9906
9907 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9908   for ncn_progname in lipo; do
9909     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9910 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9911     if test -x $with_build_time_tools/${ncn_progname}; then
9912       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9913       echo "$as_me:$LINENO: result: yes" >&5
9914 echo "${ECHO_T}yes" >&6
9915       break
9916     else
9917       echo "$as_me:$LINENO: result: no" >&5
9918 echo "${ECHO_T}no" >&6
9919     fi
9920   done
9921 fi
9922
9923 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9924   for ncn_progname in lipo; do
9925     if test -n "$ncn_target_tool_prefix"; then
9926       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9927 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9928 echo "$as_me:$LINENO: checking for $ac_word" >&5
9929 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9930 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9931   echo $ECHO_N "(cached) $ECHO_C" >&6
9932 else
9933   if test -n "$LIPO_FOR_TARGET"; then
9934   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9935 else
9936 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9937 for as_dir in $PATH
9938 do
9939   IFS=$as_save_IFS
9940   test -z "$as_dir" && as_dir=.
9941   for ac_exec_ext in '' $ac_executable_extensions; do
9942   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9943     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9944     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9945     break 2
9946   fi
9947 done
9948 done
9949
9950 fi
9951 fi
9952 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9953 if test -n "$LIPO_FOR_TARGET"; then
9954   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9955 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9956 else
9957   echo "$as_me:$LINENO: result: no" >&5
9958 echo "${ECHO_T}no" >&6
9959 fi
9960
9961     fi
9962     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9963       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9964 set dummy ${ncn_progname}; ac_word=$2
9965 echo "$as_me:$LINENO: checking for $ac_word" >&5
9966 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9967 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9968   echo $ECHO_N "(cached) $ECHO_C" >&6
9969 else
9970   if test -n "$LIPO_FOR_TARGET"; then
9971   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9972 else
9973 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9974 for as_dir in $PATH
9975 do
9976   IFS=$as_save_IFS
9977   test -z "$as_dir" && as_dir=.
9978   for ac_exec_ext in '' $ac_executable_extensions; do
9979   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9980     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9981     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9982     break 2
9983   fi
9984 done
9985 done
9986
9987 fi
9988 fi
9989 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9990 if test -n "$LIPO_FOR_TARGET"; then
9991   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9992 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9993 else
9994   echo "$as_me:$LINENO: result: no" >&5
9995 echo "${ECHO_T}no" >&6
9996 fi
9997
9998     fi
9999     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10000   done
10001 fi
10002
10003 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10004   set dummy lipo
10005   if test $build = $target ; then
10006     LIPO_FOR_TARGET="$2"
10007   else
10008     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10009   fi
10010 else
10011   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10012 fi
10013
10014 else
10015   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10016 fi
10017
10018
10019
10020
10021 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10022   if test -n "$with_build_time_tools"; then
10023     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10024 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10025     if test -x $with_build_time_tools/nm; then
10026       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10027       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10028       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10029 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10030     else
10031       echo "$as_me:$LINENO: result: no" >&5
10032 echo "${ECHO_T}no" >&6
10033     fi
10034   elif test $build != $host && test $have_gcc_for_target = yes; then
10035     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10036     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10037     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10038   fi
10039 fi
10040 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10041   # Extract the first word of "nm", so it can be a program name with args.
10042 set dummy nm; ac_word=$2
10043 echo "$as_me:$LINENO: checking for $ac_word" >&5
10044 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10045 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10046   echo $ECHO_N "(cached) $ECHO_C" >&6
10047 else
10048   case $NM_FOR_TARGET in
10049   [\\/]* | ?:[\\/]*)
10050   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10051   ;;
10052   *)
10053   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10054 for as_dir in $gcc_cv_tool_dirs
10055 do
10056   IFS=$as_save_IFS
10057   test -z "$as_dir" && as_dir=.
10058   for ac_exec_ext in '' $ac_executable_extensions; do
10059   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10060     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10061     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10062     break 2
10063   fi
10064 done
10065 done
10066
10067   ;;
10068 esac
10069 fi
10070 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10071
10072 if test -n "$NM_FOR_TARGET"; then
10073   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10074 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10075 else
10076   echo "$as_me:$LINENO: result: no" >&5
10077 echo "${ECHO_T}no" >&6
10078 fi
10079
10080 fi
10081 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10082
10083
10084 if test -n "$NM_FOR_TARGET"; then
10085   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10086 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10087   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10088 fi
10089
10090 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10091   for ncn_progname in nm; do
10092     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10093 set dummy ${ncn_progname}; ac_word=$2
10094 echo "$as_me:$LINENO: checking for $ac_word" >&5
10095 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10096 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10097   echo $ECHO_N "(cached) $ECHO_C" >&6
10098 else
10099   if test -n "$NM_FOR_TARGET"; then
10100   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10101 else
10102 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10103 for as_dir in $PATH
10104 do
10105   IFS=$as_save_IFS
10106   test -z "$as_dir" && as_dir=.
10107   for ac_exec_ext in '' $ac_executable_extensions; do
10108   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10109     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10110     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10111     break 2
10112   fi
10113 done
10114 done
10115
10116 fi
10117 fi
10118 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10119 if test -n "$NM_FOR_TARGET"; then
10120   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10121 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10122 else
10123   echo "$as_me:$LINENO: result: no" >&5
10124 echo "${ECHO_T}no" >&6
10125 fi
10126
10127   done
10128 fi
10129
10130 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10131   for ncn_progname in nm; do
10132     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10133 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10134     if test -x $with_build_time_tools/${ncn_progname}; then
10135       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10136       echo "$as_me:$LINENO: result: yes" >&5
10137 echo "${ECHO_T}yes" >&6
10138       break
10139     else
10140       echo "$as_me:$LINENO: result: no" >&5
10141 echo "${ECHO_T}no" >&6
10142     fi
10143   done
10144 fi
10145
10146 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10147   for ncn_progname in nm; do
10148     if test -n "$ncn_target_tool_prefix"; then
10149       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10150 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10151 echo "$as_me:$LINENO: checking for $ac_word" >&5
10152 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10153 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10154   echo $ECHO_N "(cached) $ECHO_C" >&6
10155 else
10156   if test -n "$NM_FOR_TARGET"; then
10157   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10158 else
10159 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10160 for as_dir in $PATH
10161 do
10162   IFS=$as_save_IFS
10163   test -z "$as_dir" && as_dir=.
10164   for ac_exec_ext in '' $ac_executable_extensions; do
10165   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10166     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10167     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10168     break 2
10169   fi
10170 done
10171 done
10172
10173 fi
10174 fi
10175 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10176 if test -n "$NM_FOR_TARGET"; then
10177   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10178 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10179 else
10180   echo "$as_me:$LINENO: result: no" >&5
10181 echo "${ECHO_T}no" >&6
10182 fi
10183
10184     fi
10185     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10186       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10187 set dummy ${ncn_progname}; ac_word=$2
10188 echo "$as_me:$LINENO: checking for $ac_word" >&5
10189 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10190 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10191   echo $ECHO_N "(cached) $ECHO_C" >&6
10192 else
10193   if test -n "$NM_FOR_TARGET"; then
10194   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10195 else
10196 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10197 for as_dir in $PATH
10198 do
10199   IFS=$as_save_IFS
10200   test -z "$as_dir" && as_dir=.
10201   for ac_exec_ext in '' $ac_executable_extensions; do
10202   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10203     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10204     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10205     break 2
10206   fi
10207 done
10208 done
10209
10210 fi
10211 fi
10212 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10213 if test -n "$NM_FOR_TARGET"; then
10214   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10215 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10216 else
10217   echo "$as_me:$LINENO: result: no" >&5
10218 echo "${ECHO_T}no" >&6
10219 fi
10220
10221     fi
10222     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10223   done
10224 fi
10225
10226 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10227   set dummy nm
10228   if test $build = $target ; then
10229     NM_FOR_TARGET="$2"
10230   else
10231     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10232   fi
10233 else
10234   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10235 fi
10236
10237 else
10238   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10239 fi
10240
10241
10242
10243
10244 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10245   if test -n "$with_build_time_tools"; then
10246     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10247 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10248     if test -x $with_build_time_tools/objdump; then
10249       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10250       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10251       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10252 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10253     else
10254       echo "$as_me:$LINENO: result: no" >&5
10255 echo "${ECHO_T}no" >&6
10256     fi
10257   elif test $build != $host && test $have_gcc_for_target = yes; then
10258     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10259     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10260     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10261   fi
10262 fi
10263 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10264   # Extract the first word of "objdump", so it can be a program name with args.
10265 set dummy objdump; ac_word=$2
10266 echo "$as_me:$LINENO: checking for $ac_word" >&5
10267 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10268 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10269   echo $ECHO_N "(cached) $ECHO_C" >&6
10270 else
10271   case $OBJDUMP_FOR_TARGET in
10272   [\\/]* | ?:[\\/]*)
10273   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10274   ;;
10275   *)
10276   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10277 for as_dir in $gcc_cv_tool_dirs
10278 do
10279   IFS=$as_save_IFS
10280   test -z "$as_dir" && as_dir=.
10281   for ac_exec_ext in '' $ac_executable_extensions; do
10282   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10283     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10284     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10285     break 2
10286   fi
10287 done
10288 done
10289
10290   ;;
10291 esac
10292 fi
10293 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10294
10295 if test -n "$OBJDUMP_FOR_TARGET"; then
10296   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10297 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10298 else
10299   echo "$as_me:$LINENO: result: no" >&5
10300 echo "${ECHO_T}no" >&6
10301 fi
10302
10303 fi
10304 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10305
10306
10307 if test -n "$OBJDUMP_FOR_TARGET"; then
10308   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10309 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10310   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10311 fi
10312
10313 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10314   for ncn_progname in objdump; do
10315     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10316 set dummy ${ncn_progname}; ac_word=$2
10317 echo "$as_me:$LINENO: checking for $ac_word" >&5
10318 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10319 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10320   echo $ECHO_N "(cached) $ECHO_C" >&6
10321 else
10322   if test -n "$OBJDUMP_FOR_TARGET"; then
10323   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10324 else
10325 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10326 for as_dir in $PATH
10327 do
10328   IFS=$as_save_IFS
10329   test -z "$as_dir" && as_dir=.
10330   for ac_exec_ext in '' $ac_executable_extensions; do
10331   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10332     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10333     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10334     break 2
10335   fi
10336 done
10337 done
10338
10339 fi
10340 fi
10341 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10342 if test -n "$OBJDUMP_FOR_TARGET"; then
10343   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10344 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10345 else
10346   echo "$as_me:$LINENO: result: no" >&5
10347 echo "${ECHO_T}no" >&6
10348 fi
10349
10350   done
10351 fi
10352
10353 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10354   for ncn_progname in objdump; do
10355     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10356 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10357     if test -x $with_build_time_tools/${ncn_progname}; then
10358       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10359       echo "$as_me:$LINENO: result: yes" >&5
10360 echo "${ECHO_T}yes" >&6
10361       break
10362     else
10363       echo "$as_me:$LINENO: result: no" >&5
10364 echo "${ECHO_T}no" >&6
10365     fi
10366   done
10367 fi
10368
10369 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10370   for ncn_progname in objdump; do
10371     if test -n "$ncn_target_tool_prefix"; then
10372       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10373 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10374 echo "$as_me:$LINENO: checking for $ac_word" >&5
10375 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10376 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10377   echo $ECHO_N "(cached) $ECHO_C" >&6
10378 else
10379   if test -n "$OBJDUMP_FOR_TARGET"; then
10380   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10381 else
10382 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10383 for as_dir in $PATH
10384 do
10385   IFS=$as_save_IFS
10386   test -z "$as_dir" && as_dir=.
10387   for ac_exec_ext in '' $ac_executable_extensions; do
10388   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10389     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10390     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10391     break 2
10392   fi
10393 done
10394 done
10395
10396 fi
10397 fi
10398 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10399 if test -n "$OBJDUMP_FOR_TARGET"; then
10400   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10401 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10402 else
10403   echo "$as_me:$LINENO: result: no" >&5
10404 echo "${ECHO_T}no" >&6
10405 fi
10406
10407     fi
10408     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10409       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10410 set dummy ${ncn_progname}; ac_word=$2
10411 echo "$as_me:$LINENO: checking for $ac_word" >&5
10412 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10413 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10414   echo $ECHO_N "(cached) $ECHO_C" >&6
10415 else
10416   if test -n "$OBJDUMP_FOR_TARGET"; then
10417   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10418 else
10419 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10420 for as_dir in $PATH
10421 do
10422   IFS=$as_save_IFS
10423   test -z "$as_dir" && as_dir=.
10424   for ac_exec_ext in '' $ac_executable_extensions; do
10425   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10426     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10427     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10428     break 2
10429   fi
10430 done
10431 done
10432
10433 fi
10434 fi
10435 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10436 if test -n "$OBJDUMP_FOR_TARGET"; then
10437   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10438 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10439 else
10440   echo "$as_me:$LINENO: result: no" >&5
10441 echo "${ECHO_T}no" >&6
10442 fi
10443
10444     fi
10445     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10446   done
10447 fi
10448
10449 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10450   set dummy objdump
10451   if test $build = $target ; then
10452     OBJDUMP_FOR_TARGET="$2"
10453   else
10454     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10455   fi
10456 else
10457   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10458 fi
10459
10460 else
10461   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10462 fi
10463
10464
10465
10466
10467 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10468   if test -n "$with_build_time_tools"; then
10469     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10470 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10471     if test -x $with_build_time_tools/ranlib; then
10472       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10473       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10474       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10475 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10476     else
10477       echo "$as_me:$LINENO: result: no" >&5
10478 echo "${ECHO_T}no" >&6
10479     fi
10480   elif test $build != $host && test $have_gcc_for_target = yes; then
10481     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10482     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10483     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10484   fi
10485 fi
10486 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10487   # Extract the first word of "ranlib", so it can be a program name with args.
10488 set dummy ranlib; ac_word=$2
10489 echo "$as_me:$LINENO: checking for $ac_word" >&5
10490 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10491 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10492   echo $ECHO_N "(cached) $ECHO_C" >&6
10493 else
10494   case $RANLIB_FOR_TARGET in
10495   [\\/]* | ?:[\\/]*)
10496   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10497   ;;
10498   *)
10499   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10500 for as_dir in $gcc_cv_tool_dirs
10501 do
10502   IFS=$as_save_IFS
10503   test -z "$as_dir" && as_dir=.
10504   for ac_exec_ext in '' $ac_executable_extensions; do
10505   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10506     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10507     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10508     break 2
10509   fi
10510 done
10511 done
10512
10513   ;;
10514 esac
10515 fi
10516 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10517
10518 if test -n "$RANLIB_FOR_TARGET"; then
10519   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10520 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10521 else
10522   echo "$as_me:$LINENO: result: no" >&5
10523 echo "${ECHO_T}no" >&6
10524 fi
10525
10526 fi
10527 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10528
10529
10530 if test -n "$RANLIB_FOR_TARGET"; then
10531   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10532 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10533   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10534 fi
10535
10536 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10537   for ncn_progname in ranlib; do
10538     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10539 set dummy ${ncn_progname}; ac_word=$2
10540 echo "$as_me:$LINENO: checking for $ac_word" >&5
10541 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10542 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10543   echo $ECHO_N "(cached) $ECHO_C" >&6
10544 else
10545   if test -n "$RANLIB_FOR_TARGET"; then
10546   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10547 else
10548 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10549 for as_dir in $PATH
10550 do
10551   IFS=$as_save_IFS
10552   test -z "$as_dir" && as_dir=.
10553   for ac_exec_ext in '' $ac_executable_extensions; do
10554   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10555     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10556     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10557     break 2
10558   fi
10559 done
10560 done
10561
10562 fi
10563 fi
10564 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10565 if test -n "$RANLIB_FOR_TARGET"; then
10566   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10567 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10568 else
10569   echo "$as_me:$LINENO: result: no" >&5
10570 echo "${ECHO_T}no" >&6
10571 fi
10572
10573   done
10574 fi
10575
10576 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10577   for ncn_progname in ranlib; do
10578     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10579 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10580     if test -x $with_build_time_tools/${ncn_progname}; then
10581       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10582       echo "$as_me:$LINENO: result: yes" >&5
10583 echo "${ECHO_T}yes" >&6
10584       break
10585     else
10586       echo "$as_me:$LINENO: result: no" >&5
10587 echo "${ECHO_T}no" >&6
10588     fi
10589   done
10590 fi
10591
10592 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10593   for ncn_progname in ranlib; do
10594     if test -n "$ncn_target_tool_prefix"; then
10595       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10596 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10597 echo "$as_me:$LINENO: checking for $ac_word" >&5
10598 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10599 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10600   echo $ECHO_N "(cached) $ECHO_C" >&6
10601 else
10602   if test -n "$RANLIB_FOR_TARGET"; then
10603   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10604 else
10605 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10606 for as_dir in $PATH
10607 do
10608   IFS=$as_save_IFS
10609   test -z "$as_dir" && as_dir=.
10610   for ac_exec_ext in '' $ac_executable_extensions; do
10611   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10612     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10613     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10614     break 2
10615   fi
10616 done
10617 done
10618
10619 fi
10620 fi
10621 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10622 if test -n "$RANLIB_FOR_TARGET"; then
10623   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10624 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10625 else
10626   echo "$as_me:$LINENO: result: no" >&5
10627 echo "${ECHO_T}no" >&6
10628 fi
10629
10630     fi
10631     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10632       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10633 set dummy ${ncn_progname}; ac_word=$2
10634 echo "$as_me:$LINENO: checking for $ac_word" >&5
10635 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10636 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10637   echo $ECHO_N "(cached) $ECHO_C" >&6
10638 else
10639   if test -n "$RANLIB_FOR_TARGET"; then
10640   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10641 else
10642 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10643 for as_dir in $PATH
10644 do
10645   IFS=$as_save_IFS
10646   test -z "$as_dir" && as_dir=.
10647   for ac_exec_ext in '' $ac_executable_extensions; do
10648   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10649     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10650     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10651     break 2
10652   fi
10653 done
10654 done
10655
10656 fi
10657 fi
10658 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10659 if test -n "$RANLIB_FOR_TARGET"; then
10660   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10661 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10662 else
10663   echo "$as_me:$LINENO: result: no" >&5
10664 echo "${ECHO_T}no" >&6
10665 fi
10666
10667     fi
10668     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10669   done
10670 fi
10671
10672 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10673   set dummy ranlib
10674   if test $build = $target ; then
10675     RANLIB_FOR_TARGET="$2"
10676   else
10677     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10678   fi
10679 else
10680   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10681 fi
10682
10683 else
10684   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10685 fi
10686
10687
10688
10689
10690 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10691   if test -n "$with_build_time_tools"; then
10692     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10693 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10694     if test -x $with_build_time_tools/strip; then
10695       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10696       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10697       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10698 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10699     else
10700       echo "$as_me:$LINENO: result: no" >&5
10701 echo "${ECHO_T}no" >&6
10702     fi
10703   elif test $build != $host && test $have_gcc_for_target = yes; then
10704     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10705     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10706     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10707   fi
10708 fi
10709 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10710   # Extract the first word of "strip", so it can be a program name with args.
10711 set dummy strip; ac_word=$2
10712 echo "$as_me:$LINENO: checking for $ac_word" >&5
10713 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10714 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10715   echo $ECHO_N "(cached) $ECHO_C" >&6
10716 else
10717   case $STRIP_FOR_TARGET in
10718   [\\/]* | ?:[\\/]*)
10719   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10720   ;;
10721   *)
10722   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10723 for as_dir in $gcc_cv_tool_dirs
10724 do
10725   IFS=$as_save_IFS
10726   test -z "$as_dir" && as_dir=.
10727   for ac_exec_ext in '' $ac_executable_extensions; do
10728   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10729     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10730     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10731     break 2
10732   fi
10733 done
10734 done
10735
10736   ;;
10737 esac
10738 fi
10739 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10740
10741 if test -n "$STRIP_FOR_TARGET"; then
10742   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10743 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10744 else
10745   echo "$as_me:$LINENO: result: no" >&5
10746 echo "${ECHO_T}no" >&6
10747 fi
10748
10749 fi
10750 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10751
10752
10753 if test -n "$STRIP_FOR_TARGET"; then
10754   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10755 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10756   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10757 fi
10758
10759 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10760   for ncn_progname in strip; do
10761     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10762 set dummy ${ncn_progname}; ac_word=$2
10763 echo "$as_me:$LINENO: checking for $ac_word" >&5
10764 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10765 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10766   echo $ECHO_N "(cached) $ECHO_C" >&6
10767 else
10768   if test -n "$STRIP_FOR_TARGET"; then
10769   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10770 else
10771 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10772 for as_dir in $PATH
10773 do
10774   IFS=$as_save_IFS
10775   test -z "$as_dir" && as_dir=.
10776   for ac_exec_ext in '' $ac_executable_extensions; do
10777   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10778     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10779     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10780     break 2
10781   fi
10782 done
10783 done
10784
10785 fi
10786 fi
10787 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10788 if test -n "$STRIP_FOR_TARGET"; then
10789   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10790 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10791 else
10792   echo "$as_me:$LINENO: result: no" >&5
10793 echo "${ECHO_T}no" >&6
10794 fi
10795
10796   done
10797 fi
10798
10799 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10800   for ncn_progname in strip; do
10801     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10802 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10803     if test -x $with_build_time_tools/${ncn_progname}; then
10804       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10805       echo "$as_me:$LINENO: result: yes" >&5
10806 echo "${ECHO_T}yes" >&6
10807       break
10808     else
10809       echo "$as_me:$LINENO: result: no" >&5
10810 echo "${ECHO_T}no" >&6
10811     fi
10812   done
10813 fi
10814
10815 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10816   for ncn_progname in strip; do
10817     if test -n "$ncn_target_tool_prefix"; then
10818       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10819 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10820 echo "$as_me:$LINENO: checking for $ac_word" >&5
10821 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10822 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10823   echo $ECHO_N "(cached) $ECHO_C" >&6
10824 else
10825   if test -n "$STRIP_FOR_TARGET"; then
10826   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10827 else
10828 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10829 for as_dir in $PATH
10830 do
10831   IFS=$as_save_IFS
10832   test -z "$as_dir" && as_dir=.
10833   for ac_exec_ext in '' $ac_executable_extensions; do
10834   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10835     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10836     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10837     break 2
10838   fi
10839 done
10840 done
10841
10842 fi
10843 fi
10844 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10845 if test -n "$STRIP_FOR_TARGET"; then
10846   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10847 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10848 else
10849   echo "$as_me:$LINENO: result: no" >&5
10850 echo "${ECHO_T}no" >&6
10851 fi
10852
10853     fi
10854     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10855       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10856 set dummy ${ncn_progname}; ac_word=$2
10857 echo "$as_me:$LINENO: checking for $ac_word" >&5
10858 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10859 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10860   echo $ECHO_N "(cached) $ECHO_C" >&6
10861 else
10862   if test -n "$STRIP_FOR_TARGET"; then
10863   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10864 else
10865 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10866 for as_dir in $PATH
10867 do
10868   IFS=$as_save_IFS
10869   test -z "$as_dir" && as_dir=.
10870   for ac_exec_ext in '' $ac_executable_extensions; do
10871   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10872     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10873     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10874     break 2
10875   fi
10876 done
10877 done
10878
10879 fi
10880 fi
10881 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10882 if test -n "$STRIP_FOR_TARGET"; then
10883   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10884 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10885 else
10886   echo "$as_me:$LINENO: result: no" >&5
10887 echo "${ECHO_T}no" >&6
10888 fi
10889
10890     fi
10891     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10892   done
10893 fi
10894
10895 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10896   set dummy strip
10897   if test $build = $target ; then
10898     STRIP_FOR_TARGET="$2"
10899   else
10900     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10901   fi
10902 else
10903   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10904 fi
10905
10906 else
10907   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10908 fi
10909
10910
10911
10912
10913 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10914   if test -n "$with_build_time_tools"; then
10915     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10916 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10917     if test -x $with_build_time_tools/windres; then
10918       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10919       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10920       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10921 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10922     else
10923       echo "$as_me:$LINENO: result: no" >&5
10924 echo "${ECHO_T}no" >&6
10925     fi
10926   elif test $build != $host && test $have_gcc_for_target = yes; then
10927     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10928     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10929     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10930   fi
10931 fi
10932 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10933   # Extract the first word of "windres", so it can be a program name with args.
10934 set dummy windres; ac_word=$2
10935 echo "$as_me:$LINENO: checking for $ac_word" >&5
10936 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10937 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10938   echo $ECHO_N "(cached) $ECHO_C" >&6
10939 else
10940   case $WINDRES_FOR_TARGET in
10941   [\\/]* | ?:[\\/]*)
10942   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10943   ;;
10944   *)
10945   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10946 for as_dir in $gcc_cv_tool_dirs
10947 do
10948   IFS=$as_save_IFS
10949   test -z "$as_dir" && as_dir=.
10950   for ac_exec_ext in '' $ac_executable_extensions; do
10951   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10952     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10953     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10954     break 2
10955   fi
10956 done
10957 done
10958
10959   ;;
10960 esac
10961 fi
10962 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10963
10964 if test -n "$WINDRES_FOR_TARGET"; then
10965   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10966 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10967 else
10968   echo "$as_me:$LINENO: result: no" >&5
10969 echo "${ECHO_T}no" >&6
10970 fi
10971
10972 fi
10973 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10974
10975
10976 if test -n "$WINDRES_FOR_TARGET"; then
10977   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10978 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10979   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10980 fi
10981
10982 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10983   for ncn_progname in windres; do
10984     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10985 set dummy ${ncn_progname}; ac_word=$2
10986 echo "$as_me:$LINENO: checking for $ac_word" >&5
10987 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10988 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10989   echo $ECHO_N "(cached) $ECHO_C" >&6
10990 else
10991   if test -n "$WINDRES_FOR_TARGET"; then
10992   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10993 else
10994 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10995 for as_dir in $PATH
10996 do
10997   IFS=$as_save_IFS
10998   test -z "$as_dir" && as_dir=.
10999   for ac_exec_ext in '' $ac_executable_extensions; do
11000   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11001     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11002     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11003     break 2
11004   fi
11005 done
11006 done
11007
11008 fi
11009 fi
11010 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11011 if test -n "$WINDRES_FOR_TARGET"; then
11012   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11013 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11014 else
11015   echo "$as_me:$LINENO: result: no" >&5
11016 echo "${ECHO_T}no" >&6
11017 fi
11018
11019   done
11020 fi
11021
11022 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11023   for ncn_progname in windres; do
11024     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11025 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11026     if test -x $with_build_time_tools/${ncn_progname}; then
11027       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11028       echo "$as_me:$LINENO: result: yes" >&5
11029 echo "${ECHO_T}yes" >&6
11030       break
11031     else
11032       echo "$as_me:$LINENO: result: no" >&5
11033 echo "${ECHO_T}no" >&6
11034     fi
11035   done
11036 fi
11037
11038 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11039   for ncn_progname in windres; do
11040     if test -n "$ncn_target_tool_prefix"; then
11041       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11042 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11043 echo "$as_me:$LINENO: checking for $ac_word" >&5
11044 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11045 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11046   echo $ECHO_N "(cached) $ECHO_C" >&6
11047 else
11048   if test -n "$WINDRES_FOR_TARGET"; then
11049   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11050 else
11051 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11052 for as_dir in $PATH
11053 do
11054   IFS=$as_save_IFS
11055   test -z "$as_dir" && as_dir=.
11056   for ac_exec_ext in '' $ac_executable_extensions; do
11057   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11058     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11059     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11060     break 2
11061   fi
11062 done
11063 done
11064
11065 fi
11066 fi
11067 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11068 if test -n "$WINDRES_FOR_TARGET"; then
11069   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11070 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11071 else
11072   echo "$as_me:$LINENO: result: no" >&5
11073 echo "${ECHO_T}no" >&6
11074 fi
11075
11076     fi
11077     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11078       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11079 set dummy ${ncn_progname}; ac_word=$2
11080 echo "$as_me:$LINENO: checking for $ac_word" >&5
11081 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11082 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11083   echo $ECHO_N "(cached) $ECHO_C" >&6
11084 else
11085   if test -n "$WINDRES_FOR_TARGET"; then
11086   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11087 else
11088 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11089 for as_dir in $PATH
11090 do
11091   IFS=$as_save_IFS
11092   test -z "$as_dir" && as_dir=.
11093   for ac_exec_ext in '' $ac_executable_extensions; do
11094   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11095     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11096     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11097     break 2
11098   fi
11099 done
11100 done
11101
11102 fi
11103 fi
11104 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11105 if test -n "$WINDRES_FOR_TARGET"; then
11106   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11107 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11108 else
11109   echo "$as_me:$LINENO: result: no" >&5
11110 echo "${ECHO_T}no" >&6
11111 fi
11112
11113     fi
11114     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11115   done
11116 fi
11117
11118 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11119   set dummy windres
11120   if test $build = $target ; then
11121     WINDRES_FOR_TARGET="$2"
11122   else
11123     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11124   fi
11125 else
11126   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11127 fi
11128
11129 else
11130   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11131 fi
11132
11133
11134
11135
11136 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11137   if test -n "$with_build_time_tools"; then
11138     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11139 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11140     if test -x $with_build_time_tools/windmc; then
11141       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11142       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11143       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11144 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11145     else
11146       echo "$as_me:$LINENO: result: no" >&5
11147 echo "${ECHO_T}no" >&6
11148     fi
11149   elif test $build != $host && test $have_gcc_for_target = yes; then
11150     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11151     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11152     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11153   fi
11154 fi
11155 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11156   # Extract the first word of "windmc", so it can be a program name with args.
11157 set dummy windmc; ac_word=$2
11158 echo "$as_me:$LINENO: checking for $ac_word" >&5
11159 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11160 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11161   echo $ECHO_N "(cached) $ECHO_C" >&6
11162 else
11163   case $WINDMC_FOR_TARGET in
11164   [\\/]* | ?:[\\/]*)
11165   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11166   ;;
11167   *)
11168   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11169 for as_dir in $gcc_cv_tool_dirs
11170 do
11171   IFS=$as_save_IFS
11172   test -z "$as_dir" && as_dir=.
11173   for ac_exec_ext in '' $ac_executable_extensions; do
11174   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11175     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11176     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11177     break 2
11178   fi
11179 done
11180 done
11181
11182   ;;
11183 esac
11184 fi
11185 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11186
11187 if test -n "$WINDMC_FOR_TARGET"; then
11188   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11189 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11190 else
11191   echo "$as_me:$LINENO: result: no" >&5
11192 echo "${ECHO_T}no" >&6
11193 fi
11194
11195 fi
11196 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11197
11198
11199 if test -n "$WINDMC_FOR_TARGET"; then
11200   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11201 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11202   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11203 fi
11204
11205 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11206   for ncn_progname in windmc; do
11207     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11208 set dummy ${ncn_progname}; ac_word=$2
11209 echo "$as_me:$LINENO: checking for $ac_word" >&5
11210 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11211 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11212   echo $ECHO_N "(cached) $ECHO_C" >&6
11213 else
11214   if test -n "$WINDMC_FOR_TARGET"; then
11215   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11216 else
11217 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11218 for as_dir in $PATH
11219 do
11220   IFS=$as_save_IFS
11221   test -z "$as_dir" && as_dir=.
11222   for ac_exec_ext in '' $ac_executable_extensions; do
11223   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11224     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11225     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11226     break 2
11227   fi
11228 done
11229 done
11230
11231 fi
11232 fi
11233 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11234 if test -n "$WINDMC_FOR_TARGET"; then
11235   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11236 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11237 else
11238   echo "$as_me:$LINENO: result: no" >&5
11239 echo "${ECHO_T}no" >&6
11240 fi
11241
11242   done
11243 fi
11244
11245 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11246   for ncn_progname in windmc; do
11247     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11248 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11249     if test -x $with_build_time_tools/${ncn_progname}; then
11250       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11251       echo "$as_me:$LINENO: result: yes" >&5
11252 echo "${ECHO_T}yes" >&6
11253       break
11254     else
11255       echo "$as_me:$LINENO: result: no" >&5
11256 echo "${ECHO_T}no" >&6
11257     fi
11258   done
11259 fi
11260
11261 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11262   for ncn_progname in windmc; do
11263     if test -n "$ncn_target_tool_prefix"; then
11264       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11265 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11266 echo "$as_me:$LINENO: checking for $ac_word" >&5
11267 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11268 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11269   echo $ECHO_N "(cached) $ECHO_C" >&6
11270 else
11271   if test -n "$WINDMC_FOR_TARGET"; then
11272   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11273 else
11274 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11275 for as_dir in $PATH
11276 do
11277   IFS=$as_save_IFS
11278   test -z "$as_dir" && as_dir=.
11279   for ac_exec_ext in '' $ac_executable_extensions; do
11280   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11281     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11282     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11283     break 2
11284   fi
11285 done
11286 done
11287
11288 fi
11289 fi
11290 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11291 if test -n "$WINDMC_FOR_TARGET"; then
11292   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11293 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11294 else
11295   echo "$as_me:$LINENO: result: no" >&5
11296 echo "${ECHO_T}no" >&6
11297 fi
11298
11299     fi
11300     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11301       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11302 set dummy ${ncn_progname}; ac_word=$2
11303 echo "$as_me:$LINENO: checking for $ac_word" >&5
11304 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11305 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11306   echo $ECHO_N "(cached) $ECHO_C" >&6
11307 else
11308   if test -n "$WINDMC_FOR_TARGET"; then
11309   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11310 else
11311 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11312 for as_dir in $PATH
11313 do
11314   IFS=$as_save_IFS
11315   test -z "$as_dir" && as_dir=.
11316   for ac_exec_ext in '' $ac_executable_extensions; do
11317   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11318     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11319     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11320     break 2
11321   fi
11322 done
11323 done
11324
11325 fi
11326 fi
11327 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11328 if test -n "$WINDMC_FOR_TARGET"; then
11329   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11330 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11331 else
11332   echo "$as_me:$LINENO: result: no" >&5
11333 echo "${ECHO_T}no" >&6
11334 fi
11335
11336     fi
11337     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11338   done
11339 fi
11340
11341 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11342   set dummy windmc
11343   if test $build = $target ; then
11344     WINDMC_FOR_TARGET="$2"
11345   else
11346     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11347   fi
11348 else
11349   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11350 fi
11351
11352 else
11353   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11354 fi
11355
11356
11357 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11358
11359 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11360 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11361 if test "x${build}" != "x${host}" ; then
11362   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11363     # We already found the complete path
11364     ac_dir=`dirname $AR_FOR_TARGET`
11365     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11366 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11367   else
11368     # Canadian cross, just use what we found
11369     echo "$as_me:$LINENO: result: pre-installed" >&5
11370 echo "${ECHO_T}pre-installed" >&6
11371   fi
11372 else
11373   ok=yes
11374   case " ${configdirs} " in
11375     *" binutils "*) ;;
11376     *) ok=no ;;
11377   esac
11378
11379   if test $ok = yes; then
11380     # An in-tree tool is available and we can use it
11381     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11382     echo "$as_me:$LINENO: result: just compiled" >&5
11383 echo "${ECHO_T}just compiled" >&6
11384   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11385     # We already found the complete path
11386     ac_dir=`dirname $AR_FOR_TARGET`
11387     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11388 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11389   elif test "x$target" = "x$host"; then
11390     # We can use an host tool
11391     AR_FOR_TARGET='$(AR)'
11392     echo "$as_me:$LINENO: result: host tool" >&5
11393 echo "${ECHO_T}host tool" >&6
11394   else
11395     # We need a cross tool
11396     echo "$as_me:$LINENO: result: pre-installed" >&5
11397 echo "${ECHO_T}pre-installed" >&6
11398   fi
11399 fi
11400
11401 echo "$as_me:$LINENO: checking where to find the target as" >&5
11402 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11403 if test "x${build}" != "x${host}" ; then
11404   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11405     # We already found the complete path
11406     ac_dir=`dirname $AS_FOR_TARGET`
11407     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11408 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11409   else
11410     # Canadian cross, just use what we found
11411     echo "$as_me:$LINENO: result: pre-installed" >&5
11412 echo "${ECHO_T}pre-installed" >&6
11413   fi
11414 else
11415   ok=yes
11416   case " ${configdirs} " in
11417     *" gas "*) ;;
11418     *) ok=no ;;
11419   esac
11420
11421   if test $ok = yes; then
11422     # An in-tree tool is available and we can use it
11423     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11424     echo "$as_me:$LINENO: result: just compiled" >&5
11425 echo "${ECHO_T}just compiled" >&6
11426   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11427     # We already found the complete path
11428     ac_dir=`dirname $AS_FOR_TARGET`
11429     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11430 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11431   elif test "x$target" = "x$host"; then
11432     # We can use an host tool
11433     AS_FOR_TARGET='$(AS)'
11434     echo "$as_me:$LINENO: result: host tool" >&5
11435 echo "${ECHO_T}host tool" >&6
11436   else
11437     # We need a cross tool
11438     echo "$as_me:$LINENO: result: pre-installed" >&5
11439 echo "${ECHO_T}pre-installed" >&6
11440   fi
11441 fi
11442
11443 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11444 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11445 if test "x${build}" != "x${host}" ; then
11446   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11447     # We already found the complete path
11448     ac_dir=`dirname $CC_FOR_TARGET`
11449     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11450 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11451   else
11452     # Canadian cross, just use what we found
11453     echo "$as_me:$LINENO: result: pre-installed" >&5
11454 echo "${ECHO_T}pre-installed" >&6
11455   fi
11456 else
11457   ok=yes
11458   case " ${configdirs} " in
11459     *" gcc "*) ;;
11460     *) ok=no ;;
11461   esac
11462
11463   if test $ok = yes; then
11464     # An in-tree tool is available and we can use it
11465     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11466     echo "$as_me:$LINENO: result: just compiled" >&5
11467 echo "${ECHO_T}just compiled" >&6
11468   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11469     # We already found the complete path
11470     ac_dir=`dirname $CC_FOR_TARGET`
11471     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11472 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11473   elif test "x$target" = "x$host"; then
11474     # We can use an host tool
11475     CC_FOR_TARGET='$(CC)'
11476     echo "$as_me:$LINENO: result: host tool" >&5
11477 echo "${ECHO_T}host tool" >&6
11478   else
11479     # We need a cross tool
11480     echo "$as_me:$LINENO: result: pre-installed" >&5
11481 echo "${ECHO_T}pre-installed" >&6
11482   fi
11483 fi
11484
11485 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11486 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11487 if test "x${build}" != "x${host}" ; then
11488   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11489     # We already found the complete path
11490     ac_dir=`dirname $CXX_FOR_TARGET`
11491     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11492 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11493   else
11494     # Canadian cross, just use what we found
11495     echo "$as_me:$LINENO: result: pre-installed" >&5
11496 echo "${ECHO_T}pre-installed" >&6
11497   fi
11498 else
11499   ok=yes
11500   case " ${configdirs} " in
11501     *" gcc "*) ;;
11502     *) ok=no ;;
11503   esac
11504   case ,${enable_languages}, in
11505     *,c++,*) ;;
11506     *) ok=no ;;
11507   esac
11508   if test $ok = yes; then
11509     # An in-tree tool is available and we can use it
11510     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'
11511     echo "$as_me:$LINENO: result: just compiled" >&5
11512 echo "${ECHO_T}just compiled" >&6
11513   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11514     # We already found the complete path
11515     ac_dir=`dirname $CXX_FOR_TARGET`
11516     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11517 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11518   elif test "x$target" = "x$host"; then
11519     # We can use an host tool
11520     CXX_FOR_TARGET='$(CXX)'
11521     echo "$as_me:$LINENO: result: host tool" >&5
11522 echo "${ECHO_T}host tool" >&6
11523   else
11524     # We need a cross tool
11525     echo "$as_me:$LINENO: result: pre-installed" >&5
11526 echo "${ECHO_T}pre-installed" >&6
11527   fi
11528 fi
11529
11530 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11531 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11532 if test "x${build}" != "x${host}" ; then
11533   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11534     # We already found the complete path
11535     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11536     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11537 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11538   else
11539     # Canadian cross, just use what we found
11540     echo "$as_me:$LINENO: result: pre-installed" >&5
11541 echo "${ECHO_T}pre-installed" >&6
11542   fi
11543 else
11544   ok=yes
11545   case " ${configdirs} " in
11546     *" gcc "*) ;;
11547     *) ok=no ;;
11548   esac
11549   case ,${enable_languages}, in
11550     *,c++,*) ;;
11551     *) ok=no ;;
11552   esac
11553   if test $ok = yes; then
11554     # An in-tree tool is available and we can use it
11555     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'
11556     echo "$as_me:$LINENO: result: just compiled" >&5
11557 echo "${ECHO_T}just compiled" >&6
11558   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11559     # We already found the complete path
11560     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11561     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11562 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11563   elif test "x$target" = "x$host"; then
11564     # We can use an host tool
11565     RAW_CXX_FOR_TARGET='$(CXX)'
11566     echo "$as_me:$LINENO: result: host tool" >&5
11567 echo "${ECHO_T}host tool" >&6
11568   else
11569     # We need a cross tool
11570     echo "$as_me:$LINENO: result: pre-installed" >&5
11571 echo "${ECHO_T}pre-installed" >&6
11572   fi
11573 fi
11574
11575 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11576 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11577 if test "x${build}" != "x${host}" ; then
11578   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11579     # We already found the complete path
11580     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11581     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11582 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11583   else
11584     # Canadian cross, just use what we found
11585     echo "$as_me:$LINENO: result: pre-installed" >&5
11586 echo "${ECHO_T}pre-installed" >&6
11587   fi
11588 else
11589   ok=yes
11590   case " ${configdirs} " in
11591     *" binutils "*) ;;
11592     *) ok=no ;;
11593   esac
11594
11595   if test $ok = yes; then
11596     # An in-tree tool is available and we can use it
11597     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11598     echo "$as_me:$LINENO: result: just compiled" >&5
11599 echo "${ECHO_T}just compiled" >&6
11600   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11601     # We already found the complete path
11602     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11603     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11604 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11605   elif test "x$target" = "x$host"; then
11606     # We can use an host tool
11607     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11608     echo "$as_me:$LINENO: result: host tool" >&5
11609 echo "${ECHO_T}host tool" >&6
11610   else
11611     # We need a cross tool
11612     echo "$as_me:$LINENO: result: pre-installed" >&5
11613 echo "${ECHO_T}pre-installed" >&6
11614   fi
11615 fi
11616
11617 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11618 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11619 if test "x${build}" != "x${host}" ; then
11620   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11621     # We already found the complete path
11622     ac_dir=`dirname $GCC_FOR_TARGET`
11623     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11624 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11625   else
11626     # Canadian cross, just use what we found
11627     echo "$as_me:$LINENO: result: pre-installed" >&5
11628 echo "${ECHO_T}pre-installed" >&6
11629   fi
11630 else
11631   ok=yes
11632   case " ${configdirs} " in
11633     *" gcc "*) ;;
11634     *) ok=no ;;
11635   esac
11636
11637   if test $ok = yes; then
11638     # An in-tree tool is available and we can use it
11639     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11640     echo "$as_me:$LINENO: result: just compiled" >&5
11641 echo "${ECHO_T}just compiled" >&6
11642   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11643     # We already found the complete path
11644     ac_dir=`dirname $GCC_FOR_TARGET`
11645     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11646 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11647   elif test "x$target" = "x$host"; then
11648     # We can use an host tool
11649     GCC_FOR_TARGET='$()'
11650     echo "$as_me:$LINENO: result: host tool" >&5
11651 echo "${ECHO_T}host tool" >&6
11652   else
11653     # We need a cross tool
11654     echo "$as_me:$LINENO: result: pre-installed" >&5
11655 echo "${ECHO_T}pre-installed" >&6
11656   fi
11657 fi
11658
11659 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11660 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11661 if test "x${build}" != "x${host}" ; then
11662   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11663     # We already found the complete path
11664     ac_dir=`dirname $GCJ_FOR_TARGET`
11665     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11666 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11667   else
11668     # Canadian cross, just use what we found
11669     echo "$as_me:$LINENO: result: pre-installed" >&5
11670 echo "${ECHO_T}pre-installed" >&6
11671   fi
11672 else
11673   ok=yes
11674   case " ${configdirs} " in
11675     *" gcc "*) ;;
11676     *) ok=no ;;
11677   esac
11678   case ,${enable_languages}, in
11679     *,java,*) ;;
11680     *) ok=no ;;
11681   esac
11682   if test $ok = yes; then
11683     # An in-tree tool is available and we can use it
11684     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11685     echo "$as_me:$LINENO: result: just compiled" >&5
11686 echo "${ECHO_T}just compiled" >&6
11687   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11688     # We already found the complete path
11689     ac_dir=`dirname $GCJ_FOR_TARGET`
11690     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11691 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11692   elif test "x$target" = "x$host"; then
11693     # We can use an host tool
11694     GCJ_FOR_TARGET='$(GCJ)'
11695     echo "$as_me:$LINENO: result: host tool" >&5
11696 echo "${ECHO_T}host tool" >&6
11697   else
11698     # We need a cross tool
11699     echo "$as_me:$LINENO: result: pre-installed" >&5
11700 echo "${ECHO_T}pre-installed" >&6
11701   fi
11702 fi
11703
11704 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11705 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11706 if test "x${build}" != "x${host}" ; then
11707   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11708     # We already found the complete path
11709     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11710     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11711 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11712   else
11713     # Canadian cross, just use what we found
11714     echo "$as_me:$LINENO: result: pre-installed" >&5
11715 echo "${ECHO_T}pre-installed" >&6
11716   fi
11717 else
11718   ok=yes
11719   case " ${configdirs} " in
11720     *" gcc "*) ;;
11721     *) ok=no ;;
11722   esac
11723   case ,${enable_languages}, in
11724     *,fortran,*) ;;
11725     *) ok=no ;;
11726   esac
11727   if test $ok = yes; then
11728     # An in-tree tool is available and we can use it
11729     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11730     echo "$as_me:$LINENO: result: just compiled" >&5
11731 echo "${ECHO_T}just compiled" >&6
11732   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11733     # We already found the complete path
11734     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11735     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11736 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11737   elif test "x$target" = "x$host"; then
11738     # We can use an host tool
11739     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11740     echo "$as_me:$LINENO: result: host tool" >&5
11741 echo "${ECHO_T}host tool" >&6
11742   else
11743     # We need a cross tool
11744     echo "$as_me:$LINENO: result: pre-installed" >&5
11745 echo "${ECHO_T}pre-installed" >&6
11746   fi
11747 fi
11748
11749 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11750 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11751 if test "x${build}" != "x${host}" ; then
11752   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11753     # We already found the complete path
11754     ac_dir=`dirname $LD_FOR_TARGET`
11755     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11756 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11757   else
11758     # Canadian cross, just use what we found
11759     echo "$as_me:$LINENO: result: pre-installed" >&5
11760 echo "${ECHO_T}pre-installed" >&6
11761   fi
11762 else
11763   ok=yes
11764   case " ${configdirs} " in
11765     *" ld "*) ;;
11766     *) ok=no ;;
11767   esac
11768
11769   if test $ok = yes; then
11770     # An in-tree tool is available and we can use it
11771     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11772     echo "$as_me:$LINENO: result: just compiled" >&5
11773 echo "${ECHO_T}just compiled" >&6
11774   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11775     # We already found the complete path
11776     ac_dir=`dirname $LD_FOR_TARGET`
11777     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11778 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11779   elif test "x$target" = "x$host"; then
11780     # We can use an host tool
11781     LD_FOR_TARGET='$(LD)'
11782     echo "$as_me:$LINENO: result: host tool" >&5
11783 echo "${ECHO_T}host tool" >&6
11784   else
11785     # We need a cross tool
11786     echo "$as_me:$LINENO: result: pre-installed" >&5
11787 echo "${ECHO_T}pre-installed" >&6
11788   fi
11789 fi
11790
11791 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11792 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11793 if test "x${build}" != "x${host}" ; then
11794   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11795     # We already found the complete path
11796     ac_dir=`dirname $LIPO_FOR_TARGET`
11797     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11798 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11799   else
11800     # Canadian cross, just use what we found
11801     echo "$as_me:$LINENO: result: pre-installed" >&5
11802 echo "${ECHO_T}pre-installed" >&6
11803   fi
11804 else
11805   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11806     # We already found the complete path
11807     ac_dir=`dirname $LIPO_FOR_TARGET`
11808     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11809 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11810   elif test "x$target" = "x$host"; then
11811     # We can use an host tool
11812     LIPO_FOR_TARGET='$(LIPO)'
11813     echo "$as_me:$LINENO: result: host tool" >&5
11814 echo "${ECHO_T}host tool" >&6
11815   else
11816     # We need a cross tool
11817     echo "$as_me:$LINENO: result: pre-installed" >&5
11818 echo "${ECHO_T}pre-installed" >&6
11819   fi
11820 fi
11821
11822 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11823 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11824 if test "x${build}" != "x${host}" ; then
11825   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11826     # We already found the complete path
11827     ac_dir=`dirname $NM_FOR_TARGET`
11828     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11829 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11830   else
11831     # Canadian cross, just use what we found
11832     echo "$as_me:$LINENO: result: pre-installed" >&5
11833 echo "${ECHO_T}pre-installed" >&6
11834   fi
11835 else
11836   ok=yes
11837   case " ${configdirs} " in
11838     *" binutils "*) ;;
11839     *) ok=no ;;
11840   esac
11841
11842   if test $ok = yes; then
11843     # An in-tree tool is available and we can use it
11844     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11845     echo "$as_me:$LINENO: result: just compiled" >&5
11846 echo "${ECHO_T}just compiled" >&6
11847   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11848     # We already found the complete path
11849     ac_dir=`dirname $NM_FOR_TARGET`
11850     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11851 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11852   elif test "x$target" = "x$host"; then
11853     # We can use an host tool
11854     NM_FOR_TARGET='$(NM)'
11855     echo "$as_me:$LINENO: result: host tool" >&5
11856 echo "${ECHO_T}host tool" >&6
11857   else
11858     # We need a cross tool
11859     echo "$as_me:$LINENO: result: pre-installed" >&5
11860 echo "${ECHO_T}pre-installed" >&6
11861   fi
11862 fi
11863
11864 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11865 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11866 if test "x${build}" != "x${host}" ; then
11867   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11868     # We already found the complete path
11869     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11870     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11871 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11872   else
11873     # Canadian cross, just use what we found
11874     echo "$as_me:$LINENO: result: pre-installed" >&5
11875 echo "${ECHO_T}pre-installed" >&6
11876   fi
11877 else
11878   ok=yes
11879   case " ${configdirs} " in
11880     *" binutils "*) ;;
11881     *) ok=no ;;
11882   esac
11883
11884   if test $ok = yes; then
11885     # An in-tree tool is available and we can use it
11886     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11887     echo "$as_me:$LINENO: result: just compiled" >&5
11888 echo "${ECHO_T}just compiled" >&6
11889   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11890     # We already found the complete path
11891     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11892     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11893 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11894   elif test "x$target" = "x$host"; then
11895     # We can use an host tool
11896     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11897     echo "$as_me:$LINENO: result: host tool" >&5
11898 echo "${ECHO_T}host tool" >&6
11899   else
11900     # We need a cross tool
11901     echo "$as_me:$LINENO: result: pre-installed" >&5
11902 echo "${ECHO_T}pre-installed" >&6
11903   fi
11904 fi
11905
11906 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11907 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11908 if test "x${build}" != "x${host}" ; then
11909   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11910     # We already found the complete path
11911     ac_dir=`dirname $RANLIB_FOR_TARGET`
11912     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11913 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11914   else
11915     # Canadian cross, just use what we found
11916     echo "$as_me:$LINENO: result: pre-installed" >&5
11917 echo "${ECHO_T}pre-installed" >&6
11918   fi
11919 else
11920   ok=yes
11921   case " ${configdirs} " in
11922     *" binutils "*) ;;
11923     *) ok=no ;;
11924   esac
11925
11926   if test $ok = yes; then
11927     # An in-tree tool is available and we can use it
11928     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11929     echo "$as_me:$LINENO: result: just compiled" >&5
11930 echo "${ECHO_T}just compiled" >&6
11931   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11932     # We already found the complete path
11933     ac_dir=`dirname $RANLIB_FOR_TARGET`
11934     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11935 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11936   elif test "x$target" = "x$host"; then
11937     # We can use an host tool
11938     RANLIB_FOR_TARGET='$(RANLIB)'
11939     echo "$as_me:$LINENO: result: host tool" >&5
11940 echo "${ECHO_T}host tool" >&6
11941   else
11942     # We need a cross tool
11943     echo "$as_me:$LINENO: result: pre-installed" >&5
11944 echo "${ECHO_T}pre-installed" >&6
11945   fi
11946 fi
11947
11948 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11949 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11950 if test "x${build}" != "x${host}" ; then
11951   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11952     # We already found the complete path
11953     ac_dir=`dirname $STRIP_FOR_TARGET`
11954     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11955 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11956   else
11957     # Canadian cross, just use what we found
11958     echo "$as_me:$LINENO: result: pre-installed" >&5
11959 echo "${ECHO_T}pre-installed" >&6
11960   fi
11961 else
11962   ok=yes
11963   case " ${configdirs} " in
11964     *" binutils "*) ;;
11965     *) ok=no ;;
11966   esac
11967
11968   if test $ok = yes; then
11969     # An in-tree tool is available and we can use it
11970     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11971     echo "$as_me:$LINENO: result: just compiled" >&5
11972 echo "${ECHO_T}just compiled" >&6
11973   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11974     # We already found the complete path
11975     ac_dir=`dirname $STRIP_FOR_TARGET`
11976     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11977 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11978   elif test "x$target" = "x$host"; then
11979     # We can use an host tool
11980     STRIP_FOR_TARGET='$(STRIP)'
11981     echo "$as_me:$LINENO: result: host tool" >&5
11982 echo "${ECHO_T}host tool" >&6
11983   else
11984     # We need a cross tool
11985     echo "$as_me:$LINENO: result: pre-installed" >&5
11986 echo "${ECHO_T}pre-installed" >&6
11987   fi
11988 fi
11989
11990 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11991 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11992 if test "x${build}" != "x${host}" ; then
11993   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11994     # We already found the complete path
11995     ac_dir=`dirname $WINDRES_FOR_TARGET`
11996     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11997 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11998   else
11999     # Canadian cross, just use what we found
12000     echo "$as_me:$LINENO: result: pre-installed" >&5
12001 echo "${ECHO_T}pre-installed" >&6
12002   fi
12003 else
12004   ok=yes
12005   case " ${configdirs} " in
12006     *" binutils "*) ;;
12007     *) ok=no ;;
12008   esac
12009
12010   if test $ok = yes; then
12011     # An in-tree tool is available and we can use it
12012     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12013     echo "$as_me:$LINENO: result: just compiled" >&5
12014 echo "${ECHO_T}just compiled" >&6
12015   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12016     # We already found the complete path
12017     ac_dir=`dirname $WINDRES_FOR_TARGET`
12018     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12019 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12020   elif test "x$target" = "x$host"; then
12021     # We can use an host tool
12022     WINDRES_FOR_TARGET='$(WINDRES)'
12023     echo "$as_me:$LINENO: result: host tool" >&5
12024 echo "${ECHO_T}host tool" >&6
12025   else
12026     # We need a cross tool
12027     echo "$as_me:$LINENO: result: pre-installed" >&5
12028 echo "${ECHO_T}pre-installed" >&6
12029   fi
12030 fi
12031
12032 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12033 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12034 if test "x${build}" != "x${host}" ; then
12035   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12036     # We already found the complete path
12037     ac_dir=`dirname $WINDMC_FOR_TARGET`
12038     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12039 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12040   else
12041     # Canadian cross, just use what we found
12042     echo "$as_me:$LINENO: result: pre-installed" >&5
12043 echo "${ECHO_T}pre-installed" >&6
12044   fi
12045 else
12046   ok=yes
12047   case " ${configdirs} " in
12048     *" binutils "*) ;;
12049     *) ok=no ;;
12050   esac
12051
12052   if test $ok = yes; then
12053     # An in-tree tool is available and we can use it
12054     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12055     echo "$as_me:$LINENO: result: just compiled" >&5
12056 echo "${ECHO_T}just compiled" >&6
12057   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12058     # We already found the complete path
12059     ac_dir=`dirname $WINDMC_FOR_TARGET`
12060     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12061 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12062   elif test "x$target" = "x$host"; then
12063     # We can use an host tool
12064     WINDMC_FOR_TARGET='$(WINDMC)'
12065     echo "$as_me:$LINENO: result: host tool" >&5
12066 echo "${ECHO_T}host tool" >&6
12067   else
12068     # We need a cross tool
12069     echo "$as_me:$LINENO: result: pre-installed" >&5
12070 echo "${ECHO_T}pre-installed" >&6
12071   fi
12072 fi
12073
12074
12075
12076
12077
12078 # Certain tools may need extra flags.
12079 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12080 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12081 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12082
12083 # When building target libraries, except in a Canadian cross, we use
12084 # the same toolchain as the compiler we just built.
12085 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12086 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12087 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12088 if test $host = $build; then
12089   case " $configdirs " in
12090     *" gcc "*)
12091       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12092       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12093       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12094       ;;
12095   esac
12096 fi
12097
12098
12099
12100
12101
12102 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12103 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12104 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12105 if test "${enable_maintainer_mode+set}" = set; then
12106   enableval="$enable_maintainer_mode"
12107   USE_MAINTAINER_MODE=$enableval
12108 else
12109   USE_MAINTAINER_MODE=no
12110 fi;
12111 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12112 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12113
12114
12115 if test "$USE_MAINTAINER_MODE" = yes; then
12116   MAINTAINER_MODE_TRUE=
12117   MAINTAINER_MODE_FALSE='#'
12118 else
12119   MAINTAINER_MODE_TRUE='#'
12120   MAINTAINER_MODE_FALSE=
12121 fi
12122 MAINT=$MAINTAINER_MODE_TRUE
12123
12124 # ---------------------
12125 # GCC bootstrap support
12126 # ---------------------
12127
12128 # Stage specific cflags for build.
12129 stage1_cflags="-g"
12130 case $build in
12131   vax-*-*)
12132     case ${GCC} in
12133       yes) stage1_cflags="-g -Wa,-J" ;;
12134       *) stage1_cflags="-g -J" ;;
12135     esac ;;
12136 esac
12137
12138 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12139 if test "$GCC" = yes; then
12140   saved_CFLAGS="$CFLAGS"
12141
12142   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12143   CFLAGS="$CFLAGS -fkeep-inline-functions"
12144   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12145 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12146   cat >conftest.$ac_ext <<_ACEOF
12147 /* confdefs.h.  */
12148 _ACEOF
12149 cat confdefs.h >>conftest.$ac_ext
12150 cat >>conftest.$ac_ext <<_ACEOF
12151 /* end confdefs.h.  */
12152
12153 #if (__GNUC__ < 3) \
12154     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12155                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12156 #error http://gcc.gnu.org/PR29382
12157 #endif
12158
12159 int
12160 main ()
12161 {
12162
12163   ;
12164   return 0;
12165 }
12166 _ACEOF
12167 rm -f conftest.$ac_objext
12168 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12169   (eval $ac_compile) 2>conftest.er1
12170   ac_status=$?
12171   grep -v '^ *+' conftest.er1 >conftest.err
12172   rm -f conftest.er1
12173   cat conftest.err >&5
12174   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12175   (exit $ac_status); } &&
12176          { ac_try='test -z "$ac_c_werror_flag"
12177                          || test ! -s conftest.err'
12178   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12179   (eval $ac_try) 2>&5
12180   ac_status=$?
12181   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12182   (exit $ac_status); }; } &&
12183          { ac_try='test -s conftest.$ac_objext'
12184   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12185   (eval $ac_try) 2>&5
12186   ac_status=$?
12187   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12188   (exit $ac_status); }; }; then
12189   echo "$as_me:$LINENO: result: yes" >&5
12190 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12191 else
12192   echo "$as_me: failed program was:" >&5
12193 sed 's/^/| /' conftest.$ac_ext >&5
12194
12195 echo "$as_me:$LINENO: result: no" >&5
12196 echo "${ECHO_T}no" >&6
12197 fi
12198 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12199
12200   CFLAGS="$saved_CFLAGS"
12201 fi
12202
12203
12204
12205 # Enable --enable-checking in stage1 of the compiler.
12206 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12207 if test "${enable_stage1_checking+set}" = set; then
12208   enableval="$enable_stage1_checking"
12209   stage1_checking=--enable-checking=${enable_stage1_checking}
12210 else
12211   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12212   stage1_checking=--enable-checking=yes,types
12213 else
12214   stage1_checking=--enable-checking=$enable_checking,types
12215 fi
12216 fi;
12217
12218
12219 # Enable -Werror in bootstrap stage2 and later.
12220 # Check whether --enable-werror or --disable-werror was given.
12221 if test "${enable_werror+set}" = set; then
12222   enableval="$enable_werror"
12223
12224 else
12225   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12226   enable_werror=yes
12227 else
12228   enable_werror=no
12229 fi
12230 fi;
12231 case ${enable_werror} in
12232   yes) stage2_werror_flag="--enable-werror-always" ;;
12233   *) stage2_werror_flag="" ;;
12234 esac
12235
12236
12237 # Flags needed to enable html installing and building
12238
12239 # Check whether --with-datarootdir or --without-datarootdir was given.
12240 if test "${with_datarootdir+set}" = set; then
12241   withval="$with_datarootdir"
12242   datarootdir="\${prefix}/${withval}"
12243 else
12244   datarootdir="\${prefix}/share"
12245 fi;
12246
12247
12248 # Check whether --with-docdir or --without-docdir was given.
12249 if test "${with_docdir+set}" = set; then
12250   withval="$with_docdir"
12251   docdir="\${prefix}/${withval}"
12252 else
12253   docdir="\${datarootdir}/doc"
12254 fi;
12255
12256
12257 # Check whether --with-pdfdir or --without-pdfdir was given.
12258 if test "${with_pdfdir+set}" = set; then
12259   withval="$with_pdfdir"
12260   pdfdir="\${prefix}/${withval}"
12261 else
12262   pdfdir="\${docdir}"
12263 fi;
12264
12265
12266 # Check whether --with-htmldir or --without-htmldir was given.
12267 if test "${with_htmldir+set}" = set; then
12268   withval="$with_htmldir"
12269   htmldir="\${prefix}/${withval}"
12270 else
12271   htmldir="\${docdir}"
12272 fi;
12273
12274
12275
12276
12277
12278
12279           ac_config_files="$ac_config_files Makefile"
12280 cat >confcache <<\_ACEOF
12281 # This file is a shell script that caches the results of configure
12282 # tests run on this system so they can be shared between configure
12283 # scripts and configure runs, see configure's option --config-cache.
12284 # It is not useful on other systems.  If it contains results you don't
12285 # want to keep, you may remove or edit it.
12286 #
12287 # config.status only pays attention to the cache file if you give it
12288 # the --recheck option to rerun configure.
12289 #
12290 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12291 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12292 # following values.
12293
12294 _ACEOF
12295
12296 # The following way of writing the cache mishandles newlines in values,
12297 # but we know of no workaround that is simple, portable, and efficient.
12298 # So, don't put newlines in cache variables' values.
12299 # Ultrix sh set writes to stderr and can't be redirected directly,
12300 # and sets the high bit in the cache file unless we assign to the vars.
12301 {
12302   (set) 2>&1 |
12303     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12304     *ac_space=\ *)
12305       # `set' does not quote correctly, so add quotes (double-quote
12306       # substitution turns \\\\ into \\, and sed turns \\ into \).
12307       sed -n \
12308         "s/'/'\\\\''/g;
12309           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12310       ;;
12311     *)
12312       # `set' quotes correctly as required by POSIX, so do not add quotes.
12313       sed -n \
12314         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12315       ;;
12316     esac;
12317 } |
12318   sed '
12319      t clear
12320      : clear
12321      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12322      t end
12323      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12324      : end' >>confcache
12325 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12326   if test -w $cache_file; then
12327     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12328     cat confcache >$cache_file
12329   else
12330     echo "not updating unwritable cache $cache_file"
12331   fi
12332 fi
12333 rm -f confcache
12334
12335 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12336 # Let make expand exec_prefix.
12337 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12338
12339 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12340 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12341 # trailing colons and then remove the whole line if VPATH becomes empty
12342 # (actually we leave an empty line to preserve line numbers).
12343 if test "x$srcdir" = x.; then
12344   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12345 s/:*\$(srcdir):*/:/;
12346 s/:*\${srcdir}:*/:/;
12347 s/:*@srcdir@:*/:/;
12348 s/^\([^=]*=[     ]*\):*/\1/;
12349 s/:*$//;
12350 s/^[^=]*=[       ]*$//;
12351 }'
12352 fi
12353
12354 # Transform confdefs.h into DEFS.
12355 # Protect against shell expansion while executing Makefile rules.
12356 # Protect against Makefile macro expansion.
12357 #
12358 # If the first sed substitution is executed (which looks for macros that
12359 # take arguments), then we branch to the quote section.  Otherwise,
12360 # look for a macro that doesn't take arguments.
12361 cat >confdef2opt.sed <<\_ACEOF
12362 t clear
12363 : clear
12364 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12365 t quote
12366 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12367 t quote
12368 d
12369 : quote
12370 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12371 s,\[,\\&,g
12372 s,\],\\&,g
12373 s,\$,$$,g
12374 p
12375 _ACEOF
12376 # We use echo to avoid assuming a particular line-breaking character.
12377 # The extra dot is to prevent the shell from consuming trailing
12378 # line-breaks from the sub-command output.  A line-break within
12379 # single-quotes doesn't work because, if this script is created in a
12380 # platform that uses two characters for line-breaks (e.g., DOS), tr
12381 # would break.
12382 ac_LF_and_DOT=`echo; echo .`
12383 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12384 rm -f confdef2opt.sed
12385
12386
12387 ac_libobjs=
12388 ac_ltlibobjs=
12389 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12390   # 1. Remove the extension, and $U if already installed.
12391   ac_i=`echo "$ac_i" |
12392          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12393   # 2. Add them.
12394   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12395   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12396 done
12397 LIBOBJS=$ac_libobjs
12398
12399 LTLIBOBJS=$ac_ltlibobjs
12400
12401
12402
12403 : ${CONFIG_STATUS=./config.status}
12404 ac_clean_files_save=$ac_clean_files
12405 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12406 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12407 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12408 cat >$CONFIG_STATUS <<_ACEOF
12409 #! $SHELL
12410 # Generated by $as_me.
12411 # Run this file to recreate the current configuration.
12412 # Compiler output produced by configure, useful for debugging
12413 # configure, is in config.log if it exists.
12414
12415 debug=false
12416 ac_cs_recheck=false
12417 ac_cs_silent=false
12418 SHELL=\${CONFIG_SHELL-$SHELL}
12419 _ACEOF
12420
12421 cat >>$CONFIG_STATUS <<\_ACEOF
12422 ## --------------------- ##
12423 ## M4sh Initialization.  ##
12424 ## --------------------- ##
12425
12426 # Be Bourne compatible
12427 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12428   emulate sh
12429   NULLCMD=:
12430   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12431   # is contrary to our usage.  Disable this feature.
12432   alias -g '${1+"$@"}'='"$@"'
12433 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12434   set -o posix
12435 fi
12436 DUALCASE=1; export DUALCASE # for MKS sh
12437
12438 # Support unset when possible.
12439 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12440   as_unset=unset
12441 else
12442   as_unset=false
12443 fi
12444
12445
12446 # Work around bugs in pre-3.0 UWIN ksh.
12447 $as_unset ENV MAIL MAILPATH
12448 PS1='$ '
12449 PS2='> '
12450 PS4='+ '
12451
12452 # NLS nuisances.
12453 for as_var in \
12454   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12455   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12456   LC_TELEPHONE LC_TIME
12457 do
12458   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12459     eval $as_var=C; export $as_var
12460   else
12461     $as_unset $as_var
12462   fi
12463 done
12464
12465 # Required to use basename.
12466 if expr a : '\(a\)' >/dev/null 2>&1; then
12467   as_expr=expr
12468 else
12469   as_expr=false
12470 fi
12471
12472 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12473   as_basename=basename
12474 else
12475   as_basename=false
12476 fi
12477
12478
12479 # Name of the executable.
12480 as_me=`$as_basename "$0" ||
12481 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12482          X"$0" : 'X\(//\)$' \| \
12483          X"$0" : 'X\(/\)$' \| \
12484          .     : '\(.\)' 2>/dev/null ||
12485 echo X/"$0" |
12486     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12487           /^X\/\(\/\/\)$/{ s//\1/; q; }
12488           /^X\/\(\/\).*/{ s//\1/; q; }
12489           s/.*/./; q'`
12490
12491
12492 # PATH needs CR, and LINENO needs CR and PATH.
12493 # Avoid depending upon Character Ranges.
12494 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12495 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12496 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12497 as_cr_digits='0123456789'
12498 as_cr_alnum=$as_cr_Letters$as_cr_digits
12499
12500 # The user is always right.
12501 if test "${PATH_SEPARATOR+set}" != set; then
12502   echo "#! /bin/sh" >conf$$.sh
12503   echo  "exit 0"   >>conf$$.sh
12504   chmod +x conf$$.sh
12505   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12506     PATH_SEPARATOR=';'
12507   else
12508     PATH_SEPARATOR=:
12509   fi
12510   rm -f conf$$.sh
12511 fi
12512
12513
12514   as_lineno_1=$LINENO
12515   as_lineno_2=$LINENO
12516   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12517   test "x$as_lineno_1" != "x$as_lineno_2" &&
12518   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12519   # Find who we are.  Look in the path if we contain no path at all
12520   # relative or not.
12521   case $0 in
12522     *[\\/]* ) as_myself=$0 ;;
12523     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12524 for as_dir in $PATH
12525 do
12526   IFS=$as_save_IFS
12527   test -z "$as_dir" && as_dir=.
12528   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12529 done
12530
12531        ;;
12532   esac
12533   # We did not find ourselves, most probably we were run as `sh COMMAND'
12534   # in which case we are not to be found in the path.
12535   if test "x$as_myself" = x; then
12536     as_myself=$0
12537   fi
12538   if test ! -f "$as_myself"; then
12539     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12540 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12541    { (exit 1); exit 1; }; }
12542   fi
12543   case $CONFIG_SHELL in
12544   '')
12545     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12546 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12547 do
12548   IFS=$as_save_IFS
12549   test -z "$as_dir" && as_dir=.
12550   for as_base in sh bash ksh sh5; do
12551          case $as_dir in
12552          /*)
12553            if ("$as_dir/$as_base" -c '
12554   as_lineno_1=$LINENO
12555   as_lineno_2=$LINENO
12556   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12557   test "x$as_lineno_1" != "x$as_lineno_2" &&
12558   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12559              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12560              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12561              CONFIG_SHELL=$as_dir/$as_base
12562              export CONFIG_SHELL
12563              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12564            fi;;
12565          esac
12566        done
12567 done
12568 ;;
12569   esac
12570
12571   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12572   # uniformly replaced by the line number.  The first 'sed' inserts a
12573   # line-number line before each line; the second 'sed' does the real
12574   # work.  The second script uses 'N' to pair each line-number line
12575   # with the numbered line, and appends trailing '-' during
12576   # substitution so that $LINENO is not a special case at line end.
12577   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12578   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12579   sed '=' <$as_myself |
12580     sed '
12581       N
12582       s,$,-,
12583       : loop
12584       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12585       t loop
12586       s,-$,,
12587       s,^['$as_cr_digits']*\n,,
12588     ' >$as_me.lineno &&
12589   chmod +x $as_me.lineno ||
12590     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12591 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12592    { (exit 1); exit 1; }; }
12593
12594   # Don't try to exec as it changes $[0], causing all sort of problems
12595   # (the dirname of $[0] is not the place where we might find the
12596   # original and so on.  Autoconf is especially sensible to this).
12597   . ./$as_me.lineno
12598   # Exit status is that of the last command.
12599   exit
12600 }
12601
12602
12603 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12604   *c*,-n*) ECHO_N= ECHO_C='
12605 ' ECHO_T='      ' ;;
12606   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12607   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12608 esac
12609
12610 if expr a : '\(a\)' >/dev/null 2>&1; then
12611   as_expr=expr
12612 else
12613   as_expr=false
12614 fi
12615
12616 rm -f conf$$ conf$$.exe conf$$.file
12617 echo >conf$$.file
12618 if ln -s conf$$.file conf$$ 2>/dev/null; then
12619   # We could just check for DJGPP; but this test a) works b) is more generic
12620   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12621   if test -f conf$$.exe; then
12622     # Don't use ln at all; we don't have any links
12623     as_ln_s='cp -p'
12624   else
12625     as_ln_s='ln -s'
12626   fi
12627 elif ln conf$$.file conf$$ 2>/dev/null; then
12628   as_ln_s=ln
12629 else
12630   as_ln_s='cp -p'
12631 fi
12632 rm -f conf$$ conf$$.exe conf$$.file
12633
12634 if mkdir -p . 2>/dev/null; then
12635   as_mkdir_p=:
12636 else
12637   test -d ./-p && rmdir ./-p
12638   as_mkdir_p=false
12639 fi
12640
12641 as_executable_p="test -f"
12642
12643 # Sed expression to map a string onto a valid CPP name.
12644 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12645
12646 # Sed expression to map a string onto a valid variable name.
12647 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12648
12649
12650 # IFS
12651 # We need space, tab and new line, in precisely that order.
12652 as_nl='
12653 '
12654 IFS="   $as_nl"
12655
12656 # CDPATH.
12657 $as_unset CDPATH
12658
12659 exec 6>&1
12660
12661 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12662 # report actual input values of CONFIG_FILES etc. instead of their
12663 # values after options handling.  Logging --version etc. is OK.
12664 exec 5>>config.log
12665 {
12666   echo
12667   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12668 ## Running $as_me. ##
12669 _ASBOX
12670 } >&5
12671 cat >&5 <<_CSEOF
12672
12673 This file was extended by $as_me, which was
12674 generated by GNU Autoconf 2.59.  Invocation command line was
12675
12676   CONFIG_FILES    = $CONFIG_FILES
12677   CONFIG_HEADERS  = $CONFIG_HEADERS
12678   CONFIG_LINKS    = $CONFIG_LINKS
12679   CONFIG_COMMANDS = $CONFIG_COMMANDS
12680   $ $0 $@
12681
12682 _CSEOF
12683 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12684 echo >&5
12685 _ACEOF
12686
12687 # Files that config.status was made for.
12688 if test -n "$ac_config_files"; then
12689   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12690 fi
12691
12692 if test -n "$ac_config_headers"; then
12693   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12694 fi
12695
12696 if test -n "$ac_config_links"; then
12697   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12698 fi
12699
12700 if test -n "$ac_config_commands"; then
12701   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12702 fi
12703
12704 cat >>$CONFIG_STATUS <<\_ACEOF
12705
12706 ac_cs_usage="\
12707 \`$as_me' instantiates files from templates according to the
12708 current configuration.
12709
12710 Usage: $0 [OPTIONS] [FILE]...
12711
12712   -h, --help       print this help, then exit
12713   -V, --version    print version number, then exit
12714   -q, --quiet      do not print progress messages
12715   -d, --debug      don't remove temporary files
12716       --recheck    update $as_me by reconfiguring in the same conditions
12717   --file=FILE[:TEMPLATE]
12718                    instantiate the configuration file FILE
12719
12720 Configuration files:
12721 $config_files
12722
12723 Report bugs to <bug-autoconf@gnu.org>."
12724 _ACEOF
12725
12726 cat >>$CONFIG_STATUS <<_ACEOF
12727 ac_cs_version="\\
12728 config.status
12729 configured by $0, generated by GNU Autoconf 2.59,
12730   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12731
12732 Copyright (C) 2003 Free Software Foundation, Inc.
12733 This config.status script is free software; the Free Software Foundation
12734 gives unlimited permission to copy, distribute and modify it."
12735 srcdir=$srcdir
12736 INSTALL="$INSTALL"
12737 _ACEOF
12738
12739 cat >>$CONFIG_STATUS <<\_ACEOF
12740 # If no file are specified by the user, then we need to provide default
12741 # value.  By we need to know if files were specified by the user.
12742 ac_need_defaults=:
12743 while test $# != 0
12744 do
12745   case $1 in
12746   --*=*)
12747     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12748     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12749     ac_shift=:
12750     ;;
12751   -*)
12752     ac_option=$1
12753     ac_optarg=$2
12754     ac_shift=shift
12755     ;;
12756   *) # This is not an option, so the user has probably given explicit
12757      # arguments.
12758      ac_option=$1
12759      ac_need_defaults=false;;
12760   esac
12761
12762   case $ac_option in
12763   # Handling of the options.
12764 _ACEOF
12765 cat >>$CONFIG_STATUS <<\_ACEOF
12766   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12767     ac_cs_recheck=: ;;
12768   --version | --vers* | -V )
12769     echo "$ac_cs_version"; exit 0 ;;
12770   --he | --h)
12771     # Conflict between --help and --header
12772     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12773 Try \`$0 --help' for more information." >&5
12774 echo "$as_me: error: ambiguous option: $1
12775 Try \`$0 --help' for more information." >&2;}
12776    { (exit 1); exit 1; }; };;
12777   --help | --hel | -h )
12778     echo "$ac_cs_usage"; exit 0 ;;
12779   --debug | --d* | -d )
12780     debug=: ;;
12781   --file | --fil | --fi | --f )
12782     $ac_shift
12783     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12784     ac_need_defaults=false;;
12785   --header | --heade | --head | --hea )
12786     $ac_shift
12787     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12788     ac_need_defaults=false;;
12789   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12790   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12791     ac_cs_silent=: ;;
12792
12793   # This is an error.
12794   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12795 Try \`$0 --help' for more information." >&5
12796 echo "$as_me: error: unrecognized option: $1
12797 Try \`$0 --help' for more information." >&2;}
12798    { (exit 1); exit 1; }; } ;;
12799
12800   *) ac_config_targets="$ac_config_targets $1" ;;
12801
12802   esac
12803   shift
12804 done
12805
12806 ac_configure_extra_args=
12807
12808 if $ac_cs_silent; then
12809   exec 6>/dev/null
12810   ac_configure_extra_args="$ac_configure_extra_args --silent"
12811 fi
12812
12813 _ACEOF
12814 cat >>$CONFIG_STATUS <<_ACEOF
12815 if \$ac_cs_recheck; then
12816   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12817   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12818 fi
12819
12820 _ACEOF
12821
12822
12823
12824
12825
12826 cat >>$CONFIG_STATUS <<\_ACEOF
12827 for ac_config_target in $ac_config_targets
12828 do
12829   case "$ac_config_target" in
12830   # Handling of arguments.
12831   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12832   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12833 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12834    { (exit 1); exit 1; }; };;
12835   esac
12836 done
12837
12838 # If the user did not use the arguments to specify the items to instantiate,
12839 # then the envvar interface is used.  Set only those that are not.
12840 # We use the long form for the default assignment because of an extremely
12841 # bizarre bug on SunOS 4.1.3.
12842 if $ac_need_defaults; then
12843   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12844 fi
12845
12846 # Have a temporary directory for convenience.  Make it in the build tree
12847 # simply because there is no reason to put it here, and in addition,
12848 # creating and moving files from /tmp can sometimes cause problems.
12849 # Create a temporary directory, and hook for its removal unless debugging.
12850 $debug ||
12851 {
12852   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12853   trap '{ (exit 1); exit 1; }' 1 2 13 15
12854 }
12855
12856 # Create a (secure) tmp directory for tmp files.
12857
12858 {
12859   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12860   test -n "$tmp" && test -d "$tmp"
12861 }  ||
12862 {
12863   tmp=./confstat$$-$RANDOM
12864   (umask 077 && mkdir $tmp)
12865 } ||
12866 {
12867    echo "$me: cannot create a temporary directory in ." >&2
12868    { (exit 1); exit 1; }
12869 }
12870
12871 _ACEOF
12872
12873 cat >>$CONFIG_STATUS <<_ACEOF
12874
12875 #
12876 # CONFIG_FILES section.
12877 #
12878
12879 # No need to generate the scripts if there are no CONFIG_FILES.
12880 # This happens for instance when ./config.status config.h
12881 if test -n "\$CONFIG_FILES"; then
12882   # Protect against being on the right side of a sed subst in config.status.
12883   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12884    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12885 s,@SHELL@,$SHELL,;t t
12886 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12887 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12888 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12889 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12890 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12891 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12892 s,@exec_prefix@,$exec_prefix,;t t
12893 s,@prefix@,$prefix,;t t
12894 s,@program_transform_name@,$program_transform_name,;t t
12895 s,@bindir@,$bindir,;t t
12896 s,@sbindir@,$sbindir,;t t
12897 s,@libexecdir@,$libexecdir,;t t
12898 s,@datadir@,$datadir,;t t
12899 s,@sysconfdir@,$sysconfdir,;t t
12900 s,@sharedstatedir@,$sharedstatedir,;t t
12901 s,@localstatedir@,$localstatedir,;t t
12902 s,@libdir@,$libdir,;t t
12903 s,@includedir@,$includedir,;t t
12904 s,@oldincludedir@,$oldincludedir,;t t
12905 s,@infodir@,$infodir,;t t
12906 s,@mandir@,$mandir,;t t
12907 s,@build_alias@,$build_alias,;t t
12908 s,@host_alias@,$host_alias,;t t
12909 s,@target_alias@,$target_alias,;t t
12910 s,@DEFS@,$DEFS,;t t
12911 s,@ECHO_C@,$ECHO_C,;t t
12912 s,@ECHO_N@,$ECHO_N,;t t
12913 s,@ECHO_T@,$ECHO_T,;t t
12914 s,@LIBS@,$LIBS,;t t
12915 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12916 s,@build@,$build,;t t
12917 s,@build_cpu@,$build_cpu,;t t
12918 s,@build_vendor@,$build_vendor,;t t
12919 s,@build_os@,$build_os,;t t
12920 s,@build_noncanonical@,$build_noncanonical,;t t
12921 s,@host_noncanonical@,$host_noncanonical,;t t
12922 s,@target_noncanonical@,$target_noncanonical,;t t
12923 s,@host@,$host,;t t
12924 s,@host_cpu@,$host_cpu,;t t
12925 s,@host_vendor@,$host_vendor,;t t
12926 s,@host_os@,$host_os,;t t
12927 s,@target@,$target,;t t
12928 s,@target_cpu@,$target_cpu,;t t
12929 s,@target_vendor@,$target_vendor,;t t
12930 s,@target_os@,$target_os,;t t
12931 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12932 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12933 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12934 s,@LN@,$LN,;t t
12935 s,@LN_S@,$LN_S,;t t
12936 s,@build_libsubdir@,$build_libsubdir,;t t
12937 s,@build_subdir@,$build_subdir,;t t
12938 s,@host_subdir@,$host_subdir,;t t
12939 s,@target_subdir@,$target_subdir,;t t
12940 s,@CC@,$CC,;t t
12941 s,@CFLAGS@,$CFLAGS,;t t
12942 s,@LDFLAGS@,$LDFLAGS,;t t
12943 s,@CPPFLAGS@,$CPPFLAGS,;t t
12944 s,@ac_ct_CC@,$ac_ct_CC,;t t
12945 s,@EXEEXT@,$EXEEXT,;t t
12946 s,@OBJEXT@,$OBJEXT,;t t
12947 s,@CXX@,$CXX,;t t
12948 s,@CXXFLAGS@,$CXXFLAGS,;t t
12949 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12950 s,@GNATBIND@,$GNATBIND,;t t
12951 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12952 s,@GNATMAKE@,$GNATMAKE,;t t
12953 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12954 s,@do_compare@,$do_compare,;t t
12955 s,@gmplibs@,$gmplibs,;t t
12956 s,@gmpinc@,$gmpinc,;t t
12957 s,@stage1_languages@,$stage1_languages,;t t
12958 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12959 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12960 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
12961 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
12962 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12963 s,@tooldir@,$tooldir,;t t
12964 s,@build_tooldir@,$build_tooldir,;t t
12965 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12966 s,@GDB_TK@,$GDB_TK,;t t
12967 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12968 s,@build_configargs@,$build_configargs,;t t
12969 s,@build_configdirs@,$build_configdirs,;t t
12970 s,@host_configargs@,$host_configargs,;t t
12971 s,@configdirs@,$configdirs,;t t
12972 s,@target_configargs@,$target_configargs,;t t
12973 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
12974 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
12975 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12976 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12977 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
12978 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
12979 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
12980 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
12981 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
12982 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
12983 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
12984 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
12985 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
12986 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
12987 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
12988 s,@config_shell@,$config_shell,;t t
12989 s,@YACC@,$YACC,;t t
12990 s,@BISON@,$BISON,;t t
12991 s,@M4@,$M4,;t t
12992 s,@LEX@,$LEX,;t t
12993 s,@FLEX@,$FLEX,;t t
12994 s,@MAKEINFO@,$MAKEINFO,;t t
12995 s,@EXPECT@,$EXPECT,;t t
12996 s,@RUNTEST@,$RUNTEST,;t t
12997 s,@AR@,$AR,;t t
12998 s,@AS@,$AS,;t t
12999 s,@DLLTOOL@,$DLLTOOL,;t t
13000 s,@LD@,$LD,;t t
13001 s,@LIPO@,$LIPO,;t t
13002 s,@NM@,$NM,;t t
13003 s,@RANLIB@,$RANLIB,;t t
13004 s,@STRIP@,$STRIP,;t t
13005 s,@WINDRES@,$WINDRES,;t t
13006 s,@WINDMC@,$WINDMC,;t t
13007 s,@OBJCOPY@,$OBJCOPY,;t t
13008 s,@OBJDUMP@,$OBJDUMP,;t t
13009 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13010 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13011 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13012 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13013 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13014 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13015 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13016 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13017 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13018 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13019 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13020 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13021 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13022 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13023 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13024 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13025 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13026 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13027 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13028 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13029 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13030 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13031 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13032 s,@MAINT@,$MAINT,;t t
13033 s,@stage1_cflags@,$stage1_cflags,;t t
13034 s,@stage1_checking@,$stage1_checking,;t t
13035 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13036 s,@datarootdir@,$datarootdir,;t t
13037 s,@docdir@,$docdir,;t t
13038 s,@pdfdir@,$pdfdir,;t t
13039 s,@htmldir@,$htmldir,;t t
13040 s,@LIBOBJS@,$LIBOBJS,;t t
13041 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13042 /@serialization_dependencies@/r $serialization_dependencies
13043 s,@serialization_dependencies@,,;t t
13044 /@host_makefile_frag@/r $host_makefile_frag
13045 s,@host_makefile_frag@,,;t t
13046 /@target_makefile_frag@/r $target_makefile_frag
13047 s,@target_makefile_frag@,,;t t
13048 /@alphaieee_frag@/r $alphaieee_frag
13049 s,@alphaieee_frag@,,;t t
13050 /@ospace_frag@/r $ospace_frag
13051 s,@ospace_frag@,,;t t
13052 CEOF
13053
13054 _ACEOF
13055
13056   cat >>$CONFIG_STATUS <<\_ACEOF
13057   # Split the substitutions into bite-sized pieces for seds with
13058   # small command number limits, like on Digital OSF/1 and HP-UX.
13059   ac_max_sed_lines=48
13060   ac_sed_frag=1 # Number of current file.
13061   ac_beg=1 # First line for current file.
13062   ac_end=$ac_max_sed_lines # Line after last line for current file.
13063   ac_more_lines=:
13064   ac_sed_cmds=
13065   while $ac_more_lines; do
13066     if test $ac_beg -gt 1; then
13067       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13068     else
13069       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13070     fi
13071     if test ! -s $tmp/subs.frag; then
13072       ac_more_lines=false
13073     else
13074       # The purpose of the label and of the branching condition is to
13075       # speed up the sed processing (if there are no `@' at all, there
13076       # is no need to browse any of the substitutions).
13077       # These are the two extra sed commands mentioned above.
13078       (echo ':t
13079   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13080       if test -z "$ac_sed_cmds"; then
13081         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13082       else
13083         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13084       fi
13085       ac_sed_frag=`expr $ac_sed_frag + 1`
13086       ac_beg=$ac_end
13087       ac_end=`expr $ac_end + $ac_max_sed_lines`
13088     fi
13089   done
13090   if test -z "$ac_sed_cmds"; then
13091     ac_sed_cmds=cat
13092   fi
13093 fi # test -n "$CONFIG_FILES"
13094
13095 _ACEOF
13096 cat >>$CONFIG_STATUS <<\_ACEOF
13097 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13098   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13099   case $ac_file in
13100   - | *:- | *:-:* ) # input from stdin
13101         cat >$tmp/stdin
13102         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13103         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13104   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13105         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13106   * )   ac_file_in=$ac_file.in ;;
13107   esac
13108
13109   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13110   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13111 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13112          X"$ac_file" : 'X\(//\)[^/]' \| \
13113          X"$ac_file" : 'X\(//\)$' \| \
13114          X"$ac_file" : 'X\(/\)' \| \
13115          .     : '\(.\)' 2>/dev/null ||
13116 echo X"$ac_file" |
13117     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13118           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13119           /^X\(\/\/\)$/{ s//\1/; q; }
13120           /^X\(\/\).*/{ s//\1/; q; }
13121           s/.*/./; q'`
13122   { if $as_mkdir_p; then
13123     mkdir -p "$ac_dir"
13124   else
13125     as_dir="$ac_dir"
13126     as_dirs=
13127     while test ! -d "$as_dir"; do
13128       as_dirs="$as_dir $as_dirs"
13129       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13130 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13131          X"$as_dir" : 'X\(//\)[^/]' \| \
13132          X"$as_dir" : 'X\(//\)$' \| \
13133          X"$as_dir" : 'X\(/\)' \| \
13134          .     : '\(.\)' 2>/dev/null ||
13135 echo X"$as_dir" |
13136     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13137           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13138           /^X\(\/\/\)$/{ s//\1/; q; }
13139           /^X\(\/\).*/{ s//\1/; q; }
13140           s/.*/./; q'`
13141     done
13142     test ! -n "$as_dirs" || mkdir $as_dirs
13143   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13144 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13145    { (exit 1); exit 1; }; }; }
13146
13147   ac_builddir=.
13148
13149 if test "$ac_dir" != .; then
13150   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13151   # A "../" for each directory in $ac_dir_suffix.
13152   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13153 else
13154   ac_dir_suffix= ac_top_builddir=
13155 fi
13156
13157 case $srcdir in
13158   .)  # No --srcdir option.  We are building in place.
13159     ac_srcdir=.
13160     if test -z "$ac_top_builddir"; then
13161        ac_top_srcdir=.
13162     else
13163        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13164     fi ;;
13165   [\\/]* | ?:[\\/]* )  # Absolute path.
13166     ac_srcdir=$srcdir$ac_dir_suffix;
13167     ac_top_srcdir=$srcdir ;;
13168   *) # Relative path.
13169     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13170     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13171 esac
13172
13173 # Do not use `cd foo && pwd` to compute absolute paths, because
13174 # the directories may not exist.
13175 case `pwd` in
13176 .) ac_abs_builddir="$ac_dir";;
13177 *)
13178   case "$ac_dir" in
13179   .) ac_abs_builddir=`pwd`;;
13180   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13181   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13182   esac;;
13183 esac
13184 case $ac_abs_builddir in
13185 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13186 *)
13187   case ${ac_top_builddir}. in
13188   .) ac_abs_top_builddir=$ac_abs_builddir;;
13189   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13190   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13191   esac;;
13192 esac
13193 case $ac_abs_builddir in
13194 .) ac_abs_srcdir=$ac_srcdir;;
13195 *)
13196   case $ac_srcdir in
13197   .) ac_abs_srcdir=$ac_abs_builddir;;
13198   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13199   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13200   esac;;
13201 esac
13202 case $ac_abs_builddir in
13203 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13204 *)
13205   case $ac_top_srcdir in
13206   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13207   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13208   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13209   esac;;
13210 esac
13211
13212
13213   case $INSTALL in
13214   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13215   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13216   esac
13217
13218   if test x"$ac_file" != x-; then
13219     { echo "$as_me:$LINENO: creating $ac_file" >&5
13220 echo "$as_me: creating $ac_file" >&6;}
13221     rm -f "$ac_file"
13222   fi
13223   # Let's still pretend it is `configure' which instantiates (i.e., don't
13224   # use $as_me), people would be surprised to read:
13225   #    /* config.h.  Generated by config.status.  */
13226   if test x"$ac_file" = x-; then
13227     configure_input=
13228   else
13229     configure_input="$ac_file.  "
13230   fi
13231   configure_input=$configure_input"Generated from `echo $ac_file_in |
13232                                      sed 's,.*/,,'` by configure."
13233
13234   # First look for the input files in the build tree, otherwise in the
13235   # src tree.
13236   ac_file_inputs=`IFS=:
13237     for f in $ac_file_in; do
13238       case $f in
13239       -) echo $tmp/stdin ;;
13240       [\\/$]*)
13241          # Absolute (can't be DOS-style, as IFS=:)
13242          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13243 echo "$as_me: error: cannot find input file: $f" >&2;}
13244    { (exit 1); exit 1; }; }
13245          echo "$f";;
13246       *) # Relative
13247          if test -f "$f"; then
13248            # Build tree
13249            echo "$f"
13250          elif test -f "$srcdir/$f"; then
13251            # Source tree
13252            echo "$srcdir/$f"
13253          else
13254            # /dev/null tree
13255            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13256 echo "$as_me: error: cannot find input file: $f" >&2;}
13257    { (exit 1); exit 1; }; }
13258          fi;;
13259       esac
13260     done` || { (exit 1); exit 1; }
13261 _ACEOF
13262 cat >>$CONFIG_STATUS <<_ACEOF
13263   sed "$ac_vpsub
13264 $extrasub
13265 _ACEOF
13266 cat >>$CONFIG_STATUS <<\_ACEOF
13267 :t
13268 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13269 s,@configure_input@,$configure_input,;t t
13270 s,@srcdir@,$ac_srcdir,;t t
13271 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13272 s,@top_srcdir@,$ac_top_srcdir,;t t
13273 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13274 s,@builddir@,$ac_builddir,;t t
13275 s,@abs_builddir@,$ac_abs_builddir,;t t
13276 s,@top_builddir@,$ac_top_builddir,;t t
13277 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13278 s,@INSTALL@,$ac_INSTALL,;t t
13279 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13280   rm -f $tmp/stdin
13281   if test x"$ac_file" != x-; then
13282     mv $tmp/out $ac_file
13283   else
13284     cat $tmp/out
13285     rm -f $tmp/out
13286   fi
13287
13288 done
13289 _ACEOF
13290
13291 cat >>$CONFIG_STATUS <<\_ACEOF
13292
13293 { (exit 0); exit 0; }
13294 _ACEOF
13295 chmod +x $CONFIG_STATUS
13296 ac_clean_files=$ac_clean_files_save
13297
13298
13299 # configure is writing to config.log, and then calls config.status.
13300 # config.status does its own redirection, appending to config.log.
13301 # Unfortunately, on DOS this fails, as config.log is still kept open
13302 # by configure, so config.status won't be able to write to it; its
13303 # output is simply discarded.  So we exec the FD to /dev/null,
13304 # effectively closing config.log, so it can be properly (re)opened and
13305 # appended to by config.status.  When coming back to configure, we
13306 # need to make the FD available again.
13307 if test "$no_create" != yes; then
13308   ac_cs_success=:
13309   ac_config_status_args=
13310   test "$silent" = yes &&
13311     ac_config_status_args="$ac_config_status_args --quiet"
13312   exec 5>/dev/null
13313   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13314   exec 5>>config.log
13315   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13316   # would make configure fail if this is the last instruction.
13317   $ac_cs_success || { (exit 1); exit 1; }
13318 fi
13319