configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S TOPLEVEL_CONFIGURE_ARGUMENTS build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc stage1_languages SYSROOT_CFLAGS_FOR_TARGET RPATH_ENVVAR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs CC_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES OBJCOPY OBJDUMP CFLAGS_FOR_BUILD CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277
 278 # Initialize some variables set by options.
 279 ac_init_help=
 280 ac_init_version=false
 281 # The variables have the same names as the options, with
 282 # dashes changed to underlines.
 283 cache_file=/dev/null
 284 exec_prefix=NONE
 285 no_create=
 286 no_recursion=
 287 prefix=NONE
 288 program_prefix=NONE
 289 program_suffix=NONE
 290 program_transform_name=s,x,x,
 291 silent=
 292 site=
 293 srcdir=
 294 verbose=
 295 x_includes=NONE
 296 x_libraries=NONE
 297
 298 # Installation directory options.
 299 # These are left unexpanded so users can "make install exec_prefix=/foo"
 300 # and all the variables that are supposed to be based on exec_prefix
 301 # by default will actually change.
 302 # Use braces instead of parens because sh, perl, etc. also accept them.
 303 bindir='${exec_prefix}/bin'
 304 sbindir='${exec_prefix}/sbin'
 305 libexecdir='${exec_prefix}/libexec'
 306 datadir='${prefix}/share'
 307 sysconfdir='${prefix}/etc'
 308 sharedstatedir='${prefix}/com'
 309 localstatedir='${prefix}/var'
 310 libdir='${exec_prefix}/lib'
 311 includedir='${prefix}/include'
 312 oldincludedir='/usr/include'
 313 infodir='${prefix}/info'
 314 mandir='${prefix}/man'
 315
 316 ac_prev=
 317 for ac_option
 318 do
 319   # If the previous option needs an argument, assign it.
 320   if test -n "$ac_prev"; then
 321     eval "$ac_prev=\$ac_option"
 322     ac_prev=
 323     continue
 324   fi
 325
 326   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 327
 328   # Accept the important Cygnus configure options, so we can diagnose typos.
 329
 330   case $ac_option in
 331
 332   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 333     ac_prev=bindir ;;
 334   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 335     bindir=$ac_optarg ;;
 336
 337   -build | --build | --buil | --bui | --bu)
 338     ac_prev=build_alias ;;
 339   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 340     build_alias=$ac_optarg ;;
 341
 342   -cache-file | --cache-file | --cache-fil | --cache-fi \
 343   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 344     ac_prev=cache_file ;;
 345   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 346   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 347     cache_file=$ac_optarg ;;
 348
 349   --config-cache | -C)
 350     cache_file=config.cache ;;
 351
 352   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 353     ac_prev=datadir ;;
 354   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 355   | --da=*)
 356     datadir=$ac_optarg ;;
 357
 358   -disable-* | --disable-*)
 359     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 360     # Reject names that are not valid shell variable names.
 361     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 362       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 363    { (exit 1); exit 1; }; }
 364     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 365     eval "enable_$ac_feature=no" ;;
 366
 367   -enable-* | --enable-*)
 368     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 369     # Reject names that are not valid shell variable names.
 370     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 371       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 372    { (exit 1); exit 1; }; }
 373     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 374     case $ac_option in
 375       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 376       *) ac_optarg=yes ;;
 377     esac
 378     eval "enable_$ac_feature='$ac_optarg'" ;;
 379
 380   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 381   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 382   | --exec | --exe | --ex)
 383     ac_prev=exec_prefix ;;
 384   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 385   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 386   | --exec=* | --exe=* | --ex=*)
 387     exec_prefix=$ac_optarg ;;
 388
 389   -gas | --gas | --ga | --g)
 390     # Obsolete; use --with-gas.
 391     with_gas=yes ;;
 392
 393   -help | --help | --hel | --he | -h)
 394     ac_init_help=long ;;
 395   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 396     ac_init_help=recursive ;;
 397   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 398     ac_init_help=short ;;
 399
 400   -host | --host | --hos | --ho)
 401     ac_prev=host_alias ;;
 402   -host=* | --host=* | --hos=* | --ho=*)
 403     host_alias=$ac_optarg ;;
 404
 405   -includedir | --includedir | --includedi | --included | --include \
 406   | --includ | --inclu | --incl | --inc)
 407     ac_prev=includedir ;;
 408   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 409   | --includ=* | --inclu=* | --incl=* | --inc=*)
 410     includedir=$ac_optarg ;;
 411
 412   -infodir | --infodir | --infodi | --infod | --info | --inf)
 413     ac_prev=infodir ;;
 414   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 415     infodir=$ac_optarg ;;
 416
 417   -libdir | --libdir | --libdi | --libd)
 418     ac_prev=libdir ;;
 419   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 420     libdir=$ac_optarg ;;
 421
 422   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 423   | --libexe | --libex | --libe)
 424     ac_prev=libexecdir ;;
 425   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 426   | --libexe=* | --libex=* | --libe=*)
 427     libexecdir=$ac_optarg ;;
 428
 429   -localstatedir | --localstatedir | --localstatedi | --localstated \
 430   | --localstate | --localstat | --localsta | --localst \
 431   | --locals | --local | --loca | --loc | --lo)
 432     ac_prev=localstatedir ;;
 433   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 434   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 435   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 436     localstatedir=$ac_optarg ;;
 437
 438   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 439     ac_prev=mandir ;;
 440   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 441     mandir=$ac_optarg ;;
 442
 443   -nfp | --nfp | --nf)
 444     # Obsolete; use --without-fp.
 445     with_fp=no ;;
 446
 447   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 448   | --no-cr | --no-c | -n)
 449     no_create=yes ;;
 450
 451   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 452   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 453     no_recursion=yes ;;
 454
 455   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 456   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 457   | --oldin | --oldi | --old | --ol | --o)
 458     ac_prev=oldincludedir ;;
 459   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 460   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 461   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 462     oldincludedir=$ac_optarg ;;
 463
 464   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 465     ac_prev=prefix ;;
 466   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 467     prefix=$ac_optarg ;;
 468
 469   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 470   | --program-pre | --program-pr | --program-p)
 471     ac_prev=program_prefix ;;
 472   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 473   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 474     program_prefix=$ac_optarg ;;
 475
 476   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 477   | --program-suf | --program-su | --program-s)
 478     ac_prev=program_suffix ;;
 479   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 480   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 481     program_suffix=$ac_optarg ;;
 482
 483   -program-transform-name | --program-transform-name \
 484   | --program-transform-nam | --program-transform-na \
 485   | --program-transform-n | --program-transform- \
 486   | --program-transform | --program-transfor \
 487   | --program-transfo | --program-transf \
 488   | --program-trans | --program-tran \
 489   | --progr-tra | --program-tr | --program-t)
 490     ac_prev=program_transform_name ;;
 491   -program-transform-name=* | --program-transform-name=* \
 492   | --program-transform-nam=* | --program-transform-na=* \
 493   | --program-transform-n=* | --program-transform-=* \
 494   | --program-transform=* | --program-transfor=* \
 495   | --program-transfo=* | --program-transf=* \
 496   | --program-trans=* | --program-tran=* \
 497   | --progr-tra=* | --program-tr=* | --program-t=*)
 498     program_transform_name=$ac_optarg ;;
 499
 500   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 501   | -silent | --silent | --silen | --sile | --sil)
 502     silent=yes ;;
 503
 504   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 505     ac_prev=sbindir ;;
 506   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 507   | --sbi=* | --sb=*)
 508     sbindir=$ac_optarg ;;
 509
 510   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 511   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 512   | --sharedst | --shareds | --shared | --share | --shar \
 513   | --sha | --sh)
 514     ac_prev=sharedstatedir ;;
 515   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 516   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 517   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 518   | --sha=* | --sh=*)
 519     sharedstatedir=$ac_optarg ;;
 520
 521   -site | --site | --sit)
 522     ac_prev=site ;;
 523   -site=* | --site=* | --sit=*)
 524     site=$ac_optarg ;;
 525
 526   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 527     ac_prev=srcdir ;;
 528   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 529     srcdir=$ac_optarg ;;
 530
 531   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 532   | --syscon | --sysco | --sysc | --sys | --sy)
 533     ac_prev=sysconfdir ;;
 534   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 535   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 536     sysconfdir=$ac_optarg ;;
 537
 538   -target | --target | --targe | --targ | --tar | --ta | --t)
 539     ac_prev=target_alias ;;
 540   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 541     target_alias=$ac_optarg ;;
 542
 543   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 544     verbose=yes ;;
 545
 546   -version | --version | --versio | --versi | --vers | -V)
 547     ac_init_version=: ;;
 548
 549   -with-* | --with-*)
 550     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 551     # Reject names that are not valid shell variable names.
 552     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 553       { echo "$as_me: error: invalid package name: $ac_package" >&2
 554    { (exit 1); exit 1; }; }
 555     ac_package=`echo $ac_package| sed 's/-/_/g'`
 556     case $ac_option in
 557       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 558       *) ac_optarg=yes ;;
 559     esac
 560     eval "with_$ac_package='$ac_optarg'" ;;
 561
 562   -without-* | --without-*)
 563     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 564     # Reject names that are not valid shell variable names.
 565     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 566       { echo "$as_me: error: invalid package name: $ac_package" >&2
 567    { (exit 1); exit 1; }; }
 568     ac_package=`echo $ac_package | sed 's/-/_/g'`
 569     eval "with_$ac_package=no" ;;
 570
 571   --x)
 572     # Obsolete; use --with-x.
 573     with_x=yes ;;
 574
 575   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 576   | --x-incl | --x-inc | --x-in | --x-i)
 577     ac_prev=x_includes ;;
 578   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 579   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 580     x_includes=$ac_optarg ;;
 581
 582   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 583   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 584     ac_prev=x_libraries ;;
 585   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 586   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 587     x_libraries=$ac_optarg ;;
 588
 589   -*) { echo "$as_me: error: unrecognized option: $ac_option
 590 Try \`$0 --help' for more information." >&2
 591    { (exit 1); exit 1; }; }
 592     ;;
 593
 594   *=*)
 595     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 596     # Reject names that are not valid shell variable names.
 597     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 598       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 599    { (exit 1); exit 1; }; }
 600     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 601     eval "$ac_envvar='$ac_optarg'"
 602     export $ac_envvar ;;
 603
 604   *)
 605     # FIXME: should be removed in autoconf 3.0.
 606     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 607     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 608       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 609     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 610     ;;
 611
 612   esac
 613 done
 614
 615 if test -n "$ac_prev"; then
 616   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 617   { echo "$as_me: error: missing argument to $ac_option" >&2
 618    { (exit 1); exit 1; }; }
 619 fi
 620
 621 # Be sure to have absolute paths.
 622 for ac_var in exec_prefix prefix
 623 do
 624   eval ac_val=$`echo $ac_var`
 625   case $ac_val in
 626     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 627     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 628    { (exit 1); exit 1; }; };;
 629   esac
 630 done
 631
 632 # Be sure to have absolute paths.
 633 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 634               localstatedir libdir includedir oldincludedir infodir mandir
 635 do
 636   eval ac_val=$`echo $ac_var`
 637   case $ac_val in
 638     [\\/$]* | ?:[\\/]* ) ;;
 639     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 640    { (exit 1); exit 1; }; };;
 641   esac
 642 done
 643
 644 # There might be people who depend on the old broken behavior: `$host'
 645 # used to hold the argument of --host etc.
 646 # FIXME: To remove some day.
 647 build=$build_alias
 648 host=$host_alias
 649 target=$target_alias
 650
 651 # FIXME: To remove some day.
 652 if test "x$host_alias" != x; then
 653   if test "x$build_alias" = x; then
 654     cross_compiling=maybe
 655     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 656     If a cross compiler is detected then cross compile mode will be used." >&2
 657   elif test "x$build_alias" != "x$host_alias"; then
 658     cross_compiling=yes
 659   fi
 660 fi
 661
 662 ac_tool_prefix=
 663 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 664
 665 test "$silent" = yes && exec 6>/dev/null
 666
 667
 668 # Find the source files, if location was not specified.
 669 if test -z "$srcdir"; then
 670   ac_srcdir_defaulted=yes
 671   # Try the directory containing this script, then its parent.
 672   ac_confdir=`(dirname "$0") 2>/dev/null ||
 673 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 674          X"$0" : 'X\(//\)[^/]' \| \
 675          X"$0" : 'X\(//\)$' \| \
 676          X"$0" : 'X\(/\)' \| \
 677          .     : '\(.\)' 2>/dev/null ||
 678 echo X"$0" |
 679     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 680           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 681           /^X\(\/\/\)$/{ s//\1/; q; }
 682           /^X\(\/\).*/{ s//\1/; q; }
 683           s/.*/./; q'`
 684   srcdir=$ac_confdir
 685   if test ! -r $srcdir/$ac_unique_file; then
 686     srcdir=..
 687   fi
 688 else
 689   ac_srcdir_defaulted=no
 690 fi
 691 if test ! -r $srcdir/$ac_unique_file; then
 692   if test "$ac_srcdir_defaulted" = yes; then
 693     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 694    { (exit 1); exit 1; }; }
 695   else
 696     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 697    { (exit 1); exit 1; }; }
 698   fi
 699 fi
 700 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 701   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 702    { (exit 1); exit 1; }; }
 703 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 704 ac_env_build_alias_set=${build_alias+set}
 705 ac_env_build_alias_value=$build_alias
 706 ac_cv_env_build_alias_set=${build_alias+set}
 707 ac_cv_env_build_alias_value=$build_alias
 708 ac_env_host_alias_set=${host_alias+set}
 709 ac_env_host_alias_value=$host_alias
 710 ac_cv_env_host_alias_set=${host_alias+set}
 711 ac_cv_env_host_alias_value=$host_alias
 712 ac_env_target_alias_set=${target_alias+set}
 713 ac_env_target_alias_value=$target_alias
 714 ac_cv_env_target_alias_set=${target_alias+set}
 715 ac_cv_env_target_alias_value=$target_alias
 716 ac_env_CC_set=${CC+set}
 717 ac_env_CC_value=$CC
 718 ac_cv_env_CC_set=${CC+set}
 719 ac_cv_env_CC_value=$CC
 720 ac_env_CFLAGS_set=${CFLAGS+set}
 721 ac_env_CFLAGS_value=$CFLAGS
 722 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 723 ac_cv_env_CFLAGS_value=$CFLAGS
 724 ac_env_LDFLAGS_set=${LDFLAGS+set}
 725 ac_env_LDFLAGS_value=$LDFLAGS
 726 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 727 ac_cv_env_LDFLAGS_value=$LDFLAGS
 728 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 729 ac_env_CPPFLAGS_value=$CPPFLAGS
 730 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 731 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 732 ac_env_CXX_set=${CXX+set}
 733 ac_env_CXX_value=$CXX
 734 ac_cv_env_CXX_set=${CXX+set}
 735 ac_cv_env_CXX_value=$CXX
 736 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 737 ac_env_CXXFLAGS_value=$CXXFLAGS
 738 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 739 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 740 ac_env_AR_set=${AR+set}
 741 ac_env_AR_value=$AR
 742 ac_cv_env_AR_set=${AR+set}
 743 ac_cv_env_AR_value=$AR
 744 ac_env_AS_set=${AS+set}
 745 ac_env_AS_value=$AS
 746 ac_cv_env_AS_set=${AS+set}
 747 ac_cv_env_AS_value=$AS
 748 ac_env_DLLTOOL_set=${DLLTOOL+set}
 749 ac_env_DLLTOOL_value=$DLLTOOL
 750 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 751 ac_cv_env_DLLTOOL_value=$DLLTOOL
 752 ac_env_LD_set=${LD+set}
 753 ac_env_LD_value=$LD
 754 ac_cv_env_LD_set=${LD+set}
 755 ac_cv_env_LD_value=$LD
 756 ac_env_LIPO_set=${LIPO+set}
 757 ac_env_LIPO_value=$LIPO
 758 ac_cv_env_LIPO_set=${LIPO+set}
 759 ac_cv_env_LIPO_value=$LIPO
 760 ac_env_NM_set=${NM+set}
 761 ac_env_NM_value=$NM
 762 ac_cv_env_NM_set=${NM+set}
 763 ac_cv_env_NM_value=$NM
 764 ac_env_RANLIB_set=${RANLIB+set}
 765 ac_env_RANLIB_value=$RANLIB
 766 ac_cv_env_RANLIB_set=${RANLIB+set}
 767 ac_cv_env_RANLIB_value=$RANLIB
 768 ac_env_STRIP_set=${STRIP+set}
 769 ac_env_STRIP_value=$STRIP
 770 ac_cv_env_STRIP_set=${STRIP+set}
 771 ac_cv_env_STRIP_value=$STRIP
 772 ac_env_WINDRES_set=${WINDRES+set}
 773 ac_env_WINDRES_value=$WINDRES
 774 ac_cv_env_WINDRES_set=${WINDRES+set}
 775 ac_cv_env_WINDRES_value=$WINDRES
 776 ac_env_OBJCOPY_set=${OBJCOPY+set}
 777 ac_env_OBJCOPY_value=$OBJCOPY
 778 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 779 ac_cv_env_OBJCOPY_value=$OBJCOPY
 780 ac_env_OBJDUMP_set=${OBJDUMP+set}
 781 ac_env_OBJDUMP_value=$OBJDUMP
 782 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 783 ac_cv_env_OBJDUMP_value=$OBJDUMP
 784 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 785 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 786 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 787 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 788 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 789 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 790 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 791 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 792 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 793 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 794 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 795 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 796 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 797 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 798 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 799 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 800 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 801 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 802 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 803 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 804 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 805 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 806 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 807 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 808 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 809 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 810 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 811 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 812 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 813 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 814 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 815 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 816 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 817 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 818 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 819 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 820 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 821 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 822 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 823 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 824 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 825 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 826 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 827 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 828 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 829 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 830 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 831 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 832 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 833 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 834 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 835 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 836 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 837 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 838 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 839 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 840 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 841 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 842 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 843 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 844
 845 #
 846 # Report the --help message.
 847 #
 848 if test "$ac_init_help" = "long"; then
 849   # Omit some internal or obsolete options to make the list less imposing.
 850   # This message is too long to be a string in the A/UX 3.1 sh.
 851   cat <<_ACEOF
 852 \`configure' configures this package to adapt to many kinds of systems.
 853
 854 Usage: $0 [OPTION]... [VAR=VALUE]...
 855
 856 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 857 VAR=VALUE.  See below for descriptions of some of the useful variables.
 858
 859 Defaults for the options are specified in brackets.
 860
 861 Configuration:
 862   -h, --help              display this help and exit
 863       --help=short        display options specific to this package
 864       --help=recursive    display the short help of all the included packages
 865   -V, --version           display version information and exit
 866   -q, --quiet, --silent   do not print \`checking...' messages
 867       --cache-file=FILE   cache test results in FILE [disabled]
 868   -C, --config-cache      alias for \`--cache-file=config.cache'
 869   -n, --no-create         do not create output files
 870       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 871
 872 _ACEOF
 873
 874   cat <<_ACEOF
 875 Installation directories:
 876   --prefix=PREFIX         install architecture-independent files in PREFIX
 877                           [$ac_default_prefix]
 878   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 879                           [PREFIX]
 880
 881 By default, \`make install' will install all the files in
 882 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 883 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 884 for instance \`--prefix=\$HOME'.
 885
 886 For better control, use the options below.
 887
 888 Fine tuning of the installation directories:
 889   --bindir=DIR           user executables [EPREFIX/bin]
 890   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 891   --libexecdir=DIR       program executables [EPREFIX/libexec]
 892   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 893   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 894   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 895   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 896   --libdir=DIR           object code libraries [EPREFIX/lib]
 897   --includedir=DIR       C header files [PREFIX/include]
 898   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 899   --infodir=DIR          info documentation [PREFIX/info]
 900   --mandir=DIR           man documentation [PREFIX/man]
 901 _ACEOF
 902
 903   cat <<\_ACEOF
 904
 905 Program names:
 906   --program-prefix=PREFIX            prepend PREFIX to installed program names
 907   --program-suffix=SUFFIX            append SUFFIX to installed program names
 908   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 909
 910 System types:
 911   --build=BUILD     configure for building on BUILD [guessed]
 912   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 913   --target=TARGET   configure for building compilers for TARGET [HOST]
 914 _ACEOF
 915 fi
 916
 917 if test -n "$ac_init_help"; then
 918
 919   cat <<\_ACEOF
 920
 921 Optional Features:
 922   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 923   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 924   --enable-libada        Builds libada directory
 925   --enable-libssp        Builds libssp directory
 926   --enable-stage1-languages=all   choose additional languages to build during
 927                           stage1.  Mostly useful for compiler development.
 928   --enable-objc-gc       enable the use of Boehm's garbage collector with
 929                           the GNU Objective-C runtime.
 930   --enable-bootstrap           Enable bootstrapping yes if native build
 931   --enable-serial-{host,target,build}-configure
 932                           Force sequential configuration of
 933                           sub-packages for the host, target or build
 934                           machine, or all sub-packages
 935   --enable-maintainer-mode enable make rules and dependencies not useful
 936                           (and sometimes confusing) to the casual installer
 937   --enable-stage1-checking=all   choose additional checking for stage1
 938                           of the compiler.
 939   --enable-werror         enable -Werror in bootstrap stage2 and later
 940
 941 Optional Packages:
 942   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 943   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 944   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 945   --with-mpfr-dir=PATH    This option has been REMOVED
 946   --with-mpfr=PATH        Specify prefix directory for installed MPFR package
 947                           Equivalent to --with-mpfr-include=PATH/include
 948                           plus --with-mpfr-lib=PATH/lib
 949   --with-mpfr-include=PATH
 950                           Specify directory for installed MPFR include files
 951   --with-mpfr-lib=PATH    Specify the directory for the installed MPFR library
 952   --with-gmp-dir=PATH     This option has been REMOVED
 953   --with-gmp=PATH         Specify prefix directory for the installed GMP package
 954                           Equivalent to --with-gmp-include=PATH/include
 955                           plus --with-gmp-lib=PATH/lib
 956   --with-gmp-include=PATH Specify directory for installed GMP include files
 957   --with-gmp-lib=PATH     Specify the directory for the installed GMP library
 958   --with-build-sysroot=sysroot
 959                           use sysroot as the system root during the build
 960   --with-build-time-tools=path
 961                           use given path to find target tools during the build
 962   --with-datarootdir    Use datarootdir as the data root directory.
 963   --with-docdir Install documentation in this directory.
 964   --with-htmldir        Install html in this directory.
 965
 966 Some influential environment variables:
 967   CC          C compiler command
 968   CFLAGS      C compiler flags
 969   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 970               nonstandard directory <lib dir>
 971   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 972               headers in a nonstandard directory <include dir>
 973   CXX         C++ compiler command
 974   CXXFLAGS    C++ compiler flags
 975   AR          AR for the host
 976   AS          AS for the host
 977   DLLTOOL     DLLTOOL for the host
 978   LD          LD for the host
 979   LIPO        LIPO for the host
 980   NM          NM for the host
 981   RANLIB      RANLIB for the host
 982   STRIP       STRIP for the host
 983   WINDRES     WINDRES for the host
 984   OBJCOPY     OBJCOPY for the host
 985   OBJDUMP     OBJDUMP for the host
 986   CC_FOR_TARGET
 987               CC for the target
 988   CXX_FOR_TARGET
 989               CXX for the target
 990   GCC_FOR_TARGET
 991               GCC for the target
 992   GCJ_FOR_TARGET
 993               GCJ for the target
 994   GFORTRAN_FOR_TARGET
 995               GFORTRAN for the target
 996   AR_FOR_TARGET
 997               AR for the target
 998   AS_FOR_TARGET
 999               AS for the target
1000   DLLTOOL_FOR_TARGET
1001               DLLTOOL for the target
1002   LD_FOR_TARGET
1003               LD for the target
1004   LIPO_FOR_TARGET
1005               LIPO for the target
1006   NM_FOR_TARGET
1007               NM for the target
1008   OBJDUMP_FOR_TARGET
1009               OBJDUMP for the target
1010   RANLIB_FOR_TARGET
1011               RANLIB for the target
1012   STRIP_FOR_TARGET
1013               STRIP for the target
1014   WINDRES_FOR_TARGET
1015               WINDRES for the target
1016
1017 Use these variables to override the choices made by `configure' or to help
1018 it to find libraries and programs with nonstandard names/locations.
1019
1020 _ACEOF
1021 fi
1022
1023 if test "$ac_init_help" = "recursive"; then
1024   # If there are subdirs, report their specific --help.
1025   ac_popdir=`pwd`
1026   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1027     test -d $ac_dir || continue
1028     ac_builddir=.
1029
1030 if test "$ac_dir" != .; then
1031   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1032   # A "../" for each directory in $ac_dir_suffix.
1033   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1034 else
1035   ac_dir_suffix= ac_top_builddir=
1036 fi
1037
1038 case $srcdir in
1039   .)  # No --srcdir option.  We are building in place.
1040     ac_srcdir=.
1041     if test -z "$ac_top_builddir"; then
1042        ac_top_srcdir=.
1043     else
1044        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1045     fi ;;
1046   [\\/]* | ?:[\\/]* )  # Absolute path.
1047     ac_srcdir=$srcdir$ac_dir_suffix;
1048     ac_top_srcdir=$srcdir ;;
1049   *) # Relative path.
1050     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1051     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1052 esac
1053
1054 # Do not use `cd foo && pwd` to compute absolute paths, because
1055 # the directories may not exist.
1056 case `pwd` in
1057 .) ac_abs_builddir="$ac_dir";;
1058 *)
1059   case "$ac_dir" in
1060   .) ac_abs_builddir=`pwd`;;
1061   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1062   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1063   esac;;
1064 esac
1065 case $ac_abs_builddir in
1066 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1067 *)
1068   case ${ac_top_builddir}. in
1069   .) ac_abs_top_builddir=$ac_abs_builddir;;
1070   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1071   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1072   esac;;
1073 esac
1074 case $ac_abs_builddir in
1075 .) ac_abs_srcdir=$ac_srcdir;;
1076 *)
1077   case $ac_srcdir in
1078   .) ac_abs_srcdir=$ac_abs_builddir;;
1079   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1080   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1081   esac;;
1082 esac
1083 case $ac_abs_builddir in
1084 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1085 *)
1086   case $ac_top_srcdir in
1087   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1088   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1089   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1090   esac;;
1091 esac
1092
1093     cd $ac_dir
1094     # Check for guested configure; otherwise get Cygnus style configure.
1095     if test -f $ac_srcdir/configure.gnu; then
1096       echo
1097       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1098     elif test -f $ac_srcdir/configure; then
1099       echo
1100       $SHELL $ac_srcdir/configure  --help=recursive
1101     elif test -f $ac_srcdir/configure.ac ||
1102            test -f $ac_srcdir/configure.in; then
1103       echo
1104       $ac_configure --help
1105     else
1106       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1107     fi
1108     cd $ac_popdir
1109   done
1110 fi
1111
1112 test -n "$ac_init_help" && exit 0
1113 if $ac_init_version; then
1114   cat <<\_ACEOF
1115
1116 Copyright (C) 2003 Free Software Foundation, Inc.
1117 This configure script is free software; the Free Software Foundation
1118 gives unlimited permission to copy, distribute and modify it.
1119 _ACEOF
1120   exit 0
1121 fi
1122 exec 5>config.log
1123 cat >&5 <<_ACEOF
1124 This file contains any messages produced by compilers while
1125 running configure, to aid debugging if configure makes a mistake.
1126
1127 It was created by $as_me, which was
1128 generated by GNU Autoconf 2.59.  Invocation command line was
1129
1130   $ $0 $@
1131
1132 _ACEOF
1133 {
1134 cat <<_ASUNAME
1135 ## --------- ##
1136 ## Platform. ##
1137 ## --------- ##
1138
1139 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1140 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1141 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1142 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1143 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1144
1145 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1146 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1147
1148 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1149 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1150 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1151 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1152 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1153 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1154 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1155
1156 _ASUNAME
1157
1158 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1159 for as_dir in $PATH
1160 do
1161   IFS=$as_save_IFS
1162   test -z "$as_dir" && as_dir=.
1163   echo "PATH: $as_dir"
1164 done
1165
1166 } >&5
1167
1168 cat >&5 <<_ACEOF
1169
1170
1171 ## ----------- ##
1172 ## Core tests. ##
1173 ## ----------- ##
1174
1175 _ACEOF
1176
1177
1178 # Keep a trace of the command line.
1179 # Strip out --no-create and --no-recursion so they do not pile up.
1180 # Strip out --silent because we don't want to record it for future runs.
1181 # Also quote any args containing shell meta-characters.
1182 # Make two passes to allow for proper duplicate-argument suppression.
1183 ac_configure_args=
1184 ac_configure_args0=
1185 ac_configure_args1=
1186 ac_sep=
1187 ac_must_keep_next=false
1188 for ac_pass in 1 2
1189 do
1190   for ac_arg
1191   do
1192     case $ac_arg in
1193     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1194     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1195     | -silent | --silent | --silen | --sile | --sil)
1196       continue ;;
1197     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1198       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1199     esac
1200     case $ac_pass in
1201     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1202     2)
1203       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1204       if test $ac_must_keep_next = true; then
1205         ac_must_keep_next=false # Got value, back to normal.
1206       else
1207         case $ac_arg in
1208           *=* | --config-cache | -C | -disable-* | --disable-* \
1209           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1210           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1211           | -with-* | --with-* | -without-* | --without-* | --x)
1212             case "$ac_configure_args0 " in
1213               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1214             esac
1215             ;;
1216           -* ) ac_must_keep_next=true ;;
1217         esac
1218       fi
1219       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1220       # Get rid of the leading space.
1221       ac_sep=" "
1222       ;;
1223     esac
1224   done
1225 done
1226 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1227 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1228
1229 # When interrupted or exit'd, cleanup temporary files, and complete
1230 # config.log.  We remove comments because anyway the quotes in there
1231 # would cause problems or look ugly.
1232 # WARNING: Be sure not to use single quotes in there, as some shells,
1233 # such as our DU 5.0 friend, will then `close' the trap.
1234 trap 'exit_status=$?
1235   # Save into config.log some information that might help in debugging.
1236   {
1237     echo
1238
1239     cat <<\_ASBOX
1240 ## ---------------- ##
1241 ## Cache variables. ##
1242 ## ---------------- ##
1243 _ASBOX
1244     echo
1245     # The following way of writing the cache mishandles newlines in values,
1246 {
1247   (set) 2>&1 |
1248     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1249     *ac_space=\ *)
1250       sed -n \
1251         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1252           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1253       ;;
1254     *)
1255       sed -n \
1256         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1257       ;;
1258     esac;
1259 }
1260     echo
1261
1262     cat <<\_ASBOX
1263 ## ----------------- ##
1264 ## Output variables. ##
1265 ## ----------------- ##
1266 _ASBOX
1267     echo
1268     for ac_var in $ac_subst_vars
1269     do
1270       eval ac_val=$`echo $ac_var`
1271       echo "$ac_var='"'"'$ac_val'"'"'"
1272     done | sort
1273     echo
1274
1275     if test -n "$ac_subst_files"; then
1276       cat <<\_ASBOX
1277 ## ------------- ##
1278 ## Output files. ##
1279 ## ------------- ##
1280 _ASBOX
1281       echo
1282       for ac_var in $ac_subst_files
1283       do
1284         eval ac_val=$`echo $ac_var`
1285         echo "$ac_var='"'"'$ac_val'"'"'"
1286       done | sort
1287       echo
1288     fi
1289
1290     if test -s confdefs.h; then
1291       cat <<\_ASBOX
1292 ## ----------- ##
1293 ## confdefs.h. ##
1294 ## ----------- ##
1295 _ASBOX
1296       echo
1297       sed "/^$/d" confdefs.h | sort
1298       echo
1299     fi
1300     test "$ac_signal" != 0 &&
1301       echo "$as_me: caught signal $ac_signal"
1302     echo "$as_me: exit $exit_status"
1303   } >&5
1304   rm -f core *.core &&
1305   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1306     exit $exit_status
1307      ' 0
1308 for ac_signal in 1 2 13 15; do
1309   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1310 done
1311 ac_signal=0
1312
1313 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1314 rm -rf conftest* confdefs.h
1315 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1316 echo >confdefs.h
1317
1318 # Predefined preprocessor variables.
1319
1320 cat >>confdefs.h <<_ACEOF
1321 #define PACKAGE_NAME "$PACKAGE_NAME"
1322 _ACEOF
1323
1324
1325 cat >>confdefs.h <<_ACEOF
1326 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1327 _ACEOF
1328
1329
1330 cat >>confdefs.h <<_ACEOF
1331 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1332 _ACEOF
1333
1334
1335 cat >>confdefs.h <<_ACEOF
1336 #define PACKAGE_STRING "$PACKAGE_STRING"
1337 _ACEOF
1338
1339
1340 cat >>confdefs.h <<_ACEOF
1341 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1342 _ACEOF
1343
1344
1345 # Let the site file select an alternate cache file if it wants to.
1346 # Prefer explicitly selected file to automatically selected ones.
1347 if test -z "$CONFIG_SITE"; then
1348   if test "x$prefix" != xNONE; then
1349     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1350   else
1351     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1352   fi
1353 fi
1354 for ac_site_file in $CONFIG_SITE; do
1355   if test -r "$ac_site_file"; then
1356     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1357 echo "$as_me: loading site script $ac_site_file" >&6;}
1358     sed 's/^/| /' "$ac_site_file" >&5
1359     . "$ac_site_file"
1360   fi
1361 done
1362
1363 if test -r "$cache_file"; then
1364   # Some versions of bash will fail to source /dev/null (special
1365   # files actually), so we avoid doing that.
1366   if test -f "$cache_file"; then
1367     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1368 echo "$as_me: loading cache $cache_file" >&6;}
1369     case $cache_file in
1370       [\\/]* | ?:[\\/]* ) . $cache_file;;
1371       *)                      . ./$cache_file;;
1372     esac
1373   fi
1374 else
1375   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1376 echo "$as_me: creating cache $cache_file" >&6;}
1377   >$cache_file
1378 fi
1379
1380 # Check that the precious variables saved in the cache have kept the same
1381 # value.
1382 ac_cache_corrupted=false
1383 for ac_var in `(set) 2>&1 |
1384                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1385   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1386   eval ac_new_set=\$ac_env_${ac_var}_set
1387   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1388   eval ac_new_val="\$ac_env_${ac_var}_value"
1389   case $ac_old_set,$ac_new_set in
1390     set,)
1391       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1392 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1393       ac_cache_corrupted=: ;;
1394     ,set)
1395       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1396 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1397       ac_cache_corrupted=: ;;
1398     ,);;
1399     *)
1400       if test "x$ac_old_val" != "x$ac_new_val"; then
1401         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1402 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1403         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1404 echo "$as_me:   former value:  $ac_old_val" >&2;}
1405         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1406 echo "$as_me:   current value: $ac_new_val" >&2;}
1407         ac_cache_corrupted=:
1408       fi;;
1409   esac
1410   # Pass precious variables to config.status.
1411   if test "$ac_new_set" = set; then
1412     case $ac_new_val in
1413     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1414       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1415     *) ac_arg=$ac_var=$ac_new_val ;;
1416     esac
1417     case " $ac_configure_args " in
1418       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1419       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1420     esac
1421   fi
1422 done
1423 if $ac_cache_corrupted; then
1424   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1425 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1426   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1427 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1428    { (exit 1); exit 1; }; }
1429 fi
1430
1431 ac_ext=c
1432 ac_cpp='$CPP $CPPFLAGS'
1433 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1434 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1435 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457 # Find the build, host, and target systems.
1458 ac_aux_dir=
1459 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1460   if test -f $ac_dir/install-sh; then
1461     ac_aux_dir=$ac_dir
1462     ac_install_sh="$ac_aux_dir/install-sh -c"
1463     break
1464   elif test -f $ac_dir/install.sh; then
1465     ac_aux_dir=$ac_dir
1466     ac_install_sh="$ac_aux_dir/install.sh -c"
1467     break
1468   elif test -f $ac_dir/shtool; then
1469     ac_aux_dir=$ac_dir
1470     ac_install_sh="$ac_aux_dir/shtool install -c"
1471     break
1472   fi
1473 done
1474 if test -z "$ac_aux_dir"; then
1475   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1476 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1477    { (exit 1); exit 1; }; }
1478 fi
1479 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1480 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1481 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1482
1483 # Make sure we can run config.sub.
1484 $ac_config_sub sun4 >/dev/null 2>&1 ||
1485   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1486 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1487    { (exit 1); exit 1; }; }
1488
1489 echo "$as_me:$LINENO: checking build system type" >&5
1490 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1491 if test "${ac_cv_build+set}" = set; then
1492   echo $ECHO_N "(cached) $ECHO_C" >&6
1493 else
1494   ac_cv_build_alias=$build_alias
1495 test -z "$ac_cv_build_alias" &&
1496   ac_cv_build_alias=`$ac_config_guess`
1497 test -z "$ac_cv_build_alias" &&
1498   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1499 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1500    { (exit 1); exit 1; }; }
1501 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1502   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1503 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1504    { (exit 1); exit 1; }; }
1505
1506 fi
1507 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1508 echo "${ECHO_T}$ac_cv_build" >&6
1509 build=$ac_cv_build
1510 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1511 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1512 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1513
1514
1515  case ${build_alias} in
1516   "") build_noncanonical=${build} ;;
1517   *) build_noncanonical=${build_alias} ;;
1518 esac
1519
1520
1521
1522  case ${host_alias} in
1523   "") host_noncanonical=${build_noncanonical} ;;
1524   *) host_noncanonical=${host_alias} ;;
1525 esac
1526
1527
1528
1529  case ${target_alias} in
1530   "") target_noncanonical=${host_noncanonical} ;;
1531   *) target_noncanonical=${target_alias} ;;
1532 esac
1533
1534
1535
1536
1537 test "$host_noncanonical" = "$target_noncanonical" &&
1538   test "$program_prefix$program_suffix$program_transform_name" = \
1539     NONENONEs,x,x, &&
1540   program_transform_name=s,y,y,
1541
1542 echo "$as_me:$LINENO: checking host system type" >&5
1543 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1544 if test "${ac_cv_host+set}" = set; then
1545   echo $ECHO_N "(cached) $ECHO_C" >&6
1546 else
1547   ac_cv_host_alias=$host_alias
1548 test -z "$ac_cv_host_alias" &&
1549   ac_cv_host_alias=$ac_cv_build_alias
1550 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1551   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1552 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1553    { (exit 1); exit 1; }; }
1554
1555 fi
1556 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1557 echo "${ECHO_T}$ac_cv_host" >&6
1558 host=$ac_cv_host
1559 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1560 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1561 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1562
1563
1564 echo "$as_me:$LINENO: checking target system type" >&5
1565 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1566 if test "${ac_cv_target+set}" = set; then
1567   echo $ECHO_N "(cached) $ECHO_C" >&6
1568 else
1569   ac_cv_target_alias=$target_alias
1570 test "x$ac_cv_target_alias" = "x" &&
1571   ac_cv_target_alias=$ac_cv_host_alias
1572 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1573   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1574 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1575    { (exit 1); exit 1; }; }
1576
1577 fi
1578 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1579 echo "${ECHO_T}$ac_cv_target" >&6
1580 target=$ac_cv_target
1581 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1582 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1583 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1584
1585
1586 # The aliases save the names the user supplied, while $host etc.
1587 # will get canonicalized.
1588 test -n "$target_alias" &&
1589   test "$program_prefix$program_suffix$program_transform_name" = \
1590     NONENONEs,x,x, &&
1591   program_prefix=${target_alias}-
1592 test "$program_prefix" != NONE &&
1593   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1594 # Use a double $ so make ignores it.
1595 test "$program_suffix" != NONE &&
1596   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1597 # Double any \ or $.  echo might interpret backslashes.
1598 # By default was `s,x,x', remove it if useless.
1599 cat <<\_ACEOF >conftest.sed
1600 s/[\\$]/&&/g;s/;s,x,x,$//
1601 _ACEOF
1602 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1603 rm conftest.sed
1604
1605
1606
1607 # Get 'install' or 'install-sh' and its variants.
1608 # Find a good install program.  We prefer a C program (faster),
1609 # so one script is as good as another.  But avoid the broken or
1610 # incompatible versions:
1611 # SysV /etc/install, /usr/sbin/install
1612 # SunOS /usr/etc/install
1613 # IRIX /sbin/install
1614 # AIX /bin/install
1615 # AmigaOS /C/install, which installs bootblocks on floppy discs
1616 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1617 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1618 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1619 # OS/2's system install, which has a completely different semantic
1620 # ./install, which can be erroneously created by make from ./install.sh.
1621 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1622 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1623 if test -z "$INSTALL"; then
1624 if test "${ac_cv_path_install+set}" = set; then
1625   echo $ECHO_N "(cached) $ECHO_C" >&6
1626 else
1627   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1628 for as_dir in $PATH
1629 do
1630   IFS=$as_save_IFS
1631   test -z "$as_dir" && as_dir=.
1632   # Account for people who put trailing slashes in PATH elements.
1633 case $as_dir/ in
1634   ./ | .// | /cC/* | \
1635   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1636   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1637   /usr/ucb/* ) ;;
1638   *)
1639     # OSF1 and SCO ODT 3.0 have their own names for install.
1640     # Don't use installbsd from OSF since it installs stuff as root
1641     # by default.
1642     for ac_prog in ginstall scoinst install; do
1643       for ac_exec_ext in '' $ac_executable_extensions; do
1644         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1645           if test $ac_prog = install &&
1646             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1647             # AIX install.  It has an incompatible calling convention.
1648             :
1649           elif test $ac_prog = install &&
1650             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1651             # program-specific install script used by HP pwplus--don't use.
1652             :
1653           else
1654             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1655             break 3
1656           fi
1657         fi
1658       done
1659     done
1660     ;;
1661 esac
1662 done
1663
1664
1665 fi
1666   if test "${ac_cv_path_install+set}" = set; then
1667     INSTALL=$ac_cv_path_install
1668   else
1669     # As a last resort, use the slow shell script.  We don't cache a
1670     # path for INSTALL within a source directory, because that will
1671     # break other packages using the cache if that directory is
1672     # removed, or if the path is relative.
1673     INSTALL=$ac_install_sh
1674   fi
1675 fi
1676 echo "$as_me:$LINENO: result: $INSTALL" >&5
1677 echo "${ECHO_T}$INSTALL" >&6
1678
1679 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1680 # It thinks the first close brace ends the variable substitution.
1681 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1682
1683 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1684
1685 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1686
1687 echo "$as_me:$LINENO: checking whether ln works" >&5
1688 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1689 if test "${acx_cv_prog_LN+set}" = set; then
1690   echo $ECHO_N "(cached) $ECHO_C" >&6
1691 else
1692   rm -f conftestdata_t
1693 echo >conftestdata_f
1694 if ln conftestdata_f conftestdata_t 2>/dev/null
1695 then
1696   acx_cv_prog_LN=ln
1697 else
1698   acx_cv_prog_LN=no
1699 fi
1700 rm -f conftestdata_f conftestdata_t
1701
1702 fi
1703 if test $acx_cv_prog_LN = no; then
1704   LN="cp"
1705   echo "$as_me:$LINENO: result: no, using $LN" >&5
1706 echo "${ECHO_T}no, using $LN" >&6
1707 else
1708   LN="$acx_cv_prog_LN"
1709   echo "$as_me:$LINENO: result: yes" >&5
1710 echo "${ECHO_T}yes" >&6
1711 fi
1712
1713 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1714 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1715 LN_S=$as_ln_s
1716 if test "$LN_S" = "ln -s"; then
1717   echo "$as_me:$LINENO: result: yes" >&5
1718 echo "${ECHO_T}yes" >&6
1719 else
1720   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1721 echo "${ECHO_T}no, using $LN_S" >&6
1722 fi
1723
1724
1725 ### we might need to use some other shell than /bin/sh for running subshells
1726 ### If we are on Windows, search for the shell.  This will permit people
1727 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1728 ### without also having to set CONFIG_SHELL.  This code will work when
1729 ### using bash, which sets OSTYPE.
1730 case "${OSTYPE}" in
1731 *win32*)
1732   if test x${CONFIG_SHELL} = x ; then
1733     if test ! -f /bin/sh ; then
1734       if test x${SHELL} != x && test -f ${SHELL} ; then
1735         CONFIG_SHELL=${SHELL}
1736         export CONFIG_SHELL
1737       else
1738         for prog in sh sh.exe bash bash.exe; do
1739           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1740           for dir in $PATH; do
1741             test -z "$dir" && dir=.
1742             if test -f $dir/$prog; then
1743               CONFIG_SHELL=$dir/$prog
1744               export CONFIG_SHELL
1745               break
1746             fi
1747           done
1748           IFS="$save_ifs"
1749           test -n "${CONFIG_SHELL}" && break
1750         done
1751       fi
1752     fi
1753   fi
1754   ;;
1755 esac
1756
1757 config_shell=${CONFIG_SHELL-/bin/sh}
1758
1759 progname=$0
1760 # if PWD already has a value, it is probably wrong.
1761 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1762
1763 # Export original configure arguments for use by sub-configures.
1764 # Quote arguments with shell meta charatcers.
1765 TOPLEVEL_CONFIGURE_ARGUMENTS=
1766 set -- "$progname" "$@"
1767 for ac_arg
1768 do
1769   case "$ac_arg" in
1770   *" "*|*"      "*|*\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?*)
1771     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1772     # if the argument is of the form -foo=baz, quote the baz part only
1773     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1774   *) ;;
1775   esac
1776   # Add the quoted argument to the list.
1777   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1778 done
1779 # Remove the initial space we just introduced and, as these will be
1780 # expanded by make, quote '$'.
1781 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1782
1783
1784 moveifchange=${srcdir}/move-if-change
1785
1786 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1787
1788 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1789 # a relative path.
1790 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1791   INSTALL="${srcpwd}/install-sh -c"
1792 fi
1793
1794 # Set srcdir to "." if that's what it is.
1795 # This is important for multilib support.
1796 pwd=`${PWDCMD-pwd}`
1797 if test "${pwd}" = "${srcpwd}" ; then
1798   srcdir=.
1799 fi
1800
1801 topsrcdir=$srcpwd
1802
1803 extra_host_args=
1804
1805 ### To add a new directory to the tree, first choose whether it is a target
1806 ### or a host dependent tool.  Then put it into the appropriate list
1807 ### (library or tools, host or target), doing a dependency sort.
1808
1809 # Subdirs will be configured in the order listed in build_configdirs,
1810 # configdirs, or target_configdirs; see the serialization section below.
1811
1812 # Dependency sorting is only needed when *configuration* must be done in
1813 # a particular order.  In all cases a dependency should be specified in
1814 # the Makefile, whether or not it's implicitly specified here.
1815
1816 # Double entries in build_configdirs, configdirs, or target_configdirs may
1817 # cause circular dependencies and break everything horribly.
1818
1819 # these library is used by various programs built for the build
1820 # environment
1821 #
1822 build_libs="build-libiberty"
1823
1824 # these tools are built for the build environment
1825 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1826
1827 # these libraries are used by various programs built for the host environment
1828 #
1829 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1830
1831 # these tools are built for the host environment
1832 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1833 # know that we are building the simulator.
1834 # binutils, gas and ld appear in that order because it makes sense to run
1835 # "make check" in that particular order.
1836 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"
1837
1838 # libgcj represents the runtime libraries only used by gcj.
1839 libgcj="target-libffi \
1840         target-zlib \
1841         target-qthreads \
1842         target-libjava"
1843
1844 # these libraries are built for the target environment, and are built after
1845 # the host libraries and the host tools (which may be a cross compiler)
1846 #
1847 target_libraries="target-libgcc \
1848                 target-libiberty \
1849                 target-libgloss \
1850                 target-newlib \
1851                 target-libstdc++-v3 \
1852                 target-libmudflap \
1853                 target-libssp \
1854                 target-libgfortran \
1855                 target-boehm-gc \
1856                 ${libgcj} \
1857                 target-libobjc \
1858                 target-libada \
1859                 target-libgomp"
1860
1861 # these tools are built using the target libraries, and are intended to
1862 # run only in the target environment
1863 #
1864 # note: any program that *uses* libraries that are in the "target_libraries"
1865 # list belongs in this list.  those programs are also very likely
1866 # candidates for the "native_only" list which follows
1867 #
1868 target_tools="target-examples target-groff target-gperf target-rda"
1869
1870 ################################################################################
1871
1872 ## All tools belong in one of the four categories, and are assigned above
1873 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1874 ## is important because configure will choke if they ever get through.
1875 ## ${configdirs} is directories we build using the host tools.
1876 ## ${target_configdirs} is directories we build using the target tools.
1877 configdirs=`echo ${host_libs} ${host_tools}`
1878 target_configdirs=`echo ${target_libraries} ${target_tools}`
1879 build_configdirs=`echo ${build_libs} ${build_tools}`
1880
1881 ################################################################################
1882
1883 srcname="gnu development package"
1884
1885 # This gets set non-empty for some net releases of packages.
1886 appdirs=""
1887
1888 # Define is_cross_compiler to save on calls to 'test'.
1889 is_cross_compiler=
1890 if test x"${host}" = x"${target}" ; then
1891   is_cross_compiler=no
1892 else
1893   is_cross_compiler=yes
1894 fi
1895
1896 # Find the build and target subdir names.
1897
1898 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1899 # have matching libraries, they should use host libraries: Makefile.tpl
1900 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1901 # However, they still use the build modules, because the corresponding
1902 # host modules (e.g. bison) are only built for the host when bootstrap
1903 # finishes. So:
1904 # - build_subdir is where we find build modules, and never changes.
1905 # - build_libsubdir is where we find build libraries, and can be overridden.
1906
1907 # Prefix 'build-' so this never conflicts with target_subdir.
1908 build_subdir="build-${build_noncanonical}"
1909
1910 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1911 if test "${with_build_libsubdir+set}" = set; then
1912   withval="$with_build_libsubdir"
1913   build_libsubdir="$withval"
1914 else
1915   build_libsubdir="$build_subdir"
1916 fi;
1917 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1918 if ( test $srcdir = . && test -d gcc ) \
1919    || test -d $srcdir/../host-${host_noncanonical}; then
1920   host_subdir="host-${host_noncanonical}"
1921 else
1922   host_subdir=.
1923 fi
1924 # No prefix.
1925 target_subdir=${target_noncanonical}
1926
1927
1928 # Skipdirs are removed silently.
1929 skipdirs=
1930 # Noconfigdirs are removed loudly.
1931 noconfigdirs=""
1932
1933 use_gnu_ld=
1934 # Make sure we don't let GNU ld be added if we didn't want it.
1935 if test x$with_gnu_ld = xno ; then
1936   use_gnu_ld=no
1937   noconfigdirs="$noconfigdirs ld"
1938 fi
1939
1940 use_gnu_as=
1941 # Make sure we don't let GNU as be added if we didn't want it.
1942 if test x$with_gnu_as = xno ; then
1943   use_gnu_as=no
1944   noconfigdirs="$noconfigdirs gas"
1945 fi
1946
1947 # some tools are so dependent upon X11 that if we're not building with X,
1948 # it's not even worth trying to configure, much less build, that tool.
1949
1950 case ${with_x} in
1951   yes | "") ;; # the default value for this tree is that X11 is available
1952   no)
1953     skipdirs="${skipdirs} tk itcl libgui"
1954     # We won't be able to build gdbtk without X.
1955     enable_gdbtk=no
1956     ;;
1957   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
1958 esac
1959
1960 # Some tools are only suitable for building in a "native" situation.
1961 # Remove these if host!=target.
1962 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"
1963
1964 # Similarly, some are only suitable for cross toolchains.
1965 # Remove these if host=target.
1966 cross_only="target-libgloss target-newlib target-opcodes"
1967
1968 case $is_cross_compiler in
1969   no) skipdirs="${skipdirs} ${cross_only}" ;;
1970   yes) skipdirs="${skipdirs} ${native_only}" ;;
1971 esac
1972
1973 # If both --with-headers and --with-libs are specified, default to
1974 # --without-newlib.
1975 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
1976    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
1977   if test x"${with_newlib}" = x ; then
1978     with_newlib=no
1979   fi
1980 fi
1981
1982 # Recognize --with-newlib/--without-newlib.
1983 case ${with_newlib} in
1984   no) skipdirs="${skipdirs} target-newlib" ;;
1985   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
1986 esac
1987
1988 # Configure extra directories which are host specific
1989
1990 case "${host}" in
1991   *-cygwin*)
1992     configdirs="$configdirs libtermcap" ;;
1993 esac
1994
1995 # A target can indicate whether a language isn't supported for some reason.
1996 # Only spaces may be used in this macro; not newlines or tabs.
1997 unsupported_languages=
1998
1999 # Remove more programs from consideration, based on the host or
2000 # target this usually means that a port of the program doesn't
2001 # exist yet.
2002
2003 case "${host}" in
2004   hppa*64*-*-*)
2005     noconfigdirs="$noconfigdirs byacc"
2006     ;;
2007   i[3456789]86-*-vsta)
2008     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2009     ;;
2010   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2011     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2012     ;;
2013   x86_64-*-mingw*)
2014     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2015     ;;
2016   i[3456789]86-*-mingw32*)
2017     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2018     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2019     ;;
2020   i[3456789]86-*-beos*)
2021     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2022     ;;
2023   *-*-cygwin*)
2024     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2025     ;;
2026   *-*-netbsd*)
2027     noconfigdirs="$noconfigdirs rcs"
2028     ;;
2029   ppc*-*-pe)
2030     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2031     ;;
2032   powerpc-*-beos*)
2033     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2034     ;;
2035 esac
2036
2037
2038 # Check whether --enable-libada or --disable-libada was given.
2039 if test "${enable_libada+set}" = set; then
2040   enableval="$enable_libada"
2041   ENABLE_LIBADA=$enableval
2042 else
2043   ENABLE_LIBADA=yes
2044 fi;
2045 if test "${ENABLE_LIBADA}" != "yes" ; then
2046   noconfigdirs="$noconfigdirs gnattools"
2047 fi
2048
2049 # Check whether --enable-libssp or --disable-libssp was given.
2050 if test "${enable_libssp+set}" = set; then
2051   enableval="$enable_libssp"
2052   ENABLE_LIBSSP=$enableval
2053 else
2054   ENABLE_LIBSSP=yes
2055 fi;
2056
2057 # Save it here so that, even in case of --enable-libgcj, if the Java
2058 # front-end isn't enabled, we still get libgcj disabled.
2059 libgcj_saved=$libgcj
2060 case $enable_libgcj in
2061 yes)
2062   # If we reset it here, it won't get added to noconfigdirs in the
2063   # target-specific build rules, so it will be forcibly enabled
2064   # (unless the Java language itself isn't enabled).
2065   libgcj=
2066   ;;
2067 no)
2068   # Make sure we get it printed in the list of not supported target libs.
2069   noconfigdirs="$noconfigdirs ${libgcj}"
2070   ;;
2071 esac
2072
2073
2074 # Disable libmudflap on some systems.
2075 if test x$enable_libmudflap = x ; then
2076     case "${target}" in
2077     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2078         # Enable libmudflap by default in GNU and friends.
2079         ;;
2080     *-*-freebsd*)
2081         # Enable libmudflap by default in FreeBSD.
2082         ;;
2083     *)
2084         # Disable it by default everywhere else.
2085         noconfigdirs="$noconfigdirs target-libmudflap"
2086         ;;
2087     esac
2088 fi
2089
2090 # Disable libgomp on non POSIX hosted systems.
2091 if test x$enable_libgomp = x ; then
2092     # Enable libgomp by default on hosted POSIX systems.
2093     case "${target}" in
2094     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2095         ;;
2096     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2097         ;;
2098     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2099         ;;
2100     *-*-darwin* | *-*-aix*)
2101         ;;
2102     *)
2103         noconfigdirs="$noconfigdirs target-libgomp"
2104         ;;
2105     esac
2106 fi
2107
2108
2109 case "${target}" in
2110   *-*-chorusos)
2111     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2112     ;;
2113   powerpc-*-darwin* | i[3456789]86-*-darwin*)
2114     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2115     noconfigdirs="$noconfigdirs sim target-rda"
2116     ;;
2117   *-*-darwin*)
2118     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2119     noconfigdirs="$noconfigdirs sim target-rda"
2120     noconfigdirs="$noconfigdirs ${libgcj}"
2121     ;;
2122   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2123     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2124     ;;
2125   *-*-freebsd*)
2126     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2127     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2128         && test -f /usr/local/include/gmp.h; then
2129       with_gmp=/usr/local
2130     fi
2131
2132     # Skip some stuff that's unsupported on some FreeBSD configurations.
2133     case "${target}" in
2134       i*86-*-*) ;;
2135       alpha*-*-*) ;;
2136       *)
2137         noconfigdirs="$noconfigdirs ${libgcj}"
2138         ;;
2139     esac
2140     ;;
2141   *-*-kaos*)
2142     # Remove unsupported stuff on all kaOS configurations.
2143     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2144     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2145     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2146     noconfigdirs="$noconfigdirs target-libgloss"
2147     ;;
2148   *-*-netbsd*)
2149     # Skip some stuff on all NetBSD configurations.
2150     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2151
2152     # Skip some stuff that's unsupported on some NetBSD configurations.
2153     case "${target}" in
2154       i*86-*-netbsdelf*) ;;
2155       arm*-*-netbsdelf*) ;;
2156       *)
2157         noconfigdirs="$noconfigdirs ${libgcj}"
2158         ;;
2159     esac
2160     ;;
2161   *-*-netware*)
2162     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2163     ;;
2164   *-*-rtems*)
2165     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2166     ;;
2167     # The tpf target doesn't support gdb yet.
2168   *-*-tpf*)
2169     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2170     ;;
2171   *-*-uclinux*)
2172     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2173     ;;
2174   *-*-vxworks*)
2175     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2176     ;;
2177   alpha*-dec-osf*)
2178     # ld works, but does not support shared libraries.
2179     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2180     # gas doesn't generate exception information.
2181     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2182     ;;
2183   alpha*-*-*vms*)
2184     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2185     ;;
2186   alpha*-*-linux*)
2187     # newlib is not 64 bit ready
2188     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2189     ;;
2190   alpha*-*-*)
2191     # newlib is not 64 bit ready
2192     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2193     ;;
2194   am33_2.0-*-linux*)
2195     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2196     ;;
2197   sh-*-linux*)
2198     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2199     ;;
2200   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2201     noconfigdirs="$noconfigdirs ${libgcj}"
2202     noconfigdirs="$noconfigdirs target-examples"
2203     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2204     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2205     noconfigdirs="$noconfigdirs expect dejagnu"
2206     # the C++ libraries don't build on top of CE's C libraries
2207     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2208     noconfigdirs="$noconfigdirs target-newlib"
2209     case "${host}" in
2210       *-*-cygwin*) ;; # keep gdb and readline
2211       *) noconfigdirs="$noconfigdirs gdb readline"
2212          ;;
2213     esac
2214     ;;
2215   arc-*-*)
2216     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2217     ;;
2218   arm-semi-aof )
2219     ;;
2220   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2221     noconfigdirs="$noconfigdirs ${libgcj}"
2222     ;;
2223   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2224     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2225     ;;
2226   arm*-*-linux-gnueabi)
2227     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2228     noconfigdirs="$noconfigdirs target-libjava target-libobjc"
2229     ;;
2230   arm*-*-symbianelf*)
2231     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2232     ;;
2233   arm-*-pe*)
2234     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2235     ;;
2236   thumb-*-coff)
2237     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2238     ;;
2239   thumb-*-elf)
2240     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2241     ;;
2242   thumb-*-pe)
2243     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2244     ;;
2245   arm-*-riscix*)
2246     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2247     ;;
2248   avr-*-*)
2249     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2250     ;;
2251   bfin-*-*)
2252     noconfigdirs="$noconfigdirs gdb"
2253     if test x${is_cross_compiler} != xno ; then
2254       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2255     fi
2256     ;;
2257   c4x-*-* | tic4x-*-*)
2258     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2259     ;;
2260   c54x*-*-* | tic54x-*-*)
2261     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2262     ;;
2263   cris-*-* | crisv32-*-*)
2264     unsupported_languages="$unsupported_languages java"
2265     case "${target}" in
2266       *-*-aout)
2267         unsupported_languages="$unsupported_languages fortran"
2268         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2269       *-*-elf)
2270         unsupported_languages="$unsupported_languages fortran"
2271         noconfigdirs="$noconfigdirs target-boehm-gc";;
2272       *-*-linux*)
2273         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2274       *)
2275         unsupported_languages="$unsupported_languages fortran"
2276         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2277     esac
2278     ;;
2279   crx-*-*)
2280     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2281     ;;
2282   d10v-*-*)
2283     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2284     ;;
2285   d30v-*-*)
2286     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2287     ;;
2288   fr30-*-elf*)
2289     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2290     ;;
2291   frv-*-*)
2292     noconfigdirs="$noconfigdirs ${libgcj}"
2293     ;;
2294   h8300*-*-*)
2295     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2296     ;;
2297   h8500-*-*)
2298     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2299     ;;
2300   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2301     ;;
2302   hppa*64*-*-linux* | parisc*64*-*-linux*)
2303     # In this case, it's because the hppa64-linux target is for
2304     # the kernel only at this point and has no libc, and thus no
2305     # headers, crt*.o, etc., all of which are needed by these.
2306     noconfigdirs="$noconfigdirs target-zlib"
2307     ;;
2308   parisc*-*-linux* | hppa*-*-linux*)
2309     ;;
2310   hppa*-*-*elf* | \
2311   hppa*-*-lites* | \
2312   hppa*-*-openbsd* | \
2313   hppa*64*-*-*)
2314     noconfigdirs="$noconfigdirs ${libgcj}"
2315     ;;
2316   hppa*-hp-hpux11*)
2317     noconfigdirs="$noconfigdirs ld shellutils"
2318     ;;
2319   hppa*-*-*)
2320     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2321     # build on HP-UX 10.20.
2322     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2323     ;;
2324   i960-*-*)
2325     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2326     ;;
2327   ia64*-*-elf*)
2328     # No gdb support yet.
2329     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2330     ;;
2331   ia64*-**-hpux*)
2332     # No gdb or ld support yet.
2333     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2334     ;;
2335   i370-*-opened*)
2336     ;;
2337   i[3456789]86-*-coff | i[3456789]86-*-elf)
2338     noconfigdirs="$noconfigdirs ${libgcj}"
2339     ;;
2340   i[3456789]86-*-linux*)
2341     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2342     # not build java stuff by default.
2343     case "${target}" in
2344       *-*-*libc1*)
2345         noconfigdirs="$noconfigdirs ${libgcj}";;
2346     esac
2347
2348     # This section makes it possible to build newlib natively on linux.
2349     # If we are using a cross compiler then don't configure newlib.
2350     if test x${is_cross_compiler} != xno ; then
2351       noconfigdirs="$noconfigdirs target-newlib"
2352     fi
2353     noconfigdirs="$noconfigdirs target-libgloss"
2354     # If we are not using a cross compiler, do configure newlib.
2355     # Note however, that newlib will only be configured in this situation
2356     # if the --with-newlib option has been given, because otherwise
2357     # 'target-newlib' will appear in skipdirs.
2358     ;;
2359   i[3456789]86-*-mingw32*)
2360     target_configdirs="$target_configdirs target-winsup"
2361     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2362     ;;
2363   x86_64-*-mingw*)
2364     target_configdirs="$target_configdirs target-winsup"
2365     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2366     ;;
2367   *-*-cygwin*)
2368     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2369     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2370     # always build newlib if winsup directory is present.
2371     if test -d "$srcdir/winsup/cygwin"; then
2372       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2373     elif test -d "$srcdir/newlib"; then
2374       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2375     fi
2376     ;;
2377   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2378   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2379     ;;
2380   i[3456789]86-*-pe)
2381     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2382     ;;
2383   i[3456789]86-*-sco3.2v5*)
2384     # The linker does not yet know about weak symbols in COFF,
2385     # and is not configured to handle mixed ELF and COFF.
2386     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2387     ;;
2388   i[3456789]86-*-sco*)
2389     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2390     ;;
2391   i[3456789]86-*-solaris2*)
2392     noconfigdirs="$noconfigdirs target-libgloss"
2393     ;;
2394   i[3456789]86-*-sysv4*)
2395     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2396     ;;
2397   i[3456789]86-*-beos*)
2398     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2399     ;;
2400   i[3456789]86-*-rdos*)
2401     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2402     ;;
2403   m32r-*-*)
2404     noconfigdirs="$noconfigdirs ${libgcj}"
2405     ;;
2406   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2407     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2408     ;;
2409   m68k-*-elf*)
2410     noconfigdirs="$noconfigdirs ${libgcj}"
2411     ;;
2412   m68k-*-coff*)
2413     noconfigdirs="$noconfigdirs ${libgcj}"
2414     ;;
2415   mcore-*-pe*)
2416   # The EPOC C++ environment does not support exceptions or rtti,
2417   # and so building libstdc++-v3 tends not to always work.
2418     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2419     ;;
2420   mmix-*-*)
2421     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2422     unsupported_languages="$unsupported_languages fortran java"
2423     ;;
2424   mn10200-*-*)
2425     noconfigdirs="$noconfigdirs ${libgcj}"
2426     ;;
2427   mn10300-*-*)
2428     noconfigdirs="$noconfigdirs ${libgcj}"
2429     ;;
2430   mt-*-*)
2431     noconfigdirs="$noconfigdirs sim"
2432     ;;
2433   powerpc-*-aix*)
2434     # copied from rs6000-*-* entry
2435     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2436     ;;
2437   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2438     target_configdirs="$target_configdirs target-winsup"
2439     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2440     # always build newlib.
2441     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2442     ;;
2443     # This is temporary until we can link against shared libraries
2444   powerpcle-*-solaris*)
2445     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2446     ;;
2447   powerpc-*-beos*)
2448     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2449     ;;
2450   powerpc-*-eabi)
2451     noconfigdirs="$noconfigdirs ${libgcj}"
2452     ;;
2453   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2454     ;;
2455   rs6000-*-lynxos*)
2456     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2457     ;;
2458   rs6000-*-aix*)
2459     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2460     ;;
2461   rs6000-*-*)
2462     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2463     ;;
2464   m68k-apollo-*)
2465     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2466     ;;
2467   mips*-*-irix5*)
2468     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2469     ;;
2470   mips*-*-irix6*)
2471     # Linking libjava exceeds command-line length limits on at least
2472     # IRIX 6.2, but not on IRIX 6.5.
2473     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2474     # <oldham@codesourcery.com>
2475     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2476     ;;
2477   mips*-*-bsd*)
2478     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2479     ;;
2480   mips64*-*-linux*)
2481     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2482     ;;
2483   mips*-*-linux*)
2484     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2485     ;;
2486   mips*-*-*)
2487     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2488     ;;
2489   romp-*-*)
2490     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2491     ;;
2492   sh-*-* | sh64-*-*)
2493     case "${host}" in
2494       i[3456789]86-*-vsta) ;; # don't add gprof back in
2495       i[3456789]86-*-go32*) ;; # don't add gprof back in
2496       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2497       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2498     esac
2499     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2500     ;;
2501   sparc-*-elf*)
2502     noconfigdirs="$noconfigdirs ${libgcj}"
2503     ;;
2504   sparc64-*-elf*)
2505     noconfigdirs="$noconfigdirs ${libgcj}"
2506     ;;
2507   sparclite-*-*)
2508     noconfigdirs="$noconfigdirs ${libgcj}"
2509     ;;
2510   sparc-*-sunos4*)
2511     noconfigdirs="$noconfigdirs ${libgcj}"
2512     if test x${is_cross_compiler} != xno ; then
2513            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2514     else
2515            use_gnu_ld=no
2516     fi
2517     ;;
2518   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2519     noconfigdirs="$noconfigdirs ${libgcj}"
2520     ;;
2521   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2522     ;;
2523   spu-*-*)
2524     skipdirs="target-libssp"
2525     ;;
2526   v810-*-*)
2527     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2528     ;;
2529   v850-*-*)
2530     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2531     ;;
2532   v850e-*-*)
2533     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2534     ;;
2535   v850ea-*-*)
2536     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2537     ;;
2538   vax-*-vms)
2539     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2540     ;;
2541   vax-*-*)
2542     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2543     ;;
2544   xtensa-*-*)
2545     noconfigdirs="$noconfigdirs ${libgcj}"
2546     ;;
2547   ip2k-*-*)
2548     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2549     ;;
2550   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2551     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2552     ;;
2553   *-*-lynxos*)
2554     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2555     ;;
2556   *-*-*)
2557     noconfigdirs="$noconfigdirs ${libgcj}"
2558     ;;
2559 esac
2560
2561 # If we aren't building newlib, then don't build libgloss, since libgloss
2562 # depends upon some newlib header files.
2563 case "${noconfigdirs}" in
2564   *target-libgloss*) ;;
2565   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2566 esac
2567
2568 # Work in distributions that contain no compiler tools, like Autoconf.
2569 tentative_cc=""
2570 host_makefile_frag=/dev/null
2571 if test -d ${srcdir}/config ; then
2572 case "${host}" in
2573   m68k-hp-hpux*)
2574     # Avoid "too much defining" errors from HPUX compiler.
2575     tentative_cc="cc -Wp,-H256000"
2576     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2577     # If it's HP/UX ar, this should be harmless.
2578     RANLIB="ar ts"
2579     ;;
2580   m68k-apollo-sysv*)
2581     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2582     ;;
2583   m68k-apollo-bsd*)
2584     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2585     # chokes on bfd, the compiler won't let you assign integers to enums, and
2586     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2587     # the apollo compiler" (the preferred version of GCC could be called cc,
2588     # or whatever), but I'm not sure leaving CC as cc is any better...
2589     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2590     # Used to have BISON=yacc.
2591     tentative_cc=gcc
2592     ;;
2593   m88k-dg-dgux*)
2594     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2595     ;;
2596   m88k-harris-cxux*)
2597     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2598     tentative_cc="cc -Xa"
2599     host_makefile_frag="config/mh-cxux"
2600     ;;
2601   m88k-motorola-sysv*)
2602     ;;
2603   mips*-dec-ultrix*)
2604     tentative_cc="cc -Wf,-XNg1000"
2605     host_makefile_frag="config/mh-decstation"
2606     ;;
2607   mips*-nec-sysv4*)
2608     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2609     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2610     host_makefile_frag="config/mh-necv4"
2611     ;;
2612   mips*-sgi-irix4*)
2613     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2614     # environment.  Also bump switch table size so that cp-parse will
2615     # compile.  Bump string length limit so linker builds.
2616     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2617     ;;
2618   mips*-*-sysv4*)
2619     host_makefile_frag="config/mh-sysv4"
2620     ;;
2621   mips*-*-sysv*)
2622     # This is for a MIPS running RISC/os 4.52C.
2623
2624     # This is needed for GDB, but needs to be in the top-level make because
2625     # if a library is compiled with the bsd headers and gets linked with the
2626     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2627     # a different size).
2628     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2629     # known except to select the sysv environment.  Could we use /proc instead?
2630     # These "sysv environments" and "bsd environments" often end up being a pain.
2631     #
2632     # This is not part of CFLAGS because perhaps not all C compilers have this
2633     # option.
2634     tentative_cc="cc -systype sysv"
2635     ;;
2636   i370-ibm-opened*)
2637     tentative_cc="c89"
2638     ;;
2639   i[3456789]86-*-sysv5*)
2640     host_makefile_frag="config/mh-sysv5"
2641     ;;
2642   i[3456789]86-*-dgux*)
2643     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2644     host_makefile_frag="config/mh-dgux386"
2645     ;;
2646   i[3456789]86-ncr-sysv4.3*)
2647     # The MetaWare compiler will generate a copyright message unless you
2648     # turn it off by adding the -Hnocopyr flag.
2649     tentative_cc="cc -Hnocopyr"
2650     ;;
2651   i[3456789]86-ncr-sysv4*)
2652     # for an NCR 3000 (i486/SVR4) system.
2653     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2654     # This compiler not only emits obnoxious copyright messages every time
2655     # you run it, but it chokes and dies on a whole bunch of GNU source
2656     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2657     tentative_cc="/usr/ccs/ATT/cc"
2658     host_makefile_frag="config/mh-ncr3000"
2659     ;;
2660   i[3456789]86-*-sco3.2v5*)
2661     ;;
2662   i[3456789]86-*-sco*)
2663     # The native C compiler botches some simple uses of const.  Unfortunately,
2664     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2665     tentative_cc="cc -Dconst="
2666     host_makefile_frag="config/mh-sco"
2667     ;;
2668   i[3456789]86-*-udk*)
2669     host_makefile_frag="config/mh-sysv5"
2670     ;;
2671   i[3456789]86-*-solaris2*)
2672     host_makefile_frag="config/mh-sysv4"
2673     ;;
2674   i[3456789]86-*-msdosdjgpp*)
2675     host_makefile_frag="config/mh-djgpp"
2676     ;;
2677   *-cygwin*)
2678     host_makefile_frag="config/mh-cygwin"
2679     ;;
2680   *-mingw32*)
2681     ;;
2682   *-mingw64*)
2683     ;;
2684   *-interix*)
2685     host_makefile_frag="config/mh-interix"
2686     ;;
2687   vax-*-ultrix2*)
2688     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2689     tentative_cc=gcc
2690     ;;
2691   *-*-solaris2*)
2692     host_makefile_frag="config/mh-solaris"
2693     ;;
2694   m68k-sun-sunos*)
2695     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2696     # without overflowing the jump tables (-J says to use a 32 bit table)
2697     tentative_cc="cc -J"
2698     ;;
2699   *-hp-hpux*)
2700     tentative_cc="cc -Wp,-H256000"
2701     ;;
2702   *-*-hiux*)
2703     tentative_cc="cc -Wp,-H256000"
2704     ;;
2705   rs6000-*-lynxos*)
2706     # /bin/cc is less than useful for our purposes.  Always use GCC
2707     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2708     host_makefile_frag="config/mh-lynxrs6k"
2709     ;;
2710   powerpc-*-darwin*)
2711     host_makefile_frag="config/mh-ppc-darwin"
2712     ;;
2713   powerpc-*-aix*)
2714     host_makefile_frag="config/mh-ppc-aix"
2715     ;;
2716   rs6000-*-aix*)
2717     host_makefile_frag="config/mh-ppc-aix"
2718     ;;
2719   *-*-lynxos*)
2720     # /bin/cc is less than useful for our purposes.  Always use GCC
2721     tentative_cc="/bin/gcc"
2722     ;;
2723   *-*-sysv4*)
2724     host_makefile_frag="config/mh-sysv4"
2725     ;;
2726   # This is placed last to prevent interfering with the cases above.
2727   i[3456789]86-*-*)
2728     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2729     host_makefile_frag="config/mh-x86omitfp"
2730     ;;
2731 esac
2732 fi
2733
2734 # If we aren't going to be using gcc, see if we can extract a definition
2735 # of CC from the fragment.
2736 # Actually, use the 'pre-extracted' version above.
2737 if test -z "${CC}" && test "${build}" = "${host}" ; then
2738   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2739   found=
2740   for dir in $PATH; do
2741     test -z "$dir" && dir=.
2742     if test -f $dir/gcc; then
2743       found=yes
2744       break
2745     fi
2746   done
2747   IFS="$save_ifs"
2748   if test -z "${found}" && test -n "${tentative_cc}" ; then
2749     CC=$tentative_cc
2750   fi
2751 fi
2752
2753 if test "${build}" != "${host}" ; then
2754   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2755 else
2756   CC_FOR_BUILD="\$(CC)"
2757 fi
2758
2759 ac_ext=c
2760 ac_cpp='$CPP $CPPFLAGS'
2761 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2762 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2763 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2764 if test -n "$ac_tool_prefix"; then
2765   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2766 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2767 echo "$as_me:$LINENO: checking for $ac_word" >&5
2768 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2769 if test "${ac_cv_prog_CC+set}" = set; then
2770   echo $ECHO_N "(cached) $ECHO_C" >&6
2771 else
2772   if test -n "$CC"; then
2773   ac_cv_prog_CC="$CC" # Let the user override the test.
2774 else
2775 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2776 for as_dir in $PATH
2777 do
2778   IFS=$as_save_IFS
2779   test -z "$as_dir" && as_dir=.
2780   for ac_exec_ext in '' $ac_executable_extensions; do
2781   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2782     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2783     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2784     break 2
2785   fi
2786 done
2787 done
2788
2789 fi
2790 fi
2791 CC=$ac_cv_prog_CC
2792 if test -n "$CC"; then
2793   echo "$as_me:$LINENO: result: $CC" >&5
2794 echo "${ECHO_T}$CC" >&6
2795 else
2796   echo "$as_me:$LINENO: result: no" >&5
2797 echo "${ECHO_T}no" >&6
2798 fi
2799
2800 fi
2801 if test -z "$ac_cv_prog_CC"; then
2802   ac_ct_CC=$CC
2803   # Extract the first word of "gcc", so it can be a program name with args.
2804 set dummy gcc; ac_word=$2
2805 echo "$as_me:$LINENO: checking for $ac_word" >&5
2806 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2807 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2808   echo $ECHO_N "(cached) $ECHO_C" >&6
2809 else
2810   if test -n "$ac_ct_CC"; then
2811   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2812 else
2813 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2814 for as_dir in $PATH
2815 do
2816   IFS=$as_save_IFS
2817   test -z "$as_dir" && as_dir=.
2818   for ac_exec_ext in '' $ac_executable_extensions; do
2819   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2820     ac_cv_prog_ac_ct_CC="gcc"
2821     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2822     break 2
2823   fi
2824 done
2825 done
2826
2827 fi
2828 fi
2829 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2830 if test -n "$ac_ct_CC"; then
2831   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2832 echo "${ECHO_T}$ac_ct_CC" >&6
2833 else
2834   echo "$as_me:$LINENO: result: no" >&5
2835 echo "${ECHO_T}no" >&6
2836 fi
2837
2838   CC=$ac_ct_CC
2839 else
2840   CC="$ac_cv_prog_CC"
2841 fi
2842
2843 if test -z "$CC"; then
2844   if test -n "$ac_tool_prefix"; then
2845   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2846 set dummy ${ac_tool_prefix}cc; ac_word=$2
2847 echo "$as_me:$LINENO: checking for $ac_word" >&5
2848 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2849 if test "${ac_cv_prog_CC+set}" = set; then
2850   echo $ECHO_N "(cached) $ECHO_C" >&6
2851 else
2852   if test -n "$CC"; then
2853   ac_cv_prog_CC="$CC" # Let the user override the test.
2854 else
2855 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2856 for as_dir in $PATH
2857 do
2858   IFS=$as_save_IFS
2859   test -z "$as_dir" && as_dir=.
2860   for ac_exec_ext in '' $ac_executable_extensions; do
2861   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2862     ac_cv_prog_CC="${ac_tool_prefix}cc"
2863     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2864     break 2
2865   fi
2866 done
2867 done
2868
2869 fi
2870 fi
2871 CC=$ac_cv_prog_CC
2872 if test -n "$CC"; then
2873   echo "$as_me:$LINENO: result: $CC" >&5
2874 echo "${ECHO_T}$CC" >&6
2875 else
2876   echo "$as_me:$LINENO: result: no" >&5
2877 echo "${ECHO_T}no" >&6
2878 fi
2879
2880 fi
2881 if test -z "$ac_cv_prog_CC"; then
2882   ac_ct_CC=$CC
2883   # Extract the first word of "cc", so it can be a program name with args.
2884 set dummy cc; ac_word=$2
2885 echo "$as_me:$LINENO: checking for $ac_word" >&5
2886 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2887 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2888   echo $ECHO_N "(cached) $ECHO_C" >&6
2889 else
2890   if test -n "$ac_ct_CC"; then
2891   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2892 else
2893 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2894 for as_dir in $PATH
2895 do
2896   IFS=$as_save_IFS
2897   test -z "$as_dir" && as_dir=.
2898   for ac_exec_ext in '' $ac_executable_extensions; do
2899   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2900     ac_cv_prog_ac_ct_CC="cc"
2901     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2902     break 2
2903   fi
2904 done
2905 done
2906
2907 fi
2908 fi
2909 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2910 if test -n "$ac_ct_CC"; then
2911   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2912 echo "${ECHO_T}$ac_ct_CC" >&6
2913 else
2914   echo "$as_me:$LINENO: result: no" >&5
2915 echo "${ECHO_T}no" >&6
2916 fi
2917
2918   CC=$ac_ct_CC
2919 else
2920   CC="$ac_cv_prog_CC"
2921 fi
2922
2923 fi
2924 if test -z "$CC"; then
2925   # Extract the first word of "cc", so it can be a program name with args.
2926 set dummy cc; ac_word=$2
2927 echo "$as_me:$LINENO: checking for $ac_word" >&5
2928 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2929 if test "${ac_cv_prog_CC+set}" = set; then
2930   echo $ECHO_N "(cached) $ECHO_C" >&6
2931 else
2932   if test -n "$CC"; then
2933   ac_cv_prog_CC="$CC" # Let the user override the test.
2934 else
2935   ac_prog_rejected=no
2936 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2937 for as_dir in $PATH
2938 do
2939   IFS=$as_save_IFS
2940   test -z "$as_dir" && as_dir=.
2941   for ac_exec_ext in '' $ac_executable_extensions; do
2942   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2943     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2944        ac_prog_rejected=yes
2945        continue
2946      fi
2947     ac_cv_prog_CC="cc"
2948     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2949     break 2
2950   fi
2951 done
2952 done
2953
2954 if test $ac_prog_rejected = yes; then
2955   # We found a bogon in the path, so make sure we never use it.
2956   set dummy $ac_cv_prog_CC
2957   shift
2958   if test $# != 0; then
2959     # We chose a different compiler from the bogus one.
2960     # However, it has the same basename, so the bogon will be chosen
2961     # first if we set CC to just the basename; use the full file name.
2962     shift
2963     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
2964   fi
2965 fi
2966 fi
2967 fi
2968 CC=$ac_cv_prog_CC
2969 if test -n "$CC"; then
2970   echo "$as_me:$LINENO: result: $CC" >&5
2971 echo "${ECHO_T}$CC" >&6
2972 else
2973   echo "$as_me:$LINENO: result: no" >&5
2974 echo "${ECHO_T}no" >&6
2975 fi
2976
2977 fi
2978 if test -z "$CC"; then
2979   if test -n "$ac_tool_prefix"; then
2980   for ac_prog in cl
2981   do
2982     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2983 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2984 echo "$as_me:$LINENO: checking for $ac_word" >&5
2985 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2986 if test "${ac_cv_prog_CC+set}" = set; then
2987   echo $ECHO_N "(cached) $ECHO_C" >&6
2988 else
2989   if test -n "$CC"; then
2990   ac_cv_prog_CC="$CC" # Let the user override the test.
2991 else
2992 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2993 for as_dir in $PATH
2994 do
2995   IFS=$as_save_IFS
2996   test -z "$as_dir" && as_dir=.
2997   for ac_exec_ext in '' $ac_executable_extensions; do
2998   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2999     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3000     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3001     break 2
3002   fi
3003 done
3004 done
3005
3006 fi
3007 fi
3008 CC=$ac_cv_prog_CC
3009 if test -n "$CC"; then
3010   echo "$as_me:$LINENO: result: $CC" >&5
3011 echo "${ECHO_T}$CC" >&6
3012 else
3013   echo "$as_me:$LINENO: result: no" >&5
3014 echo "${ECHO_T}no" >&6
3015 fi
3016
3017     test -n "$CC" && break
3018   done
3019 fi
3020 if test -z "$CC"; then
3021   ac_ct_CC=$CC
3022   for ac_prog in cl
3023 do
3024   # Extract the first word of "$ac_prog", so it can be a program name with args.
3025 set dummy $ac_prog; ac_word=$2
3026 echo "$as_me:$LINENO: checking for $ac_word" >&5
3027 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3028 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3029   echo $ECHO_N "(cached) $ECHO_C" >&6
3030 else
3031   if test -n "$ac_ct_CC"; then
3032   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3033 else
3034 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3035 for as_dir in $PATH
3036 do
3037   IFS=$as_save_IFS
3038   test -z "$as_dir" && as_dir=.
3039   for ac_exec_ext in '' $ac_executable_extensions; do
3040   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3041     ac_cv_prog_ac_ct_CC="$ac_prog"
3042     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3043     break 2
3044   fi
3045 done
3046 done
3047
3048 fi
3049 fi
3050 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3051 if test -n "$ac_ct_CC"; then
3052   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3053 echo "${ECHO_T}$ac_ct_CC" >&6
3054 else
3055   echo "$as_me:$LINENO: result: no" >&5
3056 echo "${ECHO_T}no" >&6
3057 fi
3058
3059   test -n "$ac_ct_CC" && break
3060 done
3061
3062   CC=$ac_ct_CC
3063 fi
3064
3065 fi
3066
3067
3068 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3069 See \`config.log' for more details." >&5
3070 echo "$as_me: error: no acceptable C compiler found in \$PATH
3071 See \`config.log' for more details." >&2;}
3072    { (exit 1); exit 1; }; }
3073
3074 # Provide some information about the compiler.
3075 echo "$as_me:$LINENO:" \
3076      "checking for C compiler version" >&5
3077 ac_compiler=`set X $ac_compile; echo $2`
3078 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3079   (eval $ac_compiler --version </dev/null >&5) 2>&5
3080   ac_status=$?
3081   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3082   (exit $ac_status); }
3083 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3084   (eval $ac_compiler -v </dev/null >&5) 2>&5
3085   ac_status=$?
3086   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3087   (exit $ac_status); }
3088 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3089   (eval $ac_compiler -V </dev/null >&5) 2>&5
3090   ac_status=$?
3091   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3092   (exit $ac_status); }
3093
3094 cat >conftest.$ac_ext <<_ACEOF
3095 /* confdefs.h.  */
3096 _ACEOF
3097 cat confdefs.h >>conftest.$ac_ext
3098 cat >>conftest.$ac_ext <<_ACEOF
3099 /* end confdefs.h.  */
3100
3101 int
3102 main ()
3103 {
3104
3105   ;
3106   return 0;
3107 }
3108 _ACEOF
3109 ac_clean_files_save=$ac_clean_files
3110 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3111 # Try to create an executable without -o first, disregard a.out.
3112 # It will help us diagnose broken compilers, and finding out an intuition
3113 # of exeext.
3114 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3115 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3116 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3117 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3118   (eval $ac_link_default) 2>&5
3119   ac_status=$?
3120   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3121   (exit $ac_status); }; then
3122   # Find the output, starting from the most likely.  This scheme is
3123 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3124 # resort.
3125
3126 # Be careful to initialize this variable, since it used to be cached.
3127 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3128 ac_cv_exeext=
3129 # b.out is created by i960 compilers.
3130 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3131 do
3132   test -f "$ac_file" || continue
3133   case $ac_file in
3134     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3135         ;;
3136     conftest.$ac_ext )
3137         # This is the source file.
3138         ;;
3139     [ab].out )
3140         # We found the default executable, but exeext='' is most
3141         # certainly right.
3142         break;;
3143     *.* )
3144         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3145         # FIXME: I believe we export ac_cv_exeext for Libtool,
3146         # but it would be cool to find out if it's true.  Does anybody
3147         # maintain Libtool? --akim.
3148         export ac_cv_exeext
3149         break;;
3150     * )
3151         break;;
3152   esac
3153 done
3154 else
3155   echo "$as_me: failed program was:" >&5
3156 sed 's/^/| /' conftest.$ac_ext >&5
3157
3158 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3159 See \`config.log' for more details." >&5
3160 echo "$as_me: error: C compiler cannot create executables
3161 See \`config.log' for more details." >&2;}
3162    { (exit 77); exit 77; }; }
3163 fi
3164
3165 ac_exeext=$ac_cv_exeext
3166 echo "$as_me:$LINENO: result: $ac_file" >&5
3167 echo "${ECHO_T}$ac_file" >&6
3168
3169 # Check the compiler produces executables we can run.  If not, either
3170 # the compiler is broken, or we cross compile.
3171 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3172 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3173 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3174 # If not cross compiling, check that we can run a simple program.
3175 if test "$cross_compiling" != yes; then
3176   if { ac_try='./$ac_file'
3177   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3178   (eval $ac_try) 2>&5
3179   ac_status=$?
3180   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3181   (exit $ac_status); }; }; then
3182     cross_compiling=no
3183   else
3184     if test "$cross_compiling" = maybe; then
3185         cross_compiling=yes
3186     else
3187         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3188 If you meant to cross compile, use \`--host'.
3189 See \`config.log' for more details." >&5
3190 echo "$as_me: error: cannot run C compiled programs.
3191 If you meant to cross compile, use \`--host'.
3192 See \`config.log' for more details." >&2;}
3193    { (exit 1); exit 1; }; }
3194     fi
3195   fi
3196 fi
3197 echo "$as_me:$LINENO: result: yes" >&5
3198 echo "${ECHO_T}yes" >&6
3199
3200 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3201 ac_clean_files=$ac_clean_files_save
3202 # Check the compiler produces executables we can run.  If not, either
3203 # the compiler is broken, or we cross compile.
3204 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3205 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3206 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3207 echo "${ECHO_T}$cross_compiling" >&6
3208
3209 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3210 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3211 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3212   (eval $ac_link) 2>&5
3213   ac_status=$?
3214   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3215   (exit $ac_status); }; then
3216   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3217 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3218 # work properly (i.e., refer to `conftest.exe'), while it won't with
3219 # `rm'.
3220 for ac_file in conftest.exe conftest conftest.*; do
3221   test -f "$ac_file" || continue
3222   case $ac_file in
3223     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3224     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3225           export ac_cv_exeext
3226           break;;
3227     * ) break;;
3228   esac
3229 done
3230 else
3231   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3232 See \`config.log' for more details." >&5
3233 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3234 See \`config.log' for more details." >&2;}
3235    { (exit 1); exit 1; }; }
3236 fi
3237
3238 rm -f conftest$ac_cv_exeext
3239 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3240 echo "${ECHO_T}$ac_cv_exeext" >&6
3241
3242 rm -f conftest.$ac_ext
3243 EXEEXT=$ac_cv_exeext
3244 ac_exeext=$EXEEXT
3245 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3246 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3247 if test "${ac_cv_objext+set}" = set; then
3248   echo $ECHO_N "(cached) $ECHO_C" >&6
3249 else
3250   cat >conftest.$ac_ext <<_ACEOF
3251 /* confdefs.h.  */
3252 _ACEOF
3253 cat confdefs.h >>conftest.$ac_ext
3254 cat >>conftest.$ac_ext <<_ACEOF
3255 /* end confdefs.h.  */
3256
3257 int
3258 main ()
3259 {
3260
3261   ;
3262   return 0;
3263 }
3264 _ACEOF
3265 rm -f conftest.o conftest.obj
3266 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3267   (eval $ac_compile) 2>&5
3268   ac_status=$?
3269   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3270   (exit $ac_status); }; then
3271   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3272   case $ac_file in
3273     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3274     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3275        break;;
3276   esac
3277 done
3278 else
3279   echo "$as_me: failed program was:" >&5
3280 sed 's/^/| /' conftest.$ac_ext >&5
3281
3282 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3283 See \`config.log' for more details." >&5
3284 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3285 See \`config.log' for more details." >&2;}
3286    { (exit 1); exit 1; }; }
3287 fi
3288
3289 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3290 fi
3291 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3292 echo "${ECHO_T}$ac_cv_objext" >&6
3293 OBJEXT=$ac_cv_objext
3294 ac_objext=$OBJEXT
3295 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3296 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3297 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3298   echo $ECHO_N "(cached) $ECHO_C" >&6
3299 else
3300   cat >conftest.$ac_ext <<_ACEOF
3301 /* confdefs.h.  */
3302 _ACEOF
3303 cat confdefs.h >>conftest.$ac_ext
3304 cat >>conftest.$ac_ext <<_ACEOF
3305 /* end confdefs.h.  */
3306
3307 int
3308 main ()
3309 {
3310 #ifndef __GNUC__
3311        choke me
3312 #endif
3313
3314   ;
3315   return 0;
3316 }
3317 _ACEOF
3318 rm -f conftest.$ac_objext
3319 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3320   (eval $ac_compile) 2>conftest.er1
3321   ac_status=$?
3322   grep -v '^ *+' conftest.er1 >conftest.err
3323   rm -f conftest.er1
3324   cat conftest.err >&5
3325   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3326   (exit $ac_status); } &&
3327          { ac_try='test -z "$ac_c_werror_flag"
3328                          || test ! -s conftest.err'
3329   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3330   (eval $ac_try) 2>&5
3331   ac_status=$?
3332   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3333   (exit $ac_status); }; } &&
3334          { ac_try='test -s conftest.$ac_objext'
3335   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3336   (eval $ac_try) 2>&5
3337   ac_status=$?
3338   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3339   (exit $ac_status); }; }; then
3340   ac_compiler_gnu=yes
3341 else
3342   echo "$as_me: failed program was:" >&5
3343 sed 's/^/| /' conftest.$ac_ext >&5
3344
3345 ac_compiler_gnu=no
3346 fi
3347 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3348 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3349
3350 fi
3351 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3352 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3353 GCC=`test $ac_compiler_gnu = yes && echo yes`
3354 ac_test_CFLAGS=${CFLAGS+set}
3355 ac_save_CFLAGS=$CFLAGS
3356 CFLAGS="-g"
3357 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3358 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3359 if test "${ac_cv_prog_cc_g+set}" = set; then
3360   echo $ECHO_N "(cached) $ECHO_C" >&6
3361 else
3362   cat >conftest.$ac_ext <<_ACEOF
3363 /* confdefs.h.  */
3364 _ACEOF
3365 cat confdefs.h >>conftest.$ac_ext
3366 cat >>conftest.$ac_ext <<_ACEOF
3367 /* end confdefs.h.  */
3368
3369 int
3370 main ()
3371 {
3372
3373   ;
3374   return 0;
3375 }
3376 _ACEOF
3377 rm -f conftest.$ac_objext
3378 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3379   (eval $ac_compile) 2>conftest.er1
3380   ac_status=$?
3381   grep -v '^ *+' conftest.er1 >conftest.err
3382   rm -f conftest.er1
3383   cat conftest.err >&5
3384   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3385   (exit $ac_status); } &&
3386          { ac_try='test -z "$ac_c_werror_flag"
3387                          || test ! -s conftest.err'
3388   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3389   (eval $ac_try) 2>&5
3390   ac_status=$?
3391   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3392   (exit $ac_status); }; } &&
3393          { ac_try='test -s conftest.$ac_objext'
3394   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3395   (eval $ac_try) 2>&5
3396   ac_status=$?
3397   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3398   (exit $ac_status); }; }; then
3399   ac_cv_prog_cc_g=yes
3400 else
3401   echo "$as_me: failed program was:" >&5
3402 sed 's/^/| /' conftest.$ac_ext >&5
3403
3404 ac_cv_prog_cc_g=no
3405 fi
3406 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3407 fi
3408 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3409 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3410 if test "$ac_test_CFLAGS" = set; then
3411   CFLAGS=$ac_save_CFLAGS
3412 elif test $ac_cv_prog_cc_g = yes; then
3413   if test "$GCC" = yes; then
3414     CFLAGS="-g -O2"
3415   else
3416     CFLAGS="-g"
3417   fi
3418 else
3419   if test "$GCC" = yes; then
3420     CFLAGS="-O2"
3421   else
3422     CFLAGS=
3423   fi
3424 fi
3425 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3426 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3427 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3428   echo $ECHO_N "(cached) $ECHO_C" >&6
3429 else
3430   ac_cv_prog_cc_stdc=no
3431 ac_save_CC=$CC
3432 cat >conftest.$ac_ext <<_ACEOF
3433 /* confdefs.h.  */
3434 _ACEOF
3435 cat confdefs.h >>conftest.$ac_ext
3436 cat >>conftest.$ac_ext <<_ACEOF
3437 /* end confdefs.h.  */
3438 #include <stdarg.h>
3439 #include <stdio.h>
3440 #include <sys/types.h>
3441 #include <sys/stat.h>
3442 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3443 struct buf { int x; };
3444 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3445 static char *e (p, i)
3446      char **p;
3447      int i;
3448 {
3449   return p[i];
3450 }
3451 static char *f (char * (*g) (char **, int), char **p, ...)
3452 {
3453   char *s;
3454   va_list v;
3455   va_start (v,p);
3456   s = g (p, va_arg (v,int));
3457   va_end (v);
3458   return s;
3459 }
3460
3461 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3462    function prototypes and stuff, but not '\xHH' hex character constants.
3463    These don't provoke an error unfortunately, instead are silently treated
3464    as 'x'.  The following induces an error, until -std1 is added to get
3465    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3466    array size at least.  It's necessary to write '\x00'==0 to get something
3467    that's true only with -std1.  */
3468 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3469
3470 int test (int i, double x);
3471 struct s1 {int (*f) (int a);};
3472 struct s2 {int (*f) (double a);};
3473 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3474 int argc;
3475 char **argv;
3476 int
3477 main ()
3478 {
3479 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3480   ;
3481   return 0;
3482 }
3483 _ACEOF
3484 # Don't try gcc -ansi; that turns off useful extensions and
3485 # breaks some systems' header files.
3486 # AIX                   -qlanglvl=ansi
3487 # Ultrix and OSF/1      -std1
3488 # HP-UX 10.20 and later -Ae
3489 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3490 # SVR4                  -Xc -D__EXTENSIONS__
3491 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3492 do
3493   CC="$ac_save_CC $ac_arg"
3494   rm -f conftest.$ac_objext
3495 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3496   (eval $ac_compile) 2>conftest.er1
3497   ac_status=$?
3498   grep -v '^ *+' conftest.er1 >conftest.err
3499   rm -f conftest.er1
3500   cat conftest.err >&5
3501   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3502   (exit $ac_status); } &&
3503          { ac_try='test -z "$ac_c_werror_flag"
3504                          || test ! -s conftest.err'
3505   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3506   (eval $ac_try) 2>&5
3507   ac_status=$?
3508   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3509   (exit $ac_status); }; } &&
3510          { ac_try='test -s conftest.$ac_objext'
3511   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3512   (eval $ac_try) 2>&5
3513   ac_status=$?
3514   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3515   (exit $ac_status); }; }; then
3516   ac_cv_prog_cc_stdc=$ac_arg
3517 break
3518 else
3519   echo "$as_me: failed program was:" >&5
3520 sed 's/^/| /' conftest.$ac_ext >&5
3521
3522 fi
3523 rm -f conftest.err conftest.$ac_objext
3524 done
3525 rm -f conftest.$ac_ext conftest.$ac_objext
3526 CC=$ac_save_CC
3527
3528 fi
3529
3530 case "x$ac_cv_prog_cc_stdc" in
3531   x|xno)
3532     echo "$as_me:$LINENO: result: none needed" >&5
3533 echo "${ECHO_T}none needed" >&6 ;;
3534   *)
3535     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3536 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3537     CC="$CC $ac_cv_prog_cc_stdc" ;;
3538 esac
3539
3540 # Some people use a C++ compiler to compile C.  Since we use `exit',
3541 # in C++ we need to declare it.  In case someone uses the same compiler
3542 # for both compiling C and C++ we need to have the C++ compiler decide
3543 # the declaration of exit, since it's the most demanding environment.
3544 cat >conftest.$ac_ext <<_ACEOF
3545 #ifndef __cplusplus
3546   choke me
3547 #endif
3548 _ACEOF
3549 rm -f conftest.$ac_objext
3550 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3551   (eval $ac_compile) 2>conftest.er1
3552   ac_status=$?
3553   grep -v '^ *+' conftest.er1 >conftest.err
3554   rm -f conftest.er1
3555   cat conftest.err >&5
3556   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3557   (exit $ac_status); } &&
3558          { ac_try='test -z "$ac_c_werror_flag"
3559                          || test ! -s conftest.err'
3560   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3561   (eval $ac_try) 2>&5
3562   ac_status=$?
3563   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3564   (exit $ac_status); }; } &&
3565          { ac_try='test -s conftest.$ac_objext'
3566   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3567   (eval $ac_try) 2>&5
3568   ac_status=$?
3569   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3570   (exit $ac_status); }; }; then
3571   for ac_declaration in \
3572    '' \
3573    'extern "C" void std::exit (int) throw (); using std::exit;' \
3574    'extern "C" void std::exit (int); using std::exit;' \
3575    'extern "C" void exit (int) throw ();' \
3576    'extern "C" void exit (int);' \
3577    'void exit (int);'
3578 do
3579   cat >conftest.$ac_ext <<_ACEOF
3580 /* confdefs.h.  */
3581 _ACEOF
3582 cat confdefs.h >>conftest.$ac_ext
3583 cat >>conftest.$ac_ext <<_ACEOF
3584 /* end confdefs.h.  */
3585 $ac_declaration
3586 #include <stdlib.h>
3587 int
3588 main ()
3589 {
3590 exit (42);
3591   ;
3592   return 0;
3593 }
3594 _ACEOF
3595 rm -f conftest.$ac_objext
3596 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3597   (eval $ac_compile) 2>conftest.er1
3598   ac_status=$?
3599   grep -v '^ *+' conftest.er1 >conftest.err
3600   rm -f conftest.er1
3601   cat conftest.err >&5
3602   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3603   (exit $ac_status); } &&
3604          { ac_try='test -z "$ac_c_werror_flag"
3605                          || test ! -s conftest.err'
3606   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3607   (eval $ac_try) 2>&5
3608   ac_status=$?
3609   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3610   (exit $ac_status); }; } &&
3611          { ac_try='test -s conftest.$ac_objext'
3612   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3613   (eval $ac_try) 2>&5
3614   ac_status=$?
3615   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3616   (exit $ac_status); }; }; then
3617   :
3618 else
3619   echo "$as_me: failed program was:" >&5
3620 sed 's/^/| /' conftest.$ac_ext >&5
3621
3622 continue
3623 fi
3624 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3625   cat >conftest.$ac_ext <<_ACEOF
3626 /* confdefs.h.  */
3627 _ACEOF
3628 cat confdefs.h >>conftest.$ac_ext
3629 cat >>conftest.$ac_ext <<_ACEOF
3630 /* end confdefs.h.  */
3631 $ac_declaration
3632 int
3633 main ()
3634 {
3635 exit (42);
3636   ;
3637   return 0;
3638 }
3639 _ACEOF
3640 rm -f conftest.$ac_objext
3641 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3642   (eval $ac_compile) 2>conftest.er1
3643   ac_status=$?
3644   grep -v '^ *+' conftest.er1 >conftest.err
3645   rm -f conftest.er1
3646   cat conftest.err >&5
3647   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3648   (exit $ac_status); } &&
3649          { ac_try='test -z "$ac_c_werror_flag"
3650                          || test ! -s conftest.err'
3651   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3652   (eval $ac_try) 2>&5
3653   ac_status=$?
3654   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3655   (exit $ac_status); }; } &&
3656          { ac_try='test -s conftest.$ac_objext'
3657   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3658   (eval $ac_try) 2>&5
3659   ac_status=$?
3660   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3661   (exit $ac_status); }; }; then
3662   break
3663 else
3664   echo "$as_me: failed program was:" >&5
3665 sed 's/^/| /' conftest.$ac_ext >&5
3666
3667 fi
3668 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3669 done
3670 rm -f conftest*
3671 if test -n "$ac_declaration"; then
3672   echo '#ifdef __cplusplus' >>confdefs.h
3673   echo $ac_declaration      >>confdefs.h
3674   echo '#endif'             >>confdefs.h
3675 fi
3676
3677 else
3678   echo "$as_me: failed program was:" >&5
3679 sed 's/^/| /' conftest.$ac_ext >&5
3680
3681 fi
3682 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3683 ac_ext=c
3684 ac_cpp='$CPP $CPPFLAGS'
3685 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3686 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3687 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3688
3689 ac_ext=cc
3690 ac_cpp='$CXXCPP $CPPFLAGS'
3691 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3692 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3693 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3694 if test -n "$ac_tool_prefix"; then
3695   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3696   do
3697     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3698 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3699 echo "$as_me:$LINENO: checking for $ac_word" >&5
3700 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3701 if test "${ac_cv_prog_CXX+set}" = set; then
3702   echo $ECHO_N "(cached) $ECHO_C" >&6
3703 else
3704   if test -n "$CXX"; then
3705   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3706 else
3707 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3708 for as_dir in $PATH
3709 do
3710   IFS=$as_save_IFS
3711   test -z "$as_dir" && as_dir=.
3712   for ac_exec_ext in '' $ac_executable_extensions; do
3713   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3714     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3715     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3716     break 2
3717   fi
3718 done
3719 done
3720
3721 fi
3722 fi
3723 CXX=$ac_cv_prog_CXX
3724 if test -n "$CXX"; then
3725   echo "$as_me:$LINENO: result: $CXX" >&5
3726 echo "${ECHO_T}$CXX" >&6
3727 else
3728   echo "$as_me:$LINENO: result: no" >&5
3729 echo "${ECHO_T}no" >&6
3730 fi
3731
3732     test -n "$CXX" && break
3733   done
3734 fi
3735 if test -z "$CXX"; then
3736   ac_ct_CXX=$CXX
3737   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3738 do
3739   # Extract the first word of "$ac_prog", so it can be a program name with args.
3740 set dummy $ac_prog; ac_word=$2
3741 echo "$as_me:$LINENO: checking for $ac_word" >&5
3742 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3743 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3744   echo $ECHO_N "(cached) $ECHO_C" >&6
3745 else
3746   if test -n "$ac_ct_CXX"; then
3747   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3748 else
3749 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3750 for as_dir in $PATH
3751 do
3752   IFS=$as_save_IFS
3753   test -z "$as_dir" && as_dir=.
3754   for ac_exec_ext in '' $ac_executable_extensions; do
3755   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3756     ac_cv_prog_ac_ct_CXX="$ac_prog"
3757     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3758     break 2
3759   fi
3760 done
3761 done
3762
3763 fi
3764 fi
3765 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3766 if test -n "$ac_ct_CXX"; then
3767   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3768 echo "${ECHO_T}$ac_ct_CXX" >&6
3769 else
3770   echo "$as_me:$LINENO: result: no" >&5
3771 echo "${ECHO_T}no" >&6
3772 fi
3773
3774   test -n "$ac_ct_CXX" && break
3775 done
3776 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3777
3778   CXX=$ac_ct_CXX
3779 fi
3780
3781
3782 # Provide some information about the compiler.
3783 echo "$as_me:$LINENO:" \
3784      "checking for C++ compiler version" >&5
3785 ac_compiler=`set X $ac_compile; echo $2`
3786 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3787   (eval $ac_compiler --version </dev/null >&5) 2>&5
3788   ac_status=$?
3789   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3790   (exit $ac_status); }
3791 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3792   (eval $ac_compiler -v </dev/null >&5) 2>&5
3793   ac_status=$?
3794   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3795   (exit $ac_status); }
3796 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3797   (eval $ac_compiler -V </dev/null >&5) 2>&5
3798   ac_status=$?
3799   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3800   (exit $ac_status); }
3801
3802 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3803 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3804 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3805   echo $ECHO_N "(cached) $ECHO_C" >&6
3806 else
3807   cat >conftest.$ac_ext <<_ACEOF
3808 /* confdefs.h.  */
3809 _ACEOF
3810 cat confdefs.h >>conftest.$ac_ext
3811 cat >>conftest.$ac_ext <<_ACEOF
3812 /* end confdefs.h.  */
3813
3814 int
3815 main ()
3816 {
3817 #ifndef __GNUC__
3818        choke me
3819 #endif
3820
3821   ;
3822   return 0;
3823 }
3824 _ACEOF
3825 rm -f conftest.$ac_objext
3826 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3827   (eval $ac_compile) 2>conftest.er1
3828   ac_status=$?
3829   grep -v '^ *+' conftest.er1 >conftest.err
3830   rm -f conftest.er1
3831   cat conftest.err >&5
3832   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3833   (exit $ac_status); } &&
3834          { ac_try='test -z "$ac_cxx_werror_flag"
3835                          || test ! -s conftest.err'
3836   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3837   (eval $ac_try) 2>&5
3838   ac_status=$?
3839   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3840   (exit $ac_status); }; } &&
3841          { ac_try='test -s conftest.$ac_objext'
3842   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3843   (eval $ac_try) 2>&5
3844   ac_status=$?
3845   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3846   (exit $ac_status); }; }; then
3847   ac_compiler_gnu=yes
3848 else
3849   echo "$as_me: failed program was:" >&5
3850 sed 's/^/| /' conftest.$ac_ext >&5
3851
3852 ac_compiler_gnu=no
3853 fi
3854 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3855 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3856
3857 fi
3858 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3859 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
3860 GXX=`test $ac_compiler_gnu = yes && echo yes`
3861 ac_test_CXXFLAGS=${CXXFLAGS+set}
3862 ac_save_CXXFLAGS=$CXXFLAGS
3863 CXXFLAGS="-g"
3864 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3865 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
3866 if test "${ac_cv_prog_cxx_g+set}" = set; then
3867   echo $ECHO_N "(cached) $ECHO_C" >&6
3868 else
3869   cat >conftest.$ac_ext <<_ACEOF
3870 /* confdefs.h.  */
3871 _ACEOF
3872 cat confdefs.h >>conftest.$ac_ext
3873 cat >>conftest.$ac_ext <<_ACEOF
3874 /* end confdefs.h.  */
3875
3876 int
3877 main ()
3878 {
3879
3880   ;
3881   return 0;
3882 }
3883 _ACEOF
3884 rm -f conftest.$ac_objext
3885 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3886   (eval $ac_compile) 2>conftest.er1
3887   ac_status=$?
3888   grep -v '^ *+' conftest.er1 >conftest.err
3889   rm -f conftest.er1
3890   cat conftest.err >&5
3891   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3892   (exit $ac_status); } &&
3893          { ac_try='test -z "$ac_cxx_werror_flag"
3894                          || test ! -s conftest.err'
3895   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3896   (eval $ac_try) 2>&5
3897   ac_status=$?
3898   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3899   (exit $ac_status); }; } &&
3900          { ac_try='test -s conftest.$ac_objext'
3901   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3902   (eval $ac_try) 2>&5
3903   ac_status=$?
3904   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3905   (exit $ac_status); }; }; then
3906   ac_cv_prog_cxx_g=yes
3907 else
3908   echo "$as_me: failed program was:" >&5
3909 sed 's/^/| /' conftest.$ac_ext >&5
3910
3911 ac_cv_prog_cxx_g=no
3912 fi
3913 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3914 fi
3915 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3916 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
3917 if test "$ac_test_CXXFLAGS" = set; then
3918   CXXFLAGS=$ac_save_CXXFLAGS
3919 elif test $ac_cv_prog_cxx_g = yes; then
3920   if test "$GXX" = yes; then
3921     CXXFLAGS="-g -O2"
3922   else
3923     CXXFLAGS="-g"
3924   fi
3925 else
3926   if test "$GXX" = yes; then
3927     CXXFLAGS="-O2"
3928   else
3929     CXXFLAGS=
3930   fi
3931 fi
3932 for ac_declaration in \
3933    '' \
3934    'extern "C" void std::exit (int) throw (); using std::exit;' \
3935    'extern "C" void std::exit (int); using std::exit;' \
3936    'extern "C" void exit (int) throw ();' \
3937    'extern "C" void exit (int);' \
3938    'void exit (int);'
3939 do
3940   cat >conftest.$ac_ext <<_ACEOF
3941 /* confdefs.h.  */
3942 _ACEOF
3943 cat confdefs.h >>conftest.$ac_ext
3944 cat >>conftest.$ac_ext <<_ACEOF
3945 /* end confdefs.h.  */
3946 $ac_declaration
3947 #include <stdlib.h>
3948 int
3949 main ()
3950 {
3951 exit (42);
3952   ;
3953   return 0;
3954 }
3955 _ACEOF
3956 rm -f conftest.$ac_objext
3957 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3958   (eval $ac_compile) 2>conftest.er1
3959   ac_status=$?
3960   grep -v '^ *+' conftest.er1 >conftest.err
3961   rm -f conftest.er1
3962   cat conftest.err >&5
3963   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3964   (exit $ac_status); } &&
3965          { ac_try='test -z "$ac_cxx_werror_flag"
3966                          || test ! -s conftest.err'
3967   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3968   (eval $ac_try) 2>&5
3969   ac_status=$?
3970   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3971   (exit $ac_status); }; } &&
3972          { ac_try='test -s conftest.$ac_objext'
3973   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3974   (eval $ac_try) 2>&5
3975   ac_status=$?
3976   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3977   (exit $ac_status); }; }; then
3978   :
3979 else
3980   echo "$as_me: failed program was:" >&5
3981 sed 's/^/| /' conftest.$ac_ext >&5
3982
3983 continue
3984 fi
3985 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3986   cat >conftest.$ac_ext <<_ACEOF
3987 /* confdefs.h.  */
3988 _ACEOF
3989 cat confdefs.h >>conftest.$ac_ext
3990 cat >>conftest.$ac_ext <<_ACEOF
3991 /* end confdefs.h.  */
3992 $ac_declaration
3993 int
3994 main ()
3995 {
3996 exit (42);
3997   ;
3998   return 0;
3999 }
4000 _ACEOF
4001 rm -f conftest.$ac_objext
4002 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4003   (eval $ac_compile) 2>conftest.er1
4004   ac_status=$?
4005   grep -v '^ *+' conftest.er1 >conftest.err
4006   rm -f conftest.er1
4007   cat conftest.err >&5
4008   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4009   (exit $ac_status); } &&
4010          { ac_try='test -z "$ac_cxx_werror_flag"
4011                          || test ! -s conftest.err'
4012   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4013   (eval $ac_try) 2>&5
4014   ac_status=$?
4015   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4016   (exit $ac_status); }; } &&
4017          { ac_try='test -s conftest.$ac_objext'
4018   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4019   (eval $ac_try) 2>&5
4020   ac_status=$?
4021   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4022   (exit $ac_status); }; }; then
4023   break
4024 else
4025   echo "$as_me: failed program was:" >&5
4026 sed 's/^/| /' conftest.$ac_ext >&5
4027
4028 fi
4029 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4030 done
4031 rm -f conftest*
4032 if test -n "$ac_declaration"; then
4033   echo '#ifdef __cplusplus' >>confdefs.h
4034   echo $ac_declaration      >>confdefs.h
4035   echo '#endif'             >>confdefs.h
4036 fi
4037
4038 ac_ext=c
4039 ac_cpp='$CPP $CPPFLAGS'
4040 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4041 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4042 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4043
4044
4045 # We must set the default linker to the linker used by gcc for the correct
4046 # operation of libtool.  If LD is not defined and we are using gcc, try to
4047 # set the LD default to the ld used by gcc.
4048 if test -z "$LD"; then
4049   if test "$GCC" = yes; then
4050     case $build in
4051     *-*-mingw*)
4052       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4053     *)
4054       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4055     esac
4056     case $gcc_prog_ld in
4057     # Accept absolute paths.
4058     [\\/]* | [A-Za-z]:[\\/]*)
4059       LD="$gcc_prog_ld" ;;
4060     esac
4061   fi
4062 fi
4063
4064
4065
4066
4067 if test -n "$ac_tool_prefix"; then
4068   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4069 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4070 echo "$as_me:$LINENO: checking for $ac_word" >&5
4071 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4072 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4073   echo $ECHO_N "(cached) $ECHO_C" >&6
4074 else
4075   if test -n "$GNATBIND"; then
4076   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4077 else
4078 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4079 for as_dir in $PATH
4080 do
4081   IFS=$as_save_IFS
4082   test -z "$as_dir" && as_dir=.
4083   for ac_exec_ext in '' $ac_executable_extensions; do
4084   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4085     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4086     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4087     break 2
4088   fi
4089 done
4090 done
4091
4092 fi
4093 fi
4094 GNATBIND=$ac_cv_prog_GNATBIND
4095 if test -n "$GNATBIND"; then
4096   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4097 echo "${ECHO_T}$GNATBIND" >&6
4098 else
4099   echo "$as_me:$LINENO: result: no" >&5
4100 echo "${ECHO_T}no" >&6
4101 fi
4102
4103 fi
4104 if test -z "$ac_cv_prog_GNATBIND"; then
4105   ac_ct_GNATBIND=$GNATBIND
4106   # Extract the first word of "gnatbind", so it can be a program name with args.
4107 set dummy gnatbind; ac_word=$2
4108 echo "$as_me:$LINENO: checking for $ac_word" >&5
4109 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4110 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4111   echo $ECHO_N "(cached) $ECHO_C" >&6
4112 else
4113   if test -n "$ac_ct_GNATBIND"; then
4114   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4115 else
4116 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4117 for as_dir in $PATH
4118 do
4119   IFS=$as_save_IFS
4120   test -z "$as_dir" && as_dir=.
4121   for ac_exec_ext in '' $ac_executable_extensions; do
4122   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4123     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4124     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4125     break 2
4126   fi
4127 done
4128 done
4129
4130   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4131 fi
4132 fi
4133 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4134 if test -n "$ac_ct_GNATBIND"; then
4135   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4136 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4137 else
4138   echo "$as_me:$LINENO: result: no" >&5
4139 echo "${ECHO_T}no" >&6
4140 fi
4141
4142   GNATBIND=$ac_ct_GNATBIND
4143 else
4144   GNATBIND="$ac_cv_prog_GNATBIND"
4145 fi
4146
4147 if test -n "$ac_tool_prefix"; then
4148   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4149 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4150 echo "$as_me:$LINENO: checking for $ac_word" >&5
4151 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4152 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4153   echo $ECHO_N "(cached) $ECHO_C" >&6
4154 else
4155   if test -n "$GNATMAKE"; then
4156   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4157 else
4158 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4159 for as_dir in $PATH
4160 do
4161   IFS=$as_save_IFS
4162   test -z "$as_dir" && as_dir=.
4163   for ac_exec_ext in '' $ac_executable_extensions; do
4164   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4165     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4166     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4167     break 2
4168   fi
4169 done
4170 done
4171
4172 fi
4173 fi
4174 GNATMAKE=$ac_cv_prog_GNATMAKE
4175 if test -n "$GNATMAKE"; then
4176   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4177 echo "${ECHO_T}$GNATMAKE" >&6
4178 else
4179   echo "$as_me:$LINENO: result: no" >&5
4180 echo "${ECHO_T}no" >&6
4181 fi
4182
4183 fi
4184 if test -z "$ac_cv_prog_GNATMAKE"; then
4185   ac_ct_GNATMAKE=$GNATMAKE
4186   # Extract the first word of "gnatmake", so it can be a program name with args.
4187 set dummy gnatmake; ac_word=$2
4188 echo "$as_me:$LINENO: checking for $ac_word" >&5
4189 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4190 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4191   echo $ECHO_N "(cached) $ECHO_C" >&6
4192 else
4193   if test -n "$ac_ct_GNATMAKE"; then
4194   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4195 else
4196 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4197 for as_dir in $PATH
4198 do
4199   IFS=$as_save_IFS
4200   test -z "$as_dir" && as_dir=.
4201   for ac_exec_ext in '' $ac_executable_extensions; do
4202   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4203     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4204     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4205     break 2
4206   fi
4207 done
4208 done
4209
4210   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4211 fi
4212 fi
4213 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4214 if test -n "$ac_ct_GNATMAKE"; then
4215   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4216 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4217 else
4218   echo "$as_me:$LINENO: result: no" >&5
4219 echo "${ECHO_T}no" >&6
4220 fi
4221
4222   GNATMAKE=$ac_ct_GNATMAKE
4223 else
4224   GNATMAKE="$ac_cv_prog_GNATMAKE"
4225 fi
4226
4227 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4228 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4229 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4230   echo $ECHO_N "(cached) $ECHO_C" >&6
4231 else
4232   cat >conftest.adb <<EOF
4233 procedure conftest is begin null; end conftest;
4234 EOF
4235 acx_cv_cc_gcc_supports_ada=no
4236 # There is a bug in old released versions of GCC which causes the
4237 # driver to exit successfully when the appropriate language module
4238 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4239 # Therefore we must check for the error message as well as an
4240 # unsuccessful exit.
4241 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4242 # given a .adb file, but produce no object file.  So we must check
4243 # if an object file was really produced to guard against this.
4244 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4245 if test x"$errors" = x && test -f conftest.$ac_objext; then
4246   acx_cv_cc_gcc_supports_ada=yes
4247 fi
4248 rm -f conftest.*
4249 fi
4250 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4251 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4252
4253 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4254   have_gnat=yes
4255 else
4256   have_gnat=no
4257 fi
4258
4259 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4260 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4261 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4262   echo $ECHO_N "(cached) $ECHO_C" >&6
4263 else
4264    echo abfoo >t1
4265   echo cdfoo >t2
4266   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4267   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4268     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4269       :
4270     else
4271       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4272     fi
4273   fi
4274   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4275     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4276       :
4277     else
4278       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4279     fi
4280   fi
4281   rm t1 t2
4282
4283 fi
4284 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4285 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4286 do_compare="$gcc_cv_prog_cmp_skip"
4287
4288
4289
4290 # Check for GMP and MPFR
4291 gmplibs="-lmpfr -lgmp"
4292 gmpinc=
4293 have_gmp=no
4294
4295 # Specify a location for mpfr
4296 # check for this first so it ends up on the link line before gmp.
4297
4298 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4299 if test "${with_mpfr_dir+set}" = set; then
4300   withval="$with_mpfr_dir"
4301   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4302 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4303 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4304 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4305    { (exit 1); exit 1; }; }
4306 fi;
4307
4308
4309 # Check whether --with-mpfr or --without-mpfr was given.
4310 if test "${with_mpfr+set}" = set; then
4311   withval="$with_mpfr"
4312
4313 fi;
4314
4315 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4316 if test "${with_mpfr_include+set}" = set; then
4317   withval="$with_mpfr_include"
4318
4319 fi;
4320
4321 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4322 if test "${with_mpfr_lib+set}" = set; then
4323   withval="$with_mpfr_lib"
4324
4325 fi;
4326
4327 if test "x$with_mpfr" != x; then
4328   gmplibs="-L$with_mpfr/lib $gmplibs"
4329   gmpinc="-I$with_mpfr/include"
4330 fi
4331 if test "x$with_mpfr_include" != x; then
4332   gmpinc="-I$with_mpfr_include"
4333 fi
4334 if test "x$with_mpfr_lib" != x; then
4335   gmplibs="-L$with_mpfr_lib $gmplibs"
4336 fi
4337 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4338   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4339   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4340   # Do not test the mpfr version.  Assume that it is sufficient, since
4341   # it is in the source tree, and the library has not been built yet
4342   # but it would be included on the link line in the version check below
4343   # hence making the test fail.
4344   have_gmp=yes
4345 fi
4346
4347 # Specify a location for gmp
4348
4349 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4350 if test "${with_gmp_dir+set}" = set; then
4351   withval="$with_gmp_dir"
4352   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4353 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4354 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4355 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4356    { (exit 1); exit 1; }; }
4357 fi;
4358
4359
4360 # Check whether --with-gmp or --without-gmp was given.
4361 if test "${with_gmp+set}" = set; then
4362   withval="$with_gmp"
4363
4364 fi;
4365
4366 # Check whether --with-gmp_include or --without-gmp_include was given.
4367 if test "${with_gmp_include+set}" = set; then
4368   withval="$with_gmp_include"
4369
4370 fi;
4371
4372 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4373 if test "${with_gmp_lib+set}" = set; then
4374   withval="$with_gmp_lib"
4375
4376 fi;
4377
4378
4379 if test "x$with_gmp" != x; then
4380   gmplibs="-L$with_gmp/lib $gmplibs"
4381   gmpinc="-I$with_gmp/include $gmpinc"
4382 fi
4383 if test "x$with_gmp_include" != x; then
4384   gmpinc="-I$with_gmp_include $gmpinc"
4385 fi
4386 if test "x$with_gmp_lib" != x; then
4387   gmplibs="-L$with_gmp_lib $gmplibs"
4388 fi
4389 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4390   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4391   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4392   # Do not test the gmp version.  Assume that it is sufficient, since
4393   # it is in the source tree, and the library has not been built yet
4394   # but it would be included on the link line in the version check below
4395   # hence making the test fail.
4396   have_gmp=yes
4397 fi
4398
4399 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4400   have_gmp=yes
4401   saved_CFLAGS="$CFLAGS"
4402   CFLAGS="$CFLAGS $gmpinc"
4403   # Check GMP actually works
4404   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4405 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4406
4407 cat >conftest.$ac_ext <<_ACEOF
4408 /* confdefs.h.  */
4409 _ACEOF
4410 cat confdefs.h >>conftest.$ac_ext
4411 cat >>conftest.$ac_ext <<_ACEOF
4412 /* end confdefs.h.  */
4413 #include "gmp.h"
4414 int
4415 main ()
4416 {
4417
4418   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4419   choke me
4420   #endif
4421
4422   ;
4423   return 0;
4424 }
4425 _ACEOF
4426 rm -f conftest.$ac_objext
4427 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4428   (eval $ac_compile) 2>conftest.er1
4429   ac_status=$?
4430   grep -v '^ *+' conftest.er1 >conftest.err
4431   rm -f conftest.er1
4432   cat conftest.err >&5
4433   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4434   (exit $ac_status); } &&
4435          { ac_try='test -z "$ac_c_werror_flag"
4436                          || test ! -s conftest.err'
4437   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4438   (eval $ac_try) 2>&5
4439   ac_status=$?
4440   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4441   (exit $ac_status); }; } &&
4442          { ac_try='test -s conftest.$ac_objext'
4443   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4444   (eval $ac_try) 2>&5
4445   ac_status=$?
4446   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4447   (exit $ac_status); }; }; then
4448   echo "$as_me:$LINENO: result: yes" >&5
4449 echo "${ECHO_T}yes" >&6
4450 else
4451   echo "$as_me: failed program was:" >&5
4452 sed 's/^/| /' conftest.$ac_ext >&5
4453
4454 echo "$as_me:$LINENO: result: no" >&5
4455 echo "${ECHO_T}no" >&6; have_gmp=no
4456 fi
4457 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4458
4459   if test x"$have_gmp" = xyes; then
4460     saved_LIBS="$LIBS"
4461     LIBS="$LIBS $gmplibs"
4462         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4463 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4464     cat >conftest.$ac_ext <<_ACEOF
4465 /* confdefs.h.  */
4466 _ACEOF
4467 cat confdefs.h >>conftest.$ac_ext
4468 cat >>conftest.$ac_ext <<_ACEOF
4469 /* end confdefs.h.  */
4470 #include <gmp.h>
4471     #include <mpfr.h>
4472 int
4473 main ()
4474 {
4475
4476     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,0)
4477     choke me
4478     #endif
4479     mpfr_t n; mpfr_init(n);
4480     mpfr_t x; mpfr_init(x);
4481     int t;
4482     mpfr_atan2 (n, n, x, GMP_RNDN);
4483     mpfr_erfc (n, x, GMP_RNDN);
4484     mpfr_subnormalize (x, t, GMP_RNDN);
4485
4486   ;
4487   return 0;
4488 }
4489 _ACEOF
4490 rm -f conftest.$ac_objext conftest$ac_exeext
4491 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4492   (eval $ac_link) 2>conftest.er1
4493   ac_status=$?
4494   grep -v '^ *+' conftest.er1 >conftest.err
4495   rm -f conftest.er1
4496   cat conftest.err >&5
4497   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4498   (exit $ac_status); } &&
4499          { ac_try='test -z "$ac_c_werror_flag"
4500                          || test ! -s conftest.err'
4501   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4502   (eval $ac_try) 2>&5
4503   ac_status=$?
4504   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4505   (exit $ac_status); }; } &&
4506          { ac_try='test -s conftest$ac_exeext'
4507   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4508   (eval $ac_try) 2>&5
4509   ac_status=$?
4510   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4511   (exit $ac_status); }; }; then
4512   cat >conftest.$ac_ext <<_ACEOF
4513 /* confdefs.h.  */
4514 _ACEOF
4515 cat confdefs.h >>conftest.$ac_ext
4516 cat >>conftest.$ac_ext <<_ACEOF
4517 /* end confdefs.h.  */
4518 #include <gmp.h>
4519     #include <mpfr.h>
4520 int
4521 main ()
4522 {
4523
4524     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4525     choke me
4526     #endif
4527     mpfr_t n; mpfr_init(n);
4528
4529   ;
4530   return 0;
4531 }
4532 _ACEOF
4533 rm -f conftest.$ac_objext conftest$ac_exeext
4534 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4535   (eval $ac_link) 2>conftest.er1
4536   ac_status=$?
4537   grep -v '^ *+' conftest.er1 >conftest.err
4538   rm -f conftest.er1
4539   cat conftest.err >&5
4540   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4541   (exit $ac_status); } &&
4542          { ac_try='test -z "$ac_c_werror_flag"
4543                          || test ! -s conftest.err'
4544   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4545   (eval $ac_try) 2>&5
4546   ac_status=$?
4547   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4548   (exit $ac_status); }; } &&
4549          { ac_try='test -s conftest$ac_exeext'
4550   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4551   (eval $ac_try) 2>&5
4552   ac_status=$?
4553   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4554   (exit $ac_status); }; }; then
4555   echo "$as_me:$LINENO: result: yes" >&5
4556 echo "${ECHO_T}yes" >&6
4557 else
4558   echo "$as_me: failed program was:" >&5
4559 sed 's/^/| /' conftest.$ac_ext >&5
4560
4561 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4562 echo "${ECHO_T}buggy but acceptable" >&6
4563 fi
4564 rm -f conftest.err conftest.$ac_objext \
4565       conftest$ac_exeext conftest.$ac_ext
4566 else
4567   echo "$as_me: failed program was:" >&5
4568 sed 's/^/| /' conftest.$ac_ext >&5
4569
4570 echo "$as_me:$LINENO: result: no" >&5
4571 echo "${ECHO_T}no" >&6; have_gmp=no
4572 fi
4573 rm -f conftest.err conftest.$ac_objext \
4574       conftest$ac_exeext conftest.$ac_ext
4575       LIBS="$saved_LIBS"
4576   fi
4577   CFLAGS="$saved_CFLAGS"
4578
4579   if test x$have_gmp != xyes; then
4580     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4581 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4582 Copies of these libraries' source code can be found at their respective
4583 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4584 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4585 If you obtained GMP and/or MPFR from a vendor distribution package, make
4586 sure that you have installed both the libraries and the header files.
4587 They may be located in separate packages." >&5
4588 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4589 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4590 Copies of these libraries' source code can be found at their respective
4591 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4592 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4593 If you obtained GMP and/or MPFR from a vendor distribution package, make
4594 sure that you have installed both the libraries and the header files.
4595 They may be located in separate packages." >&2;}
4596    { (exit 1); exit 1; }; }
4597   fi
4598 fi
4599
4600 # Flags needed for both GMP and/or MPFR
4601
4602
4603
4604 # By default, C is the only stage 1 language.
4605 stage1_languages=,c,
4606
4607 # Figure out what language subdirectories are present.
4608 # Look if the user specified --enable-languages="..."; if not, use
4609 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4610 # go away some day.
4611 # NB:  embedded tabs in this IF block -- do not untabify
4612 if test -d ${srcdir}/gcc; then
4613   if test x"${enable_languages+set}" != xset; then
4614     if test x"${LANGUAGES+set}" = xset; then
4615       enable_languages="${LANGUAGES}"
4616         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4617     else
4618       enable_languages=all
4619     fi
4620   else
4621     if test x"${enable_languages}" = x ||
4622        test x"${enable_languages}" = xyes;
4623        then
4624       echo configure.in: --enable-languages needs at least one language argument 1>&2
4625       exit 1
4626     fi
4627   fi
4628   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4629
4630   # 'f95' is the old name for the 'fortran' language. We issue a warning
4631   # and make the substitution.
4632   case ,${enable_languages}, in
4633     *,f95,*)
4634       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4635       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4636       ;;
4637   esac
4638
4639   # First scan to see if an enabled language requires some other language.
4640   # We assume that a given config-lang.in will list all the language
4641   # front ends it requires, even if some are required indirectly.
4642   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4643     case ${lang_frag} in
4644       ..) ;;
4645       # The odd quoting in the next line works around
4646       # an apparent bug in bash 1.12 on linux.
4647       ${srcdir}/gcc/[*]/config-lang.in) ;;
4648       *)
4649         # From the config-lang.in, get $language, $lang_requires
4650         language=
4651         lang_requires=
4652         . ${lang_frag}
4653         for other in ${lang_requires} ; do
4654           case ,${enable_languages}, in
4655             *,$other,*) ;;
4656             *,all,*) ;;
4657             *,$language,*)
4658               echo " \`$other' language required by \`$language'; enabling" 1>&2
4659               enable_languages="${enable_languages},${other}"
4660               ;;
4661           esac
4662         done
4663         ;;
4664     esac
4665   done
4666
4667   new_enable_languages=,c,
4668   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4669   potential_languages=,c,
4670
4671   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4672     case ${lang_frag} in
4673       ..) ;;
4674       # The odd quoting in the next line works around
4675       # an apparent bug in bash 1.12 on linux.
4676       ${srcdir}/gcc/[*]/config-lang.in) ;;
4677       *)
4678         # From the config-lang.in, get $language, $target_libs,
4679         # $lang_dirs, $boot_language, and $build_by_default
4680         language=
4681         target_libs=
4682         lang_dirs=
4683         subdir_requires=
4684         boot_language=no
4685         build_by_default=yes
4686         . ${lang_frag}
4687         if test x${language} = x; then
4688           echo "${lang_frag} doesn't set \$language." 1>&2
4689           exit 1
4690         fi
4691
4692         case ,${enable_languages}, in
4693           *,${language},*)
4694             # Language was explicitly selected; include it.
4695             add_this_lang=yes
4696             ;;
4697           *,all,*)
4698             # 'all' was selected, select it if it is a default language
4699             add_this_lang=${build_by_default}
4700             ;;
4701           *)
4702             add_this_lang=no
4703             ;;
4704         esac
4705
4706         # Disable languages that need other directories if these aren't available.
4707         for i in $subdir_requires; do
4708           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4709           case ,${enable_languages}, in
4710             *,${language},*)
4711               # Specifically requested language; tell them.
4712               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4713 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4714    { (exit 1); exit 1; }; }
4715               ;;
4716             *)
4717               # Silently disable.
4718               add_this_lang=unsupported
4719               ;;
4720           esac
4721         done
4722
4723         # Disable Ada if no preexisting GNAT is available.
4724         case ,${enable_languages},:${language}:${have_gnat} in
4725           *,${language},*:ada:no)
4726             # Specifically requested language; tell them.
4727             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4728 echo "$as_me: error: GNAT is required to build $language" >&2;}
4729    { (exit 1); exit 1; }; }
4730             ;;
4731           *:ada:no)
4732             # Silently disable.
4733             add_this_lang=unsupported
4734             ;;
4735         esac
4736
4737         # Disable a language that is unsupported by the target.
4738         case " $unsupported_languages " in
4739           *" $language "*)
4740             add_this_lang=unsupported
4741             ;;
4742         esac
4743
4744         case $add_this_lang in
4745           unsupported)
4746             # Remove language-dependent dirs.
4747             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4748             ;;
4749           no)
4750             # Remove language-dependent dirs; still show language as supported.
4751             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4752             potential_languages="${potential_languages}${language},"
4753             ;;
4754           yes)
4755             new_enable_languages="${new_enable_languages}${language},"
4756             potential_languages="${potential_languages}${language},"
4757             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4758             case ${boot_language} in
4759               yes)
4760                 # Add to (comma-separated) list of stage 1 languages.
4761                 stage1_languages="${stage1_languages}${language},"
4762                 ;;
4763             esac
4764             ;;
4765         esac
4766         ;;
4767     esac
4768   done
4769
4770   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4771 if test "${enable_stage1_languages+set}" = set; then
4772   enableval="$enable_stage1_languages"
4773   case ,${enable_stage1_languages}, in
4774     ,no,|,,)
4775       # Set it to something that will have no effect in the loop below
4776       enable_stage1_languages=c ;;
4777     ,yes,)
4778       enable_stage1_languages=`echo $new_enable_languages | \
4779         sed -e "s/^,//" -e "s/,$//" ` ;;
4780     *,all,*)
4781       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4782         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4783   esac
4784
4785   # Add "good" languages from enable_stage1_languages to stage1_languages,
4786   # while "bad" languages go in missing_languages.  Leave no duplicates.
4787   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4788     case $potential_languages in
4789       *,$i,*)
4790         case $stage1_languages in
4791           *,$i,*) ;;
4792           *) stage1_languages="$stage1_languages$i," ;;
4793         esac ;;
4794       *)
4795         case $missing_languages in
4796           *,$i,*) ;;
4797           *) missing_languages="$missing_languages$i," ;;
4798         esac ;;
4799      esac
4800   done
4801 fi;
4802
4803   # Remove leading/trailing commas that were added for simplicity
4804   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4805   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4806   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4807   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4808
4809   if test "x$missing_languages" != x; then
4810     { { echo "$as_me:$LINENO: error:
4811 The following requested languages could not be built: ${missing_languages}
4812 Supported languages are: ${potential_languages}" >&5
4813 echo "$as_me: error:
4814 The following requested languages could not be built: ${missing_languages}
4815 Supported languages are: ${potential_languages}" >&2;}
4816    { (exit 1); exit 1; }; }
4817   fi
4818   if test "x$new_enable_languages" != "x$enable_languages"; then
4819     echo The following languages will be built: ${new_enable_languages}
4820     enable_languages="$new_enable_languages"
4821   fi
4822
4823
4824   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4825 fi
4826
4827 # Handle --disable-<component> generically.
4828 for dir in $configdirs $build_configdirs $target_configdirs ; do
4829   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4830   if eval test x\${enable_${dirname}} "=" xno ; then
4831     noconfigdirs="$noconfigdirs $dir"
4832   fi
4833 done
4834
4835 # Check for Boehm's garbage collector
4836 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4837 if test "${enable_objc_gc+set}" = set; then
4838   enableval="$enable_objc_gc"
4839   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4840   *,objc,*:*:yes:*target-boehm-gc*)
4841     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4842 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4843    { (exit 1); exit 1; }; }
4844     ;;
4845 esac
4846 fi;
4847
4848 # Make sure we only build Boehm's garbage collector if required.
4849 case ,${enable_languages},:${enable_objc_gc} in
4850   *,objc,*:yes)
4851     # Keep target-boehm-gc if requested for Objective-C.
4852     ;;
4853   *)
4854     # Otherwise remove target-boehm-gc depending on target-libjava.
4855     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
4856       noconfigdirs="$noconfigdirs target-boehm-gc"
4857     fi
4858     ;;
4859 esac
4860
4861 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
4862 # $build_configdirs and $target_configdirs.
4863 # If we have the source for $noconfigdirs entries, add them to $notsupp.
4864
4865 notsupp=""
4866 for dir in . $skipdirs $noconfigdirs ; do
4867   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
4868   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4869     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
4870     if test -r $srcdir/$dirname/configure ; then
4871       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4872         true
4873       else
4874         notsupp="$notsupp $dir"
4875       fi
4876     fi
4877   fi
4878   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4879     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
4880     if test -r $srcdir/$dirname/configure ; then
4881       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4882         true
4883       else
4884         notsupp="$notsupp $dir"
4885       fi
4886     fi
4887   fi
4888   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4889     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
4890     if test -r $srcdir/$dirname/configure ; then
4891       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4892         true
4893       else
4894         notsupp="$notsupp $dir"
4895       fi
4896     fi
4897   fi
4898 done
4899
4900 # Sometimes the tools are distributed with libiberty but with no other
4901 # libraries.  In that case, we don't want to build target-libiberty.
4902 # Don't let libgcc imply libiberty either.
4903 if test -n "${target_configdirs}" ; then
4904   libgcc=
4905   others=
4906   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
4907     if test "$i" = "libgcc"; then
4908       libgcc=target-libgcc
4909     elif test "$i" != "libiberty" ; then
4910       if test -r $srcdir/$i/configure ; then
4911         others=yes;
4912         break;
4913       fi
4914     fi
4915   done
4916   if test -z "${others}" ; then
4917     target_configdirs=$libgcc
4918   fi
4919 fi
4920
4921 # Quietly strip out all directories which aren't configurable in this tree.
4922 # This relies on all configurable subdirectories being autoconfiscated, which
4923 # is now the case.
4924 build_configdirs_all="$build_configdirs"
4925 build_configdirs=
4926 for i in ${build_configdirs_all} ; do
4927   j=`echo $i | sed -e s/build-//g`
4928   if test -f ${srcdir}/$j/configure ; then
4929     build_configdirs="${build_configdirs} $i"
4930   fi
4931 done
4932
4933 configdirs_all="$configdirs"
4934 configdirs=
4935 for i in ${configdirs_all} ; do
4936   if test -f ${srcdir}/$i/configure ; then
4937     configdirs="${configdirs} $i"
4938   fi
4939 done
4940
4941 target_configdirs_all="$target_configdirs"
4942 target_configdirs=
4943 for i in ${target_configdirs_all} ; do
4944   j=`echo $i | sed -e s/target-//g`
4945   if test -f ${srcdir}/$j/configure ; then
4946     target_configdirs="${target_configdirs} $i"
4947   fi
4948 done
4949
4950 # Produce a warning message for the subdirs we can't configure.
4951 # This isn't especially interesting in the Cygnus tree, but in the individual
4952 # FSF releases, it's important to let people know when their machine isn't
4953 # supported by the one or two programs in a package.
4954
4955 if test -n "${notsupp}" && test -z "${norecursion}" ; then
4956   # If $appdirs is non-empty, at least one of those directories must still
4957   # be configured, or we error out.  (E.g., if the gas release supports a
4958   # specified target in some subdirs but not the gas subdir, we shouldn't
4959   # pretend that all is well.)
4960   if test -n "$appdirs" ; then
4961     for dir in $appdirs ; do
4962       if test -r $dir/Makefile.in ; then
4963         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4964           appdirs=""
4965           break
4966         fi
4967         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
4968           appdirs=""
4969           break
4970         fi
4971       fi
4972     done
4973     if test -n "$appdirs" ; then
4974       echo "*** This configuration is not supported by this package." 1>&2
4975       exit 1
4976     fi
4977   fi
4978   # Okay, some application will build, or we don't care to check.  Still
4979   # notify of subdirs not getting built.
4980   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
4981   echo "    ${notsupp}" 1>&2
4982   echo "    (Any other directories should still work fine.)" 1>&2
4983 fi
4984
4985 case "$host" in
4986   *msdosdjgpp*)
4987     enable_gdbtk=no ;;
4988 esac
4989
4990 # To find our prefix, in gcc_cv_tool_prefix.
4991
4992 # The user is always right.
4993 if test "${PATH_SEPARATOR+set}" != set; then
4994   echo "#! /bin/sh" >conf$$.sh
4995   echo  "exit 0"   >>conf$$.sh
4996   chmod +x conf$$.sh
4997   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
4998     PATH_SEPARATOR=';'
4999   else
5000     PATH_SEPARATOR=:
5001   fi
5002   rm -f conf$$.sh
5003 fi
5004
5005
5006
5007 if test "x$exec_prefix" = xNONE; then
5008         if test "x$prefix" = xNONE; then
5009                 gcc_cv_tool_prefix=$ac_default_prefix
5010         else
5011                 gcc_cv_tool_prefix=$prefix
5012         fi
5013 else
5014         gcc_cv_tool_prefix=$exec_prefix
5015 fi
5016
5017 # If there is no compiler in the tree, use the PATH only.  In any
5018 # case, if there is no compiler in the tree nobody should use
5019 # AS_FOR_TARGET and LD_FOR_TARGET.
5020 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5021     gcc_version=`cat $srcdir/gcc/BASE-VER`
5022     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5023     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5024     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5025     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5026     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5027     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5028 else
5029     gcc_cv_tool_dirs=
5030 fi
5031
5032 if test x$build = x$target && test -n "$md_exec_prefix"; then
5033         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5034 fi
5035
5036
5037
5038 copy_dirs=
5039
5040
5041 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5042 if test "${with_build_sysroot+set}" = set; then
5043   withval="$with_build_sysroot"
5044   if test x"$withval" != x ; then
5045      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5046    fi
5047 else
5048   SYSROOT_CFLAGS_FOR_TARGET=
5049 fi;
5050
5051
5052 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5053 # the named directory are copied to $(tooldir)/sys-include.
5054 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5055   if test x${is_cross_compiler} = xno ; then
5056     echo 1>&2 '***' --with-headers is only supported when cross compiling
5057     exit 1
5058   fi
5059   if test x"${with_headers}" != xyes ; then
5060     x=${gcc_cv_tool_prefix}
5061     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5062   fi
5063 fi
5064
5065 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5066 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5067 # are permitted.
5068 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5069   if test x${is_cross_compiler} = xno ; then
5070     echo 1>&2 '***' --with-libs is only supported when cross compiling
5071     exit 1
5072   fi
5073   if test x"${with_libs}" != xyes ; then
5074     # Copy the libraries in reverse order, so that files in the first named
5075     # library override files in subsequent libraries.
5076     x=${gcc_cv_tool_prefix}
5077     for l in ${with_libs}; do
5078       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5079     done
5080   fi
5081 fi
5082
5083 # Set with_gnu_as and with_gnu_ld as appropriate.
5084 #
5085 # This is done by determining whether or not the appropriate directory
5086 # is available, and by checking whether or not specific configurations
5087 # have requested that this magic not happen.
5088 #
5089 # The command line options always override the explicit settings in
5090 # configure.in, and the settings in configure.in override this magic.
5091 #
5092 # If the default for a toolchain is to use GNU as and ld, and you don't
5093 # want to do that, then you should use the --without-gnu-as and
5094 # --without-gnu-ld options for the configure script.
5095
5096 if test x${use_gnu_as} = x &&
5097    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5098   with_gnu_as=yes
5099   extra_host_args="$extra_host_args --with-gnu-as"
5100 fi
5101
5102 if test x${use_gnu_ld} = x &&
5103    echo " ${configdirs} " | grep " ld " > /dev/null 2>&1 ; then
5104   with_gnu_ld=yes
5105   extra_host_args="$extra_host_args --with-gnu-ld"
5106 fi
5107
5108 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5109 # can detect this case.
5110
5111 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5112   with_newlib=yes
5113   extra_host_args="$extra_host_args --with-newlib"
5114 fi
5115
5116 # Handle ${copy_dirs}
5117 set fnord ${copy_dirs}
5118 shift
5119 while test $# != 0 ; do
5120   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5121     :
5122   else
5123     echo Copying $1 to $2
5124
5125     # Use the install script to create the directory and all required
5126     # parent directories.
5127     if test -d $2 ; then
5128       :
5129     else
5130       echo >config.temp
5131       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5132     fi
5133
5134     # Copy the directory, assuming we have tar.
5135     # FIXME: Should we use B in the second tar?  Not all systems support it.
5136     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5137
5138     # It is the responsibility of the user to correctly adjust all
5139     # symlinks.  If somebody can figure out how to handle them correctly
5140     # here, feel free to add the code.
5141
5142     echo $1 > $2/COPIED
5143   fi
5144   shift; shift
5145 done
5146
5147 # Determine a target-dependent exec_prefix that the installed
5148 # gcc will search in.  Keep this list sorted by triplet, with
5149 # the *-*-osname triplets last.
5150 md_exec_prefix=
5151 case "${target}" in
5152   alpha*-*-*vms*)
5153     md_exec_prefix=/gnu/lib/gcc-lib
5154     ;;
5155   i3456786-pc-msdosdjgpp*)
5156     md_exec_prefix=/dev/env/DJDIR/bin
5157     ;;
5158   i3456786-*-sco3.2v5*)
5159     if test $with_gnu_as = yes; then
5160       md_exec_prefix=/usr/gnu/bin
5161     else
5162       md_exec_prefix=/usr/ccs/bin/elf
5163     fi
5164     ;;
5165
5166   mn10300-*-* | \
5167   powerpc-*-chorusos* | \
5168   powerpc*-*-eabi* | \
5169   powerpc*-*-sysv* | \
5170   powerpc*-*-kaos* | \
5171   s390x-ibm-tpf*)
5172     md_exec_prefix=/usr/ccs/bin
5173     ;;
5174   sparc64-*-elf*)
5175     ;;
5176   v850*-*-*)
5177     md_exec_prefix=/usr/ccs/bin
5178     ;;
5179   xtensa-*-elf*)
5180     ;;
5181
5182   *-*-beos* | \
5183   *-*-elf* | \
5184   *-*-hpux* | \
5185   *-*-netware* | \
5186   *-*-nto-qnx* | \
5187   *-*-rtems* | \
5188   *-*-solaris2* | \
5189   *-*-sysv45* | \
5190   *-*-vxworks* | \
5191   *-wrs-windiss)
5192     md_exec_prefix=/usr/ccs/bin
5193     ;;
5194 esac
5195
5196 extra_arflags_for_target=
5197 extra_nmflags_for_target=
5198 extra_ranlibflags_for_target=
5199 target_makefile_frag=/dev/null
5200 case "${target}" in
5201   mep*-*-*)
5202     target_makefile_frag="config/mt-mep"
5203     ;;
5204   spu-*-*)
5205     target_makefile_frag="config/mt-spu"
5206     ;;
5207   *-*-netware*)
5208     target_makefile_frag="config/mt-netware"
5209     ;;
5210   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5211     target_makefile_frag="config/mt-gnu"
5212     ;;
5213   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5214     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5215     # commands to handle both 32-bit and 64-bit objects.  These flags are
5216     # harmless if we're using GNU nm or ar.
5217     extra_arflags_for_target=" -X32_64"
5218     extra_nmflags_for_target=" -B -X32_64"
5219     ;;
5220   *-*-darwin*)
5221     # ranlib from Darwin requires the -c flag to look at common symbols.
5222     extra_ranlibflags_for_target=" -c"
5223     ;;
5224   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5225     target_makefile_frag="config/mt-wince"
5226     ;;
5227 esac
5228
5229 alphaieee_frag=/dev/null
5230 case $target in
5231   alpha*-*-*)
5232     # This just makes sure to use the -mieee option to build target libs.
5233     # This should probably be set individually by each library.
5234     alphaieee_frag="config/mt-alphaieee"
5235     ;;
5236 esac
5237
5238 # If --enable-target-optspace always use -Os instead of -O2 to build
5239 # the target libraries, similarly if it is not specified, use -Os
5240 # on selected platforms.
5241 ospace_frag=/dev/null
5242 case "${enable_target_optspace}:${target}" in
5243   yes:*)
5244     ospace_frag="config/mt-ospace"
5245     ;;
5246   :d30v-*)
5247     ospace_frag="config/mt-d30v"
5248     ;;
5249   :m32r-* | :d10v-* | :fr30-*)
5250     ospace_frag="config/mt-ospace"
5251     ;;
5252   no:* | :*)
5253     ;;
5254   *)
5255     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5256     ;;
5257 esac
5258
5259 # Default to using --with-stabs for certain targets.
5260 if test x${with_stabs} = x ; then
5261   case "${target}" in
5262   mips*-*-irix[56]*)
5263     ;;
5264   mips*-*-* | alpha*-*-osf*)
5265     with_stabs=yes;
5266     extra_host_args="${extra_host_args} --with-stabs"
5267     ;;
5268   esac
5269 fi
5270
5271 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5272 # them automatically.
5273 case "${host}" in
5274   hppa*64*-*-hpux11*)
5275     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5276     ;;
5277 esac
5278
5279 # Some systems (e.g., one of the i386-aix systems the gas testers are
5280 # using) don't handle "\$" correctly, so don't use it here.
5281 tooldir='${exec_prefix}'/${target_noncanonical}
5282 build_tooldir=${tooldir}
5283
5284 # Create a .gdbinit file which runs the one in srcdir
5285 # and tells GDB to look there for source files.
5286
5287 if test -r ${srcdir}/.gdbinit ; then
5288   case ${srcdir} in
5289     .) ;;
5290     *) cat > ./.gdbinit <<EOF
5291 # ${NO_EDIT}
5292 dir ${srcdir}
5293 dir .
5294 source ${srcdir}/.gdbinit
5295 EOF
5296     ;;
5297   esac
5298 fi
5299
5300 # Make sure that the compiler is able to generate an executable.  If it
5301 # can't, we are probably in trouble.  We don't care whether we can run the
5302 # executable--we might be using a cross compiler--we only care whether it
5303 # can be created.  At this point the main configure script has set CC.
5304 we_are_ok=no
5305 echo "int main () { return 0; }" > conftest.c
5306 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5307 if test $? = 0 ; then
5308   if test -s conftest || test -s conftest.exe ; then
5309     we_are_ok=yes
5310   fi
5311 fi
5312 case $we_are_ok in
5313   no)
5314     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5315     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5316     rm -f conftest*
5317     exit 1
5318     ;;
5319 esac
5320 rm -f conftest*
5321
5322 # The Solaris /usr/ucb/cc compiler does not appear to work.
5323 case "${host}" in
5324   sparc-sun-solaris2*)
5325       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5326       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5327           could_use=
5328           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5329           if test -d /opt/cygnus/bin ; then
5330               if test "$could_use" = "" ; then
5331                   could_use="/opt/cygnus/bin"
5332               else
5333                   could_use="$could_use or /opt/cygnus/bin"
5334               fi
5335           fi
5336         if test "$could_use" = "" ; then
5337             echo "Warning: compilation may fail because you're using"
5338             echo "/usr/ucb/cc.  You should change your PATH or CC "
5339             echo "variable and rerun configure."
5340         else
5341             echo "Warning: compilation may fail because you're using"
5342             echo "/usr/ucb/cc, when you should use the C compiler from"
5343             echo "$could_use.  You should change your"
5344             echo "PATH or CC variable and rerun configure."
5345         fi
5346       fi
5347   ;;
5348 esac
5349
5350 case "${host}" in
5351   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5352   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5353   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5354 esac
5355
5356 # Record target_configdirs and the configure arguments for target and
5357 # build configuration in Makefile.
5358 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5359 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5360
5361 # Determine whether gdb needs tk/tcl or not.
5362 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5363 # and in that case we want gdb to be built without tk.  Ugh!
5364 # In fact I believe gdb is the *only* package directly dependent on tk,
5365 # so we should be able to put the 'maybe's in unconditionally and
5366 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5367 # 100% sure that that's safe though.
5368
5369 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5370 case "$enable_gdbtk" in
5371   no)
5372     GDB_TK="" ;;
5373   yes)
5374     GDB_TK="${gdb_tk}" ;;
5375   *)
5376     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5377     # distro.  Eventually someone will fix this and move Insight, nee
5378     # gdbtk to a separate directory.
5379     if test -d ${srcdir}/gdb/gdbtk ; then
5380       GDB_TK="${gdb_tk}"
5381     else
5382       GDB_TK=""
5383     fi
5384     ;;
5385 esac
5386 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5387 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5388
5389 # Strip out unwanted targets.
5390
5391 # While at that, we remove Makefiles if we were started for recursive
5392 # configuration, so that the top-level Makefile reconfigures them,
5393 # like we used to do when configure itself was recursive.
5394
5395 # Loop over modules.  $extrasub must be used with care, limiting as
5396 # much as possible the usage of range addresses.  That's because autoconf
5397 # splits the sed script to overcome limits in the number of commands,
5398 # and relying on carefully-timed sed passes may turn out to be very hard
5399 # to maintain later.  In this particular case, you just have to be careful
5400 # not to nest @if/@endif pairs, because configure will not warn you at all.
5401
5402 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5403 if test "${enable_bootstrap+set}" = set; then
5404   enableval="$enable_bootstrap"
5405
5406 else
5407   enable_bootstrap=default
5408 fi;
5409
5410 # Issue errors and warnings for invalid/strange bootstrap combinations.
5411 case "$configdirs" in
5412   *gcc*) have_compiler=yes ;;
5413   *) have_compiler=no ;;
5414 esac
5415
5416 case "$have_compiler:$host:$target:$enable_bootstrap" in
5417   *:*:*:no) ;;
5418
5419   # Default behavior.  Enable bootstrap if we have a compiler
5420   # and we are in a native configuration.
5421   yes:$build:$build:default)
5422     enable_bootstrap=yes ;;
5423
5424   *:*:*:default)
5425     enable_bootstrap=no ;;
5426
5427   # We have a compiler and we are in a native configuration, bootstrap is ok
5428   yes:$build:$build:yes)
5429     ;;
5430
5431   # Other configurations, but we have a compiler.  Assume the user knows
5432   # what he's doing.
5433   yes:*:*:yes)
5434     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5435 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5436     ;;
5437
5438   # No compiler: if they passed --enable-bootstrap explicitly, fail
5439   no:*:*:yes)
5440     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5441 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5442    { (exit 1); exit 1; }; } ;;
5443
5444   # Fail if wrong command line
5445   *)
5446     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5447 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5448    { (exit 1); exit 1; }; }
5449     ;;
5450 esac
5451
5452 # Adjust the toplevel makefile according to whether bootstrap was selected.
5453 case "$enable_bootstrap" in
5454   yes)
5455     bootstrap_suffix=bootstrap ;;
5456   no)
5457     bootstrap_suffix=no-bootstrap ;;
5458 esac
5459
5460 for module in ${build_configdirs} ; do
5461   if test -z "${no_recursion}" \
5462      && test -f ${build_subdir}/${module}/Makefile; then
5463     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5464     rm -f ${build_subdir}/${module}/Makefile
5465   fi
5466   extrasub="$extrasub
5467 /^@if build-$module\$/d
5468 /^@endif build-$module\$/d
5469 /^@if build-$module-$bootstrap_suffix\$/d
5470 /^@endif build-$module-$bootstrap_suffix\$/d"
5471 done
5472 for module in ${configdirs} ; do
5473   if test -z "${no_recursion}"; then
5474     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5475       if test -f ${file}; then
5476         echo 1>&2 "*** removing ${file} to force reconfigure"
5477         rm -f ${file}
5478       fi
5479     done
5480   fi
5481   extrasub="$extrasub
5482 /^@if $module\$/d
5483 /^@endif $module\$/d
5484 /^@if $module-$bootstrap_suffix\$/d
5485 /^@endif $module-$bootstrap_suffix\$/d"
5486 done
5487 for module in ${target_configdirs} ; do
5488   if test -z "${no_recursion}" \
5489      && test -f ${target_subdir}/${module}/Makefile; then
5490     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5491     rm -f ${target_subdir}/${module}/Makefile
5492   fi
5493   extrasub="$extrasub
5494 /^@if target-$module\$/d
5495 /^@endif target-$module\$/d
5496 /^@if target-$module-$bootstrap_suffix\$/d
5497 /^@endif target-$module-$bootstrap_suffix\$/d"
5498 done
5499
5500 extrasub="$extrasub
5501 /^@if /,/^@endif /d"
5502
5503 # Create the serialization dependencies.  This uses a temporary file.
5504
5505 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5506 if test "${enable_serial_configure+set}" = set; then
5507   enableval="$enable_serial_configure"
5508
5509 fi;
5510
5511 case ${enable_serial_configure} in
5512   yes)
5513     enable_serial_build_configure=yes
5514     enable_serial_host_configure=yes
5515     enable_serial_target_configure=yes
5516     ;;
5517 esac
5518
5519 # These force 'configure's to be done one at a time, to avoid problems
5520 # with contention over a shared config.cache.
5521 rm -f serdep.tmp
5522 echo '# serdep.tmp' > serdep.tmp
5523 olditem=
5524 test "x${enable_serial_build_configure}" = xyes &&
5525 for item in ${build_configdirs} ; do
5526   case ${olditem} in
5527     "") ;;
5528     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5529   esac
5530   olditem=${item}
5531 done
5532 olditem=
5533 test "x${enable_serial_host_configure}" = xyes &&
5534 for item in ${configdirs} ; do
5535   case ${olditem} in
5536     "") ;;
5537     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5538   esac
5539   olditem=${item}
5540 done
5541 olditem=
5542 test "x${enable_serial_target_configure}" = xyes &&
5543 for item in ${target_configdirs} ; do
5544   case ${olditem} in
5545     "") ;;
5546     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5547   esac
5548   olditem=${item}
5549 done
5550 serialization_dependencies=serdep.tmp
5551
5552
5553 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5554 # target, nonopt, and variable assignments.  These are the ones we
5555 # might not want to pass down to subconfigures.  Also strip
5556 # program-prefix, program-suffix, and program-transform-name, so that
5557 # we can pass down a consistent program-transform-name.
5558 baseargs=
5559 keep_next=no
5560 skip_next=no
5561 eval "set -- $ac_configure_args"
5562 for ac_arg
5563 do
5564   if test X"$skip_next" = X"yes"; then
5565     skip_next=no
5566     continue
5567   fi
5568   if test X"$keep_next" = X"yes"; then
5569     case $ac_arg in
5570       *\'*)
5571         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5572     esac
5573     baseargs="$baseargs '$ac_arg'"
5574     keep_next=no
5575     continue
5576   fi
5577
5578   # Handle separated arguments.  Based on the logic generated by
5579   # autoconf 2.59.
5580   case $ac_arg in
5581     *=* | --config-cache | -C | -disable-* | --disable-* \
5582       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5583       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5584       | -with-* | --with-* | -without-* | --without-* | --x)
5585       separate_arg=no
5586       ;;
5587     -*)
5588       separate_arg=yes
5589       ;;
5590     *)
5591       separate_arg=no
5592       ;;
5593   esac
5594
5595   case "$ac_arg" in
5596     --no*)
5597       continue
5598       ;;
5599     --c* | \
5600     --sr* | \
5601     --ho* | \
5602     --bu* | \
5603     --t* | \
5604     --program-* | \
5605     -cache_file* | \
5606     -srcdir* | \
5607     -host* | \
5608     -build* | \
5609     -target* | \
5610     -program-prefix* | \
5611     -program-suffix* | \
5612     -program-transform-name* )
5613       skip_next=$separate_arg
5614       continue
5615       ;;
5616     -*)
5617       # An option.  Add it.
5618       case $ac_arg in
5619         *\'*)
5620           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5621       esac
5622       baseargs="$baseargs '$ac_arg'"
5623       keep_next=$separate_arg
5624       ;;
5625     *)
5626       # Either a variable assignment, or a nonopt (triplet).  Don't
5627       # pass it down; let the Makefile handle this.
5628       continue
5629       ;;
5630   esac
5631 done
5632 # Remove the initial space we just introduced and, as these will be
5633 # expanded by make, quote '$'.
5634 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5635
5636 # Add in --program-transform-name, after --program-prefix and
5637 # --program-suffix have been applied to it.  Autoconf has already
5638 # doubled dollar signs and backslashes in program_transform_name; we want
5639 # the backslashes un-doubled, and then the entire thing wrapped in single
5640 # quotes, because this will be expanded first by make and then by the shell.
5641 # Also, because we want to override the logic in subdir configure scripts to
5642 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5643 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5644 ${program_transform_name}
5645 EOF_SED
5646 gcc_transform_name=`cat conftestsed.out`
5647 rm -f conftestsed.out
5648 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5649
5650 # For the build-side libraries, we just need to pretend we're native,
5651 # and not use the same cache file.  Multilibs are neither needed nor
5652 # desired.
5653 build_configargs="--cache-file=../config.cache ${baseargs}"
5654
5655 # For host modules, accept cache file option, or specification as blank.
5656 case "${cache_file}" in
5657 "") # empty
5658   cache_file_option="" ;;
5659 /* | [A-Za-z]:[\\/]* ) # absolute path
5660   cache_file_option="--cache-file=${cache_file}" ;;
5661 *) # relative path
5662   cache_file_option="--cache-file=../${cache_file}" ;;
5663 esac
5664
5665 # Host dirs don't like to share a cache file either, horribly enough.
5666 # This seems to be due to autoconf 2.5x stupidity.
5667 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5668
5669 target_configargs=${baseargs}
5670
5671 # Passing a --with-cross-host argument lets the target libraries know
5672 # whether they are being built with a cross-compiler or being built
5673 # native.  However, it would be better to use other mechanisms to make the
5674 # sorts of decisions they want to make on this basis.  Please consider
5675 # this option to be deprecated.  FIXME.
5676 if test x${is_cross_compiler} = xyes ; then
5677   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5678 fi
5679
5680 # Default to --enable-multilib.
5681 if test x${enable_multilib} = x ; then
5682   target_configargs="--enable-multilib ${target_configargs}"
5683 fi
5684
5685 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5686 # changed from the earlier setting of with_newlib.
5687 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5688   target_configargs="--with-newlib ${target_configargs}"
5689 fi
5690
5691 # Different target subdirs use different values of certain variables
5692 # (notably CXX).  Worse, multilibs use *lots* of different values.
5693 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5694 # it doesn't automatically accept command-line overrides of them.
5695 # This means it's not safe for target subdirs to share a cache file,
5696 # which is disgusting, but there you have it.  Hopefully this can be
5697 # fixed in future.  It's still worthwhile to use a cache file for each
5698 # directory.  I think.
5699
5700 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5701 # We need to pass --target, as newer autoconf's requires consistency
5702 # for target_alias and gcc doesn't manage it consistently.
5703 target_configargs="--cache-file=./config.cache ${target_configargs}"
5704
5705 FLAGS_FOR_TARGET=
5706 case " $target_configdirs " in
5707  *" newlib "*)
5708   case " $target_configargs " in
5709   *" --with-newlib "*)
5710    case "$target" in
5711    *-cygwin*)
5712      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' ;;
5713    esac
5714
5715    # If we're not building GCC, don't discard standard headers.
5716    if test -d ${srcdir}/gcc; then
5717      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5718
5719      if test "${build}" != "${host}"; then
5720        # On Canadian crosses, CC_FOR_TARGET will have already been set
5721        # by `configure', so we won't have an opportunity to add -Bgcc/
5722        # to it.  This is right: we don't want to search that directory
5723        # for binaries, but we want the header files in there, so add
5724        # them explicitly.
5725        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5726
5727        # Someone might think of using the pre-installed headers on
5728        # Canadian crosses, in case the installed compiler is not fully
5729        # compatible with the compiler being built.  In this case, it
5730        # would be better to flag an error than risking having
5731        # incompatible object files being constructed.  We can't
5732        # guarantee that an error will be flagged, but let's hope the
5733        # compiler will do it, when presented with incompatible header
5734        # files.
5735      fi
5736    fi
5737
5738    case "${target}-${is_cross_compiler}" in
5739    i[3456789]86-*-linux*-no)
5740       # Here host == target, so we don't need to build gcc,
5741       # so we don't want to discard standard headers.
5742       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5743       ;;
5744    *)
5745       # If we're building newlib, use its generic headers last, but search
5746       # for any libc-related directories first (so make it the last -B
5747       # switch).
5748       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5749       ;;
5750    esac
5751    ;;
5752   esac
5753   ;;
5754 esac
5755 case "$target" in
5756 *-mingw*)
5757   # Can't be handled as Cygwin above since Mingw does not use newlib.
5758   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' ;;
5759 esac
5760
5761 # Allow the user to override the flags for
5762 # our build compiler if desired.
5763 CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5764
5765 # On Canadian crosses, we'll be searching the right directories for
5766 # the previously-installed cross compiler, so don't bother to add
5767 # flags for directories within the install tree of the compiler
5768 # being built; programs in there won't even run.
5769 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5770   # Search for pre-installed headers if nothing else fits.
5771   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5772 fi
5773
5774 if test "x${use_gnu_ld}" = x &&
5775    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5776   # Arrange for us to find uninstalled linker scripts.
5777   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5778 fi
5779
5780 # Search for other target-specific linker scripts and such.
5781 case "${target}" in
5782   m32c-*-* )
5783     if test -d ${srcdir}/libgloss/m32c; then
5784       # This is for crt0.o
5785       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/m32c'
5786       # This is for r8c.ld
5787       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/m32c'
5788       # This is for libnosys.a
5789       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5790     fi
5791     ;;
5792   mep*)
5793     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5794     ;;
5795 esac
5796
5797 # Makefile fragments.
5798 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5799 do
5800   eval fragval=\$$frag
5801   if test $fragval != /dev/null; then
5802     eval $frag=${srcdir}/$fragval
5803   fi
5804 done
5805
5806
5807
5808
5809
5810 # Miscellanea: directories, flags, etc.
5811
5812
5813
5814
5815
5816
5817
5818 # Build module lists & subconfigure args.
5819
5820
5821
5822 # Host module lists & subconfigure args.
5823
5824
5825
5826 # Target module lists & subconfigure args.
5827
5828
5829
5830 # Build tools.
5831
5832
5833
5834 # Generate default definitions for YACC, M4, LEX and other programs that run
5835 # on the build machine.  These are used if the Makefile can't locate these
5836 # programs in objdir.
5837 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
5838
5839 for ac_prog in 'bison -y' byacc yacc
5840 do
5841   # Extract the first word of "$ac_prog", so it can be a program name with args.
5842 set dummy $ac_prog; ac_word=$2
5843 echo "$as_me:$LINENO: checking for $ac_word" >&5
5844 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5845 if test "${ac_cv_prog_YACC+set}" = set; then
5846   echo $ECHO_N "(cached) $ECHO_C" >&6
5847 else
5848   if test -n "$YACC"; then
5849   ac_cv_prog_YACC="$YACC" # Let the user override the test.
5850 else
5851 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5852 for as_dir in $PATH
5853 do
5854   IFS=$as_save_IFS
5855   test -z "$as_dir" && as_dir=.
5856   for ac_exec_ext in '' $ac_executable_extensions; do
5857   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5858     ac_cv_prog_YACC="$ac_prog"
5859     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5860     break 2
5861   fi
5862 done
5863 done
5864
5865 fi
5866 fi
5867 YACC=$ac_cv_prog_YACC
5868 if test -n "$YACC"; then
5869   echo "$as_me:$LINENO: result: $YACC" >&5
5870 echo "${ECHO_T}$YACC" >&6
5871 else
5872   echo "$as_me:$LINENO: result: no" >&5
5873 echo "${ECHO_T}no" >&6
5874 fi
5875
5876   test -n "$YACC" && break
5877 done
5878 test -n "$YACC" || YACC="$MISSING bison -y"
5879
5880 case " $build_configdirs " in
5881   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
5882   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
5883 esac
5884
5885 for ac_prog in bison
5886 do
5887   # Extract the first word of "$ac_prog", so it can be a program name with args.
5888 set dummy $ac_prog; ac_word=$2
5889 echo "$as_me:$LINENO: checking for $ac_word" >&5
5890 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5891 if test "${ac_cv_prog_BISON+set}" = set; then
5892   echo $ECHO_N "(cached) $ECHO_C" >&6
5893 else
5894   if test -n "$BISON"; then
5895   ac_cv_prog_BISON="$BISON" # Let the user override the test.
5896 else
5897 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5898 for as_dir in $PATH
5899 do
5900   IFS=$as_save_IFS
5901   test -z "$as_dir" && as_dir=.
5902   for ac_exec_ext in '' $ac_executable_extensions; do
5903   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5904     ac_cv_prog_BISON="$ac_prog"
5905     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5906     break 2
5907   fi
5908 done
5909 done
5910
5911 fi
5912 fi
5913 BISON=$ac_cv_prog_BISON
5914 if test -n "$BISON"; then
5915   echo "$as_me:$LINENO: result: $BISON" >&5
5916 echo "${ECHO_T}$BISON" >&6
5917 else
5918   echo "$as_me:$LINENO: result: no" >&5
5919 echo "${ECHO_T}no" >&6
5920 fi
5921
5922   test -n "$BISON" && break
5923 done
5924 test -n "$BISON" || BISON="$MISSING bison"
5925
5926 case " $build_configdirs " in
5927   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
5928 esac
5929
5930 for ac_prog in gm4 gnum4 m4
5931 do
5932   # Extract the first word of "$ac_prog", so it can be a program name with args.
5933 set dummy $ac_prog; ac_word=$2
5934 echo "$as_me:$LINENO: checking for $ac_word" >&5
5935 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5936 if test "${ac_cv_prog_M4+set}" = set; then
5937   echo $ECHO_N "(cached) $ECHO_C" >&6
5938 else
5939   if test -n "$M4"; then
5940   ac_cv_prog_M4="$M4" # Let the user override the test.
5941 else
5942 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5943 for as_dir in $PATH
5944 do
5945   IFS=$as_save_IFS
5946   test -z "$as_dir" && as_dir=.
5947   for ac_exec_ext in '' $ac_executable_extensions; do
5948   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5949     ac_cv_prog_M4="$ac_prog"
5950     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5951     break 2
5952   fi
5953 done
5954 done
5955
5956 fi
5957 fi
5958 M4=$ac_cv_prog_M4
5959 if test -n "$M4"; then
5960   echo "$as_me:$LINENO: result: $M4" >&5
5961 echo "${ECHO_T}$M4" >&6
5962 else
5963   echo "$as_me:$LINENO: result: no" >&5
5964 echo "${ECHO_T}no" >&6
5965 fi
5966
5967   test -n "$M4" && break
5968 done
5969 test -n "$M4" || M4="$MISSING m4"
5970
5971 case " $build_configdirs " in
5972   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
5973 esac
5974
5975 for ac_prog in flex lex
5976 do
5977   # Extract the first word of "$ac_prog", so it can be a program name with args.
5978 set dummy $ac_prog; ac_word=$2
5979 echo "$as_me:$LINENO: checking for $ac_word" >&5
5980 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5981 if test "${ac_cv_prog_LEX+set}" = set; then
5982   echo $ECHO_N "(cached) $ECHO_C" >&6
5983 else
5984   if test -n "$LEX"; then
5985   ac_cv_prog_LEX="$LEX" # Let the user override the test.
5986 else
5987 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5988 for as_dir in $PATH
5989 do
5990   IFS=$as_save_IFS
5991   test -z "$as_dir" && as_dir=.
5992   for ac_exec_ext in '' $ac_executable_extensions; do
5993   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5994     ac_cv_prog_LEX="$ac_prog"
5995     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5996     break 2
5997   fi
5998 done
5999 done
6000
6001 fi
6002 fi
6003 LEX=$ac_cv_prog_LEX
6004 if test -n "$LEX"; then
6005   echo "$as_me:$LINENO: result: $LEX" >&5
6006 echo "${ECHO_T}$LEX" >&6
6007 else
6008   echo "$as_me:$LINENO: result: no" >&5
6009 echo "${ECHO_T}no" >&6
6010 fi
6011
6012   test -n "$LEX" && break
6013 done
6014 test -n "$LEX" || LEX="$MISSING flex"
6015
6016 case " $build_configdirs " in
6017   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6018   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6019 esac
6020
6021 for ac_prog in flex
6022 do
6023   # Extract the first word of "$ac_prog", so it can be a program name with args.
6024 set dummy $ac_prog; ac_word=$2
6025 echo "$as_me:$LINENO: checking for $ac_word" >&5
6026 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6027 if test "${ac_cv_prog_FLEX+set}" = set; then
6028   echo $ECHO_N "(cached) $ECHO_C" >&6
6029 else
6030   if test -n "$FLEX"; then
6031   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6032 else
6033 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6034 for as_dir in $PATH
6035 do
6036   IFS=$as_save_IFS
6037   test -z "$as_dir" && as_dir=.
6038   for ac_exec_ext in '' $ac_executable_extensions; do
6039   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6040     ac_cv_prog_FLEX="$ac_prog"
6041     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6042     break 2
6043   fi
6044 done
6045 done
6046
6047 fi
6048 fi
6049 FLEX=$ac_cv_prog_FLEX
6050 if test -n "$FLEX"; then
6051   echo "$as_me:$LINENO: result: $FLEX" >&5
6052 echo "${ECHO_T}$FLEX" >&6
6053 else
6054   echo "$as_me:$LINENO: result: no" >&5
6055 echo "${ECHO_T}no" >&6
6056 fi
6057
6058   test -n "$FLEX" && break
6059 done
6060 test -n "$FLEX" || FLEX="$MISSING flex"
6061
6062 case " $build_configdirs " in
6063   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6064 esac
6065
6066 for ac_prog in makeinfo
6067 do
6068   # Extract the first word of "$ac_prog", so it can be a program name with args.
6069 set dummy $ac_prog; ac_word=$2
6070 echo "$as_me:$LINENO: checking for $ac_word" >&5
6071 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6072 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6073   echo $ECHO_N "(cached) $ECHO_C" >&6
6074 else
6075   if test -n "$MAKEINFO"; then
6076   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6077 else
6078 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6079 for as_dir in $PATH
6080 do
6081   IFS=$as_save_IFS
6082   test -z "$as_dir" && as_dir=.
6083   for ac_exec_ext in '' $ac_executable_extensions; do
6084   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6085     ac_cv_prog_MAKEINFO="$ac_prog"
6086     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6087     break 2
6088   fi
6089 done
6090 done
6091
6092 fi
6093 fi
6094 MAKEINFO=$ac_cv_prog_MAKEINFO
6095 if test -n "$MAKEINFO"; then
6096   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6097 echo "${ECHO_T}$MAKEINFO" >&6
6098 else
6099   echo "$as_me:$LINENO: result: no" >&5
6100 echo "${ECHO_T}no" >&6
6101 fi
6102
6103   test -n "$MAKEINFO" && break
6104 done
6105 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6106
6107 case " $build_configdirs " in
6108   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6109   *)
6110
6111     # For an installed makeinfo, we require it to be from texinfo 4.4 or
6112     # higher, else we use the "missing" dummy.
6113     if ${MAKEINFO} --version \
6114        | egrep 'texinfo[^0-9]*([1-3][0-9]|4\.[4-9]|[5-9])' >/dev/null 2>&1; then
6115       :
6116     else
6117       MAKEINFO="$MISSING makeinfo"
6118     fi
6119     ;;
6120
6121 esac
6122
6123 # FIXME: expect and dejagnu may become build tools?
6124
6125 for ac_prog in expect
6126 do
6127   # Extract the first word of "$ac_prog", so it can be a program name with args.
6128 set dummy $ac_prog; ac_word=$2
6129 echo "$as_me:$LINENO: checking for $ac_word" >&5
6130 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6131 if test "${ac_cv_prog_EXPECT+set}" = set; then
6132   echo $ECHO_N "(cached) $ECHO_C" >&6
6133 else
6134   if test -n "$EXPECT"; then
6135   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6136 else
6137 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6138 for as_dir in $PATH
6139 do
6140   IFS=$as_save_IFS
6141   test -z "$as_dir" && as_dir=.
6142   for ac_exec_ext in '' $ac_executable_extensions; do
6143   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6144     ac_cv_prog_EXPECT="$ac_prog"
6145     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6146     break 2
6147   fi
6148 done
6149 done
6150
6151 fi
6152 fi
6153 EXPECT=$ac_cv_prog_EXPECT
6154 if test -n "$EXPECT"; then
6155   echo "$as_me:$LINENO: result: $EXPECT" >&5
6156 echo "${ECHO_T}$EXPECT" >&6
6157 else
6158   echo "$as_me:$LINENO: result: no" >&5
6159 echo "${ECHO_T}no" >&6
6160 fi
6161
6162   test -n "$EXPECT" && break
6163 done
6164 test -n "$EXPECT" || EXPECT="expect"
6165
6166 case " $configdirs " in
6167   *" expect "*)
6168     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6169     ;;
6170 esac
6171
6172 for ac_prog in runtest
6173 do
6174   # Extract the first word of "$ac_prog", so it can be a program name with args.
6175 set dummy $ac_prog; ac_word=$2
6176 echo "$as_me:$LINENO: checking for $ac_word" >&5
6177 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6178 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6179   echo $ECHO_N "(cached) $ECHO_C" >&6
6180 else
6181   if test -n "$RUNTEST"; then
6182   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6183 else
6184 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6185 for as_dir in $PATH
6186 do
6187   IFS=$as_save_IFS
6188   test -z "$as_dir" && as_dir=.
6189   for ac_exec_ext in '' $ac_executable_extensions; do
6190   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6191     ac_cv_prog_RUNTEST="$ac_prog"
6192     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6193     break 2
6194   fi
6195 done
6196 done
6197
6198 fi
6199 fi
6200 RUNTEST=$ac_cv_prog_RUNTEST
6201 if test -n "$RUNTEST"; then
6202   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6203 echo "${ECHO_T}$RUNTEST" >&6
6204 else
6205   echo "$as_me:$LINENO: result: no" >&5
6206 echo "${ECHO_T}no" >&6
6207 fi
6208
6209   test -n "$RUNTEST" && break
6210 done
6211 test -n "$RUNTEST" || RUNTEST="runtest"
6212
6213 case " $configdirs " in
6214   *" dejagnu "*)
6215     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6216     ;;
6217 esac
6218
6219
6220 # Host tools.
6221 ncn_tool_prefix=
6222 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6223 ncn_target_tool_prefix=
6224 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6225
6226
6227
6228 if test -n "$AR"; then
6229   ac_cv_prog_AR=$AR
6230 elif test -n "$ac_cv_prog_AR"; then
6231   AR=$ac_cv_prog_AR
6232 fi
6233
6234 if test -n "$ac_cv_prog_AR"; then
6235   for ncn_progname in ar; do
6236     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6237 set dummy ${ncn_progname}; ac_word=$2
6238 echo "$as_me:$LINENO: checking for $ac_word" >&5
6239 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6240 if test "${ac_cv_prog_AR+set}" = set; then
6241   echo $ECHO_N "(cached) $ECHO_C" >&6
6242 else
6243   if test -n "$AR"; then
6244   ac_cv_prog_AR="$AR" # Let the user override the test.
6245 else
6246 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6247 for as_dir in $PATH
6248 do
6249   IFS=$as_save_IFS
6250   test -z "$as_dir" && as_dir=.
6251   for ac_exec_ext in '' $ac_executable_extensions; do
6252   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6253     ac_cv_prog_AR="${ncn_progname}"
6254     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6255     break 2
6256   fi
6257 done
6258 done
6259
6260 fi
6261 fi
6262 AR=$ac_cv_prog_AR
6263 if test -n "$AR"; then
6264   echo "$as_me:$LINENO: result: $AR" >&5
6265 echo "${ECHO_T}$AR" >&6
6266 else
6267   echo "$as_me:$LINENO: result: no" >&5
6268 echo "${ECHO_T}no" >&6
6269 fi
6270
6271   done
6272 fi
6273
6274 for ncn_progname in ar; do
6275   if test -n "$ncn_tool_prefix"; then
6276     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6277 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6278 echo "$as_me:$LINENO: checking for $ac_word" >&5
6279 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6280 if test "${ac_cv_prog_AR+set}" = set; then
6281   echo $ECHO_N "(cached) $ECHO_C" >&6
6282 else
6283   if test -n "$AR"; then
6284   ac_cv_prog_AR="$AR" # Let the user override the test.
6285 else
6286 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6287 for as_dir in $PATH
6288 do
6289   IFS=$as_save_IFS
6290   test -z "$as_dir" && as_dir=.
6291   for ac_exec_ext in '' $ac_executable_extensions; do
6292   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6293     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6294     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6295     break 2
6296   fi
6297 done
6298 done
6299
6300 fi
6301 fi
6302 AR=$ac_cv_prog_AR
6303 if test -n "$AR"; then
6304   echo "$as_me:$LINENO: result: $AR" >&5
6305 echo "${ECHO_T}$AR" >&6
6306 else
6307   echo "$as_me:$LINENO: result: no" >&5
6308 echo "${ECHO_T}no" >&6
6309 fi
6310
6311   fi
6312   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6313     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6314 set dummy ${ncn_progname}; ac_word=$2
6315 echo "$as_me:$LINENO: checking for $ac_word" >&5
6316 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6317 if test "${ac_cv_prog_AR+set}" = set; then
6318   echo $ECHO_N "(cached) $ECHO_C" >&6
6319 else
6320   if test -n "$AR"; then
6321   ac_cv_prog_AR="$AR" # Let the user override the test.
6322 else
6323 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6324 for as_dir in $PATH
6325 do
6326   IFS=$as_save_IFS
6327   test -z "$as_dir" && as_dir=.
6328   for ac_exec_ext in '' $ac_executable_extensions; do
6329   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6330     ac_cv_prog_AR="${ncn_progname}"
6331     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6332     break 2
6333   fi
6334 done
6335 done
6336
6337 fi
6338 fi
6339 AR=$ac_cv_prog_AR
6340 if test -n "$AR"; then
6341   echo "$as_me:$LINENO: result: $AR" >&5
6342 echo "${ECHO_T}$AR" >&6
6343 else
6344   echo "$as_me:$LINENO: result: no" >&5
6345 echo "${ECHO_T}no" >&6
6346 fi
6347
6348   fi
6349   test -n "$ac_cv_prog_AR" && break
6350 done
6351
6352 if test -z "$ac_cv_prog_AR" ; then
6353   set dummy ar
6354   if test $build = $host ; then
6355     AR="$2"
6356   else
6357     AR="${ncn_tool_prefix}$2"
6358   fi
6359 fi
6360
6361
6362
6363 if test -n "$AS"; then
6364   ac_cv_prog_AS=$AS
6365 elif test -n "$ac_cv_prog_AS"; then
6366   AS=$ac_cv_prog_AS
6367 fi
6368
6369 if test -n "$ac_cv_prog_AS"; then
6370   for ncn_progname in as; do
6371     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6372 set dummy ${ncn_progname}; ac_word=$2
6373 echo "$as_me:$LINENO: checking for $ac_word" >&5
6374 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6375 if test "${ac_cv_prog_AS+set}" = set; then
6376   echo $ECHO_N "(cached) $ECHO_C" >&6
6377 else
6378   if test -n "$AS"; then
6379   ac_cv_prog_AS="$AS" # Let the user override the test.
6380 else
6381 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6382 for as_dir in $PATH
6383 do
6384   IFS=$as_save_IFS
6385   test -z "$as_dir" && as_dir=.
6386   for ac_exec_ext in '' $ac_executable_extensions; do
6387   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6388     ac_cv_prog_AS="${ncn_progname}"
6389     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6390     break 2
6391   fi
6392 done
6393 done
6394
6395 fi
6396 fi
6397 AS=$ac_cv_prog_AS
6398 if test -n "$AS"; then
6399   echo "$as_me:$LINENO: result: $AS" >&5
6400 echo "${ECHO_T}$AS" >&6
6401 else
6402   echo "$as_me:$LINENO: result: no" >&5
6403 echo "${ECHO_T}no" >&6
6404 fi
6405
6406   done
6407 fi
6408
6409 for ncn_progname in as; do
6410   if test -n "$ncn_tool_prefix"; then
6411     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6412 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6413 echo "$as_me:$LINENO: checking for $ac_word" >&5
6414 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6415 if test "${ac_cv_prog_AS+set}" = set; then
6416   echo $ECHO_N "(cached) $ECHO_C" >&6
6417 else
6418   if test -n "$AS"; then
6419   ac_cv_prog_AS="$AS" # Let the user override the test.
6420 else
6421 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6422 for as_dir in $PATH
6423 do
6424   IFS=$as_save_IFS
6425   test -z "$as_dir" && as_dir=.
6426   for ac_exec_ext in '' $ac_executable_extensions; do
6427   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6428     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6429     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6430     break 2
6431   fi
6432 done
6433 done
6434
6435 fi
6436 fi
6437 AS=$ac_cv_prog_AS
6438 if test -n "$AS"; then
6439   echo "$as_me:$LINENO: result: $AS" >&5
6440 echo "${ECHO_T}$AS" >&6
6441 else
6442   echo "$as_me:$LINENO: result: no" >&5
6443 echo "${ECHO_T}no" >&6
6444 fi
6445
6446   fi
6447   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6448     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6449 set dummy ${ncn_progname}; ac_word=$2
6450 echo "$as_me:$LINENO: checking for $ac_word" >&5
6451 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6452 if test "${ac_cv_prog_AS+set}" = set; then
6453   echo $ECHO_N "(cached) $ECHO_C" >&6
6454 else
6455   if test -n "$AS"; then
6456   ac_cv_prog_AS="$AS" # Let the user override the test.
6457 else
6458 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6459 for as_dir in $PATH
6460 do
6461   IFS=$as_save_IFS
6462   test -z "$as_dir" && as_dir=.
6463   for ac_exec_ext in '' $ac_executable_extensions; do
6464   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6465     ac_cv_prog_AS="${ncn_progname}"
6466     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6467     break 2
6468   fi
6469 done
6470 done
6471
6472 fi
6473 fi
6474 AS=$ac_cv_prog_AS
6475 if test -n "$AS"; then
6476   echo "$as_me:$LINENO: result: $AS" >&5
6477 echo "${ECHO_T}$AS" >&6
6478 else
6479   echo "$as_me:$LINENO: result: no" >&5
6480 echo "${ECHO_T}no" >&6
6481 fi
6482
6483   fi
6484   test -n "$ac_cv_prog_AS" && break
6485 done
6486
6487 if test -z "$ac_cv_prog_AS" ; then
6488   set dummy as
6489   if test $build = $host ; then
6490     AS="$2"
6491   else
6492     AS="${ncn_tool_prefix}$2"
6493   fi
6494 fi
6495
6496
6497
6498 if test -n "$DLLTOOL"; then
6499   ac_cv_prog_DLLTOOL=$DLLTOOL
6500 elif test -n "$ac_cv_prog_DLLTOOL"; then
6501   DLLTOOL=$ac_cv_prog_DLLTOOL
6502 fi
6503
6504 if test -n "$ac_cv_prog_DLLTOOL"; then
6505   for ncn_progname in dlltool; do
6506     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6507 set dummy ${ncn_progname}; ac_word=$2
6508 echo "$as_me:$LINENO: checking for $ac_word" >&5
6509 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6510 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6511   echo $ECHO_N "(cached) $ECHO_C" >&6
6512 else
6513   if test -n "$DLLTOOL"; then
6514   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6515 else
6516 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6517 for as_dir in $PATH
6518 do
6519   IFS=$as_save_IFS
6520   test -z "$as_dir" && as_dir=.
6521   for ac_exec_ext in '' $ac_executable_extensions; do
6522   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6523     ac_cv_prog_DLLTOOL="${ncn_progname}"
6524     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6525     break 2
6526   fi
6527 done
6528 done
6529
6530 fi
6531 fi
6532 DLLTOOL=$ac_cv_prog_DLLTOOL
6533 if test -n "$DLLTOOL"; then
6534   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6535 echo "${ECHO_T}$DLLTOOL" >&6
6536 else
6537   echo "$as_me:$LINENO: result: no" >&5
6538 echo "${ECHO_T}no" >&6
6539 fi
6540
6541   done
6542 fi
6543
6544 for ncn_progname in dlltool; do
6545   if test -n "$ncn_tool_prefix"; then
6546     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6547 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6548 echo "$as_me:$LINENO: checking for $ac_word" >&5
6549 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6550 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6551   echo $ECHO_N "(cached) $ECHO_C" >&6
6552 else
6553   if test -n "$DLLTOOL"; then
6554   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6555 else
6556 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6557 for as_dir in $PATH
6558 do
6559   IFS=$as_save_IFS
6560   test -z "$as_dir" && as_dir=.
6561   for ac_exec_ext in '' $ac_executable_extensions; do
6562   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6563     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6564     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6565     break 2
6566   fi
6567 done
6568 done
6569
6570 fi
6571 fi
6572 DLLTOOL=$ac_cv_prog_DLLTOOL
6573 if test -n "$DLLTOOL"; then
6574   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6575 echo "${ECHO_T}$DLLTOOL" >&6
6576 else
6577   echo "$as_me:$LINENO: result: no" >&5
6578 echo "${ECHO_T}no" >&6
6579 fi
6580
6581   fi
6582   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6583     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6584 set dummy ${ncn_progname}; ac_word=$2
6585 echo "$as_me:$LINENO: checking for $ac_word" >&5
6586 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6587 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6588   echo $ECHO_N "(cached) $ECHO_C" >&6
6589 else
6590   if test -n "$DLLTOOL"; then
6591   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6592 else
6593 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6594 for as_dir in $PATH
6595 do
6596   IFS=$as_save_IFS
6597   test -z "$as_dir" && as_dir=.
6598   for ac_exec_ext in '' $ac_executable_extensions; do
6599   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6600     ac_cv_prog_DLLTOOL="${ncn_progname}"
6601     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6602     break 2
6603   fi
6604 done
6605 done
6606
6607 fi
6608 fi
6609 DLLTOOL=$ac_cv_prog_DLLTOOL
6610 if test -n "$DLLTOOL"; then
6611   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6612 echo "${ECHO_T}$DLLTOOL" >&6
6613 else
6614   echo "$as_me:$LINENO: result: no" >&5
6615 echo "${ECHO_T}no" >&6
6616 fi
6617
6618   fi
6619   test -n "$ac_cv_prog_DLLTOOL" && break
6620 done
6621
6622 if test -z "$ac_cv_prog_DLLTOOL" ; then
6623   set dummy dlltool
6624   if test $build = $host ; then
6625     DLLTOOL="$2"
6626   else
6627     DLLTOOL="${ncn_tool_prefix}$2"
6628   fi
6629 fi
6630
6631
6632
6633 if test -n "$LD"; then
6634   ac_cv_prog_LD=$LD
6635 elif test -n "$ac_cv_prog_LD"; then
6636   LD=$ac_cv_prog_LD
6637 fi
6638
6639 if test -n "$ac_cv_prog_LD"; then
6640   for ncn_progname in ld; do
6641     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6642 set dummy ${ncn_progname}; ac_word=$2
6643 echo "$as_me:$LINENO: checking for $ac_word" >&5
6644 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6645 if test "${ac_cv_prog_LD+set}" = set; then
6646   echo $ECHO_N "(cached) $ECHO_C" >&6
6647 else
6648   if test -n "$LD"; then
6649   ac_cv_prog_LD="$LD" # Let the user override the test.
6650 else
6651 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6652 for as_dir in $PATH
6653 do
6654   IFS=$as_save_IFS
6655   test -z "$as_dir" && as_dir=.
6656   for ac_exec_ext in '' $ac_executable_extensions; do
6657   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6658     ac_cv_prog_LD="${ncn_progname}"
6659     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6660     break 2
6661   fi
6662 done
6663 done
6664
6665 fi
6666 fi
6667 LD=$ac_cv_prog_LD
6668 if test -n "$LD"; then
6669   echo "$as_me:$LINENO: result: $LD" >&5
6670 echo "${ECHO_T}$LD" >&6
6671 else
6672   echo "$as_me:$LINENO: result: no" >&5
6673 echo "${ECHO_T}no" >&6
6674 fi
6675
6676   done
6677 fi
6678
6679 for ncn_progname in ld; do
6680   if test -n "$ncn_tool_prefix"; then
6681     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6682 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6683 echo "$as_me:$LINENO: checking for $ac_word" >&5
6684 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6685 if test "${ac_cv_prog_LD+set}" = set; then
6686   echo $ECHO_N "(cached) $ECHO_C" >&6
6687 else
6688   if test -n "$LD"; then
6689   ac_cv_prog_LD="$LD" # Let the user override the test.
6690 else
6691 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6692 for as_dir in $PATH
6693 do
6694   IFS=$as_save_IFS
6695   test -z "$as_dir" && as_dir=.
6696   for ac_exec_ext in '' $ac_executable_extensions; do
6697   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6698     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6699     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6700     break 2
6701   fi
6702 done
6703 done
6704
6705 fi
6706 fi
6707 LD=$ac_cv_prog_LD
6708 if test -n "$LD"; then
6709   echo "$as_me:$LINENO: result: $LD" >&5
6710 echo "${ECHO_T}$LD" >&6
6711 else
6712   echo "$as_me:$LINENO: result: no" >&5
6713 echo "${ECHO_T}no" >&6
6714 fi
6715
6716   fi
6717   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6718     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6719 set dummy ${ncn_progname}; ac_word=$2
6720 echo "$as_me:$LINENO: checking for $ac_word" >&5
6721 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6722 if test "${ac_cv_prog_LD+set}" = set; then
6723   echo $ECHO_N "(cached) $ECHO_C" >&6
6724 else
6725   if test -n "$LD"; then
6726   ac_cv_prog_LD="$LD" # Let the user override the test.
6727 else
6728 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6729 for as_dir in $PATH
6730 do
6731   IFS=$as_save_IFS
6732   test -z "$as_dir" && as_dir=.
6733   for ac_exec_ext in '' $ac_executable_extensions; do
6734   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6735     ac_cv_prog_LD="${ncn_progname}"
6736     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6737     break 2
6738   fi
6739 done
6740 done
6741
6742 fi
6743 fi
6744 LD=$ac_cv_prog_LD
6745 if test -n "$LD"; then
6746   echo "$as_me:$LINENO: result: $LD" >&5
6747 echo "${ECHO_T}$LD" >&6
6748 else
6749   echo "$as_me:$LINENO: result: no" >&5
6750 echo "${ECHO_T}no" >&6
6751 fi
6752
6753   fi
6754   test -n "$ac_cv_prog_LD" && break
6755 done
6756
6757 if test -z "$ac_cv_prog_LD" ; then
6758   set dummy ld
6759   if test $build = $host ; then
6760     LD="$2"
6761   else
6762     LD="${ncn_tool_prefix}$2"
6763   fi
6764 fi
6765
6766
6767
6768 if test -n "$LIPO"; then
6769   ac_cv_prog_LIPO=$LIPO
6770 elif test -n "$ac_cv_prog_LIPO"; then
6771   LIPO=$ac_cv_prog_LIPO
6772 fi
6773
6774 if test -n "$ac_cv_prog_LIPO"; then
6775   for ncn_progname in lipo; do
6776     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6777 set dummy ${ncn_progname}; ac_word=$2
6778 echo "$as_me:$LINENO: checking for $ac_word" >&5
6779 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6780 if test "${ac_cv_prog_LIPO+set}" = set; then
6781   echo $ECHO_N "(cached) $ECHO_C" >&6
6782 else
6783   if test -n "$LIPO"; then
6784   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6785 else
6786 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6787 for as_dir in $PATH
6788 do
6789   IFS=$as_save_IFS
6790   test -z "$as_dir" && as_dir=.
6791   for ac_exec_ext in '' $ac_executable_extensions; do
6792   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6793     ac_cv_prog_LIPO="${ncn_progname}"
6794     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6795     break 2
6796   fi
6797 done
6798 done
6799
6800 fi
6801 fi
6802 LIPO=$ac_cv_prog_LIPO
6803 if test -n "$LIPO"; then
6804   echo "$as_me:$LINENO: result: $LIPO" >&5
6805 echo "${ECHO_T}$LIPO" >&6
6806 else
6807   echo "$as_me:$LINENO: result: no" >&5
6808 echo "${ECHO_T}no" >&6
6809 fi
6810
6811   done
6812 fi
6813
6814 for ncn_progname in lipo; do
6815   if test -n "$ncn_tool_prefix"; then
6816     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6817 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6818 echo "$as_me:$LINENO: checking for $ac_word" >&5
6819 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6820 if test "${ac_cv_prog_LIPO+set}" = set; then
6821   echo $ECHO_N "(cached) $ECHO_C" >&6
6822 else
6823   if test -n "$LIPO"; then
6824   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6825 else
6826 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6827 for as_dir in $PATH
6828 do
6829   IFS=$as_save_IFS
6830   test -z "$as_dir" && as_dir=.
6831   for ac_exec_ext in '' $ac_executable_extensions; do
6832   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6833     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
6834     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6835     break 2
6836   fi
6837 done
6838 done
6839
6840 fi
6841 fi
6842 LIPO=$ac_cv_prog_LIPO
6843 if test -n "$LIPO"; then
6844   echo "$as_me:$LINENO: result: $LIPO" >&5
6845 echo "${ECHO_T}$LIPO" >&6
6846 else
6847   echo "$as_me:$LINENO: result: no" >&5
6848 echo "${ECHO_T}no" >&6
6849 fi
6850
6851   fi
6852   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
6853     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6854 set dummy ${ncn_progname}; ac_word=$2
6855 echo "$as_me:$LINENO: checking for $ac_word" >&5
6856 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6857 if test "${ac_cv_prog_LIPO+set}" = set; then
6858   echo $ECHO_N "(cached) $ECHO_C" >&6
6859 else
6860   if test -n "$LIPO"; then
6861   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6862 else
6863 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6864 for as_dir in $PATH
6865 do
6866   IFS=$as_save_IFS
6867   test -z "$as_dir" && as_dir=.
6868   for ac_exec_ext in '' $ac_executable_extensions; do
6869   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6870     ac_cv_prog_LIPO="${ncn_progname}"
6871     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6872     break 2
6873   fi
6874 done
6875 done
6876
6877 fi
6878 fi
6879 LIPO=$ac_cv_prog_LIPO
6880 if test -n "$LIPO"; then
6881   echo "$as_me:$LINENO: result: $LIPO" >&5
6882 echo "${ECHO_T}$LIPO" >&6
6883 else
6884   echo "$as_me:$LINENO: result: no" >&5
6885 echo "${ECHO_T}no" >&6
6886 fi
6887
6888   fi
6889   test -n "$ac_cv_prog_LIPO" && break
6890 done
6891
6892 if test -z "$ac_cv_prog_LIPO" ; then
6893   set dummy lipo
6894   if test $build = $host ; then
6895     LIPO="$2"
6896   else
6897     LIPO="${ncn_tool_prefix}$2"
6898   fi
6899 fi
6900
6901
6902
6903 if test -n "$NM"; then
6904   ac_cv_prog_NM=$NM
6905 elif test -n "$ac_cv_prog_NM"; then
6906   NM=$ac_cv_prog_NM
6907 fi
6908
6909 if test -n "$ac_cv_prog_NM"; then
6910   for ncn_progname in nm; do
6911     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6912 set dummy ${ncn_progname}; ac_word=$2
6913 echo "$as_me:$LINENO: checking for $ac_word" >&5
6914 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6915 if test "${ac_cv_prog_NM+set}" = set; then
6916   echo $ECHO_N "(cached) $ECHO_C" >&6
6917 else
6918   if test -n "$NM"; then
6919   ac_cv_prog_NM="$NM" # Let the user override the test.
6920 else
6921 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6922 for as_dir in $PATH
6923 do
6924   IFS=$as_save_IFS
6925   test -z "$as_dir" && as_dir=.
6926   for ac_exec_ext in '' $ac_executable_extensions; do
6927   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6928     ac_cv_prog_NM="${ncn_progname}"
6929     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6930     break 2
6931   fi
6932 done
6933 done
6934
6935 fi
6936 fi
6937 NM=$ac_cv_prog_NM
6938 if test -n "$NM"; then
6939   echo "$as_me:$LINENO: result: $NM" >&5
6940 echo "${ECHO_T}$NM" >&6
6941 else
6942   echo "$as_me:$LINENO: result: no" >&5
6943 echo "${ECHO_T}no" >&6
6944 fi
6945
6946   done
6947 fi
6948
6949 for ncn_progname in nm; do
6950   if test -n "$ncn_tool_prefix"; then
6951     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6952 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6953 echo "$as_me:$LINENO: checking for $ac_word" >&5
6954 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6955 if test "${ac_cv_prog_NM+set}" = set; then
6956   echo $ECHO_N "(cached) $ECHO_C" >&6
6957 else
6958   if test -n "$NM"; then
6959   ac_cv_prog_NM="$NM" # Let the user override the test.
6960 else
6961 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6962 for as_dir in $PATH
6963 do
6964   IFS=$as_save_IFS
6965   test -z "$as_dir" && as_dir=.
6966   for ac_exec_ext in '' $ac_executable_extensions; do
6967   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6968     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
6969     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6970     break 2
6971   fi
6972 done
6973 done
6974
6975 fi
6976 fi
6977 NM=$ac_cv_prog_NM
6978 if test -n "$NM"; then
6979   echo "$as_me:$LINENO: result: $NM" >&5
6980 echo "${ECHO_T}$NM" >&6
6981 else
6982   echo "$as_me:$LINENO: result: no" >&5
6983 echo "${ECHO_T}no" >&6
6984 fi
6985
6986   fi
6987   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
6988     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6989 set dummy ${ncn_progname}; ac_word=$2
6990 echo "$as_me:$LINENO: checking for $ac_word" >&5
6991 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6992 if test "${ac_cv_prog_NM+set}" = set; then
6993   echo $ECHO_N "(cached) $ECHO_C" >&6
6994 else
6995   if test -n "$NM"; then
6996   ac_cv_prog_NM="$NM" # Let the user override the test.
6997 else
6998 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6999 for as_dir in $PATH
7000 do
7001   IFS=$as_save_IFS
7002   test -z "$as_dir" && as_dir=.
7003   for ac_exec_ext in '' $ac_executable_extensions; do
7004   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7005     ac_cv_prog_NM="${ncn_progname}"
7006     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7007     break 2
7008   fi
7009 done
7010 done
7011
7012 fi
7013 fi
7014 NM=$ac_cv_prog_NM
7015 if test -n "$NM"; then
7016   echo "$as_me:$LINENO: result: $NM" >&5
7017 echo "${ECHO_T}$NM" >&6
7018 else
7019   echo "$as_me:$LINENO: result: no" >&5
7020 echo "${ECHO_T}no" >&6
7021 fi
7022
7023   fi
7024   test -n "$ac_cv_prog_NM" && break
7025 done
7026
7027 if test -z "$ac_cv_prog_NM" ; then
7028   set dummy nm
7029   if test $build = $host ; then
7030     NM="$2"
7031   else
7032     NM="${ncn_tool_prefix}$2"
7033   fi
7034 fi
7035
7036
7037
7038 if test -n "$RANLIB"; then
7039   ac_cv_prog_RANLIB=$RANLIB
7040 elif test -n "$ac_cv_prog_RANLIB"; then
7041   RANLIB=$ac_cv_prog_RANLIB
7042 fi
7043
7044 if test -n "$ac_cv_prog_RANLIB"; then
7045   for ncn_progname in ranlib; do
7046     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7047 set dummy ${ncn_progname}; ac_word=$2
7048 echo "$as_me:$LINENO: checking for $ac_word" >&5
7049 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7050 if test "${ac_cv_prog_RANLIB+set}" = set; then
7051   echo $ECHO_N "(cached) $ECHO_C" >&6
7052 else
7053   if test -n "$RANLIB"; then
7054   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7055 else
7056 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7057 for as_dir in $PATH
7058 do
7059   IFS=$as_save_IFS
7060   test -z "$as_dir" && as_dir=.
7061   for ac_exec_ext in '' $ac_executable_extensions; do
7062   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7063     ac_cv_prog_RANLIB="${ncn_progname}"
7064     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7065     break 2
7066   fi
7067 done
7068 done
7069
7070 fi
7071 fi
7072 RANLIB=$ac_cv_prog_RANLIB
7073 if test -n "$RANLIB"; then
7074   echo "$as_me:$LINENO: result: $RANLIB" >&5
7075 echo "${ECHO_T}$RANLIB" >&6
7076 else
7077   echo "$as_me:$LINENO: result: no" >&5
7078 echo "${ECHO_T}no" >&6
7079 fi
7080
7081   done
7082 fi
7083
7084 for ncn_progname in ranlib; do
7085   if test -n "$ncn_tool_prefix"; then
7086     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7087 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7088 echo "$as_me:$LINENO: checking for $ac_word" >&5
7089 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7090 if test "${ac_cv_prog_RANLIB+set}" = set; then
7091   echo $ECHO_N "(cached) $ECHO_C" >&6
7092 else
7093   if test -n "$RANLIB"; then
7094   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7095 else
7096 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7097 for as_dir in $PATH
7098 do
7099   IFS=$as_save_IFS
7100   test -z "$as_dir" && as_dir=.
7101   for ac_exec_ext in '' $ac_executable_extensions; do
7102   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7103     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7104     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7105     break 2
7106   fi
7107 done
7108 done
7109
7110 fi
7111 fi
7112 RANLIB=$ac_cv_prog_RANLIB
7113 if test -n "$RANLIB"; then
7114   echo "$as_me:$LINENO: result: $RANLIB" >&5
7115 echo "${ECHO_T}$RANLIB" >&6
7116 else
7117   echo "$as_me:$LINENO: result: no" >&5
7118 echo "${ECHO_T}no" >&6
7119 fi
7120
7121   fi
7122   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7123     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7124 set dummy ${ncn_progname}; ac_word=$2
7125 echo "$as_me:$LINENO: checking for $ac_word" >&5
7126 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7127 if test "${ac_cv_prog_RANLIB+set}" = set; then
7128   echo $ECHO_N "(cached) $ECHO_C" >&6
7129 else
7130   if test -n "$RANLIB"; then
7131   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7132 else
7133 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7134 for as_dir in $PATH
7135 do
7136   IFS=$as_save_IFS
7137   test -z "$as_dir" && as_dir=.
7138   for ac_exec_ext in '' $ac_executable_extensions; do
7139   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7140     ac_cv_prog_RANLIB="${ncn_progname}"
7141     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7142     break 2
7143   fi
7144 done
7145 done
7146
7147 fi
7148 fi
7149 RANLIB=$ac_cv_prog_RANLIB
7150 if test -n "$RANLIB"; then
7151   echo "$as_me:$LINENO: result: $RANLIB" >&5
7152 echo "${ECHO_T}$RANLIB" >&6
7153 else
7154   echo "$as_me:$LINENO: result: no" >&5
7155 echo "${ECHO_T}no" >&6
7156 fi
7157
7158   fi
7159   test -n "$ac_cv_prog_RANLIB" && break
7160 done
7161
7162 if test -z "$ac_cv_prog_RANLIB" ; then
7163   RANLIB=":"
7164 fi
7165
7166
7167
7168 if test -n "$STRIP"; then
7169   ac_cv_prog_STRIP=$STRIP
7170 elif test -n "$ac_cv_prog_STRIP"; then
7171   STRIP=$ac_cv_prog_STRIP
7172 fi
7173
7174 if test -n "$ac_cv_prog_STRIP"; then
7175   for ncn_progname in strip; do
7176     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7177 set dummy ${ncn_progname}; ac_word=$2
7178 echo "$as_me:$LINENO: checking for $ac_word" >&5
7179 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7180 if test "${ac_cv_prog_STRIP+set}" = set; then
7181   echo $ECHO_N "(cached) $ECHO_C" >&6
7182 else
7183   if test -n "$STRIP"; then
7184   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7185 else
7186 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7187 for as_dir in $PATH
7188 do
7189   IFS=$as_save_IFS
7190   test -z "$as_dir" && as_dir=.
7191   for ac_exec_ext in '' $ac_executable_extensions; do
7192   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7193     ac_cv_prog_STRIP="${ncn_progname}"
7194     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7195     break 2
7196   fi
7197 done
7198 done
7199
7200 fi
7201 fi
7202 STRIP=$ac_cv_prog_STRIP
7203 if test -n "$STRIP"; then
7204   echo "$as_me:$LINENO: result: $STRIP" >&5
7205 echo "${ECHO_T}$STRIP" >&6
7206 else
7207   echo "$as_me:$LINENO: result: no" >&5
7208 echo "${ECHO_T}no" >&6
7209 fi
7210
7211   done
7212 fi
7213
7214 for ncn_progname in strip; do
7215   if test -n "$ncn_tool_prefix"; then
7216     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7217 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7218 echo "$as_me:$LINENO: checking for $ac_word" >&5
7219 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7220 if test "${ac_cv_prog_STRIP+set}" = set; then
7221   echo $ECHO_N "(cached) $ECHO_C" >&6
7222 else
7223   if test -n "$STRIP"; then
7224   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7225 else
7226 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7227 for as_dir in $PATH
7228 do
7229   IFS=$as_save_IFS
7230   test -z "$as_dir" && as_dir=.
7231   for ac_exec_ext in '' $ac_executable_extensions; do
7232   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7233     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7234     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7235     break 2
7236   fi
7237 done
7238 done
7239
7240 fi
7241 fi
7242 STRIP=$ac_cv_prog_STRIP
7243 if test -n "$STRIP"; then
7244   echo "$as_me:$LINENO: result: $STRIP" >&5
7245 echo "${ECHO_T}$STRIP" >&6
7246 else
7247   echo "$as_me:$LINENO: result: no" >&5
7248 echo "${ECHO_T}no" >&6
7249 fi
7250
7251   fi
7252   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7253     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7254 set dummy ${ncn_progname}; ac_word=$2
7255 echo "$as_me:$LINENO: checking for $ac_word" >&5
7256 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7257 if test "${ac_cv_prog_STRIP+set}" = set; then
7258   echo $ECHO_N "(cached) $ECHO_C" >&6
7259 else
7260   if test -n "$STRIP"; then
7261   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7262 else
7263 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7264 for as_dir in $PATH
7265 do
7266   IFS=$as_save_IFS
7267   test -z "$as_dir" && as_dir=.
7268   for ac_exec_ext in '' $ac_executable_extensions; do
7269   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7270     ac_cv_prog_STRIP="${ncn_progname}"
7271     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7272     break 2
7273   fi
7274 done
7275 done
7276
7277 fi
7278 fi
7279 STRIP=$ac_cv_prog_STRIP
7280 if test -n "$STRIP"; then
7281   echo "$as_me:$LINENO: result: $STRIP" >&5
7282 echo "${ECHO_T}$STRIP" >&6
7283 else
7284   echo "$as_me:$LINENO: result: no" >&5
7285 echo "${ECHO_T}no" >&6
7286 fi
7287
7288   fi
7289   test -n "$ac_cv_prog_STRIP" && break
7290 done
7291
7292 if test -z "$ac_cv_prog_STRIP" ; then
7293   STRIP=":"
7294 fi
7295
7296
7297
7298 if test -n "$WINDRES"; then
7299   ac_cv_prog_WINDRES=$WINDRES
7300 elif test -n "$ac_cv_prog_WINDRES"; then
7301   WINDRES=$ac_cv_prog_WINDRES
7302 fi
7303
7304 if test -n "$ac_cv_prog_WINDRES"; then
7305   for ncn_progname in windres; do
7306     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7307 set dummy ${ncn_progname}; ac_word=$2
7308 echo "$as_me:$LINENO: checking for $ac_word" >&5
7309 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7310 if test "${ac_cv_prog_WINDRES+set}" = set; then
7311   echo $ECHO_N "(cached) $ECHO_C" >&6
7312 else
7313   if test -n "$WINDRES"; then
7314   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7315 else
7316 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7317 for as_dir in $PATH
7318 do
7319   IFS=$as_save_IFS
7320   test -z "$as_dir" && as_dir=.
7321   for ac_exec_ext in '' $ac_executable_extensions; do
7322   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7323     ac_cv_prog_WINDRES="${ncn_progname}"
7324     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7325     break 2
7326   fi
7327 done
7328 done
7329
7330 fi
7331 fi
7332 WINDRES=$ac_cv_prog_WINDRES
7333 if test -n "$WINDRES"; then
7334   echo "$as_me:$LINENO: result: $WINDRES" >&5
7335 echo "${ECHO_T}$WINDRES" >&6
7336 else
7337   echo "$as_me:$LINENO: result: no" >&5
7338 echo "${ECHO_T}no" >&6
7339 fi
7340
7341   done
7342 fi
7343
7344 for ncn_progname in windres; do
7345   if test -n "$ncn_tool_prefix"; then
7346     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7347 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7348 echo "$as_me:$LINENO: checking for $ac_word" >&5
7349 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7350 if test "${ac_cv_prog_WINDRES+set}" = set; then
7351   echo $ECHO_N "(cached) $ECHO_C" >&6
7352 else
7353   if test -n "$WINDRES"; then
7354   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7355 else
7356 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7357 for as_dir in $PATH
7358 do
7359   IFS=$as_save_IFS
7360   test -z "$as_dir" && as_dir=.
7361   for ac_exec_ext in '' $ac_executable_extensions; do
7362   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7363     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7364     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7365     break 2
7366   fi
7367 done
7368 done
7369
7370 fi
7371 fi
7372 WINDRES=$ac_cv_prog_WINDRES
7373 if test -n "$WINDRES"; then
7374   echo "$as_me:$LINENO: result: $WINDRES" >&5
7375 echo "${ECHO_T}$WINDRES" >&6
7376 else
7377   echo "$as_me:$LINENO: result: no" >&5
7378 echo "${ECHO_T}no" >&6
7379 fi
7380
7381   fi
7382   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7383     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7384 set dummy ${ncn_progname}; ac_word=$2
7385 echo "$as_me:$LINENO: checking for $ac_word" >&5
7386 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7387 if test "${ac_cv_prog_WINDRES+set}" = set; then
7388   echo $ECHO_N "(cached) $ECHO_C" >&6
7389 else
7390   if test -n "$WINDRES"; then
7391   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7392 else
7393 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7394 for as_dir in $PATH
7395 do
7396   IFS=$as_save_IFS
7397   test -z "$as_dir" && as_dir=.
7398   for ac_exec_ext in '' $ac_executable_extensions; do
7399   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7400     ac_cv_prog_WINDRES="${ncn_progname}"
7401     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7402     break 2
7403   fi
7404 done
7405 done
7406
7407 fi
7408 fi
7409 WINDRES=$ac_cv_prog_WINDRES
7410 if test -n "$WINDRES"; then
7411   echo "$as_me:$LINENO: result: $WINDRES" >&5
7412 echo "${ECHO_T}$WINDRES" >&6
7413 else
7414   echo "$as_me:$LINENO: result: no" >&5
7415 echo "${ECHO_T}no" >&6
7416 fi
7417
7418   fi
7419   test -n "$ac_cv_prog_WINDRES" && break
7420 done
7421
7422 if test -z "$ac_cv_prog_WINDRES" ; then
7423   set dummy windres
7424   if test $build = $host ; then
7425     WINDRES="$2"
7426   else
7427     WINDRES="${ncn_tool_prefix}$2"
7428   fi
7429 fi
7430
7431
7432
7433 if test -n "$OBJCOPY"; then
7434   ac_cv_prog_OBJCOPY=$OBJCOPY
7435 elif test -n "$ac_cv_prog_OBJCOPY"; then
7436   OBJCOPY=$ac_cv_prog_OBJCOPY
7437 fi
7438
7439 if test -n "$ac_cv_prog_OBJCOPY"; then
7440   for ncn_progname in objcopy; do
7441     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7442 set dummy ${ncn_progname}; ac_word=$2
7443 echo "$as_me:$LINENO: checking for $ac_word" >&5
7444 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7445 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7446   echo $ECHO_N "(cached) $ECHO_C" >&6
7447 else
7448   if test -n "$OBJCOPY"; then
7449   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7450 else
7451 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7452 for as_dir in $PATH
7453 do
7454   IFS=$as_save_IFS
7455   test -z "$as_dir" && as_dir=.
7456   for ac_exec_ext in '' $ac_executable_extensions; do
7457   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7458     ac_cv_prog_OBJCOPY="${ncn_progname}"
7459     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7460     break 2
7461   fi
7462 done
7463 done
7464
7465 fi
7466 fi
7467 OBJCOPY=$ac_cv_prog_OBJCOPY
7468 if test -n "$OBJCOPY"; then
7469   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7470 echo "${ECHO_T}$OBJCOPY" >&6
7471 else
7472   echo "$as_me:$LINENO: result: no" >&5
7473 echo "${ECHO_T}no" >&6
7474 fi
7475
7476   done
7477 fi
7478
7479 for ncn_progname in objcopy; do
7480   if test -n "$ncn_tool_prefix"; then
7481     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7482 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7483 echo "$as_me:$LINENO: checking for $ac_word" >&5
7484 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7485 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7486   echo $ECHO_N "(cached) $ECHO_C" >&6
7487 else
7488   if test -n "$OBJCOPY"; then
7489   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7490 else
7491 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7492 for as_dir in $PATH
7493 do
7494   IFS=$as_save_IFS
7495   test -z "$as_dir" && as_dir=.
7496   for ac_exec_ext in '' $ac_executable_extensions; do
7497   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7498     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7499     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7500     break 2
7501   fi
7502 done
7503 done
7504
7505 fi
7506 fi
7507 OBJCOPY=$ac_cv_prog_OBJCOPY
7508 if test -n "$OBJCOPY"; then
7509   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7510 echo "${ECHO_T}$OBJCOPY" >&6
7511 else
7512   echo "$as_me:$LINENO: result: no" >&5
7513 echo "${ECHO_T}no" >&6
7514 fi
7515
7516   fi
7517   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7518     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7519 set dummy ${ncn_progname}; ac_word=$2
7520 echo "$as_me:$LINENO: checking for $ac_word" >&5
7521 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7522 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7523   echo $ECHO_N "(cached) $ECHO_C" >&6
7524 else
7525   if test -n "$OBJCOPY"; then
7526   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7527 else
7528 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7529 for as_dir in $PATH
7530 do
7531   IFS=$as_save_IFS
7532   test -z "$as_dir" && as_dir=.
7533   for ac_exec_ext in '' $ac_executable_extensions; do
7534   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7535     ac_cv_prog_OBJCOPY="${ncn_progname}"
7536     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7537     break 2
7538   fi
7539 done
7540 done
7541
7542 fi
7543 fi
7544 OBJCOPY=$ac_cv_prog_OBJCOPY
7545 if test -n "$OBJCOPY"; then
7546   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7547 echo "${ECHO_T}$OBJCOPY" >&6
7548 else
7549   echo "$as_me:$LINENO: result: no" >&5
7550 echo "${ECHO_T}no" >&6
7551 fi
7552
7553   fi
7554   test -n "$ac_cv_prog_OBJCOPY" && break
7555 done
7556
7557 if test -z "$ac_cv_prog_OBJCOPY" ; then
7558   set dummy objcopy
7559   if test $build = $host ; then
7560     OBJCOPY="$2"
7561   else
7562     OBJCOPY="${ncn_tool_prefix}$2"
7563   fi
7564 fi
7565
7566
7567
7568 if test -n "$OBJDUMP"; then
7569   ac_cv_prog_OBJDUMP=$OBJDUMP
7570 elif test -n "$ac_cv_prog_OBJDUMP"; then
7571   OBJDUMP=$ac_cv_prog_OBJDUMP
7572 fi
7573
7574 if test -n "$ac_cv_prog_OBJDUMP"; then
7575   for ncn_progname in objdump; do
7576     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7577 set dummy ${ncn_progname}; ac_word=$2
7578 echo "$as_me:$LINENO: checking for $ac_word" >&5
7579 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7580 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7581   echo $ECHO_N "(cached) $ECHO_C" >&6
7582 else
7583   if test -n "$OBJDUMP"; then
7584   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7585 else
7586 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7587 for as_dir in $PATH
7588 do
7589   IFS=$as_save_IFS
7590   test -z "$as_dir" && as_dir=.
7591   for ac_exec_ext in '' $ac_executable_extensions; do
7592   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7593     ac_cv_prog_OBJDUMP="${ncn_progname}"
7594     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7595     break 2
7596   fi
7597 done
7598 done
7599
7600 fi
7601 fi
7602 OBJDUMP=$ac_cv_prog_OBJDUMP
7603 if test -n "$OBJDUMP"; then
7604   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7605 echo "${ECHO_T}$OBJDUMP" >&6
7606 else
7607   echo "$as_me:$LINENO: result: no" >&5
7608 echo "${ECHO_T}no" >&6
7609 fi
7610
7611   done
7612 fi
7613
7614 for ncn_progname in objdump; do
7615   if test -n "$ncn_tool_prefix"; then
7616     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7617 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7618 echo "$as_me:$LINENO: checking for $ac_word" >&5
7619 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7620 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7621   echo $ECHO_N "(cached) $ECHO_C" >&6
7622 else
7623   if test -n "$OBJDUMP"; then
7624   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7625 else
7626 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7627 for as_dir in $PATH
7628 do
7629   IFS=$as_save_IFS
7630   test -z "$as_dir" && as_dir=.
7631   for ac_exec_ext in '' $ac_executable_extensions; do
7632   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7633     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7634     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7635     break 2
7636   fi
7637 done
7638 done
7639
7640 fi
7641 fi
7642 OBJDUMP=$ac_cv_prog_OBJDUMP
7643 if test -n "$OBJDUMP"; then
7644   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7645 echo "${ECHO_T}$OBJDUMP" >&6
7646 else
7647   echo "$as_me:$LINENO: result: no" >&5
7648 echo "${ECHO_T}no" >&6
7649 fi
7650
7651   fi
7652   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7653     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7654 set dummy ${ncn_progname}; ac_word=$2
7655 echo "$as_me:$LINENO: checking for $ac_word" >&5
7656 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7657 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7658   echo $ECHO_N "(cached) $ECHO_C" >&6
7659 else
7660   if test -n "$OBJDUMP"; then
7661   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7662 else
7663 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7664 for as_dir in $PATH
7665 do
7666   IFS=$as_save_IFS
7667   test -z "$as_dir" && as_dir=.
7668   for ac_exec_ext in '' $ac_executable_extensions; do
7669   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7670     ac_cv_prog_OBJDUMP="${ncn_progname}"
7671     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7672     break 2
7673   fi
7674 done
7675 done
7676
7677 fi
7678 fi
7679 OBJDUMP=$ac_cv_prog_OBJDUMP
7680 if test -n "$OBJDUMP"; then
7681   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7682 echo "${ECHO_T}$OBJDUMP" >&6
7683 else
7684   echo "$as_me:$LINENO: result: no" >&5
7685 echo "${ECHO_T}no" >&6
7686 fi
7687
7688   fi
7689   test -n "$ac_cv_prog_OBJDUMP" && break
7690 done
7691
7692 if test -z "$ac_cv_prog_OBJDUMP" ; then
7693   set dummy objdump
7694   if test $build = $host ; then
7695     OBJDUMP="$2"
7696   else
7697     OBJDUMP="${ncn_tool_prefix}$2"
7698   fi
7699 fi
7700
7701
7702
7703
7704
7705
7706
7707 # Target tools.
7708
7709 # Check whether --with-build-time-tools or --without-build-time-tools was given.
7710 if test "${with_build_time_tools+set}" = set; then
7711   withval="$with_build_time_tools"
7712   case x"$withval" in
7713      x/*) ;;
7714      *)
7715        with_build_time_tools=
7716        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
7717 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
7718        ;;
7719    esac
7720 else
7721   with_build_time_tools=
7722 fi;
7723
7724
7725
7726 if test -n "$CC_FOR_TARGET"; then
7727   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
7728 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7729   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7730 fi
7731
7732 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7733   for ncn_progname in cc gcc; do
7734     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7735 set dummy ${ncn_progname}; ac_word=$2
7736 echo "$as_me:$LINENO: checking for $ac_word" >&5
7737 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7738 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7739   echo $ECHO_N "(cached) $ECHO_C" >&6
7740 else
7741   if test -n "$CC_FOR_TARGET"; then
7742   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7743 else
7744 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7745 for as_dir in $PATH
7746 do
7747   IFS=$as_save_IFS
7748   test -z "$as_dir" && as_dir=.
7749   for ac_exec_ext in '' $ac_executable_extensions; do
7750   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7751     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7752     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7753     break 2
7754   fi
7755 done
7756 done
7757
7758 fi
7759 fi
7760 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7761 if test -n "$CC_FOR_TARGET"; then
7762   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7763 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7764 else
7765   echo "$as_me:$LINENO: result: no" >&5
7766 echo "${ECHO_T}no" >&6
7767 fi
7768
7769   done
7770 fi
7771
7772 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
7773   for ncn_progname in cc gcc; do
7774     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
7775 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
7776     if test -x $with_build_time_tools/${ncn_progname}; then
7777       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
7778       echo "$as_me:$LINENO: result: yes" >&5
7779 echo "${ECHO_T}yes" >&6
7780       break
7781     else
7782       echo "$as_me:$LINENO: result: no" >&5
7783 echo "${ECHO_T}no" >&6
7784     fi
7785   done
7786 fi
7787
7788 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
7789   for ncn_progname in cc gcc; do
7790     if test -n "$ncn_target_tool_prefix"; then
7791       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
7792 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
7793 echo "$as_me:$LINENO: checking for $ac_word" >&5
7794 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7795 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7796   echo $ECHO_N "(cached) $ECHO_C" >&6
7797 else
7798   if test -n "$CC_FOR_TARGET"; then
7799   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7800 else
7801 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7802 for as_dir in $PATH
7803 do
7804   IFS=$as_save_IFS
7805   test -z "$as_dir" && as_dir=.
7806   for ac_exec_ext in '' $ac_executable_extensions; do
7807   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7808     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
7809     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7810     break 2
7811   fi
7812 done
7813 done
7814
7815 fi
7816 fi
7817 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7818 if test -n "$CC_FOR_TARGET"; then
7819   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7820 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7821 else
7822   echo "$as_me:$LINENO: result: no" >&5
7823 echo "${ECHO_T}no" >&6
7824 fi
7825
7826     fi
7827     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
7828       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7829 set dummy ${ncn_progname}; ac_word=$2
7830 echo "$as_me:$LINENO: checking for $ac_word" >&5
7831 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7832 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7833   echo $ECHO_N "(cached) $ECHO_C" >&6
7834 else
7835   if test -n "$CC_FOR_TARGET"; then
7836   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7837 else
7838 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7839 for as_dir in $PATH
7840 do
7841   IFS=$as_save_IFS
7842   test -z "$as_dir" && as_dir=.
7843   for ac_exec_ext in '' $ac_executable_extensions; do
7844   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7845     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7846     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7847     break 2
7848   fi
7849 done
7850 done
7851
7852 fi
7853 fi
7854 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7855 if test -n "$CC_FOR_TARGET"; then
7856   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7857 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7858 else
7859   echo "$as_me:$LINENO: result: no" >&5
7860 echo "${ECHO_T}no" >&6
7861 fi
7862
7863     fi
7864     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
7865   done
7866 fi
7867
7868 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
7869   set dummy cc gcc
7870   if test $build = $target ; then
7871     CC_FOR_TARGET="$2"
7872   else
7873     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
7874   fi
7875 fi
7876
7877
7878
7879 if test -n "$CXX_FOR_TARGET"; then
7880   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
7881 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
7882   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
7883 fi
7884
7885 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
7886   for ncn_progname in c++ g++ cxx gxx; do
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_CXX_FOR_TARGET+set}" = set; then
7892   echo $ECHO_N "(cached) $ECHO_C" >&6
7893 else
7894   if test -n "$CXX_FOR_TARGET"; then
7895   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # 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_CXX_FOR_TARGET="${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 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
7914 if test -n "$CXX_FOR_TARGET"; then
7915   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
7916 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
7917 else
7918   echo "$as_me:$LINENO: result: no" >&5
7919 echo "${ECHO_T}no" >&6
7920 fi
7921
7922   done
7923 fi
7924
7925 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
7926   for ncn_progname in c++ g++ cxx gxx; do
7927     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
7928 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
7929     if test -x $with_build_time_tools/${ncn_progname}; then
7930       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
7931       echo "$as_me:$LINENO: result: yes" >&5
7932 echo "${ECHO_T}yes" >&6
7933       break
7934     else
7935       echo "$as_me:$LINENO: result: no" >&5
7936 echo "${ECHO_T}no" >&6
7937     fi
7938   done
7939 fi
7940
7941 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
7942   for ncn_progname in c++ g++ cxx gxx; do
7943     if test -n "$ncn_target_tool_prefix"; then
7944       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
7945 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
7946 echo "$as_me:$LINENO: checking for $ac_word" >&5
7947 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7948 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
7949   echo $ECHO_N "(cached) $ECHO_C" >&6
7950 else
7951   if test -n "$CXX_FOR_TARGET"; then
7952   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
7953 else
7954 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7955 for as_dir in $PATH
7956 do
7957   IFS=$as_save_IFS
7958   test -z "$as_dir" && as_dir=.
7959   for ac_exec_ext in '' $ac_executable_extensions; do
7960   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7961     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
7962     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7963     break 2
7964   fi
7965 done
7966 done
7967
7968 fi
7969 fi
7970 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
7971 if test -n "$CXX_FOR_TARGET"; then
7972   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
7973 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
7974 else
7975   echo "$as_me:$LINENO: result: no" >&5
7976 echo "${ECHO_T}no" >&6
7977 fi
7978
7979     fi
7980     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
7981       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7982 set dummy ${ncn_progname}; ac_word=$2
7983 echo "$as_me:$LINENO: checking for $ac_word" >&5
7984 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7985 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
7986   echo $ECHO_N "(cached) $ECHO_C" >&6
7987 else
7988   if test -n "$CXX_FOR_TARGET"; then
7989   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
7990 else
7991 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7992 for as_dir in $PATH
7993 do
7994   IFS=$as_save_IFS
7995   test -z "$as_dir" && as_dir=.
7996   for ac_exec_ext in '' $ac_executable_extensions; do
7997   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7998     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
7999     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8000     break 2
8001   fi
8002 done
8003 done
8004
8005 fi
8006 fi
8007 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8008 if test -n "$CXX_FOR_TARGET"; then
8009   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8010 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8011 else
8012   echo "$as_me:$LINENO: result: no" >&5
8013 echo "${ECHO_T}no" >&6
8014 fi
8015
8016     fi
8017     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8018   done
8019 fi
8020
8021 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8022   set dummy c++ g++ cxx gxx
8023   if test $build = $target ; then
8024     CXX_FOR_TARGET="$2"
8025   else
8026     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8027   fi
8028 fi
8029
8030
8031
8032 if test -n "$GCC_FOR_TARGET"; then
8033   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8034 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8035   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8036 fi
8037
8038 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8039   for ncn_progname in gcc; do
8040     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8041 set dummy ${ncn_progname}; ac_word=$2
8042 echo "$as_me:$LINENO: checking for $ac_word" >&5
8043 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8044 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8045   echo $ECHO_N "(cached) $ECHO_C" >&6
8046 else
8047   if test -n "$GCC_FOR_TARGET"; then
8048   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8049 else
8050 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8051 for as_dir in $PATH
8052 do
8053   IFS=$as_save_IFS
8054   test -z "$as_dir" && as_dir=.
8055   for ac_exec_ext in '' $ac_executable_extensions; do
8056   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8057     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8058     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8059     break 2
8060   fi
8061 done
8062 done
8063
8064 fi
8065 fi
8066 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8067 if test -n "$GCC_FOR_TARGET"; then
8068   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8069 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8070 else
8071   echo "$as_me:$LINENO: result: no" >&5
8072 echo "${ECHO_T}no" >&6
8073 fi
8074
8075   done
8076 fi
8077
8078 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8079   for ncn_progname in gcc; do
8080     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8081 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8082     if test -x $with_build_time_tools/${ncn_progname}; then
8083       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8084       echo "$as_me:$LINENO: result: yes" >&5
8085 echo "${ECHO_T}yes" >&6
8086       break
8087     else
8088       echo "$as_me:$LINENO: result: no" >&5
8089 echo "${ECHO_T}no" >&6
8090     fi
8091   done
8092 fi
8093
8094 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8095   for ncn_progname in gcc; do
8096     if test -n "$ncn_target_tool_prefix"; then
8097       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8098 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8099 echo "$as_me:$LINENO: checking for $ac_word" >&5
8100 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8101 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8102   echo $ECHO_N "(cached) $ECHO_C" >&6
8103 else
8104   if test -n "$GCC_FOR_TARGET"; then
8105   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8106 else
8107 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8108 for as_dir in $PATH
8109 do
8110   IFS=$as_save_IFS
8111   test -z "$as_dir" && as_dir=.
8112   for ac_exec_ext in '' $ac_executable_extensions; do
8113   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8114     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8115     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8116     break 2
8117   fi
8118 done
8119 done
8120
8121 fi
8122 fi
8123 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8124 if test -n "$GCC_FOR_TARGET"; then
8125   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8126 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8127 else
8128   echo "$as_me:$LINENO: result: no" >&5
8129 echo "${ECHO_T}no" >&6
8130 fi
8131
8132     fi
8133     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8134       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8135 set dummy ${ncn_progname}; ac_word=$2
8136 echo "$as_me:$LINENO: checking for $ac_word" >&5
8137 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8138 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8139   echo $ECHO_N "(cached) $ECHO_C" >&6
8140 else
8141   if test -n "$GCC_FOR_TARGET"; then
8142   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8143 else
8144 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8145 for as_dir in $PATH
8146 do
8147   IFS=$as_save_IFS
8148   test -z "$as_dir" && as_dir=.
8149   for ac_exec_ext in '' $ac_executable_extensions; do
8150   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8151     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8152     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8153     break 2
8154   fi
8155 done
8156 done
8157
8158 fi
8159 fi
8160 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8161 if test -n "$GCC_FOR_TARGET"; then
8162   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8163 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8164 else
8165   echo "$as_me:$LINENO: result: no" >&5
8166 echo "${ECHO_T}no" >&6
8167 fi
8168
8169     fi
8170     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8171   done
8172 fi
8173
8174 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8175   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8176 fi
8177
8178
8179
8180 if test -n "$GCJ_FOR_TARGET"; then
8181   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8182 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8183   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8184 fi
8185
8186 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8187   for ncn_progname in gcj; do
8188     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8189 set dummy ${ncn_progname}; ac_word=$2
8190 echo "$as_me:$LINENO: checking for $ac_word" >&5
8191 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8192 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8193   echo $ECHO_N "(cached) $ECHO_C" >&6
8194 else
8195   if test -n "$GCJ_FOR_TARGET"; then
8196   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8197 else
8198 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8199 for as_dir in $PATH
8200 do
8201   IFS=$as_save_IFS
8202   test -z "$as_dir" && as_dir=.
8203   for ac_exec_ext in '' $ac_executable_extensions; do
8204   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8205     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8206     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8207     break 2
8208   fi
8209 done
8210 done
8211
8212 fi
8213 fi
8214 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8215 if test -n "$GCJ_FOR_TARGET"; then
8216   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8217 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8218 else
8219   echo "$as_me:$LINENO: result: no" >&5
8220 echo "${ECHO_T}no" >&6
8221 fi
8222
8223   done
8224 fi
8225
8226 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8227   for ncn_progname in gcj; do
8228     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8229 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8230     if test -x $with_build_time_tools/${ncn_progname}; then
8231       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8232       echo "$as_me:$LINENO: result: yes" >&5
8233 echo "${ECHO_T}yes" >&6
8234       break
8235     else
8236       echo "$as_me:$LINENO: result: no" >&5
8237 echo "${ECHO_T}no" >&6
8238     fi
8239   done
8240 fi
8241
8242 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8243   for ncn_progname in gcj; do
8244     if test -n "$ncn_target_tool_prefix"; then
8245       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8246 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8247 echo "$as_me:$LINENO: checking for $ac_word" >&5
8248 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8249 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8250   echo $ECHO_N "(cached) $ECHO_C" >&6
8251 else
8252   if test -n "$GCJ_FOR_TARGET"; then
8253   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8254 else
8255 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8256 for as_dir in $PATH
8257 do
8258   IFS=$as_save_IFS
8259   test -z "$as_dir" && as_dir=.
8260   for ac_exec_ext in '' $ac_executable_extensions; do
8261   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8262     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8263     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8264     break 2
8265   fi
8266 done
8267 done
8268
8269 fi
8270 fi
8271 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8272 if test -n "$GCJ_FOR_TARGET"; then
8273   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8274 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8275 else
8276   echo "$as_me:$LINENO: result: no" >&5
8277 echo "${ECHO_T}no" >&6
8278 fi
8279
8280     fi
8281     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8282       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8283 set dummy ${ncn_progname}; ac_word=$2
8284 echo "$as_me:$LINENO: checking for $ac_word" >&5
8285 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8286 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8287   echo $ECHO_N "(cached) $ECHO_C" >&6
8288 else
8289   if test -n "$GCJ_FOR_TARGET"; then
8290   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8291 else
8292 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8293 for as_dir in $PATH
8294 do
8295   IFS=$as_save_IFS
8296   test -z "$as_dir" && as_dir=.
8297   for ac_exec_ext in '' $ac_executable_extensions; do
8298   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8299     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8300     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8301     break 2
8302   fi
8303 done
8304 done
8305
8306 fi
8307 fi
8308 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8309 if test -n "$GCJ_FOR_TARGET"; then
8310   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8311 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8312 else
8313   echo "$as_me:$LINENO: result: no" >&5
8314 echo "${ECHO_T}no" >&6
8315 fi
8316
8317     fi
8318     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8319   done
8320 fi
8321
8322 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8323   set dummy gcj
8324   if test $build = $target ; then
8325     GCJ_FOR_TARGET="$2"
8326   else
8327     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8328   fi
8329 fi
8330
8331
8332
8333 if test -n "$GFORTRAN_FOR_TARGET"; then
8334   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8335 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8336   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8337 fi
8338
8339 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8340   for ncn_progname in gfortran; do
8341     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8342 set dummy ${ncn_progname}; ac_word=$2
8343 echo "$as_me:$LINENO: checking for $ac_word" >&5
8344 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8345 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8346   echo $ECHO_N "(cached) $ECHO_C" >&6
8347 else
8348   if test -n "$GFORTRAN_FOR_TARGET"; then
8349   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8350 else
8351 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8352 for as_dir in $PATH
8353 do
8354   IFS=$as_save_IFS
8355   test -z "$as_dir" && as_dir=.
8356   for ac_exec_ext in '' $ac_executable_extensions; do
8357   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8358     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8359     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8360     break 2
8361   fi
8362 done
8363 done
8364
8365 fi
8366 fi
8367 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8368 if test -n "$GFORTRAN_FOR_TARGET"; then
8369   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8370 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8371 else
8372   echo "$as_me:$LINENO: result: no" >&5
8373 echo "${ECHO_T}no" >&6
8374 fi
8375
8376   done
8377 fi
8378
8379 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8380   for ncn_progname in gfortran; do
8381     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8382 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8383     if test -x $with_build_time_tools/${ncn_progname}; then
8384       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8385       echo "$as_me:$LINENO: result: yes" >&5
8386 echo "${ECHO_T}yes" >&6
8387       break
8388     else
8389       echo "$as_me:$LINENO: result: no" >&5
8390 echo "${ECHO_T}no" >&6
8391     fi
8392   done
8393 fi
8394
8395 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8396   for ncn_progname in gfortran; do
8397     if test -n "$ncn_target_tool_prefix"; then
8398       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8399 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8400 echo "$as_me:$LINENO: checking for $ac_word" >&5
8401 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8402 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8403   echo $ECHO_N "(cached) $ECHO_C" >&6
8404 else
8405   if test -n "$GFORTRAN_FOR_TARGET"; then
8406   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8407 else
8408 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8409 for as_dir in $PATH
8410 do
8411   IFS=$as_save_IFS
8412   test -z "$as_dir" && as_dir=.
8413   for ac_exec_ext in '' $ac_executable_extensions; do
8414   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8415     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8416     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8417     break 2
8418   fi
8419 done
8420 done
8421
8422 fi
8423 fi
8424 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8425 if test -n "$GFORTRAN_FOR_TARGET"; then
8426   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8427 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8428 else
8429   echo "$as_me:$LINENO: result: no" >&5
8430 echo "${ECHO_T}no" >&6
8431 fi
8432
8433     fi
8434     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8435       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8436 set dummy ${ncn_progname}; ac_word=$2
8437 echo "$as_me:$LINENO: checking for $ac_word" >&5
8438 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8439 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8440   echo $ECHO_N "(cached) $ECHO_C" >&6
8441 else
8442   if test -n "$GFORTRAN_FOR_TARGET"; then
8443   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8444 else
8445 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8446 for as_dir in $PATH
8447 do
8448   IFS=$as_save_IFS
8449   test -z "$as_dir" && as_dir=.
8450   for ac_exec_ext in '' $ac_executable_extensions; do
8451   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8452     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8453     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8454     break 2
8455   fi
8456 done
8457 done
8458
8459 fi
8460 fi
8461 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8462 if test -n "$GFORTRAN_FOR_TARGET"; then
8463   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8464 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8465 else
8466   echo "$as_me:$LINENO: result: no" >&5
8467 echo "${ECHO_T}no" >&6
8468 fi
8469
8470     fi
8471     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8472   done
8473 fi
8474
8475 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8476   set dummy gfortran
8477   if test $build = $target ; then
8478     GFORTRAN_FOR_TARGET="$2"
8479   else
8480     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8481   fi
8482 fi
8483
8484
8485
8486 cat > conftest.c << \EOF
8487 #ifdef __GNUC__
8488   gcc_yay;
8489 #endif
8490 EOF
8491 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8492   have_gcc_for_target=yes
8493 else
8494   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8495   have_gcc_for_target=no
8496 fi
8497 rm conftest.c
8498
8499
8500
8501
8502 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8503   if test -n "$with_build_time_tools"; then
8504     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8505 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8506     if test -x $with_build_time_tools/ar; then
8507       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8508       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8509       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8510 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8511     else
8512       echo "$as_me:$LINENO: result: no" >&5
8513 echo "${ECHO_T}no" >&6
8514     fi
8515   elif test $build != $host && test $have_gcc_for_target = yes; then
8516     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8517     test $AR_FOR_TARGET=ar && AR_FOR_TARGET=
8518     ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8519   fi
8520 fi
8521 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8522   # Extract the first word of "ar", so it can be a program name with args.
8523 set dummy ar; ac_word=$2
8524 echo "$as_me:$LINENO: checking for $ac_word" >&5
8525 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8526 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8527   echo $ECHO_N "(cached) $ECHO_C" >&6
8528 else
8529   case $AR_FOR_TARGET in
8530   [\\/]* | ?:[\\/]*)
8531   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8532   ;;
8533   *)
8534   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8535 for as_dir in $gcc_cv_tool_dirs
8536 do
8537   IFS=$as_save_IFS
8538   test -z "$as_dir" && as_dir=.
8539   for ac_exec_ext in '' $ac_executable_extensions; do
8540   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8541     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8542     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8543     break 2
8544   fi
8545 done
8546 done
8547
8548   ;;
8549 esac
8550 fi
8551 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8552
8553 if test -n "$AR_FOR_TARGET"; then
8554   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8555 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8556 else
8557   echo "$as_me:$LINENO: result: no" >&5
8558 echo "${ECHO_T}no" >&6
8559 fi
8560
8561 fi
8562 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8563
8564
8565 if test -n "$AR_FOR_TARGET"; then
8566   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8567 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8568   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8569 fi
8570
8571 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8572   for ncn_progname in ar; do
8573     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8574 set dummy ${ncn_progname}; ac_word=$2
8575 echo "$as_me:$LINENO: checking for $ac_word" >&5
8576 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8577 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8578   echo $ECHO_N "(cached) $ECHO_C" >&6
8579 else
8580   if test -n "$AR_FOR_TARGET"; then
8581   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8582 else
8583 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8584 for as_dir in $PATH
8585 do
8586   IFS=$as_save_IFS
8587   test -z "$as_dir" && as_dir=.
8588   for ac_exec_ext in '' $ac_executable_extensions; do
8589   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8590     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8591     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8592     break 2
8593   fi
8594 done
8595 done
8596
8597 fi
8598 fi
8599 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8600 if test -n "$AR_FOR_TARGET"; then
8601   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8602 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8603 else
8604   echo "$as_me:$LINENO: result: no" >&5
8605 echo "${ECHO_T}no" >&6
8606 fi
8607
8608   done
8609 fi
8610
8611 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8612   for ncn_progname in ar; do
8613     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8614 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8615     if test -x $with_build_time_tools/${ncn_progname}; then
8616       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8617       echo "$as_me:$LINENO: result: yes" >&5
8618 echo "${ECHO_T}yes" >&6
8619       break
8620     else
8621       echo "$as_me:$LINENO: result: no" >&5
8622 echo "${ECHO_T}no" >&6
8623     fi
8624   done
8625 fi
8626
8627 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8628   for ncn_progname in ar; do
8629     if test -n "$ncn_target_tool_prefix"; then
8630       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8631 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8632 echo "$as_me:$LINENO: checking for $ac_word" >&5
8633 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8634 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8635   echo $ECHO_N "(cached) $ECHO_C" >&6
8636 else
8637   if test -n "$AR_FOR_TARGET"; then
8638   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8639 else
8640 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8641 for as_dir in $PATH
8642 do
8643   IFS=$as_save_IFS
8644   test -z "$as_dir" && as_dir=.
8645   for ac_exec_ext in '' $ac_executable_extensions; do
8646   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8647     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8648     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8649     break 2
8650   fi
8651 done
8652 done
8653
8654 fi
8655 fi
8656 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8657 if test -n "$AR_FOR_TARGET"; then
8658   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8659 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8660 else
8661   echo "$as_me:$LINENO: result: no" >&5
8662 echo "${ECHO_T}no" >&6
8663 fi
8664
8665     fi
8666     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
8667       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8668 set dummy ${ncn_progname}; ac_word=$2
8669 echo "$as_me:$LINENO: checking for $ac_word" >&5
8670 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8671 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8672   echo $ECHO_N "(cached) $ECHO_C" >&6
8673 else
8674   if test -n "$AR_FOR_TARGET"; then
8675   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8676 else
8677 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8678 for as_dir in $PATH
8679 do
8680   IFS=$as_save_IFS
8681   test -z "$as_dir" && as_dir=.
8682   for ac_exec_ext in '' $ac_executable_extensions; do
8683   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8684     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8685     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8686     break 2
8687   fi
8688 done
8689 done
8690
8691 fi
8692 fi
8693 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8694 if test -n "$AR_FOR_TARGET"; then
8695   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8696 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8697 else
8698   echo "$as_me:$LINENO: result: no" >&5
8699 echo "${ECHO_T}no" >&6
8700 fi
8701
8702     fi
8703     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
8704   done
8705 fi
8706
8707 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
8708   set dummy ar
8709   if test $build = $target ; then
8710     AR_FOR_TARGET="$2"
8711   else
8712     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
8713   fi
8714 fi
8715
8716 else
8717   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8718 fi
8719
8720
8721
8722
8723 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8724   if test -n "$with_build_time_tools"; then
8725     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
8726 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
8727     if test -x $with_build_time_tools/as; then
8728       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
8729       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8730       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
8731 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
8732     else
8733       echo "$as_me:$LINENO: result: no" >&5
8734 echo "${ECHO_T}no" >&6
8735     fi
8736   elif test $build != $host && test $have_gcc_for_target = yes; then
8737     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
8738     test $AS_FOR_TARGET=as && AS_FOR_TARGET=
8739     ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8740   fi
8741 fi
8742 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8743   # Extract the first word of "as", so it can be a program name with args.
8744 set dummy as; ac_word=$2
8745 echo "$as_me:$LINENO: checking for $ac_word" >&5
8746 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8747 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
8748   echo $ECHO_N "(cached) $ECHO_C" >&6
8749 else
8750   case $AS_FOR_TARGET in
8751   [\\/]* | ?:[\\/]*)
8752   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
8753   ;;
8754   *)
8755   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8756 for as_dir in $gcc_cv_tool_dirs
8757 do
8758   IFS=$as_save_IFS
8759   test -z "$as_dir" && as_dir=.
8760   for ac_exec_ext in '' $ac_executable_extensions; do
8761   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8762     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8763     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8764     break 2
8765   fi
8766 done
8767 done
8768
8769   ;;
8770 esac
8771 fi
8772 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
8773
8774 if test -n "$AS_FOR_TARGET"; then
8775   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8776 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8777 else
8778   echo "$as_me:$LINENO: result: no" >&5
8779 echo "${ECHO_T}no" >&6
8780 fi
8781
8782 fi
8783 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8784
8785
8786 if test -n "$AS_FOR_TARGET"; then
8787   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
8788 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
8789   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8790 fi
8791
8792 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
8793   for ncn_progname in as; do
8794     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8795 set dummy ${ncn_progname}; ac_word=$2
8796 echo "$as_me:$LINENO: checking for $ac_word" >&5
8797 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8798 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8799   echo $ECHO_N "(cached) $ECHO_C" >&6
8800 else
8801   if test -n "$AS_FOR_TARGET"; then
8802   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8803 else
8804 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8805 for as_dir in $PATH
8806 do
8807   IFS=$as_save_IFS
8808   test -z "$as_dir" && as_dir=.
8809   for ac_exec_ext in '' $ac_executable_extensions; do
8810   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8811     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
8812     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8813     break 2
8814   fi
8815 done
8816 done
8817
8818 fi
8819 fi
8820 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8821 if test -n "$AS_FOR_TARGET"; then
8822   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8823 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8824 else
8825   echo "$as_me:$LINENO: result: no" >&5
8826 echo "${ECHO_T}no" >&6
8827 fi
8828
8829   done
8830 fi
8831
8832 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
8833   for ncn_progname in as; do
8834     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8835 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8836     if test -x $with_build_time_tools/${ncn_progname}; then
8837       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8838       echo "$as_me:$LINENO: result: yes" >&5
8839 echo "${ECHO_T}yes" >&6
8840       break
8841     else
8842       echo "$as_me:$LINENO: result: no" >&5
8843 echo "${ECHO_T}no" >&6
8844     fi
8845   done
8846 fi
8847
8848 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
8849   for ncn_progname in as; do
8850     if test -n "$ncn_target_tool_prefix"; then
8851       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8852 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8853 echo "$as_me:$LINENO: checking for $ac_word" >&5
8854 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8855 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8856   echo $ECHO_N "(cached) $ECHO_C" >&6
8857 else
8858   if test -n "$AS_FOR_TARGET"; then
8859   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8860 else
8861 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8862 for as_dir in $PATH
8863 do
8864   IFS=$as_save_IFS
8865   test -z "$as_dir" && as_dir=.
8866   for ac_exec_ext in '' $ac_executable_extensions; do
8867   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8868     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8869     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8870     break 2
8871   fi
8872 done
8873 done
8874
8875 fi
8876 fi
8877 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8878 if test -n "$AS_FOR_TARGET"; then
8879   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8880 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8881 else
8882   echo "$as_me:$LINENO: result: no" >&5
8883 echo "${ECHO_T}no" >&6
8884 fi
8885
8886     fi
8887     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
8888       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8889 set dummy ${ncn_progname}; ac_word=$2
8890 echo "$as_me:$LINENO: checking for $ac_word" >&5
8891 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8892 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8893   echo $ECHO_N "(cached) $ECHO_C" >&6
8894 else
8895   if test -n "$AS_FOR_TARGET"; then
8896   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8897 else
8898 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8899 for as_dir in $PATH
8900 do
8901   IFS=$as_save_IFS
8902   test -z "$as_dir" && as_dir=.
8903   for ac_exec_ext in '' $ac_executable_extensions; do
8904   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8905     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
8906     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8907     break 2
8908   fi
8909 done
8910 done
8911
8912 fi
8913 fi
8914 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8915 if test -n "$AS_FOR_TARGET"; then
8916   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8917 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8918 else
8919   echo "$as_me:$LINENO: result: no" >&5
8920 echo "${ECHO_T}no" >&6
8921 fi
8922
8923     fi
8924     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
8925   done
8926 fi
8927
8928 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
8929   set dummy as
8930   if test $build = $target ; then
8931     AS_FOR_TARGET="$2"
8932   else
8933     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
8934   fi
8935 fi
8936
8937 else
8938   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
8939 fi
8940
8941
8942
8943
8944 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
8945   if test -n "$with_build_time_tools"; then
8946     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
8947 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
8948     if test -x $with_build_time_tools/dlltool; then
8949       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
8950       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
8951       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
8952 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
8953     else
8954       echo "$as_me:$LINENO: result: no" >&5
8955 echo "${ECHO_T}no" >&6
8956     fi
8957   elif test $build != $host && test $have_gcc_for_target = yes; then
8958     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
8959     test $DLLTOOL_FOR_TARGET=dlltool && DLLTOOL_FOR_TARGET=
8960     ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
8961   fi
8962 fi
8963 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8964   # Extract the first word of "dlltool", so it can be a program name with args.
8965 set dummy dlltool; ac_word=$2
8966 echo "$as_me:$LINENO: checking for $ac_word" >&5
8967 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8968 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
8969   echo $ECHO_N "(cached) $ECHO_C" >&6
8970 else
8971   case $DLLTOOL_FOR_TARGET in
8972   [\\/]* | ?:[\\/]*)
8973   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
8974   ;;
8975   *)
8976   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8977 for as_dir in $gcc_cv_tool_dirs
8978 do
8979   IFS=$as_save_IFS
8980   test -z "$as_dir" && as_dir=.
8981   for ac_exec_ext in '' $ac_executable_extensions; do
8982   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8983     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8984     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8985     break 2
8986   fi
8987 done
8988 done
8989
8990   ;;
8991 esac
8992 fi
8993 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
8994
8995 if test -n "$DLLTOOL_FOR_TARGET"; then
8996   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
8997 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
8998 else
8999   echo "$as_me:$LINENO: result: no" >&5
9000 echo "${ECHO_T}no" >&6
9001 fi
9002
9003 fi
9004 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9005
9006
9007 if test -n "$DLLTOOL_FOR_TARGET"; then
9008   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9009 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9010   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9011 fi
9012
9013 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9014   for ncn_progname in dlltool; do
9015     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9016 set dummy ${ncn_progname}; ac_word=$2
9017 echo "$as_me:$LINENO: checking for $ac_word" >&5
9018 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9019 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9020   echo $ECHO_N "(cached) $ECHO_C" >&6
9021 else
9022   if test -n "$DLLTOOL_FOR_TARGET"; then
9023   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9024 else
9025 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9026 for as_dir in $PATH
9027 do
9028   IFS=$as_save_IFS
9029   test -z "$as_dir" && as_dir=.
9030   for ac_exec_ext in '' $ac_executable_extensions; do
9031   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9032     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9033     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9034     break 2
9035   fi
9036 done
9037 done
9038
9039 fi
9040 fi
9041 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9042 if test -n "$DLLTOOL_FOR_TARGET"; then
9043   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9044 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9045 else
9046   echo "$as_me:$LINENO: result: no" >&5
9047 echo "${ECHO_T}no" >&6
9048 fi
9049
9050   done
9051 fi
9052
9053 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9054   for ncn_progname in dlltool; do
9055     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9056 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9057     if test -x $with_build_time_tools/${ncn_progname}; then
9058       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9059       echo "$as_me:$LINENO: result: yes" >&5
9060 echo "${ECHO_T}yes" >&6
9061       break
9062     else
9063       echo "$as_me:$LINENO: result: no" >&5
9064 echo "${ECHO_T}no" >&6
9065     fi
9066   done
9067 fi
9068
9069 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9070   for ncn_progname in dlltool; do
9071     if test -n "$ncn_target_tool_prefix"; then
9072       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9073 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9074 echo "$as_me:$LINENO: checking for $ac_word" >&5
9075 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9076 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9077   echo $ECHO_N "(cached) $ECHO_C" >&6
9078 else
9079   if test -n "$DLLTOOL_FOR_TARGET"; then
9080   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9081 else
9082 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9083 for as_dir in $PATH
9084 do
9085   IFS=$as_save_IFS
9086   test -z "$as_dir" && as_dir=.
9087   for ac_exec_ext in '' $ac_executable_extensions; do
9088   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9089     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9090     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9091     break 2
9092   fi
9093 done
9094 done
9095
9096 fi
9097 fi
9098 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9099 if test -n "$DLLTOOL_FOR_TARGET"; then
9100   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9101 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9102 else
9103   echo "$as_me:$LINENO: result: no" >&5
9104 echo "${ECHO_T}no" >&6
9105 fi
9106
9107     fi
9108     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9109       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9110 set dummy ${ncn_progname}; ac_word=$2
9111 echo "$as_me:$LINENO: checking for $ac_word" >&5
9112 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9113 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9114   echo $ECHO_N "(cached) $ECHO_C" >&6
9115 else
9116   if test -n "$DLLTOOL_FOR_TARGET"; then
9117   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9118 else
9119 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9120 for as_dir in $PATH
9121 do
9122   IFS=$as_save_IFS
9123   test -z "$as_dir" && as_dir=.
9124   for ac_exec_ext in '' $ac_executable_extensions; do
9125   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9126     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9127     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9128     break 2
9129   fi
9130 done
9131 done
9132
9133 fi
9134 fi
9135 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9136 if test -n "$DLLTOOL_FOR_TARGET"; then
9137   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9138 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9139 else
9140   echo "$as_me:$LINENO: result: no" >&5
9141 echo "${ECHO_T}no" >&6
9142 fi
9143
9144     fi
9145     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9146   done
9147 fi
9148
9149 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9150   set dummy dlltool
9151   if test $build = $target ; then
9152     DLLTOOL_FOR_TARGET="$2"
9153   else
9154     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9155   fi
9156 fi
9157
9158 else
9159   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9160 fi
9161
9162
9163
9164
9165 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9166   if test -n "$with_build_time_tools"; then
9167     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9168 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9169     if test -x $with_build_time_tools/ld; then
9170       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9171       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9172       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9173 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9174     else
9175       echo "$as_me:$LINENO: result: no" >&5
9176 echo "${ECHO_T}no" >&6
9177     fi
9178   elif test $build != $host && test $have_gcc_for_target = yes; then
9179     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9180     test $LD_FOR_TARGET=ld && LD_FOR_TARGET=
9181     ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9182   fi
9183 fi
9184 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9185   # Extract the first word of "ld", so it can be a program name with args.
9186 set dummy ld; ac_word=$2
9187 echo "$as_me:$LINENO: checking for $ac_word" >&5
9188 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9189 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9190   echo $ECHO_N "(cached) $ECHO_C" >&6
9191 else
9192   case $LD_FOR_TARGET in
9193   [\\/]* | ?:[\\/]*)
9194   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9195   ;;
9196   *)
9197   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9198 for as_dir in $gcc_cv_tool_dirs
9199 do
9200   IFS=$as_save_IFS
9201   test -z "$as_dir" && as_dir=.
9202   for ac_exec_ext in '' $ac_executable_extensions; do
9203   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9204     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9205     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9206     break 2
9207   fi
9208 done
9209 done
9210
9211   ;;
9212 esac
9213 fi
9214 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9215
9216 if test -n "$LD_FOR_TARGET"; then
9217   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9218 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9219 else
9220   echo "$as_me:$LINENO: result: no" >&5
9221 echo "${ECHO_T}no" >&6
9222 fi
9223
9224 fi
9225 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9226
9227
9228 if test -n "$LD_FOR_TARGET"; then
9229   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9230 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9231   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9232 fi
9233
9234 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9235   for ncn_progname in ld; do
9236     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9237 set dummy ${ncn_progname}; ac_word=$2
9238 echo "$as_me:$LINENO: checking for $ac_word" >&5
9239 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9240 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9241   echo $ECHO_N "(cached) $ECHO_C" >&6
9242 else
9243   if test -n "$LD_FOR_TARGET"; then
9244   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9245 else
9246 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9247 for as_dir in $PATH
9248 do
9249   IFS=$as_save_IFS
9250   test -z "$as_dir" && as_dir=.
9251   for ac_exec_ext in '' $ac_executable_extensions; do
9252   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9253     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9254     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9255     break 2
9256   fi
9257 done
9258 done
9259
9260 fi
9261 fi
9262 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9263 if test -n "$LD_FOR_TARGET"; then
9264   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9265 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9266 else
9267   echo "$as_me:$LINENO: result: no" >&5
9268 echo "${ECHO_T}no" >&6
9269 fi
9270
9271   done
9272 fi
9273
9274 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9275   for ncn_progname in ld; do
9276     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9277 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9278     if test -x $with_build_time_tools/${ncn_progname}; then
9279       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9280       echo "$as_me:$LINENO: result: yes" >&5
9281 echo "${ECHO_T}yes" >&6
9282       break
9283     else
9284       echo "$as_me:$LINENO: result: no" >&5
9285 echo "${ECHO_T}no" >&6
9286     fi
9287   done
9288 fi
9289
9290 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9291   for ncn_progname in ld; do
9292     if test -n "$ncn_target_tool_prefix"; then
9293       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9294 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9295 echo "$as_me:$LINENO: checking for $ac_word" >&5
9296 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9297 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9298   echo $ECHO_N "(cached) $ECHO_C" >&6
9299 else
9300   if test -n "$LD_FOR_TARGET"; then
9301   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9302 else
9303 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9304 for as_dir in $PATH
9305 do
9306   IFS=$as_save_IFS
9307   test -z "$as_dir" && as_dir=.
9308   for ac_exec_ext in '' $ac_executable_extensions; do
9309   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9310     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9311     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9312     break 2
9313   fi
9314 done
9315 done
9316
9317 fi
9318 fi
9319 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9320 if test -n "$LD_FOR_TARGET"; then
9321   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9322 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9323 else
9324   echo "$as_me:$LINENO: result: no" >&5
9325 echo "${ECHO_T}no" >&6
9326 fi
9327
9328     fi
9329     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9330       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9331 set dummy ${ncn_progname}; ac_word=$2
9332 echo "$as_me:$LINENO: checking for $ac_word" >&5
9333 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9334 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9335   echo $ECHO_N "(cached) $ECHO_C" >&6
9336 else
9337   if test -n "$LD_FOR_TARGET"; then
9338   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9339 else
9340 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9341 for as_dir in $PATH
9342 do
9343   IFS=$as_save_IFS
9344   test -z "$as_dir" && as_dir=.
9345   for ac_exec_ext in '' $ac_executable_extensions; do
9346   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9347     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9348     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9349     break 2
9350   fi
9351 done
9352 done
9353
9354 fi
9355 fi
9356 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9357 if test -n "$LD_FOR_TARGET"; then
9358   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9359 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9360 else
9361   echo "$as_me:$LINENO: result: no" >&5
9362 echo "${ECHO_T}no" >&6
9363 fi
9364
9365     fi
9366     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9367   done
9368 fi
9369
9370 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9371   set dummy ld
9372   if test $build = $target ; then
9373     LD_FOR_TARGET="$2"
9374   else
9375     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9376   fi
9377 fi
9378
9379 else
9380   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9381 fi
9382
9383
9384
9385
9386 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9387   if test -n "$with_build_time_tools"; then
9388     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9389 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9390     if test -x $with_build_time_tools/lipo; then
9391       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9392       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9393       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9394 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9395     else
9396       echo "$as_me:$LINENO: result: no" >&5
9397 echo "${ECHO_T}no" >&6
9398     fi
9399   elif test $build != $host && test $have_gcc_for_target = yes; then
9400     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9401     test $LIPO_FOR_TARGET=lipo && LIPO_FOR_TARGET=
9402     ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9403   fi
9404 fi
9405 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9406   # Extract the first word of "lipo", so it can be a program name with args.
9407 set dummy lipo; ac_word=$2
9408 echo "$as_me:$LINENO: checking for $ac_word" >&5
9409 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9410 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9411   echo $ECHO_N "(cached) $ECHO_C" >&6
9412 else
9413   case $LIPO_FOR_TARGET in
9414   [\\/]* | ?:[\\/]*)
9415   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9416   ;;
9417   *)
9418   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9419 for as_dir in $gcc_cv_tool_dirs
9420 do
9421   IFS=$as_save_IFS
9422   test -z "$as_dir" && as_dir=.
9423   for ac_exec_ext in '' $ac_executable_extensions; do
9424   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9425     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9426     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9427     break 2
9428   fi
9429 done
9430 done
9431
9432   ;;
9433 esac
9434 fi
9435 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9436
9437 if test -n "$LIPO_FOR_TARGET"; then
9438   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9439 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9440 else
9441   echo "$as_me:$LINENO: result: no" >&5
9442 echo "${ECHO_T}no" >&6
9443 fi
9444
9445 fi
9446 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9447
9448
9449 if test -n "$LIPO_FOR_TARGET"; then
9450   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9451 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9452   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9453 fi
9454
9455 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9456   for ncn_progname in lipo; do
9457     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9458 set dummy ${ncn_progname}; ac_word=$2
9459 echo "$as_me:$LINENO: checking for $ac_word" >&5
9460 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9461 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9462   echo $ECHO_N "(cached) $ECHO_C" >&6
9463 else
9464   if test -n "$LIPO_FOR_TARGET"; then
9465   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9466 else
9467 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9468 for as_dir in $PATH
9469 do
9470   IFS=$as_save_IFS
9471   test -z "$as_dir" && as_dir=.
9472   for ac_exec_ext in '' $ac_executable_extensions; do
9473   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9474     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9475     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9476     break 2
9477   fi
9478 done
9479 done
9480
9481 fi
9482 fi
9483 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9484 if test -n "$LIPO_FOR_TARGET"; then
9485   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9486 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9487 else
9488   echo "$as_me:$LINENO: result: no" >&5
9489 echo "${ECHO_T}no" >&6
9490 fi
9491
9492   done
9493 fi
9494
9495 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9496   for ncn_progname in lipo; do
9497     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9498 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9499     if test -x $with_build_time_tools/${ncn_progname}; then
9500       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9501       echo "$as_me:$LINENO: result: yes" >&5
9502 echo "${ECHO_T}yes" >&6
9503       break
9504     else
9505       echo "$as_me:$LINENO: result: no" >&5
9506 echo "${ECHO_T}no" >&6
9507     fi
9508   done
9509 fi
9510
9511 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9512   for ncn_progname in lipo; do
9513     if test -n "$ncn_target_tool_prefix"; then
9514       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9515 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9516 echo "$as_me:$LINENO: checking for $ac_word" >&5
9517 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9518 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9519   echo $ECHO_N "(cached) $ECHO_C" >&6
9520 else
9521   if test -n "$LIPO_FOR_TARGET"; then
9522   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9523 else
9524 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9525 for as_dir in $PATH
9526 do
9527   IFS=$as_save_IFS
9528   test -z "$as_dir" && as_dir=.
9529   for ac_exec_ext in '' $ac_executable_extensions; do
9530   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9531     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9532     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9533     break 2
9534   fi
9535 done
9536 done
9537
9538 fi
9539 fi
9540 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9541 if test -n "$LIPO_FOR_TARGET"; then
9542   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9543 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9544 else
9545   echo "$as_me:$LINENO: result: no" >&5
9546 echo "${ECHO_T}no" >&6
9547 fi
9548
9549     fi
9550     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9551       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9552 set dummy ${ncn_progname}; ac_word=$2
9553 echo "$as_me:$LINENO: checking for $ac_word" >&5
9554 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9555 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9556   echo $ECHO_N "(cached) $ECHO_C" >&6
9557 else
9558   if test -n "$LIPO_FOR_TARGET"; then
9559   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9560 else
9561 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9562 for as_dir in $PATH
9563 do
9564   IFS=$as_save_IFS
9565   test -z "$as_dir" && as_dir=.
9566   for ac_exec_ext in '' $ac_executable_extensions; do
9567   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9568     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9569     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9570     break 2
9571   fi
9572 done
9573 done
9574
9575 fi
9576 fi
9577 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9578 if test -n "$LIPO_FOR_TARGET"; then
9579   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9580 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9581 else
9582   echo "$as_me:$LINENO: result: no" >&5
9583 echo "${ECHO_T}no" >&6
9584 fi
9585
9586     fi
9587     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9588   done
9589 fi
9590
9591 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9592   set dummy lipo
9593   if test $build = $target ; then
9594     LIPO_FOR_TARGET="$2"
9595   else
9596     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9597   fi
9598 fi
9599
9600 else
9601   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9602 fi
9603
9604
9605
9606
9607 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9608   if test -n "$with_build_time_tools"; then
9609     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9610 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9611     if test -x $with_build_time_tools/nm; then
9612       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9613       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9614       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9615 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9616     else
9617       echo "$as_me:$LINENO: result: no" >&5
9618 echo "${ECHO_T}no" >&6
9619     fi
9620   elif test $build != $host && test $have_gcc_for_target = yes; then
9621     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9622     test $NM_FOR_TARGET=nm && NM_FOR_TARGET=
9623     ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9624   fi
9625 fi
9626 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9627   # Extract the first word of "nm", so it can be a program name with args.
9628 set dummy nm; ac_word=$2
9629 echo "$as_me:$LINENO: checking for $ac_word" >&5
9630 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9631 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9632   echo $ECHO_N "(cached) $ECHO_C" >&6
9633 else
9634   case $NM_FOR_TARGET in
9635   [\\/]* | ?:[\\/]*)
9636   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9637   ;;
9638   *)
9639   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9640 for as_dir in $gcc_cv_tool_dirs
9641 do
9642   IFS=$as_save_IFS
9643   test -z "$as_dir" && as_dir=.
9644   for ac_exec_ext in '' $ac_executable_extensions; do
9645   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9646     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9647     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9648     break 2
9649   fi
9650 done
9651 done
9652
9653   ;;
9654 esac
9655 fi
9656 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9657
9658 if test -n "$NM_FOR_TARGET"; then
9659   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9660 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9661 else
9662   echo "$as_me:$LINENO: result: no" >&5
9663 echo "${ECHO_T}no" >&6
9664 fi
9665
9666 fi
9667 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9668
9669
9670 if test -n "$NM_FOR_TARGET"; then
9671   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
9672 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9673   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9674 fi
9675
9676 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9677   for ncn_progname in nm; do
9678     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9679 set dummy ${ncn_progname}; ac_word=$2
9680 echo "$as_me:$LINENO: checking for $ac_word" >&5
9681 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9682 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9683   echo $ECHO_N "(cached) $ECHO_C" >&6
9684 else
9685   if test -n "$NM_FOR_TARGET"; then
9686   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9687 else
9688 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9689 for as_dir in $PATH
9690 do
9691   IFS=$as_save_IFS
9692   test -z "$as_dir" && as_dir=.
9693   for ac_exec_ext in '' $ac_executable_extensions; do
9694   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9695     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9696     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9697     break 2
9698   fi
9699 done
9700 done
9701
9702 fi
9703 fi
9704 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9705 if test -n "$NM_FOR_TARGET"; then
9706   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9707 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9708 else
9709   echo "$as_me:$LINENO: result: no" >&5
9710 echo "${ECHO_T}no" >&6
9711 fi
9712
9713   done
9714 fi
9715
9716 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
9717   for ncn_progname in nm; do
9718     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9719 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9720     if test -x $with_build_time_tools/${ncn_progname}; then
9721       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9722       echo "$as_me:$LINENO: result: yes" >&5
9723 echo "${ECHO_T}yes" >&6
9724       break
9725     else
9726       echo "$as_me:$LINENO: result: no" >&5
9727 echo "${ECHO_T}no" >&6
9728     fi
9729   done
9730 fi
9731
9732 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
9733   for ncn_progname in nm; do
9734     if test -n "$ncn_target_tool_prefix"; then
9735       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9736 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9737 echo "$as_me:$LINENO: checking for $ac_word" >&5
9738 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9739 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9740   echo $ECHO_N "(cached) $ECHO_C" >&6
9741 else
9742   if test -n "$NM_FOR_TARGET"; then
9743   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9744 else
9745 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9746 for as_dir in $PATH
9747 do
9748   IFS=$as_save_IFS
9749   test -z "$as_dir" && as_dir=.
9750   for ac_exec_ext in '' $ac_executable_extensions; do
9751   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9752     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9753     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9754     break 2
9755   fi
9756 done
9757 done
9758
9759 fi
9760 fi
9761 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9762 if test -n "$NM_FOR_TARGET"; then
9763   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9764 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9765 else
9766   echo "$as_me:$LINENO: result: no" >&5
9767 echo "${ECHO_T}no" >&6
9768 fi
9769
9770     fi
9771     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
9772       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9773 set dummy ${ncn_progname}; ac_word=$2
9774 echo "$as_me:$LINENO: checking for $ac_word" >&5
9775 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9776 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9777   echo $ECHO_N "(cached) $ECHO_C" >&6
9778 else
9779   if test -n "$NM_FOR_TARGET"; then
9780   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9781 else
9782 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9783 for as_dir in $PATH
9784 do
9785   IFS=$as_save_IFS
9786   test -z "$as_dir" && as_dir=.
9787   for ac_exec_ext in '' $ac_executable_extensions; do
9788   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9789     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9790     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9791     break 2
9792   fi
9793 done
9794 done
9795
9796 fi
9797 fi
9798 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9799 if test -n "$NM_FOR_TARGET"; then
9800   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9801 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9802 else
9803   echo "$as_me:$LINENO: result: no" >&5
9804 echo "${ECHO_T}no" >&6
9805 fi
9806
9807     fi
9808     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
9809   done
9810 fi
9811
9812 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
9813   set dummy nm
9814   if test $build = $target ; then
9815     NM_FOR_TARGET="$2"
9816   else
9817     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
9818   fi
9819 fi
9820
9821 else
9822   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9823 fi
9824
9825
9826
9827
9828 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
9829   if test -n "$with_build_time_tools"; then
9830     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
9831 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
9832     if test -x $with_build_time_tools/objdump; then
9833       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
9834       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
9835       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
9836 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
9837     else
9838       echo "$as_me:$LINENO: result: no" >&5
9839 echo "${ECHO_T}no" >&6
9840     fi
9841   elif test $build != $host && test $have_gcc_for_target = yes; then
9842     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
9843     test $OBJDUMP_FOR_TARGET=objdump && OBJDUMP_FOR_TARGET=
9844     ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
9845   fi
9846 fi
9847 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9848   # Extract the first word of "objdump", so it can be a program name with args.
9849 set dummy objdump; ac_word=$2
9850 echo "$as_me:$LINENO: checking for $ac_word" >&5
9851 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9852 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
9853   echo $ECHO_N "(cached) $ECHO_C" >&6
9854 else
9855   case $OBJDUMP_FOR_TARGET in
9856   [\\/]* | ?:[\\/]*)
9857   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
9858   ;;
9859   *)
9860   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9861 for as_dir in $gcc_cv_tool_dirs
9862 do
9863   IFS=$as_save_IFS
9864   test -z "$as_dir" && as_dir=.
9865   for ac_exec_ext in '' $ac_executable_extensions; do
9866   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9867     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9868     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9869     break 2
9870   fi
9871 done
9872 done
9873
9874   ;;
9875 esac
9876 fi
9877 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
9878
9879 if test -n "$OBJDUMP_FOR_TARGET"; then
9880   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
9881 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
9882 else
9883   echo "$as_me:$LINENO: result: no" >&5
9884 echo "${ECHO_T}no" >&6
9885 fi
9886
9887 fi
9888 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
9889
9890
9891 if test -n "$OBJDUMP_FOR_TARGET"; then
9892   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
9893 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
9894   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
9895 fi
9896
9897 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
9898   for ncn_progname in objdump; do
9899     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9900 set dummy ${ncn_progname}; ac_word=$2
9901 echo "$as_me:$LINENO: checking for $ac_word" >&5
9902 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9903 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
9904   echo $ECHO_N "(cached) $ECHO_C" >&6
9905 else
9906   if test -n "$OBJDUMP_FOR_TARGET"; then
9907   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
9908 else
9909 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9910 for as_dir in $PATH
9911 do
9912   IFS=$as_save_IFS
9913   test -z "$as_dir" && as_dir=.
9914   for ac_exec_ext in '' $ac_executable_extensions; do
9915   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9916     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
9917     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9918     break 2
9919   fi
9920 done
9921 done
9922
9923 fi
9924 fi
9925 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
9926 if test -n "$OBJDUMP_FOR_TARGET"; then
9927   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
9928 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
9929 else
9930   echo "$as_me:$LINENO: result: no" >&5
9931 echo "${ECHO_T}no" >&6
9932 fi
9933
9934   done
9935 fi
9936
9937 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
9938   for ncn_progname in objdump; do
9939     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9940 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9941     if test -x $with_build_time_tools/${ncn_progname}; then
9942       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9943       echo "$as_me:$LINENO: result: yes" >&5
9944 echo "${ECHO_T}yes" >&6
9945       break
9946     else
9947       echo "$as_me:$LINENO: result: no" >&5
9948 echo "${ECHO_T}no" >&6
9949     fi
9950   done
9951 fi
9952
9953 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
9954   for ncn_progname in objdump; do
9955     if test -n "$ncn_target_tool_prefix"; then
9956       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9957 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9958 echo "$as_me:$LINENO: checking for $ac_word" >&5
9959 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9960 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
9961   echo $ECHO_N "(cached) $ECHO_C" >&6
9962 else
9963   if test -n "$OBJDUMP_FOR_TARGET"; then
9964   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
9965 else
9966 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9967 for as_dir in $PATH
9968 do
9969   IFS=$as_save_IFS
9970   test -z "$as_dir" && as_dir=.
9971   for ac_exec_ext in '' $ac_executable_extensions; do
9972   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9973     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9974     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9975     break 2
9976   fi
9977 done
9978 done
9979
9980 fi
9981 fi
9982 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
9983 if test -n "$OBJDUMP_FOR_TARGET"; then
9984   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
9985 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
9986 else
9987   echo "$as_me:$LINENO: result: no" >&5
9988 echo "${ECHO_T}no" >&6
9989 fi
9990
9991     fi
9992     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
9993       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9994 set dummy ${ncn_progname}; ac_word=$2
9995 echo "$as_me:$LINENO: checking for $ac_word" >&5
9996 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9997 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
9998   echo $ECHO_N "(cached) $ECHO_C" >&6
9999 else
10000   if test -n "$OBJDUMP_FOR_TARGET"; then
10001   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10002 else
10003 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10004 for as_dir in $PATH
10005 do
10006   IFS=$as_save_IFS
10007   test -z "$as_dir" && as_dir=.
10008   for ac_exec_ext in '' $ac_executable_extensions; do
10009   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10010     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10011     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10012     break 2
10013   fi
10014 done
10015 done
10016
10017 fi
10018 fi
10019 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10020 if test -n "$OBJDUMP_FOR_TARGET"; then
10021   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10022 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10023 else
10024   echo "$as_me:$LINENO: result: no" >&5
10025 echo "${ECHO_T}no" >&6
10026 fi
10027
10028     fi
10029     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10030   done
10031 fi
10032
10033 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10034   set dummy objdump
10035   if test $build = $target ; then
10036     OBJDUMP_FOR_TARGET="$2"
10037   else
10038     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10039   fi
10040 fi
10041
10042 else
10043   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10044 fi
10045
10046
10047
10048
10049 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10050   if test -n "$with_build_time_tools"; then
10051     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10052 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10053     if test -x $with_build_time_tools/ranlib; then
10054       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10055       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10056       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10057 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10058     else
10059       echo "$as_me:$LINENO: result: no" >&5
10060 echo "${ECHO_T}no" >&6
10061     fi
10062   elif test $build != $host && test $have_gcc_for_target = yes; then
10063     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10064     test $RANLIB_FOR_TARGET=ranlib && RANLIB_FOR_TARGET=
10065     ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10066   fi
10067 fi
10068 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10069   # Extract the first word of "ranlib", so it can be a program name with args.
10070 set dummy ranlib; ac_word=$2
10071 echo "$as_me:$LINENO: checking for $ac_word" >&5
10072 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10073 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10074   echo $ECHO_N "(cached) $ECHO_C" >&6
10075 else
10076   case $RANLIB_FOR_TARGET in
10077   [\\/]* | ?:[\\/]*)
10078   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10079   ;;
10080   *)
10081   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10082 for as_dir in $gcc_cv_tool_dirs
10083 do
10084   IFS=$as_save_IFS
10085   test -z "$as_dir" && as_dir=.
10086   for ac_exec_ext in '' $ac_executable_extensions; do
10087   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10088     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10089     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10090     break 2
10091   fi
10092 done
10093 done
10094
10095   ;;
10096 esac
10097 fi
10098 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10099
10100 if test -n "$RANLIB_FOR_TARGET"; then
10101   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10102 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10103 else
10104   echo "$as_me:$LINENO: result: no" >&5
10105 echo "${ECHO_T}no" >&6
10106 fi
10107
10108 fi
10109 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10110
10111
10112 if test -n "$RANLIB_FOR_TARGET"; then
10113   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10114 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10115   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10116 fi
10117
10118 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10119   for ncn_progname in ranlib; do
10120     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10121 set dummy ${ncn_progname}; ac_word=$2
10122 echo "$as_me:$LINENO: checking for $ac_word" >&5
10123 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10124 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10125   echo $ECHO_N "(cached) $ECHO_C" >&6
10126 else
10127   if test -n "$RANLIB_FOR_TARGET"; then
10128   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10129 else
10130 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10131 for as_dir in $PATH
10132 do
10133   IFS=$as_save_IFS
10134   test -z "$as_dir" && as_dir=.
10135   for ac_exec_ext in '' $ac_executable_extensions; do
10136   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10137     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10138     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10139     break 2
10140   fi
10141 done
10142 done
10143
10144 fi
10145 fi
10146 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10147 if test -n "$RANLIB_FOR_TARGET"; then
10148   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10149 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10150 else
10151   echo "$as_me:$LINENO: result: no" >&5
10152 echo "${ECHO_T}no" >&6
10153 fi
10154
10155   done
10156 fi
10157
10158 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10159   for ncn_progname in ranlib; do
10160     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10161 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10162     if test -x $with_build_time_tools/${ncn_progname}; then
10163       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10164       echo "$as_me:$LINENO: result: yes" >&5
10165 echo "${ECHO_T}yes" >&6
10166       break
10167     else
10168       echo "$as_me:$LINENO: result: no" >&5
10169 echo "${ECHO_T}no" >&6
10170     fi
10171   done
10172 fi
10173
10174 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10175   for ncn_progname in ranlib; do
10176     if test -n "$ncn_target_tool_prefix"; then
10177       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10178 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10179 echo "$as_me:$LINENO: checking for $ac_word" >&5
10180 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10181 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10182   echo $ECHO_N "(cached) $ECHO_C" >&6
10183 else
10184   if test -n "$RANLIB_FOR_TARGET"; then
10185   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10186 else
10187 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10188 for as_dir in $PATH
10189 do
10190   IFS=$as_save_IFS
10191   test -z "$as_dir" && as_dir=.
10192   for ac_exec_ext in '' $ac_executable_extensions; do
10193   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10194     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10195     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10196     break 2
10197   fi
10198 done
10199 done
10200
10201 fi
10202 fi
10203 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10204 if test -n "$RANLIB_FOR_TARGET"; then
10205   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10206 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10207 else
10208   echo "$as_me:$LINENO: result: no" >&5
10209 echo "${ECHO_T}no" >&6
10210 fi
10211
10212     fi
10213     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10214       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10215 set dummy ${ncn_progname}; ac_word=$2
10216 echo "$as_me:$LINENO: checking for $ac_word" >&5
10217 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10218 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10219   echo $ECHO_N "(cached) $ECHO_C" >&6
10220 else
10221   if test -n "$RANLIB_FOR_TARGET"; then
10222   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10223 else
10224 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10225 for as_dir in $PATH
10226 do
10227   IFS=$as_save_IFS
10228   test -z "$as_dir" && as_dir=.
10229   for ac_exec_ext in '' $ac_executable_extensions; do
10230   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10231     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10232     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10233     break 2
10234   fi
10235 done
10236 done
10237
10238 fi
10239 fi
10240 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10241 if test -n "$RANLIB_FOR_TARGET"; then
10242   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10243 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10244 else
10245   echo "$as_me:$LINENO: result: no" >&5
10246 echo "${ECHO_T}no" >&6
10247 fi
10248
10249     fi
10250     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10251   done
10252 fi
10253
10254 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10255   set dummy ranlib
10256   if test $build = $target ; then
10257     RANLIB_FOR_TARGET="$2"
10258   else
10259     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10260   fi
10261 fi
10262
10263 else
10264   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10265 fi
10266
10267
10268
10269
10270 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10271   if test -n "$with_build_time_tools"; then
10272     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10273 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10274     if test -x $with_build_time_tools/strip; then
10275       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10276       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10277       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10278 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10279     else
10280       echo "$as_me:$LINENO: result: no" >&5
10281 echo "${ECHO_T}no" >&6
10282     fi
10283   elif test $build != $host && test $have_gcc_for_target = yes; then
10284     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10285     test $STRIP_FOR_TARGET=strip && STRIP_FOR_TARGET=
10286     ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10287   fi
10288 fi
10289 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10290   # Extract the first word of "strip", so it can be a program name with args.
10291 set dummy strip; ac_word=$2
10292 echo "$as_me:$LINENO: checking for $ac_word" >&5
10293 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10294 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10295   echo $ECHO_N "(cached) $ECHO_C" >&6
10296 else
10297   case $STRIP_FOR_TARGET in
10298   [\\/]* | ?:[\\/]*)
10299   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10300   ;;
10301   *)
10302   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10303 for as_dir in $gcc_cv_tool_dirs
10304 do
10305   IFS=$as_save_IFS
10306   test -z "$as_dir" && as_dir=.
10307   for ac_exec_ext in '' $ac_executable_extensions; do
10308   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10309     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10310     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10311     break 2
10312   fi
10313 done
10314 done
10315
10316   ;;
10317 esac
10318 fi
10319 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10320
10321 if test -n "$STRIP_FOR_TARGET"; then
10322   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10323 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10324 else
10325   echo "$as_me:$LINENO: result: no" >&5
10326 echo "${ECHO_T}no" >&6
10327 fi
10328
10329 fi
10330 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10331
10332
10333 if test -n "$STRIP_FOR_TARGET"; then
10334   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10335 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10336   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10337 fi
10338
10339 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10340   for ncn_progname in strip; do
10341     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10342 set dummy ${ncn_progname}; ac_word=$2
10343 echo "$as_me:$LINENO: checking for $ac_word" >&5
10344 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10345 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10346   echo $ECHO_N "(cached) $ECHO_C" >&6
10347 else
10348   if test -n "$STRIP_FOR_TARGET"; then
10349   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10350 else
10351 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10352 for as_dir in $PATH
10353 do
10354   IFS=$as_save_IFS
10355   test -z "$as_dir" && as_dir=.
10356   for ac_exec_ext in '' $ac_executable_extensions; do
10357   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10358     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10359     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10360     break 2
10361   fi
10362 done
10363 done
10364
10365 fi
10366 fi
10367 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10368 if test -n "$STRIP_FOR_TARGET"; then
10369   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10370 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10371 else
10372   echo "$as_me:$LINENO: result: no" >&5
10373 echo "${ECHO_T}no" >&6
10374 fi
10375
10376   done
10377 fi
10378
10379 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10380   for ncn_progname in strip; do
10381     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10382 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10383     if test -x $with_build_time_tools/${ncn_progname}; then
10384       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10385       echo "$as_me:$LINENO: result: yes" >&5
10386 echo "${ECHO_T}yes" >&6
10387       break
10388     else
10389       echo "$as_me:$LINENO: result: no" >&5
10390 echo "${ECHO_T}no" >&6
10391     fi
10392   done
10393 fi
10394
10395 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10396   for ncn_progname in strip; do
10397     if test -n "$ncn_target_tool_prefix"; then
10398       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10399 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10400 echo "$as_me:$LINENO: checking for $ac_word" >&5
10401 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10402 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10403   echo $ECHO_N "(cached) $ECHO_C" >&6
10404 else
10405   if test -n "$STRIP_FOR_TARGET"; then
10406   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10407 else
10408 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10409 for as_dir in $PATH
10410 do
10411   IFS=$as_save_IFS
10412   test -z "$as_dir" && as_dir=.
10413   for ac_exec_ext in '' $ac_executable_extensions; do
10414   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10415     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10416     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10417     break 2
10418   fi
10419 done
10420 done
10421
10422 fi
10423 fi
10424 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10425 if test -n "$STRIP_FOR_TARGET"; then
10426   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10427 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10428 else
10429   echo "$as_me:$LINENO: result: no" >&5
10430 echo "${ECHO_T}no" >&6
10431 fi
10432
10433     fi
10434     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10435       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10436 set dummy ${ncn_progname}; ac_word=$2
10437 echo "$as_me:$LINENO: checking for $ac_word" >&5
10438 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10439 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10440   echo $ECHO_N "(cached) $ECHO_C" >&6
10441 else
10442   if test -n "$STRIP_FOR_TARGET"; then
10443   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10444 else
10445 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10446 for as_dir in $PATH
10447 do
10448   IFS=$as_save_IFS
10449   test -z "$as_dir" && as_dir=.
10450   for ac_exec_ext in '' $ac_executable_extensions; do
10451   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10452     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10453     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10454     break 2
10455   fi
10456 done
10457 done
10458
10459 fi
10460 fi
10461 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10462 if test -n "$STRIP_FOR_TARGET"; then
10463   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10464 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10465 else
10466   echo "$as_me:$LINENO: result: no" >&5
10467 echo "${ECHO_T}no" >&6
10468 fi
10469
10470     fi
10471     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10472   done
10473 fi
10474
10475 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10476   set dummy strip
10477   if test $build = $target ; then
10478     STRIP_FOR_TARGET="$2"
10479   else
10480     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10481   fi
10482 fi
10483
10484 else
10485   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10486 fi
10487
10488
10489
10490
10491 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10492   if test -n "$with_build_time_tools"; then
10493     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10494 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10495     if test -x $with_build_time_tools/windres; then
10496       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10497       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10498       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10499 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10500     else
10501       echo "$as_me:$LINENO: result: no" >&5
10502 echo "${ECHO_T}no" >&6
10503     fi
10504   elif test $build != $host && test $have_gcc_for_target = yes; then
10505     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10506     test $WINDRES_FOR_TARGET=windres && WINDRES_FOR_TARGET=
10507     ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10508   fi
10509 fi
10510 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10511   # Extract the first word of "windres", so it can be a program name with args.
10512 set dummy windres; ac_word=$2
10513 echo "$as_me:$LINENO: checking for $ac_word" >&5
10514 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10515 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10516   echo $ECHO_N "(cached) $ECHO_C" >&6
10517 else
10518   case $WINDRES_FOR_TARGET in
10519   [\\/]* | ?:[\\/]*)
10520   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10521   ;;
10522   *)
10523   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10524 for as_dir in $gcc_cv_tool_dirs
10525 do
10526   IFS=$as_save_IFS
10527   test -z "$as_dir" && as_dir=.
10528   for ac_exec_ext in '' $ac_executable_extensions; do
10529   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10530     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10531     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10532     break 2
10533   fi
10534 done
10535 done
10536
10537   ;;
10538 esac
10539 fi
10540 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10541
10542 if test -n "$WINDRES_FOR_TARGET"; then
10543   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10544 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10545 else
10546   echo "$as_me:$LINENO: result: no" >&5
10547 echo "${ECHO_T}no" >&6
10548 fi
10549
10550 fi
10551 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10552
10553
10554 if test -n "$WINDRES_FOR_TARGET"; then
10555   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10556 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10557   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10558 fi
10559
10560 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10561   for ncn_progname in windres; do
10562     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10563 set dummy ${ncn_progname}; ac_word=$2
10564 echo "$as_me:$LINENO: checking for $ac_word" >&5
10565 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10566 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10567   echo $ECHO_N "(cached) $ECHO_C" >&6
10568 else
10569   if test -n "$WINDRES_FOR_TARGET"; then
10570   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10571 else
10572 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10573 for as_dir in $PATH
10574 do
10575   IFS=$as_save_IFS
10576   test -z "$as_dir" && as_dir=.
10577   for ac_exec_ext in '' $ac_executable_extensions; do
10578   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10579     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10580     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10581     break 2
10582   fi
10583 done
10584 done
10585
10586 fi
10587 fi
10588 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10589 if test -n "$WINDRES_FOR_TARGET"; then
10590   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10591 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10592 else
10593   echo "$as_me:$LINENO: result: no" >&5
10594 echo "${ECHO_T}no" >&6
10595 fi
10596
10597   done
10598 fi
10599
10600 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10601   for ncn_progname in windres; do
10602     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10603 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10604     if test -x $with_build_time_tools/${ncn_progname}; then
10605       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10606       echo "$as_me:$LINENO: result: yes" >&5
10607 echo "${ECHO_T}yes" >&6
10608       break
10609     else
10610       echo "$as_me:$LINENO: result: no" >&5
10611 echo "${ECHO_T}no" >&6
10612     fi
10613   done
10614 fi
10615
10616 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10617   for ncn_progname in windres; do
10618     if test -n "$ncn_target_tool_prefix"; then
10619       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10620 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10621 echo "$as_me:$LINENO: checking for $ac_word" >&5
10622 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10623 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10624   echo $ECHO_N "(cached) $ECHO_C" >&6
10625 else
10626   if test -n "$WINDRES_FOR_TARGET"; then
10627   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10628 else
10629 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10630 for as_dir in $PATH
10631 do
10632   IFS=$as_save_IFS
10633   test -z "$as_dir" && as_dir=.
10634   for ac_exec_ext in '' $ac_executable_extensions; do
10635   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10636     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10637     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10638     break 2
10639   fi
10640 done
10641 done
10642
10643 fi
10644 fi
10645 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10646 if test -n "$WINDRES_FOR_TARGET"; then
10647   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10648 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10649 else
10650   echo "$as_me:$LINENO: result: no" >&5
10651 echo "${ECHO_T}no" >&6
10652 fi
10653
10654     fi
10655     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
10656       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10657 set dummy ${ncn_progname}; ac_word=$2
10658 echo "$as_me:$LINENO: checking for $ac_word" >&5
10659 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10660 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10661   echo $ECHO_N "(cached) $ECHO_C" >&6
10662 else
10663   if test -n "$WINDRES_FOR_TARGET"; then
10664   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10665 else
10666 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10667 for as_dir in $PATH
10668 do
10669   IFS=$as_save_IFS
10670   test -z "$as_dir" && as_dir=.
10671   for ac_exec_ext in '' $ac_executable_extensions; do
10672   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10673     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10674     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10675     break 2
10676   fi
10677 done
10678 done
10679
10680 fi
10681 fi
10682 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10683 if test -n "$WINDRES_FOR_TARGET"; then
10684   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10685 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10686 else
10687   echo "$as_me:$LINENO: result: no" >&5
10688 echo "${ECHO_T}no" >&6
10689 fi
10690
10691     fi
10692     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
10693   done
10694 fi
10695
10696 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
10697   set dummy windres
10698   if test $build = $target ; then
10699     WINDRES_FOR_TARGET="$2"
10700   else
10701     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
10702   fi
10703 fi
10704
10705 else
10706   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10707 fi
10708
10709
10710 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
10711
10712 echo "$as_me:$LINENO: checking where to find the target ar" >&5
10713 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
10714 if test "x${build}" != "x${host}" ; then
10715   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
10716     # We already found the complete path
10717     echo "$as_me:$LINENO: result: pre-installed in \`dirname $AR_FOR_TARGET\`" >&5
10718 echo "${ECHO_T}pre-installed in \`dirname $AR_FOR_TARGET\`" >&6
10719   else
10720     # Canadian cross, just use what we found
10721     echo "$as_me:$LINENO: result: pre-installed" >&5
10722 echo "${ECHO_T}pre-installed" >&6
10723   fi
10724 else
10725   ok=yes
10726   case " ${configdirs} " in
10727     *" binutils "*) ;;
10728     *) ok=no ;;
10729   esac
10730
10731   if test $ok = yes; then
10732     # An in-tree tool is available and we can use it
10733     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
10734     echo "$as_me:$LINENO: result: just compiled" >&5
10735 echo "${ECHO_T}just compiled" >&6
10736   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
10737     # We already found the complete path
10738     echo "$as_me:$LINENO: result: pre-installed in \`dirname $AR_FOR_TARGET\`" >&5
10739 echo "${ECHO_T}pre-installed in \`dirname $AR_FOR_TARGET\`" >&6
10740   elif test "x$target" = "x$host"; then
10741     # We can use an host tool
10742     AR_FOR_TARGET='$(AR)'
10743     echo "$as_me:$LINENO: result: host tool" >&5
10744 echo "${ECHO_T}host tool" >&6
10745   else
10746     # We need a cross tool
10747     echo "$as_me:$LINENO: result: pre-installed" >&5
10748 echo "${ECHO_T}pre-installed" >&6
10749   fi
10750 fi
10751
10752 echo "$as_me:$LINENO: checking where to find the target as" >&5
10753 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
10754 if test "x${build}" != "x${host}" ; then
10755   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
10756     # We already found the complete path
10757     echo "$as_me:$LINENO: result: pre-installed in \`dirname $AS_FOR_TARGET\`" >&5
10758 echo "${ECHO_T}pre-installed in \`dirname $AS_FOR_TARGET\`" >&6
10759   else
10760     # Canadian cross, just use what we found
10761     echo "$as_me:$LINENO: result: pre-installed" >&5
10762 echo "${ECHO_T}pre-installed" >&6
10763   fi
10764 else
10765   ok=yes
10766   case " ${configdirs} " in
10767     *" gas "*) ;;
10768     *) ok=no ;;
10769   esac
10770
10771   if test $ok = yes; then
10772     # An in-tree tool is available and we can use it
10773     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
10774     echo "$as_me:$LINENO: result: just compiled" >&5
10775 echo "${ECHO_T}just compiled" >&6
10776   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
10777     # We already found the complete path
10778     echo "$as_me:$LINENO: result: pre-installed in \`dirname $AS_FOR_TARGET\`" >&5
10779 echo "${ECHO_T}pre-installed in \`dirname $AS_FOR_TARGET\`" >&6
10780   elif test "x$target" = "x$host"; then
10781     # We can use an host tool
10782     AS_FOR_TARGET='$(AS)'
10783     echo "$as_me:$LINENO: result: host tool" >&5
10784 echo "${ECHO_T}host tool" >&6
10785   else
10786     # We need a cross tool
10787     echo "$as_me:$LINENO: result: pre-installed" >&5
10788 echo "${ECHO_T}pre-installed" >&6
10789   fi
10790 fi
10791
10792 echo "$as_me:$LINENO: checking where to find the target cc" >&5
10793 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
10794 if test "x${build}" != "x${host}" ; then
10795   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
10796     # We already found the complete path
10797     echo "$as_me:$LINENO: result: pre-installed in \`dirname $CC_FOR_TARGET\`" >&5
10798 echo "${ECHO_T}pre-installed in \`dirname $CC_FOR_TARGET\`" >&6
10799   else
10800     # Canadian cross, just use what we found
10801     echo "$as_me:$LINENO: result: pre-installed" >&5
10802 echo "${ECHO_T}pre-installed" >&6
10803   fi
10804 else
10805   ok=yes
10806   case " ${configdirs} " in
10807     *" gcc "*) ;;
10808     *) ok=no ;;
10809   esac
10810
10811   if test $ok = yes; then
10812     # An in-tree tool is available and we can use it
10813     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
10814     echo "$as_me:$LINENO: result: just compiled" >&5
10815 echo "${ECHO_T}just compiled" >&6
10816   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
10817     # We already found the complete path
10818     echo "$as_me:$LINENO: result: pre-installed in \`dirname $CC_FOR_TARGET\`" >&5
10819 echo "${ECHO_T}pre-installed in \`dirname $CC_FOR_TARGET\`" >&6
10820   elif test "x$target" = "x$host"; then
10821     # We can use an host tool
10822     CC_FOR_TARGET='$(CC)'
10823     echo "$as_me:$LINENO: result: host tool" >&5
10824 echo "${ECHO_T}host tool" >&6
10825   else
10826     # We need a cross tool
10827     echo "$as_me:$LINENO: result: pre-installed" >&5
10828 echo "${ECHO_T}pre-installed" >&6
10829   fi
10830 fi
10831
10832 echo "$as_me:$LINENO: checking where to find the target c++" >&5
10833 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
10834 if test "x${build}" != "x${host}" ; then
10835   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
10836     # We already found the complete path
10837     echo "$as_me:$LINENO: result: pre-installed in \`dirname $CXX_FOR_TARGET\`" >&5
10838 echo "${ECHO_T}pre-installed in \`dirname $CXX_FOR_TARGET\`" >&6
10839   else
10840     # Canadian cross, just use what we found
10841     echo "$as_me:$LINENO: result: pre-installed" >&5
10842 echo "${ECHO_T}pre-installed" >&6
10843   fi
10844 else
10845   ok=yes
10846   case " ${configdirs} " in
10847     *" gcc "*) ;;
10848     *) ok=no ;;
10849   esac
10850   case ,${enable_languages}, in
10851     *,c++,*) ;;
10852     *) ok=no ;;
10853   esac
10854   if test $ok = yes; then
10855     # An in-tree tool is available and we can use it
10856     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'
10857     echo "$as_me:$LINENO: result: just compiled" >&5
10858 echo "${ECHO_T}just compiled" >&6
10859   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
10860     # We already found the complete path
10861     echo "$as_me:$LINENO: result: pre-installed in \`dirname $CXX_FOR_TARGET\`" >&5
10862 echo "${ECHO_T}pre-installed in \`dirname $CXX_FOR_TARGET\`" >&6
10863   elif test "x$target" = "x$host"; then
10864     # We can use an host tool
10865     CXX_FOR_TARGET='$(CXX)'
10866     echo "$as_me:$LINENO: result: host tool" >&5
10867 echo "${ECHO_T}host tool" >&6
10868   else
10869     # We need a cross tool
10870     echo "$as_me:$LINENO: result: pre-installed" >&5
10871 echo "${ECHO_T}pre-installed" >&6
10872   fi
10873 fi
10874
10875 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
10876 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
10877 if test "x${build}" != "x${host}" ; then
10878   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
10879     # We already found the complete path
10880     echo "$as_me:$LINENO: result: pre-installed in \`dirname $RAW_CXX_FOR_TARGET\`" >&5
10881 echo "${ECHO_T}pre-installed in \`dirname $RAW_CXX_FOR_TARGET\`" >&6
10882   else
10883     # Canadian cross, just use what we found
10884     echo "$as_me:$LINENO: result: pre-installed" >&5
10885 echo "${ECHO_T}pre-installed" >&6
10886   fi
10887 else
10888   ok=yes
10889   case " ${configdirs} " in
10890     *" gcc "*) ;;
10891     *) ok=no ;;
10892   esac
10893   case ,${enable_languages}, in
10894     *,c++,*) ;;
10895     *) ok=no ;;
10896   esac
10897   if test $ok = yes; then
10898     # An in-tree tool is available and we can use it
10899     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'
10900     echo "$as_me:$LINENO: result: just compiled" >&5
10901 echo "${ECHO_T}just compiled" >&6
10902   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
10903     # We already found the complete path
10904     echo "$as_me:$LINENO: result: pre-installed in \`dirname $RAW_CXX_FOR_TARGET\`" >&5
10905 echo "${ECHO_T}pre-installed in \`dirname $RAW_CXX_FOR_TARGET\`" >&6
10906   elif test "x$target" = "x$host"; then
10907     # We can use an host tool
10908     RAW_CXX_FOR_TARGET='$(CXX)'
10909     echo "$as_me:$LINENO: result: host tool" >&5
10910 echo "${ECHO_T}host tool" >&6
10911   else
10912     # We need a cross tool
10913     echo "$as_me:$LINENO: result: pre-installed" >&5
10914 echo "${ECHO_T}pre-installed" >&6
10915   fi
10916 fi
10917
10918 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
10919 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
10920 if test "x${build}" != "x${host}" ; then
10921   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
10922     # We already found the complete path
10923     echo "$as_me:$LINENO: result: pre-installed in \`dirname $DLLTOOL_FOR_TARGET\`" >&5
10924 echo "${ECHO_T}pre-installed in \`dirname $DLLTOOL_FOR_TARGET\`" >&6
10925   else
10926     # Canadian cross, just use what we found
10927     echo "$as_me:$LINENO: result: pre-installed" >&5
10928 echo "${ECHO_T}pre-installed" >&6
10929   fi
10930 else
10931   ok=yes
10932   case " ${configdirs} " in
10933     *" binutils "*) ;;
10934     *) ok=no ;;
10935   esac
10936
10937   if test $ok = yes; then
10938     # An in-tree tool is available and we can use it
10939     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
10940     echo "$as_me:$LINENO: result: just compiled" >&5
10941 echo "${ECHO_T}just compiled" >&6
10942   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
10943     # We already found the complete path
10944     echo "$as_me:$LINENO: result: pre-installed in \`dirname $DLLTOOL_FOR_TARGET\`" >&5
10945 echo "${ECHO_T}pre-installed in \`dirname $DLLTOOL_FOR_TARGET\`" >&6
10946   elif test "x$target" = "x$host"; then
10947     # We can use an host tool
10948     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
10949     echo "$as_me:$LINENO: result: host tool" >&5
10950 echo "${ECHO_T}host tool" >&6
10951   else
10952     # We need a cross tool
10953     echo "$as_me:$LINENO: result: pre-installed" >&5
10954 echo "${ECHO_T}pre-installed" >&6
10955   fi
10956 fi
10957
10958 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
10959 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
10960 if test "x${build}" != "x${host}" ; then
10961   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
10962     # We already found the complete path
10963     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GCC_FOR_TARGET\`" >&5
10964 echo "${ECHO_T}pre-installed in \`dirname $GCC_FOR_TARGET\`" >&6
10965   else
10966     # Canadian cross, just use what we found
10967     echo "$as_me:$LINENO: result: pre-installed" >&5
10968 echo "${ECHO_T}pre-installed" >&6
10969   fi
10970 else
10971   ok=yes
10972   case " ${configdirs} " in
10973     *" gcc "*) ;;
10974     *) ok=no ;;
10975   esac
10976
10977   if test $ok = yes; then
10978     # An in-tree tool is available and we can use it
10979     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
10980     echo "$as_me:$LINENO: result: just compiled" >&5
10981 echo "${ECHO_T}just compiled" >&6
10982   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
10983     # We already found the complete path
10984     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GCC_FOR_TARGET\`" >&5
10985 echo "${ECHO_T}pre-installed in \`dirname $GCC_FOR_TARGET\`" >&6
10986   elif test "x$target" = "x$host"; then
10987     # We can use an host tool
10988     GCC_FOR_TARGET='$()'
10989     echo "$as_me:$LINENO: result: host tool" >&5
10990 echo "${ECHO_T}host tool" >&6
10991   else
10992     # We need a cross tool
10993     echo "$as_me:$LINENO: result: pre-installed" >&5
10994 echo "${ECHO_T}pre-installed" >&6
10995   fi
10996 fi
10997
10998 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
10999 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11000 if test "x${build}" != "x${host}" ; then
11001   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11002     # We already found the complete path
11003     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GCJ_FOR_TARGET\`" >&5
11004 echo "${ECHO_T}pre-installed in \`dirname $GCJ_FOR_TARGET\`" >&6
11005   else
11006     # Canadian cross, just use what we found
11007     echo "$as_me:$LINENO: result: pre-installed" >&5
11008 echo "${ECHO_T}pre-installed" >&6
11009   fi
11010 else
11011   ok=yes
11012   case " ${configdirs} " in
11013     *" gcc "*) ;;
11014     *) ok=no ;;
11015   esac
11016   case ,${enable_languages}, in
11017     *,java,*) ;;
11018     *) ok=no ;;
11019   esac
11020   if test $ok = yes; then
11021     # An in-tree tool is available and we can use it
11022     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11023     echo "$as_me:$LINENO: result: just compiled" >&5
11024 echo "${ECHO_T}just compiled" >&6
11025   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11026     # We already found the complete path
11027     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GCJ_FOR_TARGET\`" >&5
11028 echo "${ECHO_T}pre-installed in \`dirname $GCJ_FOR_TARGET\`" >&6
11029   elif test "x$target" = "x$host"; then
11030     # We can use an host tool
11031     GCJ_FOR_TARGET='$(GCJ)'
11032     echo "$as_me:$LINENO: result: host tool" >&5
11033 echo "${ECHO_T}host tool" >&6
11034   else
11035     # We need a cross tool
11036     echo "$as_me:$LINENO: result: pre-installed" >&5
11037 echo "${ECHO_T}pre-installed" >&6
11038   fi
11039 fi
11040
11041 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11042 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11043 if test "x${build}" != "x${host}" ; then
11044   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11045     # We already found the complete path
11046     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GFORTRAN_FOR_TARGET\`" >&5
11047 echo "${ECHO_T}pre-installed in \`dirname $GFORTRAN_FOR_TARGET\`" >&6
11048   else
11049     # Canadian cross, just use what we found
11050     echo "$as_me:$LINENO: result: pre-installed" >&5
11051 echo "${ECHO_T}pre-installed" >&6
11052   fi
11053 else
11054   ok=yes
11055   case " ${configdirs} " in
11056     *" gcc "*) ;;
11057     *) ok=no ;;
11058   esac
11059   case ,${enable_languages}, in
11060     *,fortran,*) ;;
11061     *) ok=no ;;
11062   esac
11063   if test $ok = yes; then
11064     # An in-tree tool is available and we can use it
11065     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11066     echo "$as_me:$LINENO: result: just compiled" >&5
11067 echo "${ECHO_T}just compiled" >&6
11068   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11069     # We already found the complete path
11070     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GFORTRAN_FOR_TARGET\`" >&5
11071 echo "${ECHO_T}pre-installed in \`dirname $GFORTRAN_FOR_TARGET\`" >&6
11072   elif test "x$target" = "x$host"; then
11073     # We can use an host tool
11074     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11075     echo "$as_me:$LINENO: result: host tool" >&5
11076 echo "${ECHO_T}host tool" >&6
11077   else
11078     # We need a cross tool
11079     echo "$as_me:$LINENO: result: pre-installed" >&5
11080 echo "${ECHO_T}pre-installed" >&6
11081   fi
11082 fi
11083
11084 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11085 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11086 if test "x${build}" != "x${host}" ; then
11087   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11088     # We already found the complete path
11089     echo "$as_me:$LINENO: result: pre-installed in \`dirname $LD_FOR_TARGET\`" >&5
11090 echo "${ECHO_T}pre-installed in \`dirname $LD_FOR_TARGET\`" >&6
11091   else
11092     # Canadian cross, just use what we found
11093     echo "$as_me:$LINENO: result: pre-installed" >&5
11094 echo "${ECHO_T}pre-installed" >&6
11095   fi
11096 else
11097   ok=yes
11098   case " ${configdirs} " in
11099     *" ld "*) ;;
11100     *) ok=no ;;
11101   esac
11102
11103   if test $ok = yes; then
11104     # An in-tree tool is available and we can use it
11105     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11106     echo "$as_me:$LINENO: result: just compiled" >&5
11107 echo "${ECHO_T}just compiled" >&6
11108   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11109     # We already found the complete path
11110     echo "$as_me:$LINENO: result: pre-installed in \`dirname $LD_FOR_TARGET\`" >&5
11111 echo "${ECHO_T}pre-installed in \`dirname $LD_FOR_TARGET\`" >&6
11112   elif test "x$target" = "x$host"; then
11113     # We can use an host tool
11114     LD_FOR_TARGET='$(LD)'
11115     echo "$as_me:$LINENO: result: host tool" >&5
11116 echo "${ECHO_T}host tool" >&6
11117   else
11118     # We need a cross tool
11119     echo "$as_me:$LINENO: result: pre-installed" >&5
11120 echo "${ECHO_T}pre-installed" >&6
11121   fi
11122 fi
11123
11124 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11125 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11126 if test "x${build}" != "x${host}" ; then
11127   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11128     # We already found the complete path
11129     echo "$as_me:$LINENO: result: pre-installed in \`dirname $LIPO_FOR_TARGET\`" >&5
11130 echo "${ECHO_T}pre-installed in \`dirname $LIPO_FOR_TARGET\`" >&6
11131   else
11132     # Canadian cross, just use what we found
11133     echo "$as_me:$LINENO: result: pre-installed" >&5
11134 echo "${ECHO_T}pre-installed" >&6
11135   fi
11136 else
11137   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11138     # We already found the complete path
11139     echo "$as_me:$LINENO: result: pre-installed in \`dirname $LIPO_FOR_TARGET\`" >&5
11140 echo "${ECHO_T}pre-installed in \`dirname $LIPO_FOR_TARGET\`" >&6
11141   elif test "x$target" = "x$host"; then
11142     # We can use an host tool
11143     LIPO_FOR_TARGET='$(LIPO)'
11144     echo "$as_me:$LINENO: result: host tool" >&5
11145 echo "${ECHO_T}host tool" >&6
11146   else
11147     # We need a cross tool
11148     echo "$as_me:$LINENO: result: pre-installed" >&5
11149 echo "${ECHO_T}pre-installed" >&6
11150   fi
11151 fi
11152
11153 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11154 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11155 if test "x${build}" != "x${host}" ; then
11156   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11157     # We already found the complete path
11158     echo "$as_me:$LINENO: result: pre-installed in \`dirname $NM_FOR_TARGET\`" >&5
11159 echo "${ECHO_T}pre-installed in \`dirname $NM_FOR_TARGET\`" >&6
11160   else
11161     # Canadian cross, just use what we found
11162     echo "$as_me:$LINENO: result: pre-installed" >&5
11163 echo "${ECHO_T}pre-installed" >&6
11164   fi
11165 else
11166   ok=yes
11167   case " ${configdirs} " in
11168     *" binutils "*) ;;
11169     *) ok=no ;;
11170   esac
11171
11172   if test $ok = yes; then
11173     # An in-tree tool is available and we can use it
11174     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11175     echo "$as_me:$LINENO: result: just compiled" >&5
11176 echo "${ECHO_T}just compiled" >&6
11177   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11178     # We already found the complete path
11179     echo "$as_me:$LINENO: result: pre-installed in \`dirname $NM_FOR_TARGET\`" >&5
11180 echo "${ECHO_T}pre-installed in \`dirname $NM_FOR_TARGET\`" >&6
11181   elif test "x$target" = "x$host"; then
11182     # We can use an host tool
11183     NM_FOR_TARGET='$(NM)'
11184     echo "$as_me:$LINENO: result: host tool" >&5
11185 echo "${ECHO_T}host tool" >&6
11186   else
11187     # We need a cross tool
11188     echo "$as_me:$LINENO: result: pre-installed" >&5
11189 echo "${ECHO_T}pre-installed" >&6
11190   fi
11191 fi
11192
11193 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11194 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11195 if test "x${build}" != "x${host}" ; then
11196   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11197     # We already found the complete path
11198     echo "$as_me:$LINENO: result: pre-installed in \`dirname $OBJDUMP_FOR_TARGET\`" >&5
11199 echo "${ECHO_T}pre-installed in \`dirname $OBJDUMP_FOR_TARGET\`" >&6
11200   else
11201     # Canadian cross, just use what we found
11202     echo "$as_me:$LINENO: result: pre-installed" >&5
11203 echo "${ECHO_T}pre-installed" >&6
11204   fi
11205 else
11206   ok=yes
11207   case " ${configdirs} " in
11208     *" binutils "*) ;;
11209     *) ok=no ;;
11210   esac
11211
11212   if test $ok = yes; then
11213     # An in-tree tool is available and we can use it
11214     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11215     echo "$as_me:$LINENO: result: just compiled" >&5
11216 echo "${ECHO_T}just compiled" >&6
11217   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11218     # We already found the complete path
11219     echo "$as_me:$LINENO: result: pre-installed in \`dirname $OBJDUMP_FOR_TARGET\`" >&5
11220 echo "${ECHO_T}pre-installed in \`dirname $OBJDUMP_FOR_TARGET\`" >&6
11221   elif test "x$target" = "x$host"; then
11222     # We can use an host tool
11223     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11224     echo "$as_me:$LINENO: result: host tool" >&5
11225 echo "${ECHO_T}host tool" >&6
11226   else
11227     # We need a cross tool
11228     echo "$as_me:$LINENO: result: pre-installed" >&5
11229 echo "${ECHO_T}pre-installed" >&6
11230   fi
11231 fi
11232
11233 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11234 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11235 if test "x${build}" != "x${host}" ; then
11236   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11237     # We already found the complete path
11238     echo "$as_me:$LINENO: result: pre-installed in \`dirname $RANLIB_FOR_TARGET\`" >&5
11239 echo "${ECHO_T}pre-installed in \`dirname $RANLIB_FOR_TARGET\`" >&6
11240   else
11241     # Canadian cross, just use what we found
11242     echo "$as_me:$LINENO: result: pre-installed" >&5
11243 echo "${ECHO_T}pre-installed" >&6
11244   fi
11245 else
11246   ok=yes
11247   case " ${configdirs} " in
11248     *" binutils "*) ;;
11249     *) ok=no ;;
11250   esac
11251
11252   if test $ok = yes; then
11253     # An in-tree tool is available and we can use it
11254     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11255     echo "$as_me:$LINENO: result: just compiled" >&5
11256 echo "${ECHO_T}just compiled" >&6
11257   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11258     # We already found the complete path
11259     echo "$as_me:$LINENO: result: pre-installed in \`dirname $RANLIB_FOR_TARGET\`" >&5
11260 echo "${ECHO_T}pre-installed in \`dirname $RANLIB_FOR_TARGET\`" >&6
11261   elif test "x$target" = "x$host"; then
11262     # We can use an host tool
11263     RANLIB_FOR_TARGET='$(RANLIB)'
11264     echo "$as_me:$LINENO: result: host tool" >&5
11265 echo "${ECHO_T}host tool" >&6
11266   else
11267     # We need a cross tool
11268     echo "$as_me:$LINENO: result: pre-installed" >&5
11269 echo "${ECHO_T}pre-installed" >&6
11270   fi
11271 fi
11272
11273 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11274 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11275 if test "x${build}" != "x${host}" ; then
11276   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11277     # We already found the complete path
11278     echo "$as_me:$LINENO: result: pre-installed in \`dirname $STRIP_FOR_TARGET\`" >&5
11279 echo "${ECHO_T}pre-installed in \`dirname $STRIP_FOR_TARGET\`" >&6
11280   else
11281     # Canadian cross, just use what we found
11282     echo "$as_me:$LINENO: result: pre-installed" >&5
11283 echo "${ECHO_T}pre-installed" >&6
11284   fi
11285 else
11286   ok=yes
11287   case " ${configdirs} " in
11288     *" binutils "*) ;;
11289     *) ok=no ;;
11290   esac
11291
11292   if test $ok = yes; then
11293     # An in-tree tool is available and we can use it
11294     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11295     echo "$as_me:$LINENO: result: just compiled" >&5
11296 echo "${ECHO_T}just compiled" >&6
11297   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11298     # We already found the complete path
11299     echo "$as_me:$LINENO: result: pre-installed in \`dirname $STRIP_FOR_TARGET\`" >&5
11300 echo "${ECHO_T}pre-installed in \`dirname $STRIP_FOR_TARGET\`" >&6
11301   elif test "x$target" = "x$host"; then
11302     # We can use an host tool
11303     STRIP_FOR_TARGET='$(STRIP)'
11304     echo "$as_me:$LINENO: result: host tool" >&5
11305 echo "${ECHO_T}host tool" >&6
11306   else
11307     # We need a cross tool
11308     echo "$as_me:$LINENO: result: pre-installed" >&5
11309 echo "${ECHO_T}pre-installed" >&6
11310   fi
11311 fi
11312
11313 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11314 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11315 if test "x${build}" != "x${host}" ; then
11316   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11317     # We already found the complete path
11318     echo "$as_me:$LINENO: result: pre-installed in \`dirname $WINDRES_FOR_TARGET\`" >&5
11319 echo "${ECHO_T}pre-installed in \`dirname $WINDRES_FOR_TARGET\`" >&6
11320   else
11321     # Canadian cross, just use what we found
11322     echo "$as_me:$LINENO: result: pre-installed" >&5
11323 echo "${ECHO_T}pre-installed" >&6
11324   fi
11325 else
11326   ok=yes
11327   case " ${configdirs} " in
11328     *" binutils "*) ;;
11329     *) ok=no ;;
11330   esac
11331
11332   if test $ok = yes; then
11333     # An in-tree tool is available and we can use it
11334     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11335     echo "$as_me:$LINENO: result: just compiled" >&5
11336 echo "${ECHO_T}just compiled" >&6
11337   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11338     # We already found the complete path
11339     echo "$as_me:$LINENO: result: pre-installed in \`dirname $WINDRES_FOR_TARGET\`" >&5
11340 echo "${ECHO_T}pre-installed in \`dirname $WINDRES_FOR_TARGET\`" >&6
11341   elif test "x$target" = "x$host"; then
11342     # We can use an host tool
11343     WINDRES_FOR_TARGET='$(WINDRES)'
11344     echo "$as_me:$LINENO: result: host tool" >&5
11345 echo "${ECHO_T}host tool" >&6
11346   else
11347     # We need a cross tool
11348     echo "$as_me:$LINENO: result: pre-installed" >&5
11349 echo "${ECHO_T}pre-installed" >&6
11350   fi
11351 fi
11352
11353
11354
11355
11356
11357 # Certain tools may need extra flags.
11358 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
11359 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
11360 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
11361
11362 # When building target libraries, except in a Canadian cross, we use
11363 # the same toolchain as the compiler we just built.
11364 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
11365 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
11366 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
11367 if test $host = $build; then
11368   case " $configdirs " in
11369     *" gcc "*)
11370       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
11371       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
11372       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
11373       ;;
11374   esac
11375 fi
11376
11377
11378
11379
11380
11381 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
11382 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
11383 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
11384 if test "${enable_maintainer_mode+set}" = set; then
11385   enableval="$enable_maintainer_mode"
11386   USE_MAINTAINER_MODE=$enableval
11387 else
11388   USE_MAINTAINER_MODE=no
11389 fi;
11390 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
11391 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
11392
11393
11394 if test "$USE_MAINTAINER_MODE" = yes; then
11395   MAINTAINER_MODE_TRUE=
11396   MAINTAINER_MODE_FALSE='#'
11397 else
11398   MAINTAINER_MODE_TRUE='#'
11399   MAINTAINER_MODE_FALSE=
11400 fi
11401 MAINT=$MAINTAINER_MODE_TRUE
11402
11403 # ---------------------
11404 # GCC bootstrap support
11405 # ---------------------
11406
11407 # Stage specific cflags for build.
11408 stage1_cflags="-g"
11409 case $build in
11410   vax-*-*)
11411     case ${GCC} in
11412       yes) stage1_cflags="-g -Wa,-J" ;;
11413       *) stage1_cflags="-g -J" ;;
11414     esac ;;
11415 esac
11416
11417 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
11418 if test "$GCC" = yes; then
11419   saved_CFLAGS="$CFLAGS"
11420
11421   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
11422   CFLAGS="$CFLAGS -fkeep-inline-functions"
11423   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
11424 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
11425   cat >conftest.$ac_ext <<_ACEOF
11426 /* confdefs.h.  */
11427 _ACEOF
11428 cat confdefs.h >>conftest.$ac_ext
11429 cat >>conftest.$ac_ext <<_ACEOF
11430 /* end confdefs.h.  */
11431
11432 int
11433 main ()
11434 {
11435
11436   ;
11437   return 0;
11438 }
11439 _ACEOF
11440 rm -f conftest.$ac_objext
11441 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11442   (eval $ac_compile) 2>conftest.er1
11443   ac_status=$?
11444   grep -v '^ *+' conftest.er1 >conftest.err
11445   rm -f conftest.er1
11446   cat conftest.err >&5
11447   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11448   (exit $ac_status); } &&
11449          { ac_try='test -z "$ac_c_werror_flag"
11450                          || test ! -s conftest.err'
11451   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11452   (eval $ac_try) 2>&5
11453   ac_status=$?
11454   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11455   (exit $ac_status); }; } &&
11456          { ac_try='test -s conftest.$ac_objext'
11457   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11458   (eval $ac_try) 2>&5
11459   ac_status=$?
11460   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11461   (exit $ac_status); }; }; then
11462   echo "$as_me:$LINENO: result: yes" >&5
11463 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
11464 else
11465   echo "$as_me: failed program was:" >&5
11466 sed 's/^/| /' conftest.$ac_ext >&5
11467
11468 echo "$as_me:$LINENO: result: no" >&5
11469 echo "${ECHO_T}no" >&6
11470 fi
11471 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11472
11473   CFLAGS="$saved_CFLAGS"
11474 fi
11475
11476
11477
11478 # Enable --enable-checking in stage1 of the compiler.
11479 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
11480 if test "${enable_stage1_checking+set}" = set; then
11481   enableval="$enable_stage1_checking"
11482   stage1_checking=--enable-checking=${enable_stage1_checking}
11483 else
11484   if test "x$enable_checking" = xno; then
11485   stage1_checking=--enable-checking
11486 else
11487   stage1_checking=--enable-checking${enable_checking+=}$enable_checking
11488 fi
11489 fi;
11490
11491
11492 # Enable -Werror in bootstrap stage2 and later.
11493 # Check whether --enable-werror or --disable-werror was given.
11494 if test "${enable_werror+set}" = set; then
11495   enableval="$enable_werror"
11496
11497 else
11498   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
11499   enable_werror=yes
11500 else
11501   enable_werror=no
11502 fi
11503 fi;
11504 case ${enable_werror} in
11505   yes) stage2_werror_flag="--enable-werror-always" ;;
11506   *) stage2_werror_flag="" ;;
11507 esac
11508
11509
11510 # Flags needed to enable html installing and building
11511
11512 # Check whether --with-datarootdir or --without-datarootdir was given.
11513 if test "${with_datarootdir+set}" = set; then
11514   withval="$with_datarootdir"
11515   datarootdir="\${prefix}/${withval}"
11516 else
11517   datarootdir="\${prefix}/share"
11518 fi;
11519
11520
11521 # Check whether --with-docdir or --without-docdir was given.
11522 if test "${with_docdir+set}" = set; then
11523   withval="$with_docdir"
11524   docdir="\${prefix}/${withval}"
11525 else
11526   docdir="\${datarootdir}/doc"
11527 fi;
11528
11529
11530 # Check whether --with-htmldir or --without-htmldir was given.
11531 if test "${with_htmldir+set}" = set; then
11532   withval="$with_htmldir"
11533   htmldir="\${prefix}/${withval}"
11534 else
11535   htmldir="\${docdir}"
11536 fi;
11537
11538
11539
11540
11541
11542           ac_config_files="$ac_config_files Makefile"
11543 cat >confcache <<\_ACEOF
11544 # This file is a shell script that caches the results of configure
11545 # tests run on this system so they can be shared between configure
11546 # scripts and configure runs, see configure's option --config-cache.
11547 # It is not useful on other systems.  If it contains results you don't
11548 # want to keep, you may remove or edit it.
11549 #
11550 # config.status only pays attention to the cache file if you give it
11551 # the --recheck option to rerun configure.
11552 #
11553 # `ac_cv_env_foo' variables (set or unset) will be overridden when
11554 # loading this file, other *unset* `ac_cv_foo' will be assigned the
11555 # following values.
11556
11557 _ACEOF
11558
11559 # The following way of writing the cache mishandles newlines in values,
11560 # but we know of no workaround that is simple, portable, and efficient.
11561 # So, don't put newlines in cache variables' values.
11562 # Ultrix sh set writes to stderr and can't be redirected directly,
11563 # and sets the high bit in the cache file unless we assign to the vars.
11564 {
11565   (set) 2>&1 |
11566     case `(ac_space=' '; set | grep ac_space) 2>&1` in
11567     *ac_space=\ *)
11568       # `set' does not quote correctly, so add quotes (double-quote
11569       # substitution turns \\\\ into \\, and sed turns \\ into \).
11570       sed -n \
11571         "s/'/'\\\\''/g;
11572           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
11573       ;;
11574     *)
11575       # `set' quotes correctly as required by POSIX, so do not add quotes.
11576       sed -n \
11577         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
11578       ;;
11579     esac;
11580 } |
11581   sed '
11582      t clear
11583      : clear
11584      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
11585      t end
11586      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
11587      : end' >>confcache
11588 if diff $cache_file confcache >/dev/null 2>&1; then :; else
11589   if test -w $cache_file; then
11590     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
11591     cat confcache >$cache_file
11592   else
11593     echo "not updating unwritable cache $cache_file"
11594   fi
11595 fi
11596 rm -f confcache
11597
11598 test "x$prefix" = xNONE && prefix=$ac_default_prefix
11599 # Let make expand exec_prefix.
11600 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
11601
11602 # VPATH may cause trouble with some makes, so we remove $(srcdir),
11603 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
11604 # trailing colons and then remove the whole line if VPATH becomes empty
11605 # (actually we leave an empty line to preserve line numbers).
11606 if test "x$srcdir" = x.; then
11607   ac_vpsub='/^[  ]*VPATH[        ]*=/{
11608 s/:*\$(srcdir):*/:/;
11609 s/:*\${srcdir}:*/:/;
11610 s/:*@srcdir@:*/:/;
11611 s/^\([^=]*=[     ]*\):*/\1/;
11612 s/:*$//;
11613 s/^[^=]*=[       ]*$//;
11614 }'
11615 fi
11616
11617 # Transform confdefs.h into DEFS.
11618 # Protect against shell expansion while executing Makefile rules.
11619 # Protect against Makefile macro expansion.
11620 #
11621 # If the first sed substitution is executed (which looks for macros that
11622 # take arguments), then we branch to the quote section.  Otherwise,
11623 # look for a macro that doesn't take arguments.
11624 cat >confdef2opt.sed <<\_ACEOF
11625 t clear
11626 : clear
11627 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
11628 t quote
11629 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
11630 t quote
11631 d
11632 : quote
11633 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
11634 s,\[,\\&,g
11635 s,\],\\&,g
11636 s,\$,$$,g
11637 p
11638 _ACEOF
11639 # We use echo to avoid assuming a particular line-breaking character.
11640 # The extra dot is to prevent the shell from consuming trailing
11641 # line-breaks from the sub-command output.  A line-break within
11642 # single-quotes doesn't work because, if this script is created in a
11643 # platform that uses two characters for line-breaks (e.g., DOS), tr
11644 # would break.
11645 ac_LF_and_DOT=`echo; echo .`
11646 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
11647 rm -f confdef2opt.sed
11648
11649
11650 ac_libobjs=
11651 ac_ltlibobjs=
11652 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
11653   # 1. Remove the extension, and $U if already installed.
11654   ac_i=`echo "$ac_i" |
11655          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
11656   # 2. Add them.
11657   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
11658   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
11659 done
11660 LIBOBJS=$ac_libobjs
11661
11662 LTLIBOBJS=$ac_ltlibobjs
11663
11664
11665
11666 : ${CONFIG_STATUS=./config.status}
11667 ac_clean_files_save=$ac_clean_files
11668 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
11669 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
11670 echo "$as_me: creating $CONFIG_STATUS" >&6;}
11671 cat >$CONFIG_STATUS <<_ACEOF
11672 #! $SHELL
11673 # Generated by $as_me.
11674 # Run this file to recreate the current configuration.
11675 # Compiler output produced by configure, useful for debugging
11676 # configure, is in config.log if it exists.
11677
11678 debug=false
11679 ac_cs_recheck=false
11680 ac_cs_silent=false
11681 SHELL=\${CONFIG_SHELL-$SHELL}
11682 _ACEOF
11683
11684 cat >>$CONFIG_STATUS <<\_ACEOF
11685 ## --------------------- ##
11686 ## M4sh Initialization.  ##
11687 ## --------------------- ##
11688
11689 # Be Bourne compatible
11690 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
11691   emulate sh
11692   NULLCMD=:
11693   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
11694   # is contrary to our usage.  Disable this feature.
11695   alias -g '${1+"$@"}'='"$@"'
11696 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
11697   set -o posix
11698 fi
11699 DUALCASE=1; export DUALCASE # for MKS sh
11700
11701 # Support unset when possible.
11702 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
11703   as_unset=unset
11704 else
11705   as_unset=false
11706 fi
11707
11708
11709 # Work around bugs in pre-3.0 UWIN ksh.
11710 $as_unset ENV MAIL MAILPATH
11711 PS1='$ '
11712 PS2='> '
11713 PS4='+ '
11714
11715 # NLS nuisances.
11716 for as_var in \
11717   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
11718   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
11719   LC_TELEPHONE LC_TIME
11720 do
11721   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
11722     eval $as_var=C; export $as_var
11723   else
11724     $as_unset $as_var
11725   fi
11726 done
11727
11728 # Required to use basename.
11729 if expr a : '\(a\)' >/dev/null 2>&1; then
11730   as_expr=expr
11731 else
11732   as_expr=false
11733 fi
11734
11735 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
11736   as_basename=basename
11737 else
11738   as_basename=false
11739 fi
11740
11741
11742 # Name of the executable.
11743 as_me=`$as_basename "$0" ||
11744 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
11745          X"$0" : 'X\(//\)$' \| \
11746          X"$0" : 'X\(/\)$' \| \
11747          .     : '\(.\)' 2>/dev/null ||
11748 echo X/"$0" |
11749     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
11750           /^X\/\(\/\/\)$/{ s//\1/; q; }
11751           /^X\/\(\/\).*/{ s//\1/; q; }
11752           s/.*/./; q'`
11753
11754
11755 # PATH needs CR, and LINENO needs CR and PATH.
11756 # Avoid depending upon Character Ranges.
11757 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
11758 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
11759 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
11760 as_cr_digits='0123456789'
11761 as_cr_alnum=$as_cr_Letters$as_cr_digits
11762
11763 # The user is always right.
11764 if test "${PATH_SEPARATOR+set}" != set; then
11765   echo "#! /bin/sh" >conf$$.sh
11766   echo  "exit 0"   >>conf$$.sh
11767   chmod +x conf$$.sh
11768   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
11769     PATH_SEPARATOR=';'
11770   else
11771     PATH_SEPARATOR=:
11772   fi
11773   rm -f conf$$.sh
11774 fi
11775
11776
11777   as_lineno_1=$LINENO
11778   as_lineno_2=$LINENO
11779   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
11780   test "x$as_lineno_1" != "x$as_lineno_2" &&
11781   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
11782   # Find who we are.  Look in the path if we contain no path at all
11783   # relative or not.
11784   case $0 in
11785     *[\\/]* ) as_myself=$0 ;;
11786     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11787 for as_dir in $PATH
11788 do
11789   IFS=$as_save_IFS
11790   test -z "$as_dir" && as_dir=.
11791   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
11792 done
11793
11794        ;;
11795   esac
11796   # We did not find ourselves, most probably we were run as `sh COMMAND'
11797   # in which case we are not to be found in the path.
11798   if test "x$as_myself" = x; then
11799     as_myself=$0
11800   fi
11801   if test ! -f "$as_myself"; then
11802     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
11803 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
11804    { (exit 1); exit 1; }; }
11805   fi
11806   case $CONFIG_SHELL in
11807   '')
11808     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11809 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
11810 do
11811   IFS=$as_save_IFS
11812   test -z "$as_dir" && as_dir=.
11813   for as_base in sh bash ksh sh5; do
11814          case $as_dir in
11815          /*)
11816            if ("$as_dir/$as_base" -c '
11817   as_lineno_1=$LINENO
11818   as_lineno_2=$LINENO
11819   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
11820   test "x$as_lineno_1" != "x$as_lineno_2" &&
11821   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
11822              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
11823              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
11824              CONFIG_SHELL=$as_dir/$as_base
11825              export CONFIG_SHELL
11826              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
11827            fi;;
11828          esac
11829        done
11830 done
11831 ;;
11832   esac
11833
11834   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
11835   # uniformly replaced by the line number.  The first 'sed' inserts a
11836   # line-number line before each line; the second 'sed' does the real
11837   # work.  The second script uses 'N' to pair each line-number line
11838   # with the numbered line, and appends trailing '-' during
11839   # substitution so that $LINENO is not a special case at line end.
11840   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
11841   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
11842   sed '=' <$as_myself |
11843     sed '
11844       N
11845       s,$,-,
11846       : loop
11847       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
11848       t loop
11849       s,-$,,
11850       s,^['$as_cr_digits']*\n,,
11851     ' >$as_me.lineno &&
11852   chmod +x $as_me.lineno ||
11853     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
11854 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
11855    { (exit 1); exit 1; }; }
11856
11857   # Don't try to exec as it changes $[0], causing all sort of problems
11858   # (the dirname of $[0] is not the place where we might find the
11859   # original and so on.  Autoconf is especially sensible to this).
11860   . ./$as_me.lineno
11861   # Exit status is that of the last command.
11862   exit
11863 }
11864
11865
11866 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
11867   *c*,-n*) ECHO_N= ECHO_C='
11868 ' ECHO_T='      ' ;;
11869   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
11870   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
11871 esac
11872
11873 if expr a : '\(a\)' >/dev/null 2>&1; then
11874   as_expr=expr
11875 else
11876   as_expr=false
11877 fi
11878
11879 rm -f conf$$ conf$$.exe conf$$.file
11880 echo >conf$$.file
11881 if ln -s conf$$.file conf$$ 2>/dev/null; then
11882   # We could just check for DJGPP; but this test a) works b) is more generic
11883   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
11884   if test -f conf$$.exe; then
11885     # Don't use ln at all; we don't have any links
11886     as_ln_s='cp -p'
11887   else
11888     as_ln_s='ln -s'
11889   fi
11890 elif ln conf$$.file conf$$ 2>/dev/null; then
11891   as_ln_s=ln
11892 else
11893   as_ln_s='cp -p'
11894 fi
11895 rm -f conf$$ conf$$.exe conf$$.file
11896
11897 if mkdir -p . 2>/dev/null; then
11898   as_mkdir_p=:
11899 else
11900   test -d ./-p && rmdir ./-p
11901   as_mkdir_p=false
11902 fi
11903
11904 as_executable_p="test -f"
11905
11906 # Sed expression to map a string onto a valid CPP name.
11907 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
11908
11909 # Sed expression to map a string onto a valid variable name.
11910 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
11911
11912
11913 # IFS
11914 # We need space, tab and new line, in precisely that order.
11915 as_nl='
11916 '
11917 IFS="   $as_nl"
11918
11919 # CDPATH.
11920 $as_unset CDPATH
11921
11922 exec 6>&1
11923
11924 # Open the log real soon, to keep \$[0] and so on meaningful, and to
11925 # report actual input values of CONFIG_FILES etc. instead of their
11926 # values after options handling.  Logging --version etc. is OK.
11927 exec 5>>config.log
11928 {
11929   echo
11930   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
11931 ## Running $as_me. ##
11932 _ASBOX
11933 } >&5
11934 cat >&5 <<_CSEOF
11935
11936 This file was extended by $as_me, which was
11937 generated by GNU Autoconf 2.59.  Invocation command line was
11938
11939   CONFIG_FILES    = $CONFIG_FILES
11940   CONFIG_HEADERS  = $CONFIG_HEADERS
11941   CONFIG_LINKS    = $CONFIG_LINKS
11942   CONFIG_COMMANDS = $CONFIG_COMMANDS
11943   $ $0 $@
11944
11945 _CSEOF
11946 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
11947 echo >&5
11948 _ACEOF
11949
11950 # Files that config.status was made for.
11951 if test -n "$ac_config_files"; then
11952   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
11953 fi
11954
11955 if test -n "$ac_config_headers"; then
11956   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
11957 fi
11958
11959 if test -n "$ac_config_links"; then
11960   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
11961 fi
11962
11963 if test -n "$ac_config_commands"; then
11964   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
11965 fi
11966
11967 cat >>$CONFIG_STATUS <<\_ACEOF
11968
11969 ac_cs_usage="\
11970 \`$as_me' instantiates files from templates according to the
11971 current configuration.
11972
11973 Usage: $0 [OPTIONS] [FILE]...
11974
11975   -h, --help       print this help, then exit
11976   -V, --version    print version number, then exit
11977   -q, --quiet      do not print progress messages
11978   -d, --debug      don't remove temporary files
11979       --recheck    update $as_me by reconfiguring in the same conditions
11980   --file=FILE[:TEMPLATE]
11981                    instantiate the configuration file FILE
11982
11983 Configuration files:
11984 $config_files
11985
11986 Report bugs to <bug-autoconf@gnu.org>."
11987 _ACEOF
11988
11989 cat >>$CONFIG_STATUS <<_ACEOF
11990 ac_cs_version="\\
11991 config.status
11992 configured by $0, generated by GNU Autoconf 2.59,
11993   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
11994
11995 Copyright (C) 2003 Free Software Foundation, Inc.
11996 This config.status script is free software; the Free Software Foundation
11997 gives unlimited permission to copy, distribute and modify it."
11998 srcdir=$srcdir
11999 INSTALL="$INSTALL"
12000 _ACEOF
12001
12002 cat >>$CONFIG_STATUS <<\_ACEOF
12003 # If no file are specified by the user, then we need to provide default
12004 # value.  By we need to know if files were specified by the user.
12005 ac_need_defaults=:
12006 while test $# != 0
12007 do
12008   case $1 in
12009   --*=*)
12010     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12011     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12012     ac_shift=:
12013     ;;
12014   -*)
12015     ac_option=$1
12016     ac_optarg=$2
12017     ac_shift=shift
12018     ;;
12019   *) # This is not an option, so the user has probably given explicit
12020      # arguments.
12021      ac_option=$1
12022      ac_need_defaults=false;;
12023   esac
12024
12025   case $ac_option in
12026   # Handling of the options.
12027 _ACEOF
12028 cat >>$CONFIG_STATUS <<\_ACEOF
12029   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12030     ac_cs_recheck=: ;;
12031   --version | --vers* | -V )
12032     echo "$ac_cs_version"; exit 0 ;;
12033   --he | --h)
12034     # Conflict between --help and --header
12035     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12036 Try \`$0 --help' for more information." >&5
12037 echo "$as_me: error: ambiguous option: $1
12038 Try \`$0 --help' for more information." >&2;}
12039    { (exit 1); exit 1; }; };;
12040   --help | --hel | -h )
12041     echo "$ac_cs_usage"; exit 0 ;;
12042   --debug | --d* | -d )
12043     debug=: ;;
12044   --file | --fil | --fi | --f )
12045     $ac_shift
12046     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12047     ac_need_defaults=false;;
12048   --header | --heade | --head | --hea )
12049     $ac_shift
12050     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12051     ac_need_defaults=false;;
12052   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12053   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12054     ac_cs_silent=: ;;
12055
12056   # This is an error.
12057   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12058 Try \`$0 --help' for more information." >&5
12059 echo "$as_me: error: unrecognized option: $1
12060 Try \`$0 --help' for more information." >&2;}
12061    { (exit 1); exit 1; }; } ;;
12062
12063   *) ac_config_targets="$ac_config_targets $1" ;;
12064
12065   esac
12066   shift
12067 done
12068
12069 ac_configure_extra_args=
12070
12071 if $ac_cs_silent; then
12072   exec 6>/dev/null
12073   ac_configure_extra_args="$ac_configure_extra_args --silent"
12074 fi
12075
12076 _ACEOF
12077 cat >>$CONFIG_STATUS <<_ACEOF
12078 if \$ac_cs_recheck; then
12079   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12080   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12081 fi
12082
12083 _ACEOF
12084
12085
12086
12087
12088
12089 cat >>$CONFIG_STATUS <<\_ACEOF
12090 for ac_config_target in $ac_config_targets
12091 do
12092   case "$ac_config_target" in
12093   # Handling of arguments.
12094   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12095   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12096 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12097    { (exit 1); exit 1; }; };;
12098   esac
12099 done
12100
12101 # If the user did not use the arguments to specify the items to instantiate,
12102 # then the envvar interface is used.  Set only those that are not.
12103 # We use the long form for the default assignment because of an extremely
12104 # bizarre bug on SunOS 4.1.3.
12105 if $ac_need_defaults; then
12106   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12107 fi
12108
12109 # Have a temporary directory for convenience.  Make it in the build tree
12110 # simply because there is no reason to put it here, and in addition,
12111 # creating and moving files from /tmp can sometimes cause problems.
12112 # Create a temporary directory, and hook for its removal unless debugging.
12113 $debug ||
12114 {
12115   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12116   trap '{ (exit 1); exit 1; }' 1 2 13 15
12117 }
12118
12119 # Create a (secure) tmp directory for tmp files.
12120
12121 {
12122   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12123   test -n "$tmp" && test -d "$tmp"
12124 }  ||
12125 {
12126   tmp=./confstat$$-$RANDOM
12127   (umask 077 && mkdir $tmp)
12128 } ||
12129 {
12130    echo "$me: cannot create a temporary directory in ." >&2
12131    { (exit 1); exit 1; }
12132 }
12133
12134 _ACEOF
12135
12136 cat >>$CONFIG_STATUS <<_ACEOF
12137
12138 #
12139 # CONFIG_FILES section.
12140 #
12141
12142 # No need to generate the scripts if there are no CONFIG_FILES.
12143 # This happens for instance when ./config.status config.h
12144 if test -n "\$CONFIG_FILES"; then
12145   # Protect against being on the right side of a sed subst in config.status.
12146   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12147    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12148 s,@SHELL@,$SHELL,;t t
12149 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12150 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12151 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12152 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12153 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12154 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12155 s,@exec_prefix@,$exec_prefix,;t t
12156 s,@prefix@,$prefix,;t t
12157 s,@program_transform_name@,$program_transform_name,;t t
12158 s,@bindir@,$bindir,;t t
12159 s,@sbindir@,$sbindir,;t t
12160 s,@libexecdir@,$libexecdir,;t t
12161 s,@datadir@,$datadir,;t t
12162 s,@sysconfdir@,$sysconfdir,;t t
12163 s,@sharedstatedir@,$sharedstatedir,;t t
12164 s,@localstatedir@,$localstatedir,;t t
12165 s,@libdir@,$libdir,;t t
12166 s,@includedir@,$includedir,;t t
12167 s,@oldincludedir@,$oldincludedir,;t t
12168 s,@infodir@,$infodir,;t t
12169 s,@mandir@,$mandir,;t t
12170 s,@build_alias@,$build_alias,;t t
12171 s,@host_alias@,$host_alias,;t t
12172 s,@target_alias@,$target_alias,;t t
12173 s,@DEFS@,$DEFS,;t t
12174 s,@ECHO_C@,$ECHO_C,;t t
12175 s,@ECHO_N@,$ECHO_N,;t t
12176 s,@ECHO_T@,$ECHO_T,;t t
12177 s,@LIBS@,$LIBS,;t t
12178 s,@build@,$build,;t t
12179 s,@build_cpu@,$build_cpu,;t t
12180 s,@build_vendor@,$build_vendor,;t t
12181 s,@build_os@,$build_os,;t t
12182 s,@build_noncanonical@,$build_noncanonical,;t t
12183 s,@host_noncanonical@,$host_noncanonical,;t t
12184 s,@target_noncanonical@,$target_noncanonical,;t t
12185 s,@host@,$host,;t t
12186 s,@host_cpu@,$host_cpu,;t t
12187 s,@host_vendor@,$host_vendor,;t t
12188 s,@host_os@,$host_os,;t t
12189 s,@target@,$target,;t t
12190 s,@target_cpu@,$target_cpu,;t t
12191 s,@target_vendor@,$target_vendor,;t t
12192 s,@target_os@,$target_os,;t t
12193 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12194 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12195 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12196 s,@LN@,$LN,;t t
12197 s,@LN_S@,$LN_S,;t t
12198 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12199 s,@build_libsubdir@,$build_libsubdir,;t t
12200 s,@build_subdir@,$build_subdir,;t t
12201 s,@host_subdir@,$host_subdir,;t t
12202 s,@target_subdir@,$target_subdir,;t t
12203 s,@CC@,$CC,;t t
12204 s,@CFLAGS@,$CFLAGS,;t t
12205 s,@LDFLAGS@,$LDFLAGS,;t t
12206 s,@CPPFLAGS@,$CPPFLAGS,;t t
12207 s,@ac_ct_CC@,$ac_ct_CC,;t t
12208 s,@EXEEXT@,$EXEEXT,;t t
12209 s,@OBJEXT@,$OBJEXT,;t t
12210 s,@CXX@,$CXX,;t t
12211 s,@CXXFLAGS@,$CXXFLAGS,;t t
12212 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12213 s,@GNATBIND@,$GNATBIND,;t t
12214 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12215 s,@GNATMAKE@,$GNATMAKE,;t t
12216 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12217 s,@do_compare@,$do_compare,;t t
12218 s,@gmplibs@,$gmplibs,;t t
12219 s,@gmpinc@,$gmpinc,;t t
12220 s,@stage1_languages@,$stage1_languages,;t t
12221 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12222 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12223 s,@tooldir@,$tooldir,;t t
12224 s,@build_tooldir@,$build_tooldir,;t t
12225 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12226 s,@GDB_TK@,$GDB_TK,;t t
12227 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12228 s,@build_configargs@,$build_configargs,;t t
12229 s,@build_configdirs@,$build_configdirs,;t t
12230 s,@host_configargs@,$host_configargs,;t t
12231 s,@configdirs@,$configdirs,;t t
12232 s,@target_configargs@,$target_configargs,;t t
12233 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12234 s,@config_shell@,$config_shell,;t t
12235 s,@YACC@,$YACC,;t t
12236 s,@BISON@,$BISON,;t t
12237 s,@M4@,$M4,;t t
12238 s,@LEX@,$LEX,;t t
12239 s,@FLEX@,$FLEX,;t t
12240 s,@MAKEINFO@,$MAKEINFO,;t t
12241 s,@EXPECT@,$EXPECT,;t t
12242 s,@RUNTEST@,$RUNTEST,;t t
12243 s,@AR@,$AR,;t t
12244 s,@AS@,$AS,;t t
12245 s,@DLLTOOL@,$DLLTOOL,;t t
12246 s,@LD@,$LD,;t t
12247 s,@LIPO@,$LIPO,;t t
12248 s,@NM@,$NM,;t t
12249 s,@RANLIB@,$RANLIB,;t t
12250 s,@STRIP@,$STRIP,;t t
12251 s,@WINDRES@,$WINDRES,;t t
12252 s,@OBJCOPY@,$OBJCOPY,;t t
12253 s,@OBJDUMP@,$OBJDUMP,;t t
12254 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12255 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12256 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12257 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12258 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12259 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12260 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12261 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12262 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12263 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12264 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12265 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12266 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12267 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12268 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12269 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12270 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12271 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12272 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12273 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12274 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12275 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12276 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12277 s,@MAINT@,$MAINT,;t t
12278 s,@stage1_cflags@,$stage1_cflags,;t t
12279 s,@stage1_checking@,$stage1_checking,;t t
12280 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12281 s,@datarootdir@,$datarootdir,;t t
12282 s,@docdir@,$docdir,;t t
12283 s,@htmldir@,$htmldir,;t t
12284 s,@LIBOBJS@,$LIBOBJS,;t t
12285 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12286 /@serialization_dependencies@/r $serialization_dependencies
12287 s,@serialization_dependencies@,,;t t
12288 /@host_makefile_frag@/r $host_makefile_frag
12289 s,@host_makefile_frag@,,;t t
12290 /@target_makefile_frag@/r $target_makefile_frag
12291 s,@target_makefile_frag@,,;t t
12292 /@alphaieee_frag@/r $alphaieee_frag
12293 s,@alphaieee_frag@,,;t t
12294 /@ospace_frag@/r $ospace_frag
12295 s,@ospace_frag@,,;t t
12296 CEOF
12297
12298 _ACEOF
12299
12300   cat >>$CONFIG_STATUS <<\_ACEOF
12301   # Split the substitutions into bite-sized pieces for seds with
12302   # small command number limits, like on Digital OSF/1 and HP-UX.
12303   ac_max_sed_lines=48
12304   ac_sed_frag=1 # Number of current file.
12305   ac_beg=1 # First line for current file.
12306   ac_end=$ac_max_sed_lines # Line after last line for current file.
12307   ac_more_lines=:
12308   ac_sed_cmds=
12309   while $ac_more_lines; do
12310     if test $ac_beg -gt 1; then
12311       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12312     else
12313       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12314     fi
12315     if test ! -s $tmp/subs.frag; then
12316       ac_more_lines=false
12317     else
12318       # The purpose of the label and of the branching condition is to
12319       # speed up the sed processing (if there are no `@' at all, there
12320       # is no need to browse any of the substitutions).
12321       # These are the two extra sed commands mentioned above.
12322       (echo ':t
12323   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
12324       if test -z "$ac_sed_cmds"; then
12325         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
12326       else
12327         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
12328       fi
12329       ac_sed_frag=`expr $ac_sed_frag + 1`
12330       ac_beg=$ac_end
12331       ac_end=`expr $ac_end + $ac_max_sed_lines`
12332     fi
12333   done
12334   if test -z "$ac_sed_cmds"; then
12335     ac_sed_cmds=cat
12336   fi
12337 fi # test -n "$CONFIG_FILES"
12338
12339 _ACEOF
12340 cat >>$CONFIG_STATUS <<\_ACEOF
12341 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
12342   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
12343   case $ac_file in
12344   - | *:- | *:-:* ) # input from stdin
12345         cat >$tmp/stdin
12346         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12347         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12348   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12349         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12350   * )   ac_file_in=$ac_file.in ;;
12351   esac
12352
12353   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
12354   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
12355 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12356          X"$ac_file" : 'X\(//\)[^/]' \| \
12357          X"$ac_file" : 'X\(//\)$' \| \
12358          X"$ac_file" : 'X\(/\)' \| \
12359          .     : '\(.\)' 2>/dev/null ||
12360 echo X"$ac_file" |
12361     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12362           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12363           /^X\(\/\/\)$/{ s//\1/; q; }
12364           /^X\(\/\).*/{ s//\1/; q; }
12365           s/.*/./; q'`
12366   { if $as_mkdir_p; then
12367     mkdir -p "$ac_dir"
12368   else
12369     as_dir="$ac_dir"
12370     as_dirs=
12371     while test ! -d "$as_dir"; do
12372       as_dirs="$as_dir $as_dirs"
12373       as_dir=`(dirname "$as_dir") 2>/dev/null ||
12374 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12375          X"$as_dir" : 'X\(//\)[^/]' \| \
12376          X"$as_dir" : 'X\(//\)$' \| \
12377          X"$as_dir" : 'X\(/\)' \| \
12378          .     : '\(.\)' 2>/dev/null ||
12379 echo X"$as_dir" |
12380     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12381           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12382           /^X\(\/\/\)$/{ s//\1/; q; }
12383           /^X\(\/\).*/{ s//\1/; q; }
12384           s/.*/./; q'`
12385     done
12386     test ! -n "$as_dirs" || mkdir $as_dirs
12387   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
12388 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
12389    { (exit 1); exit 1; }; }; }
12390
12391   ac_builddir=.
12392
12393 if test "$ac_dir" != .; then
12394   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
12395   # A "../" for each directory in $ac_dir_suffix.
12396   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
12397 else
12398   ac_dir_suffix= ac_top_builddir=
12399 fi
12400
12401 case $srcdir in
12402   .)  # No --srcdir option.  We are building in place.
12403     ac_srcdir=.
12404     if test -z "$ac_top_builddir"; then
12405        ac_top_srcdir=.
12406     else
12407        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
12408     fi ;;
12409   [\\/]* | ?:[\\/]* )  # Absolute path.
12410     ac_srcdir=$srcdir$ac_dir_suffix;
12411     ac_top_srcdir=$srcdir ;;
12412   *) # Relative path.
12413     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
12414     ac_top_srcdir=$ac_top_builddir$srcdir ;;
12415 esac
12416
12417 # Do not use `cd foo && pwd` to compute absolute paths, because
12418 # the directories may not exist.
12419 case `pwd` in
12420 .) ac_abs_builddir="$ac_dir";;
12421 *)
12422   case "$ac_dir" in
12423   .) ac_abs_builddir=`pwd`;;
12424   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
12425   *) ac_abs_builddir=`pwd`/"$ac_dir";;
12426   esac;;
12427 esac
12428 case $ac_abs_builddir in
12429 .) ac_abs_top_builddir=${ac_top_builddir}.;;
12430 *)
12431   case ${ac_top_builddir}. in
12432   .) ac_abs_top_builddir=$ac_abs_builddir;;
12433   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
12434   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
12435   esac;;
12436 esac
12437 case $ac_abs_builddir in
12438 .) ac_abs_srcdir=$ac_srcdir;;
12439 *)
12440   case $ac_srcdir in
12441   .) ac_abs_srcdir=$ac_abs_builddir;;
12442   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
12443   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
12444   esac;;
12445 esac
12446 case $ac_abs_builddir in
12447 .) ac_abs_top_srcdir=$ac_top_srcdir;;
12448 *)
12449   case $ac_top_srcdir in
12450   .) ac_abs_top_srcdir=$ac_abs_builddir;;
12451   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
12452   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
12453   esac;;
12454 esac
12455
12456
12457   case $INSTALL in
12458   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
12459   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
12460   esac
12461
12462   if test x"$ac_file" != x-; then
12463     { echo "$as_me:$LINENO: creating $ac_file" >&5
12464 echo "$as_me: creating $ac_file" >&6;}
12465     rm -f "$ac_file"
12466   fi
12467   # Let's still pretend it is `configure' which instantiates (i.e., don't
12468   # use $as_me), people would be surprised to read:
12469   #    /* config.h.  Generated by config.status.  */
12470   if test x"$ac_file" = x-; then
12471     configure_input=
12472   else
12473     configure_input="$ac_file.  "
12474   fi
12475   configure_input=$configure_input"Generated from `echo $ac_file_in |
12476                                      sed 's,.*/,,'` by configure."
12477
12478   # First look for the input files in the build tree, otherwise in the
12479   # src tree.
12480   ac_file_inputs=`IFS=:
12481     for f in $ac_file_in; do
12482       case $f in
12483       -) echo $tmp/stdin ;;
12484       [\\/$]*)
12485          # Absolute (can't be DOS-style, as IFS=:)
12486          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
12487 echo "$as_me: error: cannot find input file: $f" >&2;}
12488    { (exit 1); exit 1; }; }
12489          echo "$f";;
12490       *) # Relative
12491          if test -f "$f"; then
12492            # Build tree
12493            echo "$f"
12494          elif test -f "$srcdir/$f"; then
12495            # Source tree
12496            echo "$srcdir/$f"
12497          else
12498            # /dev/null tree
12499            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
12500 echo "$as_me: error: cannot find input file: $f" >&2;}
12501    { (exit 1); exit 1; }; }
12502          fi;;
12503       esac
12504     done` || { (exit 1); exit 1; }
12505 _ACEOF
12506 cat >>$CONFIG_STATUS <<_ACEOF
12507   sed "$ac_vpsub
12508 $extrasub
12509 _ACEOF
12510 cat >>$CONFIG_STATUS <<\_ACEOF
12511 :t
12512 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
12513 s,@configure_input@,$configure_input,;t t
12514 s,@srcdir@,$ac_srcdir,;t t
12515 s,@abs_srcdir@,$ac_abs_srcdir,;t t
12516 s,@top_srcdir@,$ac_top_srcdir,;t t
12517 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
12518 s,@builddir@,$ac_builddir,;t t
12519 s,@abs_builddir@,$ac_abs_builddir,;t t
12520 s,@top_builddir@,$ac_top_builddir,;t t
12521 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
12522 s,@INSTALL@,$ac_INSTALL,;t t
12523 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
12524   rm -f $tmp/stdin
12525   if test x"$ac_file" != x-; then
12526     mv $tmp/out $ac_file
12527   else
12528     cat $tmp/out
12529     rm -f $tmp/out
12530   fi
12531
12532 done
12533 _ACEOF
12534
12535 cat >>$CONFIG_STATUS <<\_ACEOF
12536
12537 { (exit 0); exit 0; }
12538 _ACEOF
12539 chmod +x $CONFIG_STATUS
12540 ac_clean_files=$ac_clean_files_save
12541
12542
12543 # configure is writing to config.log, and then calls config.status.
12544 # config.status does its own redirection, appending to config.log.
12545 # Unfortunately, on DOS this fails, as config.log is still kept open
12546 # by configure, so config.status won't be able to write to it; its
12547 # output is simply discarded.  So we exec the FD to /dev/null,
12548 # effectively closing config.log, so it can be properly (re)opened and
12549 # appended to by config.status.  When coming back to configure, we
12550 # need to make the FD available again.
12551 if test "$no_create" != yes; then
12552   ac_cs_success=:
12553   ac_config_status_args=
12554   test "$silent" = yes &&
12555     ac_config_status_args="$ac_config_status_args --quiet"
12556   exec 5>/dev/null
12557   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
12558   exec 5>>config.log
12559   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
12560   # would make configure fail if this is the last instruction.
12561   $ac_cs_success || { (exit 1); exit 1; }
12562 fi
12563