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 ppllibs pplinc clooglibs clooginc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET RPATH_ENVVAR GCC_SHLIB_SUBDIR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277 ac_pwd=`pwd`
 278
 279 # Initialize some variables set by options.
 280 ac_init_help=
 281 ac_init_version=false
 282 # The variables have the same names as the options, with
 283 # dashes changed to underlines.
 284 cache_file=/dev/null
 285 exec_prefix=NONE
 286 no_create=
 287 no_recursion=
 288 prefix=NONE
 289 program_prefix=NONE
 290 program_suffix=NONE
 291 program_transform_name=s,x,x,
 292 silent=
 293 site=
 294 srcdir=
 295 verbose=
 296 x_includes=NONE
 297 x_libraries=NONE
 298
 299 # Installation directory options.
 300 # These are left unexpanded so users can "make install exec_prefix=/foo"
 301 # and all the variables that are supposed to be based on exec_prefix
 302 # by default will actually change.
 303 # Use braces instead of parens because sh, perl, etc. also accept them.
 304 bindir='${exec_prefix}/bin'
 305 sbindir='${exec_prefix}/sbin'
 306 libexecdir='${exec_prefix}/libexec'
 307 datadir='${prefix}/share'
 308 sysconfdir='${prefix}/etc'
 309 sharedstatedir='${prefix}/com'
 310 localstatedir='${prefix}/var'
 311 libdir='${exec_prefix}/lib'
 312 includedir='${prefix}/include'
 313 oldincludedir='/usr/include'
 314 infodir='${prefix}/info'
 315 mandir='${prefix}/man'
 316
 317 ac_prev=
 318 for ac_option
 319 do
 320   # If the previous option needs an argument, assign it.
 321   if test -n "$ac_prev"; then
 322     eval "$ac_prev=\$ac_option"
 323     ac_prev=
 324     continue
 325   fi
 326
 327   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 328
 329   # Accept the important Cygnus configure options, so we can diagnose typos.
 330
 331   case $ac_option in
 332
 333   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 334     ac_prev=bindir ;;
 335   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 336     bindir=$ac_optarg ;;
 337
 338   -build | --build | --buil | --bui | --bu)
 339     ac_prev=build_alias ;;
 340   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 341     build_alias=$ac_optarg ;;
 342
 343   -cache-file | --cache-file | --cache-fil | --cache-fi \
 344   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 345     ac_prev=cache_file ;;
 346   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 347   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 348     cache_file=$ac_optarg ;;
 349
 350   --config-cache | -C)
 351     cache_file=config.cache ;;
 352
 353   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 354     ac_prev=datadir ;;
 355   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 356   | --da=*)
 357     datadir=$ac_optarg ;;
 358
 359   -disable-* | --disable-*)
 360     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 361     # Reject names that are not valid shell variable names.
 362     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 363       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 364    { (exit 1); exit 1; }; }
 365     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 366     eval "enable_$ac_feature=no" ;;
 367
 368   -enable-* | --enable-*)
 369     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 370     # Reject names that are not valid shell variable names.
 371     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 372       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 373    { (exit 1); exit 1; }; }
 374     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 375     case $ac_option in
 376       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 377       *) ac_optarg=yes ;;
 378     esac
 379     eval "enable_$ac_feature='$ac_optarg'" ;;
 380
 381   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 382   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 383   | --exec | --exe | --ex)
 384     ac_prev=exec_prefix ;;
 385   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 386   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 387   | --exec=* | --exe=* | --ex=*)
 388     exec_prefix=$ac_optarg ;;
 389
 390   -gas | --gas | --ga | --g)
 391     # Obsolete; use --with-gas.
 392     with_gas=yes ;;
 393
 394   -help | --help | --hel | --he | -h)
 395     ac_init_help=long ;;
 396   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 397     ac_init_help=recursive ;;
 398   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 399     ac_init_help=short ;;
 400
 401   -host | --host | --hos | --ho)
 402     ac_prev=host_alias ;;
 403   -host=* | --host=* | --hos=* | --ho=*)
 404     host_alias=$ac_optarg ;;
 405
 406   -includedir | --includedir | --includedi | --included | --include \
 407   | --includ | --inclu | --incl | --inc)
 408     ac_prev=includedir ;;
 409   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 410   | --includ=* | --inclu=* | --incl=* | --inc=*)
 411     includedir=$ac_optarg ;;
 412
 413   -infodir | --infodir | --infodi | --infod | --info | --inf)
 414     ac_prev=infodir ;;
 415   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 416     infodir=$ac_optarg ;;
 417
 418   -libdir | --libdir | --libdi | --libd)
 419     ac_prev=libdir ;;
 420   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 421     libdir=$ac_optarg ;;
 422
 423   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 424   | --libexe | --libex | --libe)
 425     ac_prev=libexecdir ;;
 426   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 427   | --libexe=* | --libex=* | --libe=*)
 428     libexecdir=$ac_optarg ;;
 429
 430   -localstatedir | --localstatedir | --localstatedi | --localstated \
 431   | --localstate | --localstat | --localsta | --localst \
 432   | --locals | --local | --loca | --loc | --lo)
 433     ac_prev=localstatedir ;;
 434   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 435   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 436   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 437     localstatedir=$ac_optarg ;;
 438
 439   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 440     ac_prev=mandir ;;
 441   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 442     mandir=$ac_optarg ;;
 443
 444   -nfp | --nfp | --nf)
 445     # Obsolete; use --without-fp.
 446     with_fp=no ;;
 447
 448   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 449   | --no-cr | --no-c | -n)
 450     no_create=yes ;;
 451
 452   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 453   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 454     no_recursion=yes ;;
 455
 456   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 457   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 458   | --oldin | --oldi | --old | --ol | --o)
 459     ac_prev=oldincludedir ;;
 460   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 461   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 462   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 463     oldincludedir=$ac_optarg ;;
 464
 465   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 466     ac_prev=prefix ;;
 467   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 468     prefix=$ac_optarg ;;
 469
 470   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 471   | --program-pre | --program-pr | --program-p)
 472     ac_prev=program_prefix ;;
 473   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 474   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 475     program_prefix=$ac_optarg ;;
 476
 477   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 478   | --program-suf | --program-su | --program-s)
 479     ac_prev=program_suffix ;;
 480   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 481   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 482     program_suffix=$ac_optarg ;;
 483
 484   -program-transform-name | --program-transform-name \
 485   | --program-transform-nam | --program-transform-na \
 486   | --program-transform-n | --program-transform- \
 487   | --program-transform | --program-transfor \
 488   | --program-transfo | --program-transf \
 489   | --program-trans | --program-tran \
 490   | --progr-tra | --program-tr | --program-t)
 491     ac_prev=program_transform_name ;;
 492   -program-transform-name=* | --program-transform-name=* \
 493   | --program-transform-nam=* | --program-transform-na=* \
 494   | --program-transform-n=* | --program-transform-=* \
 495   | --program-transform=* | --program-transfor=* \
 496   | --program-transfo=* | --program-transf=* \
 497   | --program-trans=* | --program-tran=* \
 498   | --progr-tra=* | --program-tr=* | --program-t=*)
 499     program_transform_name=$ac_optarg ;;
 500
 501   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 502   | -silent | --silent | --silen | --sile | --sil)
 503     silent=yes ;;
 504
 505   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 506     ac_prev=sbindir ;;
 507   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 508   | --sbi=* | --sb=*)
 509     sbindir=$ac_optarg ;;
 510
 511   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 512   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 513   | --sharedst | --shareds | --shared | --share | --shar \
 514   | --sha | --sh)
 515     ac_prev=sharedstatedir ;;
 516   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 517   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 518   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 519   | --sha=* | --sh=*)
 520     sharedstatedir=$ac_optarg ;;
 521
 522   -site | --site | --sit)
 523     ac_prev=site ;;
 524   -site=* | --site=* | --sit=*)
 525     site=$ac_optarg ;;
 526
 527   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 528     ac_prev=srcdir ;;
 529   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 530     srcdir=$ac_optarg ;;
 531
 532   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 533   | --syscon | --sysco | --sysc | --sys | --sy)
 534     ac_prev=sysconfdir ;;
 535   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 536   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 537     sysconfdir=$ac_optarg ;;
 538
 539   -target | --target | --targe | --targ | --tar | --ta | --t)
 540     ac_prev=target_alias ;;
 541   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 542     target_alias=$ac_optarg ;;
 543
 544   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 545     verbose=yes ;;
 546
 547   -version | --version | --versio | --versi | --vers | -V)
 548     ac_init_version=: ;;
 549
 550   -with-* | --with-*)
 551     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 552     # Reject names that are not valid shell variable names.
 553     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 554       { echo "$as_me: error: invalid package name: $ac_package" >&2
 555    { (exit 1); exit 1; }; }
 556     ac_package=`echo $ac_package| sed 's/-/_/g'`
 557     case $ac_option in
 558       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 559       *) ac_optarg=yes ;;
 560     esac
 561     eval "with_$ac_package='$ac_optarg'" ;;
 562
 563   -without-* | --without-*)
 564     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 565     # Reject names that are not valid shell variable names.
 566     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 567       { echo "$as_me: error: invalid package name: $ac_package" >&2
 568    { (exit 1); exit 1; }; }
 569     ac_package=`echo $ac_package | sed 's/-/_/g'`
 570     eval "with_$ac_package=no" ;;
 571
 572   --x)
 573     # Obsolete; use --with-x.
 574     with_x=yes ;;
 575
 576   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 577   | --x-incl | --x-inc | --x-in | --x-i)
 578     ac_prev=x_includes ;;
 579   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 580   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 581     x_includes=$ac_optarg ;;
 582
 583   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 584   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 585     ac_prev=x_libraries ;;
 586   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 587   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 588     x_libraries=$ac_optarg ;;
 589
 590   -*) { echo "$as_me: error: unrecognized option: $ac_option
 591 Try \`$0 --help' for more information." >&2
 592    { (exit 1); exit 1; }; }
 593     ;;
 594
 595   *=*)
 596     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 597     # Reject names that are not valid shell variable names.
 598     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 599       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 600    { (exit 1); exit 1; }; }
 601     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 602     eval "$ac_envvar='$ac_optarg'"
 603     export $ac_envvar ;;
 604
 605   *)
 606     # FIXME: should be removed in autoconf 3.0.
 607     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 608     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 609       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 610     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 611     ;;
 612
 613   esac
 614 done
 615
 616 if test -n "$ac_prev"; then
 617   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 618   { echo "$as_me: error: missing argument to $ac_option" >&2
 619    { (exit 1); exit 1; }; }
 620 fi
 621
 622 # Be sure to have absolute paths.
 623 for ac_var in exec_prefix prefix
 624 do
 625   eval ac_val=$`echo $ac_var`
 626   case $ac_val in
 627     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 628     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 629    { (exit 1); exit 1; }; };;
 630   esac
 631 done
 632
 633 # Be sure to have absolute paths.
 634 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 635               localstatedir libdir includedir oldincludedir infodir mandir
 636 do
 637   eval ac_val=$`echo $ac_var`
 638   case $ac_val in
 639     [\\/$]* | ?:[\\/]* ) ;;
 640     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 641    { (exit 1); exit 1; }; };;
 642   esac
 643 done
 644
 645 # There might be people who depend on the old broken behavior: `$host'
 646 # used to hold the argument of --host etc.
 647 # FIXME: To remove some day.
 648 build=$build_alias
 649 host=$host_alias
 650 target=$target_alias
 651
 652 # FIXME: To remove some day.
 653 if test "x$host_alias" != x; then
 654   if test "x$build_alias" = x; then
 655     cross_compiling=maybe
 656     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 657     If a cross compiler is detected then cross compile mode will be used." >&2
 658   elif test "x$build_alias" != "x$host_alias"; then
 659     cross_compiling=yes
 660   fi
 661 fi
 662
 663 ac_tool_prefix=
 664 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 665
 666 test "$silent" = yes && exec 6>/dev/null
 667
 668
 669 # Find the source files, if location was not specified.
 670 if test -z "$srcdir"; then
 671   ac_srcdir_defaulted=yes
 672   # Try the directory containing this script, then its parent.
 673   ac_confdir=`(dirname "$0") 2>/dev/null ||
 674 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 675          X"$0" : 'X\(//\)[^/]' \| \
 676          X"$0" : 'X\(//\)$' \| \
 677          X"$0" : 'X\(/\)' \| \
 678          .     : '\(.\)' 2>/dev/null ||
 679 echo X"$0" |
 680     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 681           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 682           /^X\(\/\/\)$/{ s//\1/; q; }
 683           /^X\(\/\).*/{ s//\1/; q; }
 684           s/.*/./; q'`
 685   srcdir=$ac_confdir
 686   if test ! -r $srcdir/$ac_unique_file; then
 687     srcdir=..
 688   fi
 689 else
 690   ac_srcdir_defaulted=no
 691 fi
 692 if test ! -r $srcdir/$ac_unique_file; then
 693   if test "$ac_srcdir_defaulted" = yes; then
 694     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 695    { (exit 1); exit 1; }; }
 696   else
 697     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 698    { (exit 1); exit 1; }; }
 699   fi
 700 fi
 701 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 702   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 703    { (exit 1); exit 1; }; }
 704 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 705 ac_env_build_alias_set=${build_alias+set}
 706 ac_env_build_alias_value=$build_alias
 707 ac_cv_env_build_alias_set=${build_alias+set}
 708 ac_cv_env_build_alias_value=$build_alias
 709 ac_env_host_alias_set=${host_alias+set}
 710 ac_env_host_alias_value=$host_alias
 711 ac_cv_env_host_alias_set=${host_alias+set}
 712 ac_cv_env_host_alias_value=$host_alias
 713 ac_env_target_alias_set=${target_alias+set}
 714 ac_env_target_alias_value=$target_alias
 715 ac_cv_env_target_alias_set=${target_alias+set}
 716 ac_cv_env_target_alias_value=$target_alias
 717 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 718
 719 ac_env_CC_set=${CC+set}
 720 ac_env_CC_value=$CC
 721 ac_cv_env_CC_set=${CC+set}
 722 ac_cv_env_CC_value=$CC
 723 ac_env_CFLAGS_set=${CFLAGS+set}
 724 ac_env_CFLAGS_value=$CFLAGS
 725 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 726 ac_cv_env_CFLAGS_value=$CFLAGS
 727 ac_env_LDFLAGS_set=${LDFLAGS+set}
 728 ac_env_LDFLAGS_value=$LDFLAGS
 729 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 730 ac_cv_env_LDFLAGS_value=$LDFLAGS
 731 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 732 ac_env_CPPFLAGS_value=$CPPFLAGS
 733 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 734 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 735 ac_env_CXX_set=${CXX+set}
 736 ac_env_CXX_value=$CXX
 737 ac_cv_env_CXX_set=${CXX+set}
 738 ac_cv_env_CXX_value=$CXX
 739 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 740 ac_env_CXXFLAGS_value=$CXXFLAGS
 741 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 742 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 743 ac_env_AR_set=${AR+set}
 744 ac_env_AR_value=$AR
 745 ac_cv_env_AR_set=${AR+set}
 746 ac_cv_env_AR_value=$AR
 747 ac_env_AS_set=${AS+set}
 748 ac_env_AS_value=$AS
 749 ac_cv_env_AS_set=${AS+set}
 750 ac_cv_env_AS_value=$AS
 751 ac_env_DLLTOOL_set=${DLLTOOL+set}
 752 ac_env_DLLTOOL_value=$DLLTOOL
 753 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 754 ac_cv_env_DLLTOOL_value=$DLLTOOL
 755 ac_env_LD_set=${LD+set}
 756 ac_env_LD_value=$LD
 757 ac_cv_env_LD_set=${LD+set}
 758 ac_cv_env_LD_value=$LD
 759 ac_env_LIPO_set=${LIPO+set}
 760 ac_env_LIPO_value=$LIPO
 761 ac_cv_env_LIPO_set=${LIPO+set}
 762 ac_cv_env_LIPO_value=$LIPO
 763 ac_env_NM_set=${NM+set}
 764 ac_env_NM_value=$NM
 765 ac_cv_env_NM_set=${NM+set}
 766 ac_cv_env_NM_value=$NM
 767 ac_env_RANLIB_set=${RANLIB+set}
 768 ac_env_RANLIB_value=$RANLIB
 769 ac_cv_env_RANLIB_set=${RANLIB+set}
 770 ac_cv_env_RANLIB_value=$RANLIB
 771 ac_env_STRIP_set=${STRIP+set}
 772 ac_env_STRIP_value=$STRIP
 773 ac_cv_env_STRIP_set=${STRIP+set}
 774 ac_cv_env_STRIP_value=$STRIP
 775 ac_env_WINDRES_set=${WINDRES+set}
 776 ac_env_WINDRES_value=$WINDRES
 777 ac_cv_env_WINDRES_set=${WINDRES+set}
 778 ac_cv_env_WINDRES_value=$WINDRES
 779 ac_env_WINDMC_set=${WINDMC+set}
 780 ac_env_WINDMC_value=$WINDMC
 781 ac_cv_env_WINDMC_set=${WINDMC+set}
 782 ac_cv_env_WINDMC_value=$WINDMC
 783 ac_env_OBJCOPY_set=${OBJCOPY+set}
 784 ac_env_OBJCOPY_value=$OBJCOPY
 785 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 786 ac_cv_env_OBJCOPY_value=$OBJCOPY
 787 ac_env_OBJDUMP_set=${OBJDUMP+set}
 788 ac_env_OBJDUMP_value=$OBJDUMP
 789 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 790 ac_cv_env_OBJDUMP_value=$OBJDUMP
 791 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 792 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 793 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 794 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 795 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 796 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 797 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 798 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 799 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 800 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 801 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 802 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 803 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 804 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 805 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 806 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 807 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 808 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 809 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 810 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 811 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 812 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 813 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 814 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 815 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 816 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 817 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 818 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 819 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 820 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 821 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 822 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 823 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 824 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 825 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 826 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 827 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 828 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 829 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 830 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 831 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 832 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 833 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 834 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 835 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 836 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 837 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 838 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 839 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 840 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 841 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 842 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 843 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 844 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 845 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 846 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 847 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 848 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 849 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 850 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 851 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 852 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 853 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 854 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 855
 856 #
 857 # Report the --help message.
 858 #
 859 if test "$ac_init_help" = "long"; then
 860   # Omit some internal or obsolete options to make the list less imposing.
 861   # This message is too long to be a string in the A/UX 3.1 sh.
 862   cat <<_ACEOF
 863 \`configure' configures this package to adapt to many kinds of systems.
 864
 865 Usage: $0 [OPTION]... [VAR=VALUE]...
 866
 867 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 868 VAR=VALUE.  See below for descriptions of some of the useful variables.
 869
 870 Defaults for the options are specified in brackets.
 871
 872 Configuration:
 873   -h, --help              display this help and exit
 874       --help=short        display options specific to this package
 875       --help=recursive    display the short help of all the included packages
 876   -V, --version           display version information and exit
 877   -q, --quiet, --silent   do not print \`checking...' messages
 878       --cache-file=FILE   cache test results in FILE [disabled]
 879   -C, --config-cache      alias for \`--cache-file=config.cache'
 880   -n, --no-create         do not create output files
 881       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 882
 883 _ACEOF
 884
 885   cat <<_ACEOF
 886 Installation directories:
 887   --prefix=PREFIX         install architecture-independent files in PREFIX
 888                           [$ac_default_prefix]
 889   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 890                           [PREFIX]
 891
 892 By default, \`make install' will install all the files in
 893 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 894 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 895 for instance \`--prefix=\$HOME'.
 896
 897 For better control, use the options below.
 898
 899 Fine tuning of the installation directories:
 900   --bindir=DIR           user executables [EPREFIX/bin]
 901   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 902   --libexecdir=DIR       program executables [EPREFIX/libexec]
 903   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 904   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 905   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 906   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 907   --libdir=DIR           object code libraries [EPREFIX/lib]
 908   --includedir=DIR       C header files [PREFIX/include]
 909   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 910   --infodir=DIR          info documentation [PREFIX/info]
 911   --mandir=DIR           man documentation [PREFIX/man]
 912 _ACEOF
 913
 914   cat <<\_ACEOF
 915
 916 Program names:
 917   --program-prefix=PREFIX            prepend PREFIX to installed program names
 918   --program-suffix=SUFFIX            append SUFFIX to installed program names
 919   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 920
 921 System types:
 922   --build=BUILD     configure for building on BUILD [guessed]
 923   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 924   --target=TARGET   configure for building compilers for TARGET [HOST]
 925 _ACEOF
 926 fi
 927
 928 if test -n "$ac_init_help"; then
 929
 930   cat <<\_ACEOF
 931
 932 Optional Features:
 933   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 934   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 935   --enable-gold           use gold instead of ld
 936   --enable-libada         build libada directory
 937   --enable-libssp         build libssp directory
 938   --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-ppl=PATH         Specify prefix directory for the installed PPL package
 971                           Equivalent to --with-ppl-include=PATH/include
 972                           plus --with-ppl-lib=PATH/lib
 973   --with-ppl-include=PATH Specify directory for installed PPL include files
 974   --with-ppl-lib=PATH     Specify the directory for the installed PPL library
 975   --with-cloog=PATH         Specify prefix directory for the installed CLOOG package
 976                           Equivalent to --with-cloog-include=PATH/include
 977                           plus --with-cloog-lib=PATH/lib
 978   --with-cloog-include=PATH Specify directory for installed CLOOG include files
 979   --with-cloog-lib=PATH     Specify the directory for the installed CLOOG library
 980   --with-build-sysroot=SYSROOT
 981                           use sysroot as the system root during the build
 982   --with-debug-prefix-map='A=B C=D ...'
 983                              map A to B, C to D ... in debug information
 984   --with-build-time-tools=PATH
 985                           use given path to find target tools during the build
 986   --with-datarootdir      use datarootdir as the data root directory.
 987   --with-docdir           install documentation in this directory.
 988   --with-pdfdir           install pdf in this directory.
 989   --with-htmldir          install html in this directory.
 990
 991 Some influential environment variables:
 992   CC          C compiler command
 993   CFLAGS      C compiler flags
 994   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 995               nonstandard directory <lib dir>
 996   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 997               headers in a nonstandard directory <include dir>
 998   CXX         C++ compiler command
 999   CXXFLAGS    C++ compiler flags
1000   AR          AR for the host
1001   AS          AS for the host
1002   DLLTOOL     DLLTOOL for the host
1003   LD          LD for the host
1004   LIPO        LIPO for the host
1005   NM          NM for the host
1006   RANLIB      RANLIB for the host
1007   STRIP       STRIP for the host
1008   WINDRES     WINDRES for the host
1009   WINDMC      WINDMC for the host
1010   OBJCOPY     OBJCOPY for the host
1011   OBJDUMP     OBJDUMP for the host
1012   CC_FOR_TARGET
1013               CC for the target
1014   CXX_FOR_TARGET
1015               CXX for the target
1016   GCC_FOR_TARGET
1017               GCC for the target
1018   GCJ_FOR_TARGET
1019               GCJ for the target
1020   GFORTRAN_FOR_TARGET
1021               GFORTRAN for the target
1022   AR_FOR_TARGET
1023               AR for the target
1024   AS_FOR_TARGET
1025               AS for the target
1026   DLLTOOL_FOR_TARGET
1027               DLLTOOL for the target
1028   LD_FOR_TARGET
1029               LD for the target
1030   LIPO_FOR_TARGET
1031               LIPO for the target
1032   NM_FOR_TARGET
1033               NM for the target
1034   OBJDUMP_FOR_TARGET
1035               OBJDUMP for the target
1036   RANLIB_FOR_TARGET
1037               RANLIB for the target
1038   STRIP_FOR_TARGET
1039               STRIP for the target
1040   WINDRES_FOR_TARGET
1041               WINDRES for the target
1042   WINDMC_FOR_TARGET
1043               WINDMC for the target
1044
1045 Use these variables to override the choices made by `configure' or to help
1046 it to find libraries and programs with nonstandard names/locations.
1047
1048 _ACEOF
1049 fi
1050
1051 if test "$ac_init_help" = "recursive"; then
1052   # If there are subdirs, report their specific --help.
1053   ac_popdir=`pwd`
1054   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1055     test -d $ac_dir || continue
1056     ac_builddir=.
1057
1058 if test "$ac_dir" != .; then
1059   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1060   # A "../" for each directory in $ac_dir_suffix.
1061   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1062 else
1063   ac_dir_suffix= ac_top_builddir=
1064 fi
1065
1066 case $srcdir in
1067   .)  # No --srcdir option.  We are building in place.
1068     ac_srcdir=.
1069     if test -z "$ac_top_builddir"; then
1070        ac_top_srcdir=.
1071     else
1072        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1073     fi ;;
1074   [\\/]* | ?:[\\/]* )  # Absolute path.
1075     ac_srcdir=$srcdir$ac_dir_suffix;
1076     ac_top_srcdir=$srcdir ;;
1077   *) # Relative path.
1078     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1079     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1080 esac
1081
1082 # Do not use `cd foo && pwd` to compute absolute paths, because
1083 # the directories may not exist.
1084 case `pwd` in
1085 .) ac_abs_builddir="$ac_dir";;
1086 *)
1087   case "$ac_dir" in
1088   .) ac_abs_builddir=`pwd`;;
1089   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1090   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1091   esac;;
1092 esac
1093 case $ac_abs_builddir in
1094 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1095 *)
1096   case ${ac_top_builddir}. in
1097   .) ac_abs_top_builddir=$ac_abs_builddir;;
1098   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1099   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1100   esac;;
1101 esac
1102 case $ac_abs_builddir in
1103 .) ac_abs_srcdir=$ac_srcdir;;
1104 *)
1105   case $ac_srcdir in
1106   .) ac_abs_srcdir=$ac_abs_builddir;;
1107   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1108   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1109   esac;;
1110 esac
1111 case $ac_abs_builddir in
1112 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1113 *)
1114   case $ac_top_srcdir in
1115   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1116   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1117   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1118   esac;;
1119 esac
1120
1121     cd $ac_dir
1122     # Check for guested configure; otherwise get Cygnus style configure.
1123     if test -f $ac_srcdir/configure.gnu; then
1124       echo
1125       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1126     elif test -f $ac_srcdir/configure; then
1127       echo
1128       $SHELL $ac_srcdir/configure  --help=recursive
1129     elif test -f $ac_srcdir/configure.ac ||
1130            test -f $ac_srcdir/configure.in; then
1131       echo
1132       $ac_configure --help
1133     else
1134       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1135     fi
1136     cd $ac_popdir
1137   done
1138 fi
1139
1140 test -n "$ac_init_help" && exit 0
1141 if $ac_init_version; then
1142   cat <<\_ACEOF
1143
1144 Copyright (C) 2003 Free Software Foundation, Inc.
1145 This configure script is free software; the Free Software Foundation
1146 gives unlimited permission to copy, distribute and modify it.
1147 _ACEOF
1148   exit 0
1149 fi
1150 exec 5>config.log
1151 cat >&5 <<_ACEOF
1152 This file contains any messages produced by compilers while
1153 running configure, to aid debugging if configure makes a mistake.
1154
1155 It was created by $as_me, which was
1156 generated by GNU Autoconf 2.59.  Invocation command line was
1157
1158   $ $0 $@
1159
1160 _ACEOF
1161 {
1162 cat <<_ASUNAME
1163 ## --------- ##
1164 ## Platform. ##
1165 ## --------- ##
1166
1167 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1168 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1169 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1170 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1171 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1172
1173 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1174 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1175
1176 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1177 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1178 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1179 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1180 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1181 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1182 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1183
1184 _ASUNAME
1185
1186 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1187 for as_dir in $PATH
1188 do
1189   IFS=$as_save_IFS
1190   test -z "$as_dir" && as_dir=.
1191   echo "PATH: $as_dir"
1192 done
1193
1194 } >&5
1195
1196 cat >&5 <<_ACEOF
1197
1198
1199 ## ----------- ##
1200 ## Core tests. ##
1201 ## ----------- ##
1202
1203 _ACEOF
1204
1205
1206 # Keep a trace of the command line.
1207 # Strip out --no-create and --no-recursion so they do not pile up.
1208 # Strip out --silent because we don't want to record it for future runs.
1209 # Also quote any args containing shell meta-characters.
1210 # Make two passes to allow for proper duplicate-argument suppression.
1211 ac_configure_args=
1212 ac_configure_args0=
1213 ac_configure_args1=
1214 ac_sep=
1215 ac_must_keep_next=false
1216 for ac_pass in 1 2
1217 do
1218   for ac_arg
1219   do
1220     case $ac_arg in
1221     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1222     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1223     | -silent | --silent | --silen | --sile | --sil)
1224       continue ;;
1225     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1226       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1227     esac
1228     case $ac_pass in
1229     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1230     2)
1231       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1232       if test $ac_must_keep_next = true; then
1233         ac_must_keep_next=false # Got value, back to normal.
1234       else
1235         case $ac_arg in
1236           *=* | --config-cache | -C | -disable-* | --disable-* \
1237           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1238           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1239           | -with-* | --with-* | -without-* | --without-* | --x)
1240             case "$ac_configure_args0 " in
1241               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1242             esac
1243             ;;
1244           -* ) ac_must_keep_next=true ;;
1245         esac
1246       fi
1247       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1248       # Get rid of the leading space.
1249       ac_sep=" "
1250       ;;
1251     esac
1252   done
1253 done
1254 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1255 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1256
1257 # When interrupted or exit'd, cleanup temporary files, and complete
1258 # config.log.  We remove comments because anyway the quotes in there
1259 # would cause problems or look ugly.
1260 # WARNING: Be sure not to use single quotes in there, as some shells,
1261 # such as our DU 5.0 friend, will then `close' the trap.
1262 trap 'exit_status=$?
1263   # Save into config.log some information that might help in debugging.
1264   {
1265     echo
1266
1267     cat <<\_ASBOX
1268 ## ---------------- ##
1269 ## Cache variables. ##
1270 ## ---------------- ##
1271 _ASBOX
1272     echo
1273     # The following way of writing the cache mishandles newlines in values,
1274 {
1275   (set) 2>&1 |
1276     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1277     *ac_space=\ *)
1278       sed -n \
1279         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1280           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1281       ;;
1282     *)
1283       sed -n \
1284         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1285       ;;
1286     esac;
1287 }
1288     echo
1289
1290     cat <<\_ASBOX
1291 ## ----------------- ##
1292 ## Output variables. ##
1293 ## ----------------- ##
1294 _ASBOX
1295     echo
1296     for ac_var in $ac_subst_vars
1297     do
1298       eval ac_val=$`echo $ac_var`
1299       echo "$ac_var='"'"'$ac_val'"'"'"
1300     done | sort
1301     echo
1302
1303     if test -n "$ac_subst_files"; then
1304       cat <<\_ASBOX
1305 ## ------------- ##
1306 ## Output files. ##
1307 ## ------------- ##
1308 _ASBOX
1309       echo
1310       for ac_var in $ac_subst_files
1311       do
1312         eval ac_val=$`echo $ac_var`
1313         echo "$ac_var='"'"'$ac_val'"'"'"
1314       done | sort
1315       echo
1316     fi
1317
1318     if test -s confdefs.h; then
1319       cat <<\_ASBOX
1320 ## ----------- ##
1321 ## confdefs.h. ##
1322 ## ----------- ##
1323 _ASBOX
1324       echo
1325       sed "/^$/d" confdefs.h | sort
1326       echo
1327     fi
1328     test "$ac_signal" != 0 &&
1329       echo "$as_me: caught signal $ac_signal"
1330     echo "$as_me: exit $exit_status"
1331   } >&5
1332   rm -f core *.core &&
1333   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1334     exit $exit_status
1335      ' 0
1336 for ac_signal in 1 2 13 15; do
1337   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1338 done
1339 ac_signal=0
1340
1341 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1342 rm -rf conftest* confdefs.h
1343 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1344 echo >confdefs.h
1345
1346 # Predefined preprocessor variables.
1347
1348 cat >>confdefs.h <<_ACEOF
1349 #define PACKAGE_NAME "$PACKAGE_NAME"
1350 _ACEOF
1351
1352
1353 cat >>confdefs.h <<_ACEOF
1354 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1355 _ACEOF
1356
1357
1358 cat >>confdefs.h <<_ACEOF
1359 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1360 _ACEOF
1361
1362
1363 cat >>confdefs.h <<_ACEOF
1364 #define PACKAGE_STRING "$PACKAGE_STRING"
1365 _ACEOF
1366
1367
1368 cat >>confdefs.h <<_ACEOF
1369 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1370 _ACEOF
1371
1372
1373 # Let the site file select an alternate cache file if it wants to.
1374 # Prefer explicitly selected file to automatically selected ones.
1375 if test -z "$CONFIG_SITE"; then
1376   if test "x$prefix" != xNONE; then
1377     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1378   else
1379     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1380   fi
1381 fi
1382 for ac_site_file in $CONFIG_SITE; do
1383   if test -r "$ac_site_file"; then
1384     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1385 echo "$as_me: loading site script $ac_site_file" >&6;}
1386     sed 's/^/| /' "$ac_site_file" >&5
1387     . "$ac_site_file"
1388   fi
1389 done
1390
1391 if test -r "$cache_file"; then
1392   # Some versions of bash will fail to source /dev/null (special
1393   # files actually), so we avoid doing that.
1394   if test -f "$cache_file"; then
1395     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1396 echo "$as_me: loading cache $cache_file" >&6;}
1397     case $cache_file in
1398       [\\/]* | ?:[\\/]* ) . $cache_file;;
1399       *)                      . ./$cache_file;;
1400     esac
1401   fi
1402 else
1403   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1404 echo "$as_me: creating cache $cache_file" >&6;}
1405   >$cache_file
1406 fi
1407
1408 # Check that the precious variables saved in the cache have kept the same
1409 # value.
1410 ac_cache_corrupted=false
1411 for ac_var in `(set) 2>&1 |
1412                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1413   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1414   eval ac_new_set=\$ac_env_${ac_var}_set
1415   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1416   eval ac_new_val="\$ac_env_${ac_var}_value"
1417   case $ac_old_set,$ac_new_set in
1418     set,)
1419       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1420 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1421       ac_cache_corrupted=: ;;
1422     ,set)
1423       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1424 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1425       ac_cache_corrupted=: ;;
1426     ,);;
1427     *)
1428       if test "x$ac_old_val" != "x$ac_new_val"; then
1429         # differences in whitespace do not lead to failure.
1430         ac_old_val_w=`echo x $ac_old_val`
1431         ac_new_val_w=`echo x $ac_new_val`
1432         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1433           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1434 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1435           ac_cache_corrupted=:
1436         else
1437           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1438 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1439           eval $ac_var=\$ac_old_val
1440         fi
1441         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1442 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1443         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1444 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1445       fi;;
1446   esac
1447   # Pass precious variables to config.status.
1448   if test "$ac_new_set" = set; then
1449     case $ac_new_val in
1450     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1451       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1452     *) ac_arg=$ac_var=$ac_new_val ;;
1453     esac
1454     case " $ac_configure_args " in
1455       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1456       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1457     esac
1458   fi
1459 done
1460 if $ac_cache_corrupted; then
1461   { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1462 echo "$as_me: error: in \`$ac_pwd':" >&2;}
1463   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1464 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1465   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1466 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1467    { (exit 1); exit 1; }; }
1468 fi
1469
1470 ac_ext=c
1471 ac_cpp='$CPP $CPPFLAGS'
1472 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1473 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1474 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499 progname=$0
1500 # if PWD already has a value, it is probably wrong.
1501 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1502
1503 # Export original configure arguments for use by sub-configures.
1504 # Quote arguments with shell meta charatcers.
1505 TOPLEVEL_CONFIGURE_ARGUMENTS=
1506 set -- "$progname" "$@"
1507 for ac_arg
1508 do
1509   case "$ac_arg" in
1510   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1511     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1512     # if the argument is of the form -foo=baz, quote the baz part only
1513     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1514   *) ;;
1515   esac
1516   # Add the quoted argument to the list.
1517   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1518 done
1519 if test "$silent" = yes; then
1520   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1521 fi
1522 # Remove the initial space we just introduced and, as these will be
1523 # expanded by make, quote '$'.
1524 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1525
1526
1527 # Find the build, host, and target systems.
1528 ac_aux_dir=
1529 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1530   if test -f $ac_dir/install-sh; then
1531     ac_aux_dir=$ac_dir
1532     ac_install_sh="$ac_aux_dir/install-sh -c"
1533     break
1534   elif test -f $ac_dir/install.sh; then
1535     ac_aux_dir=$ac_dir
1536     ac_install_sh="$ac_aux_dir/install.sh -c"
1537     break
1538   elif test -f $ac_dir/shtool; then
1539     ac_aux_dir=$ac_dir
1540     ac_install_sh="$ac_aux_dir/shtool install -c"
1541     break
1542   fi
1543 done
1544 if test -z "$ac_aux_dir"; then
1545   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1546 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1547    { (exit 1); exit 1; }; }
1548 fi
1549 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1550 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1551 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1552
1553 # Make sure we can run config.sub.
1554 $ac_config_sub sun4 >/dev/null 2>&1 ||
1555   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1556 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1557    { (exit 1); exit 1; }; }
1558
1559 echo "$as_me:$LINENO: checking build system type" >&5
1560 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1561 if test "${ac_cv_build+set}" = set; then
1562   echo $ECHO_N "(cached) $ECHO_C" >&6
1563 else
1564   ac_cv_build_alias=$build_alias
1565 test -z "$ac_cv_build_alias" &&
1566   ac_cv_build_alias=`$ac_config_guess`
1567 test -z "$ac_cv_build_alias" &&
1568   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1569 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1570    { (exit 1); exit 1; }; }
1571 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1572   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1573 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1574    { (exit 1); exit 1; }; }
1575
1576 fi
1577 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1578 echo "${ECHO_T}$ac_cv_build" >&6
1579 build=$ac_cv_build
1580 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1581 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1582 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1583
1584
1585  case ${build_alias} in
1586   "") build_noncanonical=${build} ;;
1587   *) build_noncanonical=${build_alias} ;;
1588 esac
1589
1590
1591
1592  case ${host_alias} in
1593   "") host_noncanonical=${build_noncanonical} ;;
1594   *) host_noncanonical=${host_alias} ;;
1595 esac
1596
1597
1598
1599  case ${target_alias} in
1600   "") target_noncanonical=${host_noncanonical} ;;
1601   *) target_noncanonical=${target_alias} ;;
1602 esac
1603
1604
1605
1606
1607 test "$host_noncanonical" = "$target_noncanonical" &&
1608   test "$program_prefix$program_suffix$program_transform_name" = \
1609     NONENONEs,x,x, &&
1610   program_transform_name=s,y,y,
1611
1612 echo "$as_me:$LINENO: checking host system type" >&5
1613 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1614 if test "${ac_cv_host+set}" = set; then
1615   echo $ECHO_N "(cached) $ECHO_C" >&6
1616 else
1617   ac_cv_host_alias=$host_alias
1618 test -z "$ac_cv_host_alias" &&
1619   ac_cv_host_alias=$ac_cv_build_alias
1620 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1621   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1622 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1623    { (exit 1); exit 1; }; }
1624
1625 fi
1626 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1627 echo "${ECHO_T}$ac_cv_host" >&6
1628 host=$ac_cv_host
1629 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1630 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1631 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1632
1633
1634 echo "$as_me:$LINENO: checking target system type" >&5
1635 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1636 if test "${ac_cv_target+set}" = set; then
1637   echo $ECHO_N "(cached) $ECHO_C" >&6
1638 else
1639   ac_cv_target_alias=$target_alias
1640 test "x$ac_cv_target_alias" = "x" &&
1641   ac_cv_target_alias=$ac_cv_host_alias
1642 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1643   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1644 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1645    { (exit 1); exit 1; }; }
1646
1647 fi
1648 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1649 echo "${ECHO_T}$ac_cv_target" >&6
1650 target=$ac_cv_target
1651 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1652 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1653 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1654
1655
1656 # The aliases save the names the user supplied, while $host etc.
1657 # will get canonicalized.
1658 test -n "$target_alias" &&
1659   test "$program_prefix$program_suffix$program_transform_name" = \
1660     NONENONEs,x,x, &&
1661   program_prefix=${target_alias}-
1662 test "$program_prefix" != NONE &&
1663   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1664 # Use a double $ so make ignores it.
1665 test "$program_suffix" != NONE &&
1666   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1667 # Double any \ or $.  echo might interpret backslashes.
1668 # By default was `s,x,x', remove it if useless.
1669 cat <<\_ACEOF >conftest.sed
1670 s/[\\$]/&&/g;s/;s,x,x,$//
1671 _ACEOF
1672 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1673 rm conftest.sed
1674
1675
1676
1677 # Get 'install' or 'install-sh' and its variants.
1678 # Find a good install program.  We prefer a C program (faster),
1679 # so one script is as good as another.  But avoid the broken or
1680 # incompatible versions:
1681 # SysV /etc/install, /usr/sbin/install
1682 # SunOS /usr/etc/install
1683 # IRIX /sbin/install
1684 # AIX /bin/install
1685 # AmigaOS /C/install, which installs bootblocks on floppy discs
1686 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1687 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1688 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1689 # OS/2's system install, which has a completely different semantic
1690 # ./install, which can be erroneously created by make from ./install.sh.
1691 # Reject install programs that cannot install multiple files.
1692 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1693 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1694 if test -z "$INSTALL"; then
1695 if test "${ac_cv_path_install+set}" = set; then
1696   echo $ECHO_N "(cached) $ECHO_C" >&6
1697 else
1698   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1699 for as_dir in $PATH
1700 do
1701   IFS=$as_save_IFS
1702   test -z "$as_dir" && as_dir=.
1703   # Account for people who put trailing slashes in PATH elements.
1704 case $as_dir/ in
1705   ./ | .// | /cC/* | \
1706   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1707   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1708   /usr/ucb/* ) ;;
1709   *)
1710     # OSF1 and SCO ODT 3.0 have their own names for install.
1711     # Don't use installbsd from OSF since it installs stuff as root
1712     # by default.
1713     for ac_prog in ginstall scoinst install; do
1714       for ac_exec_ext in '' $ac_executable_extensions; do
1715         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1716           if test $ac_prog = install &&
1717             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1718             # AIX install.  It has an incompatible calling convention.
1719             :
1720           elif test $ac_prog = install &&
1721             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1722             # program-specific install script used by HP pwplus--don't use.
1723             :
1724           else
1725             rm -rf conftest.one conftest.two conftest.dir
1726             echo one > conftest.one
1727             echo two > conftest.two
1728             mkdir conftest.dir
1729             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1730               test -s conftest.one && test -s conftest.two &&
1731               test -s conftest.dir/conftest.one &&
1732               test -s conftest.dir/conftest.two
1733             then
1734               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1735               break 3
1736             fi
1737           fi
1738         fi
1739       done
1740     done
1741     ;;
1742 esac
1743 done
1744
1745 rm -rf conftest.one conftest.two conftest.dir
1746
1747 fi
1748   if test "${ac_cv_path_install+set}" = set; then
1749     INSTALL=$ac_cv_path_install
1750   else
1751     # As a last resort, use the slow shell script.  Don't cache a
1752     # value for INSTALL within a source directory, because that will
1753     # break other packages using the cache if that directory is
1754     # removed, or if the value is a relative name.
1755     INSTALL=$ac_install_sh
1756   fi
1757 fi
1758 echo "$as_me:$LINENO: result: $INSTALL" >&5
1759 echo "${ECHO_T}$INSTALL" >&6
1760
1761 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1762 # It thinks the first close brace ends the variable substitution.
1763 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1764
1765 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1766
1767 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1768
1769 echo "$as_me:$LINENO: checking whether ln works" >&5
1770 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1771 if test "${acx_cv_prog_LN+set}" = set; then
1772   echo $ECHO_N "(cached) $ECHO_C" >&6
1773 else
1774   rm -f conftestdata_t
1775 echo >conftestdata_f
1776 if ln conftestdata_f conftestdata_t 2>/dev/null
1777 then
1778   acx_cv_prog_LN=ln
1779 else
1780   acx_cv_prog_LN=no
1781 fi
1782 rm -f conftestdata_f conftestdata_t
1783
1784 fi
1785 if test $acx_cv_prog_LN = no; then
1786   LN="cp"
1787   echo "$as_me:$LINENO: result: no, using $LN" >&5
1788 echo "${ECHO_T}no, using $LN" >&6
1789 else
1790   LN="$acx_cv_prog_LN"
1791   echo "$as_me:$LINENO: result: yes" >&5
1792 echo "${ECHO_T}yes" >&6
1793 fi
1794
1795 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1796 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1797 LN_S=$as_ln_s
1798 if test "$LN_S" = "ln -s"; then
1799   echo "$as_me:$LINENO: result: yes" >&5
1800 echo "${ECHO_T}yes" >&6
1801 else
1802   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1803 echo "${ECHO_T}no, using $LN_S" >&6
1804 fi
1805
1806
1807 ### we might need to use some other shell than /bin/sh for running subshells
1808 ### If we are on Windows, search for the shell.  This will permit people
1809 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1810 ### without also having to set CONFIG_SHELL.  This code will work when
1811 ### using bash, which sets OSTYPE.
1812 case "${OSTYPE}" in
1813 *win32*)
1814   if test x${CONFIG_SHELL} = x ; then
1815     if test ! -f /bin/sh ; then
1816       if test x${SHELL} != x && test -f ${SHELL} ; then
1817         CONFIG_SHELL=${SHELL}
1818         export CONFIG_SHELL
1819       else
1820         for prog in sh sh.exe bash bash.exe; do
1821           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1822           for dir in $PATH; do
1823             test -z "$dir" && dir=.
1824             if test -f $dir/$prog; then
1825               CONFIG_SHELL=$dir/$prog
1826               export CONFIG_SHELL
1827               break
1828             fi
1829           done
1830           IFS="$save_ifs"
1831           test -n "${CONFIG_SHELL}" && break
1832         done
1833       fi
1834     fi
1835   fi
1836   ;;
1837 esac
1838
1839 config_shell=${CONFIG_SHELL-/bin/sh}
1840
1841 moveifchange=${srcdir}/move-if-change
1842
1843 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1844
1845 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1846 # a relative path.
1847 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1848   INSTALL="${srcpwd}/install-sh -c"
1849 fi
1850
1851 # Set srcdir to "." if that's what it is.
1852 # This is important for multilib support.
1853 pwd=`${PWDCMD-pwd}`
1854 if test "${pwd}" = "${srcpwd}" ; then
1855   srcdir=.
1856 fi
1857
1858 topsrcdir=$srcpwd
1859
1860 extra_host_args=
1861
1862 ### To add a new directory to the tree, first choose whether it is a target
1863 ### or a host dependent tool.  Then put it into the appropriate list
1864 ### (library or tools, host or target), doing a dependency sort.
1865
1866 # Subdirs will be configured in the order listed in build_configdirs,
1867 # configdirs, or target_configdirs; see the serialization section below.
1868
1869 # Dependency sorting is only needed when *configuration* must be done in
1870 # a particular order.  In all cases a dependency should be specified in
1871 # the Makefile, whether or not it's implicitly specified here.
1872
1873 # Double entries in build_configdirs, configdirs, or target_configdirs may
1874 # cause circular dependencies and break everything horribly.
1875
1876 # these library is used by various programs built for the build
1877 # environment
1878 #
1879 build_libs="build-libiberty"
1880
1881 # these tools are built for the build environment
1882 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1883
1884 # these libraries are used by various programs built for the host environment
1885 #
1886 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr ppl cloog"
1887
1888 # these tools are built for the host environment
1889 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1890 # know that we are building the simulator.
1891 # binutils, gas and ld appear in that order because it makes sense to run
1892 # "make check" in that particular order.
1893 # If --enable-gold is used, "gold" will replace "ld".
1894 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"
1895
1896 # libgcj represents the runtime libraries only used by gcj.
1897 libgcj="target-libffi \
1898         target-zlib \
1899         target-qthreads \
1900         target-libjava"
1901
1902 # these libraries are built for the target environment, and are built after
1903 # the host libraries and the host tools (which may be a cross compiler)
1904 #
1905 target_libraries="target-libgcc \
1906                 target-libiberty \
1907                 target-libgloss \
1908                 target-newlib \
1909                 target-libgomp \
1910                 target-libstdc++-v3 \
1911                 target-libmudflap \
1912                 target-libssp \
1913                 target-libgfortran \
1914                 target-boehm-gc \
1915                 ${libgcj} \
1916                 target-libobjc \
1917                 target-libada"
1918
1919 # these tools are built using the target libraries, and are intended to
1920 # run only in the target environment
1921 #
1922 # note: any program that *uses* libraries that are in the "target_libraries"
1923 # list belongs in this list.  those programs are also very likely
1924 # candidates for the "native_only" list which follows
1925 #
1926 target_tools="target-examples target-groff target-gperf target-rda"
1927
1928 ################################################################################
1929
1930 ## All tools belong in one of the four categories, and are assigned above
1931 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1932 ## is important because configure will choke if they ever get through.
1933 ## ${configdirs} is directories we build using the host tools.
1934 ## ${target_configdirs} is directories we build using the target tools.
1935 configdirs=`echo ${host_libs} ${host_tools}`
1936 target_configdirs=`echo ${target_libraries} ${target_tools}`
1937 build_configdirs=`echo ${build_libs} ${build_tools}`
1938
1939
1940
1941 ################################################################################
1942
1943 srcname="gnu development package"
1944
1945 # This gets set non-empty for some net releases of packages.
1946 appdirs=""
1947
1948 # Define is_cross_compiler to save on calls to 'test'.
1949 is_cross_compiler=
1950 if test x"${host}" = x"${target}" ; then
1951   is_cross_compiler=no
1952 else
1953   is_cross_compiler=yes
1954 fi
1955
1956 # Find the build and target subdir names.
1957
1958 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1959 # have matching libraries, they should use host libraries: Makefile.tpl
1960 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1961 # However, they still use the build modules, because the corresponding
1962 # host modules (e.g. bison) are only built for the host when bootstrap
1963 # finishes. So:
1964 # - build_subdir is where we find build modules, and never changes.
1965 # - build_libsubdir is where we find build libraries, and can be overridden.
1966
1967 # Prefix 'build-' so this never conflicts with target_subdir.
1968 build_subdir="build-${build_noncanonical}"
1969
1970 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1971 if test "${with_build_libsubdir+set}" = set; then
1972   withval="$with_build_libsubdir"
1973   build_libsubdir="$withval"
1974 else
1975   build_libsubdir="$build_subdir"
1976 fi;
1977 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1978 if ( test $srcdir = . && test -d gcc ) \
1979    || test -d $srcdir/../host-${host_noncanonical}; then
1980   host_subdir="host-${host_noncanonical}"
1981 else
1982   host_subdir=.
1983 fi
1984 # No prefix.
1985 target_subdir=${target_noncanonical}
1986
1987
1988 # Skipdirs are removed silently.
1989 skipdirs=
1990 # Noconfigdirs are removed loudly.
1991 noconfigdirs=""
1992
1993 use_gnu_ld=
1994 # Make sure we don't let GNU ld be added if we didn't want it.
1995 if test x$with_gnu_ld = xno ; then
1996   use_gnu_ld=no
1997   noconfigdirs="$noconfigdirs ld gold"
1998 fi
1999
2000 use_gnu_as=
2001 # Make sure we don't let GNU as be added if we didn't want it.
2002 if test x$with_gnu_as = xno ; then
2003   use_gnu_as=no
2004   noconfigdirs="$noconfigdirs gas"
2005 fi
2006
2007 # some tools are so dependent upon X11 that if we're not building with X,
2008 # it's not even worth trying to configure, much less build, that tool.
2009
2010 case ${with_x} in
2011   yes | "") ;; # the default value for this tree is that X11 is available
2012   no)
2013     skipdirs="${skipdirs} tk itcl libgui"
2014     # We won't be able to build gdbtk without X.
2015     enable_gdbtk=no
2016     ;;
2017   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2018 esac
2019
2020 # Some tools are only suitable for building in a "native" situation.
2021 # Remove these if host!=target.
2022 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"
2023
2024 # Similarly, some are only suitable for cross toolchains.
2025 # Remove these if host=target.
2026 cross_only="target-libgloss target-newlib target-opcodes"
2027
2028 case $is_cross_compiler in
2029   no) skipdirs="${skipdirs} ${cross_only}" ;;
2030   yes) skipdirs="${skipdirs} ${native_only}" ;;
2031 esac
2032
2033 # If both --with-headers and --with-libs are specified, default to
2034 # --without-newlib.
2035 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2036    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2037   if test x"${with_newlib}" = x ; then
2038     with_newlib=no
2039   fi
2040 fi
2041
2042 # Recognize --with-newlib/--without-newlib.
2043 case ${with_newlib} in
2044   no) skipdirs="${skipdirs} target-newlib" ;;
2045   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2046 esac
2047
2048 # Handle --enable-gold.
2049
2050 # Check whether --enable-gold or --disable-gold was given.
2051 if test "${enable_gold+set}" = set; then
2052   enableval="$enable_gold"
2053   ENABLE_GOLD=$enableval
2054 else
2055   ENABLE_GOLD=no
2056 fi;
2057 if test "${ENABLE_GOLD}" = "yes"; then
2058   # Check for ELF target.
2059   is_elf=no
2060   case "${target}" in
2061     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2062     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2063     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2064       case "${target}" in
2065         *-*-linux*aout* | *-*-linux*oldld*)
2066           ;;
2067         *)
2068           is_elf=yes
2069           ;;
2070       esac
2071   esac
2072
2073   if test "$is_elf" = "yes"; then
2074     # Check for target supported by gold.
2075     case "${target}" in
2076       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-*)
2077         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2078         ;;
2079     esac
2080   fi
2081 fi
2082
2083 # Configure extra directories which are host specific
2084
2085 case "${host}" in
2086   *-cygwin*)
2087     configdirs="$configdirs libtermcap" ;;
2088 esac
2089
2090 # A target can indicate whether a language isn't supported for some reason.
2091 # Only spaces may be used in this macro; not newlines or tabs.
2092 unsupported_languages=
2093
2094 # Remove more programs from consideration, based on the host or
2095 # target this usually means that a port of the program doesn't
2096 # exist yet.
2097
2098 case "${host}" in
2099   hppa*64*-*-*)
2100     noconfigdirs="$noconfigdirs byacc"
2101     ;;
2102   i[3456789]86-*-vsta)
2103     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2104     ;;
2105   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2106     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2107     ;;
2108   x86_64-*-mingw*)
2109     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2110     ;;
2111   i[3456789]86-*-mingw32*)
2112     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2113     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2114     ;;
2115   i[3456789]86-*-beos*)
2116     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2117     ;;
2118   *-*-cygwin*)
2119     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2120     ;;
2121   *-*-netbsd*)
2122     noconfigdirs="$noconfigdirs rcs"
2123     ;;
2124   ppc*-*-pe)
2125     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2126     ;;
2127   powerpc-*-beos*)
2128     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2129     ;;
2130 esac
2131
2132
2133 # Check whether --enable-libada or --disable-libada was given.
2134 if test "${enable_libada+set}" = set; then
2135   enableval="$enable_libada"
2136   ENABLE_LIBADA=$enableval
2137 else
2138   ENABLE_LIBADA=yes
2139 fi;
2140 if test "${ENABLE_LIBADA}" != "yes" ; then
2141   noconfigdirs="$noconfigdirs gnattools"
2142 fi
2143
2144 # Check whether --enable-libssp or --disable-libssp was given.
2145 if test "${enable_libssp+set}" = set; then
2146   enableval="$enable_libssp"
2147   ENABLE_LIBSSP=$enableval
2148 else
2149   ENABLE_LIBSSP=yes
2150 fi;
2151
2152 # Save it here so that, even in case of --enable-libgcj, if the Java
2153 # front-end isn't enabled, we still get libgcj disabled.
2154 libgcj_saved=$libgcj
2155 case $enable_libgcj in
2156 yes)
2157   # If we reset it here, it won't get added to noconfigdirs in the
2158   # target-specific build rules, so it will be forcibly enabled
2159   # (unless the Java language itself isn't enabled).
2160   libgcj=
2161   ;;
2162 no)
2163   # Make sure we get it printed in the list of not supported target libs.
2164   noconfigdirs="$noconfigdirs ${libgcj}"
2165   ;;
2166 esac
2167
2168
2169 # Disable libmudflap on some systems.
2170 if test x$enable_libmudflap = x ; then
2171     case "${target}" in
2172     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2173         # Enable libmudflap by default in GNU and friends.
2174         ;;
2175     *-*-freebsd*)
2176         # Enable libmudflap by default in FreeBSD.
2177         ;;
2178     *)
2179         # Disable it by default everywhere else.
2180         noconfigdirs="$noconfigdirs target-libmudflap"
2181         ;;
2182     esac
2183 fi
2184
2185 # Disable libgomp on non POSIX hosted systems.
2186 if test x$enable_libgomp = x ; then
2187     # Enable libgomp by default on hosted POSIX systems.
2188     case "${target}" in
2189     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2190         ;;
2191     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2192         ;;
2193     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2194         ;;
2195     *-*-darwin* | *-*-aix*)
2196         ;;
2197     *)
2198         noconfigdirs="$noconfigdirs target-libgomp"
2199         ;;
2200     esac
2201 fi
2202
2203 # Default libgloss CPU subdirectory.
2204 libgloss_dir="$target_cpu"
2205
2206 case "${target}" in
2207   *-*-chorusos)
2208     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2209     ;;
2210   powerpc-*-darwin* | i[3456789]86-*-darwin* | x86_64-*-darwin9*)
2211     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2212     noconfigdirs="$noconfigdirs sim target-rda"
2213     ;;
2214   *-*-darwin*)
2215     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2216     noconfigdirs="$noconfigdirs sim target-rda"
2217     noconfigdirs="$noconfigdirs ${libgcj}"
2218     ;;
2219   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2220     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2221     ;;
2222   *-*-freebsd*)
2223     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2224     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2225         && test -f /usr/local/include/gmp.h; then
2226       with_gmp=/usr/local
2227     fi
2228
2229     # Skip some stuff that's unsupported on some FreeBSD configurations.
2230     case "${target}" in
2231       i*86-*-*) ;;
2232       alpha*-*-*) ;;
2233       *)
2234         noconfigdirs="$noconfigdirs ${libgcj}"
2235         ;;
2236     esac
2237     ;;
2238   *-*-kaos*)
2239     # Remove unsupported stuff on all kaOS configurations.
2240     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2241     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2242     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2243     noconfigdirs="$noconfigdirs target-libgloss"
2244     ;;
2245   *-*-netbsd*)
2246     # Skip some stuff on all NetBSD configurations.
2247     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2248
2249     # Skip some stuff that's unsupported on some NetBSD configurations.
2250     case "${target}" in
2251       i*86-*-netbsdelf*) ;;
2252       arm*-*-netbsdelf*) ;;
2253       *)
2254         noconfigdirs="$noconfigdirs ${libgcj}"
2255         ;;
2256     esac
2257     ;;
2258   *-*-netware*)
2259     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2260     ;;
2261   *-*-rtems*)
2262     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2263     ;;
2264     # The tpf target doesn't support gdb yet.
2265   *-*-tpf*)
2266     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2267     ;;
2268   *-*-uclinux*)
2269     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2270     ;;
2271   *-*-vxworks*)
2272     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2273     ;;
2274   alpha*-dec-osf*)
2275     # ld works, but does not support shared libraries.
2276     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2277     # gas doesn't generate exception information.
2278     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2279     ;;
2280   alpha*-*-*vms*)
2281     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2282     ;;
2283   alpha*-*-linux*)
2284     # newlib is not 64 bit ready
2285     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2286     ;;
2287   alpha*-*-*)
2288     # newlib is not 64 bit ready
2289     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2290     ;;
2291   am33_2.0-*-linux*)
2292     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2293     ;;
2294   sh-*-linux*)
2295     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2296     ;;
2297   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2298     noconfigdirs="$noconfigdirs ${libgcj}"
2299     noconfigdirs="$noconfigdirs target-examples"
2300     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2301     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2302     noconfigdirs="$noconfigdirs expect dejagnu"
2303     # the C++ libraries don't build on top of CE's C libraries
2304     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2305     noconfigdirs="$noconfigdirs target-newlib"
2306     case "${host}" in
2307       *-*-cygwin*) ;; # keep gdb and readline
2308       *) noconfigdirs="$noconfigdirs gdb readline"
2309          ;;
2310     esac
2311     libgloss_dir=wince
2312     ;;
2313   arc-*-*)
2314     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2315     ;;
2316   arm-semi-aof )
2317     ;;
2318   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2319     noconfigdirs="$noconfigdirs ${libgcj}"
2320     libgloss_dir=arm
2321     ;;
2322   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2323     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2324     libgloss_dir=arm
2325     ;;
2326   arm*-*-linux-gnueabi)
2327     noconfigdirs="$noconfigdirs target-qthreads"
2328     case ${with_newlib} in
2329       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2330     esac
2331     libgloss_dir=arm
2332     ;;
2333   arm*-*-symbianelf*)
2334     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2335     libgloss_dir=arm
2336     ;;
2337   arm-*-pe*)
2338     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2339     ;;
2340   thumb-*-coff)
2341     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2342     ;;
2343   thumb-*-elf)
2344     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2345     ;;
2346   thumb-*-pe)
2347     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2348     ;;
2349   arm-*-riscix*)
2350     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2351     ;;
2352   avr-*-*)
2353     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2354     ;;
2355   bfin-*-*)
2356     noconfigdirs="$noconfigdirs gdb"
2357     if test x${is_cross_compiler} != xno ; then
2358       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2359     fi
2360     ;;
2361   c4x-*-* | tic4x-*-*)
2362     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2363     ;;
2364   c54x*-*-* | tic54x-*-*)
2365     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2366     ;;
2367   cr16-*-*)
2368     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2369     ;;
2370   cris-*-* | crisv32-*-*)
2371     unsupported_languages="$unsupported_languages java"
2372     case "${target}" in
2373       *-*-aout)
2374         unsupported_languages="$unsupported_languages fortran"
2375         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2376       *-*-elf)
2377         noconfigdirs="$noconfigdirs target-boehm-gc";;
2378       *-*-linux*)
2379         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2380       *)
2381         unsupported_languages="$unsupported_languages fortran"
2382         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2383     esac
2384     libgloss_dir=cris
2385     ;;
2386   crx-*-*)
2387     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2388     ;;
2389   d10v-*-*)
2390     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2391     ;;
2392   d30v-*-*)
2393     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2394     ;;
2395   ep9312-*-elf | ep9312-*-coff)
2396     libgloss_dir=arm
2397     ;;
2398   fr30-*-elf*)
2399     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2400     ;;
2401   frv-*-*)
2402     noconfigdirs="$noconfigdirs ${libgcj}"
2403     ;;
2404   h8300*-*-*)
2405     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2406     ;;
2407   h8500-*-*)
2408     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2409     ;;
2410   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2411     ;;
2412   hppa*64*-*-linux* | parisc*64*-*-linux*)
2413     # In this case, it's because the hppa64-linux target is for
2414     # the kernel only at this point and has no libc, and thus no
2415     # headers, crt*.o, etc., all of which are needed by these.
2416     noconfigdirs="$noconfigdirs target-zlib"
2417     ;;
2418   parisc*-*-linux* | hppa*-*-linux*)
2419     ;;
2420   hppa*-*-*elf* | \
2421   hppa*-*-lites* | \
2422   hppa*-*-openbsd* | \
2423   hppa*64*-*-*)
2424     noconfigdirs="$noconfigdirs ${libgcj}"
2425     ;;
2426   hppa*-hp-hpux11*)
2427     noconfigdirs="$noconfigdirs ld shellutils"
2428     ;;
2429   hppa*-*-pro*)
2430     libgloss_dir=pa
2431     ;;
2432   hppa*-*-*)
2433     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2434     # build on HP-UX 10.20.
2435     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2436     ;;
2437   i960-*-*)
2438     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2439     ;;
2440   ia64*-*-elf*)
2441     # No gdb support yet.
2442     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2443     ;;
2444   ia64*-**-hpux*)
2445     # No gdb or ld support yet.
2446     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2447     ;;
2448   i370-*-opened*)
2449     ;;
2450   i[3456789]86-*-coff | i[3456789]86-*-elf)
2451     noconfigdirs="$noconfigdirs ${libgcj}"
2452     libgloss_dir=i386
2453     ;;
2454   i[3456789]86-*-linux*)
2455     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2456     # not build java stuff by default.
2457     case "${target}" in
2458       *-*-*libc1*)
2459         noconfigdirs="$noconfigdirs ${libgcj}";;
2460     esac
2461
2462     # This section makes it possible to build newlib natively on linux.
2463     # If we are using a cross compiler then don't configure newlib.
2464     if test x${is_cross_compiler} != xno ; then
2465       noconfigdirs="$noconfigdirs target-newlib"
2466     fi
2467     noconfigdirs="$noconfigdirs target-libgloss"
2468     # If we are not using a cross compiler, do configure newlib.
2469     # Note however, that newlib will only be configured in this situation
2470     # if the --with-newlib option has been given, because otherwise
2471     # 'target-newlib' will appear in skipdirs.
2472     ;;
2473   i[3456789]86-*-mingw32*)
2474     target_configdirs="$target_configdirs target-winsup"
2475     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2476     ;;
2477   x86_64-*-mingw*)
2478     target_configdirs="$target_configdirs target-winsup"
2479     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2480     ;;
2481   *-*-cygwin*)
2482     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2483     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2484     # always build newlib if winsup directory is present.
2485     if test -d "$srcdir/winsup/cygwin"; then
2486       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2487     elif test -d "$srcdir/newlib"; then
2488       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2489     fi
2490     ;;
2491   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2492   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2493     ;;
2494   i[3456789]86-*-pe)
2495     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2496     ;;
2497   i[3456789]86-*-sco3.2v5*)
2498     # The linker does not yet know about weak symbols in COFF,
2499     # and is not configured to handle mixed ELF and COFF.
2500     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2501     ;;
2502   i[3456789]86-*-sco*)
2503     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2504     ;;
2505   i[3456789]86-*-solaris2*)
2506     noconfigdirs="$noconfigdirs target-libgloss"
2507     ;;
2508   i[3456789]86-*-sysv4*)
2509     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2510     ;;
2511   i[3456789]86-*-beos*)
2512     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2513     ;;
2514   i[3456789]86-*-rdos*)
2515     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2516     ;;
2517   m32r-*-*)
2518     noconfigdirs="$noconfigdirs ${libgcj}"
2519     ;;
2520   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2521     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2522     libgloss_dir=m68hc11
2523     ;;
2524   m68k-*-elf*)
2525     noconfigdirs="$noconfigdirs ${libgcj}"
2526     ;;
2527   m68k-*-coff*)
2528     noconfigdirs="$noconfigdirs ${libgcj}"
2529     ;;
2530   m68*-*-* | fido-*-*)
2531     libgloss_dir=m68k
2532     ;;
2533   mcore-*-pe*)
2534   # The EPOC C++ environment does not support exceptions or rtti,
2535   # and so building libstdc++-v3 tends not to always work.
2536     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2537     ;;
2538   mmix-*-*)
2539     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2540     unsupported_languages="$unsupported_languages fortran java"
2541     ;;
2542   mn10200-*-*)
2543     noconfigdirs="$noconfigdirs ${libgcj}"
2544     ;;
2545   mn10300-*-*)
2546     noconfigdirs="$noconfigdirs ${libgcj}"
2547     ;;
2548   mt-*-*)
2549     noconfigdirs="$noconfigdirs sim"
2550     ;;
2551   powerpc-*-aix*)
2552     # copied from rs6000-*-* entry
2553     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2554     ;;
2555   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2556     target_configdirs="$target_configdirs target-winsup"
2557     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2558     # always build newlib.
2559     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2560     ;;
2561     # This is temporary until we can link against shared libraries
2562   powerpcle-*-solaris*)
2563     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2564     libgloss_dir=rs6000
2565     ;;
2566   powerpc-*-beos*)
2567     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2568     ;;
2569   powerpc-*-eabi)
2570     noconfigdirs="$noconfigdirs ${libgcj}"
2571     libgloss_dir=rs6000
2572     ;;
2573   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2574     libgloss_dir=rs6000
2575     ;;
2576   rs6000-*-lynxos*)
2577     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2578     ;;
2579   rs6000-*-aix*)
2580     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2581     ;;
2582   rs6000-*-*)
2583     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2584     ;;
2585   m68k-apollo-*)
2586     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2587     ;;
2588   mips*-sde-elf*)
2589     skipdirs="$skipdirs target-libiberty"
2590     noconfigdirs="$noconfigdirs ${libgcj}"
2591     if test x$with_newlib = xyes; then
2592       noconfigdirs="$noconfigdirs gprof"
2593     fi
2594     libgloss_dir=mips
2595     ;;
2596   mips*-*-irix5*)
2597     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2598     ;;
2599   mips*-*-irix6*)
2600     # Linking libjava exceeds command-line length limits on at least
2601     # IRIX 6.2, but not on IRIX 6.5.
2602     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2603     # <oldham@codesourcery.com>
2604     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2605     ;;
2606   mips*-*-bsd*)
2607     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2608     ;;
2609   mips*-*-linux*)
2610     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2611     ;;
2612   mips*-*-*)
2613     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2614     libgloss_dir=mips
2615     ;;
2616   romp-*-*)
2617     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2618     ;;
2619   sh-*-* | sh64-*-*)
2620     case "${host}" in
2621       i[3456789]86-*-vsta) ;; # don't add gprof back in
2622       i[3456789]86-*-go32*) ;; # don't add gprof back in
2623       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2624       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2625     esac
2626     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2627     ;;
2628   sparclet-*-aout* | sparc86x-*-*)
2629     libgloss_dir=sparc
2630     ;;
2631   sparc-*-elf*)
2632     noconfigdirs="$noconfigdirs ${libgcj}"
2633     ;;
2634   sparc64-*-elf*)
2635     noconfigdirs="$noconfigdirs ${libgcj}"
2636     libgloss_dir=sparc
2637     ;;
2638   sparclite-*-*)
2639     noconfigdirs="$noconfigdirs ${libgcj}"
2640     libgloss_dir=sparc
2641     ;;
2642   sparc-*-sunos4*)
2643     noconfigdirs="$noconfigdirs ${libgcj}"
2644     if test x${is_cross_compiler} != xno ; then
2645            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2646     else
2647            use_gnu_ld=no
2648     fi
2649     ;;
2650   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2651     noconfigdirs="$noconfigdirs ${libgcj}"
2652     ;;
2653   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2654     ;;
2655   spu-*-*)
2656     skipdirs="target-libssp"
2657     ;;
2658   v810-*-*)
2659     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2660     ;;
2661   v850-*-*)
2662     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2663     ;;
2664   v850e-*-*)
2665     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2666     ;;
2667   v850ea-*-*)
2668     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2669     ;;
2670   vax-*-vms)
2671     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2672     ;;
2673   vax-*-*)
2674     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2675     ;;
2676   xtensa*-*-*)
2677     noconfigdirs="$noconfigdirs ${libgcj}"
2678     ;;
2679   ip2k-*-*)
2680     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2681     ;;
2682   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2683     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2684     ;;
2685   *-*-lynxos*)
2686     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2687     ;;
2688   *-*-*)
2689     noconfigdirs="$noconfigdirs ${libgcj}"
2690     ;;
2691 esac
2692
2693 # If we aren't building newlib, then don't build libgloss, since libgloss
2694 # depends upon some newlib header files.
2695 case "${noconfigdirs}" in
2696   *target-libgloss*) ;;
2697   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2698 esac
2699
2700 # Work in distributions that contain no compiler tools, like Autoconf.
2701 tentative_cc=""
2702 host_makefile_frag=/dev/null
2703 if test -d ${srcdir}/config ; then
2704 case "${host}" in
2705   m68k-hp-hpux*)
2706     # Avoid "too much defining" errors from HPUX compiler.
2707     tentative_cc="cc -Wp,-H256000"
2708     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2709     # If it's HP/UX ar, this should be harmless.
2710     RANLIB="ar ts"
2711     ;;
2712   m68k-apollo-sysv*)
2713     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2714     ;;
2715   m68k-apollo-bsd*)
2716     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2717     # chokes on bfd, the compiler won't let you assign integers to enums, and
2718     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2719     # the apollo compiler" (the preferred version of GCC could be called cc,
2720     # or whatever), but I'm not sure leaving CC as cc is any better...
2721     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2722     # Used to have BISON=yacc.
2723     tentative_cc=gcc
2724     ;;
2725   m88k-dg-dgux*)
2726     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2727     ;;
2728   m88k-harris-cxux*)
2729     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2730     tentative_cc="cc -Xa"
2731     host_makefile_frag="config/mh-cxux"
2732     ;;
2733   m88k-motorola-sysv*)
2734     ;;
2735   mips*-dec-ultrix*)
2736     tentative_cc="cc -Wf,-XNg1000"
2737     host_makefile_frag="config/mh-decstation"
2738     ;;
2739   mips*-nec-sysv4*)
2740     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2741     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2742     host_makefile_frag="config/mh-necv4"
2743     ;;
2744   mips*-sgi-irix4*)
2745     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2746     # environment.  Also bump switch table size so that cp-parse will
2747     # compile.  Bump string length limit so linker builds.
2748     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2749     ;;
2750   mips*-*-sysv4*)
2751     host_makefile_frag="config/mh-sysv4"
2752     ;;
2753   mips*-*-sysv*)
2754     # This is for a MIPS running RISC/os 4.52C.
2755
2756     # This is needed for GDB, but needs to be in the top-level make because
2757     # if a library is compiled with the bsd headers and gets linked with the
2758     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2759     # a different size).
2760     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2761     # known except to select the sysv environment.  Could we use /proc instead?
2762     # These "sysv environments" and "bsd environments" often end up being a pain.
2763     #
2764     # This is not part of CFLAGS because perhaps not all C compilers have this
2765     # option.
2766     tentative_cc="cc -systype sysv"
2767     ;;
2768   i370-ibm-opened*)
2769     tentative_cc="c89"
2770     ;;
2771   i[3456789]86-*-sysv5*)
2772     host_makefile_frag="config/mh-sysv5"
2773     ;;
2774   i[3456789]86-*-dgux*)
2775     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2776     host_makefile_frag="config/mh-dgux386"
2777     ;;
2778   i[3456789]86-ncr-sysv4.3*)
2779     # The MetaWare compiler will generate a copyright message unless you
2780     # turn it off by adding the -Hnocopyr flag.
2781     tentative_cc="cc -Hnocopyr"
2782     ;;
2783   i[3456789]86-ncr-sysv4*)
2784     # for an NCR 3000 (i486/SVR4) system.
2785     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2786     # This compiler not only emits obnoxious copyright messages every time
2787     # you run it, but it chokes and dies on a whole bunch of GNU source
2788     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2789     tentative_cc="/usr/ccs/ATT/cc"
2790     host_makefile_frag="config/mh-ncr3000"
2791     ;;
2792   i[3456789]86-*-sco3.2v5*)
2793     ;;
2794   i[3456789]86-*-sco*)
2795     # The native C compiler botches some simple uses of const.  Unfortunately,
2796     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2797     tentative_cc="cc -Dconst="
2798     host_makefile_frag="config/mh-sco"
2799     ;;
2800   i[3456789]86-*-udk*)
2801     host_makefile_frag="config/mh-sysv5"
2802     ;;
2803   i[3456789]86-*-solaris2*)
2804     host_makefile_frag="config/mh-sysv4"
2805     ;;
2806   i[3456789]86-*-msdosdjgpp*)
2807     host_makefile_frag="config/mh-djgpp"
2808     ;;
2809   *-cygwin*)
2810
2811 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2812 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2813 echo a >cygwin-cat-check
2814 if test `cat cygwin-cat-check` == a ; then
2815   rm cygwin-cat-check
2816   echo "$as_me:$LINENO: result: yes" >&5
2817 echo "${ECHO_T}yes" >&6
2818 else
2819   rm cygwin-cat-check
2820   echo "$as_me:$LINENO: result: no" >&5
2821 echo "${ECHO_T}no" >&6
2822   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2823   Please either mount the build directory in binary mode or run the following
2824   commands before running any configure script:
2825 set -o igncr
2826 export SHELLOPTS
2827   " >&5
2828 echo "$as_me: error: The cat command does not ignore carriage return characters.
2829   Please either mount the build directory in binary mode or run the following
2830   commands before running any configure script:
2831 set -o igncr
2832 export SHELLOPTS
2833   " >&2;}
2834    { (exit 1); exit 1; }; }
2835 fi
2836
2837     host_makefile_frag="config/mh-cygwin"
2838     ;;
2839   *-mingw*)
2840     host_makefile_frag="config/mh-mingw"
2841     ;;
2842   *-interix*)
2843     host_makefile_frag="config/mh-interix"
2844     ;;
2845   vax-*-ultrix2*)
2846     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2847     tentative_cc=gcc
2848     ;;
2849   *-*-solaris2*)
2850     host_makefile_frag="config/mh-solaris"
2851     ;;
2852   m68k-sun-sunos*)
2853     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2854     # without overflowing the jump tables (-J says to use a 32 bit table)
2855     tentative_cc="cc -J"
2856     ;;
2857   hppa*-hp-hpux10*)
2858     tentative_cc="cc -Wp,-H256000"
2859     host_makefile_frag="config/mh-pa-hpux10"
2860     ;;
2861   hppa*-hp-hpux* | hppa*-*-hiux*)
2862     tentative_cc="cc -Wp,-H256000"
2863     host_makefile_frag="config/mh-pa"
2864     ;;
2865   hppa*-*)
2866     host_makefile_frag="config/mh-pa"
2867     ;;
2868   *-hp-hpux* | *-*-hiux*)
2869     tentative_cc="cc -Wp,-H256000"
2870     ;;
2871   rs6000-*-lynxos*)
2872     # /bin/cc is less than useful for our purposes.  Always use GCC
2873     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2874     host_makefile_frag="config/mh-lynxrs6k"
2875     ;;
2876   powerpc-*-darwin*)
2877     host_makefile_frag="config/mh-ppc-darwin"
2878     ;;
2879   powerpc-*-aix*)
2880     host_makefile_frag="config/mh-ppc-aix"
2881     ;;
2882   rs6000-*-aix*)
2883     host_makefile_frag="config/mh-ppc-aix"
2884     ;;
2885   *-*-lynxos*)
2886     # /bin/cc is less than useful for our purposes.  Always use GCC
2887     tentative_cc="/bin/gcc"
2888     ;;
2889   *-*-sysv4*)
2890     host_makefile_frag="config/mh-sysv4"
2891     ;;
2892   # This is placed last to prevent interfering with the cases above.
2893   i[3456789]86-*-*)
2894     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2895     host_makefile_frag="config/mh-x86omitfp"
2896     ;;
2897 esac
2898 fi
2899
2900 # If we aren't going to be using gcc, see if we can extract a definition
2901 # of CC from the fragment.
2902 # Actually, use the 'pre-extracted' version above.
2903 if test -z "${CC}" && test "${build}" = "${host}" ; then
2904   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2905   found=
2906   for dir in $PATH; do
2907     test -z "$dir" && dir=.
2908     if test -f $dir/gcc; then
2909       found=yes
2910       break
2911     fi
2912   done
2913   IFS="$save_ifs"
2914   if test -z "${found}" && test -n "${tentative_cc}" ; then
2915     CC=$tentative_cc
2916   fi
2917 fi
2918
2919 if test "${build}" != "${host}" ; then
2920   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2921   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2922   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2923   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2924   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2925   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2926   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2927   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2928   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2929   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2930   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2931   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2932 else
2933   AR_FOR_BUILD="\$(AR)"
2934   AS_FOR_BUILD="\$(AS)"
2935   CC_FOR_BUILD="\$(CC)"
2936   CXX_FOR_BUILD="\$(CXX)"
2937   GCJ_FOR_BUILD="\$(GCJ)"
2938   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2939   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2940   LD_FOR_BUILD="\$(LD)"
2941   NM_FOR_BUILD="\$(NM)"
2942   RANLIB_FOR_BUILD="\$(RANLIB)"
2943   WINDRES_FOR_BUILD="\$(WINDRES)"
2944   WINDMC_FOR_BUILD="\$(WINDMC)"
2945 fi
2946
2947 ac_ext=c
2948 ac_cpp='$CPP $CPPFLAGS'
2949 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2950 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2951 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2952 if test -n "$ac_tool_prefix"; then
2953   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2954 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2955 echo "$as_me:$LINENO: checking for $ac_word" >&5
2956 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2957 if test "${ac_cv_prog_CC+set}" = set; then
2958   echo $ECHO_N "(cached) $ECHO_C" >&6
2959 else
2960   if test -n "$CC"; then
2961   ac_cv_prog_CC="$CC" # Let the user override the test.
2962 else
2963 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2964 for as_dir in $PATH
2965 do
2966   IFS=$as_save_IFS
2967   test -z "$as_dir" && as_dir=.
2968   for ac_exec_ext in '' $ac_executable_extensions; do
2969   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2970     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2971     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2972     break 2
2973   fi
2974 done
2975 done
2976
2977 fi
2978 fi
2979 CC=$ac_cv_prog_CC
2980 if test -n "$CC"; then
2981   echo "$as_me:$LINENO: result: $CC" >&5
2982 echo "${ECHO_T}$CC" >&6
2983 else
2984   echo "$as_me:$LINENO: result: no" >&5
2985 echo "${ECHO_T}no" >&6
2986 fi
2987
2988 fi
2989 if test -z "$ac_cv_prog_CC"; then
2990   ac_ct_CC=$CC
2991   # Extract the first word of "gcc", so it can be a program name with args.
2992 set dummy gcc; ac_word=$2
2993 echo "$as_me:$LINENO: checking for $ac_word" >&5
2994 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2995 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2996   echo $ECHO_N "(cached) $ECHO_C" >&6
2997 else
2998   if test -n "$ac_ct_CC"; then
2999   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3000 else
3001 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3002 for as_dir in $PATH
3003 do
3004   IFS=$as_save_IFS
3005   test -z "$as_dir" && as_dir=.
3006   for ac_exec_ext in '' $ac_executable_extensions; do
3007   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3008     ac_cv_prog_ac_ct_CC="gcc"
3009     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3010     break 2
3011   fi
3012 done
3013 done
3014
3015 fi
3016 fi
3017 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3018 if test -n "$ac_ct_CC"; then
3019   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3020 echo "${ECHO_T}$ac_ct_CC" >&6
3021 else
3022   echo "$as_me:$LINENO: result: no" >&5
3023 echo "${ECHO_T}no" >&6
3024 fi
3025
3026   CC=$ac_ct_CC
3027 else
3028   CC="$ac_cv_prog_CC"
3029 fi
3030
3031 if test -z "$CC"; then
3032   if test -n "$ac_tool_prefix"; then
3033   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3034 set dummy ${ac_tool_prefix}cc; ac_word=$2
3035 echo "$as_me:$LINENO: checking for $ac_word" >&5
3036 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3037 if test "${ac_cv_prog_CC+set}" = set; then
3038   echo $ECHO_N "(cached) $ECHO_C" >&6
3039 else
3040   if test -n "$CC"; then
3041   ac_cv_prog_CC="$CC" # Let the user override the test.
3042 else
3043 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3044 for as_dir in $PATH
3045 do
3046   IFS=$as_save_IFS
3047   test -z "$as_dir" && as_dir=.
3048   for ac_exec_ext in '' $ac_executable_extensions; do
3049   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3050     ac_cv_prog_CC="${ac_tool_prefix}cc"
3051     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3052     break 2
3053   fi
3054 done
3055 done
3056
3057 fi
3058 fi
3059 CC=$ac_cv_prog_CC
3060 if test -n "$CC"; then
3061   echo "$as_me:$LINENO: result: $CC" >&5
3062 echo "${ECHO_T}$CC" >&6
3063 else
3064   echo "$as_me:$LINENO: result: no" >&5
3065 echo "${ECHO_T}no" >&6
3066 fi
3067
3068 fi
3069 if test -z "$ac_cv_prog_CC"; then
3070   ac_ct_CC=$CC
3071   # Extract the first word of "cc", so it can be a program name with args.
3072 set dummy cc; ac_word=$2
3073 echo "$as_me:$LINENO: checking for $ac_word" >&5
3074 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3075 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3076   echo $ECHO_N "(cached) $ECHO_C" >&6
3077 else
3078   if test -n "$ac_ct_CC"; then
3079   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3080 else
3081 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3082 for as_dir in $PATH
3083 do
3084   IFS=$as_save_IFS
3085   test -z "$as_dir" && as_dir=.
3086   for ac_exec_ext in '' $ac_executable_extensions; do
3087   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3088     ac_cv_prog_ac_ct_CC="cc"
3089     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3090     break 2
3091   fi
3092 done
3093 done
3094
3095 fi
3096 fi
3097 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3098 if test -n "$ac_ct_CC"; then
3099   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3100 echo "${ECHO_T}$ac_ct_CC" >&6
3101 else
3102   echo "$as_me:$LINENO: result: no" >&5
3103 echo "${ECHO_T}no" >&6
3104 fi
3105
3106   CC=$ac_ct_CC
3107 else
3108   CC="$ac_cv_prog_CC"
3109 fi
3110
3111 fi
3112 if test -z "$CC"; then
3113   # Extract the first word of "cc", so it can be a program name with args.
3114 set dummy cc; ac_word=$2
3115 echo "$as_me:$LINENO: checking for $ac_word" >&5
3116 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3117 if test "${ac_cv_prog_CC+set}" = set; then
3118   echo $ECHO_N "(cached) $ECHO_C" >&6
3119 else
3120   if test -n "$CC"; then
3121   ac_cv_prog_CC="$CC" # Let the user override the test.
3122 else
3123   ac_prog_rejected=no
3124 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3125 for as_dir in $PATH
3126 do
3127   IFS=$as_save_IFS
3128   test -z "$as_dir" && as_dir=.
3129   for ac_exec_ext in '' $ac_executable_extensions; do
3130   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3131     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3132        ac_prog_rejected=yes
3133        continue
3134      fi
3135     ac_cv_prog_CC="cc"
3136     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3137     break 2
3138   fi
3139 done
3140 done
3141
3142 if test $ac_prog_rejected = yes; then
3143   # We found a bogon in the path, so make sure we never use it.
3144   set dummy $ac_cv_prog_CC
3145   shift
3146   if test $# != 0; then
3147     # We chose a different compiler from the bogus one.
3148     # However, it has the same basename, so the bogon will be chosen
3149     # first if we set CC to just the basename; use the full file name.
3150     shift
3151     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3152   fi
3153 fi
3154 fi
3155 fi
3156 CC=$ac_cv_prog_CC
3157 if test -n "$CC"; then
3158   echo "$as_me:$LINENO: result: $CC" >&5
3159 echo "${ECHO_T}$CC" >&6
3160 else
3161   echo "$as_me:$LINENO: result: no" >&5
3162 echo "${ECHO_T}no" >&6
3163 fi
3164
3165 fi
3166 if test -z "$CC"; then
3167   if test -n "$ac_tool_prefix"; then
3168   for ac_prog in cl
3169   do
3170     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3171 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3172 echo "$as_me:$LINENO: checking for $ac_word" >&5
3173 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3174 if test "${ac_cv_prog_CC+set}" = set; then
3175   echo $ECHO_N "(cached) $ECHO_C" >&6
3176 else
3177   if test -n "$CC"; then
3178   ac_cv_prog_CC="$CC" # Let the user override the test.
3179 else
3180 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3181 for as_dir in $PATH
3182 do
3183   IFS=$as_save_IFS
3184   test -z "$as_dir" && as_dir=.
3185   for ac_exec_ext in '' $ac_executable_extensions; do
3186   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3187     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3188     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3189     break 2
3190   fi
3191 done
3192 done
3193
3194 fi
3195 fi
3196 CC=$ac_cv_prog_CC
3197 if test -n "$CC"; then
3198   echo "$as_me:$LINENO: result: $CC" >&5
3199 echo "${ECHO_T}$CC" >&6
3200 else
3201   echo "$as_me:$LINENO: result: no" >&5
3202 echo "${ECHO_T}no" >&6
3203 fi
3204
3205     test -n "$CC" && break
3206   done
3207 fi
3208 if test -z "$CC"; then
3209   ac_ct_CC=$CC
3210   for ac_prog in cl
3211 do
3212   # Extract the first word of "$ac_prog", so it can be a program name with args.
3213 set dummy $ac_prog; ac_word=$2
3214 echo "$as_me:$LINENO: checking for $ac_word" >&5
3215 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3216 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3217   echo $ECHO_N "(cached) $ECHO_C" >&6
3218 else
3219   if test -n "$ac_ct_CC"; then
3220   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3221 else
3222 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3223 for as_dir in $PATH
3224 do
3225   IFS=$as_save_IFS
3226   test -z "$as_dir" && as_dir=.
3227   for ac_exec_ext in '' $ac_executable_extensions; do
3228   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3229     ac_cv_prog_ac_ct_CC="$ac_prog"
3230     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3231     break 2
3232   fi
3233 done
3234 done
3235
3236 fi
3237 fi
3238 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3239 if test -n "$ac_ct_CC"; then
3240   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3241 echo "${ECHO_T}$ac_ct_CC" >&6
3242 else
3243   echo "$as_me:$LINENO: result: no" >&5
3244 echo "${ECHO_T}no" >&6
3245 fi
3246
3247   test -n "$ac_ct_CC" && break
3248 done
3249
3250   CC=$ac_ct_CC
3251 fi
3252
3253 fi
3254
3255
3256 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3257 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3258 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3259 See \`config.log' for more details." >&5
3260 echo "$as_me: error: no acceptable C compiler found in \$PATH
3261 See \`config.log' for more details." >&2;}
3262    { (exit 1); exit 1; }; }; }
3263
3264 # Provide some information about the compiler.
3265 echo "$as_me:$LINENO:" \
3266      "checking for C compiler version" >&5
3267 ac_compiler=`set X $ac_compile; echo $2`
3268 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3269   (eval $ac_compiler --version </dev/null >&5) 2>&5
3270   ac_status=$?
3271   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3272   (exit $ac_status); }
3273 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3274   (eval $ac_compiler -v </dev/null >&5) 2>&5
3275   ac_status=$?
3276   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3277   (exit $ac_status); }
3278 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3279   (eval $ac_compiler -V </dev/null >&5) 2>&5
3280   ac_status=$?
3281   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3282   (exit $ac_status); }
3283
3284 cat >conftest.$ac_ext <<_ACEOF
3285 /* confdefs.h.  */
3286 _ACEOF
3287 cat confdefs.h >>conftest.$ac_ext
3288 cat >>conftest.$ac_ext <<_ACEOF
3289 /* end confdefs.h.  */
3290
3291 int
3292 main ()
3293 {
3294
3295   ;
3296   return 0;
3297 }
3298 _ACEOF
3299 ac_clean_files_save=$ac_clean_files
3300 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3301 # Try to create an executable without -o first, disregard a.out.
3302 # It will help us diagnose broken compilers, and finding out an intuition
3303 # of exeext.
3304 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3305 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3306 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3307 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3308   (eval $ac_link_default) 2>&5
3309   ac_status=$?
3310   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3311   (exit $ac_status); }; then
3312   # Find the output, starting from the most likely.  This scheme is
3313 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3314 # resort.
3315
3316 # Be careful to initialize this variable, since it used to be cached.
3317 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3318 ac_cv_exeext=
3319 # b.out is created by i960 compilers.
3320 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3321 do
3322   test -f "$ac_file" || continue
3323   case $ac_file in
3324     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3325         ;;
3326     conftest.$ac_ext )
3327         # This is the source file.
3328         ;;
3329     [ab].out )
3330         # We found the default executable, but exeext='' is most
3331         # certainly right.
3332         break;;
3333     *.* )
3334         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3335         # FIXME: I believe we export ac_cv_exeext for Libtool,
3336         # but it would be cool to find out if it's true.  Does anybody
3337         # maintain Libtool? --akim.
3338         export ac_cv_exeext
3339         break;;
3340     * )
3341         break;;
3342   esac
3343 done
3344 else
3345   echo "$as_me: failed program was:" >&5
3346 sed 's/^/| /' conftest.$ac_ext >&5
3347
3348 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3349 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3350 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3351 See \`config.log' for more details." >&5
3352 echo "$as_me: error: C compiler cannot create executables
3353 See \`config.log' for more details." >&2;}
3354    { (exit 77); exit 77; }; }; }
3355 fi
3356
3357 ac_exeext=$ac_cv_exeext
3358 echo "$as_me:$LINENO: result: $ac_file" >&5
3359 echo "${ECHO_T}$ac_file" >&6
3360
3361 # Check the compiler produces executables we can run.  If not, either
3362 # the compiler is broken, or we cross compile.
3363 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3364 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3365 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3366 # If not cross compiling, check that we can run a simple program.
3367 if test "$cross_compiling" != yes; then
3368   if { ac_try='./$ac_file'
3369   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3370   (eval $ac_try) 2>&5
3371   ac_status=$?
3372   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3373   (exit $ac_status); }; }; then
3374     cross_compiling=no
3375   else
3376     if test "$cross_compiling" = maybe; then
3377         cross_compiling=yes
3378     else
3379         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3380 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3381 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3382 If you meant to cross compile, use \`--host'.
3383 See \`config.log' for more details." >&5
3384 echo "$as_me: error: cannot run C compiled programs.
3385 If you meant to cross compile, use \`--host'.
3386 See \`config.log' for more details." >&2;}
3387    { (exit 1); exit 1; }; }; }
3388     fi
3389   fi
3390 fi
3391 echo "$as_me:$LINENO: result: yes" >&5
3392 echo "${ECHO_T}yes" >&6
3393
3394 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3395 ac_clean_files=$ac_clean_files_save
3396 # Check the compiler produces executables we can run.  If not, either
3397 # the compiler is broken, or we cross compile.
3398 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3399 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3400 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3401 echo "${ECHO_T}$cross_compiling" >&6
3402
3403 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3404 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3405 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3406   (eval $ac_link) 2>&5
3407   ac_status=$?
3408   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3409   (exit $ac_status); }; then
3410   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3411 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3412 # work properly (i.e., refer to `conftest.exe'), while it won't with
3413 # `rm'.
3414 for ac_file in conftest.exe conftest conftest.*; do
3415   test -f "$ac_file" || continue
3416   case $ac_file in
3417     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3418     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3419           export ac_cv_exeext
3420           break;;
3421     * ) break;;
3422   esac
3423 done
3424 else
3425   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3426 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3427 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3428 See \`config.log' for more details." >&5
3429 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3430 See \`config.log' for more details." >&2;}
3431    { (exit 1); exit 1; }; }; }
3432 fi
3433
3434 rm -f conftest$ac_cv_exeext
3435 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3436 echo "${ECHO_T}$ac_cv_exeext" >&6
3437
3438 rm -f conftest.$ac_ext
3439 EXEEXT=$ac_cv_exeext
3440 ac_exeext=$EXEEXT
3441 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3442 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3443 if test "${ac_cv_objext+set}" = set; then
3444   echo $ECHO_N "(cached) $ECHO_C" >&6
3445 else
3446   cat >conftest.$ac_ext <<_ACEOF
3447 /* confdefs.h.  */
3448 _ACEOF
3449 cat confdefs.h >>conftest.$ac_ext
3450 cat >>conftest.$ac_ext <<_ACEOF
3451 /* end confdefs.h.  */
3452
3453 int
3454 main ()
3455 {
3456
3457   ;
3458   return 0;
3459 }
3460 _ACEOF
3461 rm -f conftest.o conftest.obj
3462 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3463   (eval $ac_compile) 2>&5
3464   ac_status=$?
3465   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3466   (exit $ac_status); }; then
3467   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3468   case $ac_file in
3469     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3470     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3471        break;;
3472   esac
3473 done
3474 else
3475   echo "$as_me: failed program was:" >&5
3476 sed 's/^/| /' conftest.$ac_ext >&5
3477
3478 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3479 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3480 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3481 See \`config.log' for more details." >&5
3482 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3483 See \`config.log' for more details." >&2;}
3484    { (exit 1); exit 1; }; }; }
3485 fi
3486
3487 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3488 fi
3489 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3490 echo "${ECHO_T}$ac_cv_objext" >&6
3491 OBJEXT=$ac_cv_objext
3492 ac_objext=$OBJEXT
3493 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3494 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3495 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3496   echo $ECHO_N "(cached) $ECHO_C" >&6
3497 else
3498   cat >conftest.$ac_ext <<_ACEOF
3499 /* confdefs.h.  */
3500 _ACEOF
3501 cat confdefs.h >>conftest.$ac_ext
3502 cat >>conftest.$ac_ext <<_ACEOF
3503 /* end confdefs.h.  */
3504
3505 int
3506 main ()
3507 {
3508 #ifndef __GNUC__
3509        choke me
3510 #endif
3511
3512   ;
3513   return 0;
3514 }
3515 _ACEOF
3516 rm -f conftest.$ac_objext
3517 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3518   (eval $ac_compile) 2>conftest.er1
3519   ac_status=$?
3520   grep -v '^ *+' conftest.er1 >conftest.err
3521   rm -f conftest.er1
3522   cat conftest.err >&5
3523   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3524   (exit $ac_status); } &&
3525          { ac_try='test -z "$ac_c_werror_flag"
3526                          || test ! -s conftest.err'
3527   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3528   (eval $ac_try) 2>&5
3529   ac_status=$?
3530   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3531   (exit $ac_status); }; } &&
3532          { ac_try='test -s conftest.$ac_objext'
3533   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3534   (eval $ac_try) 2>&5
3535   ac_status=$?
3536   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3537   (exit $ac_status); }; }; then
3538   ac_compiler_gnu=yes
3539 else
3540   echo "$as_me: failed program was:" >&5
3541 sed 's/^/| /' conftest.$ac_ext >&5
3542
3543 ac_compiler_gnu=no
3544 fi
3545 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3546 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3547
3548 fi
3549 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3550 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3551 GCC=`test $ac_compiler_gnu = yes && echo yes`
3552 ac_test_CFLAGS=${CFLAGS+set}
3553 ac_save_CFLAGS=$CFLAGS
3554 CFLAGS="-g"
3555 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3556 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3557 if test "${ac_cv_prog_cc_g+set}" = set; then
3558   echo $ECHO_N "(cached) $ECHO_C" >&6
3559 else
3560   cat >conftest.$ac_ext <<_ACEOF
3561 /* confdefs.h.  */
3562 _ACEOF
3563 cat confdefs.h >>conftest.$ac_ext
3564 cat >>conftest.$ac_ext <<_ACEOF
3565 /* end confdefs.h.  */
3566
3567 int
3568 main ()
3569 {
3570
3571   ;
3572   return 0;
3573 }
3574 _ACEOF
3575 rm -f conftest.$ac_objext
3576 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3577   (eval $ac_compile) 2>conftest.er1
3578   ac_status=$?
3579   grep -v '^ *+' conftest.er1 >conftest.err
3580   rm -f conftest.er1
3581   cat conftest.err >&5
3582   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3583   (exit $ac_status); } &&
3584          { ac_try='test -z "$ac_c_werror_flag"
3585                          || test ! -s conftest.err'
3586   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3587   (eval $ac_try) 2>&5
3588   ac_status=$?
3589   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3590   (exit $ac_status); }; } &&
3591          { ac_try='test -s conftest.$ac_objext'
3592   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3593   (eval $ac_try) 2>&5
3594   ac_status=$?
3595   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3596   (exit $ac_status); }; }; then
3597   ac_cv_prog_cc_g=yes
3598 else
3599   echo "$as_me: failed program was:" >&5
3600 sed 's/^/| /' conftest.$ac_ext >&5
3601
3602 ac_cv_prog_cc_g=no
3603 fi
3604 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3605 fi
3606 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3607 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3608 if test "$ac_test_CFLAGS" = set; then
3609   CFLAGS=$ac_save_CFLAGS
3610 elif test $ac_cv_prog_cc_g = yes; then
3611   if test "$GCC" = yes; then
3612     CFLAGS="-g -O2"
3613   else
3614     CFLAGS="-g"
3615   fi
3616 else
3617   if test "$GCC" = yes; then
3618     CFLAGS="-O2"
3619   else
3620     CFLAGS=
3621   fi
3622 fi
3623 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3624 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3625 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3626   echo $ECHO_N "(cached) $ECHO_C" >&6
3627 else
3628   ac_cv_prog_cc_stdc=no
3629 ac_save_CC=$CC
3630 cat >conftest.$ac_ext <<_ACEOF
3631 /* confdefs.h.  */
3632 _ACEOF
3633 cat confdefs.h >>conftest.$ac_ext
3634 cat >>conftest.$ac_ext <<_ACEOF
3635 /* end confdefs.h.  */
3636 #include <stdarg.h>
3637 #include <stdio.h>
3638 #include <sys/types.h>
3639 #include <sys/stat.h>
3640 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3641 struct buf { int x; };
3642 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3643 static char *e (p, i)
3644      char **p;
3645      int i;
3646 {
3647   return p[i];
3648 }
3649 static char *f (char * (*g) (char **, int), char **p, ...)
3650 {
3651   char *s;
3652   va_list v;
3653   va_start (v,p);
3654   s = g (p, va_arg (v,int));
3655   va_end (v);
3656   return s;
3657 }
3658
3659 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3660    function prototypes and stuff, but not '\xHH' hex character constants.
3661    These don't provoke an error unfortunately, instead are silently treated
3662    as 'x'.  The following induces an error, until -std1 is added to get
3663    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3664    array size at least.  It's necessary to write '\x00'==0 to get something
3665    that's true only with -std1.  */
3666 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3667
3668 int test (int i, double x);
3669 struct s1 {int (*f) (int a);};
3670 struct s2 {int (*f) (double a);};
3671 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3672 int argc;
3673 char **argv;
3674 int
3675 main ()
3676 {
3677 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3678   ;
3679   return 0;
3680 }
3681 _ACEOF
3682 # Don't try gcc -ansi; that turns off useful extensions and
3683 # breaks some systems' header files.
3684 # AIX                   -qlanglvl=ansi
3685 # Ultrix and OSF/1      -std1
3686 # HP-UX 10.20 and later -Ae
3687 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3688 # SVR4                  -Xc -D__EXTENSIONS__
3689 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3690 do
3691   CC="$ac_save_CC $ac_arg"
3692   rm -f conftest.$ac_objext
3693 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3694   (eval $ac_compile) 2>conftest.er1
3695   ac_status=$?
3696   grep -v '^ *+' conftest.er1 >conftest.err
3697   rm -f conftest.er1
3698   cat conftest.err >&5
3699   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3700   (exit $ac_status); } &&
3701          { ac_try='test -z "$ac_c_werror_flag"
3702                          || test ! -s conftest.err'
3703   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3704   (eval $ac_try) 2>&5
3705   ac_status=$?
3706   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3707   (exit $ac_status); }; } &&
3708          { ac_try='test -s conftest.$ac_objext'
3709   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3710   (eval $ac_try) 2>&5
3711   ac_status=$?
3712   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3713   (exit $ac_status); }; }; then
3714   ac_cv_prog_cc_stdc=$ac_arg
3715 break
3716 else
3717   echo "$as_me: failed program was:" >&5
3718 sed 's/^/| /' conftest.$ac_ext >&5
3719
3720 fi
3721 rm -f conftest.err conftest.$ac_objext
3722 done
3723 rm -f conftest.$ac_ext conftest.$ac_objext
3724 CC=$ac_save_CC
3725
3726 fi
3727
3728 case "x$ac_cv_prog_cc_stdc" in
3729   x|xno)
3730     echo "$as_me:$LINENO: result: none needed" >&5
3731 echo "${ECHO_T}none needed" >&6 ;;
3732   *)
3733     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3734 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3735     CC="$CC $ac_cv_prog_cc_stdc" ;;
3736 esac
3737
3738 # Some people use a C++ compiler to compile C.  Since we use `exit',
3739 # in C++ we need to declare it.  In case someone uses the same compiler
3740 # for both compiling C and C++ we need to have the C++ compiler decide
3741 # the declaration of exit, since it's the most demanding environment.
3742 cat >conftest.$ac_ext <<_ACEOF
3743 #ifndef __cplusplus
3744   choke me
3745 #endif
3746 _ACEOF
3747 rm -f conftest.$ac_objext
3748 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3749   (eval $ac_compile) 2>conftest.er1
3750   ac_status=$?
3751   grep -v '^ *+' conftest.er1 >conftest.err
3752   rm -f conftest.er1
3753   cat conftest.err >&5
3754   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3755   (exit $ac_status); } &&
3756          { ac_try='test -z "$ac_c_werror_flag"
3757                          || test ! -s conftest.err'
3758   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3759   (eval $ac_try) 2>&5
3760   ac_status=$?
3761   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3762   (exit $ac_status); }; } &&
3763          { ac_try='test -s conftest.$ac_objext'
3764   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3765   (eval $ac_try) 2>&5
3766   ac_status=$?
3767   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3768   (exit $ac_status); }; }; then
3769   for ac_declaration in \
3770    '' \
3771    'extern "C" void std::exit (int) throw (); using std::exit;' \
3772    'extern "C" void std::exit (int); using std::exit;' \
3773    'extern "C" void exit (int) throw ();' \
3774    'extern "C" void exit (int);' \
3775    'void exit (int);'
3776 do
3777   cat >conftest.$ac_ext <<_ACEOF
3778 /* confdefs.h.  */
3779 _ACEOF
3780 cat confdefs.h >>conftest.$ac_ext
3781 cat >>conftest.$ac_ext <<_ACEOF
3782 /* end confdefs.h.  */
3783 $ac_declaration
3784 #include <stdlib.h>
3785 int
3786 main ()
3787 {
3788 exit (42);
3789   ;
3790   return 0;
3791 }
3792 _ACEOF
3793 rm -f conftest.$ac_objext
3794 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3795   (eval $ac_compile) 2>conftest.er1
3796   ac_status=$?
3797   grep -v '^ *+' conftest.er1 >conftest.err
3798   rm -f conftest.er1
3799   cat conftest.err >&5
3800   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3801   (exit $ac_status); } &&
3802          { ac_try='test -z "$ac_c_werror_flag"
3803                          || test ! -s conftest.err'
3804   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3805   (eval $ac_try) 2>&5
3806   ac_status=$?
3807   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3808   (exit $ac_status); }; } &&
3809          { ac_try='test -s conftest.$ac_objext'
3810   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3811   (eval $ac_try) 2>&5
3812   ac_status=$?
3813   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3814   (exit $ac_status); }; }; then
3815   :
3816 else
3817   echo "$as_me: failed program was:" >&5
3818 sed 's/^/| /' conftest.$ac_ext >&5
3819
3820 continue
3821 fi
3822 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3823   cat >conftest.$ac_ext <<_ACEOF
3824 /* confdefs.h.  */
3825 _ACEOF
3826 cat confdefs.h >>conftest.$ac_ext
3827 cat >>conftest.$ac_ext <<_ACEOF
3828 /* end confdefs.h.  */
3829 $ac_declaration
3830 int
3831 main ()
3832 {
3833 exit (42);
3834   ;
3835   return 0;
3836 }
3837 _ACEOF
3838 rm -f conftest.$ac_objext
3839 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3840   (eval $ac_compile) 2>conftest.er1
3841   ac_status=$?
3842   grep -v '^ *+' conftest.er1 >conftest.err
3843   rm -f conftest.er1
3844   cat conftest.err >&5
3845   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3846   (exit $ac_status); } &&
3847          { ac_try='test -z "$ac_c_werror_flag"
3848                          || test ! -s conftest.err'
3849   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3850   (eval $ac_try) 2>&5
3851   ac_status=$?
3852   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3853   (exit $ac_status); }; } &&
3854          { ac_try='test -s conftest.$ac_objext'
3855   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3856   (eval $ac_try) 2>&5
3857   ac_status=$?
3858   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3859   (exit $ac_status); }; }; then
3860   break
3861 else
3862   echo "$as_me: failed program was:" >&5
3863 sed 's/^/| /' conftest.$ac_ext >&5
3864
3865 fi
3866 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3867 done
3868 rm -f conftest*
3869 if test -n "$ac_declaration"; then
3870   echo '#ifdef __cplusplus' >>confdefs.h
3871   echo $ac_declaration      >>confdefs.h
3872   echo '#endif'             >>confdefs.h
3873 fi
3874
3875 else
3876   echo "$as_me: failed program was:" >&5
3877 sed 's/^/| /' conftest.$ac_ext >&5
3878
3879 fi
3880 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3881 ac_ext=c
3882 ac_cpp='$CPP $CPPFLAGS'
3883 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3884 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3885 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3886
3887 ac_ext=cc
3888 ac_cpp='$CXXCPP $CPPFLAGS'
3889 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3890 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3891 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3892 if test -n "$ac_tool_prefix"; then
3893   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3894   do
3895     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3896 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3897 echo "$as_me:$LINENO: checking for $ac_word" >&5
3898 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3899 if test "${ac_cv_prog_CXX+set}" = set; then
3900   echo $ECHO_N "(cached) $ECHO_C" >&6
3901 else
3902   if test -n "$CXX"; then
3903   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3904 else
3905 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3906 for as_dir in $PATH
3907 do
3908   IFS=$as_save_IFS
3909   test -z "$as_dir" && as_dir=.
3910   for ac_exec_ext in '' $ac_executable_extensions; do
3911   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3912     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3913     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3914     break 2
3915   fi
3916 done
3917 done
3918
3919 fi
3920 fi
3921 CXX=$ac_cv_prog_CXX
3922 if test -n "$CXX"; then
3923   echo "$as_me:$LINENO: result: $CXX" >&5
3924 echo "${ECHO_T}$CXX" >&6
3925 else
3926   echo "$as_me:$LINENO: result: no" >&5
3927 echo "${ECHO_T}no" >&6
3928 fi
3929
3930     test -n "$CXX" && break
3931   done
3932 fi
3933 if test -z "$CXX"; then
3934   ac_ct_CXX=$CXX
3935   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3936 do
3937   # Extract the first word of "$ac_prog", so it can be a program name with args.
3938 set dummy $ac_prog; ac_word=$2
3939 echo "$as_me:$LINENO: checking for $ac_word" >&5
3940 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3941 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3942   echo $ECHO_N "(cached) $ECHO_C" >&6
3943 else
3944   if test -n "$ac_ct_CXX"; then
3945   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3946 else
3947 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3948 for as_dir in $PATH
3949 do
3950   IFS=$as_save_IFS
3951   test -z "$as_dir" && as_dir=.
3952   for ac_exec_ext in '' $ac_executable_extensions; do
3953   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3954     ac_cv_prog_ac_ct_CXX="$ac_prog"
3955     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3956     break 2
3957   fi
3958 done
3959 done
3960
3961 fi
3962 fi
3963 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3964 if test -n "$ac_ct_CXX"; then
3965   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3966 echo "${ECHO_T}$ac_ct_CXX" >&6
3967 else
3968   echo "$as_me:$LINENO: result: no" >&5
3969 echo "${ECHO_T}no" >&6
3970 fi
3971
3972   test -n "$ac_ct_CXX" && break
3973 done
3974 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3975
3976   CXX=$ac_ct_CXX
3977 fi
3978
3979
3980 # Provide some information about the compiler.
3981 echo "$as_me:$LINENO:" \
3982      "checking for C++ compiler version" >&5
3983 ac_compiler=`set X $ac_compile; echo $2`
3984 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3985   (eval $ac_compiler --version </dev/null >&5) 2>&5
3986   ac_status=$?
3987   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3988   (exit $ac_status); }
3989 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3990   (eval $ac_compiler -v </dev/null >&5) 2>&5
3991   ac_status=$?
3992   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3993   (exit $ac_status); }
3994 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3995   (eval $ac_compiler -V </dev/null >&5) 2>&5
3996   ac_status=$?
3997   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3998   (exit $ac_status); }
3999
4000 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4001 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4002 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4003   echo $ECHO_N "(cached) $ECHO_C" >&6
4004 else
4005   cat >conftest.$ac_ext <<_ACEOF
4006 /* confdefs.h.  */
4007 _ACEOF
4008 cat confdefs.h >>conftest.$ac_ext
4009 cat >>conftest.$ac_ext <<_ACEOF
4010 /* end confdefs.h.  */
4011
4012 int
4013 main ()
4014 {
4015 #ifndef __GNUC__
4016        choke me
4017 #endif
4018
4019   ;
4020   return 0;
4021 }
4022 _ACEOF
4023 rm -f conftest.$ac_objext
4024 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4025   (eval $ac_compile) 2>conftest.er1
4026   ac_status=$?
4027   grep -v '^ *+' conftest.er1 >conftest.err
4028   rm -f conftest.er1
4029   cat conftest.err >&5
4030   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4031   (exit $ac_status); } &&
4032          { ac_try='test -z "$ac_cxx_werror_flag"
4033                          || test ! -s conftest.err'
4034   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4035   (eval $ac_try) 2>&5
4036   ac_status=$?
4037   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4038   (exit $ac_status); }; } &&
4039          { ac_try='test -s conftest.$ac_objext'
4040   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4041   (eval $ac_try) 2>&5
4042   ac_status=$?
4043   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4044   (exit $ac_status); }; }; then
4045   ac_compiler_gnu=yes
4046 else
4047   echo "$as_me: failed program was:" >&5
4048 sed 's/^/| /' conftest.$ac_ext >&5
4049
4050 ac_compiler_gnu=no
4051 fi
4052 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4053 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4054
4055 fi
4056 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4057 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4058 GXX=`test $ac_compiler_gnu = yes && echo yes`
4059 ac_test_CXXFLAGS=${CXXFLAGS+set}
4060 ac_save_CXXFLAGS=$CXXFLAGS
4061 CXXFLAGS="-g"
4062 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4063 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4064 if test "${ac_cv_prog_cxx_g+set}" = set; then
4065   echo $ECHO_N "(cached) $ECHO_C" >&6
4066 else
4067   cat >conftest.$ac_ext <<_ACEOF
4068 /* confdefs.h.  */
4069 _ACEOF
4070 cat confdefs.h >>conftest.$ac_ext
4071 cat >>conftest.$ac_ext <<_ACEOF
4072 /* end confdefs.h.  */
4073
4074 int
4075 main ()
4076 {
4077
4078   ;
4079   return 0;
4080 }
4081 _ACEOF
4082 rm -f conftest.$ac_objext
4083 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4084   (eval $ac_compile) 2>conftest.er1
4085   ac_status=$?
4086   grep -v '^ *+' conftest.er1 >conftest.err
4087   rm -f conftest.er1
4088   cat conftest.err >&5
4089   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4090   (exit $ac_status); } &&
4091          { ac_try='test -z "$ac_cxx_werror_flag"
4092                          || test ! -s conftest.err'
4093   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4094   (eval $ac_try) 2>&5
4095   ac_status=$?
4096   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4097   (exit $ac_status); }; } &&
4098          { ac_try='test -s conftest.$ac_objext'
4099   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4100   (eval $ac_try) 2>&5
4101   ac_status=$?
4102   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4103   (exit $ac_status); }; }; then
4104   ac_cv_prog_cxx_g=yes
4105 else
4106   echo "$as_me: failed program was:" >&5
4107 sed 's/^/| /' conftest.$ac_ext >&5
4108
4109 ac_cv_prog_cxx_g=no
4110 fi
4111 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4112 fi
4113 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4114 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4115 if test "$ac_test_CXXFLAGS" = set; then
4116   CXXFLAGS=$ac_save_CXXFLAGS
4117 elif test $ac_cv_prog_cxx_g = yes; then
4118   if test "$GXX" = yes; then
4119     CXXFLAGS="-g -O2"
4120   else
4121     CXXFLAGS="-g"
4122   fi
4123 else
4124   if test "$GXX" = yes; then
4125     CXXFLAGS="-O2"
4126   else
4127     CXXFLAGS=
4128   fi
4129 fi
4130 for ac_declaration in \
4131    '' \
4132    'extern "C" void std::exit (int) throw (); using std::exit;' \
4133    'extern "C" void std::exit (int); using std::exit;' \
4134    'extern "C" void exit (int) throw ();' \
4135    'extern "C" void exit (int);' \
4136    'void exit (int);'
4137 do
4138   cat >conftest.$ac_ext <<_ACEOF
4139 /* confdefs.h.  */
4140 _ACEOF
4141 cat confdefs.h >>conftest.$ac_ext
4142 cat >>conftest.$ac_ext <<_ACEOF
4143 /* end confdefs.h.  */
4144 $ac_declaration
4145 #include <stdlib.h>
4146 int
4147 main ()
4148 {
4149 exit (42);
4150   ;
4151   return 0;
4152 }
4153 _ACEOF
4154 rm -f conftest.$ac_objext
4155 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4156   (eval $ac_compile) 2>conftest.er1
4157   ac_status=$?
4158   grep -v '^ *+' conftest.er1 >conftest.err
4159   rm -f conftest.er1
4160   cat conftest.err >&5
4161   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4162   (exit $ac_status); } &&
4163          { ac_try='test -z "$ac_cxx_werror_flag"
4164                          || test ! -s conftest.err'
4165   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4166   (eval $ac_try) 2>&5
4167   ac_status=$?
4168   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4169   (exit $ac_status); }; } &&
4170          { ac_try='test -s conftest.$ac_objext'
4171   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4172   (eval $ac_try) 2>&5
4173   ac_status=$?
4174   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4175   (exit $ac_status); }; }; then
4176   :
4177 else
4178   echo "$as_me: failed program was:" >&5
4179 sed 's/^/| /' conftest.$ac_ext >&5
4180
4181 continue
4182 fi
4183 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4184   cat >conftest.$ac_ext <<_ACEOF
4185 /* confdefs.h.  */
4186 _ACEOF
4187 cat confdefs.h >>conftest.$ac_ext
4188 cat >>conftest.$ac_ext <<_ACEOF
4189 /* end confdefs.h.  */
4190 $ac_declaration
4191 int
4192 main ()
4193 {
4194 exit (42);
4195   ;
4196   return 0;
4197 }
4198 _ACEOF
4199 rm -f conftest.$ac_objext
4200 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4201   (eval $ac_compile) 2>conftest.er1
4202   ac_status=$?
4203   grep -v '^ *+' conftest.er1 >conftest.err
4204   rm -f conftest.er1
4205   cat conftest.err >&5
4206   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4207   (exit $ac_status); } &&
4208          { ac_try='test -z "$ac_cxx_werror_flag"
4209                          || test ! -s conftest.err'
4210   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4211   (eval $ac_try) 2>&5
4212   ac_status=$?
4213   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4214   (exit $ac_status); }; } &&
4215          { ac_try='test -s conftest.$ac_objext'
4216   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4217   (eval $ac_try) 2>&5
4218   ac_status=$?
4219   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4220   (exit $ac_status); }; }; then
4221   break
4222 else
4223   echo "$as_me: failed program was:" >&5
4224 sed 's/^/| /' conftest.$ac_ext >&5
4225
4226 fi
4227 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4228 done
4229 rm -f conftest*
4230 if test -n "$ac_declaration"; then
4231   echo '#ifdef __cplusplus' >>confdefs.h
4232   echo $ac_declaration      >>confdefs.h
4233   echo '#endif'             >>confdefs.h
4234 fi
4235
4236 ac_ext=c
4237 ac_cpp='$CPP $CPPFLAGS'
4238 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4239 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4240 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4241
4242
4243 # We must set the default linker to the linker used by gcc for the correct
4244 # operation of libtool.  If LD is not defined and we are using gcc, try to
4245 # set the LD default to the ld used by gcc.
4246 if test -z "$LD"; then
4247   if test "$GCC" = yes; then
4248     case $build in
4249     *-*-mingw*)
4250       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4251     *)
4252       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4253     esac
4254     case $gcc_prog_ld in
4255     # Accept absolute paths.
4256     [\\/]* | [A-Za-z]:[\\/]*)
4257       LD="$gcc_prog_ld" ;;
4258     esac
4259   fi
4260 fi
4261
4262
4263
4264
4265 if test -n "$ac_tool_prefix"; then
4266   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4267 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4268 echo "$as_me:$LINENO: checking for $ac_word" >&5
4269 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4270 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4271   echo $ECHO_N "(cached) $ECHO_C" >&6
4272 else
4273   if test -n "$GNATBIND"; then
4274   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4275 else
4276 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4277 for as_dir in $PATH
4278 do
4279   IFS=$as_save_IFS
4280   test -z "$as_dir" && as_dir=.
4281   for ac_exec_ext in '' $ac_executable_extensions; do
4282   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4283     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4284     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4285     break 2
4286   fi
4287 done
4288 done
4289
4290 fi
4291 fi
4292 GNATBIND=$ac_cv_prog_GNATBIND
4293 if test -n "$GNATBIND"; then
4294   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4295 echo "${ECHO_T}$GNATBIND" >&6
4296 else
4297   echo "$as_me:$LINENO: result: no" >&5
4298 echo "${ECHO_T}no" >&6
4299 fi
4300
4301 fi
4302 if test -z "$ac_cv_prog_GNATBIND"; then
4303   ac_ct_GNATBIND=$GNATBIND
4304   # Extract the first word of "gnatbind", so it can be a program name with args.
4305 set dummy gnatbind; ac_word=$2
4306 echo "$as_me:$LINENO: checking for $ac_word" >&5
4307 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4308 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4309   echo $ECHO_N "(cached) $ECHO_C" >&6
4310 else
4311   if test -n "$ac_ct_GNATBIND"; then
4312   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4313 else
4314 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4315 for as_dir in $PATH
4316 do
4317   IFS=$as_save_IFS
4318   test -z "$as_dir" && as_dir=.
4319   for ac_exec_ext in '' $ac_executable_extensions; do
4320   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4321     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4322     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4323     break 2
4324   fi
4325 done
4326 done
4327
4328   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4329 fi
4330 fi
4331 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4332 if test -n "$ac_ct_GNATBIND"; then
4333   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4334 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4335 else
4336   echo "$as_me:$LINENO: result: no" >&5
4337 echo "${ECHO_T}no" >&6
4338 fi
4339
4340   GNATBIND=$ac_ct_GNATBIND
4341 else
4342   GNATBIND="$ac_cv_prog_GNATBIND"
4343 fi
4344
4345 if test -n "$ac_tool_prefix"; then
4346   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4347 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4348 echo "$as_me:$LINENO: checking for $ac_word" >&5
4349 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4350 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4351   echo $ECHO_N "(cached) $ECHO_C" >&6
4352 else
4353   if test -n "$GNATMAKE"; then
4354   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4355 else
4356 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4357 for as_dir in $PATH
4358 do
4359   IFS=$as_save_IFS
4360   test -z "$as_dir" && as_dir=.
4361   for ac_exec_ext in '' $ac_executable_extensions; do
4362   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4363     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4364     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4365     break 2
4366   fi
4367 done
4368 done
4369
4370 fi
4371 fi
4372 GNATMAKE=$ac_cv_prog_GNATMAKE
4373 if test -n "$GNATMAKE"; then
4374   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4375 echo "${ECHO_T}$GNATMAKE" >&6
4376 else
4377   echo "$as_me:$LINENO: result: no" >&5
4378 echo "${ECHO_T}no" >&6
4379 fi
4380
4381 fi
4382 if test -z "$ac_cv_prog_GNATMAKE"; then
4383   ac_ct_GNATMAKE=$GNATMAKE
4384   # Extract the first word of "gnatmake", so it can be a program name with args.
4385 set dummy gnatmake; ac_word=$2
4386 echo "$as_me:$LINENO: checking for $ac_word" >&5
4387 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4388 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4389   echo $ECHO_N "(cached) $ECHO_C" >&6
4390 else
4391   if test -n "$ac_ct_GNATMAKE"; then
4392   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4393 else
4394 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4395 for as_dir in $PATH
4396 do
4397   IFS=$as_save_IFS
4398   test -z "$as_dir" && as_dir=.
4399   for ac_exec_ext in '' $ac_executable_extensions; do
4400   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4401     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4402     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4403     break 2
4404   fi
4405 done
4406 done
4407
4408   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4409 fi
4410 fi
4411 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4412 if test -n "$ac_ct_GNATMAKE"; then
4413   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4414 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4415 else
4416   echo "$as_me:$LINENO: result: no" >&5
4417 echo "${ECHO_T}no" >&6
4418 fi
4419
4420   GNATMAKE=$ac_ct_GNATMAKE
4421 else
4422   GNATMAKE="$ac_cv_prog_GNATMAKE"
4423 fi
4424
4425 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4426 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4427 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4428   echo $ECHO_N "(cached) $ECHO_C" >&6
4429 else
4430   cat >conftest.adb <<EOF
4431 procedure conftest is begin null; end conftest;
4432 EOF
4433 acx_cv_cc_gcc_supports_ada=no
4434 # There is a bug in old released versions of GCC which causes the
4435 # driver to exit successfully when the appropriate language module
4436 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4437 # Therefore we must check for the error message as well as an
4438 # unsuccessful exit.
4439 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4440 # given a .adb file, but produce no object file.  So we must check
4441 # if an object file was really produced to guard against this.
4442 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4443 if test x"$errors" = x && test -f conftest.$ac_objext; then
4444   acx_cv_cc_gcc_supports_ada=yes
4445 fi
4446 rm -f conftest.*
4447 fi
4448 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4449 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4450
4451 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4452   have_gnat=yes
4453 else
4454   have_gnat=no
4455 fi
4456
4457 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4458 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4459 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4460   echo $ECHO_N "(cached) $ECHO_C" >&6
4461 else
4462    echo abfoo >t1
4463   echo cdfoo >t2
4464   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4465   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4466     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4467       :
4468     else
4469       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4470     fi
4471   fi
4472   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4473     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4474       :
4475     else
4476       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4477     fi
4478   fi
4479   rm t1 t2
4480
4481 fi
4482 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4483 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4484 do_compare="$gcc_cv_prog_cmp_skip"
4485
4486
4487
4488 # Check for GMP and MPFR
4489 gmplibs="-lmpfr -lgmp"
4490 gmpinc=
4491 have_gmp=no
4492
4493 # Specify a location for mpfr
4494 # check for this first so it ends up on the link line before gmp.
4495
4496 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4497 if test "${with_mpfr_dir+set}" = set; then
4498   withval="$with_mpfr_dir"
4499   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4500 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4501 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4502 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4503    { (exit 1); exit 1; }; }
4504 fi;
4505
4506
4507 # Check whether --with-mpfr or --without-mpfr was given.
4508 if test "${with_mpfr+set}" = set; then
4509   withval="$with_mpfr"
4510
4511 fi;
4512
4513 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4514 if test "${with_mpfr_include+set}" = set; then
4515   withval="$with_mpfr_include"
4516
4517 fi;
4518
4519 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4520 if test "${with_mpfr_lib+set}" = set; then
4521   withval="$with_mpfr_lib"
4522
4523 fi;
4524
4525 if test "x$with_mpfr" != x; then
4526   gmplibs="-L$with_mpfr/lib $gmplibs"
4527   gmpinc="-I$with_mpfr/include"
4528 fi
4529 if test "x$with_mpfr_include" != x; then
4530   gmpinc="-I$with_mpfr_include"
4531 fi
4532 if test "x$with_mpfr_lib" != x; then
4533   gmplibs="-L$with_mpfr_lib $gmplibs"
4534 fi
4535 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4536   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4537   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4538   # Do not test the mpfr version.  Assume that it is sufficient, since
4539   # it is in the source tree, and the library has not been built yet
4540   # but it would be included on the link line in the version check below
4541   # hence making the test fail.
4542   have_gmp=yes
4543 fi
4544
4545 # Specify a location for gmp
4546
4547 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4548 if test "${with_gmp_dir+set}" = set; then
4549   withval="$with_gmp_dir"
4550   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4551 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4552 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4553 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4554    { (exit 1); exit 1; }; }
4555 fi;
4556
4557
4558 # Check whether --with-gmp or --without-gmp was given.
4559 if test "${with_gmp+set}" = set; then
4560   withval="$with_gmp"
4561
4562 fi;
4563
4564 # Check whether --with-gmp_include or --without-gmp_include was given.
4565 if test "${with_gmp_include+set}" = set; then
4566   withval="$with_gmp_include"
4567
4568 fi;
4569
4570 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4571 if test "${with_gmp_lib+set}" = set; then
4572   withval="$with_gmp_lib"
4573
4574 fi;
4575
4576
4577 if test "x$with_gmp" != x; then
4578   gmplibs="-L$with_gmp/lib $gmplibs"
4579   gmpinc="-I$with_gmp/include $gmpinc"
4580 fi
4581 if test "x$with_gmp_include" != x; then
4582   gmpinc="-I$with_gmp_include $gmpinc"
4583 fi
4584 if test "x$with_gmp_lib" != x; then
4585   gmplibs="-L$with_gmp_lib $gmplibs"
4586 fi
4587 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4588   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4589   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4590   # Do not test the gmp version.  Assume that it is sufficient, since
4591   # it is in the source tree, and the library has not been built yet
4592   # but it would be included on the link line in the version check below
4593   # hence making the test fail.
4594   have_gmp=yes
4595 fi
4596
4597 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4598   have_gmp=yes
4599   saved_CFLAGS="$CFLAGS"
4600   CFLAGS="$CFLAGS $gmpinc"
4601   # Check GMP actually works
4602   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4603 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4604
4605 cat >conftest.$ac_ext <<_ACEOF
4606 /* confdefs.h.  */
4607 _ACEOF
4608 cat confdefs.h >>conftest.$ac_ext
4609 cat >>conftest.$ac_ext <<_ACEOF
4610 /* end confdefs.h.  */
4611 #include "gmp.h"
4612 int
4613 main ()
4614 {
4615
4616   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4617   choke me
4618   #endif
4619
4620   ;
4621   return 0;
4622 }
4623 _ACEOF
4624 rm -f conftest.$ac_objext
4625 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4626   (eval $ac_compile) 2>conftest.er1
4627   ac_status=$?
4628   grep -v '^ *+' conftest.er1 >conftest.err
4629   rm -f conftest.er1
4630   cat conftest.err >&5
4631   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4632   (exit $ac_status); } &&
4633          { ac_try='test -z "$ac_c_werror_flag"
4634                          || test ! -s conftest.err'
4635   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4636   (eval $ac_try) 2>&5
4637   ac_status=$?
4638   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4639   (exit $ac_status); }; } &&
4640          { ac_try='test -s conftest.$ac_objext'
4641   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4642   (eval $ac_try) 2>&5
4643   ac_status=$?
4644   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4645   (exit $ac_status); }; }; then
4646   echo "$as_me:$LINENO: result: yes" >&5
4647 echo "${ECHO_T}yes" >&6
4648 else
4649   echo "$as_me: failed program was:" >&5
4650 sed 's/^/| /' conftest.$ac_ext >&5
4651
4652 echo "$as_me:$LINENO: result: no" >&5
4653 echo "${ECHO_T}no" >&6; have_gmp=no
4654 fi
4655 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4656
4657   if test x"$have_gmp" = xyes; then
4658     saved_LIBS="$LIBS"
4659     LIBS="$LIBS $gmplibs"
4660         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4661 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4662     cat >conftest.$ac_ext <<_ACEOF
4663 /* confdefs.h.  */
4664 _ACEOF
4665 cat confdefs.h >>conftest.$ac_ext
4666 cat >>conftest.$ac_ext <<_ACEOF
4667 /* end confdefs.h.  */
4668 #include <gmp.h>
4669     #include <mpfr.h>
4670 int
4671 main ()
4672 {
4673
4674     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4675     choke me
4676     #endif
4677     mpfr_t n;
4678     mpfr_t x;
4679     int t;
4680     mpfr_init (n);
4681     mpfr_init (x);
4682     mpfr_atan2 (n, n, x, GMP_RNDN);
4683     mpfr_erfc (n, x, GMP_RNDN);
4684     mpfr_subnormalize (x, t, GMP_RNDN);
4685
4686   ;
4687   return 0;
4688 }
4689 _ACEOF
4690 rm -f conftest.$ac_objext conftest$ac_exeext
4691 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4692   (eval $ac_link) 2>conftest.er1
4693   ac_status=$?
4694   grep -v '^ *+' conftest.er1 >conftest.err
4695   rm -f conftest.er1
4696   cat conftest.err >&5
4697   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4698   (exit $ac_status); } &&
4699          { ac_try='test -z "$ac_c_werror_flag"
4700                          || test ! -s conftest.err'
4701   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4702   (eval $ac_try) 2>&5
4703   ac_status=$?
4704   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4705   (exit $ac_status); }; } &&
4706          { ac_try='test -s conftest$ac_exeext'
4707   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4708   (eval $ac_try) 2>&5
4709   ac_status=$?
4710   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4711   (exit $ac_status); }; }; then
4712   cat >conftest.$ac_ext <<_ACEOF
4713 /* confdefs.h.  */
4714 _ACEOF
4715 cat confdefs.h >>conftest.$ac_ext
4716 cat >>conftest.$ac_ext <<_ACEOF
4717 /* end confdefs.h.  */
4718 #include <gmp.h>
4719     #include <mpfr.h>
4720 int
4721 main ()
4722 {
4723
4724     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4725     choke me
4726     #endif
4727     mpfr_t n; mpfr_init(n);
4728
4729   ;
4730   return 0;
4731 }
4732 _ACEOF
4733 rm -f conftest.$ac_objext conftest$ac_exeext
4734 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4735   (eval $ac_link) 2>conftest.er1
4736   ac_status=$?
4737   grep -v '^ *+' conftest.er1 >conftest.err
4738   rm -f conftest.er1
4739   cat conftest.err >&5
4740   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4741   (exit $ac_status); } &&
4742          { ac_try='test -z "$ac_c_werror_flag"
4743                          || test ! -s conftest.err'
4744   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4745   (eval $ac_try) 2>&5
4746   ac_status=$?
4747   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4748   (exit $ac_status); }; } &&
4749          { ac_try='test -s conftest$ac_exeext'
4750   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4751   (eval $ac_try) 2>&5
4752   ac_status=$?
4753   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4754   (exit $ac_status); }; }; then
4755   echo "$as_me:$LINENO: result: yes" >&5
4756 echo "${ECHO_T}yes" >&6
4757 else
4758   echo "$as_me: failed program was:" >&5
4759 sed 's/^/| /' conftest.$ac_ext >&5
4760
4761 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4762 echo "${ECHO_T}buggy but acceptable" >&6
4763 fi
4764 rm -f conftest.err conftest.$ac_objext \
4765       conftest$ac_exeext conftest.$ac_ext
4766 else
4767   echo "$as_me: failed program was:" >&5
4768 sed 's/^/| /' conftest.$ac_ext >&5
4769
4770 echo "$as_me:$LINENO: result: no" >&5
4771 echo "${ECHO_T}no" >&6; have_gmp=no
4772 fi
4773 rm -f conftest.err conftest.$ac_objext \
4774       conftest$ac_exeext conftest.$ac_ext
4775       LIBS="$saved_LIBS"
4776   fi
4777   CFLAGS="$saved_CFLAGS"
4778
4779   if test x$have_gmp != xyes; then
4780     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4781 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4782 Copies of these libraries' source code can be found at their respective
4783 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4784 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4785 If you obtained GMP and/or MPFR from a vendor distribution package, make
4786 sure that you have installed both the libraries and the header files.
4787 They may be located in separate packages." >&5
4788 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4789 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4790 Copies of these libraries' source code can be found at their respective
4791 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4792 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4793 If you obtained GMP and/or MPFR from a vendor distribution package, make
4794 sure that you have installed both the libraries and the header files.
4795 They may be located in separate packages." >&2;}
4796    { (exit 1); exit 1; }; }
4797   fi
4798 fi
4799
4800 # Flags needed for both GMP and/or MPFR
4801
4802
4803
4804
4805 # Check for PPL
4806 ppl_major_version=0
4807 ppl_minor_version=10
4808 ppllibs=
4809 pplinc=
4810
4811
4812 # Check whether --with-ppl or --without-ppl was given.
4813 if test "${with_ppl+set}" = set; then
4814   withval="$with_ppl"
4815
4816 fi;
4817
4818 # Check whether --with-ppl_include or --without-ppl_include was given.
4819 if test "${with_ppl_include+set}" = set; then
4820   withval="$with_ppl_include"
4821
4822 fi;
4823
4824 # Check whether --with-ppl_lib or --without-ppl_lib was given.
4825 if test "${with_ppl_lib+set}" = set; then
4826   withval="$with_ppl_lib"
4827
4828 fi;
4829
4830 if test "x$with_ppl" != x; then
4831   ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx"
4832   pplinc="-I$with_ppl/include $pplinc"
4833   LIBS="$ppllibs $LIBS"
4834 fi
4835 if test "x$with_ppl_include" != x; then
4836   pplinc="-I$with_ppl_include $pplinc"
4837 fi
4838 if test "x$with_ppl_lib" != x; then
4839   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx"
4840   LIBS="$ppllibs $LIBS"
4841 fi
4842 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
4843   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '
4844   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
4845   LIBS="$ppllibs $LIBS"
4846 fi
4847
4848 # Flags needed for PPL
4849
4850
4851
4852
4853 # Check for CLOOG
4854 clooglibs=
4855 clooginc=
4856
4857
4858 # Check whether --with-cloog or --without-cloog was given.
4859 if test "${with_cloog+set}" = set; then
4860   withval="$with_cloog"
4861
4862 fi;
4863
4864 # Check whether --with-cloog_include or --without-cloog_include was given.
4865 if test "${with_cloog_include+set}" = set; then
4866   withval="$with_cloog_include"
4867
4868 fi;
4869
4870 # Check whether --with-cloog_lib or --without-cloog_lib was given.
4871 if test "${with_cloog_lib+set}" = set; then
4872   withval="$with_cloog_lib"
4873
4874 fi;
4875
4876 if test "x$with_cloog" != x; then
4877   clooglibs="-L$with_cloog/lib -lcloog"
4878   clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
4879   LIBS="$clooglibs $LIBS"
4880 fi
4881 if test "x$with_cloog_include" != x; then
4882   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
4883 fi
4884 if test "x$with_cloog_lib" != x; then
4885   clooglibs="-L$with_cloog_lib -lcloog"
4886   LIBS="$clooglibs $LIBS"
4887 fi
4888 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
4889   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
4890   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
4891   LIBS="$clooglibs $LIBS"
4892 fi
4893
4894 saved_CFLAGS="$CFLAGS"
4895 CFLAGS="$CFLAGS $pplinc $gmpinc"
4896
4897 echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
4898 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
4899 cat >conftest.$ac_ext <<_ACEOF
4900 /* confdefs.h.  */
4901 _ACEOF
4902 cat confdefs.h >>conftest.$ac_ext
4903 cat >>conftest.$ac_ext <<_ACEOF
4904 /* end confdefs.h.  */
4905 #include "ppl_c.h"
4906 int
4907 main ()
4908 {
4909
4910 #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
4911 choke me
4912 #endif
4913
4914   ;
4915   return 0;
4916 }
4917 _ACEOF
4918 rm -f conftest.$ac_objext
4919 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4920   (eval $ac_compile) 2>conftest.er1
4921   ac_status=$?
4922   grep -v '^ *+' conftest.er1 >conftest.err
4923   rm -f conftest.er1
4924   cat conftest.err >&5
4925   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4926   (exit $ac_status); } &&
4927          { ac_try='test -z "$ac_c_werror_flag"
4928                          || test ! -s conftest.err'
4929   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4930   (eval $ac_try) 2>&5
4931   ac_status=$?
4932   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4933   (exit $ac_status); }; } &&
4934          { ac_try='test -s conftest.$ac_objext'
4935   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4936   (eval $ac_try) 2>&5
4937   ac_status=$?
4938   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4939   (exit $ac_status); }; }; then
4940   echo "$as_me:$LINENO: result: yes" >&5
4941 echo "${ECHO_T}yes" >&6
4942 else
4943   echo "$as_me: failed program was:" >&5
4944 sed 's/^/| /' conftest.$ac_ext >&5
4945
4946 echo "$as_me:$LINENO: result: no" >&5
4947 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
4948 fi
4949 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4950 CFLAGS="$saved_CFLAGS"
4951
4952 saved_CFLAGS="$CFLAGS"
4953 CFLAGS="$CFLAGS $clooginc -DCLOOG_PPL_BACKEND $gmpinc $pplinc"
4954
4955 echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
4956 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
4957 cat >conftest.$ac_ext <<_ACEOF
4958 /* confdefs.h.  */
4959 _ACEOF
4960 cat confdefs.h >>conftest.$ac_ext
4961 cat >>conftest.$ac_ext <<_ACEOF
4962 /* end confdefs.h.  */
4963 #include "cloog/cloog.h"
4964 int
4965 main ()
4966 {
4967
4968 #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
4969 choke me
4970 #endif
4971
4972   ;
4973   return 0;
4974 }
4975 _ACEOF
4976 rm -f conftest.$ac_objext
4977 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4978   (eval $ac_compile) 2>conftest.er1
4979   ac_status=$?
4980   grep -v '^ *+' conftest.er1 >conftest.err
4981   rm -f conftest.er1
4982   cat conftest.err >&5
4983   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4984   (exit $ac_status); } &&
4985          { ac_try='test -z "$ac_c_werror_flag"
4986                          || test ! -s conftest.err'
4987   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4988   (eval $ac_try) 2>&5
4989   ac_status=$?
4990   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4991   (exit $ac_status); }; } &&
4992          { ac_try='test -s conftest.$ac_objext'
4993   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4994   (eval $ac_try) 2>&5
4995   ac_status=$?
4996   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4997   (exit $ac_status); }; }; then
4998   echo "$as_me:$LINENO: result: yes" >&5
4999 echo "${ECHO_T}yes" >&6
5000 else
5001   echo "$as_me: failed program was:" >&5
5002 sed 's/^/| /' conftest.$ac_ext >&5
5003
5004 echo "$as_me:$LINENO: result: no" >&5
5005 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5006 fi
5007 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5008 CFLAGS="$saved_CFLAGS"
5009
5010 # Flags needed for CLOOG
5011
5012
5013
5014
5015 # By default, C is the only stage 1 language.
5016 stage1_languages=,c,
5017
5018 # Figure out what language subdirectories are present.
5019 # Look if the user specified --enable-languages="..."; if not, use
5020 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5021 # go away some day.
5022 # NB:  embedded tabs in this IF block -- do not untabify
5023 if test -d ${srcdir}/gcc; then
5024   if test x"${enable_languages+set}" != xset; then
5025     if test x"${LANGUAGES+set}" = xset; then
5026       enable_languages="${LANGUAGES}"
5027         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5028     else
5029       enable_languages=all
5030     fi
5031   else
5032     if test x"${enable_languages}" = x ||
5033        test x"${enable_languages}" = xyes;
5034        then
5035       echo configure.in: --enable-languages needs at least one language argument 1>&2
5036       exit 1
5037     fi
5038   fi
5039   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5040
5041   # 'f95' is the old name for the 'fortran' language. We issue a warning
5042   # and make the substitution.
5043   case ,${enable_languages}, in
5044     *,f95,*)
5045       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5046       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5047       ;;
5048   esac
5049
5050   # First scan to see if an enabled language requires some other language.
5051   # We assume that a given config-lang.in will list all the language
5052   # front ends it requires, even if some are required indirectly.
5053   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5054     case ${lang_frag} in
5055       ..) ;;
5056       # The odd quoting in the next line works around
5057       # an apparent bug in bash 1.12 on linux.
5058       ${srcdir}/gcc/[*]/config-lang.in) ;;
5059       *)
5060         # From the config-lang.in, get $language, $lang_requires
5061         language=
5062         lang_requires=
5063         . ${lang_frag}
5064         for other in ${lang_requires} ; do
5065           case ,${enable_languages}, in
5066             *,$other,*) ;;
5067             *,all,*) ;;
5068             *,$language,*)
5069               echo " \`$other' language required by \`$language'; enabling" 1>&2
5070               enable_languages="${enable_languages},${other}"
5071               ;;
5072           esac
5073         done
5074         ;;
5075     esac
5076   done
5077
5078   new_enable_languages=,c,
5079   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5080   potential_languages=,c,
5081
5082   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5083     case ${lang_frag} in
5084       ..) ;;
5085       # The odd quoting in the next line works around
5086       # an apparent bug in bash 1.12 on linux.
5087       ${srcdir}/gcc/[*]/config-lang.in) ;;
5088       *)
5089         # From the config-lang.in, get $language, $target_libs,
5090         # $lang_dirs, $boot_language, and $build_by_default
5091         language=
5092         target_libs=
5093         lang_dirs=
5094         subdir_requires=
5095         boot_language=no
5096         build_by_default=yes
5097         . ${lang_frag}
5098         if test x${language} = x; then
5099           echo "${lang_frag} doesn't set \$language." 1>&2
5100           exit 1
5101         fi
5102
5103         case ,${enable_languages}, in
5104           *,${language},*)
5105             # Language was explicitly selected; include it.
5106             add_this_lang=yes
5107             ;;
5108           *,all,*)
5109             # 'all' was selected, select it if it is a default language
5110             add_this_lang=${build_by_default}
5111             ;;
5112           *)
5113             add_this_lang=no
5114             ;;
5115         esac
5116
5117         # Disable languages that need other directories if these aren't available.
5118         for i in $subdir_requires; do
5119           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5120           case ,${enable_languages}, in
5121             *,${language},*)
5122               # Specifically requested language; tell them.
5123               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5124 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5125    { (exit 1); exit 1; }; }
5126               ;;
5127             *)
5128               # Silently disable.
5129               add_this_lang=unsupported
5130               ;;
5131           esac
5132         done
5133
5134         # Disable Ada if no preexisting GNAT is available.
5135         case ,${enable_languages},:${language}:${have_gnat} in
5136           *,${language},*:ada:no)
5137             # Specifically requested language; tell them.
5138             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5139 echo "$as_me: error: GNAT is required to build $language" >&2;}
5140    { (exit 1); exit 1; }; }
5141             ;;
5142           *:ada:no)
5143             # Silently disable.
5144             add_this_lang=unsupported
5145             ;;
5146         esac
5147
5148         # Disable a language that is unsupported by the target.
5149         case " $unsupported_languages " in
5150           *" $language "*)
5151             add_this_lang=unsupported
5152             ;;
5153         esac
5154
5155         case $add_this_lang in
5156           unsupported)
5157             # Remove language-dependent dirs.
5158             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5159             ;;
5160           no)
5161             # Remove language-dependent dirs; still show language as supported.
5162             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5163             potential_languages="${potential_languages}${language},"
5164             ;;
5165           yes)
5166             new_enable_languages="${new_enable_languages}${language},"
5167             potential_languages="${potential_languages}${language},"
5168             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5169             case ${boot_language} in
5170               yes)
5171                 # Add to (comma-separated) list of stage 1 languages.
5172                 stage1_languages="${stage1_languages}${language},"
5173                 ;;
5174             esac
5175             ;;
5176         esac
5177         ;;
5178     esac
5179   done
5180
5181   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5182 if test "${enable_stage1_languages+set}" = set; then
5183   enableval="$enable_stage1_languages"
5184   case ,${enable_stage1_languages}, in
5185     ,no,|,,)
5186       # Set it to something that will have no effect in the loop below
5187       enable_stage1_languages=c ;;
5188     ,yes,)
5189       enable_stage1_languages=`echo $new_enable_languages | \
5190         sed -e "s/^,//" -e "s/,$//" ` ;;
5191     *,all,*)
5192       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5193         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5194   esac
5195
5196   # Add "good" languages from enable_stage1_languages to stage1_languages,
5197   # while "bad" languages go in missing_languages.  Leave no duplicates.
5198   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5199     case $potential_languages in
5200       *,$i,*)
5201         case $stage1_languages in
5202           *,$i,*) ;;
5203           *) stage1_languages="$stage1_languages$i," ;;
5204         esac ;;
5205       *)
5206         case $missing_languages in
5207           *,$i,*) ;;
5208           *) missing_languages="$missing_languages$i," ;;
5209         esac ;;
5210      esac
5211   done
5212 fi;
5213
5214   # Remove leading/trailing commas that were added for simplicity
5215   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5216   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5217   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5218   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5219
5220   if test "x$missing_languages" != x; then
5221     { { echo "$as_me:$LINENO: error:
5222 The following requested languages could not be built: ${missing_languages}
5223 Supported languages are: ${potential_languages}" >&5
5224 echo "$as_me: error:
5225 The following requested languages could not be built: ${missing_languages}
5226 Supported languages are: ${potential_languages}" >&2;}
5227    { (exit 1); exit 1; }; }
5228   fi
5229   if test "x$new_enable_languages" != "x$enable_languages"; then
5230     echo The following languages will be built: ${new_enable_languages}
5231     enable_languages="$new_enable_languages"
5232   fi
5233
5234
5235   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5236 fi
5237
5238 # Handle --disable-<component> generically.
5239 for dir in $configdirs $build_configdirs $target_configdirs ; do
5240   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5241   varname=`echo $dirname | sed -e s/+/_/g`
5242   if eval test x\${enable_${varname}} "=" xno ; then
5243     noconfigdirs="$noconfigdirs $dir"
5244   fi
5245 done
5246
5247 # Check for Boehm's garbage collector
5248 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5249 if test "${enable_objc_gc+set}" = set; then
5250   enableval="$enable_objc_gc"
5251   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5252   *,objc,*:*:yes:*target-boehm-gc*)
5253     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5254 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5255    { (exit 1); exit 1; }; }
5256     ;;
5257 esac
5258 fi;
5259
5260 # Make sure we only build Boehm's garbage collector if required.
5261 case ,${enable_languages},:${enable_objc_gc} in
5262   *,objc,*:yes)
5263     # Keep target-boehm-gc if requested for Objective-C.
5264     ;;
5265   *)
5266     # Otherwise remove target-boehm-gc depending on target-libjava.
5267     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5268       noconfigdirs="$noconfigdirs target-boehm-gc"
5269     fi
5270     ;;
5271 esac
5272
5273 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5274 # $build_configdirs and $target_configdirs.
5275 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5276
5277 notsupp=""
5278 for dir in . $skipdirs $noconfigdirs ; do
5279   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5280   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5281     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5282     if test -r $srcdir/$dirname/configure ; then
5283       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5284         true
5285       else
5286         notsupp="$notsupp $dir"
5287       fi
5288     fi
5289   fi
5290   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5291     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5292     if test -r $srcdir/$dirname/configure ; then
5293       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5294         true
5295       else
5296         notsupp="$notsupp $dir"
5297       fi
5298     fi
5299   fi
5300   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5301     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5302     if test -r $srcdir/$dirname/configure ; then
5303       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5304         true
5305       else
5306         notsupp="$notsupp $dir"
5307       fi
5308     fi
5309   fi
5310 done
5311
5312 # Sometimes the tools are distributed with libiberty but with no other
5313 # libraries.  In that case, we don't want to build target-libiberty.
5314 # Don't let libgcc imply libiberty either.
5315 if test -n "${target_configdirs}" ; then
5316   libgcc=
5317   others=
5318   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5319     if test "$i" = "libgcc"; then
5320       libgcc=target-libgcc
5321     elif test "$i" != "libiberty" ; then
5322       if test -r $srcdir/$i/configure ; then
5323         others=yes;
5324         break;
5325       fi
5326     fi
5327   done
5328   if test -z "${others}" ; then
5329     target_configdirs=$libgcc
5330   fi
5331 fi
5332
5333 # Quietly strip out all directories which aren't configurable in this tree.
5334 # This relies on all configurable subdirectories being autoconfiscated, which
5335 # is now the case.
5336 build_configdirs_all="$build_configdirs"
5337 build_configdirs=
5338 for i in ${build_configdirs_all} ; do
5339   j=`echo $i | sed -e s/build-//g`
5340   if test -f ${srcdir}/$j/configure ; then
5341     build_configdirs="${build_configdirs} $i"
5342   fi
5343 done
5344
5345 configdirs_all="$configdirs"
5346 configdirs=
5347 for i in ${configdirs_all} ; do
5348   if test -f ${srcdir}/$i/configure ; then
5349     configdirs="${configdirs} $i"
5350   fi
5351 done
5352
5353 target_configdirs_all="$target_configdirs"
5354 target_configdirs=
5355 for i in ${target_configdirs_all} ; do
5356   j=`echo $i | sed -e s/target-//g`
5357   if test -f ${srcdir}/$j/configure ; then
5358     target_configdirs="${target_configdirs} $i"
5359   fi
5360 done
5361
5362 # Produce a warning message for the subdirs we can't configure.
5363 # This isn't especially interesting in the Cygnus tree, but in the individual
5364 # FSF releases, it's important to let people know when their machine isn't
5365 # supported by the one or two programs in a package.
5366
5367 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5368   # If $appdirs is non-empty, at least one of those directories must still
5369   # be configured, or we error out.  (E.g., if the gas release supports a
5370   # specified target in some subdirs but not the gas subdir, we shouldn't
5371   # pretend that all is well.)
5372   if test -n "$appdirs" ; then
5373     for dir in $appdirs ; do
5374       if test -r $dir/Makefile.in ; then
5375         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5376           appdirs=""
5377           break
5378         fi
5379         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5380           appdirs=""
5381           break
5382         fi
5383       fi
5384     done
5385     if test -n "$appdirs" ; then
5386       echo "*** This configuration is not supported by this package." 1>&2
5387       exit 1
5388     fi
5389   fi
5390   # Okay, some application will build, or we don't care to check.  Still
5391   # notify of subdirs not getting built.
5392   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5393   echo "    ${notsupp}" 1>&2
5394   echo "    (Any other directories should still work fine.)" 1>&2
5395 fi
5396
5397 case "$host" in
5398   *msdosdjgpp*)
5399     enable_gdbtk=no ;;
5400 esac
5401
5402 # To find our prefix, in gcc_cv_tool_prefix.
5403
5404 # The user is always right.
5405 if test "${PATH_SEPARATOR+set}" != set; then
5406   echo "#! /bin/sh" >conf$$.sh
5407   echo  "exit 0"   >>conf$$.sh
5408   chmod +x conf$$.sh
5409   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5410     PATH_SEPARATOR=';'
5411   else
5412     PATH_SEPARATOR=:
5413   fi
5414   rm -f conf$$.sh
5415 fi
5416
5417
5418
5419 if test "x$exec_prefix" = xNONE; then
5420         if test "x$prefix" = xNONE; then
5421                 gcc_cv_tool_prefix=$ac_default_prefix
5422         else
5423                 gcc_cv_tool_prefix=$prefix
5424         fi
5425 else
5426         gcc_cv_tool_prefix=$exec_prefix
5427 fi
5428
5429 # If there is no compiler in the tree, use the PATH only.  In any
5430 # case, if there is no compiler in the tree nobody should use
5431 # AS_FOR_TARGET and LD_FOR_TARGET.
5432 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5433     gcc_version=`cat $srcdir/gcc/BASE-VER`
5434     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5435     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5436     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5437     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5438     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5439     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5440 else
5441     gcc_cv_tool_dirs=
5442 fi
5443
5444 if test x$build = x$target && test -n "$md_exec_prefix"; then
5445         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5446 fi
5447
5448
5449
5450 copy_dirs=
5451
5452
5453 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5454 if test "${with_build_sysroot+set}" = set; then
5455   withval="$with_build_sysroot"
5456   if test x"$withval" != x ; then
5457      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5458    fi
5459 else
5460   SYSROOT_CFLAGS_FOR_TARGET=
5461 fi;
5462
5463
5464
5465 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5466 if test "${with_debug_prefix_map+set}" = set; then
5467   withval="$with_debug_prefix_map"
5468   if test x"$withval" != x; then
5469      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5470      for debug_map in $withval; do
5471        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5472      done
5473    fi
5474 else
5475   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5476 fi;
5477
5478
5479 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5480 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5481 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5482 # We want to ensure that TARGET libraries (which we know are built with
5483 # gcc) are built with "-O2 -g", so include those options when setting
5484 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5485 if test "x$CFLAGS_FOR_TARGET" = x; then
5486   CFLAGS_FOR_TARGET=$CFLAGS
5487   case " $CFLAGS " in
5488     *" -O2 "*) ;;
5489     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5490   esac
5491   case " $CFLAGS " in
5492     *" -g "* | *" -g3 "*) ;;
5493     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5494   esac
5495 fi
5496
5497
5498 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5499   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5500   case " $CXXFLAGS " in
5501     *" -O2 "*) ;;
5502     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5503   esac
5504   case " $CXXFLAGS " in
5505     *" -g "* | *" -g3 "*) ;;
5506     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5507   esac
5508 fi
5509
5510
5511 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5512 # the named directory are copied to $(tooldir)/sys-include.
5513 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5514   if test x${is_cross_compiler} = xno ; then
5515     echo 1>&2 '***' --with-headers is only supported when cross compiling
5516     exit 1
5517   fi
5518   if test x"${with_headers}" != xyes ; then
5519     x=${gcc_cv_tool_prefix}
5520     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5521   fi
5522 fi
5523
5524 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5525 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5526 # are permitted.
5527 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5528   if test x${is_cross_compiler} = xno ; then
5529     echo 1>&2 '***' --with-libs is only supported when cross compiling
5530     exit 1
5531   fi
5532   if test x"${with_libs}" != xyes ; then
5533     # Copy the libraries in reverse order, so that files in the first named
5534     # library override files in subsequent libraries.
5535     x=${gcc_cv_tool_prefix}
5536     for l in ${with_libs}; do
5537       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5538     done
5539   fi
5540 fi
5541
5542 # Set with_gnu_as and with_gnu_ld as appropriate.
5543 #
5544 # This is done by determining whether or not the appropriate directory
5545 # is available, and by checking whether or not specific configurations
5546 # have requested that this magic not happen.
5547 #
5548 # The command line options always override the explicit settings in
5549 # configure.in, and the settings in configure.in override this magic.
5550 #
5551 # If the default for a toolchain is to use GNU as and ld, and you don't
5552 # want to do that, then you should use the --without-gnu-as and
5553 # --without-gnu-ld options for the configure script.
5554
5555 if test x${use_gnu_as} = x &&
5556    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5557   with_gnu_as=yes
5558   extra_host_args="$extra_host_args --with-gnu-as"
5559 fi
5560
5561 if test x${use_gnu_ld} = x &&
5562    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5563   with_gnu_ld=yes
5564   extra_host_args="$extra_host_args --with-gnu-ld"
5565 fi
5566
5567 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5568 # can detect this case.
5569
5570 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5571   with_newlib=yes
5572   extra_host_args="$extra_host_args --with-newlib"
5573 fi
5574
5575 # Handle ${copy_dirs}
5576 set fnord ${copy_dirs}
5577 shift
5578 while test $# != 0 ; do
5579   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5580     :
5581   else
5582     echo Copying $1 to $2
5583
5584     # Use the install script to create the directory and all required
5585     # parent directories.
5586     if test -d $2 ; then
5587       :
5588     else
5589       echo >config.temp
5590       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5591     fi
5592
5593     # Copy the directory, assuming we have tar.
5594     # FIXME: Should we use B in the second tar?  Not all systems support it.
5595     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5596
5597     # It is the responsibility of the user to correctly adjust all
5598     # symlinks.  If somebody can figure out how to handle them correctly
5599     # here, feel free to add the code.
5600
5601     echo $1 > $2/COPIED
5602   fi
5603   shift; shift
5604 done
5605
5606 # Determine a target-dependent exec_prefix that the installed
5607 # gcc will search in.  Keep this list sorted by triplet, with
5608 # the *-*-osname triplets last.
5609 md_exec_prefix=
5610 case "${target}" in
5611   alpha*-*-*vms*)
5612     md_exec_prefix=/gnu/lib/gcc-lib
5613     ;;
5614   i[34567]86-pc-msdosdjgpp*)
5615     md_exec_prefix=/dev/env/DJDIR/bin
5616     ;;
5617   i[34567]86-*-sco3.2v5*)
5618     if test $with_gnu_as = yes; then
5619       md_exec_prefix=/usr/gnu/bin
5620     else
5621       md_exec_prefix=/usr/ccs/bin/elf
5622     fi
5623     ;;
5624
5625   mn10300-*-* | \
5626   powerpc-*-chorusos* | \
5627   powerpc*-*-eabi* | \
5628   powerpc*-*-sysv* | \
5629   powerpc*-*-kaos* | \
5630   s390x-ibm-tpf*)
5631     md_exec_prefix=/usr/ccs/bin
5632     ;;
5633   sparc64-*-elf*)
5634     ;;
5635   v850*-*-*)
5636     md_exec_prefix=/usr/ccs/bin
5637     ;;
5638   xtensa*-*-elf*)
5639     ;;
5640
5641   *-*-beos* | \
5642   *-*-elf* | \
5643   *-*-hpux* | \
5644   *-*-netware* | \
5645   *-*-nto-qnx* | \
5646   *-*-rtems* | \
5647   *-*-solaris2* | \
5648   *-*-sysv[45]* | \
5649   *-*-vxworks* | \
5650   *-wrs-windiss)
5651     md_exec_prefix=/usr/ccs/bin
5652     ;;
5653 esac
5654
5655 extra_arflags_for_target=
5656 extra_nmflags_for_target=
5657 extra_ranlibflags_for_target=
5658 target_makefile_frag=/dev/null
5659 case "${target}" in
5660   mep*-*-*)
5661     target_makefile_frag="config/mt-mep"
5662     ;;
5663   spu-*-*)
5664     target_makefile_frag="config/mt-spu"
5665     ;;
5666   mips*-sde-elf*)
5667     target_makefile_frag="config/mt-sde"
5668     ;;
5669   mipsisa*-*-elfoabi*)
5670     target_makefile_frag="config/mt-mips-elfoabi"
5671     ;;
5672   mips*-*-*linux* | mips*-*-gnu*)
5673     target_makefile_frag="config/mt-mips-gnu"
5674     ;;
5675   *-*-netware*)
5676     target_makefile_frag="config/mt-netware"
5677     ;;
5678   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5679     target_makefile_frag="config/mt-gnu"
5680     ;;
5681   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5682     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5683     # commands to handle both 32-bit and 64-bit objects.  These flags are
5684     # harmless if we're using GNU nm or ar.
5685     extra_arflags_for_target=" -X32_64"
5686     extra_nmflags_for_target=" -B -X32_64"
5687     ;;
5688   *-*-darwin*)
5689     # ranlib from Darwin requires the -c flag to look at common symbols.
5690     extra_ranlibflags_for_target=" -c"
5691     ;;
5692   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5693     target_makefile_frag="config/mt-wince"
5694     ;;
5695 esac
5696
5697 alphaieee_frag=/dev/null
5698 case $target in
5699   alpha*-*-*)
5700     # This just makes sure to use the -mieee option to build target libs.
5701     # This should probably be set individually by each library.
5702     alphaieee_frag="config/mt-alphaieee"
5703     ;;
5704 esac
5705
5706 # If --enable-target-optspace always use -Os instead of -O2 to build
5707 # the target libraries, similarly if it is not specified, use -Os
5708 # on selected platforms.
5709 ospace_frag=/dev/null
5710 case "${enable_target_optspace}:${target}" in
5711   yes:*)
5712     ospace_frag="config/mt-ospace"
5713     ;;
5714   :d30v-*)
5715     ospace_frag="config/mt-d30v"
5716     ;;
5717   :m32r-* | :d10v-* | :fr30-*)
5718     ospace_frag="config/mt-ospace"
5719     ;;
5720   no:* | :*)
5721     ;;
5722   *)
5723     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5724     ;;
5725 esac
5726
5727 # Default to using --with-stabs for certain targets.
5728 if test x${with_stabs} = x ; then
5729   case "${target}" in
5730   mips*-*-irix[56]*)
5731     ;;
5732   mips*-*-* | alpha*-*-osf*)
5733     with_stabs=yes;
5734     extra_host_args="${extra_host_args} --with-stabs"
5735     ;;
5736   esac
5737 fi
5738
5739 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5740 # them automatically.
5741 case "${host}" in
5742   hppa*64*-*-hpux11*)
5743     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5744     ;;
5745 esac
5746
5747 # Some systems (e.g., one of the i386-aix systems the gas testers are
5748 # using) don't handle "\$" correctly, so don't use it here.
5749 tooldir='${exec_prefix}'/${target_noncanonical}
5750 build_tooldir=${tooldir}
5751
5752 # Create a .gdbinit file which runs the one in srcdir
5753 # and tells GDB to look there for source files.
5754
5755 if test -r ${srcdir}/.gdbinit ; then
5756   case ${srcdir} in
5757     .) ;;
5758     *) cat > ./.gdbinit <<EOF
5759 # ${NO_EDIT}
5760 dir ${srcdir}
5761 dir .
5762 source ${srcdir}/.gdbinit
5763 EOF
5764     ;;
5765   esac
5766 fi
5767
5768 # Make sure that the compiler is able to generate an executable.  If it
5769 # can't, we are probably in trouble.  We don't care whether we can run the
5770 # executable--we might be using a cross compiler--we only care whether it
5771 # can be created.  At this point the main configure script has set CC.
5772 we_are_ok=no
5773 echo "int main () { return 0; }" > conftest.c
5774 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5775 if test $? = 0 ; then
5776   if test -s conftest || test -s conftest.exe ; then
5777     we_are_ok=yes
5778   fi
5779 fi
5780 case $we_are_ok in
5781   no)
5782     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5783     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5784     rm -f conftest*
5785     exit 1
5786     ;;
5787 esac
5788 rm -f conftest*
5789
5790 # The Solaris /usr/ucb/cc compiler does not appear to work.
5791 case "${host}" in
5792   sparc-sun-solaris2*)
5793       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5794       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5795           could_use=
5796           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5797           if test -d /opt/cygnus/bin ; then
5798               if test "$could_use" = "" ; then
5799                   could_use="/opt/cygnus/bin"
5800               else
5801                   could_use="$could_use or /opt/cygnus/bin"
5802               fi
5803           fi
5804         if test "$could_use" = "" ; then
5805             echo "Warning: compilation may fail because you're using"
5806             echo "/usr/ucb/cc.  You should change your PATH or CC "
5807             echo "variable and rerun configure."
5808         else
5809             echo "Warning: compilation may fail because you're using"
5810             echo "/usr/ucb/cc, when you should use the C compiler from"
5811             echo "$could_use.  You should change your"
5812             echo "PATH or CC variable and rerun configure."
5813         fi
5814       fi
5815   ;;
5816 esac
5817
5818 # Decide which environment variable is used to find dynamic libraries.
5819 case "${host}" in
5820   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5821   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5822   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
5823   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5824 esac
5825
5826 # On systems where the dynamic library environment variable is PATH,
5827 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
5828 # built executables to PATH.
5829 if test "$RPATH_ENVVAR" = PATH; then
5830   GCC_SHLIB_SUBDIR=/shlib
5831 else
5832   GCC_SHLIB_SUBDIR=
5833 fi
5834
5835 # Record target_configdirs and the configure arguments for target and
5836 # build configuration in Makefile.
5837 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5838 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5839
5840 # Determine whether gdb needs tk/tcl or not.
5841 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5842 # and in that case we want gdb to be built without tk.  Ugh!
5843 # In fact I believe gdb is the *only* package directly dependent on tk,
5844 # so we should be able to put the 'maybe's in unconditionally and
5845 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5846 # 100% sure that that's safe though.
5847
5848 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5849 case "$enable_gdbtk" in
5850   no)
5851     GDB_TK="" ;;
5852   yes)
5853     GDB_TK="${gdb_tk}" ;;
5854   *)
5855     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5856     # distro.  Eventually someone will fix this and move Insight, nee
5857     # gdbtk to a separate directory.
5858     if test -d ${srcdir}/gdb/gdbtk ; then
5859       GDB_TK="${gdb_tk}"
5860     else
5861       GDB_TK=""
5862     fi
5863     ;;
5864 esac
5865 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5866 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5867
5868 # Strip out unwanted targets.
5869
5870 # While at that, we remove Makefiles if we were started for recursive
5871 # configuration, so that the top-level Makefile reconfigures them,
5872 # like we used to do when configure itself was recursive.
5873
5874 # Loop over modules.  $extrasub must be used with care, limiting as
5875 # much as possible the usage of range addresses.  That's because autoconf
5876 # splits the sed script to overcome limits in the number of commands,
5877 # and relying on carefully-timed sed passes may turn out to be very hard
5878 # to maintain later.  In this particular case, you just have to be careful
5879 # not to nest @if/@endif pairs, because configure will not warn you at all.
5880
5881 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5882 if test "${enable_bootstrap+set}" = set; then
5883   enableval="$enable_bootstrap"
5884
5885 else
5886   enable_bootstrap=default
5887 fi;
5888
5889 # Issue errors and warnings for invalid/strange bootstrap combinations.
5890 case "$configdirs" in
5891   *gcc*) have_compiler=yes ;;
5892   *) have_compiler=no ;;
5893 esac
5894
5895 case "$have_compiler:$host:$target:$enable_bootstrap" in
5896   *:*:*:no) ;;
5897
5898   # Default behavior.  Enable bootstrap if we have a compiler
5899   # and we are in a native configuration.
5900   yes:$build:$build:default)
5901     enable_bootstrap=yes ;;
5902
5903   *:*:*:default)
5904     enable_bootstrap=no ;;
5905
5906   # We have a compiler and we are in a native configuration, bootstrap is ok
5907   yes:$build:$build:yes)
5908     ;;
5909
5910   # Other configurations, but we have a compiler.  Assume the user knows
5911   # what he's doing.
5912   yes:*:*:yes)
5913     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5914 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5915     ;;
5916
5917   # No compiler: if they passed --enable-bootstrap explicitly, fail
5918   no:*:*:yes)
5919     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5920 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5921    { (exit 1); exit 1; }; } ;;
5922
5923   # Fail if wrong command line
5924   *)
5925     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5926 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5927    { (exit 1); exit 1; }; }
5928     ;;
5929 esac
5930
5931 # Adjust the toplevel makefile according to whether bootstrap was selected.
5932 case "$enable_bootstrap" in
5933   yes)
5934     bootstrap_suffix=bootstrap ;;
5935   no)
5936     bootstrap_suffix=no-bootstrap ;;
5937 esac
5938
5939 for module in ${build_configdirs} ; do
5940   if test -z "${no_recursion}" \
5941      && test -f ${build_subdir}/${module}/Makefile; then
5942     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5943     rm -f ${build_subdir}/${module}/Makefile
5944   fi
5945   extrasub="$extrasub
5946 /^@if build-$module\$/d
5947 /^@endif build-$module\$/d
5948 /^@if build-$module-$bootstrap_suffix\$/d
5949 /^@endif build-$module-$bootstrap_suffix\$/d"
5950 done
5951 for module in ${configdirs} ; do
5952   if test -z "${no_recursion}"; then
5953     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5954       if test -f ${file}; then
5955         echo 1>&2 "*** removing ${file} to force reconfigure"
5956         rm -f ${file}
5957       fi
5958     done
5959   fi
5960   extrasub="$extrasub
5961 /^@if $module\$/d
5962 /^@endif $module\$/d
5963 /^@if $module-$bootstrap_suffix\$/d
5964 /^@endif $module-$bootstrap_suffix\$/d"
5965 done
5966 for module in ${target_configdirs} ; do
5967   if test -z "${no_recursion}" \
5968      && test -f ${target_subdir}/${module}/Makefile; then
5969     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5970     rm -f ${target_subdir}/${module}/Makefile
5971   fi
5972   extrasub="$extrasub
5973 /^@if target-$module\$/d
5974 /^@endif target-$module\$/d
5975 /^@if target-$module-$bootstrap_suffix\$/d
5976 /^@endif target-$module-$bootstrap_suffix\$/d"
5977 done
5978
5979 extrasub="$extrasub
5980 /^@if /,/^@endif /d"
5981
5982 # Create the serialization dependencies.  This uses a temporary file.
5983
5984 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5985 if test "${enable_serial_configure+set}" = set; then
5986   enableval="$enable_serial_configure"
5987
5988 fi;
5989
5990 case ${enable_serial_configure} in
5991   yes)
5992     enable_serial_build_configure=yes
5993     enable_serial_host_configure=yes
5994     enable_serial_target_configure=yes
5995     ;;
5996 esac
5997
5998 # These force 'configure's to be done one at a time, to avoid problems
5999 # with contention over a shared config.cache.
6000 rm -f serdep.tmp
6001 echo '# serdep.tmp' > serdep.tmp
6002 olditem=
6003 test "x${enable_serial_build_configure}" = xyes &&
6004 for item in ${build_configdirs} ; do
6005   case ${olditem} in
6006     "") ;;
6007     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6008   esac
6009   olditem=${item}
6010 done
6011 olditem=
6012 test "x${enable_serial_host_configure}" = xyes &&
6013 for item in ${configdirs} ; do
6014   case ${olditem} in
6015     "") ;;
6016     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6017   esac
6018   olditem=${item}
6019 done
6020 olditem=
6021 test "x${enable_serial_target_configure}" = xyes &&
6022 for item in ${target_configdirs} ; do
6023   case ${olditem} in
6024     "") ;;
6025     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6026   esac
6027   olditem=${item}
6028 done
6029 serialization_dependencies=serdep.tmp
6030
6031
6032 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6033 # target, nonopt, and variable assignments.  These are the ones we
6034 # might not want to pass down to subconfigures.  Also strip
6035 # program-prefix, program-suffix, and program-transform-name, so that
6036 # we can pass down a consistent program-transform-name.
6037 baseargs=
6038 keep_next=no
6039 skip_next=no
6040 eval "set -- $ac_configure_args"
6041 for ac_arg
6042 do
6043   if test X"$skip_next" = X"yes"; then
6044     skip_next=no
6045     continue
6046   fi
6047   if test X"$keep_next" = X"yes"; then
6048     case $ac_arg in
6049       *\'*)
6050         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6051     esac
6052     baseargs="$baseargs '$ac_arg'"
6053     keep_next=no
6054     continue
6055   fi
6056
6057   # Handle separated arguments.  Based on the logic generated by
6058   # autoconf 2.59.
6059   case $ac_arg in
6060     *=* | --config-cache | -C | -disable-* | --disable-* \
6061       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6062       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6063       | -with-* | --with-* | -without-* | --without-* | --x)
6064       separate_arg=no
6065       ;;
6066     -*)
6067       separate_arg=yes
6068       ;;
6069     *)
6070       separate_arg=no
6071       ;;
6072   esac
6073
6074   case "$ac_arg" in
6075     --no*)
6076       continue
6077       ;;
6078     --c* | \
6079     --sr* | \
6080     --ho* | \
6081     --bu* | \
6082     --t* | \
6083     --program-* | \
6084     -cache_file* | \
6085     -srcdir* | \
6086     -host* | \
6087     -build* | \
6088     -target* | \
6089     -program-prefix* | \
6090     -program-suffix* | \
6091     -program-transform-name* )
6092       skip_next=$separate_arg
6093       continue
6094       ;;
6095     -*)
6096       # An option.  Add it.
6097       case $ac_arg in
6098         *\'*)
6099           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6100       esac
6101       baseargs="$baseargs '$ac_arg'"
6102       keep_next=$separate_arg
6103       ;;
6104     *)
6105       # Either a variable assignment, or a nonopt (triplet).  Don't
6106       # pass it down; let the Makefile handle this.
6107       continue
6108       ;;
6109   esac
6110 done
6111 # Remove the initial space we just introduced and, as these will be
6112 # expanded by make, quote '$'.
6113 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6114
6115 # Add in --program-transform-name, after --program-prefix and
6116 # --program-suffix have been applied to it.  Autoconf has already
6117 # doubled dollar signs and backslashes in program_transform_name; we want
6118 # the backslashes un-doubled, and then the entire thing wrapped in single
6119 # quotes, because this will be expanded first by make and then by the shell.
6120 # Also, because we want to override the logic in subdir configure scripts to
6121 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6122 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6123 ${program_transform_name}
6124 EOF_SED
6125 gcc_transform_name=`cat conftestsed.out`
6126 rm -f conftestsed.out
6127 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6128 if test "$silent" = yes; then
6129   baseargs="$baseargs --silent"
6130 fi
6131
6132 # For the build-side libraries, we just need to pretend we're native,
6133 # and not use the same cache file.  Multilibs are neither needed nor
6134 # desired.
6135 build_configargs="--cache-file=../config.cache ${baseargs}"
6136
6137 # For host modules, accept cache file option, or specification as blank.
6138 case "${cache_file}" in
6139 "") # empty
6140   cache_file_option="" ;;
6141 /* | [A-Za-z]:[\\/]* ) # absolute path
6142   cache_file_option="--cache-file=${cache_file}" ;;
6143 *) # relative path
6144   cache_file_option="--cache-file=../${cache_file}" ;;
6145 esac
6146
6147 # Host dirs don't like to share a cache file either, horribly enough.
6148 # This seems to be due to autoconf 2.5x stupidity.
6149 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6150
6151 target_configargs=${baseargs}
6152
6153 # Passing a --with-cross-host argument lets the target libraries know
6154 # whether they are being built with a cross-compiler or being built
6155 # native.  However, it would be better to use other mechanisms to make the
6156 # sorts of decisions they want to make on this basis.  Please consider
6157 # this option to be deprecated.  FIXME.
6158 if test x${is_cross_compiler} = xyes ; then
6159   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6160 fi
6161
6162 # Default to --enable-multilib.
6163 if test x${enable_multilib} = x ; then
6164   target_configargs="--enable-multilib ${target_configargs}"
6165 fi
6166
6167 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6168 # changed from the earlier setting of with_newlib.
6169 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6170   target_configargs="--with-newlib ${target_configargs}"
6171 fi
6172
6173 # Different target subdirs use different values of certain variables
6174 # (notably CXX).  Worse, multilibs use *lots* of different values.
6175 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6176 # it doesn't automatically accept command-line overrides of them.
6177 # This means it's not safe for target subdirs to share a cache file,
6178 # which is disgusting, but there you have it.  Hopefully this can be
6179 # fixed in future.  It's still worthwhile to use a cache file for each
6180 # directory.  I think.
6181
6182 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6183 # We need to pass --target, as newer autoconf's requires consistency
6184 # for target_alias and gcc doesn't manage it consistently.
6185 target_configargs="--cache-file=./config.cache ${target_configargs}"
6186
6187 FLAGS_FOR_TARGET=
6188 case " $target_configdirs " in
6189  *" newlib "*)
6190   case " $target_configargs " in
6191   *" --with-newlib "*)
6192    case "$target" in
6193    *-cygwin*)
6194      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' ;;
6195    esac
6196
6197    # If we're not building GCC, don't discard standard headers.
6198    if test -d ${srcdir}/gcc; then
6199      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6200
6201      if test "${build}" != "${host}"; then
6202        # On Canadian crosses, CC_FOR_TARGET will have already been set
6203        # by `configure', so we won't have an opportunity to add -Bgcc/
6204        # to it.  This is right: we don't want to search that directory
6205        # for binaries, but we want the header files in there, so add
6206        # them explicitly.
6207        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6208
6209        # Someone might think of using the pre-installed headers on
6210        # Canadian crosses, in case the installed compiler is not fully
6211        # compatible with the compiler being built.  In this case, it
6212        # would be better to flag an error than risking having
6213        # incompatible object files being constructed.  We can't
6214        # guarantee that an error will be flagged, but let's hope the
6215        # compiler will do it, when presented with incompatible header
6216        # files.
6217      fi
6218    fi
6219
6220    case "${target}-${is_cross_compiler}" in
6221    i[3456789]86-*-linux*-no)
6222       # Here host == target, so we don't need to build gcc,
6223       # so we don't want to discard standard headers.
6224       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6225       ;;
6226    *)
6227       # If we're building newlib, use its generic headers last, but search
6228       # for any libc-related directories first (so make it the last -B
6229       # switch).
6230       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6231
6232       # If we're building libgloss, find the startup file, simulator library
6233       # and linker script.
6234       case " $target_configdirs " in
6235         *" libgloss "*)
6236         # Look for startup file, simulator library and maybe linker script.
6237         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6238         # Look for libnosys.a in case the target needs it.
6239         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6240         # Most targets have the linker script in the source directory.
6241         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6242         ;;
6243       esac
6244       ;;
6245    esac
6246    ;;
6247   esac
6248   ;;
6249 esac
6250 case "$target" in
6251 *-mingw*)
6252   # Can't be handled as Cygwin above since Mingw does not use newlib.
6253   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' ;;
6254 esac
6255
6256 # Allow the user to override the flags for
6257 # our build compiler if desired.
6258 if test x"${build}" = x"${host}" ; then
6259   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6260   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6261   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6262 fi
6263
6264 # On Canadian crosses, we'll be searching the right directories for
6265 # the previously-installed cross compiler, so don't bother to add
6266 # flags for directories within the install tree of the compiler
6267 # being built; programs in there won't even run.
6268 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6269   # Search for pre-installed headers if nothing else fits.
6270   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6271 fi
6272
6273 if test "x${use_gnu_ld}" = x &&
6274    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6275   # Arrange for us to find uninstalled linker scripts.
6276   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6277 fi
6278
6279 # Search for other target-specific linker scripts and such.
6280 case "${target}" in
6281   mep*)
6282     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6283     ;;
6284 esac
6285
6286 # Makefile fragments.
6287 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6288 do
6289   eval fragval=\$$frag
6290   if test $fragval != /dev/null; then
6291     eval $frag=${srcdir}/$fragval
6292   fi
6293 done
6294
6295
6296
6297
6298
6299 # Miscellanea: directories, flags, etc.
6300
6301
6302
6303
6304
6305
6306
6307
6308 # Build module lists & subconfigure args.
6309
6310
6311
6312 # Host module lists & subconfigure args.
6313
6314
6315
6316 # Target module lists & subconfigure args.
6317
6318
6319
6320 # Build tools.
6321
6322
6323
6324
6325
6326
6327
6328
6329
6330
6331
6332
6333
6334
6335
6336
6337
6338 # Generate default definitions for YACC, M4, LEX and other programs that run
6339 # on the build machine.  These are used if the Makefile can't locate these
6340 # programs in objdir.
6341 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6342
6343 for ac_prog in 'bison -y' byacc yacc
6344 do
6345   # Extract the first word of "$ac_prog", so it can be a program name with args.
6346 set dummy $ac_prog; ac_word=$2
6347 echo "$as_me:$LINENO: checking for $ac_word" >&5
6348 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6349 if test "${ac_cv_prog_YACC+set}" = set; then
6350   echo $ECHO_N "(cached) $ECHO_C" >&6
6351 else
6352   if test -n "$YACC"; then
6353   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6354 else
6355 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6356 for as_dir in $PATH
6357 do
6358   IFS=$as_save_IFS
6359   test -z "$as_dir" && as_dir=.
6360   for ac_exec_ext in '' $ac_executable_extensions; do
6361   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6362     ac_cv_prog_YACC="$ac_prog"
6363     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6364     break 2
6365   fi
6366 done
6367 done
6368
6369 fi
6370 fi
6371 YACC=$ac_cv_prog_YACC
6372 if test -n "$YACC"; then
6373   echo "$as_me:$LINENO: result: $YACC" >&5
6374 echo "${ECHO_T}$YACC" >&6
6375 else
6376   echo "$as_me:$LINENO: result: no" >&5
6377 echo "${ECHO_T}no" >&6
6378 fi
6379
6380   test -n "$YACC" && break
6381 done
6382 test -n "$YACC" || YACC="$MISSING bison -y"
6383
6384 case " $build_configdirs " in
6385   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6386   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6387 esac
6388
6389 for ac_prog in bison
6390 do
6391   # Extract the first word of "$ac_prog", so it can be a program name with args.
6392 set dummy $ac_prog; ac_word=$2
6393 echo "$as_me:$LINENO: checking for $ac_word" >&5
6394 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6395 if test "${ac_cv_prog_BISON+set}" = set; then
6396   echo $ECHO_N "(cached) $ECHO_C" >&6
6397 else
6398   if test -n "$BISON"; then
6399   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6400 else
6401 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6402 for as_dir in $PATH
6403 do
6404   IFS=$as_save_IFS
6405   test -z "$as_dir" && as_dir=.
6406   for ac_exec_ext in '' $ac_executable_extensions; do
6407   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6408     ac_cv_prog_BISON="$ac_prog"
6409     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6410     break 2
6411   fi
6412 done
6413 done
6414
6415 fi
6416 fi
6417 BISON=$ac_cv_prog_BISON
6418 if test -n "$BISON"; then
6419   echo "$as_me:$LINENO: result: $BISON" >&5
6420 echo "${ECHO_T}$BISON" >&6
6421 else
6422   echo "$as_me:$LINENO: result: no" >&5
6423 echo "${ECHO_T}no" >&6
6424 fi
6425
6426   test -n "$BISON" && break
6427 done
6428 test -n "$BISON" || BISON="$MISSING bison"
6429
6430 case " $build_configdirs " in
6431   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6432 esac
6433
6434 for ac_prog in gm4 gnum4 m4
6435 do
6436   # Extract the first word of "$ac_prog", so it can be a program name with args.
6437 set dummy $ac_prog; ac_word=$2
6438 echo "$as_me:$LINENO: checking for $ac_word" >&5
6439 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6440 if test "${ac_cv_prog_M4+set}" = set; then
6441   echo $ECHO_N "(cached) $ECHO_C" >&6
6442 else
6443   if test -n "$M4"; then
6444   ac_cv_prog_M4="$M4" # Let the user override the test.
6445 else
6446 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6447 for as_dir in $PATH
6448 do
6449   IFS=$as_save_IFS
6450   test -z "$as_dir" && as_dir=.
6451   for ac_exec_ext in '' $ac_executable_extensions; do
6452   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6453     ac_cv_prog_M4="$ac_prog"
6454     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6455     break 2
6456   fi
6457 done
6458 done
6459
6460 fi
6461 fi
6462 M4=$ac_cv_prog_M4
6463 if test -n "$M4"; then
6464   echo "$as_me:$LINENO: result: $M4" >&5
6465 echo "${ECHO_T}$M4" >&6
6466 else
6467   echo "$as_me:$LINENO: result: no" >&5
6468 echo "${ECHO_T}no" >&6
6469 fi
6470
6471   test -n "$M4" && break
6472 done
6473 test -n "$M4" || M4="$MISSING m4"
6474
6475 case " $build_configdirs " in
6476   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6477 esac
6478
6479 for ac_prog in flex lex
6480 do
6481   # Extract the first word of "$ac_prog", so it can be a program name with args.
6482 set dummy $ac_prog; ac_word=$2
6483 echo "$as_me:$LINENO: checking for $ac_word" >&5
6484 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6485 if test "${ac_cv_prog_LEX+set}" = set; then
6486   echo $ECHO_N "(cached) $ECHO_C" >&6
6487 else
6488   if test -n "$LEX"; then
6489   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6490 else
6491 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6492 for as_dir in $PATH
6493 do
6494   IFS=$as_save_IFS
6495   test -z "$as_dir" && as_dir=.
6496   for ac_exec_ext in '' $ac_executable_extensions; do
6497   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6498     ac_cv_prog_LEX="$ac_prog"
6499     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6500     break 2
6501   fi
6502 done
6503 done
6504
6505 fi
6506 fi
6507 LEX=$ac_cv_prog_LEX
6508 if test -n "$LEX"; then
6509   echo "$as_me:$LINENO: result: $LEX" >&5
6510 echo "${ECHO_T}$LEX" >&6
6511 else
6512   echo "$as_me:$LINENO: result: no" >&5
6513 echo "${ECHO_T}no" >&6
6514 fi
6515
6516   test -n "$LEX" && break
6517 done
6518 test -n "$LEX" || LEX="$MISSING flex"
6519
6520 case " $build_configdirs " in
6521   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6522   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6523 esac
6524
6525 for ac_prog in flex
6526 do
6527   # Extract the first word of "$ac_prog", so it can be a program name with args.
6528 set dummy $ac_prog; ac_word=$2
6529 echo "$as_me:$LINENO: checking for $ac_word" >&5
6530 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6531 if test "${ac_cv_prog_FLEX+set}" = set; then
6532   echo $ECHO_N "(cached) $ECHO_C" >&6
6533 else
6534   if test -n "$FLEX"; then
6535   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6536 else
6537 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6538 for as_dir in $PATH
6539 do
6540   IFS=$as_save_IFS
6541   test -z "$as_dir" && as_dir=.
6542   for ac_exec_ext in '' $ac_executable_extensions; do
6543   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6544     ac_cv_prog_FLEX="$ac_prog"
6545     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6546     break 2
6547   fi
6548 done
6549 done
6550
6551 fi
6552 fi
6553 FLEX=$ac_cv_prog_FLEX
6554 if test -n "$FLEX"; then
6555   echo "$as_me:$LINENO: result: $FLEX" >&5
6556 echo "${ECHO_T}$FLEX" >&6
6557 else
6558   echo "$as_me:$LINENO: result: no" >&5
6559 echo "${ECHO_T}no" >&6
6560 fi
6561
6562   test -n "$FLEX" && break
6563 done
6564 test -n "$FLEX" || FLEX="$MISSING flex"
6565
6566 case " $build_configdirs " in
6567   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6568 esac
6569
6570 for ac_prog in makeinfo
6571 do
6572   # Extract the first word of "$ac_prog", so it can be a program name with args.
6573 set dummy $ac_prog; ac_word=$2
6574 echo "$as_me:$LINENO: checking for $ac_word" >&5
6575 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6576 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6577   echo $ECHO_N "(cached) $ECHO_C" >&6
6578 else
6579   if test -n "$MAKEINFO"; then
6580   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6581 else
6582 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6583 for as_dir in $PATH
6584 do
6585   IFS=$as_save_IFS
6586   test -z "$as_dir" && as_dir=.
6587   for ac_exec_ext in '' $ac_executable_extensions; do
6588   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6589     ac_cv_prog_MAKEINFO="$ac_prog"
6590     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6591     break 2
6592   fi
6593 done
6594 done
6595
6596 fi
6597 fi
6598 MAKEINFO=$ac_cv_prog_MAKEINFO
6599 if test -n "$MAKEINFO"; then
6600   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6601 echo "${ECHO_T}$MAKEINFO" >&6
6602 else
6603   echo "$as_me:$LINENO: result: no" >&5
6604 echo "${ECHO_T}no" >&6
6605 fi
6606
6607   test -n "$MAKEINFO" && break
6608 done
6609 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6610
6611 case " $build_configdirs " in
6612   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6613   *)
6614
6615     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6616     # higher, else we use the "missing" dummy.
6617     if ${MAKEINFO} --version \
6618        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6619       :
6620     else
6621       MAKEINFO="$MISSING makeinfo"
6622     fi
6623     ;;
6624
6625 esac
6626
6627 # FIXME: expect and dejagnu may become build tools?
6628
6629 for ac_prog in expect
6630 do
6631   # Extract the first word of "$ac_prog", so it can be a program name with args.
6632 set dummy $ac_prog; 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_EXPECT+set}" = set; then
6636   echo $ECHO_N "(cached) $ECHO_C" >&6
6637 else
6638   if test -n "$EXPECT"; then
6639   ac_cv_prog_EXPECT="$EXPECT" # 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_EXPECT="$ac_prog"
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 EXPECT=$ac_cv_prog_EXPECT
6658 if test -n "$EXPECT"; then
6659   echo "$as_me:$LINENO: result: $EXPECT" >&5
6660 echo "${ECHO_T}$EXPECT" >&6
6661 else
6662   echo "$as_me:$LINENO: result: no" >&5
6663 echo "${ECHO_T}no" >&6
6664 fi
6665
6666   test -n "$EXPECT" && break
6667 done
6668 test -n "$EXPECT" || EXPECT="expect"
6669
6670 case " $configdirs " in
6671   *" expect "*)
6672     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6673     ;;
6674 esac
6675
6676 for ac_prog in runtest
6677 do
6678   # Extract the first word of "$ac_prog", so it can be a program name with args.
6679 set dummy $ac_prog; ac_word=$2
6680 echo "$as_me:$LINENO: checking for $ac_word" >&5
6681 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6682 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6683   echo $ECHO_N "(cached) $ECHO_C" >&6
6684 else
6685   if test -n "$RUNTEST"; then
6686   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6687 else
6688 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6689 for as_dir in $PATH
6690 do
6691   IFS=$as_save_IFS
6692   test -z "$as_dir" && as_dir=.
6693   for ac_exec_ext in '' $ac_executable_extensions; do
6694   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6695     ac_cv_prog_RUNTEST="$ac_prog"
6696     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6697     break 2
6698   fi
6699 done
6700 done
6701
6702 fi
6703 fi
6704 RUNTEST=$ac_cv_prog_RUNTEST
6705 if test -n "$RUNTEST"; then
6706   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6707 echo "${ECHO_T}$RUNTEST" >&6
6708 else
6709   echo "$as_me:$LINENO: result: no" >&5
6710 echo "${ECHO_T}no" >&6
6711 fi
6712
6713   test -n "$RUNTEST" && break
6714 done
6715 test -n "$RUNTEST" || RUNTEST="runtest"
6716
6717 case " $configdirs " in
6718   *" dejagnu "*)
6719     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6720     ;;
6721 esac
6722
6723
6724 # Host tools.
6725 ncn_tool_prefix=
6726 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6727 ncn_target_tool_prefix=
6728 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6729
6730
6731
6732 if test -n "$AR"; then
6733   ac_cv_prog_AR=$AR
6734 elif test -n "$ac_cv_prog_AR"; then
6735   AR=$ac_cv_prog_AR
6736 fi
6737
6738 if test -n "$ac_cv_prog_AR"; then
6739   for ncn_progname in ar; do
6740     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6741 set dummy ${ncn_progname}; ac_word=$2
6742 echo "$as_me:$LINENO: checking for $ac_word" >&5
6743 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6744 if test "${ac_cv_prog_AR+set}" = set; then
6745   echo $ECHO_N "(cached) $ECHO_C" >&6
6746 else
6747   if test -n "$AR"; then
6748   ac_cv_prog_AR="$AR" # Let the user override the test.
6749 else
6750 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6751 for as_dir in $PATH
6752 do
6753   IFS=$as_save_IFS
6754   test -z "$as_dir" && as_dir=.
6755   for ac_exec_ext in '' $ac_executable_extensions; do
6756   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6757     ac_cv_prog_AR="${ncn_progname}"
6758     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6759     break 2
6760   fi
6761 done
6762 done
6763
6764 fi
6765 fi
6766 AR=$ac_cv_prog_AR
6767 if test -n "$AR"; then
6768   echo "$as_me:$LINENO: result: $AR" >&5
6769 echo "${ECHO_T}$AR" >&6
6770 else
6771   echo "$as_me:$LINENO: result: no" >&5
6772 echo "${ECHO_T}no" >&6
6773 fi
6774
6775   done
6776 fi
6777
6778 for ncn_progname in ar; do
6779   if test -n "$ncn_tool_prefix"; then
6780     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6781 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6782 echo "$as_me:$LINENO: checking for $ac_word" >&5
6783 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6784 if test "${ac_cv_prog_AR+set}" = set; then
6785   echo $ECHO_N "(cached) $ECHO_C" >&6
6786 else
6787   if test -n "$AR"; then
6788   ac_cv_prog_AR="$AR" # Let the user override the test.
6789 else
6790 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6791 for as_dir in $PATH
6792 do
6793   IFS=$as_save_IFS
6794   test -z "$as_dir" && as_dir=.
6795   for ac_exec_ext in '' $ac_executable_extensions; do
6796   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6797     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6798     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6799     break 2
6800   fi
6801 done
6802 done
6803
6804 fi
6805 fi
6806 AR=$ac_cv_prog_AR
6807 if test -n "$AR"; then
6808   echo "$as_me:$LINENO: result: $AR" >&5
6809 echo "${ECHO_T}$AR" >&6
6810 else
6811   echo "$as_me:$LINENO: result: no" >&5
6812 echo "${ECHO_T}no" >&6
6813 fi
6814
6815   fi
6816   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6817     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6818 set dummy ${ncn_progname}; ac_word=$2
6819 echo "$as_me:$LINENO: checking for $ac_word" >&5
6820 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6821 if test "${ac_cv_prog_AR+set}" = set; then
6822   echo $ECHO_N "(cached) $ECHO_C" >&6
6823 else
6824   if test -n "$AR"; then
6825   ac_cv_prog_AR="$AR" # Let the user override the test.
6826 else
6827 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6828 for as_dir in $PATH
6829 do
6830   IFS=$as_save_IFS
6831   test -z "$as_dir" && as_dir=.
6832   for ac_exec_ext in '' $ac_executable_extensions; do
6833   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6834     ac_cv_prog_AR="${ncn_progname}"
6835     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6836     break 2
6837   fi
6838 done
6839 done
6840
6841 fi
6842 fi
6843 AR=$ac_cv_prog_AR
6844 if test -n "$AR"; then
6845   echo "$as_me:$LINENO: result: $AR" >&5
6846 echo "${ECHO_T}$AR" >&6
6847 else
6848   echo "$as_me:$LINENO: result: no" >&5
6849 echo "${ECHO_T}no" >&6
6850 fi
6851
6852   fi
6853   test -n "$ac_cv_prog_AR" && break
6854 done
6855
6856 if test -z "$ac_cv_prog_AR" ; then
6857   set dummy ar
6858   if test $build = $host ; then
6859     AR="$2"
6860   else
6861     AR="${ncn_tool_prefix}$2"
6862   fi
6863 fi
6864
6865
6866
6867 if test -n "$AS"; then
6868   ac_cv_prog_AS=$AS
6869 elif test -n "$ac_cv_prog_AS"; then
6870   AS=$ac_cv_prog_AS
6871 fi
6872
6873 if test -n "$ac_cv_prog_AS"; then
6874   for ncn_progname in as; do
6875     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6876 set dummy ${ncn_progname}; ac_word=$2
6877 echo "$as_me:$LINENO: checking for $ac_word" >&5
6878 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6879 if test "${ac_cv_prog_AS+set}" = set; then
6880   echo $ECHO_N "(cached) $ECHO_C" >&6
6881 else
6882   if test -n "$AS"; then
6883   ac_cv_prog_AS="$AS" # Let the user override the test.
6884 else
6885 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6886 for as_dir in $PATH
6887 do
6888   IFS=$as_save_IFS
6889   test -z "$as_dir" && as_dir=.
6890   for ac_exec_ext in '' $ac_executable_extensions; do
6891   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6892     ac_cv_prog_AS="${ncn_progname}"
6893     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6894     break 2
6895   fi
6896 done
6897 done
6898
6899 fi
6900 fi
6901 AS=$ac_cv_prog_AS
6902 if test -n "$AS"; then
6903   echo "$as_me:$LINENO: result: $AS" >&5
6904 echo "${ECHO_T}$AS" >&6
6905 else
6906   echo "$as_me:$LINENO: result: no" >&5
6907 echo "${ECHO_T}no" >&6
6908 fi
6909
6910   done
6911 fi
6912
6913 for ncn_progname in as; do
6914   if test -n "$ncn_tool_prefix"; then
6915     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6916 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6917 echo "$as_me:$LINENO: checking for $ac_word" >&5
6918 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6919 if test "${ac_cv_prog_AS+set}" = set; then
6920   echo $ECHO_N "(cached) $ECHO_C" >&6
6921 else
6922   if test -n "$AS"; then
6923   ac_cv_prog_AS="$AS" # Let the user override the test.
6924 else
6925 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6926 for as_dir in $PATH
6927 do
6928   IFS=$as_save_IFS
6929   test -z "$as_dir" && as_dir=.
6930   for ac_exec_ext in '' $ac_executable_extensions; do
6931   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6932     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6933     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6934     break 2
6935   fi
6936 done
6937 done
6938
6939 fi
6940 fi
6941 AS=$ac_cv_prog_AS
6942 if test -n "$AS"; then
6943   echo "$as_me:$LINENO: result: $AS" >&5
6944 echo "${ECHO_T}$AS" >&6
6945 else
6946   echo "$as_me:$LINENO: result: no" >&5
6947 echo "${ECHO_T}no" >&6
6948 fi
6949
6950   fi
6951   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6952     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6953 set dummy ${ncn_progname}; ac_word=$2
6954 echo "$as_me:$LINENO: checking for $ac_word" >&5
6955 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6956 if test "${ac_cv_prog_AS+set}" = set; then
6957   echo $ECHO_N "(cached) $ECHO_C" >&6
6958 else
6959   if test -n "$AS"; then
6960   ac_cv_prog_AS="$AS" # Let the user override the test.
6961 else
6962 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6963 for as_dir in $PATH
6964 do
6965   IFS=$as_save_IFS
6966   test -z "$as_dir" && as_dir=.
6967   for ac_exec_ext in '' $ac_executable_extensions; do
6968   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6969     ac_cv_prog_AS="${ncn_progname}"
6970     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6971     break 2
6972   fi
6973 done
6974 done
6975
6976 fi
6977 fi
6978 AS=$ac_cv_prog_AS
6979 if test -n "$AS"; then
6980   echo "$as_me:$LINENO: result: $AS" >&5
6981 echo "${ECHO_T}$AS" >&6
6982 else
6983   echo "$as_me:$LINENO: result: no" >&5
6984 echo "${ECHO_T}no" >&6
6985 fi
6986
6987   fi
6988   test -n "$ac_cv_prog_AS" && break
6989 done
6990
6991 if test -z "$ac_cv_prog_AS" ; then
6992   set dummy as
6993   if test $build = $host ; then
6994     AS="$2"
6995   else
6996     AS="${ncn_tool_prefix}$2"
6997   fi
6998 fi
6999
7000
7001
7002 if test -n "$DLLTOOL"; then
7003   ac_cv_prog_DLLTOOL=$DLLTOOL
7004 elif test -n "$ac_cv_prog_DLLTOOL"; then
7005   DLLTOOL=$ac_cv_prog_DLLTOOL
7006 fi
7007
7008 if test -n "$ac_cv_prog_DLLTOOL"; then
7009   for ncn_progname in dlltool; do
7010     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7011 set dummy ${ncn_progname}; ac_word=$2
7012 echo "$as_me:$LINENO: checking for $ac_word" >&5
7013 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7014 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7015   echo $ECHO_N "(cached) $ECHO_C" >&6
7016 else
7017   if test -n "$DLLTOOL"; then
7018   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7019 else
7020 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7021 for as_dir in $PATH
7022 do
7023   IFS=$as_save_IFS
7024   test -z "$as_dir" && as_dir=.
7025   for ac_exec_ext in '' $ac_executable_extensions; do
7026   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7027     ac_cv_prog_DLLTOOL="${ncn_progname}"
7028     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7029     break 2
7030   fi
7031 done
7032 done
7033
7034 fi
7035 fi
7036 DLLTOOL=$ac_cv_prog_DLLTOOL
7037 if test -n "$DLLTOOL"; then
7038   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7039 echo "${ECHO_T}$DLLTOOL" >&6
7040 else
7041   echo "$as_me:$LINENO: result: no" >&5
7042 echo "${ECHO_T}no" >&6
7043 fi
7044
7045   done
7046 fi
7047
7048 for ncn_progname in dlltool; do
7049   if test -n "$ncn_tool_prefix"; then
7050     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7051 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7052 echo "$as_me:$LINENO: checking for $ac_word" >&5
7053 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7054 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7055   echo $ECHO_N "(cached) $ECHO_C" >&6
7056 else
7057   if test -n "$DLLTOOL"; then
7058   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7059 else
7060 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7061 for as_dir in $PATH
7062 do
7063   IFS=$as_save_IFS
7064   test -z "$as_dir" && as_dir=.
7065   for ac_exec_ext in '' $ac_executable_extensions; do
7066   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7067     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7068     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7069     break 2
7070   fi
7071 done
7072 done
7073
7074 fi
7075 fi
7076 DLLTOOL=$ac_cv_prog_DLLTOOL
7077 if test -n "$DLLTOOL"; then
7078   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7079 echo "${ECHO_T}$DLLTOOL" >&6
7080 else
7081   echo "$as_me:$LINENO: result: no" >&5
7082 echo "${ECHO_T}no" >&6
7083 fi
7084
7085   fi
7086   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7087     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7088 set dummy ${ncn_progname}; ac_word=$2
7089 echo "$as_me:$LINENO: checking for $ac_word" >&5
7090 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7091 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7092   echo $ECHO_N "(cached) $ECHO_C" >&6
7093 else
7094   if test -n "$DLLTOOL"; then
7095   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7096 else
7097 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7098 for as_dir in $PATH
7099 do
7100   IFS=$as_save_IFS
7101   test -z "$as_dir" && as_dir=.
7102   for ac_exec_ext in '' $ac_executable_extensions; do
7103   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7104     ac_cv_prog_DLLTOOL="${ncn_progname}"
7105     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7106     break 2
7107   fi
7108 done
7109 done
7110
7111 fi
7112 fi
7113 DLLTOOL=$ac_cv_prog_DLLTOOL
7114 if test -n "$DLLTOOL"; then
7115   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7116 echo "${ECHO_T}$DLLTOOL" >&6
7117 else
7118   echo "$as_me:$LINENO: result: no" >&5
7119 echo "${ECHO_T}no" >&6
7120 fi
7121
7122   fi
7123   test -n "$ac_cv_prog_DLLTOOL" && break
7124 done
7125
7126 if test -z "$ac_cv_prog_DLLTOOL" ; then
7127   set dummy dlltool
7128   if test $build = $host ; then
7129     DLLTOOL="$2"
7130   else
7131     DLLTOOL="${ncn_tool_prefix}$2"
7132   fi
7133 fi
7134
7135
7136
7137 if test -n "$LD"; then
7138   ac_cv_prog_LD=$LD
7139 elif test -n "$ac_cv_prog_LD"; then
7140   LD=$ac_cv_prog_LD
7141 fi
7142
7143 if test -n "$ac_cv_prog_LD"; then
7144   for ncn_progname in ld; do
7145     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7146 set dummy ${ncn_progname}; ac_word=$2
7147 echo "$as_me:$LINENO: checking for $ac_word" >&5
7148 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7149 if test "${ac_cv_prog_LD+set}" = set; then
7150   echo $ECHO_N "(cached) $ECHO_C" >&6
7151 else
7152   if test -n "$LD"; then
7153   ac_cv_prog_LD="$LD" # Let the user override the test.
7154 else
7155 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7156 for as_dir in $PATH
7157 do
7158   IFS=$as_save_IFS
7159   test -z "$as_dir" && as_dir=.
7160   for ac_exec_ext in '' $ac_executable_extensions; do
7161   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7162     ac_cv_prog_LD="${ncn_progname}"
7163     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7164     break 2
7165   fi
7166 done
7167 done
7168
7169 fi
7170 fi
7171 LD=$ac_cv_prog_LD
7172 if test -n "$LD"; then
7173   echo "$as_me:$LINENO: result: $LD" >&5
7174 echo "${ECHO_T}$LD" >&6
7175 else
7176   echo "$as_me:$LINENO: result: no" >&5
7177 echo "${ECHO_T}no" >&6
7178 fi
7179
7180   done
7181 fi
7182
7183 for ncn_progname in ld; do
7184   if test -n "$ncn_tool_prefix"; then
7185     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7186 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7187 echo "$as_me:$LINENO: checking for $ac_word" >&5
7188 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7189 if test "${ac_cv_prog_LD+set}" = set; then
7190   echo $ECHO_N "(cached) $ECHO_C" >&6
7191 else
7192   if test -n "$LD"; then
7193   ac_cv_prog_LD="$LD" # Let the user override the test.
7194 else
7195 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7196 for as_dir in $PATH
7197 do
7198   IFS=$as_save_IFS
7199   test -z "$as_dir" && as_dir=.
7200   for ac_exec_ext in '' $ac_executable_extensions; do
7201   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7202     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7203     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7204     break 2
7205   fi
7206 done
7207 done
7208
7209 fi
7210 fi
7211 LD=$ac_cv_prog_LD
7212 if test -n "$LD"; then
7213   echo "$as_me:$LINENO: result: $LD" >&5
7214 echo "${ECHO_T}$LD" >&6
7215 else
7216   echo "$as_me:$LINENO: result: no" >&5
7217 echo "${ECHO_T}no" >&6
7218 fi
7219
7220   fi
7221   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7222     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7223 set dummy ${ncn_progname}; ac_word=$2
7224 echo "$as_me:$LINENO: checking for $ac_word" >&5
7225 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7226 if test "${ac_cv_prog_LD+set}" = set; then
7227   echo $ECHO_N "(cached) $ECHO_C" >&6
7228 else
7229   if test -n "$LD"; then
7230   ac_cv_prog_LD="$LD" # Let the user override the test.
7231 else
7232 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7233 for as_dir in $PATH
7234 do
7235   IFS=$as_save_IFS
7236   test -z "$as_dir" && as_dir=.
7237   for ac_exec_ext in '' $ac_executable_extensions; do
7238   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7239     ac_cv_prog_LD="${ncn_progname}"
7240     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7241     break 2
7242   fi
7243 done
7244 done
7245
7246 fi
7247 fi
7248 LD=$ac_cv_prog_LD
7249 if test -n "$LD"; then
7250   echo "$as_me:$LINENO: result: $LD" >&5
7251 echo "${ECHO_T}$LD" >&6
7252 else
7253   echo "$as_me:$LINENO: result: no" >&5
7254 echo "${ECHO_T}no" >&6
7255 fi
7256
7257   fi
7258   test -n "$ac_cv_prog_LD" && break
7259 done
7260
7261 if test -z "$ac_cv_prog_LD" ; then
7262   set dummy ld
7263   if test $build = $host ; then
7264     LD="$2"
7265   else
7266     LD="${ncn_tool_prefix}$2"
7267   fi
7268 fi
7269
7270
7271
7272 if test -n "$LIPO"; then
7273   ac_cv_prog_LIPO=$LIPO
7274 elif test -n "$ac_cv_prog_LIPO"; then
7275   LIPO=$ac_cv_prog_LIPO
7276 fi
7277
7278 if test -n "$ac_cv_prog_LIPO"; then
7279   for ncn_progname in lipo; do
7280     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7281 set dummy ${ncn_progname}; ac_word=$2
7282 echo "$as_me:$LINENO: checking for $ac_word" >&5
7283 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7284 if test "${ac_cv_prog_LIPO+set}" = set; then
7285   echo $ECHO_N "(cached) $ECHO_C" >&6
7286 else
7287   if test -n "$LIPO"; then
7288   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7289 else
7290 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7291 for as_dir in $PATH
7292 do
7293   IFS=$as_save_IFS
7294   test -z "$as_dir" && as_dir=.
7295   for ac_exec_ext in '' $ac_executable_extensions; do
7296   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7297     ac_cv_prog_LIPO="${ncn_progname}"
7298     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7299     break 2
7300   fi
7301 done
7302 done
7303
7304 fi
7305 fi
7306 LIPO=$ac_cv_prog_LIPO
7307 if test -n "$LIPO"; then
7308   echo "$as_me:$LINENO: result: $LIPO" >&5
7309 echo "${ECHO_T}$LIPO" >&6
7310 else
7311   echo "$as_me:$LINENO: result: no" >&5
7312 echo "${ECHO_T}no" >&6
7313 fi
7314
7315   done
7316 fi
7317
7318 for ncn_progname in lipo; do
7319   if test -n "$ncn_tool_prefix"; then
7320     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7321 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7322 echo "$as_me:$LINENO: checking for $ac_word" >&5
7323 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7324 if test "${ac_cv_prog_LIPO+set}" = set; then
7325   echo $ECHO_N "(cached) $ECHO_C" >&6
7326 else
7327   if test -n "$LIPO"; then
7328   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7329 else
7330 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7331 for as_dir in $PATH
7332 do
7333   IFS=$as_save_IFS
7334   test -z "$as_dir" && as_dir=.
7335   for ac_exec_ext in '' $ac_executable_extensions; do
7336   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7337     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7338     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7339     break 2
7340   fi
7341 done
7342 done
7343
7344 fi
7345 fi
7346 LIPO=$ac_cv_prog_LIPO
7347 if test -n "$LIPO"; then
7348   echo "$as_me:$LINENO: result: $LIPO" >&5
7349 echo "${ECHO_T}$LIPO" >&6
7350 else
7351   echo "$as_me:$LINENO: result: no" >&5
7352 echo "${ECHO_T}no" >&6
7353 fi
7354
7355   fi
7356   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7357     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7358 set dummy ${ncn_progname}; ac_word=$2
7359 echo "$as_me:$LINENO: checking for $ac_word" >&5
7360 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7361 if test "${ac_cv_prog_LIPO+set}" = set; then
7362   echo $ECHO_N "(cached) $ECHO_C" >&6
7363 else
7364   if test -n "$LIPO"; then
7365   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7366 else
7367 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7368 for as_dir in $PATH
7369 do
7370   IFS=$as_save_IFS
7371   test -z "$as_dir" && as_dir=.
7372   for ac_exec_ext in '' $ac_executable_extensions; do
7373   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7374     ac_cv_prog_LIPO="${ncn_progname}"
7375     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7376     break 2
7377   fi
7378 done
7379 done
7380
7381 fi
7382 fi
7383 LIPO=$ac_cv_prog_LIPO
7384 if test -n "$LIPO"; then
7385   echo "$as_me:$LINENO: result: $LIPO" >&5
7386 echo "${ECHO_T}$LIPO" >&6
7387 else
7388   echo "$as_me:$LINENO: result: no" >&5
7389 echo "${ECHO_T}no" >&6
7390 fi
7391
7392   fi
7393   test -n "$ac_cv_prog_LIPO" && break
7394 done
7395
7396 if test -z "$ac_cv_prog_LIPO" ; then
7397   set dummy lipo
7398   if test $build = $host ; then
7399     LIPO="$2"
7400   else
7401     LIPO="${ncn_tool_prefix}$2"
7402   fi
7403 fi
7404
7405
7406
7407 if test -n "$NM"; then
7408   ac_cv_prog_NM=$NM
7409 elif test -n "$ac_cv_prog_NM"; then
7410   NM=$ac_cv_prog_NM
7411 fi
7412
7413 if test -n "$ac_cv_prog_NM"; then
7414   for ncn_progname in nm; do
7415     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7416 set dummy ${ncn_progname}; ac_word=$2
7417 echo "$as_me:$LINENO: checking for $ac_word" >&5
7418 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7419 if test "${ac_cv_prog_NM+set}" = set; then
7420   echo $ECHO_N "(cached) $ECHO_C" >&6
7421 else
7422   if test -n "$NM"; then
7423   ac_cv_prog_NM="$NM" # Let the user override the test.
7424 else
7425 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7426 for as_dir in $PATH
7427 do
7428   IFS=$as_save_IFS
7429   test -z "$as_dir" && as_dir=.
7430   for ac_exec_ext in '' $ac_executable_extensions; do
7431   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7432     ac_cv_prog_NM="${ncn_progname}"
7433     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7434     break 2
7435   fi
7436 done
7437 done
7438
7439 fi
7440 fi
7441 NM=$ac_cv_prog_NM
7442 if test -n "$NM"; then
7443   echo "$as_me:$LINENO: result: $NM" >&5
7444 echo "${ECHO_T}$NM" >&6
7445 else
7446   echo "$as_me:$LINENO: result: no" >&5
7447 echo "${ECHO_T}no" >&6
7448 fi
7449
7450   done
7451 fi
7452
7453 for ncn_progname in nm; do
7454   if test -n "$ncn_tool_prefix"; then
7455     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7456 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7457 echo "$as_me:$LINENO: checking for $ac_word" >&5
7458 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7459 if test "${ac_cv_prog_NM+set}" = set; then
7460   echo $ECHO_N "(cached) $ECHO_C" >&6
7461 else
7462   if test -n "$NM"; then
7463   ac_cv_prog_NM="$NM" # Let the user override the test.
7464 else
7465 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7466 for as_dir in $PATH
7467 do
7468   IFS=$as_save_IFS
7469   test -z "$as_dir" && as_dir=.
7470   for ac_exec_ext in '' $ac_executable_extensions; do
7471   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7472     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7473     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7474     break 2
7475   fi
7476 done
7477 done
7478
7479 fi
7480 fi
7481 NM=$ac_cv_prog_NM
7482 if test -n "$NM"; then
7483   echo "$as_me:$LINENO: result: $NM" >&5
7484 echo "${ECHO_T}$NM" >&6
7485 else
7486   echo "$as_me:$LINENO: result: no" >&5
7487 echo "${ECHO_T}no" >&6
7488 fi
7489
7490   fi
7491   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7492     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7493 set dummy ${ncn_progname}; ac_word=$2
7494 echo "$as_me:$LINENO: checking for $ac_word" >&5
7495 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7496 if test "${ac_cv_prog_NM+set}" = set; then
7497   echo $ECHO_N "(cached) $ECHO_C" >&6
7498 else
7499   if test -n "$NM"; then
7500   ac_cv_prog_NM="$NM" # Let the user override the test.
7501 else
7502 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7503 for as_dir in $PATH
7504 do
7505   IFS=$as_save_IFS
7506   test -z "$as_dir" && as_dir=.
7507   for ac_exec_ext in '' $ac_executable_extensions; do
7508   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7509     ac_cv_prog_NM="${ncn_progname}"
7510     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7511     break 2
7512   fi
7513 done
7514 done
7515
7516 fi
7517 fi
7518 NM=$ac_cv_prog_NM
7519 if test -n "$NM"; then
7520   echo "$as_me:$LINENO: result: $NM" >&5
7521 echo "${ECHO_T}$NM" >&6
7522 else
7523   echo "$as_me:$LINENO: result: no" >&5
7524 echo "${ECHO_T}no" >&6
7525 fi
7526
7527   fi
7528   test -n "$ac_cv_prog_NM" && break
7529 done
7530
7531 if test -z "$ac_cv_prog_NM" ; then
7532   set dummy nm
7533   if test $build = $host ; then
7534     NM="$2"
7535   else
7536     NM="${ncn_tool_prefix}$2"
7537   fi
7538 fi
7539
7540
7541
7542 if test -n "$RANLIB"; then
7543   ac_cv_prog_RANLIB=$RANLIB
7544 elif test -n "$ac_cv_prog_RANLIB"; then
7545   RANLIB=$ac_cv_prog_RANLIB
7546 fi
7547
7548 if test -n "$ac_cv_prog_RANLIB"; then
7549   for ncn_progname in ranlib; do
7550     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7551 set dummy ${ncn_progname}; ac_word=$2
7552 echo "$as_me:$LINENO: checking for $ac_word" >&5
7553 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7554 if test "${ac_cv_prog_RANLIB+set}" = set; then
7555   echo $ECHO_N "(cached) $ECHO_C" >&6
7556 else
7557   if test -n "$RANLIB"; then
7558   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7559 else
7560 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7561 for as_dir in $PATH
7562 do
7563   IFS=$as_save_IFS
7564   test -z "$as_dir" && as_dir=.
7565   for ac_exec_ext in '' $ac_executable_extensions; do
7566   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7567     ac_cv_prog_RANLIB="${ncn_progname}"
7568     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7569     break 2
7570   fi
7571 done
7572 done
7573
7574 fi
7575 fi
7576 RANLIB=$ac_cv_prog_RANLIB
7577 if test -n "$RANLIB"; then
7578   echo "$as_me:$LINENO: result: $RANLIB" >&5
7579 echo "${ECHO_T}$RANLIB" >&6
7580 else
7581   echo "$as_me:$LINENO: result: no" >&5
7582 echo "${ECHO_T}no" >&6
7583 fi
7584
7585   done
7586 fi
7587
7588 for ncn_progname in ranlib; do
7589   if test -n "$ncn_tool_prefix"; then
7590     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7591 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7592 echo "$as_me:$LINENO: checking for $ac_word" >&5
7593 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7594 if test "${ac_cv_prog_RANLIB+set}" = set; then
7595   echo $ECHO_N "(cached) $ECHO_C" >&6
7596 else
7597   if test -n "$RANLIB"; then
7598   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7599 else
7600 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7601 for as_dir in $PATH
7602 do
7603   IFS=$as_save_IFS
7604   test -z "$as_dir" && as_dir=.
7605   for ac_exec_ext in '' $ac_executable_extensions; do
7606   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7607     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7608     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7609     break 2
7610   fi
7611 done
7612 done
7613
7614 fi
7615 fi
7616 RANLIB=$ac_cv_prog_RANLIB
7617 if test -n "$RANLIB"; then
7618   echo "$as_me:$LINENO: result: $RANLIB" >&5
7619 echo "${ECHO_T}$RANLIB" >&6
7620 else
7621   echo "$as_me:$LINENO: result: no" >&5
7622 echo "${ECHO_T}no" >&6
7623 fi
7624
7625   fi
7626   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7627     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7628 set dummy ${ncn_progname}; ac_word=$2
7629 echo "$as_me:$LINENO: checking for $ac_word" >&5
7630 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7631 if test "${ac_cv_prog_RANLIB+set}" = set; then
7632   echo $ECHO_N "(cached) $ECHO_C" >&6
7633 else
7634   if test -n "$RANLIB"; then
7635   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7636 else
7637 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7638 for as_dir in $PATH
7639 do
7640   IFS=$as_save_IFS
7641   test -z "$as_dir" && as_dir=.
7642   for ac_exec_ext in '' $ac_executable_extensions; do
7643   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7644     ac_cv_prog_RANLIB="${ncn_progname}"
7645     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7646     break 2
7647   fi
7648 done
7649 done
7650
7651 fi
7652 fi
7653 RANLIB=$ac_cv_prog_RANLIB
7654 if test -n "$RANLIB"; then
7655   echo "$as_me:$LINENO: result: $RANLIB" >&5
7656 echo "${ECHO_T}$RANLIB" >&6
7657 else
7658   echo "$as_me:$LINENO: result: no" >&5
7659 echo "${ECHO_T}no" >&6
7660 fi
7661
7662   fi
7663   test -n "$ac_cv_prog_RANLIB" && break
7664 done
7665
7666 if test -z "$ac_cv_prog_RANLIB" ; then
7667   RANLIB=":"
7668 fi
7669
7670
7671
7672 if test -n "$STRIP"; then
7673   ac_cv_prog_STRIP=$STRIP
7674 elif test -n "$ac_cv_prog_STRIP"; then
7675   STRIP=$ac_cv_prog_STRIP
7676 fi
7677
7678 if test -n "$ac_cv_prog_STRIP"; then
7679   for ncn_progname in strip; do
7680     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7681 set dummy ${ncn_progname}; ac_word=$2
7682 echo "$as_me:$LINENO: checking for $ac_word" >&5
7683 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7684 if test "${ac_cv_prog_STRIP+set}" = set; then
7685   echo $ECHO_N "(cached) $ECHO_C" >&6
7686 else
7687   if test -n "$STRIP"; then
7688   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7689 else
7690 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7691 for as_dir in $PATH
7692 do
7693   IFS=$as_save_IFS
7694   test -z "$as_dir" && as_dir=.
7695   for ac_exec_ext in '' $ac_executable_extensions; do
7696   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7697     ac_cv_prog_STRIP="${ncn_progname}"
7698     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7699     break 2
7700   fi
7701 done
7702 done
7703
7704 fi
7705 fi
7706 STRIP=$ac_cv_prog_STRIP
7707 if test -n "$STRIP"; then
7708   echo "$as_me:$LINENO: result: $STRIP" >&5
7709 echo "${ECHO_T}$STRIP" >&6
7710 else
7711   echo "$as_me:$LINENO: result: no" >&5
7712 echo "${ECHO_T}no" >&6
7713 fi
7714
7715   done
7716 fi
7717
7718 for ncn_progname in strip; do
7719   if test -n "$ncn_tool_prefix"; then
7720     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7721 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7722 echo "$as_me:$LINENO: checking for $ac_word" >&5
7723 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7724 if test "${ac_cv_prog_STRIP+set}" = set; then
7725   echo $ECHO_N "(cached) $ECHO_C" >&6
7726 else
7727   if test -n "$STRIP"; then
7728   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7729 else
7730 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7731 for as_dir in $PATH
7732 do
7733   IFS=$as_save_IFS
7734   test -z "$as_dir" && as_dir=.
7735   for ac_exec_ext in '' $ac_executable_extensions; do
7736   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7737     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7738     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7739     break 2
7740   fi
7741 done
7742 done
7743
7744 fi
7745 fi
7746 STRIP=$ac_cv_prog_STRIP
7747 if test -n "$STRIP"; then
7748   echo "$as_me:$LINENO: result: $STRIP" >&5
7749 echo "${ECHO_T}$STRIP" >&6
7750 else
7751   echo "$as_me:$LINENO: result: no" >&5
7752 echo "${ECHO_T}no" >&6
7753 fi
7754
7755   fi
7756   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7757     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7758 set dummy ${ncn_progname}; ac_word=$2
7759 echo "$as_me:$LINENO: checking for $ac_word" >&5
7760 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7761 if test "${ac_cv_prog_STRIP+set}" = set; then
7762   echo $ECHO_N "(cached) $ECHO_C" >&6
7763 else
7764   if test -n "$STRIP"; then
7765   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7766 else
7767 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7768 for as_dir in $PATH
7769 do
7770   IFS=$as_save_IFS
7771   test -z "$as_dir" && as_dir=.
7772   for ac_exec_ext in '' $ac_executable_extensions; do
7773   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7774     ac_cv_prog_STRIP="${ncn_progname}"
7775     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7776     break 2
7777   fi
7778 done
7779 done
7780
7781 fi
7782 fi
7783 STRIP=$ac_cv_prog_STRIP
7784 if test -n "$STRIP"; then
7785   echo "$as_me:$LINENO: result: $STRIP" >&5
7786 echo "${ECHO_T}$STRIP" >&6
7787 else
7788   echo "$as_me:$LINENO: result: no" >&5
7789 echo "${ECHO_T}no" >&6
7790 fi
7791
7792   fi
7793   test -n "$ac_cv_prog_STRIP" && break
7794 done
7795
7796 if test -z "$ac_cv_prog_STRIP" ; then
7797   STRIP=":"
7798 fi
7799
7800
7801
7802 if test -n "$WINDRES"; then
7803   ac_cv_prog_WINDRES=$WINDRES
7804 elif test -n "$ac_cv_prog_WINDRES"; then
7805   WINDRES=$ac_cv_prog_WINDRES
7806 fi
7807
7808 if test -n "$ac_cv_prog_WINDRES"; then
7809   for ncn_progname in windres; do
7810     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7811 set dummy ${ncn_progname}; ac_word=$2
7812 echo "$as_me:$LINENO: checking for $ac_word" >&5
7813 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7814 if test "${ac_cv_prog_WINDRES+set}" = set; then
7815   echo $ECHO_N "(cached) $ECHO_C" >&6
7816 else
7817   if test -n "$WINDRES"; then
7818   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7819 else
7820 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7821 for as_dir in $PATH
7822 do
7823   IFS=$as_save_IFS
7824   test -z "$as_dir" && as_dir=.
7825   for ac_exec_ext in '' $ac_executable_extensions; do
7826   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7827     ac_cv_prog_WINDRES="${ncn_progname}"
7828     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7829     break 2
7830   fi
7831 done
7832 done
7833
7834 fi
7835 fi
7836 WINDRES=$ac_cv_prog_WINDRES
7837 if test -n "$WINDRES"; then
7838   echo "$as_me:$LINENO: result: $WINDRES" >&5
7839 echo "${ECHO_T}$WINDRES" >&6
7840 else
7841   echo "$as_me:$LINENO: result: no" >&5
7842 echo "${ECHO_T}no" >&6
7843 fi
7844
7845   done
7846 fi
7847
7848 for ncn_progname in windres; do
7849   if test -n "$ncn_tool_prefix"; then
7850     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7851 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7852 echo "$as_me:$LINENO: checking for $ac_word" >&5
7853 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7854 if test "${ac_cv_prog_WINDRES+set}" = set; then
7855   echo $ECHO_N "(cached) $ECHO_C" >&6
7856 else
7857   if test -n "$WINDRES"; then
7858   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7859 else
7860 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7861 for as_dir in $PATH
7862 do
7863   IFS=$as_save_IFS
7864   test -z "$as_dir" && as_dir=.
7865   for ac_exec_ext in '' $ac_executable_extensions; do
7866   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7867     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7868     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7869     break 2
7870   fi
7871 done
7872 done
7873
7874 fi
7875 fi
7876 WINDRES=$ac_cv_prog_WINDRES
7877 if test -n "$WINDRES"; then
7878   echo "$as_me:$LINENO: result: $WINDRES" >&5
7879 echo "${ECHO_T}$WINDRES" >&6
7880 else
7881   echo "$as_me:$LINENO: result: no" >&5
7882 echo "${ECHO_T}no" >&6
7883 fi
7884
7885   fi
7886   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7887     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7888 set dummy ${ncn_progname}; ac_word=$2
7889 echo "$as_me:$LINENO: checking for $ac_word" >&5
7890 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7891 if test "${ac_cv_prog_WINDRES+set}" = set; then
7892   echo $ECHO_N "(cached) $ECHO_C" >&6
7893 else
7894   if test -n "$WINDRES"; then
7895   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7896 else
7897 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7898 for as_dir in $PATH
7899 do
7900   IFS=$as_save_IFS
7901   test -z "$as_dir" && as_dir=.
7902   for ac_exec_ext in '' $ac_executable_extensions; do
7903   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7904     ac_cv_prog_WINDRES="${ncn_progname}"
7905     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7906     break 2
7907   fi
7908 done
7909 done
7910
7911 fi
7912 fi
7913 WINDRES=$ac_cv_prog_WINDRES
7914 if test -n "$WINDRES"; then
7915   echo "$as_me:$LINENO: result: $WINDRES" >&5
7916 echo "${ECHO_T}$WINDRES" >&6
7917 else
7918   echo "$as_me:$LINENO: result: no" >&5
7919 echo "${ECHO_T}no" >&6
7920 fi
7921
7922   fi
7923   test -n "$ac_cv_prog_WINDRES" && break
7924 done
7925
7926 if test -z "$ac_cv_prog_WINDRES" ; then
7927   set dummy windres
7928   if test $build = $host ; then
7929     WINDRES="$2"
7930   else
7931     WINDRES="${ncn_tool_prefix}$2"
7932   fi
7933 fi
7934
7935
7936
7937 if test -n "$WINDMC"; then
7938   ac_cv_prog_WINDMC=$WINDMC
7939 elif test -n "$ac_cv_prog_WINDMC"; then
7940   WINDMC=$ac_cv_prog_WINDMC
7941 fi
7942
7943 if test -n "$ac_cv_prog_WINDMC"; then
7944   for ncn_progname in windmc; do
7945     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7946 set dummy ${ncn_progname}; ac_word=$2
7947 echo "$as_me:$LINENO: checking for $ac_word" >&5
7948 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7949 if test "${ac_cv_prog_WINDMC+set}" = set; then
7950   echo $ECHO_N "(cached) $ECHO_C" >&6
7951 else
7952   if test -n "$WINDMC"; then
7953   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7954 else
7955 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7956 for as_dir in $PATH
7957 do
7958   IFS=$as_save_IFS
7959   test -z "$as_dir" && as_dir=.
7960   for ac_exec_ext in '' $ac_executable_extensions; do
7961   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7962     ac_cv_prog_WINDMC="${ncn_progname}"
7963     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7964     break 2
7965   fi
7966 done
7967 done
7968
7969 fi
7970 fi
7971 WINDMC=$ac_cv_prog_WINDMC
7972 if test -n "$WINDMC"; then
7973   echo "$as_me:$LINENO: result: $WINDMC" >&5
7974 echo "${ECHO_T}$WINDMC" >&6
7975 else
7976   echo "$as_me:$LINENO: result: no" >&5
7977 echo "${ECHO_T}no" >&6
7978 fi
7979
7980   done
7981 fi
7982
7983 for ncn_progname in windmc; do
7984   if test -n "$ncn_tool_prefix"; then
7985     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7986 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7987 echo "$as_me:$LINENO: checking for $ac_word" >&5
7988 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7989 if test "${ac_cv_prog_WINDMC+set}" = set; then
7990   echo $ECHO_N "(cached) $ECHO_C" >&6
7991 else
7992   if test -n "$WINDMC"; then
7993   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7994 else
7995 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7996 for as_dir in $PATH
7997 do
7998   IFS=$as_save_IFS
7999   test -z "$as_dir" && as_dir=.
8000   for ac_exec_ext in '' $ac_executable_extensions; do
8001   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8002     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8003     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8004     break 2
8005   fi
8006 done
8007 done
8008
8009 fi
8010 fi
8011 WINDMC=$ac_cv_prog_WINDMC
8012 if test -n "$WINDMC"; then
8013   echo "$as_me:$LINENO: result: $WINDMC" >&5
8014 echo "${ECHO_T}$WINDMC" >&6
8015 else
8016   echo "$as_me:$LINENO: result: no" >&5
8017 echo "${ECHO_T}no" >&6
8018 fi
8019
8020   fi
8021   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8022     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8023 set dummy ${ncn_progname}; ac_word=$2
8024 echo "$as_me:$LINENO: checking for $ac_word" >&5
8025 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8026 if test "${ac_cv_prog_WINDMC+set}" = set; then
8027   echo $ECHO_N "(cached) $ECHO_C" >&6
8028 else
8029   if test -n "$WINDMC"; then
8030   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8031 else
8032 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8033 for as_dir in $PATH
8034 do
8035   IFS=$as_save_IFS
8036   test -z "$as_dir" && as_dir=.
8037   for ac_exec_ext in '' $ac_executable_extensions; do
8038   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8039     ac_cv_prog_WINDMC="${ncn_progname}"
8040     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8041     break 2
8042   fi
8043 done
8044 done
8045
8046 fi
8047 fi
8048 WINDMC=$ac_cv_prog_WINDMC
8049 if test -n "$WINDMC"; then
8050   echo "$as_me:$LINENO: result: $WINDMC" >&5
8051 echo "${ECHO_T}$WINDMC" >&6
8052 else
8053   echo "$as_me:$LINENO: result: no" >&5
8054 echo "${ECHO_T}no" >&6
8055 fi
8056
8057   fi
8058   test -n "$ac_cv_prog_WINDMC" && break
8059 done
8060
8061 if test -z "$ac_cv_prog_WINDMC" ; then
8062   set dummy windmc
8063   if test $build = $host ; then
8064     WINDMC="$2"
8065   else
8066     WINDMC="${ncn_tool_prefix}$2"
8067   fi
8068 fi
8069
8070
8071
8072 if test -n "$OBJCOPY"; then
8073   ac_cv_prog_OBJCOPY=$OBJCOPY
8074 elif test -n "$ac_cv_prog_OBJCOPY"; then
8075   OBJCOPY=$ac_cv_prog_OBJCOPY
8076 fi
8077
8078 if test -n "$ac_cv_prog_OBJCOPY"; then
8079   for ncn_progname in objcopy; do
8080     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8081 set dummy ${ncn_progname}; ac_word=$2
8082 echo "$as_me:$LINENO: checking for $ac_word" >&5
8083 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8084 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8085   echo $ECHO_N "(cached) $ECHO_C" >&6
8086 else
8087   if test -n "$OBJCOPY"; then
8088   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8089 else
8090 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8091 for as_dir in $PATH
8092 do
8093   IFS=$as_save_IFS
8094   test -z "$as_dir" && as_dir=.
8095   for ac_exec_ext in '' $ac_executable_extensions; do
8096   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8097     ac_cv_prog_OBJCOPY="${ncn_progname}"
8098     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8099     break 2
8100   fi
8101 done
8102 done
8103
8104 fi
8105 fi
8106 OBJCOPY=$ac_cv_prog_OBJCOPY
8107 if test -n "$OBJCOPY"; then
8108   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8109 echo "${ECHO_T}$OBJCOPY" >&6
8110 else
8111   echo "$as_me:$LINENO: result: no" >&5
8112 echo "${ECHO_T}no" >&6
8113 fi
8114
8115   done
8116 fi
8117
8118 for ncn_progname in objcopy; do
8119   if test -n "$ncn_tool_prefix"; then
8120     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8121 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8122 echo "$as_me:$LINENO: checking for $ac_word" >&5
8123 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8124 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8125   echo $ECHO_N "(cached) $ECHO_C" >&6
8126 else
8127   if test -n "$OBJCOPY"; then
8128   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8129 else
8130 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8131 for as_dir in $PATH
8132 do
8133   IFS=$as_save_IFS
8134   test -z "$as_dir" && as_dir=.
8135   for ac_exec_ext in '' $ac_executable_extensions; do
8136   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8137     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8138     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8139     break 2
8140   fi
8141 done
8142 done
8143
8144 fi
8145 fi
8146 OBJCOPY=$ac_cv_prog_OBJCOPY
8147 if test -n "$OBJCOPY"; then
8148   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8149 echo "${ECHO_T}$OBJCOPY" >&6
8150 else
8151   echo "$as_me:$LINENO: result: no" >&5
8152 echo "${ECHO_T}no" >&6
8153 fi
8154
8155   fi
8156   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8157     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8158 set dummy ${ncn_progname}; ac_word=$2
8159 echo "$as_me:$LINENO: checking for $ac_word" >&5
8160 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8161 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8162   echo $ECHO_N "(cached) $ECHO_C" >&6
8163 else
8164   if test -n "$OBJCOPY"; then
8165   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8166 else
8167 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8168 for as_dir in $PATH
8169 do
8170   IFS=$as_save_IFS
8171   test -z "$as_dir" && as_dir=.
8172   for ac_exec_ext in '' $ac_executable_extensions; do
8173   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8174     ac_cv_prog_OBJCOPY="${ncn_progname}"
8175     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8176     break 2
8177   fi
8178 done
8179 done
8180
8181 fi
8182 fi
8183 OBJCOPY=$ac_cv_prog_OBJCOPY
8184 if test -n "$OBJCOPY"; then
8185   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8186 echo "${ECHO_T}$OBJCOPY" >&6
8187 else
8188   echo "$as_me:$LINENO: result: no" >&5
8189 echo "${ECHO_T}no" >&6
8190 fi
8191
8192   fi
8193   test -n "$ac_cv_prog_OBJCOPY" && break
8194 done
8195
8196 if test -z "$ac_cv_prog_OBJCOPY" ; then
8197   set dummy objcopy
8198   if test $build = $host ; then
8199     OBJCOPY="$2"
8200   else
8201     OBJCOPY="${ncn_tool_prefix}$2"
8202   fi
8203 fi
8204
8205
8206
8207 if test -n "$OBJDUMP"; then
8208   ac_cv_prog_OBJDUMP=$OBJDUMP
8209 elif test -n "$ac_cv_prog_OBJDUMP"; then
8210   OBJDUMP=$ac_cv_prog_OBJDUMP
8211 fi
8212
8213 if test -n "$ac_cv_prog_OBJDUMP"; then
8214   for ncn_progname in objdump; do
8215     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8216 set dummy ${ncn_progname}; ac_word=$2
8217 echo "$as_me:$LINENO: checking for $ac_word" >&5
8218 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8219 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8220   echo $ECHO_N "(cached) $ECHO_C" >&6
8221 else
8222   if test -n "$OBJDUMP"; then
8223   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8224 else
8225 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8226 for as_dir in $PATH
8227 do
8228   IFS=$as_save_IFS
8229   test -z "$as_dir" && as_dir=.
8230   for ac_exec_ext in '' $ac_executable_extensions; do
8231   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8232     ac_cv_prog_OBJDUMP="${ncn_progname}"
8233     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8234     break 2
8235   fi
8236 done
8237 done
8238
8239 fi
8240 fi
8241 OBJDUMP=$ac_cv_prog_OBJDUMP
8242 if test -n "$OBJDUMP"; then
8243   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8244 echo "${ECHO_T}$OBJDUMP" >&6
8245 else
8246   echo "$as_me:$LINENO: result: no" >&5
8247 echo "${ECHO_T}no" >&6
8248 fi
8249
8250   done
8251 fi
8252
8253 for ncn_progname in objdump; do
8254   if test -n "$ncn_tool_prefix"; then
8255     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8256 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8257 echo "$as_me:$LINENO: checking for $ac_word" >&5
8258 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8259 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8260   echo $ECHO_N "(cached) $ECHO_C" >&6
8261 else
8262   if test -n "$OBJDUMP"; then
8263   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8264 else
8265 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8266 for as_dir in $PATH
8267 do
8268   IFS=$as_save_IFS
8269   test -z "$as_dir" && as_dir=.
8270   for ac_exec_ext in '' $ac_executable_extensions; do
8271   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8272     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8273     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8274     break 2
8275   fi
8276 done
8277 done
8278
8279 fi
8280 fi
8281 OBJDUMP=$ac_cv_prog_OBJDUMP
8282 if test -n "$OBJDUMP"; then
8283   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8284 echo "${ECHO_T}$OBJDUMP" >&6
8285 else
8286   echo "$as_me:$LINENO: result: no" >&5
8287 echo "${ECHO_T}no" >&6
8288 fi
8289
8290   fi
8291   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8292     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8293 set dummy ${ncn_progname}; ac_word=$2
8294 echo "$as_me:$LINENO: checking for $ac_word" >&5
8295 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8296 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8297   echo $ECHO_N "(cached) $ECHO_C" >&6
8298 else
8299   if test -n "$OBJDUMP"; then
8300   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8301 else
8302 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8303 for as_dir in $PATH
8304 do
8305   IFS=$as_save_IFS
8306   test -z "$as_dir" && as_dir=.
8307   for ac_exec_ext in '' $ac_executable_extensions; do
8308   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8309     ac_cv_prog_OBJDUMP="${ncn_progname}"
8310     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8311     break 2
8312   fi
8313 done
8314 done
8315
8316 fi
8317 fi
8318 OBJDUMP=$ac_cv_prog_OBJDUMP
8319 if test -n "$OBJDUMP"; then
8320   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8321 echo "${ECHO_T}$OBJDUMP" >&6
8322 else
8323   echo "$as_me:$LINENO: result: no" >&5
8324 echo "${ECHO_T}no" >&6
8325 fi
8326
8327   fi
8328   test -n "$ac_cv_prog_OBJDUMP" && break
8329 done
8330
8331 if test -z "$ac_cv_prog_OBJDUMP" ; then
8332   set dummy objdump
8333   if test $build = $host ; then
8334     OBJDUMP="$2"
8335   else
8336     OBJDUMP="${ncn_tool_prefix}$2"
8337   fi
8338 fi
8339
8340
8341
8342
8343
8344
8345 # Target tools.
8346
8347 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8348 if test "${with_build_time_tools+set}" = set; then
8349   withval="$with_build_time_tools"
8350   case x"$withval" in
8351      x/*) ;;
8352      *)
8353        with_build_time_tools=
8354        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8355 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8356        ;;
8357    esac
8358 else
8359   with_build_time_tools=
8360 fi;
8361
8362
8363
8364 if test -n "$CC_FOR_TARGET"; then
8365   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8366 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8367   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8368 fi
8369
8370 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8371   for ncn_progname in cc gcc; do
8372     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8373 set dummy ${ncn_progname}; ac_word=$2
8374 echo "$as_me:$LINENO: checking for $ac_word" >&5
8375 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8376 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8377   echo $ECHO_N "(cached) $ECHO_C" >&6
8378 else
8379   if test -n "$CC_FOR_TARGET"; then
8380   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8381 else
8382 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8383 for as_dir in $PATH
8384 do
8385   IFS=$as_save_IFS
8386   test -z "$as_dir" && as_dir=.
8387   for ac_exec_ext in '' $ac_executable_extensions; do
8388   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8389     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8390     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8391     break 2
8392   fi
8393 done
8394 done
8395
8396 fi
8397 fi
8398 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8399 if test -n "$CC_FOR_TARGET"; then
8400   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8401 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8402 else
8403   echo "$as_me:$LINENO: result: no" >&5
8404 echo "${ECHO_T}no" >&6
8405 fi
8406
8407   done
8408 fi
8409
8410 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8411   for ncn_progname in cc gcc; do
8412     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8413 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8414     if test -x $with_build_time_tools/${ncn_progname}; then
8415       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8416       echo "$as_me:$LINENO: result: yes" >&5
8417 echo "${ECHO_T}yes" >&6
8418       break
8419     else
8420       echo "$as_me:$LINENO: result: no" >&5
8421 echo "${ECHO_T}no" >&6
8422     fi
8423   done
8424 fi
8425
8426 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8427   for ncn_progname in cc gcc; do
8428     if test -n "$ncn_target_tool_prefix"; then
8429       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8430 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8431 echo "$as_me:$LINENO: checking for $ac_word" >&5
8432 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8433 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8434   echo $ECHO_N "(cached) $ECHO_C" >&6
8435 else
8436   if test -n "$CC_FOR_TARGET"; then
8437   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8438 else
8439 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8440 for as_dir in $PATH
8441 do
8442   IFS=$as_save_IFS
8443   test -z "$as_dir" && as_dir=.
8444   for ac_exec_ext in '' $ac_executable_extensions; do
8445   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8446     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8447     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8448     break 2
8449   fi
8450 done
8451 done
8452
8453 fi
8454 fi
8455 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8456 if test -n "$CC_FOR_TARGET"; then
8457   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8458 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8459 else
8460   echo "$as_me:$LINENO: result: no" >&5
8461 echo "${ECHO_T}no" >&6
8462 fi
8463
8464     fi
8465     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8466       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8467 set dummy ${ncn_progname}; ac_word=$2
8468 echo "$as_me:$LINENO: checking for $ac_word" >&5
8469 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8470 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8471   echo $ECHO_N "(cached) $ECHO_C" >&6
8472 else
8473   if test -n "$CC_FOR_TARGET"; then
8474   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8475 else
8476 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8477 for as_dir in $PATH
8478 do
8479   IFS=$as_save_IFS
8480   test -z "$as_dir" && as_dir=.
8481   for ac_exec_ext in '' $ac_executable_extensions; do
8482   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8483     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8484     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8485     break 2
8486   fi
8487 done
8488 done
8489
8490 fi
8491 fi
8492 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8493 if test -n "$CC_FOR_TARGET"; then
8494   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8495 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8496 else
8497   echo "$as_me:$LINENO: result: no" >&5
8498 echo "${ECHO_T}no" >&6
8499 fi
8500
8501     fi
8502     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8503   done
8504 fi
8505
8506 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8507   set dummy cc gcc
8508   if test $build = $target ; then
8509     CC_FOR_TARGET="$2"
8510   else
8511     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8512   fi
8513 else
8514   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8515 fi
8516
8517
8518
8519 if test -n "$CXX_FOR_TARGET"; then
8520   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8521 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8522   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8523 fi
8524
8525 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8526   for ncn_progname in c++ g++ cxx gxx; do
8527     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8528 set dummy ${ncn_progname}; ac_word=$2
8529 echo "$as_me:$LINENO: checking for $ac_word" >&5
8530 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8531 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8532   echo $ECHO_N "(cached) $ECHO_C" >&6
8533 else
8534   if test -n "$CXX_FOR_TARGET"; then
8535   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8536 else
8537 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8538 for as_dir in $PATH
8539 do
8540   IFS=$as_save_IFS
8541   test -z "$as_dir" && as_dir=.
8542   for ac_exec_ext in '' $ac_executable_extensions; do
8543   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8544     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8545     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8546     break 2
8547   fi
8548 done
8549 done
8550
8551 fi
8552 fi
8553 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8554 if test -n "$CXX_FOR_TARGET"; then
8555   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8556 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8557 else
8558   echo "$as_me:$LINENO: result: no" >&5
8559 echo "${ECHO_T}no" >&6
8560 fi
8561
8562   done
8563 fi
8564
8565 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8566   for ncn_progname in c++ g++ cxx gxx; do
8567     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8568 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8569     if test -x $with_build_time_tools/${ncn_progname}; then
8570       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8571       echo "$as_me:$LINENO: result: yes" >&5
8572 echo "${ECHO_T}yes" >&6
8573       break
8574     else
8575       echo "$as_me:$LINENO: result: no" >&5
8576 echo "${ECHO_T}no" >&6
8577     fi
8578   done
8579 fi
8580
8581 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8582   for ncn_progname in c++ g++ cxx gxx; do
8583     if test -n "$ncn_target_tool_prefix"; then
8584       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8585 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8586 echo "$as_me:$LINENO: checking for $ac_word" >&5
8587 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8588 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8589   echo $ECHO_N "(cached) $ECHO_C" >&6
8590 else
8591   if test -n "$CXX_FOR_TARGET"; then
8592   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8593 else
8594 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8595 for as_dir in $PATH
8596 do
8597   IFS=$as_save_IFS
8598   test -z "$as_dir" && as_dir=.
8599   for ac_exec_ext in '' $ac_executable_extensions; do
8600   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8601     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8602     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8603     break 2
8604   fi
8605 done
8606 done
8607
8608 fi
8609 fi
8610 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8611 if test -n "$CXX_FOR_TARGET"; then
8612   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8613 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8614 else
8615   echo "$as_me:$LINENO: result: no" >&5
8616 echo "${ECHO_T}no" >&6
8617 fi
8618
8619     fi
8620     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8621       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8622 set dummy ${ncn_progname}; ac_word=$2
8623 echo "$as_me:$LINENO: checking for $ac_word" >&5
8624 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8625 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8626   echo $ECHO_N "(cached) $ECHO_C" >&6
8627 else
8628   if test -n "$CXX_FOR_TARGET"; then
8629   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8630 else
8631 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8632 for as_dir in $PATH
8633 do
8634   IFS=$as_save_IFS
8635   test -z "$as_dir" && as_dir=.
8636   for ac_exec_ext in '' $ac_executable_extensions; do
8637   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8638     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8639     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8640     break 2
8641   fi
8642 done
8643 done
8644
8645 fi
8646 fi
8647 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8648 if test -n "$CXX_FOR_TARGET"; then
8649   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8650 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8651 else
8652   echo "$as_me:$LINENO: result: no" >&5
8653 echo "${ECHO_T}no" >&6
8654 fi
8655
8656     fi
8657     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8658   done
8659 fi
8660
8661 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8662   set dummy c++ g++ cxx gxx
8663   if test $build = $target ; then
8664     CXX_FOR_TARGET="$2"
8665   else
8666     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8667   fi
8668 else
8669   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8670 fi
8671
8672
8673
8674 if test -n "$GCC_FOR_TARGET"; then
8675   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8676 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8677   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8678 fi
8679
8680 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8681   for ncn_progname in gcc; do
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_GCC_FOR_TARGET+set}" = set; then
8687   echo $ECHO_N "(cached) $ECHO_C" >&6
8688 else
8689   if test -n "$GCC_FOR_TARGET"; then
8690   ac_cv_prog_GCC_FOR_TARGET="$GCC_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_GCC_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 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8709 if test -n "$GCC_FOR_TARGET"; then
8710   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8711 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8712 else
8713   echo "$as_me:$LINENO: result: no" >&5
8714 echo "${ECHO_T}no" >&6
8715 fi
8716
8717   done
8718 fi
8719
8720 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8721   for ncn_progname in gcc; do
8722     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8723 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8724     if test -x $with_build_time_tools/${ncn_progname}; then
8725       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8726       echo "$as_me:$LINENO: result: yes" >&5
8727 echo "${ECHO_T}yes" >&6
8728       break
8729     else
8730       echo "$as_me:$LINENO: result: no" >&5
8731 echo "${ECHO_T}no" >&6
8732     fi
8733   done
8734 fi
8735
8736 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8737   for ncn_progname in gcc; do
8738     if test -n "$ncn_target_tool_prefix"; then
8739       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8740 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8741 echo "$as_me:$LINENO: checking for $ac_word" >&5
8742 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8743 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8744   echo $ECHO_N "(cached) $ECHO_C" >&6
8745 else
8746   if test -n "$GCC_FOR_TARGET"; then
8747   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8748 else
8749 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8750 for as_dir in $PATH
8751 do
8752   IFS=$as_save_IFS
8753   test -z "$as_dir" && as_dir=.
8754   for ac_exec_ext in '' $ac_executable_extensions; do
8755   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8756     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8757     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8758     break 2
8759   fi
8760 done
8761 done
8762
8763 fi
8764 fi
8765 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8766 if test -n "$GCC_FOR_TARGET"; then
8767   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8768 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8769 else
8770   echo "$as_me:$LINENO: result: no" >&5
8771 echo "${ECHO_T}no" >&6
8772 fi
8773
8774     fi
8775     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8776       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8777 set dummy ${ncn_progname}; ac_word=$2
8778 echo "$as_me:$LINENO: checking for $ac_word" >&5
8779 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8780 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8781   echo $ECHO_N "(cached) $ECHO_C" >&6
8782 else
8783   if test -n "$GCC_FOR_TARGET"; then
8784   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8785 else
8786 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8787 for as_dir in $PATH
8788 do
8789   IFS=$as_save_IFS
8790   test -z "$as_dir" && as_dir=.
8791   for ac_exec_ext in '' $ac_executable_extensions; do
8792   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8793     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8794     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8795     break 2
8796   fi
8797 done
8798 done
8799
8800 fi
8801 fi
8802 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8803 if test -n "$GCC_FOR_TARGET"; then
8804   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8805 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8806 else
8807   echo "$as_me:$LINENO: result: no" >&5
8808 echo "${ECHO_T}no" >&6
8809 fi
8810
8811     fi
8812     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8813   done
8814 fi
8815
8816 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8817   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8818 else
8819   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8820 fi
8821
8822
8823
8824 if test -n "$GCJ_FOR_TARGET"; then
8825   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8826 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8827   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8828 fi
8829
8830 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8831   for ncn_progname in gcj; do
8832     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8833 set dummy ${ncn_progname}; ac_word=$2
8834 echo "$as_me:$LINENO: checking for $ac_word" >&5
8835 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8836 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8837   echo $ECHO_N "(cached) $ECHO_C" >&6
8838 else
8839   if test -n "$GCJ_FOR_TARGET"; then
8840   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8841 else
8842 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8843 for as_dir in $PATH
8844 do
8845   IFS=$as_save_IFS
8846   test -z "$as_dir" && as_dir=.
8847   for ac_exec_ext in '' $ac_executable_extensions; do
8848   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8849     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8850     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8851     break 2
8852   fi
8853 done
8854 done
8855
8856 fi
8857 fi
8858 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8859 if test -n "$GCJ_FOR_TARGET"; then
8860   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8861 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8862 else
8863   echo "$as_me:$LINENO: result: no" >&5
8864 echo "${ECHO_T}no" >&6
8865 fi
8866
8867   done
8868 fi
8869
8870 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8871   for ncn_progname in gcj; do
8872     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8873 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8874     if test -x $with_build_time_tools/${ncn_progname}; then
8875       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8876       echo "$as_me:$LINENO: result: yes" >&5
8877 echo "${ECHO_T}yes" >&6
8878       break
8879     else
8880       echo "$as_me:$LINENO: result: no" >&5
8881 echo "${ECHO_T}no" >&6
8882     fi
8883   done
8884 fi
8885
8886 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8887   for ncn_progname in gcj; do
8888     if test -n "$ncn_target_tool_prefix"; then
8889       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8890 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8891 echo "$as_me:$LINENO: checking for $ac_word" >&5
8892 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8893 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8894   echo $ECHO_N "(cached) $ECHO_C" >&6
8895 else
8896   if test -n "$GCJ_FOR_TARGET"; then
8897   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8898 else
8899 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8900 for as_dir in $PATH
8901 do
8902   IFS=$as_save_IFS
8903   test -z "$as_dir" && as_dir=.
8904   for ac_exec_ext in '' $ac_executable_extensions; do
8905   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8906     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8907     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8908     break 2
8909   fi
8910 done
8911 done
8912
8913 fi
8914 fi
8915 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8916 if test -n "$GCJ_FOR_TARGET"; then
8917   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8918 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8919 else
8920   echo "$as_me:$LINENO: result: no" >&5
8921 echo "${ECHO_T}no" >&6
8922 fi
8923
8924     fi
8925     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8926       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8927 set dummy ${ncn_progname}; 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_prog_GCJ_FOR_TARGET+set}" = set; then
8931   echo $ECHO_N "(cached) $ECHO_C" >&6
8932 else
8933   if test -n "$GCJ_FOR_TARGET"; then
8934   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8935 else
8936 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8937 for as_dir in $PATH
8938 do
8939   IFS=$as_save_IFS
8940   test -z "$as_dir" && as_dir=.
8941   for ac_exec_ext in '' $ac_executable_extensions; do
8942   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8943     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8944     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8945     break 2
8946   fi
8947 done
8948 done
8949
8950 fi
8951 fi
8952 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8953 if test -n "$GCJ_FOR_TARGET"; then
8954   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8955 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8956 else
8957   echo "$as_me:$LINENO: result: no" >&5
8958 echo "${ECHO_T}no" >&6
8959 fi
8960
8961     fi
8962     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8963   done
8964 fi
8965
8966 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8967   set dummy gcj
8968   if test $build = $target ; then
8969     GCJ_FOR_TARGET="$2"
8970   else
8971     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8972   fi
8973 else
8974   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8975 fi
8976
8977
8978
8979 if test -n "$GFORTRAN_FOR_TARGET"; then
8980   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8981 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8982   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8983 fi
8984
8985 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8986   for ncn_progname in gfortran; do
8987     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8988 set dummy ${ncn_progname}; ac_word=$2
8989 echo "$as_me:$LINENO: checking for $ac_word" >&5
8990 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8991 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8992   echo $ECHO_N "(cached) $ECHO_C" >&6
8993 else
8994   if test -n "$GFORTRAN_FOR_TARGET"; then
8995   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8996 else
8997 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8998 for as_dir in $PATH
8999 do
9000   IFS=$as_save_IFS
9001   test -z "$as_dir" && as_dir=.
9002   for ac_exec_ext in '' $ac_executable_extensions; do
9003   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9004     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9005     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9006     break 2
9007   fi
9008 done
9009 done
9010
9011 fi
9012 fi
9013 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9014 if test -n "$GFORTRAN_FOR_TARGET"; then
9015   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9016 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9017 else
9018   echo "$as_me:$LINENO: result: no" >&5
9019 echo "${ECHO_T}no" >&6
9020 fi
9021
9022   done
9023 fi
9024
9025 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9026   for ncn_progname in gfortran; do
9027     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9028 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9029     if test -x $with_build_time_tools/${ncn_progname}; then
9030       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9031       echo "$as_me:$LINENO: result: yes" >&5
9032 echo "${ECHO_T}yes" >&6
9033       break
9034     else
9035       echo "$as_me:$LINENO: result: no" >&5
9036 echo "${ECHO_T}no" >&6
9037     fi
9038   done
9039 fi
9040
9041 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9042   for ncn_progname in gfortran; do
9043     if test -n "$ncn_target_tool_prefix"; then
9044       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9045 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9046 echo "$as_me:$LINENO: checking for $ac_word" >&5
9047 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9048 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9049   echo $ECHO_N "(cached) $ECHO_C" >&6
9050 else
9051   if test -n "$GFORTRAN_FOR_TARGET"; then
9052   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9053 else
9054 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9055 for as_dir in $PATH
9056 do
9057   IFS=$as_save_IFS
9058   test -z "$as_dir" && as_dir=.
9059   for ac_exec_ext in '' $ac_executable_extensions; do
9060   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9061     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9062     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9063     break 2
9064   fi
9065 done
9066 done
9067
9068 fi
9069 fi
9070 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9071 if test -n "$GFORTRAN_FOR_TARGET"; then
9072   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9073 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9074 else
9075   echo "$as_me:$LINENO: result: no" >&5
9076 echo "${ECHO_T}no" >&6
9077 fi
9078
9079     fi
9080     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9081       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9082 set dummy ${ncn_progname}; ac_word=$2
9083 echo "$as_me:$LINENO: checking for $ac_word" >&5
9084 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9085 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9086   echo $ECHO_N "(cached) $ECHO_C" >&6
9087 else
9088   if test -n "$GFORTRAN_FOR_TARGET"; then
9089   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9090 else
9091 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9092 for as_dir in $PATH
9093 do
9094   IFS=$as_save_IFS
9095   test -z "$as_dir" && as_dir=.
9096   for ac_exec_ext in '' $ac_executable_extensions; do
9097   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9098     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9099     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9100     break 2
9101   fi
9102 done
9103 done
9104
9105 fi
9106 fi
9107 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9108 if test -n "$GFORTRAN_FOR_TARGET"; then
9109   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9110 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9111 else
9112   echo "$as_me:$LINENO: result: no" >&5
9113 echo "${ECHO_T}no" >&6
9114 fi
9115
9116     fi
9117     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9118   done
9119 fi
9120
9121 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9122   set dummy gfortran
9123   if test $build = $target ; then
9124     GFORTRAN_FOR_TARGET="$2"
9125   else
9126     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9127   fi
9128 else
9129   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9130 fi
9131
9132
9133
9134 cat > conftest.c << \EOF
9135 #ifdef __GNUC__
9136   gcc_yay;
9137 #endif
9138 EOF
9139 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9140   have_gcc_for_target=yes
9141 else
9142   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9143   have_gcc_for_target=no
9144 fi
9145 rm conftest.c
9146
9147
9148
9149
9150 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9151   if test -n "$with_build_time_tools"; then
9152     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9153 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9154     if test -x $with_build_time_tools/ar; then
9155       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9156       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9157       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9158 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9159     else
9160       echo "$as_me:$LINENO: result: no" >&5
9161 echo "${ECHO_T}no" >&6
9162     fi
9163   elif test $build != $host && test $have_gcc_for_target = yes; then
9164     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9165     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9166     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9167   fi
9168 fi
9169 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9170   # Extract the first word of "ar", so it can be a program name with args.
9171 set dummy ar; ac_word=$2
9172 echo "$as_me:$LINENO: checking for $ac_word" >&5
9173 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9174 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9175   echo $ECHO_N "(cached) $ECHO_C" >&6
9176 else
9177   case $AR_FOR_TARGET in
9178   [\\/]* | ?:[\\/]*)
9179   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9180   ;;
9181   *)
9182   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9183 for as_dir in $gcc_cv_tool_dirs
9184 do
9185   IFS=$as_save_IFS
9186   test -z "$as_dir" && as_dir=.
9187   for ac_exec_ext in '' $ac_executable_extensions; do
9188   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9189     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9190     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9191     break 2
9192   fi
9193 done
9194 done
9195
9196   ;;
9197 esac
9198 fi
9199 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9200
9201 if test -n "$AR_FOR_TARGET"; then
9202   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9203 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9204 else
9205   echo "$as_me:$LINENO: result: no" >&5
9206 echo "${ECHO_T}no" >&6
9207 fi
9208
9209 fi
9210 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9211
9212
9213 if test -n "$AR_FOR_TARGET"; then
9214   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9215 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9216   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9217 fi
9218
9219 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9220   for ncn_progname in ar; do
9221     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9222 set dummy ${ncn_progname}; ac_word=$2
9223 echo "$as_me:$LINENO: checking for $ac_word" >&5
9224 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9225 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9226   echo $ECHO_N "(cached) $ECHO_C" >&6
9227 else
9228   if test -n "$AR_FOR_TARGET"; then
9229   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9230 else
9231 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9232 for as_dir in $PATH
9233 do
9234   IFS=$as_save_IFS
9235   test -z "$as_dir" && as_dir=.
9236   for ac_exec_ext in '' $ac_executable_extensions; do
9237   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9238     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9239     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9240     break 2
9241   fi
9242 done
9243 done
9244
9245 fi
9246 fi
9247 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9248 if test -n "$AR_FOR_TARGET"; then
9249   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9250 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9251 else
9252   echo "$as_me:$LINENO: result: no" >&5
9253 echo "${ECHO_T}no" >&6
9254 fi
9255
9256   done
9257 fi
9258
9259 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9260   for ncn_progname in ar; do
9261     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9262 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9263     if test -x $with_build_time_tools/${ncn_progname}; then
9264       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9265       echo "$as_me:$LINENO: result: yes" >&5
9266 echo "${ECHO_T}yes" >&6
9267       break
9268     else
9269       echo "$as_me:$LINENO: result: no" >&5
9270 echo "${ECHO_T}no" >&6
9271     fi
9272   done
9273 fi
9274
9275 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9276   for ncn_progname in ar; do
9277     if test -n "$ncn_target_tool_prefix"; then
9278       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9279 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9280 echo "$as_me:$LINENO: checking for $ac_word" >&5
9281 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9282 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9283   echo $ECHO_N "(cached) $ECHO_C" >&6
9284 else
9285   if test -n "$AR_FOR_TARGET"; then
9286   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9287 else
9288 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9289 for as_dir in $PATH
9290 do
9291   IFS=$as_save_IFS
9292   test -z "$as_dir" && as_dir=.
9293   for ac_exec_ext in '' $ac_executable_extensions; do
9294   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9295     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9296     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9297     break 2
9298   fi
9299 done
9300 done
9301
9302 fi
9303 fi
9304 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9305 if test -n "$AR_FOR_TARGET"; then
9306   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9307 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9308 else
9309   echo "$as_me:$LINENO: result: no" >&5
9310 echo "${ECHO_T}no" >&6
9311 fi
9312
9313     fi
9314     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9315       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9316 set dummy ${ncn_progname}; ac_word=$2
9317 echo "$as_me:$LINENO: checking for $ac_word" >&5
9318 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9319 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9320   echo $ECHO_N "(cached) $ECHO_C" >&6
9321 else
9322   if test -n "$AR_FOR_TARGET"; then
9323   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9324 else
9325 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9326 for as_dir in $PATH
9327 do
9328   IFS=$as_save_IFS
9329   test -z "$as_dir" && as_dir=.
9330   for ac_exec_ext in '' $ac_executable_extensions; do
9331   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9332     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9333     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9334     break 2
9335   fi
9336 done
9337 done
9338
9339 fi
9340 fi
9341 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9342 if test -n "$AR_FOR_TARGET"; then
9343   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9344 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9345 else
9346   echo "$as_me:$LINENO: result: no" >&5
9347 echo "${ECHO_T}no" >&6
9348 fi
9349
9350     fi
9351     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9352   done
9353 fi
9354
9355 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9356   set dummy ar
9357   if test $build = $target ; then
9358     AR_FOR_TARGET="$2"
9359   else
9360     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9361   fi
9362 else
9363   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9364 fi
9365
9366 else
9367   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9368 fi
9369
9370
9371
9372
9373 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9374   if test -n "$with_build_time_tools"; then
9375     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9376 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9377     if test -x $with_build_time_tools/as; then
9378       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9379       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9380       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9381 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9382     else
9383       echo "$as_me:$LINENO: result: no" >&5
9384 echo "${ECHO_T}no" >&6
9385     fi
9386   elif test $build != $host && test $have_gcc_for_target = yes; then
9387     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9388     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9389     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9390   fi
9391 fi
9392 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9393   # Extract the first word of "as", so it can be a program name with args.
9394 set dummy as; ac_word=$2
9395 echo "$as_me:$LINENO: checking for $ac_word" >&5
9396 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9397 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9398   echo $ECHO_N "(cached) $ECHO_C" >&6
9399 else
9400   case $AS_FOR_TARGET in
9401   [\\/]* | ?:[\\/]*)
9402   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9403   ;;
9404   *)
9405   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9406 for as_dir in $gcc_cv_tool_dirs
9407 do
9408   IFS=$as_save_IFS
9409   test -z "$as_dir" && as_dir=.
9410   for ac_exec_ext in '' $ac_executable_extensions; do
9411   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9412     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9413     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9414     break 2
9415   fi
9416 done
9417 done
9418
9419   ;;
9420 esac
9421 fi
9422 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9423
9424 if test -n "$AS_FOR_TARGET"; then
9425   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9426 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9427 else
9428   echo "$as_me:$LINENO: result: no" >&5
9429 echo "${ECHO_T}no" >&6
9430 fi
9431
9432 fi
9433 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9434
9435
9436 if test -n "$AS_FOR_TARGET"; then
9437   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9438 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9439   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9440 fi
9441
9442 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9443   for ncn_progname in as; do
9444     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9445 set dummy ${ncn_progname}; ac_word=$2
9446 echo "$as_me:$LINENO: checking for $ac_word" >&5
9447 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9448 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9449   echo $ECHO_N "(cached) $ECHO_C" >&6
9450 else
9451   if test -n "$AS_FOR_TARGET"; then
9452   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9453 else
9454 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9455 for as_dir in $PATH
9456 do
9457   IFS=$as_save_IFS
9458   test -z "$as_dir" && as_dir=.
9459   for ac_exec_ext in '' $ac_executable_extensions; do
9460   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9461     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9462     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9463     break 2
9464   fi
9465 done
9466 done
9467
9468 fi
9469 fi
9470 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9471 if test -n "$AS_FOR_TARGET"; then
9472   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9473 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9474 else
9475   echo "$as_me:$LINENO: result: no" >&5
9476 echo "${ECHO_T}no" >&6
9477 fi
9478
9479   done
9480 fi
9481
9482 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9483   for ncn_progname in as; do
9484     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9485 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9486     if test -x $with_build_time_tools/${ncn_progname}; then
9487       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9488       echo "$as_me:$LINENO: result: yes" >&5
9489 echo "${ECHO_T}yes" >&6
9490       break
9491     else
9492       echo "$as_me:$LINENO: result: no" >&5
9493 echo "${ECHO_T}no" >&6
9494     fi
9495   done
9496 fi
9497
9498 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9499   for ncn_progname in as; do
9500     if test -n "$ncn_target_tool_prefix"; then
9501       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9502 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9503 echo "$as_me:$LINENO: checking for $ac_word" >&5
9504 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9505 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9506   echo $ECHO_N "(cached) $ECHO_C" >&6
9507 else
9508   if test -n "$AS_FOR_TARGET"; then
9509   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9510 else
9511 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9512 for as_dir in $PATH
9513 do
9514   IFS=$as_save_IFS
9515   test -z "$as_dir" && as_dir=.
9516   for ac_exec_ext in '' $ac_executable_extensions; do
9517   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9518     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9519     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9520     break 2
9521   fi
9522 done
9523 done
9524
9525 fi
9526 fi
9527 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9528 if test -n "$AS_FOR_TARGET"; then
9529   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9530 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9531 else
9532   echo "$as_me:$LINENO: result: no" >&5
9533 echo "${ECHO_T}no" >&6
9534 fi
9535
9536     fi
9537     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9538       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9539 set dummy ${ncn_progname}; ac_word=$2
9540 echo "$as_me:$LINENO: checking for $ac_word" >&5
9541 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9542 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9543   echo $ECHO_N "(cached) $ECHO_C" >&6
9544 else
9545   if test -n "$AS_FOR_TARGET"; then
9546   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9547 else
9548 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9549 for as_dir in $PATH
9550 do
9551   IFS=$as_save_IFS
9552   test -z "$as_dir" && as_dir=.
9553   for ac_exec_ext in '' $ac_executable_extensions; do
9554   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9555     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9556     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9557     break 2
9558   fi
9559 done
9560 done
9561
9562 fi
9563 fi
9564 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9565 if test -n "$AS_FOR_TARGET"; then
9566   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9567 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9568 else
9569   echo "$as_me:$LINENO: result: no" >&5
9570 echo "${ECHO_T}no" >&6
9571 fi
9572
9573     fi
9574     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9575   done
9576 fi
9577
9578 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9579   set dummy as
9580   if test $build = $target ; then
9581     AS_FOR_TARGET="$2"
9582   else
9583     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9584   fi
9585 else
9586   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9587 fi
9588
9589 else
9590   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9591 fi
9592
9593
9594
9595
9596 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9597   if test -n "$with_build_time_tools"; then
9598     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9599 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9600     if test -x $with_build_time_tools/dlltool; then
9601       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9602       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9603       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9604 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9605     else
9606       echo "$as_me:$LINENO: result: no" >&5
9607 echo "${ECHO_T}no" >&6
9608     fi
9609   elif test $build != $host && test $have_gcc_for_target = yes; then
9610     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9611     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9612     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9613   fi
9614 fi
9615 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9616   # Extract the first word of "dlltool", so it can be a program name with args.
9617 set dummy dlltool; ac_word=$2
9618 echo "$as_me:$LINENO: checking for $ac_word" >&5
9619 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9620 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9621   echo $ECHO_N "(cached) $ECHO_C" >&6
9622 else
9623   case $DLLTOOL_FOR_TARGET in
9624   [\\/]* | ?:[\\/]*)
9625   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9626   ;;
9627   *)
9628   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9629 for as_dir in $gcc_cv_tool_dirs
9630 do
9631   IFS=$as_save_IFS
9632   test -z "$as_dir" && as_dir=.
9633   for ac_exec_ext in '' $ac_executable_extensions; do
9634   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9635     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9636     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9637     break 2
9638   fi
9639 done
9640 done
9641
9642   ;;
9643 esac
9644 fi
9645 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9646
9647 if test -n "$DLLTOOL_FOR_TARGET"; then
9648   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9649 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9650 else
9651   echo "$as_me:$LINENO: result: no" >&5
9652 echo "${ECHO_T}no" >&6
9653 fi
9654
9655 fi
9656 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9657
9658
9659 if test -n "$DLLTOOL_FOR_TARGET"; then
9660   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9661 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9662   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9663 fi
9664
9665 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9666   for ncn_progname in dlltool; do
9667     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9668 set dummy ${ncn_progname}; ac_word=$2
9669 echo "$as_me:$LINENO: checking for $ac_word" >&5
9670 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9671 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9672   echo $ECHO_N "(cached) $ECHO_C" >&6
9673 else
9674   if test -n "$DLLTOOL_FOR_TARGET"; then
9675   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9676 else
9677 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9678 for as_dir in $PATH
9679 do
9680   IFS=$as_save_IFS
9681   test -z "$as_dir" && as_dir=.
9682   for ac_exec_ext in '' $ac_executable_extensions; do
9683   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9684     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9685     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9686     break 2
9687   fi
9688 done
9689 done
9690
9691 fi
9692 fi
9693 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9694 if test -n "$DLLTOOL_FOR_TARGET"; then
9695   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9696 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9697 else
9698   echo "$as_me:$LINENO: result: no" >&5
9699 echo "${ECHO_T}no" >&6
9700 fi
9701
9702   done
9703 fi
9704
9705 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9706   for ncn_progname in dlltool; do
9707     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9708 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9709     if test -x $with_build_time_tools/${ncn_progname}; then
9710       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9711       echo "$as_me:$LINENO: result: yes" >&5
9712 echo "${ECHO_T}yes" >&6
9713       break
9714     else
9715       echo "$as_me:$LINENO: result: no" >&5
9716 echo "${ECHO_T}no" >&6
9717     fi
9718   done
9719 fi
9720
9721 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9722   for ncn_progname in dlltool; do
9723     if test -n "$ncn_target_tool_prefix"; then
9724       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9725 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9726 echo "$as_me:$LINENO: checking for $ac_word" >&5
9727 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9728 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9729   echo $ECHO_N "(cached) $ECHO_C" >&6
9730 else
9731   if test -n "$DLLTOOL_FOR_TARGET"; then
9732   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9733 else
9734 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9735 for as_dir in $PATH
9736 do
9737   IFS=$as_save_IFS
9738   test -z "$as_dir" && as_dir=.
9739   for ac_exec_ext in '' $ac_executable_extensions; do
9740   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9741     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9742     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9743     break 2
9744   fi
9745 done
9746 done
9747
9748 fi
9749 fi
9750 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9751 if test -n "$DLLTOOL_FOR_TARGET"; then
9752   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9753 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9754 else
9755   echo "$as_me:$LINENO: result: no" >&5
9756 echo "${ECHO_T}no" >&6
9757 fi
9758
9759     fi
9760     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9761       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9762 set dummy ${ncn_progname}; ac_word=$2
9763 echo "$as_me:$LINENO: checking for $ac_word" >&5
9764 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9765 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9766   echo $ECHO_N "(cached) $ECHO_C" >&6
9767 else
9768   if test -n "$DLLTOOL_FOR_TARGET"; then
9769   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9770 else
9771 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9772 for as_dir in $PATH
9773 do
9774   IFS=$as_save_IFS
9775   test -z "$as_dir" && as_dir=.
9776   for ac_exec_ext in '' $ac_executable_extensions; do
9777   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9778     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9779     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9780     break 2
9781   fi
9782 done
9783 done
9784
9785 fi
9786 fi
9787 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9788 if test -n "$DLLTOOL_FOR_TARGET"; then
9789   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9790 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9791 else
9792   echo "$as_me:$LINENO: result: no" >&5
9793 echo "${ECHO_T}no" >&6
9794 fi
9795
9796     fi
9797     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9798   done
9799 fi
9800
9801 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9802   set dummy dlltool
9803   if test $build = $target ; then
9804     DLLTOOL_FOR_TARGET="$2"
9805   else
9806     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9807   fi
9808 else
9809   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9810 fi
9811
9812 else
9813   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9814 fi
9815
9816
9817
9818
9819 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9820   if test -n "$with_build_time_tools"; then
9821     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9822 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9823     if test -x $with_build_time_tools/ld; then
9824       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9825       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9826       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9827 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9828     else
9829       echo "$as_me:$LINENO: result: no" >&5
9830 echo "${ECHO_T}no" >&6
9831     fi
9832   elif test $build != $host && test $have_gcc_for_target = yes; then
9833     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9834     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9835     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9836   fi
9837 fi
9838 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9839   # Extract the first word of "ld", so it can be a program name with args.
9840 set dummy ld; ac_word=$2
9841 echo "$as_me:$LINENO: checking for $ac_word" >&5
9842 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9843 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9844   echo $ECHO_N "(cached) $ECHO_C" >&6
9845 else
9846   case $LD_FOR_TARGET in
9847   [\\/]* | ?:[\\/]*)
9848   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9849   ;;
9850   *)
9851   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9852 for as_dir in $gcc_cv_tool_dirs
9853 do
9854   IFS=$as_save_IFS
9855   test -z "$as_dir" && as_dir=.
9856   for ac_exec_ext in '' $ac_executable_extensions; do
9857   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9858     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9859     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9860     break 2
9861   fi
9862 done
9863 done
9864
9865   ;;
9866 esac
9867 fi
9868 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9869
9870 if test -n "$LD_FOR_TARGET"; then
9871   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9872 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9873 else
9874   echo "$as_me:$LINENO: result: no" >&5
9875 echo "${ECHO_T}no" >&6
9876 fi
9877
9878 fi
9879 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9880
9881
9882 if test -n "$LD_FOR_TARGET"; then
9883   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9884 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9885   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9886 fi
9887
9888 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9889   for ncn_progname in ld; do
9890     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9891 set dummy ${ncn_progname}; ac_word=$2
9892 echo "$as_me:$LINENO: checking for $ac_word" >&5
9893 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9894 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9895   echo $ECHO_N "(cached) $ECHO_C" >&6
9896 else
9897   if test -n "$LD_FOR_TARGET"; then
9898   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9899 else
9900 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9901 for as_dir in $PATH
9902 do
9903   IFS=$as_save_IFS
9904   test -z "$as_dir" && as_dir=.
9905   for ac_exec_ext in '' $ac_executable_extensions; do
9906   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9907     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9908     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9909     break 2
9910   fi
9911 done
9912 done
9913
9914 fi
9915 fi
9916 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9917 if test -n "$LD_FOR_TARGET"; then
9918   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9919 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9920 else
9921   echo "$as_me:$LINENO: result: no" >&5
9922 echo "${ECHO_T}no" >&6
9923 fi
9924
9925   done
9926 fi
9927
9928 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9929   for ncn_progname in ld; do
9930     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9931 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9932     if test -x $with_build_time_tools/${ncn_progname}; then
9933       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9934       echo "$as_me:$LINENO: result: yes" >&5
9935 echo "${ECHO_T}yes" >&6
9936       break
9937     else
9938       echo "$as_me:$LINENO: result: no" >&5
9939 echo "${ECHO_T}no" >&6
9940     fi
9941   done
9942 fi
9943
9944 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9945   for ncn_progname in ld; do
9946     if test -n "$ncn_target_tool_prefix"; then
9947       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9948 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9949 echo "$as_me:$LINENO: checking for $ac_word" >&5
9950 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9951 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9952   echo $ECHO_N "(cached) $ECHO_C" >&6
9953 else
9954   if test -n "$LD_FOR_TARGET"; then
9955   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9956 else
9957 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9958 for as_dir in $PATH
9959 do
9960   IFS=$as_save_IFS
9961   test -z "$as_dir" && as_dir=.
9962   for ac_exec_ext in '' $ac_executable_extensions; do
9963   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9964     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9965     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9966     break 2
9967   fi
9968 done
9969 done
9970
9971 fi
9972 fi
9973 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9974 if test -n "$LD_FOR_TARGET"; then
9975   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9976 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9977 else
9978   echo "$as_me:$LINENO: result: no" >&5
9979 echo "${ECHO_T}no" >&6
9980 fi
9981
9982     fi
9983     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9984       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9985 set dummy ${ncn_progname}; ac_word=$2
9986 echo "$as_me:$LINENO: checking for $ac_word" >&5
9987 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9988 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9989   echo $ECHO_N "(cached) $ECHO_C" >&6
9990 else
9991   if test -n "$LD_FOR_TARGET"; then
9992   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9993 else
9994 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9995 for as_dir in $PATH
9996 do
9997   IFS=$as_save_IFS
9998   test -z "$as_dir" && as_dir=.
9999   for ac_exec_ext in '' $ac_executable_extensions; do
10000   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10001     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10002     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10003     break 2
10004   fi
10005 done
10006 done
10007
10008 fi
10009 fi
10010 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10011 if test -n "$LD_FOR_TARGET"; then
10012   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10013 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10014 else
10015   echo "$as_me:$LINENO: result: no" >&5
10016 echo "${ECHO_T}no" >&6
10017 fi
10018
10019     fi
10020     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10021   done
10022 fi
10023
10024 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10025   set dummy ld
10026   if test $build = $target ; then
10027     LD_FOR_TARGET="$2"
10028   else
10029     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10030   fi
10031 else
10032   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10033 fi
10034
10035 else
10036   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10037 fi
10038
10039
10040
10041
10042 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10043   if test -n "$with_build_time_tools"; then
10044     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10045 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10046     if test -x $with_build_time_tools/lipo; then
10047       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10048       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10049       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10050 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10051     else
10052       echo "$as_me:$LINENO: result: no" >&5
10053 echo "${ECHO_T}no" >&6
10054     fi
10055   elif test $build != $host && test $have_gcc_for_target = yes; then
10056     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10057     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10058     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10059   fi
10060 fi
10061 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10062   # Extract the first word of "lipo", so it can be a program name with args.
10063 set dummy lipo; ac_word=$2
10064 echo "$as_me:$LINENO: checking for $ac_word" >&5
10065 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10066 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10067   echo $ECHO_N "(cached) $ECHO_C" >&6
10068 else
10069   case $LIPO_FOR_TARGET in
10070   [\\/]* | ?:[\\/]*)
10071   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10072   ;;
10073   *)
10074   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10075 for as_dir in $gcc_cv_tool_dirs
10076 do
10077   IFS=$as_save_IFS
10078   test -z "$as_dir" && as_dir=.
10079   for ac_exec_ext in '' $ac_executable_extensions; do
10080   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10081     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10082     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10083     break 2
10084   fi
10085 done
10086 done
10087
10088   ;;
10089 esac
10090 fi
10091 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10092
10093 if test -n "$LIPO_FOR_TARGET"; then
10094   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10095 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10096 else
10097   echo "$as_me:$LINENO: result: no" >&5
10098 echo "${ECHO_T}no" >&6
10099 fi
10100
10101 fi
10102 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10103
10104
10105 if test -n "$LIPO_FOR_TARGET"; then
10106   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10107 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10108   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10109 fi
10110
10111 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10112   for ncn_progname in lipo; do
10113     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10114 set dummy ${ncn_progname}; ac_word=$2
10115 echo "$as_me:$LINENO: checking for $ac_word" >&5
10116 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10117 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10118   echo $ECHO_N "(cached) $ECHO_C" >&6
10119 else
10120   if test -n "$LIPO_FOR_TARGET"; then
10121   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10122 else
10123 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10124 for as_dir in $PATH
10125 do
10126   IFS=$as_save_IFS
10127   test -z "$as_dir" && as_dir=.
10128   for ac_exec_ext in '' $ac_executable_extensions; do
10129   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10130     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10131     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10132     break 2
10133   fi
10134 done
10135 done
10136
10137 fi
10138 fi
10139 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10140 if test -n "$LIPO_FOR_TARGET"; then
10141   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10142 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10143 else
10144   echo "$as_me:$LINENO: result: no" >&5
10145 echo "${ECHO_T}no" >&6
10146 fi
10147
10148   done
10149 fi
10150
10151 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10152   for ncn_progname in lipo; do
10153     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10154 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10155     if test -x $with_build_time_tools/${ncn_progname}; then
10156       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10157       echo "$as_me:$LINENO: result: yes" >&5
10158 echo "${ECHO_T}yes" >&6
10159       break
10160     else
10161       echo "$as_me:$LINENO: result: no" >&5
10162 echo "${ECHO_T}no" >&6
10163     fi
10164   done
10165 fi
10166
10167 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10168   for ncn_progname in lipo; do
10169     if test -n "$ncn_target_tool_prefix"; then
10170       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10171 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10172 echo "$as_me:$LINENO: checking for $ac_word" >&5
10173 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10174 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10175   echo $ECHO_N "(cached) $ECHO_C" >&6
10176 else
10177   if test -n "$LIPO_FOR_TARGET"; then
10178   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10179 else
10180 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10181 for as_dir in $PATH
10182 do
10183   IFS=$as_save_IFS
10184   test -z "$as_dir" && as_dir=.
10185   for ac_exec_ext in '' $ac_executable_extensions; do
10186   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10187     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10188     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10189     break 2
10190   fi
10191 done
10192 done
10193
10194 fi
10195 fi
10196 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10197 if test -n "$LIPO_FOR_TARGET"; then
10198   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10199 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10200 else
10201   echo "$as_me:$LINENO: result: no" >&5
10202 echo "${ECHO_T}no" >&6
10203 fi
10204
10205     fi
10206     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10207       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10208 set dummy ${ncn_progname}; ac_word=$2
10209 echo "$as_me:$LINENO: checking for $ac_word" >&5
10210 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10211 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10212   echo $ECHO_N "(cached) $ECHO_C" >&6
10213 else
10214   if test -n "$LIPO_FOR_TARGET"; then
10215   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10216 else
10217 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10218 for as_dir in $PATH
10219 do
10220   IFS=$as_save_IFS
10221   test -z "$as_dir" && as_dir=.
10222   for ac_exec_ext in '' $ac_executable_extensions; do
10223   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10224     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10225     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10226     break 2
10227   fi
10228 done
10229 done
10230
10231 fi
10232 fi
10233 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10234 if test -n "$LIPO_FOR_TARGET"; then
10235   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10236 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10237 else
10238   echo "$as_me:$LINENO: result: no" >&5
10239 echo "${ECHO_T}no" >&6
10240 fi
10241
10242     fi
10243     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10244   done
10245 fi
10246
10247 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10248   set dummy lipo
10249   if test $build = $target ; then
10250     LIPO_FOR_TARGET="$2"
10251   else
10252     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10253   fi
10254 else
10255   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10256 fi
10257
10258 else
10259   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10260 fi
10261
10262
10263
10264
10265 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10266   if test -n "$with_build_time_tools"; then
10267     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10268 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10269     if test -x $with_build_time_tools/nm; then
10270       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10271       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10272       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10273 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10274     else
10275       echo "$as_me:$LINENO: result: no" >&5
10276 echo "${ECHO_T}no" >&6
10277     fi
10278   elif test $build != $host && test $have_gcc_for_target = yes; then
10279     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10280     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10281     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10282   fi
10283 fi
10284 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10285   # Extract the first word of "nm", so it can be a program name with args.
10286 set dummy nm; ac_word=$2
10287 echo "$as_me:$LINENO: checking for $ac_word" >&5
10288 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10289 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10290   echo $ECHO_N "(cached) $ECHO_C" >&6
10291 else
10292   case $NM_FOR_TARGET in
10293   [\\/]* | ?:[\\/]*)
10294   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10295   ;;
10296   *)
10297   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10298 for as_dir in $gcc_cv_tool_dirs
10299 do
10300   IFS=$as_save_IFS
10301   test -z "$as_dir" && as_dir=.
10302   for ac_exec_ext in '' $ac_executable_extensions; do
10303   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10304     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10305     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10306     break 2
10307   fi
10308 done
10309 done
10310
10311   ;;
10312 esac
10313 fi
10314 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10315
10316 if test -n "$NM_FOR_TARGET"; then
10317   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10318 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10319 else
10320   echo "$as_me:$LINENO: result: no" >&5
10321 echo "${ECHO_T}no" >&6
10322 fi
10323
10324 fi
10325 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10326
10327
10328 if test -n "$NM_FOR_TARGET"; then
10329   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10330 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10331   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10332 fi
10333
10334 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10335   for ncn_progname in nm; do
10336     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10337 set dummy ${ncn_progname}; ac_word=$2
10338 echo "$as_me:$LINENO: checking for $ac_word" >&5
10339 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10340 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10341   echo $ECHO_N "(cached) $ECHO_C" >&6
10342 else
10343   if test -n "$NM_FOR_TARGET"; then
10344   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10345 else
10346 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10347 for as_dir in $PATH
10348 do
10349   IFS=$as_save_IFS
10350   test -z "$as_dir" && as_dir=.
10351   for ac_exec_ext in '' $ac_executable_extensions; do
10352   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10353     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10354     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10355     break 2
10356   fi
10357 done
10358 done
10359
10360 fi
10361 fi
10362 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10363 if test -n "$NM_FOR_TARGET"; then
10364   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10365 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10366 else
10367   echo "$as_me:$LINENO: result: no" >&5
10368 echo "${ECHO_T}no" >&6
10369 fi
10370
10371   done
10372 fi
10373
10374 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10375   for ncn_progname in nm; do
10376     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10377 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10378     if test -x $with_build_time_tools/${ncn_progname}; then
10379       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10380       echo "$as_me:$LINENO: result: yes" >&5
10381 echo "${ECHO_T}yes" >&6
10382       break
10383     else
10384       echo "$as_me:$LINENO: result: no" >&5
10385 echo "${ECHO_T}no" >&6
10386     fi
10387   done
10388 fi
10389
10390 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10391   for ncn_progname in nm; do
10392     if test -n "$ncn_target_tool_prefix"; then
10393       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10394 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10395 echo "$as_me:$LINENO: checking for $ac_word" >&5
10396 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10397 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10398   echo $ECHO_N "(cached) $ECHO_C" >&6
10399 else
10400   if test -n "$NM_FOR_TARGET"; then
10401   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10402 else
10403 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10404 for as_dir in $PATH
10405 do
10406   IFS=$as_save_IFS
10407   test -z "$as_dir" && as_dir=.
10408   for ac_exec_ext in '' $ac_executable_extensions; do
10409   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10410     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10411     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10412     break 2
10413   fi
10414 done
10415 done
10416
10417 fi
10418 fi
10419 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10420 if test -n "$NM_FOR_TARGET"; then
10421   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10422 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10423 else
10424   echo "$as_me:$LINENO: result: no" >&5
10425 echo "${ECHO_T}no" >&6
10426 fi
10427
10428     fi
10429     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10430       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10431 set dummy ${ncn_progname}; ac_word=$2
10432 echo "$as_me:$LINENO: checking for $ac_word" >&5
10433 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10434 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10435   echo $ECHO_N "(cached) $ECHO_C" >&6
10436 else
10437   if test -n "$NM_FOR_TARGET"; then
10438   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10439 else
10440 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10441 for as_dir in $PATH
10442 do
10443   IFS=$as_save_IFS
10444   test -z "$as_dir" && as_dir=.
10445   for ac_exec_ext in '' $ac_executable_extensions; do
10446   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10447     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10448     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10449     break 2
10450   fi
10451 done
10452 done
10453
10454 fi
10455 fi
10456 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10457 if test -n "$NM_FOR_TARGET"; then
10458   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10459 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10460 else
10461   echo "$as_me:$LINENO: result: no" >&5
10462 echo "${ECHO_T}no" >&6
10463 fi
10464
10465     fi
10466     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10467   done
10468 fi
10469
10470 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10471   set dummy nm
10472   if test $build = $target ; then
10473     NM_FOR_TARGET="$2"
10474   else
10475     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10476   fi
10477 else
10478   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10479 fi
10480
10481 else
10482   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10483 fi
10484
10485
10486
10487
10488 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10489   if test -n "$with_build_time_tools"; then
10490     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10491 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10492     if test -x $with_build_time_tools/objdump; then
10493       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10494       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10495       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10496 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10497     else
10498       echo "$as_me:$LINENO: result: no" >&5
10499 echo "${ECHO_T}no" >&6
10500     fi
10501   elif test $build != $host && test $have_gcc_for_target = yes; then
10502     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10503     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10504     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10505   fi
10506 fi
10507 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10508   # Extract the first word of "objdump", so it can be a program name with args.
10509 set dummy objdump; ac_word=$2
10510 echo "$as_me:$LINENO: checking for $ac_word" >&5
10511 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10512 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10513   echo $ECHO_N "(cached) $ECHO_C" >&6
10514 else
10515   case $OBJDUMP_FOR_TARGET in
10516   [\\/]* | ?:[\\/]*)
10517   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10518   ;;
10519   *)
10520   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10521 for as_dir in $gcc_cv_tool_dirs
10522 do
10523   IFS=$as_save_IFS
10524   test -z "$as_dir" && as_dir=.
10525   for ac_exec_ext in '' $ac_executable_extensions; do
10526   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10527     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10528     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10529     break 2
10530   fi
10531 done
10532 done
10533
10534   ;;
10535 esac
10536 fi
10537 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10538
10539 if test -n "$OBJDUMP_FOR_TARGET"; then
10540   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10541 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10542 else
10543   echo "$as_me:$LINENO: result: no" >&5
10544 echo "${ECHO_T}no" >&6
10545 fi
10546
10547 fi
10548 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10549
10550
10551 if test -n "$OBJDUMP_FOR_TARGET"; then
10552   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10553 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10554   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10555 fi
10556
10557 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10558   for ncn_progname in objdump; do
10559     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10560 set dummy ${ncn_progname}; ac_word=$2
10561 echo "$as_me:$LINENO: checking for $ac_word" >&5
10562 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10563 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10564   echo $ECHO_N "(cached) $ECHO_C" >&6
10565 else
10566   if test -n "$OBJDUMP_FOR_TARGET"; then
10567   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10568 else
10569 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10570 for as_dir in $PATH
10571 do
10572   IFS=$as_save_IFS
10573   test -z "$as_dir" && as_dir=.
10574   for ac_exec_ext in '' $ac_executable_extensions; do
10575   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10576     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10577     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10578     break 2
10579   fi
10580 done
10581 done
10582
10583 fi
10584 fi
10585 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10586 if test -n "$OBJDUMP_FOR_TARGET"; then
10587   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10588 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10589 else
10590   echo "$as_me:$LINENO: result: no" >&5
10591 echo "${ECHO_T}no" >&6
10592 fi
10593
10594   done
10595 fi
10596
10597 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10598   for ncn_progname in objdump; do
10599     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10600 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10601     if test -x $with_build_time_tools/${ncn_progname}; then
10602       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10603       echo "$as_me:$LINENO: result: yes" >&5
10604 echo "${ECHO_T}yes" >&6
10605       break
10606     else
10607       echo "$as_me:$LINENO: result: no" >&5
10608 echo "${ECHO_T}no" >&6
10609     fi
10610   done
10611 fi
10612
10613 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10614   for ncn_progname in objdump; do
10615     if test -n "$ncn_target_tool_prefix"; then
10616       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10617 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10618 echo "$as_me:$LINENO: checking for $ac_word" >&5
10619 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10620 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10621   echo $ECHO_N "(cached) $ECHO_C" >&6
10622 else
10623   if test -n "$OBJDUMP_FOR_TARGET"; then
10624   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10625 else
10626 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10627 for as_dir in $PATH
10628 do
10629   IFS=$as_save_IFS
10630   test -z "$as_dir" && as_dir=.
10631   for ac_exec_ext in '' $ac_executable_extensions; do
10632   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10633     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10634     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10635     break 2
10636   fi
10637 done
10638 done
10639
10640 fi
10641 fi
10642 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10643 if test -n "$OBJDUMP_FOR_TARGET"; then
10644   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10645 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10646 else
10647   echo "$as_me:$LINENO: result: no" >&5
10648 echo "${ECHO_T}no" >&6
10649 fi
10650
10651     fi
10652     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10653       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10654 set dummy ${ncn_progname}; ac_word=$2
10655 echo "$as_me:$LINENO: checking for $ac_word" >&5
10656 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10657 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10658   echo $ECHO_N "(cached) $ECHO_C" >&6
10659 else
10660   if test -n "$OBJDUMP_FOR_TARGET"; then
10661   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10662 else
10663 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10664 for as_dir in $PATH
10665 do
10666   IFS=$as_save_IFS
10667   test -z "$as_dir" && as_dir=.
10668   for ac_exec_ext in '' $ac_executable_extensions; do
10669   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10670     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10671     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10672     break 2
10673   fi
10674 done
10675 done
10676
10677 fi
10678 fi
10679 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10680 if test -n "$OBJDUMP_FOR_TARGET"; then
10681   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10682 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10683 else
10684   echo "$as_me:$LINENO: result: no" >&5
10685 echo "${ECHO_T}no" >&6
10686 fi
10687
10688     fi
10689     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10690   done
10691 fi
10692
10693 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10694   set dummy objdump
10695   if test $build = $target ; then
10696     OBJDUMP_FOR_TARGET="$2"
10697   else
10698     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10699   fi
10700 else
10701   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10702 fi
10703
10704 else
10705   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10706 fi
10707
10708
10709
10710
10711 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10712   if test -n "$with_build_time_tools"; then
10713     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10714 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10715     if test -x $with_build_time_tools/ranlib; then
10716       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10717       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10718       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10719 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10720     else
10721       echo "$as_me:$LINENO: result: no" >&5
10722 echo "${ECHO_T}no" >&6
10723     fi
10724   elif test $build != $host && test $have_gcc_for_target = yes; then
10725     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10726     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10727     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10728   fi
10729 fi
10730 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10731   # Extract the first word of "ranlib", so it can be a program name with args.
10732 set dummy ranlib; ac_word=$2
10733 echo "$as_me:$LINENO: checking for $ac_word" >&5
10734 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10735 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10736   echo $ECHO_N "(cached) $ECHO_C" >&6
10737 else
10738   case $RANLIB_FOR_TARGET in
10739   [\\/]* | ?:[\\/]*)
10740   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10741   ;;
10742   *)
10743   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10744 for as_dir in $gcc_cv_tool_dirs
10745 do
10746   IFS=$as_save_IFS
10747   test -z "$as_dir" && as_dir=.
10748   for ac_exec_ext in '' $ac_executable_extensions; do
10749   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10750     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10751     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10752     break 2
10753   fi
10754 done
10755 done
10756
10757   ;;
10758 esac
10759 fi
10760 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10761
10762 if test -n "$RANLIB_FOR_TARGET"; then
10763   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10764 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10765 else
10766   echo "$as_me:$LINENO: result: no" >&5
10767 echo "${ECHO_T}no" >&6
10768 fi
10769
10770 fi
10771 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10772
10773
10774 if test -n "$RANLIB_FOR_TARGET"; then
10775   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10776 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10777   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10778 fi
10779
10780 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10781   for ncn_progname in ranlib; do
10782     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10783 set dummy ${ncn_progname}; ac_word=$2
10784 echo "$as_me:$LINENO: checking for $ac_word" >&5
10785 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10786 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10787   echo $ECHO_N "(cached) $ECHO_C" >&6
10788 else
10789   if test -n "$RANLIB_FOR_TARGET"; then
10790   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10791 else
10792 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10793 for as_dir in $PATH
10794 do
10795   IFS=$as_save_IFS
10796   test -z "$as_dir" && as_dir=.
10797   for ac_exec_ext in '' $ac_executable_extensions; do
10798   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10799     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10800     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10801     break 2
10802   fi
10803 done
10804 done
10805
10806 fi
10807 fi
10808 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10809 if test -n "$RANLIB_FOR_TARGET"; then
10810   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10811 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10812 else
10813   echo "$as_me:$LINENO: result: no" >&5
10814 echo "${ECHO_T}no" >&6
10815 fi
10816
10817   done
10818 fi
10819
10820 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10821   for ncn_progname in ranlib; do
10822     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10823 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10824     if test -x $with_build_time_tools/${ncn_progname}; then
10825       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10826       echo "$as_me:$LINENO: result: yes" >&5
10827 echo "${ECHO_T}yes" >&6
10828       break
10829     else
10830       echo "$as_me:$LINENO: result: no" >&5
10831 echo "${ECHO_T}no" >&6
10832     fi
10833   done
10834 fi
10835
10836 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10837   for ncn_progname in ranlib; do
10838     if test -n "$ncn_target_tool_prefix"; then
10839       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10840 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10841 echo "$as_me:$LINENO: checking for $ac_word" >&5
10842 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10843 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10844   echo $ECHO_N "(cached) $ECHO_C" >&6
10845 else
10846   if test -n "$RANLIB_FOR_TARGET"; then
10847   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10848 else
10849 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10850 for as_dir in $PATH
10851 do
10852   IFS=$as_save_IFS
10853   test -z "$as_dir" && as_dir=.
10854   for ac_exec_ext in '' $ac_executable_extensions; do
10855   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10856     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10857     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10858     break 2
10859   fi
10860 done
10861 done
10862
10863 fi
10864 fi
10865 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10866 if test -n "$RANLIB_FOR_TARGET"; then
10867   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10868 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10869 else
10870   echo "$as_me:$LINENO: result: no" >&5
10871 echo "${ECHO_T}no" >&6
10872 fi
10873
10874     fi
10875     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10876       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10877 set dummy ${ncn_progname}; ac_word=$2
10878 echo "$as_me:$LINENO: checking for $ac_word" >&5
10879 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10880 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10881   echo $ECHO_N "(cached) $ECHO_C" >&6
10882 else
10883   if test -n "$RANLIB_FOR_TARGET"; then
10884   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10885 else
10886 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10887 for as_dir in $PATH
10888 do
10889   IFS=$as_save_IFS
10890   test -z "$as_dir" && as_dir=.
10891   for ac_exec_ext in '' $ac_executable_extensions; do
10892   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10893     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10894     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10895     break 2
10896   fi
10897 done
10898 done
10899
10900 fi
10901 fi
10902 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10903 if test -n "$RANLIB_FOR_TARGET"; then
10904   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10905 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10906 else
10907   echo "$as_me:$LINENO: result: no" >&5
10908 echo "${ECHO_T}no" >&6
10909 fi
10910
10911     fi
10912     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10913   done
10914 fi
10915
10916 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10917   set dummy ranlib
10918   if test $build = $target ; then
10919     RANLIB_FOR_TARGET="$2"
10920   else
10921     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10922   fi
10923 else
10924   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10925 fi
10926
10927 else
10928   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10929 fi
10930
10931
10932
10933
10934 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10935   if test -n "$with_build_time_tools"; then
10936     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10937 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10938     if test -x $with_build_time_tools/strip; then
10939       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10940       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10941       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10942 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10943     else
10944       echo "$as_me:$LINENO: result: no" >&5
10945 echo "${ECHO_T}no" >&6
10946     fi
10947   elif test $build != $host && test $have_gcc_for_target = yes; then
10948     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10949     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10950     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10951   fi
10952 fi
10953 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10954   # Extract the first word of "strip", so it can be a program name with args.
10955 set dummy strip; ac_word=$2
10956 echo "$as_me:$LINENO: checking for $ac_word" >&5
10957 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10958 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10959   echo $ECHO_N "(cached) $ECHO_C" >&6
10960 else
10961   case $STRIP_FOR_TARGET in
10962   [\\/]* | ?:[\\/]*)
10963   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10964   ;;
10965   *)
10966   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10967 for as_dir in $gcc_cv_tool_dirs
10968 do
10969   IFS=$as_save_IFS
10970   test -z "$as_dir" && as_dir=.
10971   for ac_exec_ext in '' $ac_executable_extensions; do
10972   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10973     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10974     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10975     break 2
10976   fi
10977 done
10978 done
10979
10980   ;;
10981 esac
10982 fi
10983 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10984
10985 if test -n "$STRIP_FOR_TARGET"; then
10986   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10987 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10988 else
10989   echo "$as_me:$LINENO: result: no" >&5
10990 echo "${ECHO_T}no" >&6
10991 fi
10992
10993 fi
10994 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10995
10996
10997 if test -n "$STRIP_FOR_TARGET"; then
10998   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10999 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11000   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11001 fi
11002
11003 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11004   for ncn_progname in strip; do
11005     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11006 set dummy ${ncn_progname}; ac_word=$2
11007 echo "$as_me:$LINENO: checking for $ac_word" >&5
11008 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11009 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11010   echo $ECHO_N "(cached) $ECHO_C" >&6
11011 else
11012   if test -n "$STRIP_FOR_TARGET"; then
11013   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11014 else
11015 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11016 for as_dir in $PATH
11017 do
11018   IFS=$as_save_IFS
11019   test -z "$as_dir" && as_dir=.
11020   for ac_exec_ext in '' $ac_executable_extensions; do
11021   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11022     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11023     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11024     break 2
11025   fi
11026 done
11027 done
11028
11029 fi
11030 fi
11031 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11032 if test -n "$STRIP_FOR_TARGET"; then
11033   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11034 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11035 else
11036   echo "$as_me:$LINENO: result: no" >&5
11037 echo "${ECHO_T}no" >&6
11038 fi
11039
11040   done
11041 fi
11042
11043 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11044   for ncn_progname in strip; do
11045     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11046 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11047     if test -x $with_build_time_tools/${ncn_progname}; then
11048       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11049       echo "$as_me:$LINENO: result: yes" >&5
11050 echo "${ECHO_T}yes" >&6
11051       break
11052     else
11053       echo "$as_me:$LINENO: result: no" >&5
11054 echo "${ECHO_T}no" >&6
11055     fi
11056   done
11057 fi
11058
11059 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11060   for ncn_progname in strip; do
11061     if test -n "$ncn_target_tool_prefix"; then
11062       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11063 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11064 echo "$as_me:$LINENO: checking for $ac_word" >&5
11065 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11066 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11067   echo $ECHO_N "(cached) $ECHO_C" >&6
11068 else
11069   if test -n "$STRIP_FOR_TARGET"; then
11070   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11071 else
11072 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11073 for as_dir in $PATH
11074 do
11075   IFS=$as_save_IFS
11076   test -z "$as_dir" && as_dir=.
11077   for ac_exec_ext in '' $ac_executable_extensions; do
11078   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11079     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11080     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11081     break 2
11082   fi
11083 done
11084 done
11085
11086 fi
11087 fi
11088 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11089 if test -n "$STRIP_FOR_TARGET"; then
11090   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11091 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11092 else
11093   echo "$as_me:$LINENO: result: no" >&5
11094 echo "${ECHO_T}no" >&6
11095 fi
11096
11097     fi
11098     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11099       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11100 set dummy ${ncn_progname}; ac_word=$2
11101 echo "$as_me:$LINENO: checking for $ac_word" >&5
11102 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11103 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11104   echo $ECHO_N "(cached) $ECHO_C" >&6
11105 else
11106   if test -n "$STRIP_FOR_TARGET"; then
11107   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11108 else
11109 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11110 for as_dir in $PATH
11111 do
11112   IFS=$as_save_IFS
11113   test -z "$as_dir" && as_dir=.
11114   for ac_exec_ext in '' $ac_executable_extensions; do
11115   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11116     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11117     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11118     break 2
11119   fi
11120 done
11121 done
11122
11123 fi
11124 fi
11125 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11126 if test -n "$STRIP_FOR_TARGET"; then
11127   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11128 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11129 else
11130   echo "$as_me:$LINENO: result: no" >&5
11131 echo "${ECHO_T}no" >&6
11132 fi
11133
11134     fi
11135     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11136   done
11137 fi
11138
11139 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11140   set dummy strip
11141   if test $build = $target ; then
11142     STRIP_FOR_TARGET="$2"
11143   else
11144     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11145   fi
11146 else
11147   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11148 fi
11149
11150 else
11151   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11152 fi
11153
11154
11155
11156
11157 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11158   if test -n "$with_build_time_tools"; then
11159     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11160 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11161     if test -x $with_build_time_tools/windres; then
11162       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11163       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11164       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11165 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11166     else
11167       echo "$as_me:$LINENO: result: no" >&5
11168 echo "${ECHO_T}no" >&6
11169     fi
11170   elif test $build != $host && test $have_gcc_for_target = yes; then
11171     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11172     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11173     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11174   fi
11175 fi
11176 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11177   # Extract the first word of "windres", so it can be a program name with args.
11178 set dummy windres; ac_word=$2
11179 echo "$as_me:$LINENO: checking for $ac_word" >&5
11180 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11181 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11182   echo $ECHO_N "(cached) $ECHO_C" >&6
11183 else
11184   case $WINDRES_FOR_TARGET in
11185   [\\/]* | ?:[\\/]*)
11186   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11187   ;;
11188   *)
11189   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11190 for as_dir in $gcc_cv_tool_dirs
11191 do
11192   IFS=$as_save_IFS
11193   test -z "$as_dir" && as_dir=.
11194   for ac_exec_ext in '' $ac_executable_extensions; do
11195   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11196     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11197     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11198     break 2
11199   fi
11200 done
11201 done
11202
11203   ;;
11204 esac
11205 fi
11206 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11207
11208 if test -n "$WINDRES_FOR_TARGET"; then
11209   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11210 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11211 else
11212   echo "$as_me:$LINENO: result: no" >&5
11213 echo "${ECHO_T}no" >&6
11214 fi
11215
11216 fi
11217 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11218
11219
11220 if test -n "$WINDRES_FOR_TARGET"; then
11221   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11222 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11223   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11224 fi
11225
11226 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11227   for ncn_progname in windres; do
11228     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11229 set dummy ${ncn_progname}; ac_word=$2
11230 echo "$as_me:$LINENO: checking for $ac_word" >&5
11231 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11232 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11233   echo $ECHO_N "(cached) $ECHO_C" >&6
11234 else
11235   if test -n "$WINDRES_FOR_TARGET"; then
11236   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11237 else
11238 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11239 for as_dir in $PATH
11240 do
11241   IFS=$as_save_IFS
11242   test -z "$as_dir" && as_dir=.
11243   for ac_exec_ext in '' $ac_executable_extensions; do
11244   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11245     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11246     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11247     break 2
11248   fi
11249 done
11250 done
11251
11252 fi
11253 fi
11254 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11255 if test -n "$WINDRES_FOR_TARGET"; then
11256   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11257 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11258 else
11259   echo "$as_me:$LINENO: result: no" >&5
11260 echo "${ECHO_T}no" >&6
11261 fi
11262
11263   done
11264 fi
11265
11266 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11267   for ncn_progname in windres; do
11268     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11269 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11270     if test -x $with_build_time_tools/${ncn_progname}; then
11271       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11272       echo "$as_me:$LINENO: result: yes" >&5
11273 echo "${ECHO_T}yes" >&6
11274       break
11275     else
11276       echo "$as_me:$LINENO: result: no" >&5
11277 echo "${ECHO_T}no" >&6
11278     fi
11279   done
11280 fi
11281
11282 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11283   for ncn_progname in windres; do
11284     if test -n "$ncn_target_tool_prefix"; then
11285       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11286 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11287 echo "$as_me:$LINENO: checking for $ac_word" >&5
11288 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11289 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11290   echo $ECHO_N "(cached) $ECHO_C" >&6
11291 else
11292   if test -n "$WINDRES_FOR_TARGET"; then
11293   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11294 else
11295 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11296 for as_dir in $PATH
11297 do
11298   IFS=$as_save_IFS
11299   test -z "$as_dir" && as_dir=.
11300   for ac_exec_ext in '' $ac_executable_extensions; do
11301   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11302     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11303     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11304     break 2
11305   fi
11306 done
11307 done
11308
11309 fi
11310 fi
11311 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11312 if test -n "$WINDRES_FOR_TARGET"; then
11313   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11314 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11315 else
11316   echo "$as_me:$LINENO: result: no" >&5
11317 echo "${ECHO_T}no" >&6
11318 fi
11319
11320     fi
11321     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11322       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11323 set dummy ${ncn_progname}; ac_word=$2
11324 echo "$as_me:$LINENO: checking for $ac_word" >&5
11325 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11326 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11327   echo $ECHO_N "(cached) $ECHO_C" >&6
11328 else
11329   if test -n "$WINDRES_FOR_TARGET"; then
11330   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11331 else
11332 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11333 for as_dir in $PATH
11334 do
11335   IFS=$as_save_IFS
11336   test -z "$as_dir" && as_dir=.
11337   for ac_exec_ext in '' $ac_executable_extensions; do
11338   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11339     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11340     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11341     break 2
11342   fi
11343 done
11344 done
11345
11346 fi
11347 fi
11348 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11349 if test -n "$WINDRES_FOR_TARGET"; then
11350   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11351 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11352 else
11353   echo "$as_me:$LINENO: result: no" >&5
11354 echo "${ECHO_T}no" >&6
11355 fi
11356
11357     fi
11358     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11359   done
11360 fi
11361
11362 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11363   set dummy windres
11364   if test $build = $target ; then
11365     WINDRES_FOR_TARGET="$2"
11366   else
11367     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11368   fi
11369 else
11370   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11371 fi
11372
11373 else
11374   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11375 fi
11376
11377
11378
11379
11380 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11381   if test -n "$with_build_time_tools"; then
11382     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11383 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11384     if test -x $with_build_time_tools/windmc; then
11385       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11386       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11387       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11388 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11389     else
11390       echo "$as_me:$LINENO: result: no" >&5
11391 echo "${ECHO_T}no" >&6
11392     fi
11393   elif test $build != $host && test $have_gcc_for_target = yes; then
11394     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11395     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11396     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11397   fi
11398 fi
11399 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11400   # Extract the first word of "windmc", so it can be a program name with args.
11401 set dummy windmc; ac_word=$2
11402 echo "$as_me:$LINENO: checking for $ac_word" >&5
11403 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11404 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11405   echo $ECHO_N "(cached) $ECHO_C" >&6
11406 else
11407   case $WINDMC_FOR_TARGET in
11408   [\\/]* | ?:[\\/]*)
11409   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11410   ;;
11411   *)
11412   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11413 for as_dir in $gcc_cv_tool_dirs
11414 do
11415   IFS=$as_save_IFS
11416   test -z "$as_dir" && as_dir=.
11417   for ac_exec_ext in '' $ac_executable_extensions; do
11418   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11419     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11420     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11421     break 2
11422   fi
11423 done
11424 done
11425
11426   ;;
11427 esac
11428 fi
11429 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11430
11431 if test -n "$WINDMC_FOR_TARGET"; then
11432   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11433 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11434 else
11435   echo "$as_me:$LINENO: result: no" >&5
11436 echo "${ECHO_T}no" >&6
11437 fi
11438
11439 fi
11440 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11441
11442
11443 if test -n "$WINDMC_FOR_TARGET"; then
11444   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11445 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11446   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11447 fi
11448
11449 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11450   for ncn_progname in windmc; do
11451     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11452 set dummy ${ncn_progname}; ac_word=$2
11453 echo "$as_me:$LINENO: checking for $ac_word" >&5
11454 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11455 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11456   echo $ECHO_N "(cached) $ECHO_C" >&6
11457 else
11458   if test -n "$WINDMC_FOR_TARGET"; then
11459   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11460 else
11461 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11462 for as_dir in $PATH
11463 do
11464   IFS=$as_save_IFS
11465   test -z "$as_dir" && as_dir=.
11466   for ac_exec_ext in '' $ac_executable_extensions; do
11467   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11468     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11469     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11470     break 2
11471   fi
11472 done
11473 done
11474
11475 fi
11476 fi
11477 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11478 if test -n "$WINDMC_FOR_TARGET"; then
11479   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11480 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11481 else
11482   echo "$as_me:$LINENO: result: no" >&5
11483 echo "${ECHO_T}no" >&6
11484 fi
11485
11486   done
11487 fi
11488
11489 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11490   for ncn_progname in windmc; do
11491     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11492 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11493     if test -x $with_build_time_tools/${ncn_progname}; then
11494       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11495       echo "$as_me:$LINENO: result: yes" >&5
11496 echo "${ECHO_T}yes" >&6
11497       break
11498     else
11499       echo "$as_me:$LINENO: result: no" >&5
11500 echo "${ECHO_T}no" >&6
11501     fi
11502   done
11503 fi
11504
11505 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11506   for ncn_progname in windmc; do
11507     if test -n "$ncn_target_tool_prefix"; then
11508       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11509 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11510 echo "$as_me:$LINENO: checking for $ac_word" >&5
11511 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11512 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11513   echo $ECHO_N "(cached) $ECHO_C" >&6
11514 else
11515   if test -n "$WINDMC_FOR_TARGET"; then
11516   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11517 else
11518 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11519 for as_dir in $PATH
11520 do
11521   IFS=$as_save_IFS
11522   test -z "$as_dir" && as_dir=.
11523   for ac_exec_ext in '' $ac_executable_extensions; do
11524   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11525     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11526     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11527     break 2
11528   fi
11529 done
11530 done
11531
11532 fi
11533 fi
11534 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11535 if test -n "$WINDMC_FOR_TARGET"; then
11536   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11537 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11538 else
11539   echo "$as_me:$LINENO: result: no" >&5
11540 echo "${ECHO_T}no" >&6
11541 fi
11542
11543     fi
11544     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11545       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11546 set dummy ${ncn_progname}; ac_word=$2
11547 echo "$as_me:$LINENO: checking for $ac_word" >&5
11548 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11549 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11550   echo $ECHO_N "(cached) $ECHO_C" >&6
11551 else
11552   if test -n "$WINDMC_FOR_TARGET"; then
11553   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11554 else
11555 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11556 for as_dir in $PATH
11557 do
11558   IFS=$as_save_IFS
11559   test -z "$as_dir" && as_dir=.
11560   for ac_exec_ext in '' $ac_executable_extensions; do
11561   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11562     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11563     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11564     break 2
11565   fi
11566 done
11567 done
11568
11569 fi
11570 fi
11571 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11572 if test -n "$WINDMC_FOR_TARGET"; then
11573   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11574 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11575 else
11576   echo "$as_me:$LINENO: result: no" >&5
11577 echo "${ECHO_T}no" >&6
11578 fi
11579
11580     fi
11581     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11582   done
11583 fi
11584
11585 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11586   set dummy windmc
11587   if test $build = $target ; then
11588     WINDMC_FOR_TARGET="$2"
11589   else
11590     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11591   fi
11592 else
11593   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11594 fi
11595
11596 else
11597   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11598 fi
11599
11600
11601 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11602
11603 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11604 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11605 if test "x${build}" != "x${host}" ; then
11606   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11607     # We already found the complete path
11608     ac_dir=`dirname $AR_FOR_TARGET`
11609     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11610 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11611   else
11612     # Canadian cross, just use what we found
11613     echo "$as_me:$LINENO: result: pre-installed" >&5
11614 echo "${ECHO_T}pre-installed" >&6
11615   fi
11616 else
11617   ok=yes
11618   case " ${configdirs} " in
11619     *" binutils "*) ;;
11620     *) ok=no ;;
11621   esac
11622
11623   if test $ok = yes; then
11624     # An in-tree tool is available and we can use it
11625     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11626     echo "$as_me:$LINENO: result: just compiled" >&5
11627 echo "${ECHO_T}just compiled" >&6
11628   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11629     # We already found the complete path
11630     ac_dir=`dirname $AR_FOR_TARGET`
11631     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11632 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11633   elif test "x$target" = "x$host"; then
11634     # We can use an host tool
11635     AR_FOR_TARGET='$(AR)'
11636     echo "$as_me:$LINENO: result: host tool" >&5
11637 echo "${ECHO_T}host tool" >&6
11638   else
11639     # We need a cross tool
11640     echo "$as_me:$LINENO: result: pre-installed" >&5
11641 echo "${ECHO_T}pre-installed" >&6
11642   fi
11643 fi
11644
11645 echo "$as_me:$LINENO: checking where to find the target as" >&5
11646 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11647 if test "x${build}" != "x${host}" ; then
11648   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11649     # We already found the complete path
11650     ac_dir=`dirname $AS_FOR_TARGET`
11651     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11652 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11653   else
11654     # Canadian cross, just use what we found
11655     echo "$as_me:$LINENO: result: pre-installed" >&5
11656 echo "${ECHO_T}pre-installed" >&6
11657   fi
11658 else
11659   ok=yes
11660   case " ${configdirs} " in
11661     *" gas "*) ;;
11662     *) ok=no ;;
11663   esac
11664
11665   if test $ok = yes; then
11666     # An in-tree tool is available and we can use it
11667     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11668     echo "$as_me:$LINENO: result: just compiled" >&5
11669 echo "${ECHO_T}just compiled" >&6
11670   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11671     # We already found the complete path
11672     ac_dir=`dirname $AS_FOR_TARGET`
11673     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11674 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11675   elif test "x$target" = "x$host"; then
11676     # We can use an host tool
11677     AS_FOR_TARGET='$(AS)'
11678     echo "$as_me:$LINENO: result: host tool" >&5
11679 echo "${ECHO_T}host tool" >&6
11680   else
11681     # We need a cross tool
11682     echo "$as_me:$LINENO: result: pre-installed" >&5
11683 echo "${ECHO_T}pre-installed" >&6
11684   fi
11685 fi
11686
11687 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11688 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11689 if test "x${build}" != "x${host}" ; then
11690   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11691     # We already found the complete path
11692     ac_dir=`dirname $CC_FOR_TARGET`
11693     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11694 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11695   else
11696     # Canadian cross, just use what we found
11697     echo "$as_me:$LINENO: result: pre-installed" >&5
11698 echo "${ECHO_T}pre-installed" >&6
11699   fi
11700 else
11701   ok=yes
11702   case " ${configdirs} " in
11703     *" gcc "*) ;;
11704     *) ok=no ;;
11705   esac
11706
11707   if test $ok = yes; then
11708     # An in-tree tool is available and we can use it
11709     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11710     echo "$as_me:$LINENO: result: just compiled" >&5
11711 echo "${ECHO_T}just compiled" >&6
11712   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11713     # We already found the complete path
11714     ac_dir=`dirname $CC_FOR_TARGET`
11715     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11716 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11717   elif test "x$target" = "x$host"; then
11718     # We can use an host tool
11719     CC_FOR_TARGET='$(CC)'
11720     echo "$as_me:$LINENO: result: host tool" >&5
11721 echo "${ECHO_T}host tool" >&6
11722   else
11723     # We need a cross tool
11724     echo "$as_me:$LINENO: result: pre-installed" >&5
11725 echo "${ECHO_T}pre-installed" >&6
11726   fi
11727 fi
11728
11729 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11730 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11731 if test "x${build}" != "x${host}" ; then
11732   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11733     # We already found the complete path
11734     ac_dir=`dirname $CXX_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   else
11738     # Canadian cross, just use what we found
11739     echo "$as_me:$LINENO: result: pre-installed" >&5
11740 echo "${ECHO_T}pre-installed" >&6
11741   fi
11742 else
11743   ok=yes
11744   case " ${configdirs} " in
11745     *" gcc "*) ;;
11746     *) ok=no ;;
11747   esac
11748   case ,${enable_languages}, in
11749     *,c++,*) ;;
11750     *) ok=no ;;
11751   esac
11752   if test $ok = yes; then
11753     # An in-tree tool is available and we can use it
11754     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'
11755     echo "$as_me:$LINENO: result: just compiled" >&5
11756 echo "${ECHO_T}just compiled" >&6
11757   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11758     # We already found the complete path
11759     ac_dir=`dirname $CXX_FOR_TARGET`
11760     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11761 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11762   elif test "x$target" = "x$host"; then
11763     # We can use an host tool
11764     CXX_FOR_TARGET='$(CXX)'
11765     echo "$as_me:$LINENO: result: host tool" >&5
11766 echo "${ECHO_T}host tool" >&6
11767   else
11768     # We need a cross tool
11769     echo "$as_me:$LINENO: result: pre-installed" >&5
11770 echo "${ECHO_T}pre-installed" >&6
11771   fi
11772 fi
11773
11774 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11775 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11776 if test "x${build}" != "x${host}" ; then
11777   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11778     # We already found the complete path
11779     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11780     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11781 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11782   else
11783     # Canadian cross, just use what we found
11784     echo "$as_me:$LINENO: result: pre-installed" >&5
11785 echo "${ECHO_T}pre-installed" >&6
11786   fi
11787 else
11788   ok=yes
11789   case " ${configdirs} " in
11790     *" gcc "*) ;;
11791     *) ok=no ;;
11792   esac
11793   case ,${enable_languages}, in
11794     *,c++,*) ;;
11795     *) ok=no ;;
11796   esac
11797   if test $ok = yes; then
11798     # An in-tree tool is available and we can use it
11799     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'
11800     echo "$as_me:$LINENO: result: just compiled" >&5
11801 echo "${ECHO_T}just compiled" >&6
11802   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11803     # We already found the complete path
11804     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11805     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11806 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11807   elif test "x$target" = "x$host"; then
11808     # We can use an host tool
11809     RAW_CXX_FOR_TARGET='$(CXX)'
11810     echo "$as_me:$LINENO: result: host tool" >&5
11811 echo "${ECHO_T}host tool" >&6
11812   else
11813     # We need a cross tool
11814     echo "$as_me:$LINENO: result: pre-installed" >&5
11815 echo "${ECHO_T}pre-installed" >&6
11816   fi
11817 fi
11818
11819 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11820 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11821 if test "x${build}" != "x${host}" ; then
11822   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11823     # We already found the complete path
11824     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11825     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11826 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11827   else
11828     # Canadian cross, just use what we found
11829     echo "$as_me:$LINENO: result: pre-installed" >&5
11830 echo "${ECHO_T}pre-installed" >&6
11831   fi
11832 else
11833   ok=yes
11834   case " ${configdirs} " in
11835     *" binutils "*) ;;
11836     *) ok=no ;;
11837   esac
11838
11839   if test $ok = yes; then
11840     # An in-tree tool is available and we can use it
11841     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11842     echo "$as_me:$LINENO: result: just compiled" >&5
11843 echo "${ECHO_T}just compiled" >&6
11844   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11845     # We already found the complete path
11846     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11847     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11848 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11849   elif test "x$target" = "x$host"; then
11850     # We can use an host tool
11851     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11852     echo "$as_me:$LINENO: result: host tool" >&5
11853 echo "${ECHO_T}host tool" >&6
11854   else
11855     # We need a cross tool
11856     echo "$as_me:$LINENO: result: pre-installed" >&5
11857 echo "${ECHO_T}pre-installed" >&6
11858   fi
11859 fi
11860
11861 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11862 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11863 if test "x${build}" != "x${host}" ; then
11864   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11865     # We already found the complete path
11866     ac_dir=`dirname $GCC_FOR_TARGET`
11867     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11868 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11869   else
11870     # Canadian cross, just use what we found
11871     echo "$as_me:$LINENO: result: pre-installed" >&5
11872 echo "${ECHO_T}pre-installed" >&6
11873   fi
11874 else
11875   ok=yes
11876   case " ${configdirs} " in
11877     *" gcc "*) ;;
11878     *) ok=no ;;
11879   esac
11880
11881   if test $ok = yes; then
11882     # An in-tree tool is available and we can use it
11883     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11884     echo "$as_me:$LINENO: result: just compiled" >&5
11885 echo "${ECHO_T}just compiled" >&6
11886   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11887     # We already found the complete path
11888     ac_dir=`dirname $GCC_FOR_TARGET`
11889     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11890 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11891   elif test "x$target" = "x$host"; then
11892     # We can use an host tool
11893     GCC_FOR_TARGET='$()'
11894     echo "$as_me:$LINENO: result: host tool" >&5
11895 echo "${ECHO_T}host tool" >&6
11896   else
11897     # We need a cross tool
11898     echo "$as_me:$LINENO: result: pre-installed" >&5
11899 echo "${ECHO_T}pre-installed" >&6
11900   fi
11901 fi
11902
11903 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11904 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11905 if test "x${build}" != "x${host}" ; then
11906   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11907     # We already found the complete path
11908     ac_dir=`dirname $GCJ_FOR_TARGET`
11909     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11910 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11911   else
11912     # Canadian cross, just use what we found
11913     echo "$as_me:$LINENO: result: pre-installed" >&5
11914 echo "${ECHO_T}pre-installed" >&6
11915   fi
11916 else
11917   ok=yes
11918   case " ${configdirs} " in
11919     *" gcc "*) ;;
11920     *) ok=no ;;
11921   esac
11922   case ,${enable_languages}, in
11923     *,java,*) ;;
11924     *) ok=no ;;
11925   esac
11926   if test $ok = yes; then
11927     # An in-tree tool is available and we can use it
11928     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11929     echo "$as_me:$LINENO: result: just compiled" >&5
11930 echo "${ECHO_T}just compiled" >&6
11931   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11932     # We already found the complete path
11933     ac_dir=`dirname $GCJ_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     GCJ_FOR_TARGET='$(GCJ)'
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 gfortran" >&5
11949 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11950 if test "x${build}" != "x${host}" ; then
11951   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11952     # We already found the complete path
11953     ac_dir=`dirname $GFORTRAN_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     *" gcc "*) ;;
11965     *) ok=no ;;
11966   esac
11967   case ,${enable_languages}, in
11968     *,fortran,*) ;;
11969     *) ok=no ;;
11970   esac
11971   if test $ok = yes; then
11972     # An in-tree tool is available and we can use it
11973     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11974     echo "$as_me:$LINENO: result: just compiled" >&5
11975 echo "${ECHO_T}just compiled" >&6
11976   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11977     # We already found the complete path
11978     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11979     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11980 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11981   elif test "x$target" = "x$host"; then
11982     # We can use an host tool
11983     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11984     echo "$as_me:$LINENO: result: host tool" >&5
11985 echo "${ECHO_T}host tool" >&6
11986   else
11987     # We need a cross tool
11988     echo "$as_me:$LINENO: result: pre-installed" >&5
11989 echo "${ECHO_T}pre-installed" >&6
11990   fi
11991 fi
11992
11993 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11994 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11995 if test "x${build}" != "x${host}" ; then
11996   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11997     # We already found the complete path
11998     ac_dir=`dirname $LD_FOR_TARGET`
11999     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12000 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12001   else
12002     # Canadian cross, just use what we found
12003     echo "$as_me:$LINENO: result: pre-installed" >&5
12004 echo "${ECHO_T}pre-installed" >&6
12005   fi
12006 else
12007   ok=yes
12008   case " ${configdirs} " in
12009     *" ld "*) ;;
12010     *) ok=no ;;
12011   esac
12012
12013   if test $ok = yes; then
12014     # An in-tree tool is available and we can use it
12015     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12016     echo "$as_me:$LINENO: result: just compiled" >&5
12017 echo "${ECHO_T}just compiled" >&6
12018   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12019     # We already found the complete path
12020     ac_dir=`dirname $LD_FOR_TARGET`
12021     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12022 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12023   elif test "x$target" = "x$host"; then
12024     # We can use an host tool
12025     LD_FOR_TARGET='$(LD)'
12026     echo "$as_me:$LINENO: result: host tool" >&5
12027 echo "${ECHO_T}host tool" >&6
12028   else
12029     # We need a cross tool
12030     echo "$as_me:$LINENO: result: pre-installed" >&5
12031 echo "${ECHO_T}pre-installed" >&6
12032   fi
12033 fi
12034
12035 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12036 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12037 if test "x${build}" != "x${host}" ; then
12038   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12039     # We already found the complete path
12040     ac_dir=`dirname $LIPO_FOR_TARGET`
12041     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12042 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12043   else
12044     # Canadian cross, just use what we found
12045     echo "$as_me:$LINENO: result: pre-installed" >&5
12046 echo "${ECHO_T}pre-installed" >&6
12047   fi
12048 else
12049   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12050     # We already found the complete path
12051     ac_dir=`dirname $LIPO_FOR_TARGET`
12052     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12053 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12054   elif test "x$target" = "x$host"; then
12055     # We can use an host tool
12056     LIPO_FOR_TARGET='$(LIPO)'
12057     echo "$as_me:$LINENO: result: host tool" >&5
12058 echo "${ECHO_T}host tool" >&6
12059   else
12060     # We need a cross tool
12061     echo "$as_me:$LINENO: result: pre-installed" >&5
12062 echo "${ECHO_T}pre-installed" >&6
12063   fi
12064 fi
12065
12066 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12067 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12068 if test "x${build}" != "x${host}" ; then
12069   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12070     # We already found the complete path
12071     ac_dir=`dirname $NM_FOR_TARGET`
12072     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12073 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12074   else
12075     # Canadian cross, just use what we found
12076     echo "$as_me:$LINENO: result: pre-installed" >&5
12077 echo "${ECHO_T}pre-installed" >&6
12078   fi
12079 else
12080   ok=yes
12081   case " ${configdirs} " in
12082     *" binutils "*) ;;
12083     *) ok=no ;;
12084   esac
12085
12086   if test $ok = yes; then
12087     # An in-tree tool is available and we can use it
12088     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12089     echo "$as_me:$LINENO: result: just compiled" >&5
12090 echo "${ECHO_T}just compiled" >&6
12091   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12092     # We already found the complete path
12093     ac_dir=`dirname $NM_FOR_TARGET`
12094     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12095 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12096   elif test "x$target" = "x$host"; then
12097     # We can use an host tool
12098     NM_FOR_TARGET='$(NM)'
12099     echo "$as_me:$LINENO: result: host tool" >&5
12100 echo "${ECHO_T}host tool" >&6
12101   else
12102     # We need a cross tool
12103     echo "$as_me:$LINENO: result: pre-installed" >&5
12104 echo "${ECHO_T}pre-installed" >&6
12105   fi
12106 fi
12107
12108 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12109 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12110 if test "x${build}" != "x${host}" ; then
12111   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12112     # We already found the complete path
12113     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12114     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12115 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12116   else
12117     # Canadian cross, just use what we found
12118     echo "$as_me:$LINENO: result: pre-installed" >&5
12119 echo "${ECHO_T}pre-installed" >&6
12120   fi
12121 else
12122   ok=yes
12123   case " ${configdirs} " in
12124     *" binutils "*) ;;
12125     *) ok=no ;;
12126   esac
12127
12128   if test $ok = yes; then
12129     # An in-tree tool is available and we can use it
12130     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12131     echo "$as_me:$LINENO: result: just compiled" >&5
12132 echo "${ECHO_T}just compiled" >&6
12133   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12134     # We already found the complete path
12135     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12136     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12137 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12138   elif test "x$target" = "x$host"; then
12139     # We can use an host tool
12140     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12141     echo "$as_me:$LINENO: result: host tool" >&5
12142 echo "${ECHO_T}host tool" >&6
12143   else
12144     # We need a cross tool
12145     echo "$as_me:$LINENO: result: pre-installed" >&5
12146 echo "${ECHO_T}pre-installed" >&6
12147   fi
12148 fi
12149
12150 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12151 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12152 if test "x${build}" != "x${host}" ; then
12153   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12154     # We already found the complete path
12155     ac_dir=`dirname $RANLIB_FOR_TARGET`
12156     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12157 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12158   else
12159     # Canadian cross, just use what we found
12160     echo "$as_me:$LINENO: result: pre-installed" >&5
12161 echo "${ECHO_T}pre-installed" >&6
12162   fi
12163 else
12164   ok=yes
12165   case " ${configdirs} " in
12166     *" binutils "*) ;;
12167     *) ok=no ;;
12168   esac
12169
12170   if test $ok = yes; then
12171     # An in-tree tool is available and we can use it
12172     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12173     echo "$as_me:$LINENO: result: just compiled" >&5
12174 echo "${ECHO_T}just compiled" >&6
12175   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12176     # We already found the complete path
12177     ac_dir=`dirname $RANLIB_FOR_TARGET`
12178     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12179 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12180   elif test "x$target" = "x$host"; then
12181     # We can use an host tool
12182     RANLIB_FOR_TARGET='$(RANLIB)'
12183     echo "$as_me:$LINENO: result: host tool" >&5
12184 echo "${ECHO_T}host tool" >&6
12185   else
12186     # We need a cross tool
12187     echo "$as_me:$LINENO: result: pre-installed" >&5
12188 echo "${ECHO_T}pre-installed" >&6
12189   fi
12190 fi
12191
12192 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12193 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12194 if test "x${build}" != "x${host}" ; then
12195   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12196     # We already found the complete path
12197     ac_dir=`dirname $STRIP_FOR_TARGET`
12198     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12199 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12200   else
12201     # Canadian cross, just use what we found
12202     echo "$as_me:$LINENO: result: pre-installed" >&5
12203 echo "${ECHO_T}pre-installed" >&6
12204   fi
12205 else
12206   ok=yes
12207   case " ${configdirs} " in
12208     *" binutils "*) ;;
12209     *) ok=no ;;
12210   esac
12211
12212   if test $ok = yes; then
12213     # An in-tree tool is available and we can use it
12214     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12215     echo "$as_me:$LINENO: result: just compiled" >&5
12216 echo "${ECHO_T}just compiled" >&6
12217   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12218     # We already found the complete path
12219     ac_dir=`dirname $STRIP_FOR_TARGET`
12220     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12221 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12222   elif test "x$target" = "x$host"; then
12223     # We can use an host tool
12224     STRIP_FOR_TARGET='$(STRIP)'
12225     echo "$as_me:$LINENO: result: host tool" >&5
12226 echo "${ECHO_T}host tool" >&6
12227   else
12228     # We need a cross tool
12229     echo "$as_me:$LINENO: result: pre-installed" >&5
12230 echo "${ECHO_T}pre-installed" >&6
12231   fi
12232 fi
12233
12234 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12235 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12236 if test "x${build}" != "x${host}" ; then
12237   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12238     # We already found the complete path
12239     ac_dir=`dirname $WINDRES_FOR_TARGET`
12240     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12241 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12242   else
12243     # Canadian cross, just use what we found
12244     echo "$as_me:$LINENO: result: pre-installed" >&5
12245 echo "${ECHO_T}pre-installed" >&6
12246   fi
12247 else
12248   ok=yes
12249   case " ${configdirs} " in
12250     *" binutils "*) ;;
12251     *) ok=no ;;
12252   esac
12253
12254   if test $ok = yes; then
12255     # An in-tree tool is available and we can use it
12256     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12257     echo "$as_me:$LINENO: result: just compiled" >&5
12258 echo "${ECHO_T}just compiled" >&6
12259   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12260     # We already found the complete path
12261     ac_dir=`dirname $WINDRES_FOR_TARGET`
12262     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12263 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12264   elif test "x$target" = "x$host"; then
12265     # We can use an host tool
12266     WINDRES_FOR_TARGET='$(WINDRES)'
12267     echo "$as_me:$LINENO: result: host tool" >&5
12268 echo "${ECHO_T}host tool" >&6
12269   else
12270     # We need a cross tool
12271     echo "$as_me:$LINENO: result: pre-installed" >&5
12272 echo "${ECHO_T}pre-installed" >&6
12273   fi
12274 fi
12275
12276 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12277 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12278 if test "x${build}" != "x${host}" ; then
12279   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12280     # We already found the complete path
12281     ac_dir=`dirname $WINDMC_FOR_TARGET`
12282     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12283 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12284   else
12285     # Canadian cross, just use what we found
12286     echo "$as_me:$LINENO: result: pre-installed" >&5
12287 echo "${ECHO_T}pre-installed" >&6
12288   fi
12289 else
12290   ok=yes
12291   case " ${configdirs} " in
12292     *" binutils "*) ;;
12293     *) ok=no ;;
12294   esac
12295
12296   if test $ok = yes; then
12297     # An in-tree tool is available and we can use it
12298     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12299     echo "$as_me:$LINENO: result: just compiled" >&5
12300 echo "${ECHO_T}just compiled" >&6
12301   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12302     # We already found the complete path
12303     ac_dir=`dirname $WINDMC_FOR_TARGET`
12304     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12305 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12306   elif test "x$target" = "x$host"; then
12307     # We can use an host tool
12308     WINDMC_FOR_TARGET='$(WINDMC)'
12309     echo "$as_me:$LINENO: result: host tool" >&5
12310 echo "${ECHO_T}host tool" >&6
12311   else
12312     # We need a cross tool
12313     echo "$as_me:$LINENO: result: pre-installed" >&5
12314 echo "${ECHO_T}pre-installed" >&6
12315   fi
12316 fi
12317
12318
12319
12320
12321
12322 # Certain tools may need extra flags.
12323 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12324 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12325 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12326
12327 # When building target libraries, except in a Canadian cross, we use
12328 # the same toolchain as the compiler we just built.
12329 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12330 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12331 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12332 if test $host = $build; then
12333   case " $configdirs " in
12334     *" gcc "*)
12335       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12336       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12337       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12338       ;;
12339   esac
12340 fi
12341
12342
12343
12344
12345
12346 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12347 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12348 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12349 if test "${enable_maintainer_mode+set}" = set; then
12350   enableval="$enable_maintainer_mode"
12351   USE_MAINTAINER_MODE=$enableval
12352 else
12353   USE_MAINTAINER_MODE=no
12354 fi;
12355 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12356 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12357
12358
12359 if test "$USE_MAINTAINER_MODE" = yes; then
12360   MAINTAINER_MODE_TRUE=
12361   MAINTAINER_MODE_FALSE='#'
12362 else
12363   MAINTAINER_MODE_TRUE='#'
12364   MAINTAINER_MODE_FALSE=
12365 fi
12366 MAINT=$MAINTAINER_MODE_TRUE
12367
12368 # ---------------------
12369 # GCC bootstrap support
12370 # ---------------------
12371
12372 # Stage specific cflags for build.
12373 stage1_cflags="-g"
12374 case $build in
12375   vax-*-*)
12376     case ${GCC} in
12377       yes) stage1_cflags="-g -Wa,-J" ;;
12378       *) stage1_cflags="-g -J" ;;
12379     esac ;;
12380 esac
12381
12382 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12383 if test "$GCC" = yes; then
12384   saved_CFLAGS="$CFLAGS"
12385
12386   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12387   CFLAGS="$CFLAGS -fkeep-inline-functions"
12388   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12389 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12390   cat >conftest.$ac_ext <<_ACEOF
12391 /* confdefs.h.  */
12392 _ACEOF
12393 cat confdefs.h >>conftest.$ac_ext
12394 cat >>conftest.$ac_ext <<_ACEOF
12395 /* end confdefs.h.  */
12396
12397 #if (__GNUC__ < 3) \
12398     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12399                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12400 #error http://gcc.gnu.org/PR29382
12401 #endif
12402
12403 int
12404 main ()
12405 {
12406
12407   ;
12408   return 0;
12409 }
12410 _ACEOF
12411 rm -f conftest.$ac_objext
12412 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12413   (eval $ac_compile) 2>conftest.er1
12414   ac_status=$?
12415   grep -v '^ *+' conftest.er1 >conftest.err
12416   rm -f conftest.er1
12417   cat conftest.err >&5
12418   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12419   (exit $ac_status); } &&
12420          { ac_try='test -z "$ac_c_werror_flag"
12421                          || test ! -s conftest.err'
12422   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12423   (eval $ac_try) 2>&5
12424   ac_status=$?
12425   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12426   (exit $ac_status); }; } &&
12427          { ac_try='test -s conftest.$ac_objext'
12428   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12429   (eval $ac_try) 2>&5
12430   ac_status=$?
12431   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12432   (exit $ac_status); }; }; then
12433   echo "$as_me:$LINENO: result: yes" >&5
12434 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12435 else
12436   echo "$as_me: failed program was:" >&5
12437 sed 's/^/| /' conftest.$ac_ext >&5
12438
12439 echo "$as_me:$LINENO: result: no" >&5
12440 echo "${ECHO_T}no" >&6
12441 fi
12442 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12443
12444   CFLAGS="$saved_CFLAGS"
12445 fi
12446
12447
12448
12449 # Enable --enable-checking in stage1 of the compiler.
12450 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12451 if test "${enable_stage1_checking+set}" = set; then
12452   enableval="$enable_stage1_checking"
12453   stage1_checking=--enable-checking=${enable_stage1_checking}
12454 else
12455   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12456   stage1_checking=--enable-checking=yes,types
12457 else
12458   stage1_checking=--enable-checking=$enable_checking,types
12459 fi
12460 fi;
12461
12462
12463 # Enable -Werror in bootstrap stage2 and later.
12464 # Check whether --enable-werror or --disable-werror was given.
12465 if test "${enable_werror+set}" = set; then
12466   enableval="$enable_werror"
12467
12468 else
12469   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12470   enable_werror=yes
12471 else
12472   enable_werror=no
12473 fi
12474 fi;
12475 case ${enable_werror} in
12476   yes) stage2_werror_flag="--enable-werror-always" ;;
12477   *) stage2_werror_flag="" ;;
12478 esac
12479
12480
12481 # Flags needed to enable html installing and building
12482
12483 # Check whether --with-datarootdir or --without-datarootdir was given.
12484 if test "${with_datarootdir+set}" = set; then
12485   withval="$with_datarootdir"
12486   datarootdir="\${prefix}/${withval}"
12487 else
12488   datarootdir="\${prefix}/share"
12489 fi;
12490
12491
12492 # Check whether --with-docdir or --without-docdir was given.
12493 if test "${with_docdir+set}" = set; then
12494   withval="$with_docdir"
12495   docdir="\${prefix}/${withval}"
12496 else
12497   docdir="\${datarootdir}/doc"
12498 fi;
12499
12500
12501 # Check whether --with-pdfdir or --without-pdfdir was given.
12502 if test "${with_pdfdir+set}" = set; then
12503   withval="$with_pdfdir"
12504   pdfdir="\${prefix}/${withval}"
12505 else
12506   pdfdir="\${docdir}"
12507 fi;
12508
12509
12510 # Check whether --with-htmldir or --without-htmldir was given.
12511 if test "${with_htmldir+set}" = set; then
12512   withval="$with_htmldir"
12513   htmldir="\${prefix}/${withval}"
12514 else
12515   htmldir="\${docdir}"
12516 fi;
12517
12518
12519
12520
12521
12522
12523           ac_config_files="$ac_config_files Makefile"
12524 cat >confcache <<\_ACEOF
12525 # This file is a shell script that caches the results of configure
12526 # tests run on this system so they can be shared between configure
12527 # scripts and configure runs, see configure's option --config-cache.
12528 # It is not useful on other systems.  If it contains results you don't
12529 # want to keep, you may remove or edit it.
12530 #
12531 # config.status only pays attention to the cache file if you give it
12532 # the --recheck option to rerun configure.
12533 #
12534 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12535 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12536 # following values.
12537
12538 _ACEOF
12539
12540 # The following way of writing the cache mishandles newlines in values,
12541 # but we know of no workaround that is simple, portable, and efficient.
12542 # So, don't put newlines in cache variables' values.
12543 # Ultrix sh set writes to stderr and can't be redirected directly,
12544 # and sets the high bit in the cache file unless we assign to the vars.
12545 {
12546   (set) 2>&1 |
12547     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12548     *ac_space=\ *)
12549       # `set' does not quote correctly, so add quotes (double-quote
12550       # substitution turns \\\\ into \\, and sed turns \\ into \).
12551       sed -n \
12552         "s/'/'\\\\''/g;
12553           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12554       ;;
12555     *)
12556       # `set' quotes correctly as required by POSIX, so do not add quotes.
12557       sed -n \
12558         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12559       ;;
12560     esac;
12561 } |
12562   sed '
12563      t clear
12564      : clear
12565      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12566      t end
12567      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12568      : end' >>confcache
12569 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12570   if test -w $cache_file; then
12571     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12572     cat confcache >$cache_file
12573   else
12574     echo "not updating unwritable cache $cache_file"
12575   fi
12576 fi
12577 rm -f confcache
12578
12579 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12580 # Let make expand exec_prefix.
12581 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12582
12583 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12584 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12585 # trailing colons and then remove the whole line if VPATH becomes empty
12586 # (actually we leave an empty line to preserve line numbers).
12587 if test "x$srcdir" = x.; then
12588   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12589 s/:*\$(srcdir):*/:/;
12590 s/:*\${srcdir}:*/:/;
12591 s/:*@srcdir@:*/:/;
12592 s/^\([^=]*=[     ]*\):*/\1/;
12593 s/:*$//;
12594 s/^[^=]*=[       ]*$//;
12595 }'
12596 fi
12597
12598 # Transform confdefs.h into DEFS.
12599 # Protect against shell expansion while executing Makefile rules.
12600 # Protect against Makefile macro expansion.
12601 #
12602 # If the first sed substitution is executed (which looks for macros that
12603 # take arguments), then we branch to the quote section.  Otherwise,
12604 # look for a macro that doesn't take arguments.
12605 cat >confdef2opt.sed <<\_ACEOF
12606 t clear
12607 : clear
12608 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12609 t quote
12610 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12611 t quote
12612 d
12613 : quote
12614 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12615 s,\[,\\&,g
12616 s,\],\\&,g
12617 s,\$,$$,g
12618 p
12619 _ACEOF
12620 # We use echo to avoid assuming a particular line-breaking character.
12621 # The extra dot is to prevent the shell from consuming trailing
12622 # line-breaks from the sub-command output.  A line-break within
12623 # single-quotes doesn't work because, if this script is created in a
12624 # platform that uses two characters for line-breaks (e.g., DOS), tr
12625 # would break.
12626 ac_LF_and_DOT=`echo; echo .`
12627 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12628 rm -f confdef2opt.sed
12629
12630
12631 ac_libobjs=
12632 ac_ltlibobjs=
12633 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12634   # 1. Remove the extension, and $U if already installed.
12635   ac_i=`echo "$ac_i" |
12636          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12637   # 2. Add them.
12638   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12639   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12640 done
12641 LIBOBJS=$ac_libobjs
12642
12643 LTLIBOBJS=$ac_ltlibobjs
12644
12645
12646
12647 : ${CONFIG_STATUS=./config.status}
12648 ac_clean_files_save=$ac_clean_files
12649 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12650 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12651 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12652 cat >$CONFIG_STATUS <<_ACEOF
12653 #! $SHELL
12654 # Generated by $as_me.
12655 # Run this file to recreate the current configuration.
12656 # Compiler output produced by configure, useful for debugging
12657 # configure, is in config.log if it exists.
12658
12659 debug=false
12660 ac_cs_recheck=false
12661 ac_cs_silent=false
12662 SHELL=\${CONFIG_SHELL-$SHELL}
12663 _ACEOF
12664
12665 cat >>$CONFIG_STATUS <<\_ACEOF
12666 ## --------------------- ##
12667 ## M4sh Initialization.  ##
12668 ## --------------------- ##
12669
12670 # Be Bourne compatible
12671 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12672   emulate sh
12673   NULLCMD=:
12674   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12675   # is contrary to our usage.  Disable this feature.
12676   alias -g '${1+"$@"}'='"$@"'
12677 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12678   set -o posix
12679 fi
12680 DUALCASE=1; export DUALCASE # for MKS sh
12681
12682 # Support unset when possible.
12683 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12684   as_unset=unset
12685 else
12686   as_unset=false
12687 fi
12688
12689
12690 # Work around bugs in pre-3.0 UWIN ksh.
12691 $as_unset ENV MAIL MAILPATH
12692 PS1='$ '
12693 PS2='> '
12694 PS4='+ '
12695
12696 # NLS nuisances.
12697 for as_var in \
12698   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12699   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12700   LC_TELEPHONE LC_TIME
12701 do
12702   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12703     eval $as_var=C; export $as_var
12704   else
12705     $as_unset $as_var
12706   fi
12707 done
12708
12709 # Required to use basename.
12710 if expr a : '\(a\)' >/dev/null 2>&1; then
12711   as_expr=expr
12712 else
12713   as_expr=false
12714 fi
12715
12716 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12717   as_basename=basename
12718 else
12719   as_basename=false
12720 fi
12721
12722
12723 # Name of the executable.
12724 as_me=`$as_basename "$0" ||
12725 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12726          X"$0" : 'X\(//\)$' \| \
12727          X"$0" : 'X\(/\)$' \| \
12728          .     : '\(.\)' 2>/dev/null ||
12729 echo X/"$0" |
12730     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12731           /^X\/\(\/\/\)$/{ s//\1/; q; }
12732           /^X\/\(\/\).*/{ s//\1/; q; }
12733           s/.*/./; q'`
12734
12735
12736 # PATH needs CR, and LINENO needs CR and PATH.
12737 # Avoid depending upon Character Ranges.
12738 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12739 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12740 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12741 as_cr_digits='0123456789'
12742 as_cr_alnum=$as_cr_Letters$as_cr_digits
12743
12744 # The user is always right.
12745 if test "${PATH_SEPARATOR+set}" != set; then
12746   echo "#! /bin/sh" >conf$$.sh
12747   echo  "exit 0"   >>conf$$.sh
12748   chmod +x conf$$.sh
12749   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12750     PATH_SEPARATOR=';'
12751   else
12752     PATH_SEPARATOR=:
12753   fi
12754   rm -f conf$$.sh
12755 fi
12756
12757
12758   as_lineno_1=$LINENO
12759   as_lineno_2=$LINENO
12760   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12761   test "x$as_lineno_1" != "x$as_lineno_2" &&
12762   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12763   # Find who we are.  Look in the path if we contain no path at all
12764   # relative or not.
12765   case $0 in
12766     *[\\/]* ) as_myself=$0 ;;
12767     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12768 for as_dir in $PATH
12769 do
12770   IFS=$as_save_IFS
12771   test -z "$as_dir" && as_dir=.
12772   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12773 done
12774
12775        ;;
12776   esac
12777   # We did not find ourselves, most probably we were run as `sh COMMAND'
12778   # in which case we are not to be found in the path.
12779   if test "x$as_myself" = x; then
12780     as_myself=$0
12781   fi
12782   if test ! -f "$as_myself"; then
12783     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12784 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12785    { (exit 1); exit 1; }; }
12786   fi
12787   case $CONFIG_SHELL in
12788   '')
12789     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12790 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12791 do
12792   IFS=$as_save_IFS
12793   test -z "$as_dir" && as_dir=.
12794   for as_base in sh bash ksh sh5; do
12795          case $as_dir in
12796          /*)
12797            if ("$as_dir/$as_base" -c '
12798   as_lineno_1=$LINENO
12799   as_lineno_2=$LINENO
12800   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12801   test "x$as_lineno_1" != "x$as_lineno_2" &&
12802   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12803              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12804              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12805              CONFIG_SHELL=$as_dir/$as_base
12806              export CONFIG_SHELL
12807              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12808            fi;;
12809          esac
12810        done
12811 done
12812 ;;
12813   esac
12814
12815   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12816   # uniformly replaced by the line number.  The first 'sed' inserts a
12817   # line-number line before each line; the second 'sed' does the real
12818   # work.  The second script uses 'N' to pair each line-number line
12819   # with the numbered line, and appends trailing '-' during
12820   # substitution so that $LINENO is not a special case at line end.
12821   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12822   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12823   sed '=' <$as_myself |
12824     sed '
12825       N
12826       s,$,-,
12827       : loop
12828       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12829       t loop
12830       s,-$,,
12831       s,^['$as_cr_digits']*\n,,
12832     ' >$as_me.lineno &&
12833   chmod +x $as_me.lineno ||
12834     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12835 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12836    { (exit 1); exit 1; }; }
12837
12838   # Don't try to exec as it changes $[0], causing all sort of problems
12839   # (the dirname of $[0] is not the place where we might find the
12840   # original and so on.  Autoconf is especially sensible to this).
12841   . ./$as_me.lineno
12842   # Exit status is that of the last command.
12843   exit
12844 }
12845
12846
12847 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12848   *c*,-n*) ECHO_N= ECHO_C='
12849 ' ECHO_T='      ' ;;
12850   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12851   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12852 esac
12853
12854 if expr a : '\(a\)' >/dev/null 2>&1; then
12855   as_expr=expr
12856 else
12857   as_expr=false
12858 fi
12859
12860 rm -f conf$$ conf$$.exe conf$$.file
12861 echo >conf$$.file
12862 if ln -s conf$$.file conf$$ 2>/dev/null; then
12863   # We could just check for DJGPP; but this test a) works b) is more generic
12864   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12865   if test -f conf$$.exe; then
12866     # Don't use ln at all; we don't have any links
12867     as_ln_s='cp -p'
12868   else
12869     as_ln_s='ln -s'
12870   fi
12871 elif ln conf$$.file conf$$ 2>/dev/null; then
12872   as_ln_s=ln
12873 else
12874   as_ln_s='cp -p'
12875 fi
12876 rm -f conf$$ conf$$.exe conf$$.file
12877
12878 if mkdir -p . 2>/dev/null; then
12879   as_mkdir_p=:
12880 else
12881   test -d ./-p && rmdir ./-p
12882   as_mkdir_p=false
12883 fi
12884
12885 as_executable_p="test -f"
12886
12887 # Sed expression to map a string onto a valid CPP name.
12888 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12889
12890 # Sed expression to map a string onto a valid variable name.
12891 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12892
12893
12894 # IFS
12895 # We need space, tab and new line, in precisely that order.
12896 as_nl='
12897 '
12898 IFS="   $as_nl"
12899
12900 # CDPATH.
12901 $as_unset CDPATH
12902
12903 exec 6>&1
12904
12905 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12906 # report actual input values of CONFIG_FILES etc. instead of their
12907 # values after options handling.  Logging --version etc. is OK.
12908 exec 5>>config.log
12909 {
12910   echo
12911   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12912 ## Running $as_me. ##
12913 _ASBOX
12914 } >&5
12915 cat >&5 <<_CSEOF
12916
12917 This file was extended by $as_me, which was
12918 generated by GNU Autoconf 2.59.  Invocation command line was
12919
12920   CONFIG_FILES    = $CONFIG_FILES
12921   CONFIG_HEADERS  = $CONFIG_HEADERS
12922   CONFIG_LINKS    = $CONFIG_LINKS
12923   CONFIG_COMMANDS = $CONFIG_COMMANDS
12924   $ $0 $@
12925
12926 _CSEOF
12927 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12928 echo >&5
12929 _ACEOF
12930
12931 # Files that config.status was made for.
12932 if test -n "$ac_config_files"; then
12933   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12934 fi
12935
12936 if test -n "$ac_config_headers"; then
12937   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12938 fi
12939
12940 if test -n "$ac_config_links"; then
12941   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12942 fi
12943
12944 if test -n "$ac_config_commands"; then
12945   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12946 fi
12947
12948 cat >>$CONFIG_STATUS <<\_ACEOF
12949
12950 ac_cs_usage="\
12951 \`$as_me' instantiates files from templates according to the
12952 current configuration.
12953
12954 Usage: $0 [OPTIONS] [FILE]...
12955
12956   -h, --help       print this help, then exit
12957   -V, --version    print version number, then exit
12958   -q, --quiet      do not print progress messages
12959   -d, --debug      don't remove temporary files
12960       --recheck    update $as_me by reconfiguring in the same conditions
12961   --file=FILE[:TEMPLATE]
12962                    instantiate the configuration file FILE
12963
12964 Configuration files:
12965 $config_files
12966
12967 Report bugs to <bug-autoconf@gnu.org>."
12968 _ACEOF
12969
12970 cat >>$CONFIG_STATUS <<_ACEOF
12971 ac_cs_version="\\
12972 config.status
12973 configured by $0, generated by GNU Autoconf 2.59,
12974   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12975
12976 Copyright (C) 2003 Free Software Foundation, Inc.
12977 This config.status script is free software; the Free Software Foundation
12978 gives unlimited permission to copy, distribute and modify it."
12979 srcdir=$srcdir
12980 INSTALL="$INSTALL"
12981 _ACEOF
12982
12983 cat >>$CONFIG_STATUS <<\_ACEOF
12984 # If no file are specified by the user, then we need to provide default
12985 # value.  By we need to know if files were specified by the user.
12986 ac_need_defaults=:
12987 while test $# != 0
12988 do
12989   case $1 in
12990   --*=*)
12991     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12992     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12993     ac_shift=:
12994     ;;
12995   -*)
12996     ac_option=$1
12997     ac_optarg=$2
12998     ac_shift=shift
12999     ;;
13000   *) # This is not an option, so the user has probably given explicit
13001      # arguments.
13002      ac_option=$1
13003      ac_need_defaults=false;;
13004   esac
13005
13006   case $ac_option in
13007   # Handling of the options.
13008 _ACEOF
13009 cat >>$CONFIG_STATUS <<\_ACEOF
13010   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13011     ac_cs_recheck=: ;;
13012   --version | --vers* | -V )
13013     echo "$ac_cs_version"; exit 0 ;;
13014   --he | --h)
13015     # Conflict between --help and --header
13016     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13017 Try \`$0 --help' for more information." >&5
13018 echo "$as_me: error: ambiguous option: $1
13019 Try \`$0 --help' for more information." >&2;}
13020    { (exit 1); exit 1; }; };;
13021   --help | --hel | -h )
13022     echo "$ac_cs_usage"; exit 0 ;;
13023   --debug | --d* | -d )
13024     debug=: ;;
13025   --file | --fil | --fi | --f )
13026     $ac_shift
13027     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13028     ac_need_defaults=false;;
13029   --header | --heade | --head | --hea )
13030     $ac_shift
13031     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13032     ac_need_defaults=false;;
13033   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13034   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13035     ac_cs_silent=: ;;
13036
13037   # This is an error.
13038   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13039 Try \`$0 --help' for more information." >&5
13040 echo "$as_me: error: unrecognized option: $1
13041 Try \`$0 --help' for more information." >&2;}
13042    { (exit 1); exit 1; }; } ;;
13043
13044   *) ac_config_targets="$ac_config_targets $1" ;;
13045
13046   esac
13047   shift
13048 done
13049
13050 ac_configure_extra_args=
13051
13052 if $ac_cs_silent; then
13053   exec 6>/dev/null
13054   ac_configure_extra_args="$ac_configure_extra_args --silent"
13055 fi
13056
13057 _ACEOF
13058 cat >>$CONFIG_STATUS <<_ACEOF
13059 if \$ac_cs_recheck; then
13060   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13061   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13062 fi
13063
13064 _ACEOF
13065
13066
13067
13068
13069
13070 cat >>$CONFIG_STATUS <<\_ACEOF
13071 for ac_config_target in $ac_config_targets
13072 do
13073   case "$ac_config_target" in
13074   # Handling of arguments.
13075   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13076   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13077 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13078    { (exit 1); exit 1; }; };;
13079   esac
13080 done
13081
13082 # If the user did not use the arguments to specify the items to instantiate,
13083 # then the envvar interface is used.  Set only those that are not.
13084 # We use the long form for the default assignment because of an extremely
13085 # bizarre bug on SunOS 4.1.3.
13086 if $ac_need_defaults; then
13087   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13088 fi
13089
13090 # Have a temporary directory for convenience.  Make it in the build tree
13091 # simply because there is no reason to put it here, and in addition,
13092 # creating and moving files from /tmp can sometimes cause problems.
13093 # Create a temporary directory, and hook for its removal unless debugging.
13094 $debug ||
13095 {
13096   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13097   trap '{ (exit 1); exit 1; }' 1 2 13 15
13098 }
13099
13100 # Create a (secure) tmp directory for tmp files.
13101
13102 {
13103   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13104   test -n "$tmp" && test -d "$tmp"
13105 }  ||
13106 {
13107   tmp=./confstat$$-$RANDOM
13108   (umask 077 && mkdir $tmp)
13109 } ||
13110 {
13111    echo "$me: cannot create a temporary directory in ." >&2
13112    { (exit 1); exit 1; }
13113 }
13114
13115 _ACEOF
13116
13117 cat >>$CONFIG_STATUS <<_ACEOF
13118
13119 #
13120 # CONFIG_FILES section.
13121 #
13122
13123 # No need to generate the scripts if there are no CONFIG_FILES.
13124 # This happens for instance when ./config.status config.h
13125 if test -n "\$CONFIG_FILES"; then
13126   # Protect against being on the right side of a sed subst in config.status.
13127   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13128    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13129 s,@SHELL@,$SHELL,;t t
13130 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13131 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13132 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13133 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13134 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13135 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13136 s,@exec_prefix@,$exec_prefix,;t t
13137 s,@prefix@,$prefix,;t t
13138 s,@program_transform_name@,$program_transform_name,;t t
13139 s,@bindir@,$bindir,;t t
13140 s,@sbindir@,$sbindir,;t t
13141 s,@libexecdir@,$libexecdir,;t t
13142 s,@datadir@,$datadir,;t t
13143 s,@sysconfdir@,$sysconfdir,;t t
13144 s,@sharedstatedir@,$sharedstatedir,;t t
13145 s,@localstatedir@,$localstatedir,;t t
13146 s,@libdir@,$libdir,;t t
13147 s,@includedir@,$includedir,;t t
13148 s,@oldincludedir@,$oldincludedir,;t t
13149 s,@infodir@,$infodir,;t t
13150 s,@mandir@,$mandir,;t t
13151 s,@build_alias@,$build_alias,;t t
13152 s,@host_alias@,$host_alias,;t t
13153 s,@target_alias@,$target_alias,;t t
13154 s,@DEFS@,$DEFS,;t t
13155 s,@ECHO_C@,$ECHO_C,;t t
13156 s,@ECHO_N@,$ECHO_N,;t t
13157 s,@ECHO_T@,$ECHO_T,;t t
13158 s,@LIBS@,$LIBS,;t t
13159 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13160 s,@build@,$build,;t t
13161 s,@build_cpu@,$build_cpu,;t t
13162 s,@build_vendor@,$build_vendor,;t t
13163 s,@build_os@,$build_os,;t t
13164 s,@build_noncanonical@,$build_noncanonical,;t t
13165 s,@host_noncanonical@,$host_noncanonical,;t t
13166 s,@target_noncanonical@,$target_noncanonical,;t t
13167 s,@host@,$host,;t t
13168 s,@host_cpu@,$host_cpu,;t t
13169 s,@host_vendor@,$host_vendor,;t t
13170 s,@host_os@,$host_os,;t t
13171 s,@target@,$target,;t t
13172 s,@target_cpu@,$target_cpu,;t t
13173 s,@target_vendor@,$target_vendor,;t t
13174 s,@target_os@,$target_os,;t t
13175 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13176 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13177 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13178 s,@LN@,$LN,;t t
13179 s,@LN_S@,$LN_S,;t t
13180 s,@build_libsubdir@,$build_libsubdir,;t t
13181 s,@build_subdir@,$build_subdir,;t t
13182 s,@host_subdir@,$host_subdir,;t t
13183 s,@target_subdir@,$target_subdir,;t t
13184 s,@CC@,$CC,;t t
13185 s,@CFLAGS@,$CFLAGS,;t t
13186 s,@LDFLAGS@,$LDFLAGS,;t t
13187 s,@CPPFLAGS@,$CPPFLAGS,;t t
13188 s,@ac_ct_CC@,$ac_ct_CC,;t t
13189 s,@EXEEXT@,$EXEEXT,;t t
13190 s,@OBJEXT@,$OBJEXT,;t t
13191 s,@CXX@,$CXX,;t t
13192 s,@CXXFLAGS@,$CXXFLAGS,;t t
13193 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13194 s,@GNATBIND@,$GNATBIND,;t t
13195 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13196 s,@GNATMAKE@,$GNATMAKE,;t t
13197 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13198 s,@do_compare@,$do_compare,;t t
13199 s,@gmplibs@,$gmplibs,;t t
13200 s,@gmpinc@,$gmpinc,;t t
13201 s,@ppllibs@,$ppllibs,;t t
13202 s,@pplinc@,$pplinc,;t t
13203 s,@clooglibs@,$clooglibs,;t t
13204 s,@clooginc@,$clooginc,;t t
13205 s,@stage1_languages@,$stage1_languages,;t t
13206 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13207 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13208 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13209 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13210 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13211 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13212 s,@tooldir@,$tooldir,;t t
13213 s,@build_tooldir@,$build_tooldir,;t t
13214 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13215 s,@GDB_TK@,$GDB_TK,;t t
13216 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13217 s,@build_configargs@,$build_configargs,;t t
13218 s,@build_configdirs@,$build_configdirs,;t t
13219 s,@host_configargs@,$host_configargs,;t t
13220 s,@configdirs@,$configdirs,;t t
13221 s,@target_configargs@,$target_configargs,;t t
13222 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13223 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13224 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13225 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13226 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13227 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13228 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13229 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13230 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13231 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13232 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13233 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13234 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13235 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13236 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13237 s,@config_shell@,$config_shell,;t t
13238 s,@YACC@,$YACC,;t t
13239 s,@BISON@,$BISON,;t t
13240 s,@M4@,$M4,;t t
13241 s,@LEX@,$LEX,;t t
13242 s,@FLEX@,$FLEX,;t t
13243 s,@MAKEINFO@,$MAKEINFO,;t t
13244 s,@EXPECT@,$EXPECT,;t t
13245 s,@RUNTEST@,$RUNTEST,;t t
13246 s,@AR@,$AR,;t t
13247 s,@AS@,$AS,;t t
13248 s,@DLLTOOL@,$DLLTOOL,;t t
13249 s,@LD@,$LD,;t t
13250 s,@LIPO@,$LIPO,;t t
13251 s,@NM@,$NM,;t t
13252 s,@RANLIB@,$RANLIB,;t t
13253 s,@STRIP@,$STRIP,;t t
13254 s,@WINDRES@,$WINDRES,;t t
13255 s,@WINDMC@,$WINDMC,;t t
13256 s,@OBJCOPY@,$OBJCOPY,;t t
13257 s,@OBJDUMP@,$OBJDUMP,;t t
13258 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13259 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13260 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13261 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13262 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13263 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13264 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13265 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13266 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13267 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13268 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13269 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13270 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13271 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13272 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13273 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13274 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13275 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13276 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13277 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13278 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13279 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13280 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13281 s,@MAINT@,$MAINT,;t t
13282 s,@stage1_cflags@,$stage1_cflags,;t t
13283 s,@stage1_checking@,$stage1_checking,;t t
13284 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13285 s,@datarootdir@,$datarootdir,;t t
13286 s,@docdir@,$docdir,;t t
13287 s,@pdfdir@,$pdfdir,;t t
13288 s,@htmldir@,$htmldir,;t t
13289 s,@LIBOBJS@,$LIBOBJS,;t t
13290 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13291 /@serialization_dependencies@/r $serialization_dependencies
13292 s,@serialization_dependencies@,,;t t
13293 /@host_makefile_frag@/r $host_makefile_frag
13294 s,@host_makefile_frag@,,;t t
13295 /@target_makefile_frag@/r $target_makefile_frag
13296 s,@target_makefile_frag@,,;t t
13297 /@alphaieee_frag@/r $alphaieee_frag
13298 s,@alphaieee_frag@,,;t t
13299 /@ospace_frag@/r $ospace_frag
13300 s,@ospace_frag@,,;t t
13301 CEOF
13302
13303 _ACEOF
13304
13305   cat >>$CONFIG_STATUS <<\_ACEOF
13306   # Split the substitutions into bite-sized pieces for seds with
13307   # small command number limits, like on Digital OSF/1 and HP-UX.
13308   ac_max_sed_lines=48
13309   ac_sed_frag=1 # Number of current file.
13310   ac_beg=1 # First line for current file.
13311   ac_end=$ac_max_sed_lines # Line after last line for current file.
13312   ac_more_lines=:
13313   ac_sed_cmds=
13314   while $ac_more_lines; do
13315     if test $ac_beg -gt 1; then
13316       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13317     else
13318       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13319     fi
13320     if test ! -s $tmp/subs.frag; then
13321       ac_more_lines=false
13322     else
13323       # The purpose of the label and of the branching condition is to
13324       # speed up the sed processing (if there are no `@' at all, there
13325       # is no need to browse any of the substitutions).
13326       # These are the two extra sed commands mentioned above.
13327       (echo ':t
13328   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13329       if test -z "$ac_sed_cmds"; then
13330         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13331       else
13332         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13333       fi
13334       ac_sed_frag=`expr $ac_sed_frag + 1`
13335       ac_beg=$ac_end
13336       ac_end=`expr $ac_end + $ac_max_sed_lines`
13337     fi
13338   done
13339   if test -z "$ac_sed_cmds"; then
13340     ac_sed_cmds=cat
13341   fi
13342 fi # test -n "$CONFIG_FILES"
13343
13344 _ACEOF
13345 cat >>$CONFIG_STATUS <<\_ACEOF
13346 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13347   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13348   case $ac_file in
13349   - | *:- | *:-:* ) # input from stdin
13350         cat >$tmp/stdin
13351         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13352         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13353   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13354         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13355   * )   ac_file_in=$ac_file.in ;;
13356   esac
13357
13358   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13359   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13360 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13361          X"$ac_file" : 'X\(//\)[^/]' \| \
13362          X"$ac_file" : 'X\(//\)$' \| \
13363          X"$ac_file" : 'X\(/\)' \| \
13364          .     : '\(.\)' 2>/dev/null ||
13365 echo X"$ac_file" |
13366     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13367           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13368           /^X\(\/\/\)$/{ s//\1/; q; }
13369           /^X\(\/\).*/{ s//\1/; q; }
13370           s/.*/./; q'`
13371   { if $as_mkdir_p; then
13372     mkdir -p "$ac_dir"
13373   else
13374     as_dir="$ac_dir"
13375     as_dirs=
13376     while test ! -d "$as_dir"; do
13377       as_dirs="$as_dir $as_dirs"
13378       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13379 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13380          X"$as_dir" : 'X\(//\)[^/]' \| \
13381          X"$as_dir" : 'X\(//\)$' \| \
13382          X"$as_dir" : 'X\(/\)' \| \
13383          .     : '\(.\)' 2>/dev/null ||
13384 echo X"$as_dir" |
13385     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13386           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13387           /^X\(\/\/\)$/{ s//\1/; q; }
13388           /^X\(\/\).*/{ s//\1/; q; }
13389           s/.*/./; q'`
13390     done
13391     test ! -n "$as_dirs" || mkdir $as_dirs
13392   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13393 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13394    { (exit 1); exit 1; }; }; }
13395
13396   ac_builddir=.
13397
13398 if test "$ac_dir" != .; then
13399   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13400   # A "../" for each directory in $ac_dir_suffix.
13401   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13402 else
13403   ac_dir_suffix= ac_top_builddir=
13404 fi
13405
13406 case $srcdir in
13407   .)  # No --srcdir option.  We are building in place.
13408     ac_srcdir=.
13409     if test -z "$ac_top_builddir"; then
13410        ac_top_srcdir=.
13411     else
13412        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13413     fi ;;
13414   [\\/]* | ?:[\\/]* )  # Absolute path.
13415     ac_srcdir=$srcdir$ac_dir_suffix;
13416     ac_top_srcdir=$srcdir ;;
13417   *) # Relative path.
13418     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13419     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13420 esac
13421
13422 # Do not use `cd foo && pwd` to compute absolute paths, because
13423 # the directories may not exist.
13424 case `pwd` in
13425 .) ac_abs_builddir="$ac_dir";;
13426 *)
13427   case "$ac_dir" in
13428   .) ac_abs_builddir=`pwd`;;
13429   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13430   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13431   esac;;
13432 esac
13433 case $ac_abs_builddir in
13434 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13435 *)
13436   case ${ac_top_builddir}. in
13437   .) ac_abs_top_builddir=$ac_abs_builddir;;
13438   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13439   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13440   esac;;
13441 esac
13442 case $ac_abs_builddir in
13443 .) ac_abs_srcdir=$ac_srcdir;;
13444 *)
13445   case $ac_srcdir in
13446   .) ac_abs_srcdir=$ac_abs_builddir;;
13447   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13448   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13449   esac;;
13450 esac
13451 case $ac_abs_builddir in
13452 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13453 *)
13454   case $ac_top_srcdir in
13455   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13456   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13457   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13458   esac;;
13459 esac
13460
13461
13462   case $INSTALL in
13463   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13464   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13465   esac
13466
13467   if test x"$ac_file" != x-; then
13468     { echo "$as_me:$LINENO: creating $ac_file" >&5
13469 echo "$as_me: creating $ac_file" >&6;}
13470     rm -f "$ac_file"
13471   fi
13472   # Let's still pretend it is `configure' which instantiates (i.e., don't
13473   # use $as_me), people would be surprised to read:
13474   #    /* config.h.  Generated by config.status.  */
13475   if test x"$ac_file" = x-; then
13476     configure_input=
13477   else
13478     configure_input="$ac_file.  "
13479   fi
13480   configure_input=$configure_input"Generated from `echo $ac_file_in |
13481                                      sed 's,.*/,,'` by configure."
13482
13483   # First look for the input files in the build tree, otherwise in the
13484   # src tree.
13485   ac_file_inputs=`IFS=:
13486     for f in $ac_file_in; do
13487       case $f in
13488       -) echo $tmp/stdin ;;
13489       [\\/$]*)
13490          # Absolute (can't be DOS-style, as IFS=:)
13491          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13492 echo "$as_me: error: cannot find input file: $f" >&2;}
13493    { (exit 1); exit 1; }; }
13494          echo "$f";;
13495       *) # Relative
13496          if test -f "$f"; then
13497            # Build tree
13498            echo "$f"
13499          elif test -f "$srcdir/$f"; then
13500            # Source tree
13501            echo "$srcdir/$f"
13502          else
13503            # /dev/null tree
13504            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13505 echo "$as_me: error: cannot find input file: $f" >&2;}
13506    { (exit 1); exit 1; }; }
13507          fi;;
13508       esac
13509     done` || { (exit 1); exit 1; }
13510 _ACEOF
13511 cat >>$CONFIG_STATUS <<_ACEOF
13512   sed "$ac_vpsub
13513 $extrasub
13514 _ACEOF
13515 cat >>$CONFIG_STATUS <<\_ACEOF
13516 :t
13517 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13518 s,@configure_input@,$configure_input,;t t
13519 s,@srcdir@,$ac_srcdir,;t t
13520 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13521 s,@top_srcdir@,$ac_top_srcdir,;t t
13522 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13523 s,@builddir@,$ac_builddir,;t t
13524 s,@abs_builddir@,$ac_abs_builddir,;t t
13525 s,@top_builddir@,$ac_top_builddir,;t t
13526 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13527 s,@INSTALL@,$ac_INSTALL,;t t
13528 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13529   rm -f $tmp/stdin
13530   if test x"$ac_file" != x-; then
13531     mv $tmp/out $ac_file
13532   else
13533     cat $tmp/out
13534     rm -f $tmp/out
13535   fi
13536
13537 done
13538 _ACEOF
13539
13540 cat >>$CONFIG_STATUS <<\_ACEOF
13541
13542 { (exit 0); exit 0; }
13543 _ACEOF
13544 chmod +x $CONFIG_STATUS
13545 ac_clean_files=$ac_clean_files_save
13546
13547
13548 # configure is writing to config.log, and then calls config.status.
13549 # config.status does its own redirection, appending to config.log.
13550 # Unfortunately, on DOS this fails, as config.log is still kept open
13551 # by configure, so config.status won't be able to write to it; its
13552 # output is simply discarded.  So we exec the FD to /dev/null,
13553 # effectively closing config.log, so it can be properly (re)opened and
13554 # appended to by config.status.  When coming back to configure, we
13555 # need to make the FD available again.
13556 if test "$no_create" != yes; then
13557   ac_cs_success=:
13558   ac_config_status_args=
13559   test "$silent" = yes &&
13560     ac_config_status_args="$ac_config_status_args --quiet"
13561   exec 5>/dev/null
13562   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13563   exec 5>>config.log
13564   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13565   # would make configure fail if this is the last instruction.
13566   $ac_cs_success || { (exit 1); exit 1; }
13567 fi
13568