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;
4480     mpfr_t x;
4481     int t;
4482     mpfr_init (n);
4483     mpfr_init (x);
4484     mpfr_atan2 (n, n, x, GMP_RNDN);
4485     mpfr_erfc (n, x, GMP_RNDN);
4486     mpfr_subnormalize (x, t, GMP_RNDN);
4487
4488   ;
4489   return 0;
4490 }
4491 _ACEOF
4492 rm -f conftest.$ac_objext conftest$ac_exeext
4493 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4494   (eval $ac_link) 2>conftest.er1
4495   ac_status=$?
4496   grep -v '^ *+' conftest.er1 >conftest.err
4497   rm -f conftest.er1
4498   cat conftest.err >&5
4499   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4500   (exit $ac_status); } &&
4501          { ac_try='test -z "$ac_c_werror_flag"
4502                          || test ! -s conftest.err'
4503   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4504   (eval $ac_try) 2>&5
4505   ac_status=$?
4506   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4507   (exit $ac_status); }; } &&
4508          { ac_try='test -s conftest$ac_exeext'
4509   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4510   (eval $ac_try) 2>&5
4511   ac_status=$?
4512   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4513   (exit $ac_status); }; }; then
4514   cat >conftest.$ac_ext <<_ACEOF
4515 /* confdefs.h.  */
4516 _ACEOF
4517 cat confdefs.h >>conftest.$ac_ext
4518 cat >>conftest.$ac_ext <<_ACEOF
4519 /* end confdefs.h.  */
4520 #include <gmp.h>
4521     #include <mpfr.h>
4522 int
4523 main ()
4524 {
4525
4526     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4527     choke me
4528     #endif
4529     mpfr_t n; mpfr_init(n);
4530
4531   ;
4532   return 0;
4533 }
4534 _ACEOF
4535 rm -f conftest.$ac_objext conftest$ac_exeext
4536 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4537   (eval $ac_link) 2>conftest.er1
4538   ac_status=$?
4539   grep -v '^ *+' conftest.er1 >conftest.err
4540   rm -f conftest.er1
4541   cat conftest.err >&5
4542   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4543   (exit $ac_status); } &&
4544          { ac_try='test -z "$ac_c_werror_flag"
4545                          || test ! -s conftest.err'
4546   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4547   (eval $ac_try) 2>&5
4548   ac_status=$?
4549   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4550   (exit $ac_status); }; } &&
4551          { ac_try='test -s conftest$ac_exeext'
4552   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4553   (eval $ac_try) 2>&5
4554   ac_status=$?
4555   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4556   (exit $ac_status); }; }; then
4557   echo "$as_me:$LINENO: result: yes" >&5
4558 echo "${ECHO_T}yes" >&6
4559 else
4560   echo "$as_me: failed program was:" >&5
4561 sed 's/^/| /' conftest.$ac_ext >&5
4562
4563 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4564 echo "${ECHO_T}buggy but acceptable" >&6
4565 fi
4566 rm -f conftest.err conftest.$ac_objext \
4567       conftest$ac_exeext conftest.$ac_ext
4568 else
4569   echo "$as_me: failed program was:" >&5
4570 sed 's/^/| /' conftest.$ac_ext >&5
4571
4572 echo "$as_me:$LINENO: result: no" >&5
4573 echo "${ECHO_T}no" >&6; have_gmp=no
4574 fi
4575 rm -f conftest.err conftest.$ac_objext \
4576       conftest$ac_exeext conftest.$ac_ext
4577       LIBS="$saved_LIBS"
4578   fi
4579   CFLAGS="$saved_CFLAGS"
4580
4581   if test x$have_gmp != xyes; then
4582     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4583 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4584 Copies of these libraries' source code can be found at their respective
4585 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4586 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4587 If you obtained GMP and/or MPFR from a vendor distribution package, make
4588 sure that you have installed both the libraries and the header files.
4589 They may be located in separate packages." >&5
4590 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4591 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4592 Copies of these libraries' source code can be found at their respective
4593 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4594 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4595 If you obtained GMP and/or MPFR from a vendor distribution package, make
4596 sure that you have installed both the libraries and the header files.
4597 They may be located in separate packages." >&2;}
4598    { (exit 1); exit 1; }; }
4599   fi
4600 fi
4601
4602 # Flags needed for both GMP and/or MPFR
4603
4604
4605
4606 # By default, C is the only stage 1 language.
4607 stage1_languages=,c,
4608
4609 # Figure out what language subdirectories are present.
4610 # Look if the user specified --enable-languages="..."; if not, use
4611 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4612 # go away some day.
4613 # NB:  embedded tabs in this IF block -- do not untabify
4614 if test -d ${srcdir}/gcc; then
4615   if test x"${enable_languages+set}" != xset; then
4616     if test x"${LANGUAGES+set}" = xset; then
4617       enable_languages="${LANGUAGES}"
4618         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4619     else
4620       enable_languages=all
4621     fi
4622   else
4623     if test x"${enable_languages}" = x ||
4624        test x"${enable_languages}" = xyes;
4625        then
4626       echo configure.in: --enable-languages needs at least one language argument 1>&2
4627       exit 1
4628     fi
4629   fi
4630   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4631
4632   # 'f95' is the old name for the 'fortran' language. We issue a warning
4633   # and make the substitution.
4634   case ,${enable_languages}, in
4635     *,f95,*)
4636       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4637       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4638       ;;
4639   esac
4640
4641   # First scan to see if an enabled language requires some other language.
4642   # We assume that a given config-lang.in will list all the language
4643   # front ends it requires, even if some are required indirectly.
4644   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4645     case ${lang_frag} in
4646       ..) ;;
4647       # The odd quoting in the next line works around
4648       # an apparent bug in bash 1.12 on linux.
4649       ${srcdir}/gcc/[*]/config-lang.in) ;;
4650       *)
4651         # From the config-lang.in, get $language, $lang_requires
4652         language=
4653         lang_requires=
4654         . ${lang_frag}
4655         for other in ${lang_requires} ; do
4656           case ,${enable_languages}, in
4657             *,$other,*) ;;
4658             *,all,*) ;;
4659             *,$language,*)
4660               echo " \`$other' language required by \`$language'; enabling" 1>&2
4661               enable_languages="${enable_languages},${other}"
4662               ;;
4663           esac
4664         done
4665         ;;
4666     esac
4667   done
4668
4669   new_enable_languages=,c,
4670   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4671   potential_languages=,c,
4672
4673   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4674     case ${lang_frag} in
4675       ..) ;;
4676       # The odd quoting in the next line works around
4677       # an apparent bug in bash 1.12 on linux.
4678       ${srcdir}/gcc/[*]/config-lang.in) ;;
4679       *)
4680         # From the config-lang.in, get $language, $target_libs,
4681         # $lang_dirs, $boot_language, and $build_by_default
4682         language=
4683         target_libs=
4684         lang_dirs=
4685         subdir_requires=
4686         boot_language=no
4687         build_by_default=yes
4688         . ${lang_frag}
4689         if test x${language} = x; then
4690           echo "${lang_frag} doesn't set \$language." 1>&2
4691           exit 1
4692         fi
4693
4694         case ,${enable_languages}, in
4695           *,${language},*)
4696             # Language was explicitly selected; include it.
4697             add_this_lang=yes
4698             ;;
4699           *,all,*)
4700             # 'all' was selected, select it if it is a default language
4701             add_this_lang=${build_by_default}
4702             ;;
4703           *)
4704             add_this_lang=no
4705             ;;
4706         esac
4707
4708         # Disable languages that need other directories if these aren't available.
4709         for i in $subdir_requires; do
4710           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4711           case ,${enable_languages}, in
4712             *,${language},*)
4713               # Specifically requested language; tell them.
4714               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4715 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4716    { (exit 1); exit 1; }; }
4717               ;;
4718             *)
4719               # Silently disable.
4720               add_this_lang=unsupported
4721               ;;
4722           esac
4723         done
4724
4725         # Disable Ada if no preexisting GNAT is available.
4726         case ,${enable_languages},:${language}:${have_gnat} in
4727           *,${language},*:ada:no)
4728             # Specifically requested language; tell them.
4729             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4730 echo "$as_me: error: GNAT is required to build $language" >&2;}
4731    { (exit 1); exit 1; }; }
4732             ;;
4733           *:ada:no)
4734             # Silently disable.
4735             add_this_lang=unsupported
4736             ;;
4737         esac
4738
4739         # Disable a language that is unsupported by the target.
4740         case " $unsupported_languages " in
4741           *" $language "*)
4742             add_this_lang=unsupported
4743             ;;
4744         esac
4745
4746         case $add_this_lang in
4747           unsupported)
4748             # Remove language-dependent dirs.
4749             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4750             ;;
4751           no)
4752             # Remove language-dependent dirs; still show language as supported.
4753             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4754             potential_languages="${potential_languages}${language},"
4755             ;;
4756           yes)
4757             new_enable_languages="${new_enable_languages}${language},"
4758             potential_languages="${potential_languages}${language},"
4759             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4760             case ${boot_language} in
4761               yes)
4762                 # Add to (comma-separated) list of stage 1 languages.
4763                 stage1_languages="${stage1_languages}${language},"
4764                 ;;
4765             esac
4766             ;;
4767         esac
4768         ;;
4769     esac
4770   done
4771
4772   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4773 if test "${enable_stage1_languages+set}" = set; then
4774   enableval="$enable_stage1_languages"
4775   case ,${enable_stage1_languages}, in
4776     ,no,|,,)
4777       # Set it to something that will have no effect in the loop below
4778       enable_stage1_languages=c ;;
4779     ,yes,)
4780       enable_stage1_languages=`echo $new_enable_languages | \
4781         sed -e "s/^,//" -e "s/,$//" ` ;;
4782     *,all,*)
4783       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4784         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4785   esac
4786
4787   # Add "good" languages from enable_stage1_languages to stage1_languages,
4788   # while "bad" languages go in missing_languages.  Leave no duplicates.
4789   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4790     case $potential_languages in
4791       *,$i,*)
4792         case $stage1_languages in
4793           *,$i,*) ;;
4794           *) stage1_languages="$stage1_languages$i," ;;
4795         esac ;;
4796       *)
4797         case $missing_languages in
4798           *,$i,*) ;;
4799           *) missing_languages="$missing_languages$i," ;;
4800         esac ;;
4801      esac
4802   done
4803 fi;
4804
4805   # Remove leading/trailing commas that were added for simplicity
4806   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4807   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4808   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4809   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4810
4811   if test "x$missing_languages" != x; then
4812     { { echo "$as_me:$LINENO: error:
4813 The following requested languages could not be built: ${missing_languages}
4814 Supported languages are: ${potential_languages}" >&5
4815 echo "$as_me: error:
4816 The following requested languages could not be built: ${missing_languages}
4817 Supported languages are: ${potential_languages}" >&2;}
4818    { (exit 1); exit 1; }; }
4819   fi
4820   if test "x$new_enable_languages" != "x$enable_languages"; then
4821     echo The following languages will be built: ${new_enable_languages}
4822     enable_languages="$new_enable_languages"
4823   fi
4824
4825
4826   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4827 fi
4828
4829 # Handle --disable-<component> generically.
4830 for dir in $configdirs $build_configdirs $target_configdirs ; do
4831   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4832   if eval test x\${enable_${dirname}} "=" xno ; then
4833     noconfigdirs="$noconfigdirs $dir"
4834   fi
4835 done
4836
4837 # Check for Boehm's garbage collector
4838 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4839 if test "${enable_objc_gc+set}" = set; then
4840   enableval="$enable_objc_gc"
4841   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4842   *,objc,*:*:yes:*target-boehm-gc*)
4843     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4844 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4845    { (exit 1); exit 1; }; }
4846     ;;
4847 esac
4848 fi;
4849
4850 # Make sure we only build Boehm's garbage collector if required.
4851 case ,${enable_languages},:${enable_objc_gc} in
4852   *,objc,*:yes)
4853     # Keep target-boehm-gc if requested for Objective-C.
4854     ;;
4855   *)
4856     # Otherwise remove target-boehm-gc depending on target-libjava.
4857     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
4858       noconfigdirs="$noconfigdirs target-boehm-gc"
4859     fi
4860     ;;
4861 esac
4862
4863 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
4864 # $build_configdirs and $target_configdirs.
4865 # If we have the source for $noconfigdirs entries, add them to $notsupp.
4866
4867 notsupp=""
4868 for dir in . $skipdirs $noconfigdirs ; do
4869   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
4870   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4871     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
4872     if test -r $srcdir/$dirname/configure ; then
4873       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4874         true
4875       else
4876         notsupp="$notsupp $dir"
4877       fi
4878     fi
4879   fi
4880   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4881     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
4882     if test -r $srcdir/$dirname/configure ; then
4883       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4884         true
4885       else
4886         notsupp="$notsupp $dir"
4887       fi
4888     fi
4889   fi
4890   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4891     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
4892     if test -r $srcdir/$dirname/configure ; then
4893       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4894         true
4895       else
4896         notsupp="$notsupp $dir"
4897       fi
4898     fi
4899   fi
4900 done
4901
4902 # Sometimes the tools are distributed with libiberty but with no other
4903 # libraries.  In that case, we don't want to build target-libiberty.
4904 # Don't let libgcc imply libiberty either.
4905 if test -n "${target_configdirs}" ; then
4906   libgcc=
4907   others=
4908   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
4909     if test "$i" = "libgcc"; then
4910       libgcc=target-libgcc
4911     elif test "$i" != "libiberty" ; then
4912       if test -r $srcdir/$i/configure ; then
4913         others=yes;
4914         break;
4915       fi
4916     fi
4917   done
4918   if test -z "${others}" ; then
4919     target_configdirs=$libgcc
4920   fi
4921 fi
4922
4923 # Quietly strip out all directories which aren't configurable in this tree.
4924 # This relies on all configurable subdirectories being autoconfiscated, which
4925 # is now the case.
4926 build_configdirs_all="$build_configdirs"
4927 build_configdirs=
4928 for i in ${build_configdirs_all} ; do
4929   j=`echo $i | sed -e s/build-//g`
4930   if test -f ${srcdir}/$j/configure ; then
4931     build_configdirs="${build_configdirs} $i"
4932   fi
4933 done
4934
4935 configdirs_all="$configdirs"
4936 configdirs=
4937 for i in ${configdirs_all} ; do
4938   if test -f ${srcdir}/$i/configure ; then
4939     configdirs="${configdirs} $i"
4940   fi
4941 done
4942
4943 target_configdirs_all="$target_configdirs"
4944 target_configdirs=
4945 for i in ${target_configdirs_all} ; do
4946   j=`echo $i | sed -e s/target-//g`
4947   if test -f ${srcdir}/$j/configure ; then
4948     target_configdirs="${target_configdirs} $i"
4949   fi
4950 done
4951
4952 # Produce a warning message for the subdirs we can't configure.
4953 # This isn't especially interesting in the Cygnus tree, but in the individual
4954 # FSF releases, it's important to let people know when their machine isn't
4955 # supported by the one or two programs in a package.
4956
4957 if test -n "${notsupp}" && test -z "${norecursion}" ; then
4958   # If $appdirs is non-empty, at least one of those directories must still
4959   # be configured, or we error out.  (E.g., if the gas release supports a
4960   # specified target in some subdirs but not the gas subdir, we shouldn't
4961   # pretend that all is well.)
4962   if test -n "$appdirs" ; then
4963     for dir in $appdirs ; do
4964       if test -r $dir/Makefile.in ; then
4965         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4966           appdirs=""
4967           break
4968         fi
4969         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
4970           appdirs=""
4971           break
4972         fi
4973       fi
4974     done
4975     if test -n "$appdirs" ; then
4976       echo "*** This configuration is not supported by this package." 1>&2
4977       exit 1
4978     fi
4979   fi
4980   # Okay, some application will build, or we don't care to check.  Still
4981   # notify of subdirs not getting built.
4982   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
4983   echo "    ${notsupp}" 1>&2
4984   echo "    (Any other directories should still work fine.)" 1>&2
4985 fi
4986
4987 case "$host" in
4988   *msdosdjgpp*)
4989     enable_gdbtk=no ;;
4990 esac
4991
4992 # To find our prefix, in gcc_cv_tool_prefix.
4993
4994 # The user is always right.
4995 if test "${PATH_SEPARATOR+set}" != set; then
4996   echo "#! /bin/sh" >conf$$.sh
4997   echo  "exit 0"   >>conf$$.sh
4998   chmod +x conf$$.sh
4999   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5000     PATH_SEPARATOR=';'
5001   else
5002     PATH_SEPARATOR=:
5003   fi
5004   rm -f conf$$.sh
5005 fi
5006
5007
5008
5009 if test "x$exec_prefix" = xNONE; then
5010         if test "x$prefix" = xNONE; then
5011                 gcc_cv_tool_prefix=$ac_default_prefix
5012         else
5013                 gcc_cv_tool_prefix=$prefix
5014         fi
5015 else
5016         gcc_cv_tool_prefix=$exec_prefix
5017 fi
5018
5019 # If there is no compiler in the tree, use the PATH only.  In any
5020 # case, if there is no compiler in the tree nobody should use
5021 # AS_FOR_TARGET and LD_FOR_TARGET.
5022 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5023     gcc_version=`cat $srcdir/gcc/BASE-VER`
5024     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5025     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5026     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5027     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5028     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5029     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5030 else
5031     gcc_cv_tool_dirs=
5032 fi
5033
5034 if test x$build = x$target && test -n "$md_exec_prefix"; then
5035         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5036 fi
5037
5038
5039
5040 copy_dirs=
5041
5042
5043 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5044 if test "${with_build_sysroot+set}" = set; then
5045   withval="$with_build_sysroot"
5046   if test x"$withval" != x ; then
5047      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5048    fi
5049 else
5050   SYSROOT_CFLAGS_FOR_TARGET=
5051 fi;
5052
5053
5054 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5055 # the named directory are copied to $(tooldir)/sys-include.
5056 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5057   if test x${is_cross_compiler} = xno ; then
5058     echo 1>&2 '***' --with-headers is only supported when cross compiling
5059     exit 1
5060   fi
5061   if test x"${with_headers}" != xyes ; then
5062     x=${gcc_cv_tool_prefix}
5063     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5064   fi
5065 fi
5066
5067 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5068 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5069 # are permitted.
5070 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5071   if test x${is_cross_compiler} = xno ; then
5072     echo 1>&2 '***' --with-libs is only supported when cross compiling
5073     exit 1
5074   fi
5075   if test x"${with_libs}" != xyes ; then
5076     # Copy the libraries in reverse order, so that files in the first named
5077     # library override files in subsequent libraries.
5078     x=${gcc_cv_tool_prefix}
5079     for l in ${with_libs}; do
5080       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5081     done
5082   fi
5083 fi
5084
5085 # Set with_gnu_as and with_gnu_ld as appropriate.
5086 #
5087 # This is done by determining whether or not the appropriate directory
5088 # is available, and by checking whether or not specific configurations
5089 # have requested that this magic not happen.
5090 #
5091 # The command line options always override the explicit settings in
5092 # configure.in, and the settings in configure.in override this magic.
5093 #
5094 # If the default for a toolchain is to use GNU as and ld, and you don't
5095 # want to do that, then you should use the --without-gnu-as and
5096 # --without-gnu-ld options for the configure script.
5097
5098 if test x${use_gnu_as} = x &&
5099    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5100   with_gnu_as=yes
5101   extra_host_args="$extra_host_args --with-gnu-as"
5102 fi
5103
5104 if test x${use_gnu_ld} = x &&
5105    echo " ${configdirs} " | grep " ld " > /dev/null 2>&1 ; then
5106   with_gnu_ld=yes
5107   extra_host_args="$extra_host_args --with-gnu-ld"
5108 fi
5109
5110 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5111 # can detect this case.
5112
5113 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5114   with_newlib=yes
5115   extra_host_args="$extra_host_args --with-newlib"
5116 fi
5117
5118 # Handle ${copy_dirs}
5119 set fnord ${copy_dirs}
5120 shift
5121 while test $# != 0 ; do
5122   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5123     :
5124   else
5125     echo Copying $1 to $2
5126
5127     # Use the install script to create the directory and all required
5128     # parent directories.
5129     if test -d $2 ; then
5130       :
5131     else
5132       echo >config.temp
5133       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5134     fi
5135
5136     # Copy the directory, assuming we have tar.
5137     # FIXME: Should we use B in the second tar?  Not all systems support it.
5138     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5139
5140     # It is the responsibility of the user to correctly adjust all
5141     # symlinks.  If somebody can figure out how to handle them correctly
5142     # here, feel free to add the code.
5143
5144     echo $1 > $2/COPIED
5145   fi
5146   shift; shift
5147 done
5148
5149 # Determine a target-dependent exec_prefix that the installed
5150 # gcc will search in.  Keep this list sorted by triplet, with
5151 # the *-*-osname triplets last.
5152 md_exec_prefix=
5153 case "${target}" in
5154   alpha*-*-*vms*)
5155     md_exec_prefix=/gnu/lib/gcc-lib
5156     ;;
5157   i3456786-pc-msdosdjgpp*)
5158     md_exec_prefix=/dev/env/DJDIR/bin
5159     ;;
5160   i3456786-*-sco3.2v5*)
5161     if test $with_gnu_as = yes; then
5162       md_exec_prefix=/usr/gnu/bin
5163     else
5164       md_exec_prefix=/usr/ccs/bin/elf
5165     fi
5166     ;;
5167
5168   mn10300-*-* | \
5169   powerpc-*-chorusos* | \
5170   powerpc*-*-eabi* | \
5171   powerpc*-*-sysv* | \
5172   powerpc*-*-kaos* | \
5173   s390x-ibm-tpf*)
5174     md_exec_prefix=/usr/ccs/bin
5175     ;;
5176   sparc64-*-elf*)
5177     ;;
5178   v850*-*-*)
5179     md_exec_prefix=/usr/ccs/bin
5180     ;;
5181   xtensa-*-elf*)
5182     ;;
5183
5184   *-*-beos* | \
5185   *-*-elf* | \
5186   *-*-hpux* | \
5187   *-*-netware* | \
5188   *-*-nto-qnx* | \
5189   *-*-rtems* | \
5190   *-*-solaris2* | \
5191   *-*-sysv45* | \
5192   *-*-vxworks* | \
5193   *-wrs-windiss)
5194     md_exec_prefix=/usr/ccs/bin
5195     ;;
5196 esac
5197
5198 extra_arflags_for_target=
5199 extra_nmflags_for_target=
5200 extra_ranlibflags_for_target=
5201 target_makefile_frag=/dev/null
5202 case "${target}" in
5203   mep*-*-*)
5204     target_makefile_frag="config/mt-mep"
5205     ;;
5206   spu-*-*)
5207     target_makefile_frag="config/mt-spu"
5208     ;;
5209   *-*-netware*)
5210     target_makefile_frag="config/mt-netware"
5211     ;;
5212   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5213     target_makefile_frag="config/mt-gnu"
5214     ;;
5215   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5216     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5217     # commands to handle both 32-bit and 64-bit objects.  These flags are
5218     # harmless if we're using GNU nm or ar.
5219     extra_arflags_for_target=" -X32_64"
5220     extra_nmflags_for_target=" -B -X32_64"
5221     ;;
5222   *-*-darwin*)
5223     # ranlib from Darwin requires the -c flag to look at common symbols.
5224     extra_ranlibflags_for_target=" -c"
5225     ;;
5226   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5227     target_makefile_frag="config/mt-wince"
5228     ;;
5229 esac
5230
5231 alphaieee_frag=/dev/null
5232 case $target in
5233   alpha*-*-*)
5234     # This just makes sure to use the -mieee option to build target libs.
5235     # This should probably be set individually by each library.
5236     alphaieee_frag="config/mt-alphaieee"
5237     ;;
5238 esac
5239
5240 # If --enable-target-optspace always use -Os instead of -O2 to build
5241 # the target libraries, similarly if it is not specified, use -Os
5242 # on selected platforms.
5243 ospace_frag=/dev/null
5244 case "${enable_target_optspace}:${target}" in
5245   yes:*)
5246     ospace_frag="config/mt-ospace"
5247     ;;
5248   :d30v-*)
5249     ospace_frag="config/mt-d30v"
5250     ;;
5251   :m32r-* | :d10v-* | :fr30-*)
5252     ospace_frag="config/mt-ospace"
5253     ;;
5254   no:* | :*)
5255     ;;
5256   *)
5257     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5258     ;;
5259 esac
5260
5261 # Default to using --with-stabs for certain targets.
5262 if test x${with_stabs} = x ; then
5263   case "${target}" in
5264   mips*-*-irix[56]*)
5265     ;;
5266   mips*-*-* | alpha*-*-osf*)
5267     with_stabs=yes;
5268     extra_host_args="${extra_host_args} --with-stabs"
5269     ;;
5270   esac
5271 fi
5272
5273 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5274 # them automatically.
5275 case "${host}" in
5276   hppa*64*-*-hpux11*)
5277     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5278     ;;
5279 esac
5280
5281 # Some systems (e.g., one of the i386-aix systems the gas testers are
5282 # using) don't handle "\$" correctly, so don't use it here.
5283 tooldir='${exec_prefix}'/${target_noncanonical}
5284 build_tooldir=${tooldir}
5285
5286 # Create a .gdbinit file which runs the one in srcdir
5287 # and tells GDB to look there for source files.
5288
5289 if test -r ${srcdir}/.gdbinit ; then
5290   case ${srcdir} in
5291     .) ;;
5292     *) cat > ./.gdbinit <<EOF
5293 # ${NO_EDIT}
5294 dir ${srcdir}
5295 dir .
5296 source ${srcdir}/.gdbinit
5297 EOF
5298     ;;
5299   esac
5300 fi
5301
5302 # Make sure that the compiler is able to generate an executable.  If it
5303 # can't, we are probably in trouble.  We don't care whether we can run the
5304 # executable--we might be using a cross compiler--we only care whether it
5305 # can be created.  At this point the main configure script has set CC.
5306 we_are_ok=no
5307 echo "int main () { return 0; }" > conftest.c
5308 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5309 if test $? = 0 ; then
5310   if test -s conftest || test -s conftest.exe ; then
5311     we_are_ok=yes
5312   fi
5313 fi
5314 case $we_are_ok in
5315   no)
5316     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5317     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5318     rm -f conftest*
5319     exit 1
5320     ;;
5321 esac
5322 rm -f conftest*
5323
5324 # The Solaris /usr/ucb/cc compiler does not appear to work.
5325 case "${host}" in
5326   sparc-sun-solaris2*)
5327       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5328       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5329           could_use=
5330           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5331           if test -d /opt/cygnus/bin ; then
5332               if test "$could_use" = "" ; then
5333                   could_use="/opt/cygnus/bin"
5334               else
5335                   could_use="$could_use or /opt/cygnus/bin"
5336               fi
5337           fi
5338         if test "$could_use" = "" ; then
5339             echo "Warning: compilation may fail because you're using"
5340             echo "/usr/ucb/cc.  You should change your PATH or CC "
5341             echo "variable and rerun configure."
5342         else
5343             echo "Warning: compilation may fail because you're using"
5344             echo "/usr/ucb/cc, when you should use the C compiler from"
5345             echo "$could_use.  You should change your"
5346             echo "PATH or CC variable and rerun configure."
5347         fi
5348       fi
5349   ;;
5350 esac
5351
5352 case "${host}" in
5353   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5354   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5355   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5356 esac
5357
5358 # Record target_configdirs and the configure arguments for target and
5359 # build configuration in Makefile.
5360 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5361 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5362
5363 # Determine whether gdb needs tk/tcl or not.
5364 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5365 # and in that case we want gdb to be built without tk.  Ugh!
5366 # In fact I believe gdb is the *only* package directly dependent on tk,
5367 # so we should be able to put the 'maybe's in unconditionally and
5368 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5369 # 100% sure that that's safe though.
5370
5371 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5372 case "$enable_gdbtk" in
5373   no)
5374     GDB_TK="" ;;
5375   yes)
5376     GDB_TK="${gdb_tk}" ;;
5377   *)
5378     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5379     # distro.  Eventually someone will fix this and move Insight, nee
5380     # gdbtk to a separate directory.
5381     if test -d ${srcdir}/gdb/gdbtk ; then
5382       GDB_TK="${gdb_tk}"
5383     else
5384       GDB_TK=""
5385     fi
5386     ;;
5387 esac
5388 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5389 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5390
5391 # Strip out unwanted targets.
5392
5393 # While at that, we remove Makefiles if we were started for recursive
5394 # configuration, so that the top-level Makefile reconfigures them,
5395 # like we used to do when configure itself was recursive.
5396
5397 # Loop over modules.  $extrasub must be used with care, limiting as
5398 # much as possible the usage of range addresses.  That's because autoconf
5399 # splits the sed script to overcome limits in the number of commands,
5400 # and relying on carefully-timed sed passes may turn out to be very hard
5401 # to maintain later.  In this particular case, you just have to be careful
5402 # not to nest @if/@endif pairs, because configure will not warn you at all.
5403
5404 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5405 if test "${enable_bootstrap+set}" = set; then
5406   enableval="$enable_bootstrap"
5407
5408 else
5409   enable_bootstrap=default
5410 fi;
5411
5412 # Issue errors and warnings for invalid/strange bootstrap combinations.
5413 case "$configdirs" in
5414   *gcc*) have_compiler=yes ;;
5415   *) have_compiler=no ;;
5416 esac
5417
5418 case "$have_compiler:$host:$target:$enable_bootstrap" in
5419   *:*:*:no) ;;
5420
5421   # Default behavior.  Enable bootstrap if we have a compiler
5422   # and we are in a native configuration.
5423   yes:$build:$build:default)
5424     enable_bootstrap=yes ;;
5425
5426   *:*:*:default)
5427     enable_bootstrap=no ;;
5428
5429   # We have a compiler and we are in a native configuration, bootstrap is ok
5430   yes:$build:$build:yes)
5431     ;;
5432
5433   # Other configurations, but we have a compiler.  Assume the user knows
5434   # what he's doing.
5435   yes:*:*:yes)
5436     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5437 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5438     ;;
5439
5440   # No compiler: if they passed --enable-bootstrap explicitly, fail
5441   no:*:*:yes)
5442     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5443 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5444    { (exit 1); exit 1; }; } ;;
5445
5446   # Fail if wrong command line
5447   *)
5448     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5449 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5450    { (exit 1); exit 1; }; }
5451     ;;
5452 esac
5453
5454 # Adjust the toplevel makefile according to whether bootstrap was selected.
5455 case "$enable_bootstrap" in
5456   yes)
5457     bootstrap_suffix=bootstrap ;;
5458   no)
5459     bootstrap_suffix=no-bootstrap ;;
5460 esac
5461
5462 for module in ${build_configdirs} ; do
5463   if test -z "${no_recursion}" \
5464      && test -f ${build_subdir}/${module}/Makefile; then
5465     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5466     rm -f ${build_subdir}/${module}/Makefile
5467   fi
5468   extrasub="$extrasub
5469 /^@if build-$module\$/d
5470 /^@endif build-$module\$/d
5471 /^@if build-$module-$bootstrap_suffix\$/d
5472 /^@endif build-$module-$bootstrap_suffix\$/d"
5473 done
5474 for module in ${configdirs} ; do
5475   if test -z "${no_recursion}"; then
5476     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5477       if test -f ${file}; then
5478         echo 1>&2 "*** removing ${file} to force reconfigure"
5479         rm -f ${file}
5480       fi
5481     done
5482   fi
5483   extrasub="$extrasub
5484 /^@if $module\$/d
5485 /^@endif $module\$/d
5486 /^@if $module-$bootstrap_suffix\$/d
5487 /^@endif $module-$bootstrap_suffix\$/d"
5488 done
5489 for module in ${target_configdirs} ; do
5490   if test -z "${no_recursion}" \
5491      && test -f ${target_subdir}/${module}/Makefile; then
5492     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5493     rm -f ${target_subdir}/${module}/Makefile
5494   fi
5495   extrasub="$extrasub
5496 /^@if target-$module\$/d
5497 /^@endif target-$module\$/d
5498 /^@if target-$module-$bootstrap_suffix\$/d
5499 /^@endif target-$module-$bootstrap_suffix\$/d"
5500 done
5501
5502 extrasub="$extrasub
5503 /^@if /,/^@endif /d"
5504
5505 # Create the serialization dependencies.  This uses a temporary file.
5506
5507 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5508 if test "${enable_serial_configure+set}" = set; then
5509   enableval="$enable_serial_configure"
5510
5511 fi;
5512
5513 case ${enable_serial_configure} in
5514   yes)
5515     enable_serial_build_configure=yes
5516     enable_serial_host_configure=yes
5517     enable_serial_target_configure=yes
5518     ;;
5519 esac
5520
5521 # These force 'configure's to be done one at a time, to avoid problems
5522 # with contention over a shared config.cache.
5523 rm -f serdep.tmp
5524 echo '# serdep.tmp' > serdep.tmp
5525 olditem=
5526 test "x${enable_serial_build_configure}" = xyes &&
5527 for item in ${build_configdirs} ; do
5528   case ${olditem} in
5529     "") ;;
5530     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5531   esac
5532   olditem=${item}
5533 done
5534 olditem=
5535 test "x${enable_serial_host_configure}" = xyes &&
5536 for item in ${configdirs} ; do
5537   case ${olditem} in
5538     "") ;;
5539     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5540   esac
5541   olditem=${item}
5542 done
5543 olditem=
5544 test "x${enable_serial_target_configure}" = xyes &&
5545 for item in ${target_configdirs} ; do
5546   case ${olditem} in
5547     "") ;;
5548     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5549   esac
5550   olditem=${item}
5551 done
5552 serialization_dependencies=serdep.tmp
5553
5554
5555 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5556 # target, nonopt, and variable assignments.  These are the ones we
5557 # might not want to pass down to subconfigures.  Also strip
5558 # program-prefix, program-suffix, and program-transform-name, so that
5559 # we can pass down a consistent program-transform-name.
5560 baseargs=
5561 keep_next=no
5562 skip_next=no
5563 eval "set -- $ac_configure_args"
5564 for ac_arg
5565 do
5566   if test X"$skip_next" = X"yes"; then
5567     skip_next=no
5568     continue
5569   fi
5570   if test X"$keep_next" = X"yes"; then
5571     case $ac_arg in
5572       *\'*)
5573         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5574     esac
5575     baseargs="$baseargs '$ac_arg'"
5576     keep_next=no
5577     continue
5578   fi
5579
5580   # Handle separated arguments.  Based on the logic generated by
5581   # autoconf 2.59.
5582   case $ac_arg in
5583     *=* | --config-cache | -C | -disable-* | --disable-* \
5584       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5585       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5586       | -with-* | --with-* | -without-* | --without-* | --x)
5587       separate_arg=no
5588       ;;
5589     -*)
5590       separate_arg=yes
5591       ;;
5592     *)
5593       separate_arg=no
5594       ;;
5595   esac
5596
5597   case "$ac_arg" in
5598     --no*)
5599       continue
5600       ;;
5601     --c* | \
5602     --sr* | \
5603     --ho* | \
5604     --bu* | \
5605     --t* | \
5606     --program-* | \
5607     -cache_file* | \
5608     -srcdir* | \
5609     -host* | \
5610     -build* | \
5611     -target* | \
5612     -program-prefix* | \
5613     -program-suffix* | \
5614     -program-transform-name* )
5615       skip_next=$separate_arg
5616       continue
5617       ;;
5618     -*)
5619       # An option.  Add it.
5620       case $ac_arg in
5621         *\'*)
5622           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5623       esac
5624       baseargs="$baseargs '$ac_arg'"
5625       keep_next=$separate_arg
5626       ;;
5627     *)
5628       # Either a variable assignment, or a nonopt (triplet).  Don't
5629       # pass it down; let the Makefile handle this.
5630       continue
5631       ;;
5632   esac
5633 done
5634 # Remove the initial space we just introduced and, as these will be
5635 # expanded by make, quote '$'.
5636 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5637
5638 # Add in --program-transform-name, after --program-prefix and
5639 # --program-suffix have been applied to it.  Autoconf has already
5640 # doubled dollar signs and backslashes in program_transform_name; we want
5641 # the backslashes un-doubled, and then the entire thing wrapped in single
5642 # quotes, because this will be expanded first by make and then by the shell.
5643 # Also, because we want to override the logic in subdir configure scripts to
5644 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5645 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5646 ${program_transform_name}
5647 EOF_SED
5648 gcc_transform_name=`cat conftestsed.out`
5649 rm -f conftestsed.out
5650 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5651
5652 # For the build-side libraries, we just need to pretend we're native,
5653 # and not use the same cache file.  Multilibs are neither needed nor
5654 # desired.
5655 build_configargs="--cache-file=../config.cache ${baseargs}"
5656
5657 # For host modules, accept cache file option, or specification as blank.
5658 case "${cache_file}" in
5659 "") # empty
5660   cache_file_option="" ;;
5661 /* | [A-Za-z]:[\\/]* ) # absolute path
5662   cache_file_option="--cache-file=${cache_file}" ;;
5663 *) # relative path
5664   cache_file_option="--cache-file=../${cache_file}" ;;
5665 esac
5666
5667 # Host dirs don't like to share a cache file either, horribly enough.
5668 # This seems to be due to autoconf 2.5x stupidity.
5669 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5670
5671 target_configargs=${baseargs}
5672
5673 # Passing a --with-cross-host argument lets the target libraries know
5674 # whether they are being built with a cross-compiler or being built
5675 # native.  However, it would be better to use other mechanisms to make the
5676 # sorts of decisions they want to make on this basis.  Please consider
5677 # this option to be deprecated.  FIXME.
5678 if test x${is_cross_compiler} = xyes ; then
5679   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5680 fi
5681
5682 # Default to --enable-multilib.
5683 if test x${enable_multilib} = x ; then
5684   target_configargs="--enable-multilib ${target_configargs}"
5685 fi
5686
5687 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5688 # changed from the earlier setting of with_newlib.
5689 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5690   target_configargs="--with-newlib ${target_configargs}"
5691 fi
5692
5693 # Different target subdirs use different values of certain variables
5694 # (notably CXX).  Worse, multilibs use *lots* of different values.
5695 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5696 # it doesn't automatically accept command-line overrides of them.
5697 # This means it's not safe for target subdirs to share a cache file,
5698 # which is disgusting, but there you have it.  Hopefully this can be
5699 # fixed in future.  It's still worthwhile to use a cache file for each
5700 # directory.  I think.
5701
5702 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5703 # We need to pass --target, as newer autoconf's requires consistency
5704 # for target_alias and gcc doesn't manage it consistently.
5705 target_configargs="--cache-file=./config.cache ${target_configargs}"
5706
5707 FLAGS_FOR_TARGET=
5708 case " $target_configdirs " in
5709  *" newlib "*)
5710   case " $target_configargs " in
5711   *" --with-newlib "*)
5712    case "$target" in
5713    *-cygwin*)
5714      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' ;;
5715    esac
5716
5717    # If we're not building GCC, don't discard standard headers.
5718    if test -d ${srcdir}/gcc; then
5719      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5720
5721      if test "${build}" != "${host}"; then
5722        # On Canadian crosses, CC_FOR_TARGET will have already been set
5723        # by `configure', so we won't have an opportunity to add -Bgcc/
5724        # to it.  This is right: we don't want to search that directory
5725        # for binaries, but we want the header files in there, so add
5726        # them explicitly.
5727        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5728
5729        # Someone might think of using the pre-installed headers on
5730        # Canadian crosses, in case the installed compiler is not fully
5731        # compatible with the compiler being built.  In this case, it
5732        # would be better to flag an error than risking having
5733        # incompatible object files being constructed.  We can't
5734        # guarantee that an error will be flagged, but let's hope the
5735        # compiler will do it, when presented with incompatible header
5736        # files.
5737      fi
5738    fi
5739
5740    case "${target}-${is_cross_compiler}" in
5741    i[3456789]86-*-linux*-no)
5742       # Here host == target, so we don't need to build gcc,
5743       # so we don't want to discard standard headers.
5744       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5745       ;;
5746    *)
5747       # If we're building newlib, use its generic headers last, but search
5748       # for any libc-related directories first (so make it the last -B
5749       # switch).
5750       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5751       ;;
5752    esac
5753    ;;
5754   esac
5755   ;;
5756 esac
5757 case "$target" in
5758 *-mingw*)
5759   # Can't be handled as Cygwin above since Mingw does not use newlib.
5760   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' ;;
5761 esac
5762
5763 # Allow the user to override the flags for
5764 # our build compiler if desired.
5765 CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5766
5767 # On Canadian crosses, we'll be searching the right directories for
5768 # the previously-installed cross compiler, so don't bother to add
5769 # flags for directories within the install tree of the compiler
5770 # being built; programs in there won't even run.
5771 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5772   # Search for pre-installed headers if nothing else fits.
5773   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5774 fi
5775
5776 if test "x${use_gnu_ld}" = x &&
5777    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5778   # Arrange for us to find uninstalled linker scripts.
5779   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5780 fi
5781
5782 # Search for other target-specific linker scripts and such.
5783 case "${target}" in
5784   m32c-*-* )
5785     if test -d ${srcdir}/libgloss/m32c; then
5786       # This is for crt0.o
5787       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/m32c'
5788       # This is for r8c.ld
5789       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/m32c'
5790       # This is for libnosys.a
5791       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5792     fi
5793     ;;
5794   mep*)
5795     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5796     ;;
5797 esac
5798
5799 # Makefile fragments.
5800 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5801 do
5802   eval fragval=\$$frag
5803   if test $fragval != /dev/null; then
5804     eval $frag=${srcdir}/$fragval
5805   fi
5806 done
5807
5808
5809
5810
5811
5812 # Miscellanea: directories, flags, etc.
5813
5814
5815
5816
5817
5818
5819
5820 # Build module lists & subconfigure args.
5821
5822
5823
5824 # Host module lists & subconfigure args.
5825
5826
5827
5828 # Target module lists & subconfigure args.
5829
5830
5831
5832 # Build tools.
5833
5834
5835
5836 # Generate default definitions for YACC, M4, LEX and other programs that run
5837 # on the build machine.  These are used if the Makefile can't locate these
5838 # programs in objdir.
5839 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
5840
5841 for ac_prog in 'bison -y' byacc yacc
5842 do
5843   # Extract the first word of "$ac_prog", so it can be a program name with args.
5844 set dummy $ac_prog; ac_word=$2
5845 echo "$as_me:$LINENO: checking for $ac_word" >&5
5846 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5847 if test "${ac_cv_prog_YACC+set}" = set; then
5848   echo $ECHO_N "(cached) $ECHO_C" >&6
5849 else
5850   if test -n "$YACC"; then
5851   ac_cv_prog_YACC="$YACC" # Let the user override the test.
5852 else
5853 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5854 for as_dir in $PATH
5855 do
5856   IFS=$as_save_IFS
5857   test -z "$as_dir" && as_dir=.
5858   for ac_exec_ext in '' $ac_executable_extensions; do
5859   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5860     ac_cv_prog_YACC="$ac_prog"
5861     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5862     break 2
5863   fi
5864 done
5865 done
5866
5867 fi
5868 fi
5869 YACC=$ac_cv_prog_YACC
5870 if test -n "$YACC"; then
5871   echo "$as_me:$LINENO: result: $YACC" >&5
5872 echo "${ECHO_T}$YACC" >&6
5873 else
5874   echo "$as_me:$LINENO: result: no" >&5
5875 echo "${ECHO_T}no" >&6
5876 fi
5877
5878   test -n "$YACC" && break
5879 done
5880 test -n "$YACC" || YACC="$MISSING bison -y"
5881
5882 case " $build_configdirs " in
5883   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
5884   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
5885 esac
5886
5887 for ac_prog in bison
5888 do
5889   # Extract the first word of "$ac_prog", so it can be a program name with args.
5890 set dummy $ac_prog; ac_word=$2
5891 echo "$as_me:$LINENO: checking for $ac_word" >&5
5892 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5893 if test "${ac_cv_prog_BISON+set}" = set; then
5894   echo $ECHO_N "(cached) $ECHO_C" >&6
5895 else
5896   if test -n "$BISON"; then
5897   ac_cv_prog_BISON="$BISON" # Let the user override the test.
5898 else
5899 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5900 for as_dir in $PATH
5901 do
5902   IFS=$as_save_IFS
5903   test -z "$as_dir" && as_dir=.
5904   for ac_exec_ext in '' $ac_executable_extensions; do
5905   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5906     ac_cv_prog_BISON="$ac_prog"
5907     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5908     break 2
5909   fi
5910 done
5911 done
5912
5913 fi
5914 fi
5915 BISON=$ac_cv_prog_BISON
5916 if test -n "$BISON"; then
5917   echo "$as_me:$LINENO: result: $BISON" >&5
5918 echo "${ECHO_T}$BISON" >&6
5919 else
5920   echo "$as_me:$LINENO: result: no" >&5
5921 echo "${ECHO_T}no" >&6
5922 fi
5923
5924   test -n "$BISON" && break
5925 done
5926 test -n "$BISON" || BISON="$MISSING bison"
5927
5928 case " $build_configdirs " in
5929   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
5930 esac
5931
5932 for ac_prog in gm4 gnum4 m4
5933 do
5934   # Extract the first word of "$ac_prog", so it can be a program name with args.
5935 set dummy $ac_prog; ac_word=$2
5936 echo "$as_me:$LINENO: checking for $ac_word" >&5
5937 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5938 if test "${ac_cv_prog_M4+set}" = set; then
5939   echo $ECHO_N "(cached) $ECHO_C" >&6
5940 else
5941   if test -n "$M4"; then
5942   ac_cv_prog_M4="$M4" # Let the user override the test.
5943 else
5944 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5945 for as_dir in $PATH
5946 do
5947   IFS=$as_save_IFS
5948   test -z "$as_dir" && as_dir=.
5949   for ac_exec_ext in '' $ac_executable_extensions; do
5950   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5951     ac_cv_prog_M4="$ac_prog"
5952     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5953     break 2
5954   fi
5955 done
5956 done
5957
5958 fi
5959 fi
5960 M4=$ac_cv_prog_M4
5961 if test -n "$M4"; then
5962   echo "$as_me:$LINENO: result: $M4" >&5
5963 echo "${ECHO_T}$M4" >&6
5964 else
5965   echo "$as_me:$LINENO: result: no" >&5
5966 echo "${ECHO_T}no" >&6
5967 fi
5968
5969   test -n "$M4" && break
5970 done
5971 test -n "$M4" || M4="$MISSING m4"
5972
5973 case " $build_configdirs " in
5974   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
5975 esac
5976
5977 for ac_prog in flex lex
5978 do
5979   # Extract the first word of "$ac_prog", so it can be a program name with args.
5980 set dummy $ac_prog; ac_word=$2
5981 echo "$as_me:$LINENO: checking for $ac_word" >&5
5982 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5983 if test "${ac_cv_prog_LEX+set}" = set; then
5984   echo $ECHO_N "(cached) $ECHO_C" >&6
5985 else
5986   if test -n "$LEX"; then
5987   ac_cv_prog_LEX="$LEX" # Let the user override the test.
5988 else
5989 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5990 for as_dir in $PATH
5991 do
5992   IFS=$as_save_IFS
5993   test -z "$as_dir" && as_dir=.
5994   for ac_exec_ext in '' $ac_executable_extensions; do
5995   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5996     ac_cv_prog_LEX="$ac_prog"
5997     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5998     break 2
5999   fi
6000 done
6001 done
6002
6003 fi
6004 fi
6005 LEX=$ac_cv_prog_LEX
6006 if test -n "$LEX"; then
6007   echo "$as_me:$LINENO: result: $LEX" >&5
6008 echo "${ECHO_T}$LEX" >&6
6009 else
6010   echo "$as_me:$LINENO: result: no" >&5
6011 echo "${ECHO_T}no" >&6
6012 fi
6013
6014   test -n "$LEX" && break
6015 done
6016 test -n "$LEX" || LEX="$MISSING flex"
6017
6018 case " $build_configdirs " in
6019   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6020   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6021 esac
6022
6023 for ac_prog in flex
6024 do
6025   # Extract the first word of "$ac_prog", so it can be a program name with args.
6026 set dummy $ac_prog; ac_word=$2
6027 echo "$as_me:$LINENO: checking for $ac_word" >&5
6028 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6029 if test "${ac_cv_prog_FLEX+set}" = set; then
6030   echo $ECHO_N "(cached) $ECHO_C" >&6
6031 else
6032   if test -n "$FLEX"; then
6033   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6034 else
6035 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6036 for as_dir in $PATH
6037 do
6038   IFS=$as_save_IFS
6039   test -z "$as_dir" && as_dir=.
6040   for ac_exec_ext in '' $ac_executable_extensions; do
6041   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6042     ac_cv_prog_FLEX="$ac_prog"
6043     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6044     break 2
6045   fi
6046 done
6047 done
6048
6049 fi
6050 fi
6051 FLEX=$ac_cv_prog_FLEX
6052 if test -n "$FLEX"; then
6053   echo "$as_me:$LINENO: result: $FLEX" >&5
6054 echo "${ECHO_T}$FLEX" >&6
6055 else
6056   echo "$as_me:$LINENO: result: no" >&5
6057 echo "${ECHO_T}no" >&6
6058 fi
6059
6060   test -n "$FLEX" && break
6061 done
6062 test -n "$FLEX" || FLEX="$MISSING flex"
6063
6064 case " $build_configdirs " in
6065   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6066 esac
6067
6068 for ac_prog in makeinfo
6069 do
6070   # Extract the first word of "$ac_prog", so it can be a program name with args.
6071 set dummy $ac_prog; ac_word=$2
6072 echo "$as_me:$LINENO: checking for $ac_word" >&5
6073 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6074 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6075   echo $ECHO_N "(cached) $ECHO_C" >&6
6076 else
6077   if test -n "$MAKEINFO"; then
6078   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6079 else
6080 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6081 for as_dir in $PATH
6082 do
6083   IFS=$as_save_IFS
6084   test -z "$as_dir" && as_dir=.
6085   for ac_exec_ext in '' $ac_executable_extensions; do
6086   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6087     ac_cv_prog_MAKEINFO="$ac_prog"
6088     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6089     break 2
6090   fi
6091 done
6092 done
6093
6094 fi
6095 fi
6096 MAKEINFO=$ac_cv_prog_MAKEINFO
6097 if test -n "$MAKEINFO"; then
6098   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6099 echo "${ECHO_T}$MAKEINFO" >&6
6100 else
6101   echo "$as_me:$LINENO: result: no" >&5
6102 echo "${ECHO_T}no" >&6
6103 fi
6104
6105   test -n "$MAKEINFO" && break
6106 done
6107 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6108
6109 case " $build_configdirs " in
6110   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6111   *)
6112
6113     # For an installed makeinfo, we require it to be from texinfo 4.4 or
6114     # higher, else we use the "missing" dummy.
6115     if ${MAKEINFO} --version \
6116        | egrep 'texinfo[^0-9]*([1-3][0-9]|4\.[4-9]|[5-9])' >/dev/null 2>&1; then
6117       :
6118     else
6119       MAKEINFO="$MISSING makeinfo"
6120     fi
6121     ;;
6122
6123 esac
6124
6125 # FIXME: expect and dejagnu may become build tools?
6126
6127 for ac_prog in expect
6128 do
6129   # Extract the first word of "$ac_prog", so it can be a program name with args.
6130 set dummy $ac_prog; ac_word=$2
6131 echo "$as_me:$LINENO: checking for $ac_word" >&5
6132 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6133 if test "${ac_cv_prog_EXPECT+set}" = set; then
6134   echo $ECHO_N "(cached) $ECHO_C" >&6
6135 else
6136   if test -n "$EXPECT"; then
6137   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6138 else
6139 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6140 for as_dir in $PATH
6141 do
6142   IFS=$as_save_IFS
6143   test -z "$as_dir" && as_dir=.
6144   for ac_exec_ext in '' $ac_executable_extensions; do
6145   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6146     ac_cv_prog_EXPECT="$ac_prog"
6147     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6148     break 2
6149   fi
6150 done
6151 done
6152
6153 fi
6154 fi
6155 EXPECT=$ac_cv_prog_EXPECT
6156 if test -n "$EXPECT"; then
6157   echo "$as_me:$LINENO: result: $EXPECT" >&5
6158 echo "${ECHO_T}$EXPECT" >&6
6159 else
6160   echo "$as_me:$LINENO: result: no" >&5
6161 echo "${ECHO_T}no" >&6
6162 fi
6163
6164   test -n "$EXPECT" && break
6165 done
6166 test -n "$EXPECT" || EXPECT="expect"
6167
6168 case " $configdirs " in
6169   *" expect "*)
6170     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6171     ;;
6172 esac
6173
6174 for ac_prog in runtest
6175 do
6176   # Extract the first word of "$ac_prog", so it can be a program name with args.
6177 set dummy $ac_prog; ac_word=$2
6178 echo "$as_me:$LINENO: checking for $ac_word" >&5
6179 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6180 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6181   echo $ECHO_N "(cached) $ECHO_C" >&6
6182 else
6183   if test -n "$RUNTEST"; then
6184   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6185 else
6186 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6187 for as_dir in $PATH
6188 do
6189   IFS=$as_save_IFS
6190   test -z "$as_dir" && as_dir=.
6191   for ac_exec_ext in '' $ac_executable_extensions; do
6192   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6193     ac_cv_prog_RUNTEST="$ac_prog"
6194     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6195     break 2
6196   fi
6197 done
6198 done
6199
6200 fi
6201 fi
6202 RUNTEST=$ac_cv_prog_RUNTEST
6203 if test -n "$RUNTEST"; then
6204   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6205 echo "${ECHO_T}$RUNTEST" >&6
6206 else
6207   echo "$as_me:$LINENO: result: no" >&5
6208 echo "${ECHO_T}no" >&6
6209 fi
6210
6211   test -n "$RUNTEST" && break
6212 done
6213 test -n "$RUNTEST" || RUNTEST="runtest"
6214
6215 case " $configdirs " in
6216   *" dejagnu "*)
6217     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6218     ;;
6219 esac
6220
6221
6222 # Host tools.
6223 ncn_tool_prefix=
6224 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6225 ncn_target_tool_prefix=
6226 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6227
6228
6229
6230 if test -n "$AR"; then
6231   ac_cv_prog_AR=$AR
6232 elif test -n "$ac_cv_prog_AR"; then
6233   AR=$ac_cv_prog_AR
6234 fi
6235
6236 if test -n "$ac_cv_prog_AR"; then
6237   for ncn_progname in ar; do
6238     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6239 set dummy ${ncn_progname}; ac_word=$2
6240 echo "$as_me:$LINENO: checking for $ac_word" >&5
6241 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6242 if test "${ac_cv_prog_AR+set}" = set; then
6243   echo $ECHO_N "(cached) $ECHO_C" >&6
6244 else
6245   if test -n "$AR"; then
6246   ac_cv_prog_AR="$AR" # Let the user override the test.
6247 else
6248 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6249 for as_dir in $PATH
6250 do
6251   IFS=$as_save_IFS
6252   test -z "$as_dir" && as_dir=.
6253   for ac_exec_ext in '' $ac_executable_extensions; do
6254   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6255     ac_cv_prog_AR="${ncn_progname}"
6256     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6257     break 2
6258   fi
6259 done
6260 done
6261
6262 fi
6263 fi
6264 AR=$ac_cv_prog_AR
6265 if test -n "$AR"; then
6266   echo "$as_me:$LINENO: result: $AR" >&5
6267 echo "${ECHO_T}$AR" >&6
6268 else
6269   echo "$as_me:$LINENO: result: no" >&5
6270 echo "${ECHO_T}no" >&6
6271 fi
6272
6273   done
6274 fi
6275
6276 for ncn_progname in ar; do
6277   if test -n "$ncn_tool_prefix"; then
6278     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6279 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6280 echo "$as_me:$LINENO: checking for $ac_word" >&5
6281 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6282 if test "${ac_cv_prog_AR+set}" = set; then
6283   echo $ECHO_N "(cached) $ECHO_C" >&6
6284 else
6285   if test -n "$AR"; then
6286   ac_cv_prog_AR="$AR" # Let the user override the test.
6287 else
6288 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6289 for as_dir in $PATH
6290 do
6291   IFS=$as_save_IFS
6292   test -z "$as_dir" && as_dir=.
6293   for ac_exec_ext in '' $ac_executable_extensions; do
6294   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6295     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6296     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6297     break 2
6298   fi
6299 done
6300 done
6301
6302 fi
6303 fi
6304 AR=$ac_cv_prog_AR
6305 if test -n "$AR"; then
6306   echo "$as_me:$LINENO: result: $AR" >&5
6307 echo "${ECHO_T}$AR" >&6
6308 else
6309   echo "$as_me:$LINENO: result: no" >&5
6310 echo "${ECHO_T}no" >&6
6311 fi
6312
6313   fi
6314   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6315     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6316 set dummy ${ncn_progname}; ac_word=$2
6317 echo "$as_me:$LINENO: checking for $ac_word" >&5
6318 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6319 if test "${ac_cv_prog_AR+set}" = set; then
6320   echo $ECHO_N "(cached) $ECHO_C" >&6
6321 else
6322   if test -n "$AR"; then
6323   ac_cv_prog_AR="$AR" # Let the user override the test.
6324 else
6325 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6326 for as_dir in $PATH
6327 do
6328   IFS=$as_save_IFS
6329   test -z "$as_dir" && as_dir=.
6330   for ac_exec_ext in '' $ac_executable_extensions; do
6331   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6332     ac_cv_prog_AR="${ncn_progname}"
6333     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6334     break 2
6335   fi
6336 done
6337 done
6338
6339 fi
6340 fi
6341 AR=$ac_cv_prog_AR
6342 if test -n "$AR"; then
6343   echo "$as_me:$LINENO: result: $AR" >&5
6344 echo "${ECHO_T}$AR" >&6
6345 else
6346   echo "$as_me:$LINENO: result: no" >&5
6347 echo "${ECHO_T}no" >&6
6348 fi
6349
6350   fi
6351   test -n "$ac_cv_prog_AR" && break
6352 done
6353
6354 if test -z "$ac_cv_prog_AR" ; then
6355   set dummy ar
6356   if test $build = $host ; then
6357     AR="$2"
6358   else
6359     AR="${ncn_tool_prefix}$2"
6360   fi
6361 fi
6362
6363
6364
6365 if test -n "$AS"; then
6366   ac_cv_prog_AS=$AS
6367 elif test -n "$ac_cv_prog_AS"; then
6368   AS=$ac_cv_prog_AS
6369 fi
6370
6371 if test -n "$ac_cv_prog_AS"; then
6372   for ncn_progname in as; do
6373     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6374 set dummy ${ncn_progname}; ac_word=$2
6375 echo "$as_me:$LINENO: checking for $ac_word" >&5
6376 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6377 if test "${ac_cv_prog_AS+set}" = set; then
6378   echo $ECHO_N "(cached) $ECHO_C" >&6
6379 else
6380   if test -n "$AS"; then
6381   ac_cv_prog_AS="$AS" # Let the user override the test.
6382 else
6383 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6384 for as_dir in $PATH
6385 do
6386   IFS=$as_save_IFS
6387   test -z "$as_dir" && as_dir=.
6388   for ac_exec_ext in '' $ac_executable_extensions; do
6389   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6390     ac_cv_prog_AS="${ncn_progname}"
6391     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6392     break 2
6393   fi
6394 done
6395 done
6396
6397 fi
6398 fi
6399 AS=$ac_cv_prog_AS
6400 if test -n "$AS"; then
6401   echo "$as_me:$LINENO: result: $AS" >&5
6402 echo "${ECHO_T}$AS" >&6
6403 else
6404   echo "$as_me:$LINENO: result: no" >&5
6405 echo "${ECHO_T}no" >&6
6406 fi
6407
6408   done
6409 fi
6410
6411 for ncn_progname in as; do
6412   if test -n "$ncn_tool_prefix"; then
6413     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6414 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6415 echo "$as_me:$LINENO: checking for $ac_word" >&5
6416 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6417 if test "${ac_cv_prog_AS+set}" = set; then
6418   echo $ECHO_N "(cached) $ECHO_C" >&6
6419 else
6420   if test -n "$AS"; then
6421   ac_cv_prog_AS="$AS" # Let the user override the test.
6422 else
6423 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6424 for as_dir in $PATH
6425 do
6426   IFS=$as_save_IFS
6427   test -z "$as_dir" && as_dir=.
6428   for ac_exec_ext in '' $ac_executable_extensions; do
6429   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6430     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6431     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6432     break 2
6433   fi
6434 done
6435 done
6436
6437 fi
6438 fi
6439 AS=$ac_cv_prog_AS
6440 if test -n "$AS"; then
6441   echo "$as_me:$LINENO: result: $AS" >&5
6442 echo "${ECHO_T}$AS" >&6
6443 else
6444   echo "$as_me:$LINENO: result: no" >&5
6445 echo "${ECHO_T}no" >&6
6446 fi
6447
6448   fi
6449   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6450     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6451 set dummy ${ncn_progname}; ac_word=$2
6452 echo "$as_me:$LINENO: checking for $ac_word" >&5
6453 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6454 if test "${ac_cv_prog_AS+set}" = set; then
6455   echo $ECHO_N "(cached) $ECHO_C" >&6
6456 else
6457   if test -n "$AS"; then
6458   ac_cv_prog_AS="$AS" # Let the user override the test.
6459 else
6460 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6461 for as_dir in $PATH
6462 do
6463   IFS=$as_save_IFS
6464   test -z "$as_dir" && as_dir=.
6465   for ac_exec_ext in '' $ac_executable_extensions; do
6466   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6467     ac_cv_prog_AS="${ncn_progname}"
6468     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6469     break 2
6470   fi
6471 done
6472 done
6473
6474 fi
6475 fi
6476 AS=$ac_cv_prog_AS
6477 if test -n "$AS"; then
6478   echo "$as_me:$LINENO: result: $AS" >&5
6479 echo "${ECHO_T}$AS" >&6
6480 else
6481   echo "$as_me:$LINENO: result: no" >&5
6482 echo "${ECHO_T}no" >&6
6483 fi
6484
6485   fi
6486   test -n "$ac_cv_prog_AS" && break
6487 done
6488
6489 if test -z "$ac_cv_prog_AS" ; then
6490   set dummy as
6491   if test $build = $host ; then
6492     AS="$2"
6493   else
6494     AS="${ncn_tool_prefix}$2"
6495   fi
6496 fi
6497
6498
6499
6500 if test -n "$DLLTOOL"; then
6501   ac_cv_prog_DLLTOOL=$DLLTOOL
6502 elif test -n "$ac_cv_prog_DLLTOOL"; then
6503   DLLTOOL=$ac_cv_prog_DLLTOOL
6504 fi
6505
6506 if test -n "$ac_cv_prog_DLLTOOL"; then
6507   for ncn_progname in dlltool; do
6508     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6509 set dummy ${ncn_progname}; ac_word=$2
6510 echo "$as_me:$LINENO: checking for $ac_word" >&5
6511 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6512 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6513   echo $ECHO_N "(cached) $ECHO_C" >&6
6514 else
6515   if test -n "$DLLTOOL"; then
6516   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6517 else
6518 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6519 for as_dir in $PATH
6520 do
6521   IFS=$as_save_IFS
6522   test -z "$as_dir" && as_dir=.
6523   for ac_exec_ext in '' $ac_executable_extensions; do
6524   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6525     ac_cv_prog_DLLTOOL="${ncn_progname}"
6526     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6527     break 2
6528   fi
6529 done
6530 done
6531
6532 fi
6533 fi
6534 DLLTOOL=$ac_cv_prog_DLLTOOL
6535 if test -n "$DLLTOOL"; then
6536   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6537 echo "${ECHO_T}$DLLTOOL" >&6
6538 else
6539   echo "$as_me:$LINENO: result: no" >&5
6540 echo "${ECHO_T}no" >&6
6541 fi
6542
6543   done
6544 fi
6545
6546 for ncn_progname in dlltool; do
6547   if test -n "$ncn_tool_prefix"; then
6548     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6549 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6550 echo "$as_me:$LINENO: checking for $ac_word" >&5
6551 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6552 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6553   echo $ECHO_N "(cached) $ECHO_C" >&6
6554 else
6555   if test -n "$DLLTOOL"; then
6556   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6557 else
6558 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6559 for as_dir in $PATH
6560 do
6561   IFS=$as_save_IFS
6562   test -z "$as_dir" && as_dir=.
6563   for ac_exec_ext in '' $ac_executable_extensions; do
6564   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6565     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6566     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6567     break 2
6568   fi
6569 done
6570 done
6571
6572 fi
6573 fi
6574 DLLTOOL=$ac_cv_prog_DLLTOOL
6575 if test -n "$DLLTOOL"; then
6576   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6577 echo "${ECHO_T}$DLLTOOL" >&6
6578 else
6579   echo "$as_me:$LINENO: result: no" >&5
6580 echo "${ECHO_T}no" >&6
6581 fi
6582
6583   fi
6584   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6585     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6586 set dummy ${ncn_progname}; ac_word=$2
6587 echo "$as_me:$LINENO: checking for $ac_word" >&5
6588 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6589 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6590   echo $ECHO_N "(cached) $ECHO_C" >&6
6591 else
6592   if test -n "$DLLTOOL"; then
6593   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6594 else
6595 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6596 for as_dir in $PATH
6597 do
6598   IFS=$as_save_IFS
6599   test -z "$as_dir" && as_dir=.
6600   for ac_exec_ext in '' $ac_executable_extensions; do
6601   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6602     ac_cv_prog_DLLTOOL="${ncn_progname}"
6603     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6604     break 2
6605   fi
6606 done
6607 done
6608
6609 fi
6610 fi
6611 DLLTOOL=$ac_cv_prog_DLLTOOL
6612 if test -n "$DLLTOOL"; then
6613   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6614 echo "${ECHO_T}$DLLTOOL" >&6
6615 else
6616   echo "$as_me:$LINENO: result: no" >&5
6617 echo "${ECHO_T}no" >&6
6618 fi
6619
6620   fi
6621   test -n "$ac_cv_prog_DLLTOOL" && break
6622 done
6623
6624 if test -z "$ac_cv_prog_DLLTOOL" ; then
6625   set dummy dlltool
6626   if test $build = $host ; then
6627     DLLTOOL="$2"
6628   else
6629     DLLTOOL="${ncn_tool_prefix}$2"
6630   fi
6631 fi
6632
6633
6634
6635 if test -n "$LD"; then
6636   ac_cv_prog_LD=$LD
6637 elif test -n "$ac_cv_prog_LD"; then
6638   LD=$ac_cv_prog_LD
6639 fi
6640
6641 if test -n "$ac_cv_prog_LD"; then
6642   for ncn_progname in ld; do
6643     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6644 set dummy ${ncn_progname}; ac_word=$2
6645 echo "$as_me:$LINENO: checking for $ac_word" >&5
6646 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6647 if test "${ac_cv_prog_LD+set}" = set; then
6648   echo $ECHO_N "(cached) $ECHO_C" >&6
6649 else
6650   if test -n "$LD"; then
6651   ac_cv_prog_LD="$LD" # Let the user override the test.
6652 else
6653 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6654 for as_dir in $PATH
6655 do
6656   IFS=$as_save_IFS
6657   test -z "$as_dir" && as_dir=.
6658   for ac_exec_ext in '' $ac_executable_extensions; do
6659   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6660     ac_cv_prog_LD="${ncn_progname}"
6661     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6662     break 2
6663   fi
6664 done
6665 done
6666
6667 fi
6668 fi
6669 LD=$ac_cv_prog_LD
6670 if test -n "$LD"; then
6671   echo "$as_me:$LINENO: result: $LD" >&5
6672 echo "${ECHO_T}$LD" >&6
6673 else
6674   echo "$as_me:$LINENO: result: no" >&5
6675 echo "${ECHO_T}no" >&6
6676 fi
6677
6678   done
6679 fi
6680
6681 for ncn_progname in ld; do
6682   if test -n "$ncn_tool_prefix"; then
6683     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6684 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6685 echo "$as_me:$LINENO: checking for $ac_word" >&5
6686 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6687 if test "${ac_cv_prog_LD+set}" = set; then
6688   echo $ECHO_N "(cached) $ECHO_C" >&6
6689 else
6690   if test -n "$LD"; then
6691   ac_cv_prog_LD="$LD" # Let the user override the test.
6692 else
6693 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6694 for as_dir in $PATH
6695 do
6696   IFS=$as_save_IFS
6697   test -z "$as_dir" && as_dir=.
6698   for ac_exec_ext in '' $ac_executable_extensions; do
6699   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6700     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6701     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6702     break 2
6703   fi
6704 done
6705 done
6706
6707 fi
6708 fi
6709 LD=$ac_cv_prog_LD
6710 if test -n "$LD"; then
6711   echo "$as_me:$LINENO: result: $LD" >&5
6712 echo "${ECHO_T}$LD" >&6
6713 else
6714   echo "$as_me:$LINENO: result: no" >&5
6715 echo "${ECHO_T}no" >&6
6716 fi
6717
6718   fi
6719   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6720     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6721 set dummy ${ncn_progname}; ac_word=$2
6722 echo "$as_me:$LINENO: checking for $ac_word" >&5
6723 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6724 if test "${ac_cv_prog_LD+set}" = set; then
6725   echo $ECHO_N "(cached) $ECHO_C" >&6
6726 else
6727   if test -n "$LD"; then
6728   ac_cv_prog_LD="$LD" # Let the user override the test.
6729 else
6730 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6731 for as_dir in $PATH
6732 do
6733   IFS=$as_save_IFS
6734   test -z "$as_dir" && as_dir=.
6735   for ac_exec_ext in '' $ac_executable_extensions; do
6736   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6737     ac_cv_prog_LD="${ncn_progname}"
6738     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6739     break 2
6740   fi
6741 done
6742 done
6743
6744 fi
6745 fi
6746 LD=$ac_cv_prog_LD
6747 if test -n "$LD"; then
6748   echo "$as_me:$LINENO: result: $LD" >&5
6749 echo "${ECHO_T}$LD" >&6
6750 else
6751   echo "$as_me:$LINENO: result: no" >&5
6752 echo "${ECHO_T}no" >&6
6753 fi
6754
6755   fi
6756   test -n "$ac_cv_prog_LD" && break
6757 done
6758
6759 if test -z "$ac_cv_prog_LD" ; then
6760   set dummy ld
6761   if test $build = $host ; then
6762     LD="$2"
6763   else
6764     LD="${ncn_tool_prefix}$2"
6765   fi
6766 fi
6767
6768
6769
6770 if test -n "$LIPO"; then
6771   ac_cv_prog_LIPO=$LIPO
6772 elif test -n "$ac_cv_prog_LIPO"; then
6773   LIPO=$ac_cv_prog_LIPO
6774 fi
6775
6776 if test -n "$ac_cv_prog_LIPO"; then
6777   for ncn_progname in lipo; do
6778     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6779 set dummy ${ncn_progname}; ac_word=$2
6780 echo "$as_me:$LINENO: checking for $ac_word" >&5
6781 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6782 if test "${ac_cv_prog_LIPO+set}" = set; then
6783   echo $ECHO_N "(cached) $ECHO_C" >&6
6784 else
6785   if test -n "$LIPO"; then
6786   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6787 else
6788 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6789 for as_dir in $PATH
6790 do
6791   IFS=$as_save_IFS
6792   test -z "$as_dir" && as_dir=.
6793   for ac_exec_ext in '' $ac_executable_extensions; do
6794   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6795     ac_cv_prog_LIPO="${ncn_progname}"
6796     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6797     break 2
6798   fi
6799 done
6800 done
6801
6802 fi
6803 fi
6804 LIPO=$ac_cv_prog_LIPO
6805 if test -n "$LIPO"; then
6806   echo "$as_me:$LINENO: result: $LIPO" >&5
6807 echo "${ECHO_T}$LIPO" >&6
6808 else
6809   echo "$as_me:$LINENO: result: no" >&5
6810 echo "${ECHO_T}no" >&6
6811 fi
6812
6813   done
6814 fi
6815
6816 for ncn_progname in lipo; do
6817   if test -n "$ncn_tool_prefix"; then
6818     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6819 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6820 echo "$as_me:$LINENO: checking for $ac_word" >&5
6821 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6822 if test "${ac_cv_prog_LIPO+set}" = set; then
6823   echo $ECHO_N "(cached) $ECHO_C" >&6
6824 else
6825   if test -n "$LIPO"; then
6826   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6827 else
6828 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6829 for as_dir in $PATH
6830 do
6831   IFS=$as_save_IFS
6832   test -z "$as_dir" && as_dir=.
6833   for ac_exec_ext in '' $ac_executable_extensions; do
6834   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6835     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
6836     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6837     break 2
6838   fi
6839 done
6840 done
6841
6842 fi
6843 fi
6844 LIPO=$ac_cv_prog_LIPO
6845 if test -n "$LIPO"; then
6846   echo "$as_me:$LINENO: result: $LIPO" >&5
6847 echo "${ECHO_T}$LIPO" >&6
6848 else
6849   echo "$as_me:$LINENO: result: no" >&5
6850 echo "${ECHO_T}no" >&6
6851 fi
6852
6853   fi
6854   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
6855     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6856 set dummy ${ncn_progname}; ac_word=$2
6857 echo "$as_me:$LINENO: checking for $ac_word" >&5
6858 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6859 if test "${ac_cv_prog_LIPO+set}" = set; then
6860   echo $ECHO_N "(cached) $ECHO_C" >&6
6861 else
6862   if test -n "$LIPO"; then
6863   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6864 else
6865 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6866 for as_dir in $PATH
6867 do
6868   IFS=$as_save_IFS
6869   test -z "$as_dir" && as_dir=.
6870   for ac_exec_ext in '' $ac_executable_extensions; do
6871   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6872     ac_cv_prog_LIPO="${ncn_progname}"
6873     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6874     break 2
6875   fi
6876 done
6877 done
6878
6879 fi
6880 fi
6881 LIPO=$ac_cv_prog_LIPO
6882 if test -n "$LIPO"; then
6883   echo "$as_me:$LINENO: result: $LIPO" >&5
6884 echo "${ECHO_T}$LIPO" >&6
6885 else
6886   echo "$as_me:$LINENO: result: no" >&5
6887 echo "${ECHO_T}no" >&6
6888 fi
6889
6890   fi
6891   test -n "$ac_cv_prog_LIPO" && break
6892 done
6893
6894 if test -z "$ac_cv_prog_LIPO" ; then
6895   set dummy lipo
6896   if test $build = $host ; then
6897     LIPO="$2"
6898   else
6899     LIPO="${ncn_tool_prefix}$2"
6900   fi
6901 fi
6902
6903
6904
6905 if test -n "$NM"; then
6906   ac_cv_prog_NM=$NM
6907 elif test -n "$ac_cv_prog_NM"; then
6908   NM=$ac_cv_prog_NM
6909 fi
6910
6911 if test -n "$ac_cv_prog_NM"; then
6912   for ncn_progname in nm; do
6913     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6914 set dummy ${ncn_progname}; ac_word=$2
6915 echo "$as_me:$LINENO: checking for $ac_word" >&5
6916 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6917 if test "${ac_cv_prog_NM+set}" = set; then
6918   echo $ECHO_N "(cached) $ECHO_C" >&6
6919 else
6920   if test -n "$NM"; then
6921   ac_cv_prog_NM="$NM" # Let the user override the test.
6922 else
6923 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6924 for as_dir in $PATH
6925 do
6926   IFS=$as_save_IFS
6927   test -z "$as_dir" && as_dir=.
6928   for ac_exec_ext in '' $ac_executable_extensions; do
6929   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6930     ac_cv_prog_NM="${ncn_progname}"
6931     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6932     break 2
6933   fi
6934 done
6935 done
6936
6937 fi
6938 fi
6939 NM=$ac_cv_prog_NM
6940 if test -n "$NM"; then
6941   echo "$as_me:$LINENO: result: $NM" >&5
6942 echo "${ECHO_T}$NM" >&6
6943 else
6944   echo "$as_me:$LINENO: result: no" >&5
6945 echo "${ECHO_T}no" >&6
6946 fi
6947
6948   done
6949 fi
6950
6951 for ncn_progname in nm; do
6952   if test -n "$ncn_tool_prefix"; then
6953     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6954 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6955 echo "$as_me:$LINENO: checking for $ac_word" >&5
6956 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6957 if test "${ac_cv_prog_NM+set}" = set; then
6958   echo $ECHO_N "(cached) $ECHO_C" >&6
6959 else
6960   if test -n "$NM"; then
6961   ac_cv_prog_NM="$NM" # Let the user override the test.
6962 else
6963 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6964 for as_dir in $PATH
6965 do
6966   IFS=$as_save_IFS
6967   test -z "$as_dir" && as_dir=.
6968   for ac_exec_ext in '' $ac_executable_extensions; do
6969   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6970     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
6971     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6972     break 2
6973   fi
6974 done
6975 done
6976
6977 fi
6978 fi
6979 NM=$ac_cv_prog_NM
6980 if test -n "$NM"; then
6981   echo "$as_me:$LINENO: result: $NM" >&5
6982 echo "${ECHO_T}$NM" >&6
6983 else
6984   echo "$as_me:$LINENO: result: no" >&5
6985 echo "${ECHO_T}no" >&6
6986 fi
6987
6988   fi
6989   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
6990     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6991 set dummy ${ncn_progname}; ac_word=$2
6992 echo "$as_me:$LINENO: checking for $ac_word" >&5
6993 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6994 if test "${ac_cv_prog_NM+set}" = set; then
6995   echo $ECHO_N "(cached) $ECHO_C" >&6
6996 else
6997   if test -n "$NM"; then
6998   ac_cv_prog_NM="$NM" # Let the user override the test.
6999 else
7000 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7001 for as_dir in $PATH
7002 do
7003   IFS=$as_save_IFS
7004   test -z "$as_dir" && as_dir=.
7005   for ac_exec_ext in '' $ac_executable_extensions; do
7006   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7007     ac_cv_prog_NM="${ncn_progname}"
7008     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7009     break 2
7010   fi
7011 done
7012 done
7013
7014 fi
7015 fi
7016 NM=$ac_cv_prog_NM
7017 if test -n "$NM"; then
7018   echo "$as_me:$LINENO: result: $NM" >&5
7019 echo "${ECHO_T}$NM" >&6
7020 else
7021   echo "$as_me:$LINENO: result: no" >&5
7022 echo "${ECHO_T}no" >&6
7023 fi
7024
7025   fi
7026   test -n "$ac_cv_prog_NM" && break
7027 done
7028
7029 if test -z "$ac_cv_prog_NM" ; then
7030   set dummy nm
7031   if test $build = $host ; then
7032     NM="$2"
7033   else
7034     NM="${ncn_tool_prefix}$2"
7035   fi
7036 fi
7037
7038
7039
7040 if test -n "$RANLIB"; then
7041   ac_cv_prog_RANLIB=$RANLIB
7042 elif test -n "$ac_cv_prog_RANLIB"; then
7043   RANLIB=$ac_cv_prog_RANLIB
7044 fi
7045
7046 if test -n "$ac_cv_prog_RANLIB"; then
7047   for ncn_progname in ranlib; do
7048     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7049 set dummy ${ncn_progname}; ac_word=$2
7050 echo "$as_me:$LINENO: checking for $ac_word" >&5
7051 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7052 if test "${ac_cv_prog_RANLIB+set}" = set; then
7053   echo $ECHO_N "(cached) $ECHO_C" >&6
7054 else
7055   if test -n "$RANLIB"; then
7056   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7057 else
7058 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7059 for as_dir in $PATH
7060 do
7061   IFS=$as_save_IFS
7062   test -z "$as_dir" && as_dir=.
7063   for ac_exec_ext in '' $ac_executable_extensions; do
7064   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7065     ac_cv_prog_RANLIB="${ncn_progname}"
7066     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7067     break 2
7068   fi
7069 done
7070 done
7071
7072 fi
7073 fi
7074 RANLIB=$ac_cv_prog_RANLIB
7075 if test -n "$RANLIB"; then
7076   echo "$as_me:$LINENO: result: $RANLIB" >&5
7077 echo "${ECHO_T}$RANLIB" >&6
7078 else
7079   echo "$as_me:$LINENO: result: no" >&5
7080 echo "${ECHO_T}no" >&6
7081 fi
7082
7083   done
7084 fi
7085
7086 for ncn_progname in ranlib; do
7087   if test -n "$ncn_tool_prefix"; then
7088     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7089 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7090 echo "$as_me:$LINENO: checking for $ac_word" >&5
7091 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7092 if test "${ac_cv_prog_RANLIB+set}" = set; then
7093   echo $ECHO_N "(cached) $ECHO_C" >&6
7094 else
7095   if test -n "$RANLIB"; then
7096   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7097 else
7098 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7099 for as_dir in $PATH
7100 do
7101   IFS=$as_save_IFS
7102   test -z "$as_dir" && as_dir=.
7103   for ac_exec_ext in '' $ac_executable_extensions; do
7104   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7105     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7106     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7107     break 2
7108   fi
7109 done
7110 done
7111
7112 fi
7113 fi
7114 RANLIB=$ac_cv_prog_RANLIB
7115 if test -n "$RANLIB"; then
7116   echo "$as_me:$LINENO: result: $RANLIB" >&5
7117 echo "${ECHO_T}$RANLIB" >&6
7118 else
7119   echo "$as_me:$LINENO: result: no" >&5
7120 echo "${ECHO_T}no" >&6
7121 fi
7122
7123   fi
7124   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7125     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7126 set dummy ${ncn_progname}; ac_word=$2
7127 echo "$as_me:$LINENO: checking for $ac_word" >&5
7128 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7129 if test "${ac_cv_prog_RANLIB+set}" = set; then
7130   echo $ECHO_N "(cached) $ECHO_C" >&6
7131 else
7132   if test -n "$RANLIB"; then
7133   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7134 else
7135 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7136 for as_dir in $PATH
7137 do
7138   IFS=$as_save_IFS
7139   test -z "$as_dir" && as_dir=.
7140   for ac_exec_ext in '' $ac_executable_extensions; do
7141   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7142     ac_cv_prog_RANLIB="${ncn_progname}"
7143     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7144     break 2
7145   fi
7146 done
7147 done
7148
7149 fi
7150 fi
7151 RANLIB=$ac_cv_prog_RANLIB
7152 if test -n "$RANLIB"; then
7153   echo "$as_me:$LINENO: result: $RANLIB" >&5
7154 echo "${ECHO_T}$RANLIB" >&6
7155 else
7156   echo "$as_me:$LINENO: result: no" >&5
7157 echo "${ECHO_T}no" >&6
7158 fi
7159
7160   fi
7161   test -n "$ac_cv_prog_RANLIB" && break
7162 done
7163
7164 if test -z "$ac_cv_prog_RANLIB" ; then
7165   RANLIB=":"
7166 fi
7167
7168
7169
7170 if test -n "$STRIP"; then
7171   ac_cv_prog_STRIP=$STRIP
7172 elif test -n "$ac_cv_prog_STRIP"; then
7173   STRIP=$ac_cv_prog_STRIP
7174 fi
7175
7176 if test -n "$ac_cv_prog_STRIP"; then
7177   for ncn_progname in strip; do
7178     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7179 set dummy ${ncn_progname}; ac_word=$2
7180 echo "$as_me:$LINENO: checking for $ac_word" >&5
7181 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7182 if test "${ac_cv_prog_STRIP+set}" = set; then
7183   echo $ECHO_N "(cached) $ECHO_C" >&6
7184 else
7185   if test -n "$STRIP"; then
7186   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7187 else
7188 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7189 for as_dir in $PATH
7190 do
7191   IFS=$as_save_IFS
7192   test -z "$as_dir" && as_dir=.
7193   for ac_exec_ext in '' $ac_executable_extensions; do
7194   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7195     ac_cv_prog_STRIP="${ncn_progname}"
7196     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7197     break 2
7198   fi
7199 done
7200 done
7201
7202 fi
7203 fi
7204 STRIP=$ac_cv_prog_STRIP
7205 if test -n "$STRIP"; then
7206   echo "$as_me:$LINENO: result: $STRIP" >&5
7207 echo "${ECHO_T}$STRIP" >&6
7208 else
7209   echo "$as_me:$LINENO: result: no" >&5
7210 echo "${ECHO_T}no" >&6
7211 fi
7212
7213   done
7214 fi
7215
7216 for ncn_progname in strip; do
7217   if test -n "$ncn_tool_prefix"; then
7218     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7219 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7220 echo "$as_me:$LINENO: checking for $ac_word" >&5
7221 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7222 if test "${ac_cv_prog_STRIP+set}" = set; then
7223   echo $ECHO_N "(cached) $ECHO_C" >&6
7224 else
7225   if test -n "$STRIP"; then
7226   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7227 else
7228 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7229 for as_dir in $PATH
7230 do
7231   IFS=$as_save_IFS
7232   test -z "$as_dir" && as_dir=.
7233   for ac_exec_ext in '' $ac_executable_extensions; do
7234   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7235     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7236     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7237     break 2
7238   fi
7239 done
7240 done
7241
7242 fi
7243 fi
7244 STRIP=$ac_cv_prog_STRIP
7245 if test -n "$STRIP"; then
7246   echo "$as_me:$LINENO: result: $STRIP" >&5
7247 echo "${ECHO_T}$STRIP" >&6
7248 else
7249   echo "$as_me:$LINENO: result: no" >&5
7250 echo "${ECHO_T}no" >&6
7251 fi
7252
7253   fi
7254   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7255     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7256 set dummy ${ncn_progname}; ac_word=$2
7257 echo "$as_me:$LINENO: checking for $ac_word" >&5
7258 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7259 if test "${ac_cv_prog_STRIP+set}" = set; then
7260   echo $ECHO_N "(cached) $ECHO_C" >&6
7261 else
7262   if test -n "$STRIP"; then
7263   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7264 else
7265 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7266 for as_dir in $PATH
7267 do
7268   IFS=$as_save_IFS
7269   test -z "$as_dir" && as_dir=.
7270   for ac_exec_ext in '' $ac_executable_extensions; do
7271   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7272     ac_cv_prog_STRIP="${ncn_progname}"
7273     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7274     break 2
7275   fi
7276 done
7277 done
7278
7279 fi
7280 fi
7281 STRIP=$ac_cv_prog_STRIP
7282 if test -n "$STRIP"; then
7283   echo "$as_me:$LINENO: result: $STRIP" >&5
7284 echo "${ECHO_T}$STRIP" >&6
7285 else
7286   echo "$as_me:$LINENO: result: no" >&5
7287 echo "${ECHO_T}no" >&6
7288 fi
7289
7290   fi
7291   test -n "$ac_cv_prog_STRIP" && break
7292 done
7293
7294 if test -z "$ac_cv_prog_STRIP" ; then
7295   STRIP=":"
7296 fi
7297
7298
7299
7300 if test -n "$WINDRES"; then
7301   ac_cv_prog_WINDRES=$WINDRES
7302 elif test -n "$ac_cv_prog_WINDRES"; then
7303   WINDRES=$ac_cv_prog_WINDRES
7304 fi
7305
7306 if test -n "$ac_cv_prog_WINDRES"; then
7307   for ncn_progname in windres; do
7308     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7309 set dummy ${ncn_progname}; ac_word=$2
7310 echo "$as_me:$LINENO: checking for $ac_word" >&5
7311 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7312 if test "${ac_cv_prog_WINDRES+set}" = set; then
7313   echo $ECHO_N "(cached) $ECHO_C" >&6
7314 else
7315   if test -n "$WINDRES"; then
7316   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7317 else
7318 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7319 for as_dir in $PATH
7320 do
7321   IFS=$as_save_IFS
7322   test -z "$as_dir" && as_dir=.
7323   for ac_exec_ext in '' $ac_executable_extensions; do
7324   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7325     ac_cv_prog_WINDRES="${ncn_progname}"
7326     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7327     break 2
7328   fi
7329 done
7330 done
7331
7332 fi
7333 fi
7334 WINDRES=$ac_cv_prog_WINDRES
7335 if test -n "$WINDRES"; then
7336   echo "$as_me:$LINENO: result: $WINDRES" >&5
7337 echo "${ECHO_T}$WINDRES" >&6
7338 else
7339   echo "$as_me:$LINENO: result: no" >&5
7340 echo "${ECHO_T}no" >&6
7341 fi
7342
7343   done
7344 fi
7345
7346 for ncn_progname in windres; do
7347   if test -n "$ncn_tool_prefix"; then
7348     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7349 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7350 echo "$as_me:$LINENO: checking for $ac_word" >&5
7351 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7352 if test "${ac_cv_prog_WINDRES+set}" = set; then
7353   echo $ECHO_N "(cached) $ECHO_C" >&6
7354 else
7355   if test -n "$WINDRES"; then
7356   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7357 else
7358 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7359 for as_dir in $PATH
7360 do
7361   IFS=$as_save_IFS
7362   test -z "$as_dir" && as_dir=.
7363   for ac_exec_ext in '' $ac_executable_extensions; do
7364   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7365     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7366     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7367     break 2
7368   fi
7369 done
7370 done
7371
7372 fi
7373 fi
7374 WINDRES=$ac_cv_prog_WINDRES
7375 if test -n "$WINDRES"; then
7376   echo "$as_me:$LINENO: result: $WINDRES" >&5
7377 echo "${ECHO_T}$WINDRES" >&6
7378 else
7379   echo "$as_me:$LINENO: result: no" >&5
7380 echo "${ECHO_T}no" >&6
7381 fi
7382
7383   fi
7384   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7385     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7386 set dummy ${ncn_progname}; ac_word=$2
7387 echo "$as_me:$LINENO: checking for $ac_word" >&5
7388 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7389 if test "${ac_cv_prog_WINDRES+set}" = set; then
7390   echo $ECHO_N "(cached) $ECHO_C" >&6
7391 else
7392   if test -n "$WINDRES"; then
7393   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7394 else
7395 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7396 for as_dir in $PATH
7397 do
7398   IFS=$as_save_IFS
7399   test -z "$as_dir" && as_dir=.
7400   for ac_exec_ext in '' $ac_executable_extensions; do
7401   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7402     ac_cv_prog_WINDRES="${ncn_progname}"
7403     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7404     break 2
7405   fi
7406 done
7407 done
7408
7409 fi
7410 fi
7411 WINDRES=$ac_cv_prog_WINDRES
7412 if test -n "$WINDRES"; then
7413   echo "$as_me:$LINENO: result: $WINDRES" >&5
7414 echo "${ECHO_T}$WINDRES" >&6
7415 else
7416   echo "$as_me:$LINENO: result: no" >&5
7417 echo "${ECHO_T}no" >&6
7418 fi
7419
7420   fi
7421   test -n "$ac_cv_prog_WINDRES" && break
7422 done
7423
7424 if test -z "$ac_cv_prog_WINDRES" ; then
7425   set dummy windres
7426   if test $build = $host ; then
7427     WINDRES="$2"
7428   else
7429     WINDRES="${ncn_tool_prefix}$2"
7430   fi
7431 fi
7432
7433
7434
7435 if test -n "$OBJCOPY"; then
7436   ac_cv_prog_OBJCOPY=$OBJCOPY
7437 elif test -n "$ac_cv_prog_OBJCOPY"; then
7438   OBJCOPY=$ac_cv_prog_OBJCOPY
7439 fi
7440
7441 if test -n "$ac_cv_prog_OBJCOPY"; then
7442   for ncn_progname in objcopy; do
7443     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7444 set dummy ${ncn_progname}; ac_word=$2
7445 echo "$as_me:$LINENO: checking for $ac_word" >&5
7446 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7447 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7448   echo $ECHO_N "(cached) $ECHO_C" >&6
7449 else
7450   if test -n "$OBJCOPY"; then
7451   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7452 else
7453 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7454 for as_dir in $PATH
7455 do
7456   IFS=$as_save_IFS
7457   test -z "$as_dir" && as_dir=.
7458   for ac_exec_ext in '' $ac_executable_extensions; do
7459   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7460     ac_cv_prog_OBJCOPY="${ncn_progname}"
7461     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7462     break 2
7463   fi
7464 done
7465 done
7466
7467 fi
7468 fi
7469 OBJCOPY=$ac_cv_prog_OBJCOPY
7470 if test -n "$OBJCOPY"; then
7471   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7472 echo "${ECHO_T}$OBJCOPY" >&6
7473 else
7474   echo "$as_me:$LINENO: result: no" >&5
7475 echo "${ECHO_T}no" >&6
7476 fi
7477
7478   done
7479 fi
7480
7481 for ncn_progname in objcopy; do
7482   if test -n "$ncn_tool_prefix"; then
7483     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7484 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7485 echo "$as_me:$LINENO: checking for $ac_word" >&5
7486 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7487 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7488   echo $ECHO_N "(cached) $ECHO_C" >&6
7489 else
7490   if test -n "$OBJCOPY"; then
7491   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7492 else
7493 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7494 for as_dir in $PATH
7495 do
7496   IFS=$as_save_IFS
7497   test -z "$as_dir" && as_dir=.
7498   for ac_exec_ext in '' $ac_executable_extensions; do
7499   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7500     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7501     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7502     break 2
7503   fi
7504 done
7505 done
7506
7507 fi
7508 fi
7509 OBJCOPY=$ac_cv_prog_OBJCOPY
7510 if test -n "$OBJCOPY"; then
7511   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7512 echo "${ECHO_T}$OBJCOPY" >&6
7513 else
7514   echo "$as_me:$LINENO: result: no" >&5
7515 echo "${ECHO_T}no" >&6
7516 fi
7517
7518   fi
7519   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7520     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7521 set dummy ${ncn_progname}; ac_word=$2
7522 echo "$as_me:$LINENO: checking for $ac_word" >&5
7523 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7524 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7525   echo $ECHO_N "(cached) $ECHO_C" >&6
7526 else
7527   if test -n "$OBJCOPY"; then
7528   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7529 else
7530 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7531 for as_dir in $PATH
7532 do
7533   IFS=$as_save_IFS
7534   test -z "$as_dir" && as_dir=.
7535   for ac_exec_ext in '' $ac_executable_extensions; do
7536   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7537     ac_cv_prog_OBJCOPY="${ncn_progname}"
7538     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7539     break 2
7540   fi
7541 done
7542 done
7543
7544 fi
7545 fi
7546 OBJCOPY=$ac_cv_prog_OBJCOPY
7547 if test -n "$OBJCOPY"; then
7548   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7549 echo "${ECHO_T}$OBJCOPY" >&6
7550 else
7551   echo "$as_me:$LINENO: result: no" >&5
7552 echo "${ECHO_T}no" >&6
7553 fi
7554
7555   fi
7556   test -n "$ac_cv_prog_OBJCOPY" && break
7557 done
7558
7559 if test -z "$ac_cv_prog_OBJCOPY" ; then
7560   set dummy objcopy
7561   if test $build = $host ; then
7562     OBJCOPY="$2"
7563   else
7564     OBJCOPY="${ncn_tool_prefix}$2"
7565   fi
7566 fi
7567
7568
7569
7570 if test -n "$OBJDUMP"; then
7571   ac_cv_prog_OBJDUMP=$OBJDUMP
7572 elif test -n "$ac_cv_prog_OBJDUMP"; then
7573   OBJDUMP=$ac_cv_prog_OBJDUMP
7574 fi
7575
7576 if test -n "$ac_cv_prog_OBJDUMP"; then
7577   for ncn_progname in objdump; do
7578     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7579 set dummy ${ncn_progname}; ac_word=$2
7580 echo "$as_me:$LINENO: checking for $ac_word" >&5
7581 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7582 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7583   echo $ECHO_N "(cached) $ECHO_C" >&6
7584 else
7585   if test -n "$OBJDUMP"; then
7586   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7587 else
7588 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7589 for as_dir in $PATH
7590 do
7591   IFS=$as_save_IFS
7592   test -z "$as_dir" && as_dir=.
7593   for ac_exec_ext in '' $ac_executable_extensions; do
7594   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7595     ac_cv_prog_OBJDUMP="${ncn_progname}"
7596     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7597     break 2
7598   fi
7599 done
7600 done
7601
7602 fi
7603 fi
7604 OBJDUMP=$ac_cv_prog_OBJDUMP
7605 if test -n "$OBJDUMP"; then
7606   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7607 echo "${ECHO_T}$OBJDUMP" >&6
7608 else
7609   echo "$as_me:$LINENO: result: no" >&5
7610 echo "${ECHO_T}no" >&6
7611 fi
7612
7613   done
7614 fi
7615
7616 for ncn_progname in objdump; do
7617   if test -n "$ncn_tool_prefix"; then
7618     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7619 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7620 echo "$as_me:$LINENO: checking for $ac_word" >&5
7621 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7622 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7623   echo $ECHO_N "(cached) $ECHO_C" >&6
7624 else
7625   if test -n "$OBJDUMP"; then
7626   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7627 else
7628 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7629 for as_dir in $PATH
7630 do
7631   IFS=$as_save_IFS
7632   test -z "$as_dir" && as_dir=.
7633   for ac_exec_ext in '' $ac_executable_extensions; do
7634   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7635     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7636     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7637     break 2
7638   fi
7639 done
7640 done
7641
7642 fi
7643 fi
7644 OBJDUMP=$ac_cv_prog_OBJDUMP
7645 if test -n "$OBJDUMP"; then
7646   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7647 echo "${ECHO_T}$OBJDUMP" >&6
7648 else
7649   echo "$as_me:$LINENO: result: no" >&5
7650 echo "${ECHO_T}no" >&6
7651 fi
7652
7653   fi
7654   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7655     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7656 set dummy ${ncn_progname}; ac_word=$2
7657 echo "$as_me:$LINENO: checking for $ac_word" >&5
7658 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7659 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7660   echo $ECHO_N "(cached) $ECHO_C" >&6
7661 else
7662   if test -n "$OBJDUMP"; then
7663   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7664 else
7665 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7666 for as_dir in $PATH
7667 do
7668   IFS=$as_save_IFS
7669   test -z "$as_dir" && as_dir=.
7670   for ac_exec_ext in '' $ac_executable_extensions; do
7671   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7672     ac_cv_prog_OBJDUMP="${ncn_progname}"
7673     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7674     break 2
7675   fi
7676 done
7677 done
7678
7679 fi
7680 fi
7681 OBJDUMP=$ac_cv_prog_OBJDUMP
7682 if test -n "$OBJDUMP"; then
7683   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7684 echo "${ECHO_T}$OBJDUMP" >&6
7685 else
7686   echo "$as_me:$LINENO: result: no" >&5
7687 echo "${ECHO_T}no" >&6
7688 fi
7689
7690   fi
7691   test -n "$ac_cv_prog_OBJDUMP" && break
7692 done
7693
7694 if test -z "$ac_cv_prog_OBJDUMP" ; then
7695   set dummy objdump
7696   if test $build = $host ; then
7697     OBJDUMP="$2"
7698   else
7699     OBJDUMP="${ncn_tool_prefix}$2"
7700   fi
7701 fi
7702
7703
7704
7705
7706
7707
7708
7709 # Target tools.
7710
7711 # Check whether --with-build-time-tools or --without-build-time-tools was given.
7712 if test "${with_build_time_tools+set}" = set; then
7713   withval="$with_build_time_tools"
7714   case x"$withval" in
7715      x/*) ;;
7716      *)
7717        with_build_time_tools=
7718        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
7719 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
7720        ;;
7721    esac
7722 else
7723   with_build_time_tools=
7724 fi;
7725
7726
7727
7728 if test -n "$CC_FOR_TARGET"; then
7729   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
7730 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7731   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7732 fi
7733
7734 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7735   for ncn_progname in cc gcc; do
7736     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7737 set dummy ${ncn_progname}; ac_word=$2
7738 echo "$as_me:$LINENO: checking for $ac_word" >&5
7739 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7740 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7741   echo $ECHO_N "(cached) $ECHO_C" >&6
7742 else
7743   if test -n "$CC_FOR_TARGET"; then
7744   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7745 else
7746 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7747 for as_dir in $PATH
7748 do
7749   IFS=$as_save_IFS
7750   test -z "$as_dir" && as_dir=.
7751   for ac_exec_ext in '' $ac_executable_extensions; do
7752   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7753     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7754     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7755     break 2
7756   fi
7757 done
7758 done
7759
7760 fi
7761 fi
7762 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7763 if test -n "$CC_FOR_TARGET"; then
7764   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7765 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7766 else
7767   echo "$as_me:$LINENO: result: no" >&5
7768 echo "${ECHO_T}no" >&6
7769 fi
7770
7771   done
7772 fi
7773
7774 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
7775   for ncn_progname in cc gcc; do
7776     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
7777 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
7778     if test -x $with_build_time_tools/${ncn_progname}; then
7779       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
7780       echo "$as_me:$LINENO: result: yes" >&5
7781 echo "${ECHO_T}yes" >&6
7782       break
7783     else
7784       echo "$as_me:$LINENO: result: no" >&5
7785 echo "${ECHO_T}no" >&6
7786     fi
7787   done
7788 fi
7789
7790 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
7791   for ncn_progname in cc gcc; do
7792     if test -n "$ncn_target_tool_prefix"; then
7793       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
7794 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
7795 echo "$as_me:$LINENO: checking for $ac_word" >&5
7796 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7797 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7798   echo $ECHO_N "(cached) $ECHO_C" >&6
7799 else
7800   if test -n "$CC_FOR_TARGET"; then
7801   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7802 else
7803 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7804 for as_dir in $PATH
7805 do
7806   IFS=$as_save_IFS
7807   test -z "$as_dir" && as_dir=.
7808   for ac_exec_ext in '' $ac_executable_extensions; do
7809   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7810     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
7811     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7812     break 2
7813   fi
7814 done
7815 done
7816
7817 fi
7818 fi
7819 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7820 if test -n "$CC_FOR_TARGET"; then
7821   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7822 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7823 else
7824   echo "$as_me:$LINENO: result: no" >&5
7825 echo "${ECHO_T}no" >&6
7826 fi
7827
7828     fi
7829     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
7830       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7831 set dummy ${ncn_progname}; ac_word=$2
7832 echo "$as_me:$LINENO: checking for $ac_word" >&5
7833 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7834 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7835   echo $ECHO_N "(cached) $ECHO_C" >&6
7836 else
7837   if test -n "$CC_FOR_TARGET"; then
7838   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7839 else
7840 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7841 for as_dir in $PATH
7842 do
7843   IFS=$as_save_IFS
7844   test -z "$as_dir" && as_dir=.
7845   for ac_exec_ext in '' $ac_executable_extensions; do
7846   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7847     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7848     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7849     break 2
7850   fi
7851 done
7852 done
7853
7854 fi
7855 fi
7856 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7857 if test -n "$CC_FOR_TARGET"; then
7858   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7859 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7860 else
7861   echo "$as_me:$LINENO: result: no" >&5
7862 echo "${ECHO_T}no" >&6
7863 fi
7864
7865     fi
7866     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
7867   done
7868 fi
7869
7870 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
7871   set dummy cc gcc
7872   if test $build = $target ; then
7873     CC_FOR_TARGET="$2"
7874   else
7875     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
7876   fi
7877 fi
7878
7879
7880
7881 if test -n "$CXX_FOR_TARGET"; then
7882   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
7883 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
7884   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
7885 fi
7886
7887 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
7888   for ncn_progname in c++ g++ cxx gxx; do
7889     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7890 set dummy ${ncn_progname}; ac_word=$2
7891 echo "$as_me:$LINENO: checking for $ac_word" >&5
7892 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7893 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
7894   echo $ECHO_N "(cached) $ECHO_C" >&6
7895 else
7896   if test -n "$CXX_FOR_TARGET"; then
7897   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
7898 else
7899 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7900 for as_dir in $PATH
7901 do
7902   IFS=$as_save_IFS
7903   test -z "$as_dir" && as_dir=.
7904   for ac_exec_ext in '' $ac_executable_extensions; do
7905   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7906     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
7907     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7908     break 2
7909   fi
7910 done
7911 done
7912
7913 fi
7914 fi
7915 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
7916 if test -n "$CXX_FOR_TARGET"; then
7917   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
7918 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
7919 else
7920   echo "$as_me:$LINENO: result: no" >&5
7921 echo "${ECHO_T}no" >&6
7922 fi
7923
7924   done
7925 fi
7926
7927 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
7928   for ncn_progname in c++ g++ cxx gxx; do
7929     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
7930 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
7931     if test -x $with_build_time_tools/${ncn_progname}; then
7932       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
7933       echo "$as_me:$LINENO: result: yes" >&5
7934 echo "${ECHO_T}yes" >&6
7935       break
7936     else
7937       echo "$as_me:$LINENO: result: no" >&5
7938 echo "${ECHO_T}no" >&6
7939     fi
7940   done
7941 fi
7942
7943 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
7944   for ncn_progname in c++ g++ cxx gxx; do
7945     if test -n "$ncn_target_tool_prefix"; then
7946       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
7947 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
7948 echo "$as_me:$LINENO: checking for $ac_word" >&5
7949 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7950 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
7951   echo $ECHO_N "(cached) $ECHO_C" >&6
7952 else
7953   if test -n "$CXX_FOR_TARGET"; then
7954   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
7955 else
7956 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7957 for as_dir in $PATH
7958 do
7959   IFS=$as_save_IFS
7960   test -z "$as_dir" && as_dir=.
7961   for ac_exec_ext in '' $ac_executable_extensions; do
7962   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7963     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
7964     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7965     break 2
7966   fi
7967 done
7968 done
7969
7970 fi
7971 fi
7972 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
7973 if test -n "$CXX_FOR_TARGET"; then
7974   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
7975 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
7976 else
7977   echo "$as_me:$LINENO: result: no" >&5
7978 echo "${ECHO_T}no" >&6
7979 fi
7980
7981     fi
7982     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
7983       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7984 set dummy ${ncn_progname}; ac_word=$2
7985 echo "$as_me:$LINENO: checking for $ac_word" >&5
7986 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7987 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
7988   echo $ECHO_N "(cached) $ECHO_C" >&6
7989 else
7990   if test -n "$CXX_FOR_TARGET"; then
7991   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
7992 else
7993 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7994 for as_dir in $PATH
7995 do
7996   IFS=$as_save_IFS
7997   test -z "$as_dir" && as_dir=.
7998   for ac_exec_ext in '' $ac_executable_extensions; do
7999   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8000     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8001     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8002     break 2
8003   fi
8004 done
8005 done
8006
8007 fi
8008 fi
8009 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8010 if test -n "$CXX_FOR_TARGET"; then
8011   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8012 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8013 else
8014   echo "$as_me:$LINENO: result: no" >&5
8015 echo "${ECHO_T}no" >&6
8016 fi
8017
8018     fi
8019     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8020   done
8021 fi
8022
8023 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8024   set dummy c++ g++ cxx gxx
8025   if test $build = $target ; then
8026     CXX_FOR_TARGET="$2"
8027   else
8028     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8029   fi
8030 fi
8031
8032
8033
8034 if test -n "$GCC_FOR_TARGET"; then
8035   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8036 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8037   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8038 fi
8039
8040 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8041   for ncn_progname in gcc; do
8042     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8043 set dummy ${ncn_progname}; ac_word=$2
8044 echo "$as_me:$LINENO: checking for $ac_word" >&5
8045 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8046 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8047   echo $ECHO_N "(cached) $ECHO_C" >&6
8048 else
8049   if test -n "$GCC_FOR_TARGET"; then
8050   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8051 else
8052 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8053 for as_dir in $PATH
8054 do
8055   IFS=$as_save_IFS
8056   test -z "$as_dir" && as_dir=.
8057   for ac_exec_ext in '' $ac_executable_extensions; do
8058   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8059     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8060     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8061     break 2
8062   fi
8063 done
8064 done
8065
8066 fi
8067 fi
8068 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8069 if test -n "$GCC_FOR_TARGET"; then
8070   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8071 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8072 else
8073   echo "$as_me:$LINENO: result: no" >&5
8074 echo "${ECHO_T}no" >&6
8075 fi
8076
8077   done
8078 fi
8079
8080 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8081   for ncn_progname in gcc; do
8082     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8083 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8084     if test -x $with_build_time_tools/${ncn_progname}; then
8085       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8086       echo "$as_me:$LINENO: result: yes" >&5
8087 echo "${ECHO_T}yes" >&6
8088       break
8089     else
8090       echo "$as_me:$LINENO: result: no" >&5
8091 echo "${ECHO_T}no" >&6
8092     fi
8093   done
8094 fi
8095
8096 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8097   for ncn_progname in gcc; do
8098     if test -n "$ncn_target_tool_prefix"; then
8099       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8100 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8101 echo "$as_me:$LINENO: checking for $ac_word" >&5
8102 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8103 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8104   echo $ECHO_N "(cached) $ECHO_C" >&6
8105 else
8106   if test -n "$GCC_FOR_TARGET"; then
8107   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8108 else
8109 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8110 for as_dir in $PATH
8111 do
8112   IFS=$as_save_IFS
8113   test -z "$as_dir" && as_dir=.
8114   for ac_exec_ext in '' $ac_executable_extensions; do
8115   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8116     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8117     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8118     break 2
8119   fi
8120 done
8121 done
8122
8123 fi
8124 fi
8125 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8126 if test -n "$GCC_FOR_TARGET"; then
8127   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8128 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8129 else
8130   echo "$as_me:$LINENO: result: no" >&5
8131 echo "${ECHO_T}no" >&6
8132 fi
8133
8134     fi
8135     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8136       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8137 set dummy ${ncn_progname}; ac_word=$2
8138 echo "$as_me:$LINENO: checking for $ac_word" >&5
8139 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8140 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8141   echo $ECHO_N "(cached) $ECHO_C" >&6
8142 else
8143   if test -n "$GCC_FOR_TARGET"; then
8144   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8145 else
8146 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8147 for as_dir in $PATH
8148 do
8149   IFS=$as_save_IFS
8150   test -z "$as_dir" && as_dir=.
8151   for ac_exec_ext in '' $ac_executable_extensions; do
8152   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8153     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8154     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8155     break 2
8156   fi
8157 done
8158 done
8159
8160 fi
8161 fi
8162 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8163 if test -n "$GCC_FOR_TARGET"; then
8164   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8165 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8166 else
8167   echo "$as_me:$LINENO: result: no" >&5
8168 echo "${ECHO_T}no" >&6
8169 fi
8170
8171     fi
8172     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8173   done
8174 fi
8175
8176 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8177   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8178 fi
8179
8180
8181
8182 if test -n "$GCJ_FOR_TARGET"; then
8183   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8184 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8185   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8186 fi
8187
8188 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8189   for ncn_progname in gcj; do
8190     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8191 set dummy ${ncn_progname}; ac_word=$2
8192 echo "$as_me:$LINENO: checking for $ac_word" >&5
8193 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8194 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8195   echo $ECHO_N "(cached) $ECHO_C" >&6
8196 else
8197   if test -n "$GCJ_FOR_TARGET"; then
8198   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8199 else
8200 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8201 for as_dir in $PATH
8202 do
8203   IFS=$as_save_IFS
8204   test -z "$as_dir" && as_dir=.
8205   for ac_exec_ext in '' $ac_executable_extensions; do
8206   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8207     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8208     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8209     break 2
8210   fi
8211 done
8212 done
8213
8214 fi
8215 fi
8216 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8217 if test -n "$GCJ_FOR_TARGET"; then
8218   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8219 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8220 else
8221   echo "$as_me:$LINENO: result: no" >&5
8222 echo "${ECHO_T}no" >&6
8223 fi
8224
8225   done
8226 fi
8227
8228 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8229   for ncn_progname in gcj; do
8230     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8231 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8232     if test -x $with_build_time_tools/${ncn_progname}; then
8233       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8234       echo "$as_me:$LINENO: result: yes" >&5
8235 echo "${ECHO_T}yes" >&6
8236       break
8237     else
8238       echo "$as_me:$LINENO: result: no" >&5
8239 echo "${ECHO_T}no" >&6
8240     fi
8241   done
8242 fi
8243
8244 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8245   for ncn_progname in gcj; do
8246     if test -n "$ncn_target_tool_prefix"; then
8247       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8248 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8249 echo "$as_me:$LINENO: checking for $ac_word" >&5
8250 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8251 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8252   echo $ECHO_N "(cached) $ECHO_C" >&6
8253 else
8254   if test -n "$GCJ_FOR_TARGET"; then
8255   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8256 else
8257 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8258 for as_dir in $PATH
8259 do
8260   IFS=$as_save_IFS
8261   test -z "$as_dir" && as_dir=.
8262   for ac_exec_ext in '' $ac_executable_extensions; do
8263   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8264     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8265     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8266     break 2
8267   fi
8268 done
8269 done
8270
8271 fi
8272 fi
8273 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8274 if test -n "$GCJ_FOR_TARGET"; then
8275   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8276 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8277 else
8278   echo "$as_me:$LINENO: result: no" >&5
8279 echo "${ECHO_T}no" >&6
8280 fi
8281
8282     fi
8283     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8284       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8285 set dummy ${ncn_progname}; ac_word=$2
8286 echo "$as_me:$LINENO: checking for $ac_word" >&5
8287 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8288 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8289   echo $ECHO_N "(cached) $ECHO_C" >&6
8290 else
8291   if test -n "$GCJ_FOR_TARGET"; then
8292   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8293 else
8294 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8295 for as_dir in $PATH
8296 do
8297   IFS=$as_save_IFS
8298   test -z "$as_dir" && as_dir=.
8299   for ac_exec_ext in '' $ac_executable_extensions; do
8300   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8301     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8302     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8303     break 2
8304   fi
8305 done
8306 done
8307
8308 fi
8309 fi
8310 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8311 if test -n "$GCJ_FOR_TARGET"; then
8312   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8313 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8314 else
8315   echo "$as_me:$LINENO: result: no" >&5
8316 echo "${ECHO_T}no" >&6
8317 fi
8318
8319     fi
8320     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8321   done
8322 fi
8323
8324 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8325   set dummy gcj
8326   if test $build = $target ; then
8327     GCJ_FOR_TARGET="$2"
8328   else
8329     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8330   fi
8331 fi
8332
8333
8334
8335 if test -n "$GFORTRAN_FOR_TARGET"; then
8336   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8337 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8338   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8339 fi
8340
8341 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8342   for ncn_progname in gfortran; do
8343     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8344 set dummy ${ncn_progname}; ac_word=$2
8345 echo "$as_me:$LINENO: checking for $ac_word" >&5
8346 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8347 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8348   echo $ECHO_N "(cached) $ECHO_C" >&6
8349 else
8350   if test -n "$GFORTRAN_FOR_TARGET"; then
8351   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8352 else
8353 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8354 for as_dir in $PATH
8355 do
8356   IFS=$as_save_IFS
8357   test -z "$as_dir" && as_dir=.
8358   for ac_exec_ext in '' $ac_executable_extensions; do
8359   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8360     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8361     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8362     break 2
8363   fi
8364 done
8365 done
8366
8367 fi
8368 fi
8369 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8370 if test -n "$GFORTRAN_FOR_TARGET"; then
8371   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8372 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8373 else
8374   echo "$as_me:$LINENO: result: no" >&5
8375 echo "${ECHO_T}no" >&6
8376 fi
8377
8378   done
8379 fi
8380
8381 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8382   for ncn_progname in gfortran; do
8383     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8384 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8385     if test -x $with_build_time_tools/${ncn_progname}; then
8386       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8387       echo "$as_me:$LINENO: result: yes" >&5
8388 echo "${ECHO_T}yes" >&6
8389       break
8390     else
8391       echo "$as_me:$LINENO: result: no" >&5
8392 echo "${ECHO_T}no" >&6
8393     fi
8394   done
8395 fi
8396
8397 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8398   for ncn_progname in gfortran; do
8399     if test -n "$ncn_target_tool_prefix"; then
8400       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8401 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8402 echo "$as_me:$LINENO: checking for $ac_word" >&5
8403 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8404 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8405   echo $ECHO_N "(cached) $ECHO_C" >&6
8406 else
8407   if test -n "$GFORTRAN_FOR_TARGET"; then
8408   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8409 else
8410 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8411 for as_dir in $PATH
8412 do
8413   IFS=$as_save_IFS
8414   test -z "$as_dir" && as_dir=.
8415   for ac_exec_ext in '' $ac_executable_extensions; do
8416   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8417     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8418     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8419     break 2
8420   fi
8421 done
8422 done
8423
8424 fi
8425 fi
8426 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8427 if test -n "$GFORTRAN_FOR_TARGET"; then
8428   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8429 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8430 else
8431   echo "$as_me:$LINENO: result: no" >&5
8432 echo "${ECHO_T}no" >&6
8433 fi
8434
8435     fi
8436     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8437       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8438 set dummy ${ncn_progname}; ac_word=$2
8439 echo "$as_me:$LINENO: checking for $ac_word" >&5
8440 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8441 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8442   echo $ECHO_N "(cached) $ECHO_C" >&6
8443 else
8444   if test -n "$GFORTRAN_FOR_TARGET"; then
8445   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8446 else
8447 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8448 for as_dir in $PATH
8449 do
8450   IFS=$as_save_IFS
8451   test -z "$as_dir" && as_dir=.
8452   for ac_exec_ext in '' $ac_executable_extensions; do
8453   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8454     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8455     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8456     break 2
8457   fi
8458 done
8459 done
8460
8461 fi
8462 fi
8463 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8464 if test -n "$GFORTRAN_FOR_TARGET"; then
8465   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8466 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8467 else
8468   echo "$as_me:$LINENO: result: no" >&5
8469 echo "${ECHO_T}no" >&6
8470 fi
8471
8472     fi
8473     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8474   done
8475 fi
8476
8477 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8478   set dummy gfortran
8479   if test $build = $target ; then
8480     GFORTRAN_FOR_TARGET="$2"
8481   else
8482     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8483   fi
8484 fi
8485
8486
8487
8488 cat > conftest.c << \EOF
8489 #ifdef __GNUC__
8490   gcc_yay;
8491 #endif
8492 EOF
8493 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8494   have_gcc_for_target=yes
8495 else
8496   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8497   have_gcc_for_target=no
8498 fi
8499 rm conftest.c
8500
8501
8502
8503
8504 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8505   if test -n "$with_build_time_tools"; then
8506     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8507 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8508     if test -x $with_build_time_tools/ar; then
8509       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8510       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8511       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8512 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8513     else
8514       echo "$as_me:$LINENO: result: no" >&5
8515 echo "${ECHO_T}no" >&6
8516     fi
8517   elif test $build != $host && test $have_gcc_for_target = yes; then
8518     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8519     test $AR_FOR_TARGET=ar && AR_FOR_TARGET=
8520     ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8521   fi
8522 fi
8523 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8524   # Extract the first word of "ar", so it can be a program name with args.
8525 set dummy ar; ac_word=$2
8526 echo "$as_me:$LINENO: checking for $ac_word" >&5
8527 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8528 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8529   echo $ECHO_N "(cached) $ECHO_C" >&6
8530 else
8531   case $AR_FOR_TARGET in
8532   [\\/]* | ?:[\\/]*)
8533   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8534   ;;
8535   *)
8536   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8537 for as_dir in $gcc_cv_tool_dirs
8538 do
8539   IFS=$as_save_IFS
8540   test -z "$as_dir" && as_dir=.
8541   for ac_exec_ext in '' $ac_executable_extensions; do
8542   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8543     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8544     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8545     break 2
8546   fi
8547 done
8548 done
8549
8550   ;;
8551 esac
8552 fi
8553 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8554
8555 if test -n "$AR_FOR_TARGET"; then
8556   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8557 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8558 else
8559   echo "$as_me:$LINENO: result: no" >&5
8560 echo "${ECHO_T}no" >&6
8561 fi
8562
8563 fi
8564 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8565
8566
8567 if test -n "$AR_FOR_TARGET"; then
8568   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8569 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8570   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8571 fi
8572
8573 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8574   for ncn_progname in ar; do
8575     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8576 set dummy ${ncn_progname}; ac_word=$2
8577 echo "$as_me:$LINENO: checking for $ac_word" >&5
8578 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8579 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8580   echo $ECHO_N "(cached) $ECHO_C" >&6
8581 else
8582   if test -n "$AR_FOR_TARGET"; then
8583   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8584 else
8585 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8586 for as_dir in $PATH
8587 do
8588   IFS=$as_save_IFS
8589   test -z "$as_dir" && as_dir=.
8590   for ac_exec_ext in '' $ac_executable_extensions; do
8591   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8592     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8593     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8594     break 2
8595   fi
8596 done
8597 done
8598
8599 fi
8600 fi
8601 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8602 if test -n "$AR_FOR_TARGET"; then
8603   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8604 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8605 else
8606   echo "$as_me:$LINENO: result: no" >&5
8607 echo "${ECHO_T}no" >&6
8608 fi
8609
8610   done
8611 fi
8612
8613 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8614   for ncn_progname in ar; do
8615     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8616 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8617     if test -x $with_build_time_tools/${ncn_progname}; then
8618       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8619       echo "$as_me:$LINENO: result: yes" >&5
8620 echo "${ECHO_T}yes" >&6
8621       break
8622     else
8623       echo "$as_me:$LINENO: result: no" >&5
8624 echo "${ECHO_T}no" >&6
8625     fi
8626   done
8627 fi
8628
8629 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8630   for ncn_progname in ar; do
8631     if test -n "$ncn_target_tool_prefix"; then
8632       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8633 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8634 echo "$as_me:$LINENO: checking for $ac_word" >&5
8635 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8636 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8637   echo $ECHO_N "(cached) $ECHO_C" >&6
8638 else
8639   if test -n "$AR_FOR_TARGET"; then
8640   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8641 else
8642 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8643 for as_dir in $PATH
8644 do
8645   IFS=$as_save_IFS
8646   test -z "$as_dir" && as_dir=.
8647   for ac_exec_ext in '' $ac_executable_extensions; do
8648   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8649     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8650     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8651     break 2
8652   fi
8653 done
8654 done
8655
8656 fi
8657 fi
8658 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8659 if test -n "$AR_FOR_TARGET"; then
8660   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8661 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8662 else
8663   echo "$as_me:$LINENO: result: no" >&5
8664 echo "${ECHO_T}no" >&6
8665 fi
8666
8667     fi
8668     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
8669       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8670 set dummy ${ncn_progname}; ac_word=$2
8671 echo "$as_me:$LINENO: checking for $ac_word" >&5
8672 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8673 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8674   echo $ECHO_N "(cached) $ECHO_C" >&6
8675 else
8676   if test -n "$AR_FOR_TARGET"; then
8677   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8678 else
8679 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8680 for as_dir in $PATH
8681 do
8682   IFS=$as_save_IFS
8683   test -z "$as_dir" && as_dir=.
8684   for ac_exec_ext in '' $ac_executable_extensions; do
8685   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8686     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8687     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8688     break 2
8689   fi
8690 done
8691 done
8692
8693 fi
8694 fi
8695 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8696 if test -n "$AR_FOR_TARGET"; then
8697   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8698 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8699 else
8700   echo "$as_me:$LINENO: result: no" >&5
8701 echo "${ECHO_T}no" >&6
8702 fi
8703
8704     fi
8705     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
8706   done
8707 fi
8708
8709 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
8710   set dummy ar
8711   if test $build = $target ; then
8712     AR_FOR_TARGET="$2"
8713   else
8714     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
8715   fi
8716 fi
8717
8718 else
8719   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8720 fi
8721
8722
8723
8724
8725 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8726   if test -n "$with_build_time_tools"; then
8727     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
8728 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
8729     if test -x $with_build_time_tools/as; then
8730       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
8731       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8732       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
8733 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
8734     else
8735       echo "$as_me:$LINENO: result: no" >&5
8736 echo "${ECHO_T}no" >&6
8737     fi
8738   elif test $build != $host && test $have_gcc_for_target = yes; then
8739     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
8740     test $AS_FOR_TARGET=as && AS_FOR_TARGET=
8741     ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8742   fi
8743 fi
8744 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8745   # Extract the first word of "as", so it can be a program name with args.
8746 set dummy as; ac_word=$2
8747 echo "$as_me:$LINENO: checking for $ac_word" >&5
8748 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8749 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
8750   echo $ECHO_N "(cached) $ECHO_C" >&6
8751 else
8752   case $AS_FOR_TARGET in
8753   [\\/]* | ?:[\\/]*)
8754   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
8755   ;;
8756   *)
8757   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8758 for as_dir in $gcc_cv_tool_dirs
8759 do
8760   IFS=$as_save_IFS
8761   test -z "$as_dir" && as_dir=.
8762   for ac_exec_ext in '' $ac_executable_extensions; do
8763   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8764     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8765     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8766     break 2
8767   fi
8768 done
8769 done
8770
8771   ;;
8772 esac
8773 fi
8774 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
8775
8776 if test -n "$AS_FOR_TARGET"; then
8777   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8778 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8779 else
8780   echo "$as_me:$LINENO: result: no" >&5
8781 echo "${ECHO_T}no" >&6
8782 fi
8783
8784 fi
8785 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8786
8787
8788 if test -n "$AS_FOR_TARGET"; then
8789   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
8790 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
8791   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8792 fi
8793
8794 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
8795   for ncn_progname in as; do
8796     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8797 set dummy ${ncn_progname}; ac_word=$2
8798 echo "$as_me:$LINENO: checking for $ac_word" >&5
8799 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8800 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8801   echo $ECHO_N "(cached) $ECHO_C" >&6
8802 else
8803   if test -n "$AS_FOR_TARGET"; then
8804   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8805 else
8806 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8807 for as_dir in $PATH
8808 do
8809   IFS=$as_save_IFS
8810   test -z "$as_dir" && as_dir=.
8811   for ac_exec_ext in '' $ac_executable_extensions; do
8812   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8813     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
8814     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8815     break 2
8816   fi
8817 done
8818 done
8819
8820 fi
8821 fi
8822 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8823 if test -n "$AS_FOR_TARGET"; then
8824   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8825 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8826 else
8827   echo "$as_me:$LINENO: result: no" >&5
8828 echo "${ECHO_T}no" >&6
8829 fi
8830
8831   done
8832 fi
8833
8834 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
8835   for ncn_progname in as; do
8836     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8837 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8838     if test -x $with_build_time_tools/${ncn_progname}; then
8839       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8840       echo "$as_me:$LINENO: result: yes" >&5
8841 echo "${ECHO_T}yes" >&6
8842       break
8843     else
8844       echo "$as_me:$LINENO: result: no" >&5
8845 echo "${ECHO_T}no" >&6
8846     fi
8847   done
8848 fi
8849
8850 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
8851   for ncn_progname in as; do
8852     if test -n "$ncn_target_tool_prefix"; then
8853       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8854 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8855 echo "$as_me:$LINENO: checking for $ac_word" >&5
8856 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8857 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8858   echo $ECHO_N "(cached) $ECHO_C" >&6
8859 else
8860   if test -n "$AS_FOR_TARGET"; then
8861   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8862 else
8863 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8864 for as_dir in $PATH
8865 do
8866   IFS=$as_save_IFS
8867   test -z "$as_dir" && as_dir=.
8868   for ac_exec_ext in '' $ac_executable_extensions; do
8869   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8870     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8871     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8872     break 2
8873   fi
8874 done
8875 done
8876
8877 fi
8878 fi
8879 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8880 if test -n "$AS_FOR_TARGET"; then
8881   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8882 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8883 else
8884   echo "$as_me:$LINENO: result: no" >&5
8885 echo "${ECHO_T}no" >&6
8886 fi
8887
8888     fi
8889     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
8890       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8891 set dummy ${ncn_progname}; ac_word=$2
8892 echo "$as_me:$LINENO: checking for $ac_word" >&5
8893 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8894 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8895   echo $ECHO_N "(cached) $ECHO_C" >&6
8896 else
8897   if test -n "$AS_FOR_TARGET"; then
8898   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8899 else
8900 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8901 for as_dir in $PATH
8902 do
8903   IFS=$as_save_IFS
8904   test -z "$as_dir" && as_dir=.
8905   for ac_exec_ext in '' $ac_executable_extensions; do
8906   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8907     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
8908     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8909     break 2
8910   fi
8911 done
8912 done
8913
8914 fi
8915 fi
8916 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8917 if test -n "$AS_FOR_TARGET"; then
8918   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8919 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8920 else
8921   echo "$as_me:$LINENO: result: no" >&5
8922 echo "${ECHO_T}no" >&6
8923 fi
8924
8925     fi
8926     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
8927   done
8928 fi
8929
8930 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
8931   set dummy as
8932   if test $build = $target ; then
8933     AS_FOR_TARGET="$2"
8934   else
8935     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
8936   fi
8937 fi
8938
8939 else
8940   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
8941 fi
8942
8943
8944
8945
8946 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
8947   if test -n "$with_build_time_tools"; then
8948     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
8949 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
8950     if test -x $with_build_time_tools/dlltool; then
8951       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
8952       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
8953       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
8954 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
8955     else
8956       echo "$as_me:$LINENO: result: no" >&5
8957 echo "${ECHO_T}no" >&6
8958     fi
8959   elif test $build != $host && test $have_gcc_for_target = yes; then
8960     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
8961     test $DLLTOOL_FOR_TARGET=dlltool && DLLTOOL_FOR_TARGET=
8962     ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
8963   fi
8964 fi
8965 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8966   # Extract the first word of "dlltool", so it can be a program name with args.
8967 set dummy dlltool; ac_word=$2
8968 echo "$as_me:$LINENO: checking for $ac_word" >&5
8969 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8970 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
8971   echo $ECHO_N "(cached) $ECHO_C" >&6
8972 else
8973   case $DLLTOOL_FOR_TARGET in
8974   [\\/]* | ?:[\\/]*)
8975   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
8976   ;;
8977   *)
8978   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8979 for as_dir in $gcc_cv_tool_dirs
8980 do
8981   IFS=$as_save_IFS
8982   test -z "$as_dir" && as_dir=.
8983   for ac_exec_ext in '' $ac_executable_extensions; do
8984   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8985     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8986     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8987     break 2
8988   fi
8989 done
8990 done
8991
8992   ;;
8993 esac
8994 fi
8995 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
8996
8997 if test -n "$DLLTOOL_FOR_TARGET"; then
8998   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
8999 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9000 else
9001   echo "$as_me:$LINENO: result: no" >&5
9002 echo "${ECHO_T}no" >&6
9003 fi
9004
9005 fi
9006 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9007
9008
9009 if test -n "$DLLTOOL_FOR_TARGET"; then
9010   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9011 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9012   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9013 fi
9014
9015 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9016   for ncn_progname in dlltool; do
9017     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9018 set dummy ${ncn_progname}; ac_word=$2
9019 echo "$as_me:$LINENO: checking for $ac_word" >&5
9020 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9021 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9022   echo $ECHO_N "(cached) $ECHO_C" >&6
9023 else
9024   if test -n "$DLLTOOL_FOR_TARGET"; then
9025   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9026 else
9027 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9028 for as_dir in $PATH
9029 do
9030   IFS=$as_save_IFS
9031   test -z "$as_dir" && as_dir=.
9032   for ac_exec_ext in '' $ac_executable_extensions; do
9033   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9034     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9035     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9036     break 2
9037   fi
9038 done
9039 done
9040
9041 fi
9042 fi
9043 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9044 if test -n "$DLLTOOL_FOR_TARGET"; then
9045   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9046 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9047 else
9048   echo "$as_me:$LINENO: result: no" >&5
9049 echo "${ECHO_T}no" >&6
9050 fi
9051
9052   done
9053 fi
9054
9055 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9056   for ncn_progname in dlltool; do
9057     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9058 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9059     if test -x $with_build_time_tools/${ncn_progname}; then
9060       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9061       echo "$as_me:$LINENO: result: yes" >&5
9062 echo "${ECHO_T}yes" >&6
9063       break
9064     else
9065       echo "$as_me:$LINENO: result: no" >&5
9066 echo "${ECHO_T}no" >&6
9067     fi
9068   done
9069 fi
9070
9071 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9072   for ncn_progname in dlltool; do
9073     if test -n "$ncn_target_tool_prefix"; then
9074       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9075 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9076 echo "$as_me:$LINENO: checking for $ac_word" >&5
9077 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9078 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9079   echo $ECHO_N "(cached) $ECHO_C" >&6
9080 else
9081   if test -n "$DLLTOOL_FOR_TARGET"; then
9082   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9083 else
9084 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9085 for as_dir in $PATH
9086 do
9087   IFS=$as_save_IFS
9088   test -z "$as_dir" && as_dir=.
9089   for ac_exec_ext in '' $ac_executable_extensions; do
9090   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9091     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9092     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9093     break 2
9094   fi
9095 done
9096 done
9097
9098 fi
9099 fi
9100 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9101 if test -n "$DLLTOOL_FOR_TARGET"; then
9102   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9103 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9104 else
9105   echo "$as_me:$LINENO: result: no" >&5
9106 echo "${ECHO_T}no" >&6
9107 fi
9108
9109     fi
9110     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9111       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9112 set dummy ${ncn_progname}; ac_word=$2
9113 echo "$as_me:$LINENO: checking for $ac_word" >&5
9114 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9115 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9116   echo $ECHO_N "(cached) $ECHO_C" >&6
9117 else
9118   if test -n "$DLLTOOL_FOR_TARGET"; then
9119   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9120 else
9121 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9122 for as_dir in $PATH
9123 do
9124   IFS=$as_save_IFS
9125   test -z "$as_dir" && as_dir=.
9126   for ac_exec_ext in '' $ac_executable_extensions; do
9127   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9128     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9129     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9130     break 2
9131   fi
9132 done
9133 done
9134
9135 fi
9136 fi
9137 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9138 if test -n "$DLLTOOL_FOR_TARGET"; then
9139   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9140 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9141 else
9142   echo "$as_me:$LINENO: result: no" >&5
9143 echo "${ECHO_T}no" >&6
9144 fi
9145
9146     fi
9147     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9148   done
9149 fi
9150
9151 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9152   set dummy dlltool
9153   if test $build = $target ; then
9154     DLLTOOL_FOR_TARGET="$2"
9155   else
9156     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9157   fi
9158 fi
9159
9160 else
9161   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9162 fi
9163
9164
9165
9166
9167 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9168   if test -n "$with_build_time_tools"; then
9169     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9170 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9171     if test -x $with_build_time_tools/ld; then
9172       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9173       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9174       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9175 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9176     else
9177       echo "$as_me:$LINENO: result: no" >&5
9178 echo "${ECHO_T}no" >&6
9179     fi
9180   elif test $build != $host && test $have_gcc_for_target = yes; then
9181     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9182     test $LD_FOR_TARGET=ld && LD_FOR_TARGET=
9183     ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9184   fi
9185 fi
9186 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9187   # Extract the first word of "ld", so it can be a program name with args.
9188 set dummy ld; ac_word=$2
9189 echo "$as_me:$LINENO: checking for $ac_word" >&5
9190 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9191 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9192   echo $ECHO_N "(cached) $ECHO_C" >&6
9193 else
9194   case $LD_FOR_TARGET in
9195   [\\/]* | ?:[\\/]*)
9196   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9197   ;;
9198   *)
9199   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9200 for as_dir in $gcc_cv_tool_dirs
9201 do
9202   IFS=$as_save_IFS
9203   test -z "$as_dir" && as_dir=.
9204   for ac_exec_ext in '' $ac_executable_extensions; do
9205   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9206     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9207     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9208     break 2
9209   fi
9210 done
9211 done
9212
9213   ;;
9214 esac
9215 fi
9216 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9217
9218 if test -n "$LD_FOR_TARGET"; then
9219   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9220 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9221 else
9222   echo "$as_me:$LINENO: result: no" >&5
9223 echo "${ECHO_T}no" >&6
9224 fi
9225
9226 fi
9227 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9228
9229
9230 if test -n "$LD_FOR_TARGET"; then
9231   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9232 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9233   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9234 fi
9235
9236 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9237   for ncn_progname in ld; do
9238     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9239 set dummy ${ncn_progname}; ac_word=$2
9240 echo "$as_me:$LINENO: checking for $ac_word" >&5
9241 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9242 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9243   echo $ECHO_N "(cached) $ECHO_C" >&6
9244 else
9245   if test -n "$LD_FOR_TARGET"; then
9246   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9247 else
9248 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9249 for as_dir in $PATH
9250 do
9251   IFS=$as_save_IFS
9252   test -z "$as_dir" && as_dir=.
9253   for ac_exec_ext in '' $ac_executable_extensions; do
9254   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9255     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9256     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9257     break 2
9258   fi
9259 done
9260 done
9261
9262 fi
9263 fi
9264 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9265 if test -n "$LD_FOR_TARGET"; then
9266   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9267 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9268 else
9269   echo "$as_me:$LINENO: result: no" >&5
9270 echo "${ECHO_T}no" >&6
9271 fi
9272
9273   done
9274 fi
9275
9276 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9277   for ncn_progname in ld; do
9278     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9279 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9280     if test -x $with_build_time_tools/${ncn_progname}; then
9281       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9282       echo "$as_me:$LINENO: result: yes" >&5
9283 echo "${ECHO_T}yes" >&6
9284       break
9285     else
9286       echo "$as_me:$LINENO: result: no" >&5
9287 echo "${ECHO_T}no" >&6
9288     fi
9289   done
9290 fi
9291
9292 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9293   for ncn_progname in ld; do
9294     if test -n "$ncn_target_tool_prefix"; then
9295       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9296 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9297 echo "$as_me:$LINENO: checking for $ac_word" >&5
9298 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9299 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9300   echo $ECHO_N "(cached) $ECHO_C" >&6
9301 else
9302   if test -n "$LD_FOR_TARGET"; then
9303   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9304 else
9305 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9306 for as_dir in $PATH
9307 do
9308   IFS=$as_save_IFS
9309   test -z "$as_dir" && as_dir=.
9310   for ac_exec_ext in '' $ac_executable_extensions; do
9311   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9312     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9313     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9314     break 2
9315   fi
9316 done
9317 done
9318
9319 fi
9320 fi
9321 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9322 if test -n "$LD_FOR_TARGET"; then
9323   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9324 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9325 else
9326   echo "$as_me:$LINENO: result: no" >&5
9327 echo "${ECHO_T}no" >&6
9328 fi
9329
9330     fi
9331     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9332       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9333 set dummy ${ncn_progname}; ac_word=$2
9334 echo "$as_me:$LINENO: checking for $ac_word" >&5
9335 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9336 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9337   echo $ECHO_N "(cached) $ECHO_C" >&6
9338 else
9339   if test -n "$LD_FOR_TARGET"; then
9340   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9341 else
9342 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9343 for as_dir in $PATH
9344 do
9345   IFS=$as_save_IFS
9346   test -z "$as_dir" && as_dir=.
9347   for ac_exec_ext in '' $ac_executable_extensions; do
9348   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9349     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9350     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9351     break 2
9352   fi
9353 done
9354 done
9355
9356 fi
9357 fi
9358 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9359 if test -n "$LD_FOR_TARGET"; then
9360   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9361 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9362 else
9363   echo "$as_me:$LINENO: result: no" >&5
9364 echo "${ECHO_T}no" >&6
9365 fi
9366
9367     fi
9368     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9369   done
9370 fi
9371
9372 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9373   set dummy ld
9374   if test $build = $target ; then
9375     LD_FOR_TARGET="$2"
9376   else
9377     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9378   fi
9379 fi
9380
9381 else
9382   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9383 fi
9384
9385
9386
9387
9388 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9389   if test -n "$with_build_time_tools"; then
9390     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9391 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9392     if test -x $with_build_time_tools/lipo; then
9393       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9394       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9395       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9396 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9397     else
9398       echo "$as_me:$LINENO: result: no" >&5
9399 echo "${ECHO_T}no" >&6
9400     fi
9401   elif test $build != $host && test $have_gcc_for_target = yes; then
9402     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9403     test $LIPO_FOR_TARGET=lipo && LIPO_FOR_TARGET=
9404     ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9405   fi
9406 fi
9407 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9408   # Extract the first word of "lipo", so it can be a program name with args.
9409 set dummy lipo; ac_word=$2
9410 echo "$as_me:$LINENO: checking for $ac_word" >&5
9411 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9412 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9413   echo $ECHO_N "(cached) $ECHO_C" >&6
9414 else
9415   case $LIPO_FOR_TARGET in
9416   [\\/]* | ?:[\\/]*)
9417   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9418   ;;
9419   *)
9420   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9421 for as_dir in $gcc_cv_tool_dirs
9422 do
9423   IFS=$as_save_IFS
9424   test -z "$as_dir" && as_dir=.
9425   for ac_exec_ext in '' $ac_executable_extensions; do
9426   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9427     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9428     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9429     break 2
9430   fi
9431 done
9432 done
9433
9434   ;;
9435 esac
9436 fi
9437 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9438
9439 if test -n "$LIPO_FOR_TARGET"; then
9440   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9441 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9442 else
9443   echo "$as_me:$LINENO: result: no" >&5
9444 echo "${ECHO_T}no" >&6
9445 fi
9446
9447 fi
9448 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9449
9450
9451 if test -n "$LIPO_FOR_TARGET"; then
9452   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9453 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9454   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9455 fi
9456
9457 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9458   for ncn_progname in lipo; do
9459     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9460 set dummy ${ncn_progname}; ac_word=$2
9461 echo "$as_me:$LINENO: checking for $ac_word" >&5
9462 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9463 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9464   echo $ECHO_N "(cached) $ECHO_C" >&6
9465 else
9466   if test -n "$LIPO_FOR_TARGET"; then
9467   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9468 else
9469 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9470 for as_dir in $PATH
9471 do
9472   IFS=$as_save_IFS
9473   test -z "$as_dir" && as_dir=.
9474   for ac_exec_ext in '' $ac_executable_extensions; do
9475   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9476     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9477     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9478     break 2
9479   fi
9480 done
9481 done
9482
9483 fi
9484 fi
9485 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9486 if test -n "$LIPO_FOR_TARGET"; then
9487   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9488 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9489 else
9490   echo "$as_me:$LINENO: result: no" >&5
9491 echo "${ECHO_T}no" >&6
9492 fi
9493
9494   done
9495 fi
9496
9497 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9498   for ncn_progname in lipo; do
9499     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9500 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9501     if test -x $with_build_time_tools/${ncn_progname}; then
9502       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9503       echo "$as_me:$LINENO: result: yes" >&5
9504 echo "${ECHO_T}yes" >&6
9505       break
9506     else
9507       echo "$as_me:$LINENO: result: no" >&5
9508 echo "${ECHO_T}no" >&6
9509     fi
9510   done
9511 fi
9512
9513 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9514   for ncn_progname in lipo; do
9515     if test -n "$ncn_target_tool_prefix"; then
9516       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9517 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9518 echo "$as_me:$LINENO: checking for $ac_word" >&5
9519 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9520 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9521   echo $ECHO_N "(cached) $ECHO_C" >&6
9522 else
9523   if test -n "$LIPO_FOR_TARGET"; then
9524   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9525 else
9526 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9527 for as_dir in $PATH
9528 do
9529   IFS=$as_save_IFS
9530   test -z "$as_dir" && as_dir=.
9531   for ac_exec_ext in '' $ac_executable_extensions; do
9532   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9533     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9534     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9535     break 2
9536   fi
9537 done
9538 done
9539
9540 fi
9541 fi
9542 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9543 if test -n "$LIPO_FOR_TARGET"; then
9544   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9545 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9546 else
9547   echo "$as_me:$LINENO: result: no" >&5
9548 echo "${ECHO_T}no" >&6
9549 fi
9550
9551     fi
9552     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9553       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9554 set dummy ${ncn_progname}; ac_word=$2
9555 echo "$as_me:$LINENO: checking for $ac_word" >&5
9556 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9557 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9558   echo $ECHO_N "(cached) $ECHO_C" >&6
9559 else
9560   if test -n "$LIPO_FOR_TARGET"; then
9561   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9562 else
9563 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9564 for as_dir in $PATH
9565 do
9566   IFS=$as_save_IFS
9567   test -z "$as_dir" && as_dir=.
9568   for ac_exec_ext in '' $ac_executable_extensions; do
9569   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9570     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9571     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9572     break 2
9573   fi
9574 done
9575 done
9576
9577 fi
9578 fi
9579 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9580 if test -n "$LIPO_FOR_TARGET"; then
9581   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9582 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9583 else
9584   echo "$as_me:$LINENO: result: no" >&5
9585 echo "${ECHO_T}no" >&6
9586 fi
9587
9588     fi
9589     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9590   done
9591 fi
9592
9593 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9594   set dummy lipo
9595   if test $build = $target ; then
9596     LIPO_FOR_TARGET="$2"
9597   else
9598     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9599   fi
9600 fi
9601
9602 else
9603   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9604 fi
9605
9606
9607
9608
9609 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9610   if test -n "$with_build_time_tools"; then
9611     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9612 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9613     if test -x $with_build_time_tools/nm; then
9614       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9615       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9616       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9617 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9618     else
9619       echo "$as_me:$LINENO: result: no" >&5
9620 echo "${ECHO_T}no" >&6
9621     fi
9622   elif test $build != $host && test $have_gcc_for_target = yes; then
9623     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9624     test $NM_FOR_TARGET=nm && NM_FOR_TARGET=
9625     ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9626   fi
9627 fi
9628 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9629   # Extract the first word of "nm", so it can be a program name with args.
9630 set dummy nm; ac_word=$2
9631 echo "$as_me:$LINENO: checking for $ac_word" >&5
9632 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9633 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9634   echo $ECHO_N "(cached) $ECHO_C" >&6
9635 else
9636   case $NM_FOR_TARGET in
9637   [\\/]* | ?:[\\/]*)
9638   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9639   ;;
9640   *)
9641   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9642 for as_dir in $gcc_cv_tool_dirs
9643 do
9644   IFS=$as_save_IFS
9645   test -z "$as_dir" && as_dir=.
9646   for ac_exec_ext in '' $ac_executable_extensions; do
9647   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9648     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9649     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9650     break 2
9651   fi
9652 done
9653 done
9654
9655   ;;
9656 esac
9657 fi
9658 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9659
9660 if test -n "$NM_FOR_TARGET"; then
9661   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9662 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9663 else
9664   echo "$as_me:$LINENO: result: no" >&5
9665 echo "${ECHO_T}no" >&6
9666 fi
9667
9668 fi
9669 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9670
9671
9672 if test -n "$NM_FOR_TARGET"; then
9673   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
9674 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9675   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9676 fi
9677
9678 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9679   for ncn_progname in nm; do
9680     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9681 set dummy ${ncn_progname}; ac_word=$2
9682 echo "$as_me:$LINENO: checking for $ac_word" >&5
9683 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9684 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9685   echo $ECHO_N "(cached) $ECHO_C" >&6
9686 else
9687   if test -n "$NM_FOR_TARGET"; then
9688   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9689 else
9690 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9691 for as_dir in $PATH
9692 do
9693   IFS=$as_save_IFS
9694   test -z "$as_dir" && as_dir=.
9695   for ac_exec_ext in '' $ac_executable_extensions; do
9696   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9697     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9698     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9699     break 2
9700   fi
9701 done
9702 done
9703
9704 fi
9705 fi
9706 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9707 if test -n "$NM_FOR_TARGET"; then
9708   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9709 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9710 else
9711   echo "$as_me:$LINENO: result: no" >&5
9712 echo "${ECHO_T}no" >&6
9713 fi
9714
9715   done
9716 fi
9717
9718 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
9719   for ncn_progname in nm; do
9720     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9721 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9722     if test -x $with_build_time_tools/${ncn_progname}; then
9723       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9724       echo "$as_me:$LINENO: result: yes" >&5
9725 echo "${ECHO_T}yes" >&6
9726       break
9727     else
9728       echo "$as_me:$LINENO: result: no" >&5
9729 echo "${ECHO_T}no" >&6
9730     fi
9731   done
9732 fi
9733
9734 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
9735   for ncn_progname in nm; do
9736     if test -n "$ncn_target_tool_prefix"; then
9737       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9738 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9739 echo "$as_me:$LINENO: checking for $ac_word" >&5
9740 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9741 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9742   echo $ECHO_N "(cached) $ECHO_C" >&6
9743 else
9744   if test -n "$NM_FOR_TARGET"; then
9745   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9746 else
9747 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9748 for as_dir in $PATH
9749 do
9750   IFS=$as_save_IFS
9751   test -z "$as_dir" && as_dir=.
9752   for ac_exec_ext in '' $ac_executable_extensions; do
9753   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9754     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9755     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9756     break 2
9757   fi
9758 done
9759 done
9760
9761 fi
9762 fi
9763 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9764 if test -n "$NM_FOR_TARGET"; then
9765   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9766 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9767 else
9768   echo "$as_me:$LINENO: result: no" >&5
9769 echo "${ECHO_T}no" >&6
9770 fi
9771
9772     fi
9773     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
9774       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9775 set dummy ${ncn_progname}; ac_word=$2
9776 echo "$as_me:$LINENO: checking for $ac_word" >&5
9777 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9778 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9779   echo $ECHO_N "(cached) $ECHO_C" >&6
9780 else
9781   if test -n "$NM_FOR_TARGET"; then
9782   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9783 else
9784 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9785 for as_dir in $PATH
9786 do
9787   IFS=$as_save_IFS
9788   test -z "$as_dir" && as_dir=.
9789   for ac_exec_ext in '' $ac_executable_extensions; do
9790   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9791     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9792     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9793     break 2
9794   fi
9795 done
9796 done
9797
9798 fi
9799 fi
9800 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9801 if test -n "$NM_FOR_TARGET"; then
9802   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9803 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9804 else
9805   echo "$as_me:$LINENO: result: no" >&5
9806 echo "${ECHO_T}no" >&6
9807 fi
9808
9809     fi
9810     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
9811   done
9812 fi
9813
9814 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
9815   set dummy nm
9816   if test $build = $target ; then
9817     NM_FOR_TARGET="$2"
9818   else
9819     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
9820   fi
9821 fi
9822
9823 else
9824   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9825 fi
9826
9827
9828
9829
9830 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
9831   if test -n "$with_build_time_tools"; then
9832     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
9833 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
9834     if test -x $with_build_time_tools/objdump; then
9835       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
9836       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
9837       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
9838 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
9839     else
9840       echo "$as_me:$LINENO: result: no" >&5
9841 echo "${ECHO_T}no" >&6
9842     fi
9843   elif test $build != $host && test $have_gcc_for_target = yes; then
9844     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
9845     test $OBJDUMP_FOR_TARGET=objdump && OBJDUMP_FOR_TARGET=
9846     ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
9847   fi
9848 fi
9849 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9850   # Extract the first word of "objdump", so it can be a program name with args.
9851 set dummy objdump; ac_word=$2
9852 echo "$as_me:$LINENO: checking for $ac_word" >&5
9853 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9854 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
9855   echo $ECHO_N "(cached) $ECHO_C" >&6
9856 else
9857   case $OBJDUMP_FOR_TARGET in
9858   [\\/]* | ?:[\\/]*)
9859   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
9860   ;;
9861   *)
9862   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9863 for as_dir in $gcc_cv_tool_dirs
9864 do
9865   IFS=$as_save_IFS
9866   test -z "$as_dir" && as_dir=.
9867   for ac_exec_ext in '' $ac_executable_extensions; do
9868   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9869     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9870     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9871     break 2
9872   fi
9873 done
9874 done
9875
9876   ;;
9877 esac
9878 fi
9879 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
9880
9881 if test -n "$OBJDUMP_FOR_TARGET"; then
9882   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
9883 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
9884 else
9885   echo "$as_me:$LINENO: result: no" >&5
9886 echo "${ECHO_T}no" >&6
9887 fi
9888
9889 fi
9890 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
9891
9892
9893 if test -n "$OBJDUMP_FOR_TARGET"; then
9894   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
9895 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
9896   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
9897 fi
9898
9899 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
9900   for ncn_progname in objdump; do
9901     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9902 set dummy ${ncn_progname}; ac_word=$2
9903 echo "$as_me:$LINENO: checking for $ac_word" >&5
9904 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9905 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
9906   echo $ECHO_N "(cached) $ECHO_C" >&6
9907 else
9908   if test -n "$OBJDUMP_FOR_TARGET"; then
9909   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
9910 else
9911 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9912 for as_dir in $PATH
9913 do
9914   IFS=$as_save_IFS
9915   test -z "$as_dir" && as_dir=.
9916   for ac_exec_ext in '' $ac_executable_extensions; do
9917   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9918     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
9919     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9920     break 2
9921   fi
9922 done
9923 done
9924
9925 fi
9926 fi
9927 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
9928 if test -n "$OBJDUMP_FOR_TARGET"; then
9929   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
9930 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
9931 else
9932   echo "$as_me:$LINENO: result: no" >&5
9933 echo "${ECHO_T}no" >&6
9934 fi
9935
9936   done
9937 fi
9938
9939 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
9940   for ncn_progname in objdump; do
9941     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9942 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9943     if test -x $with_build_time_tools/${ncn_progname}; then
9944       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9945       echo "$as_me:$LINENO: result: yes" >&5
9946 echo "${ECHO_T}yes" >&6
9947       break
9948     else
9949       echo "$as_me:$LINENO: result: no" >&5
9950 echo "${ECHO_T}no" >&6
9951     fi
9952   done
9953 fi
9954
9955 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
9956   for ncn_progname in objdump; do
9957     if test -n "$ncn_target_tool_prefix"; then
9958       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9959 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9960 echo "$as_me:$LINENO: checking for $ac_word" >&5
9961 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9962 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
9963   echo $ECHO_N "(cached) $ECHO_C" >&6
9964 else
9965   if test -n "$OBJDUMP_FOR_TARGET"; then
9966   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
9967 else
9968 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9969 for as_dir in $PATH
9970 do
9971   IFS=$as_save_IFS
9972   test -z "$as_dir" && as_dir=.
9973   for ac_exec_ext in '' $ac_executable_extensions; do
9974   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9975     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9976     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9977     break 2
9978   fi
9979 done
9980 done
9981
9982 fi
9983 fi
9984 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
9985 if test -n "$OBJDUMP_FOR_TARGET"; then
9986   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
9987 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
9988 else
9989   echo "$as_me:$LINENO: result: no" >&5
9990 echo "${ECHO_T}no" >&6
9991 fi
9992
9993     fi
9994     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
9995       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9996 set dummy ${ncn_progname}; ac_word=$2
9997 echo "$as_me:$LINENO: checking for $ac_word" >&5
9998 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9999 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10000   echo $ECHO_N "(cached) $ECHO_C" >&6
10001 else
10002   if test -n "$OBJDUMP_FOR_TARGET"; then
10003   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10004 else
10005 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10006 for as_dir in $PATH
10007 do
10008   IFS=$as_save_IFS
10009   test -z "$as_dir" && as_dir=.
10010   for ac_exec_ext in '' $ac_executable_extensions; do
10011   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10012     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10013     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10014     break 2
10015   fi
10016 done
10017 done
10018
10019 fi
10020 fi
10021 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10022 if test -n "$OBJDUMP_FOR_TARGET"; then
10023   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10024 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10025 else
10026   echo "$as_me:$LINENO: result: no" >&5
10027 echo "${ECHO_T}no" >&6
10028 fi
10029
10030     fi
10031     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10032   done
10033 fi
10034
10035 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10036   set dummy objdump
10037   if test $build = $target ; then
10038     OBJDUMP_FOR_TARGET="$2"
10039   else
10040     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10041   fi
10042 fi
10043
10044 else
10045   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10046 fi
10047
10048
10049
10050
10051 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10052   if test -n "$with_build_time_tools"; then
10053     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10054 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10055     if test -x $with_build_time_tools/ranlib; then
10056       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10057       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10058       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10059 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10060     else
10061       echo "$as_me:$LINENO: result: no" >&5
10062 echo "${ECHO_T}no" >&6
10063     fi
10064   elif test $build != $host && test $have_gcc_for_target = yes; then
10065     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10066     test $RANLIB_FOR_TARGET=ranlib && RANLIB_FOR_TARGET=
10067     ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10068   fi
10069 fi
10070 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10071   # Extract the first word of "ranlib", so it can be a program name with args.
10072 set dummy ranlib; ac_word=$2
10073 echo "$as_me:$LINENO: checking for $ac_word" >&5
10074 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10075 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10076   echo $ECHO_N "(cached) $ECHO_C" >&6
10077 else
10078   case $RANLIB_FOR_TARGET in
10079   [\\/]* | ?:[\\/]*)
10080   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10081   ;;
10082   *)
10083   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10084 for as_dir in $gcc_cv_tool_dirs
10085 do
10086   IFS=$as_save_IFS
10087   test -z "$as_dir" && as_dir=.
10088   for ac_exec_ext in '' $ac_executable_extensions; do
10089   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10090     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10091     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10092     break 2
10093   fi
10094 done
10095 done
10096
10097   ;;
10098 esac
10099 fi
10100 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10101
10102 if test -n "$RANLIB_FOR_TARGET"; then
10103   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10104 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10105 else
10106   echo "$as_me:$LINENO: result: no" >&5
10107 echo "${ECHO_T}no" >&6
10108 fi
10109
10110 fi
10111 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10112
10113
10114 if test -n "$RANLIB_FOR_TARGET"; then
10115   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10116 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10117   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10118 fi
10119
10120 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10121   for ncn_progname in ranlib; do
10122     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10123 set dummy ${ncn_progname}; ac_word=$2
10124 echo "$as_me:$LINENO: checking for $ac_word" >&5
10125 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10126 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10127   echo $ECHO_N "(cached) $ECHO_C" >&6
10128 else
10129   if test -n "$RANLIB_FOR_TARGET"; then
10130   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10131 else
10132 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10133 for as_dir in $PATH
10134 do
10135   IFS=$as_save_IFS
10136   test -z "$as_dir" && as_dir=.
10137   for ac_exec_ext in '' $ac_executable_extensions; do
10138   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10139     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10140     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10141     break 2
10142   fi
10143 done
10144 done
10145
10146 fi
10147 fi
10148 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10149 if test -n "$RANLIB_FOR_TARGET"; then
10150   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10151 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10152 else
10153   echo "$as_me:$LINENO: result: no" >&5
10154 echo "${ECHO_T}no" >&6
10155 fi
10156
10157   done
10158 fi
10159
10160 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10161   for ncn_progname in ranlib; do
10162     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10163 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10164     if test -x $with_build_time_tools/${ncn_progname}; then
10165       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10166       echo "$as_me:$LINENO: result: yes" >&5
10167 echo "${ECHO_T}yes" >&6
10168       break
10169     else
10170       echo "$as_me:$LINENO: result: no" >&5
10171 echo "${ECHO_T}no" >&6
10172     fi
10173   done
10174 fi
10175
10176 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10177   for ncn_progname in ranlib; do
10178     if test -n "$ncn_target_tool_prefix"; then
10179       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10180 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10181 echo "$as_me:$LINENO: checking for $ac_word" >&5
10182 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10183 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10184   echo $ECHO_N "(cached) $ECHO_C" >&6
10185 else
10186   if test -n "$RANLIB_FOR_TARGET"; then
10187   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10188 else
10189 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10190 for as_dir in $PATH
10191 do
10192   IFS=$as_save_IFS
10193   test -z "$as_dir" && as_dir=.
10194   for ac_exec_ext in '' $ac_executable_extensions; do
10195   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10196     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10197     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10198     break 2
10199   fi
10200 done
10201 done
10202
10203 fi
10204 fi
10205 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10206 if test -n "$RANLIB_FOR_TARGET"; then
10207   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10208 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10209 else
10210   echo "$as_me:$LINENO: result: no" >&5
10211 echo "${ECHO_T}no" >&6
10212 fi
10213
10214     fi
10215     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10216       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10217 set dummy ${ncn_progname}; ac_word=$2
10218 echo "$as_me:$LINENO: checking for $ac_word" >&5
10219 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10220 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10221   echo $ECHO_N "(cached) $ECHO_C" >&6
10222 else
10223   if test -n "$RANLIB_FOR_TARGET"; then
10224   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10225 else
10226 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10227 for as_dir in $PATH
10228 do
10229   IFS=$as_save_IFS
10230   test -z "$as_dir" && as_dir=.
10231   for ac_exec_ext in '' $ac_executable_extensions; do
10232   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10233     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10234     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10235     break 2
10236   fi
10237 done
10238 done
10239
10240 fi
10241 fi
10242 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10243 if test -n "$RANLIB_FOR_TARGET"; then
10244   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10245 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10246 else
10247   echo "$as_me:$LINENO: result: no" >&5
10248 echo "${ECHO_T}no" >&6
10249 fi
10250
10251     fi
10252     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10253   done
10254 fi
10255
10256 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10257   set dummy ranlib
10258   if test $build = $target ; then
10259     RANLIB_FOR_TARGET="$2"
10260   else
10261     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10262   fi
10263 fi
10264
10265 else
10266   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10267 fi
10268
10269
10270
10271
10272 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10273   if test -n "$with_build_time_tools"; then
10274     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10275 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10276     if test -x $with_build_time_tools/strip; then
10277       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10278       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10279       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10280 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10281     else
10282       echo "$as_me:$LINENO: result: no" >&5
10283 echo "${ECHO_T}no" >&6
10284     fi
10285   elif test $build != $host && test $have_gcc_for_target = yes; then
10286     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10287     test $STRIP_FOR_TARGET=strip && STRIP_FOR_TARGET=
10288     ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10289   fi
10290 fi
10291 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10292   # Extract the first word of "strip", so it can be a program name with args.
10293 set dummy strip; ac_word=$2
10294 echo "$as_me:$LINENO: checking for $ac_word" >&5
10295 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10296 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10297   echo $ECHO_N "(cached) $ECHO_C" >&6
10298 else
10299   case $STRIP_FOR_TARGET in
10300   [\\/]* | ?:[\\/]*)
10301   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10302   ;;
10303   *)
10304   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10305 for as_dir in $gcc_cv_tool_dirs
10306 do
10307   IFS=$as_save_IFS
10308   test -z "$as_dir" && as_dir=.
10309   for ac_exec_ext in '' $ac_executable_extensions; do
10310   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10311     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10312     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10313     break 2
10314   fi
10315 done
10316 done
10317
10318   ;;
10319 esac
10320 fi
10321 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10322
10323 if test -n "$STRIP_FOR_TARGET"; then
10324   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10325 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10326 else
10327   echo "$as_me:$LINENO: result: no" >&5
10328 echo "${ECHO_T}no" >&6
10329 fi
10330
10331 fi
10332 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10333
10334
10335 if test -n "$STRIP_FOR_TARGET"; then
10336   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10337 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10338   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10339 fi
10340
10341 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10342   for ncn_progname in strip; do
10343     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10344 set dummy ${ncn_progname}; ac_word=$2
10345 echo "$as_me:$LINENO: checking for $ac_word" >&5
10346 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10347 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10348   echo $ECHO_N "(cached) $ECHO_C" >&6
10349 else
10350   if test -n "$STRIP_FOR_TARGET"; then
10351   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10352 else
10353 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10354 for as_dir in $PATH
10355 do
10356   IFS=$as_save_IFS
10357   test -z "$as_dir" && as_dir=.
10358   for ac_exec_ext in '' $ac_executable_extensions; do
10359   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10360     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10361     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10362     break 2
10363   fi
10364 done
10365 done
10366
10367 fi
10368 fi
10369 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10370 if test -n "$STRIP_FOR_TARGET"; then
10371   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10372 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10373 else
10374   echo "$as_me:$LINENO: result: no" >&5
10375 echo "${ECHO_T}no" >&6
10376 fi
10377
10378   done
10379 fi
10380
10381 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10382   for ncn_progname in strip; do
10383     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10384 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10385     if test -x $with_build_time_tools/${ncn_progname}; then
10386       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10387       echo "$as_me:$LINENO: result: yes" >&5
10388 echo "${ECHO_T}yes" >&6
10389       break
10390     else
10391       echo "$as_me:$LINENO: result: no" >&5
10392 echo "${ECHO_T}no" >&6
10393     fi
10394   done
10395 fi
10396
10397 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10398   for ncn_progname in strip; do
10399     if test -n "$ncn_target_tool_prefix"; then
10400       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10401 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10402 echo "$as_me:$LINENO: checking for $ac_word" >&5
10403 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10404 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10405   echo $ECHO_N "(cached) $ECHO_C" >&6
10406 else
10407   if test -n "$STRIP_FOR_TARGET"; then
10408   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10409 else
10410 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10411 for as_dir in $PATH
10412 do
10413   IFS=$as_save_IFS
10414   test -z "$as_dir" && as_dir=.
10415   for ac_exec_ext in '' $ac_executable_extensions; do
10416   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10417     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10418     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10419     break 2
10420   fi
10421 done
10422 done
10423
10424 fi
10425 fi
10426 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10427 if test -n "$STRIP_FOR_TARGET"; then
10428   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10429 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10430 else
10431   echo "$as_me:$LINENO: result: no" >&5
10432 echo "${ECHO_T}no" >&6
10433 fi
10434
10435     fi
10436     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10437       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10438 set dummy ${ncn_progname}; ac_word=$2
10439 echo "$as_me:$LINENO: checking for $ac_word" >&5
10440 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10441 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10442   echo $ECHO_N "(cached) $ECHO_C" >&6
10443 else
10444   if test -n "$STRIP_FOR_TARGET"; then
10445   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10446 else
10447 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10448 for as_dir in $PATH
10449 do
10450   IFS=$as_save_IFS
10451   test -z "$as_dir" && as_dir=.
10452   for ac_exec_ext in '' $ac_executable_extensions; do
10453   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10454     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10455     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10456     break 2
10457   fi
10458 done
10459 done
10460
10461 fi
10462 fi
10463 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10464 if test -n "$STRIP_FOR_TARGET"; then
10465   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10466 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10467 else
10468   echo "$as_me:$LINENO: result: no" >&5
10469 echo "${ECHO_T}no" >&6
10470 fi
10471
10472     fi
10473     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10474   done
10475 fi
10476
10477 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10478   set dummy strip
10479   if test $build = $target ; then
10480     STRIP_FOR_TARGET="$2"
10481   else
10482     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10483   fi
10484 fi
10485
10486 else
10487   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10488 fi
10489
10490
10491
10492
10493 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10494   if test -n "$with_build_time_tools"; then
10495     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10496 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10497     if test -x $with_build_time_tools/windres; then
10498       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10499       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10500       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10501 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10502     else
10503       echo "$as_me:$LINENO: result: no" >&5
10504 echo "${ECHO_T}no" >&6
10505     fi
10506   elif test $build != $host && test $have_gcc_for_target = yes; then
10507     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10508     test $WINDRES_FOR_TARGET=windres && WINDRES_FOR_TARGET=
10509     ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10510   fi
10511 fi
10512 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10513   # Extract the first word of "windres", so it can be a program name with args.
10514 set dummy windres; ac_word=$2
10515 echo "$as_me:$LINENO: checking for $ac_word" >&5
10516 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10517 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10518   echo $ECHO_N "(cached) $ECHO_C" >&6
10519 else
10520   case $WINDRES_FOR_TARGET in
10521   [\\/]* | ?:[\\/]*)
10522   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10523   ;;
10524   *)
10525   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10526 for as_dir in $gcc_cv_tool_dirs
10527 do
10528   IFS=$as_save_IFS
10529   test -z "$as_dir" && as_dir=.
10530   for ac_exec_ext in '' $ac_executable_extensions; do
10531   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10532     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10533     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10534     break 2
10535   fi
10536 done
10537 done
10538
10539   ;;
10540 esac
10541 fi
10542 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10543
10544 if test -n "$WINDRES_FOR_TARGET"; then
10545   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10546 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10547 else
10548   echo "$as_me:$LINENO: result: no" >&5
10549 echo "${ECHO_T}no" >&6
10550 fi
10551
10552 fi
10553 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10554
10555
10556 if test -n "$WINDRES_FOR_TARGET"; then
10557   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10558 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10559   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10560 fi
10561
10562 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10563   for ncn_progname in windres; do
10564     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10565 set dummy ${ncn_progname}; ac_word=$2
10566 echo "$as_me:$LINENO: checking for $ac_word" >&5
10567 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10568 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10569   echo $ECHO_N "(cached) $ECHO_C" >&6
10570 else
10571   if test -n "$WINDRES_FOR_TARGET"; then
10572   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10573 else
10574 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10575 for as_dir in $PATH
10576 do
10577   IFS=$as_save_IFS
10578   test -z "$as_dir" && as_dir=.
10579   for ac_exec_ext in '' $ac_executable_extensions; do
10580   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10581     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10582     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10583     break 2
10584   fi
10585 done
10586 done
10587
10588 fi
10589 fi
10590 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10591 if test -n "$WINDRES_FOR_TARGET"; then
10592   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10593 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10594 else
10595   echo "$as_me:$LINENO: result: no" >&5
10596 echo "${ECHO_T}no" >&6
10597 fi
10598
10599   done
10600 fi
10601
10602 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10603   for ncn_progname in windres; do
10604     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10605 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10606     if test -x $with_build_time_tools/${ncn_progname}; then
10607       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10608       echo "$as_me:$LINENO: result: yes" >&5
10609 echo "${ECHO_T}yes" >&6
10610       break
10611     else
10612       echo "$as_me:$LINENO: result: no" >&5
10613 echo "${ECHO_T}no" >&6
10614     fi
10615   done
10616 fi
10617
10618 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10619   for ncn_progname in windres; do
10620     if test -n "$ncn_target_tool_prefix"; then
10621       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10622 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10623 echo "$as_me:$LINENO: checking for $ac_word" >&5
10624 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10625 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10626   echo $ECHO_N "(cached) $ECHO_C" >&6
10627 else
10628   if test -n "$WINDRES_FOR_TARGET"; then
10629   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10630 else
10631 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10632 for as_dir in $PATH
10633 do
10634   IFS=$as_save_IFS
10635   test -z "$as_dir" && as_dir=.
10636   for ac_exec_ext in '' $ac_executable_extensions; do
10637   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10638     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10639     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10640     break 2
10641   fi
10642 done
10643 done
10644
10645 fi
10646 fi
10647 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10648 if test -n "$WINDRES_FOR_TARGET"; then
10649   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10650 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10651 else
10652   echo "$as_me:$LINENO: result: no" >&5
10653 echo "${ECHO_T}no" >&6
10654 fi
10655
10656     fi
10657     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
10658       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10659 set dummy ${ncn_progname}; ac_word=$2
10660 echo "$as_me:$LINENO: checking for $ac_word" >&5
10661 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10662 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10663   echo $ECHO_N "(cached) $ECHO_C" >&6
10664 else
10665   if test -n "$WINDRES_FOR_TARGET"; then
10666   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10667 else
10668 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10669 for as_dir in $PATH
10670 do
10671   IFS=$as_save_IFS
10672   test -z "$as_dir" && as_dir=.
10673   for ac_exec_ext in '' $ac_executable_extensions; do
10674   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10675     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10676     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10677     break 2
10678   fi
10679 done
10680 done
10681
10682 fi
10683 fi
10684 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10685 if test -n "$WINDRES_FOR_TARGET"; then
10686   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10687 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10688 else
10689   echo "$as_me:$LINENO: result: no" >&5
10690 echo "${ECHO_T}no" >&6
10691 fi
10692
10693     fi
10694     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
10695   done
10696 fi
10697
10698 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
10699   set dummy windres
10700   if test $build = $target ; then
10701     WINDRES_FOR_TARGET="$2"
10702   else
10703     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
10704   fi
10705 fi
10706
10707 else
10708   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10709 fi
10710
10711
10712 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
10713
10714 echo "$as_me:$LINENO: checking where to find the target ar" >&5
10715 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
10716 if test "x${build}" != "x${host}" ; then
10717   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
10718     # We already found the complete path
10719     echo "$as_me:$LINENO: result: pre-installed in \`dirname $AR_FOR_TARGET\`" >&5
10720 echo "${ECHO_T}pre-installed in \`dirname $AR_FOR_TARGET\`" >&6
10721   else
10722     # Canadian cross, just use what we found
10723     echo "$as_me:$LINENO: result: pre-installed" >&5
10724 echo "${ECHO_T}pre-installed" >&6
10725   fi
10726 else
10727   ok=yes
10728   case " ${configdirs} " in
10729     *" binutils "*) ;;
10730     *) ok=no ;;
10731   esac
10732
10733   if test $ok = yes; then
10734     # An in-tree tool is available and we can use it
10735     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
10736     echo "$as_me:$LINENO: result: just compiled" >&5
10737 echo "${ECHO_T}just compiled" >&6
10738   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
10739     # We already found the complete path
10740     echo "$as_me:$LINENO: result: pre-installed in \`dirname $AR_FOR_TARGET\`" >&5
10741 echo "${ECHO_T}pre-installed in \`dirname $AR_FOR_TARGET\`" >&6
10742   elif test "x$target" = "x$host"; then
10743     # We can use an host tool
10744     AR_FOR_TARGET='$(AR)'
10745     echo "$as_me:$LINENO: result: host tool" >&5
10746 echo "${ECHO_T}host tool" >&6
10747   else
10748     # We need a cross tool
10749     echo "$as_me:$LINENO: result: pre-installed" >&5
10750 echo "${ECHO_T}pre-installed" >&6
10751   fi
10752 fi
10753
10754 echo "$as_me:$LINENO: checking where to find the target as" >&5
10755 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
10756 if test "x${build}" != "x${host}" ; then
10757   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
10758     # We already found the complete path
10759     echo "$as_me:$LINENO: result: pre-installed in \`dirname $AS_FOR_TARGET\`" >&5
10760 echo "${ECHO_T}pre-installed in \`dirname $AS_FOR_TARGET\`" >&6
10761   else
10762     # Canadian cross, just use what we found
10763     echo "$as_me:$LINENO: result: pre-installed" >&5
10764 echo "${ECHO_T}pre-installed" >&6
10765   fi
10766 else
10767   ok=yes
10768   case " ${configdirs} " in
10769     *" gas "*) ;;
10770     *) ok=no ;;
10771   esac
10772
10773   if test $ok = yes; then
10774     # An in-tree tool is available and we can use it
10775     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
10776     echo "$as_me:$LINENO: result: just compiled" >&5
10777 echo "${ECHO_T}just compiled" >&6
10778   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
10779     # We already found the complete path
10780     echo "$as_me:$LINENO: result: pre-installed in \`dirname $AS_FOR_TARGET\`" >&5
10781 echo "${ECHO_T}pre-installed in \`dirname $AS_FOR_TARGET\`" >&6
10782   elif test "x$target" = "x$host"; then
10783     # We can use an host tool
10784     AS_FOR_TARGET='$(AS)'
10785     echo "$as_me:$LINENO: result: host tool" >&5
10786 echo "${ECHO_T}host tool" >&6
10787   else
10788     # We need a cross tool
10789     echo "$as_me:$LINENO: result: pre-installed" >&5
10790 echo "${ECHO_T}pre-installed" >&6
10791   fi
10792 fi
10793
10794 echo "$as_me:$LINENO: checking where to find the target cc" >&5
10795 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
10796 if test "x${build}" != "x${host}" ; then
10797   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
10798     # We already found the complete path
10799     echo "$as_me:$LINENO: result: pre-installed in \`dirname $CC_FOR_TARGET\`" >&5
10800 echo "${ECHO_T}pre-installed in \`dirname $CC_FOR_TARGET\`" >&6
10801   else
10802     # Canadian cross, just use what we found
10803     echo "$as_me:$LINENO: result: pre-installed" >&5
10804 echo "${ECHO_T}pre-installed" >&6
10805   fi
10806 else
10807   ok=yes
10808   case " ${configdirs} " in
10809     *" gcc "*) ;;
10810     *) ok=no ;;
10811   esac
10812
10813   if test $ok = yes; then
10814     # An in-tree tool is available and we can use it
10815     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
10816     echo "$as_me:$LINENO: result: just compiled" >&5
10817 echo "${ECHO_T}just compiled" >&6
10818   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
10819     # We already found the complete path
10820     echo "$as_me:$LINENO: result: pre-installed in \`dirname $CC_FOR_TARGET\`" >&5
10821 echo "${ECHO_T}pre-installed in \`dirname $CC_FOR_TARGET\`" >&6
10822   elif test "x$target" = "x$host"; then
10823     # We can use an host tool
10824     CC_FOR_TARGET='$(CC)'
10825     echo "$as_me:$LINENO: result: host tool" >&5
10826 echo "${ECHO_T}host tool" >&6
10827   else
10828     # We need a cross tool
10829     echo "$as_me:$LINENO: result: pre-installed" >&5
10830 echo "${ECHO_T}pre-installed" >&6
10831   fi
10832 fi
10833
10834 echo "$as_me:$LINENO: checking where to find the target c++" >&5
10835 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
10836 if test "x${build}" != "x${host}" ; then
10837   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
10838     # We already found the complete path
10839     echo "$as_me:$LINENO: result: pre-installed in \`dirname $CXX_FOR_TARGET\`" >&5
10840 echo "${ECHO_T}pre-installed in \`dirname $CXX_FOR_TARGET\`" >&6
10841   else
10842     # Canadian cross, just use what we found
10843     echo "$as_me:$LINENO: result: pre-installed" >&5
10844 echo "${ECHO_T}pre-installed" >&6
10845   fi
10846 else
10847   ok=yes
10848   case " ${configdirs} " in
10849     *" gcc "*) ;;
10850     *) ok=no ;;
10851   esac
10852   case ,${enable_languages}, in
10853     *,c++,*) ;;
10854     *) ok=no ;;
10855   esac
10856   if test $ok = yes; then
10857     # An in-tree tool is available and we can use it
10858     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'
10859     echo "$as_me:$LINENO: result: just compiled" >&5
10860 echo "${ECHO_T}just compiled" >&6
10861   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
10862     # We already found the complete path
10863     echo "$as_me:$LINENO: result: pre-installed in \`dirname $CXX_FOR_TARGET\`" >&5
10864 echo "${ECHO_T}pre-installed in \`dirname $CXX_FOR_TARGET\`" >&6
10865   elif test "x$target" = "x$host"; then
10866     # We can use an host tool
10867     CXX_FOR_TARGET='$(CXX)'
10868     echo "$as_me:$LINENO: result: host tool" >&5
10869 echo "${ECHO_T}host tool" >&6
10870   else
10871     # We need a cross tool
10872     echo "$as_me:$LINENO: result: pre-installed" >&5
10873 echo "${ECHO_T}pre-installed" >&6
10874   fi
10875 fi
10876
10877 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
10878 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
10879 if test "x${build}" != "x${host}" ; then
10880   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
10881     # We already found the complete path
10882     echo "$as_me:$LINENO: result: pre-installed in \`dirname $RAW_CXX_FOR_TARGET\`" >&5
10883 echo "${ECHO_T}pre-installed in \`dirname $RAW_CXX_FOR_TARGET\`" >&6
10884   else
10885     # Canadian cross, just use what we found
10886     echo "$as_me:$LINENO: result: pre-installed" >&5
10887 echo "${ECHO_T}pre-installed" >&6
10888   fi
10889 else
10890   ok=yes
10891   case " ${configdirs} " in
10892     *" gcc "*) ;;
10893     *) ok=no ;;
10894   esac
10895   case ,${enable_languages}, in
10896     *,c++,*) ;;
10897     *) ok=no ;;
10898   esac
10899   if test $ok = yes; then
10900     # An in-tree tool is available and we can use it
10901     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'
10902     echo "$as_me:$LINENO: result: just compiled" >&5
10903 echo "${ECHO_T}just compiled" >&6
10904   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
10905     # We already found the complete path
10906     echo "$as_me:$LINENO: result: pre-installed in \`dirname $RAW_CXX_FOR_TARGET\`" >&5
10907 echo "${ECHO_T}pre-installed in \`dirname $RAW_CXX_FOR_TARGET\`" >&6
10908   elif test "x$target" = "x$host"; then
10909     # We can use an host tool
10910     RAW_CXX_FOR_TARGET='$(CXX)'
10911     echo "$as_me:$LINENO: result: host tool" >&5
10912 echo "${ECHO_T}host tool" >&6
10913   else
10914     # We need a cross tool
10915     echo "$as_me:$LINENO: result: pre-installed" >&5
10916 echo "${ECHO_T}pre-installed" >&6
10917   fi
10918 fi
10919
10920 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
10921 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
10922 if test "x${build}" != "x${host}" ; then
10923   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
10924     # We already found the complete path
10925     echo "$as_me:$LINENO: result: pre-installed in \`dirname $DLLTOOL_FOR_TARGET\`" >&5
10926 echo "${ECHO_T}pre-installed in \`dirname $DLLTOOL_FOR_TARGET\`" >&6
10927   else
10928     # Canadian cross, just use what we found
10929     echo "$as_me:$LINENO: result: pre-installed" >&5
10930 echo "${ECHO_T}pre-installed" >&6
10931   fi
10932 else
10933   ok=yes
10934   case " ${configdirs} " in
10935     *" binutils "*) ;;
10936     *) ok=no ;;
10937   esac
10938
10939   if test $ok = yes; then
10940     # An in-tree tool is available and we can use it
10941     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
10942     echo "$as_me:$LINENO: result: just compiled" >&5
10943 echo "${ECHO_T}just compiled" >&6
10944   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
10945     # We already found the complete path
10946     echo "$as_me:$LINENO: result: pre-installed in \`dirname $DLLTOOL_FOR_TARGET\`" >&5
10947 echo "${ECHO_T}pre-installed in \`dirname $DLLTOOL_FOR_TARGET\`" >&6
10948   elif test "x$target" = "x$host"; then
10949     # We can use an host tool
10950     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
10951     echo "$as_me:$LINENO: result: host tool" >&5
10952 echo "${ECHO_T}host tool" >&6
10953   else
10954     # We need a cross tool
10955     echo "$as_me:$LINENO: result: pre-installed" >&5
10956 echo "${ECHO_T}pre-installed" >&6
10957   fi
10958 fi
10959
10960 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
10961 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
10962 if test "x${build}" != "x${host}" ; then
10963   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
10964     # We already found the complete path
10965     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GCC_FOR_TARGET\`" >&5
10966 echo "${ECHO_T}pre-installed in \`dirname $GCC_FOR_TARGET\`" >&6
10967   else
10968     # Canadian cross, just use what we found
10969     echo "$as_me:$LINENO: result: pre-installed" >&5
10970 echo "${ECHO_T}pre-installed" >&6
10971   fi
10972 else
10973   ok=yes
10974   case " ${configdirs} " in
10975     *" gcc "*) ;;
10976     *) ok=no ;;
10977   esac
10978
10979   if test $ok = yes; then
10980     # An in-tree tool is available and we can use it
10981     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
10982     echo "$as_me:$LINENO: result: just compiled" >&5
10983 echo "${ECHO_T}just compiled" >&6
10984   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
10985     # We already found the complete path
10986     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GCC_FOR_TARGET\`" >&5
10987 echo "${ECHO_T}pre-installed in \`dirname $GCC_FOR_TARGET\`" >&6
10988   elif test "x$target" = "x$host"; then
10989     # We can use an host tool
10990     GCC_FOR_TARGET='$()'
10991     echo "$as_me:$LINENO: result: host tool" >&5
10992 echo "${ECHO_T}host tool" >&6
10993   else
10994     # We need a cross tool
10995     echo "$as_me:$LINENO: result: pre-installed" >&5
10996 echo "${ECHO_T}pre-installed" >&6
10997   fi
10998 fi
10999
11000 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11001 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11002 if test "x${build}" != "x${host}" ; then
11003   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11004     # We already found the complete path
11005     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GCJ_FOR_TARGET\`" >&5
11006 echo "${ECHO_T}pre-installed in \`dirname $GCJ_FOR_TARGET\`" >&6
11007   else
11008     # Canadian cross, just use what we found
11009     echo "$as_me:$LINENO: result: pre-installed" >&5
11010 echo "${ECHO_T}pre-installed" >&6
11011   fi
11012 else
11013   ok=yes
11014   case " ${configdirs} " in
11015     *" gcc "*) ;;
11016     *) ok=no ;;
11017   esac
11018   case ,${enable_languages}, in
11019     *,java,*) ;;
11020     *) ok=no ;;
11021   esac
11022   if test $ok = yes; then
11023     # An in-tree tool is available and we can use it
11024     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11025     echo "$as_me:$LINENO: result: just compiled" >&5
11026 echo "${ECHO_T}just compiled" >&6
11027   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11028     # We already found the complete path
11029     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GCJ_FOR_TARGET\`" >&5
11030 echo "${ECHO_T}pre-installed in \`dirname $GCJ_FOR_TARGET\`" >&6
11031   elif test "x$target" = "x$host"; then
11032     # We can use an host tool
11033     GCJ_FOR_TARGET='$(GCJ)'
11034     echo "$as_me:$LINENO: result: host tool" >&5
11035 echo "${ECHO_T}host tool" >&6
11036   else
11037     # We need a cross tool
11038     echo "$as_me:$LINENO: result: pre-installed" >&5
11039 echo "${ECHO_T}pre-installed" >&6
11040   fi
11041 fi
11042
11043 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11044 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11045 if test "x${build}" != "x${host}" ; then
11046   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11047     # We already found the complete path
11048     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GFORTRAN_FOR_TARGET\`" >&5
11049 echo "${ECHO_T}pre-installed in \`dirname $GFORTRAN_FOR_TARGET\`" >&6
11050   else
11051     # Canadian cross, just use what we found
11052     echo "$as_me:$LINENO: result: pre-installed" >&5
11053 echo "${ECHO_T}pre-installed" >&6
11054   fi
11055 else
11056   ok=yes
11057   case " ${configdirs} " in
11058     *" gcc "*) ;;
11059     *) ok=no ;;
11060   esac
11061   case ,${enable_languages}, in
11062     *,fortran,*) ;;
11063     *) ok=no ;;
11064   esac
11065   if test $ok = yes; then
11066     # An in-tree tool is available and we can use it
11067     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11068     echo "$as_me:$LINENO: result: just compiled" >&5
11069 echo "${ECHO_T}just compiled" >&6
11070   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11071     # We already found the complete path
11072     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GFORTRAN_FOR_TARGET\`" >&5
11073 echo "${ECHO_T}pre-installed in \`dirname $GFORTRAN_FOR_TARGET\`" >&6
11074   elif test "x$target" = "x$host"; then
11075     # We can use an host tool
11076     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11077     echo "$as_me:$LINENO: result: host tool" >&5
11078 echo "${ECHO_T}host tool" >&6
11079   else
11080     # We need a cross tool
11081     echo "$as_me:$LINENO: result: pre-installed" >&5
11082 echo "${ECHO_T}pre-installed" >&6
11083   fi
11084 fi
11085
11086 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11087 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11088 if test "x${build}" != "x${host}" ; then
11089   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11090     # We already found the complete path
11091     echo "$as_me:$LINENO: result: pre-installed in \`dirname $LD_FOR_TARGET\`" >&5
11092 echo "${ECHO_T}pre-installed in \`dirname $LD_FOR_TARGET\`" >&6
11093   else
11094     # Canadian cross, just use what we found
11095     echo "$as_me:$LINENO: result: pre-installed" >&5
11096 echo "${ECHO_T}pre-installed" >&6
11097   fi
11098 else
11099   ok=yes
11100   case " ${configdirs} " in
11101     *" ld "*) ;;
11102     *) ok=no ;;
11103   esac
11104
11105   if test $ok = yes; then
11106     # An in-tree tool is available and we can use it
11107     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11108     echo "$as_me:$LINENO: result: just compiled" >&5
11109 echo "${ECHO_T}just compiled" >&6
11110   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11111     # We already found the complete path
11112     echo "$as_me:$LINENO: result: pre-installed in \`dirname $LD_FOR_TARGET\`" >&5
11113 echo "${ECHO_T}pre-installed in \`dirname $LD_FOR_TARGET\`" >&6
11114   elif test "x$target" = "x$host"; then
11115     # We can use an host tool
11116     LD_FOR_TARGET='$(LD)'
11117     echo "$as_me:$LINENO: result: host tool" >&5
11118 echo "${ECHO_T}host tool" >&6
11119   else
11120     # We need a cross tool
11121     echo "$as_me:$LINENO: result: pre-installed" >&5
11122 echo "${ECHO_T}pre-installed" >&6
11123   fi
11124 fi
11125
11126 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11127 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11128 if test "x${build}" != "x${host}" ; then
11129   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11130     # We already found the complete path
11131     echo "$as_me:$LINENO: result: pre-installed in \`dirname $LIPO_FOR_TARGET\`" >&5
11132 echo "${ECHO_T}pre-installed in \`dirname $LIPO_FOR_TARGET\`" >&6
11133   else
11134     # Canadian cross, just use what we found
11135     echo "$as_me:$LINENO: result: pre-installed" >&5
11136 echo "${ECHO_T}pre-installed" >&6
11137   fi
11138 else
11139   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11140     # We already found the complete path
11141     echo "$as_me:$LINENO: result: pre-installed in \`dirname $LIPO_FOR_TARGET\`" >&5
11142 echo "${ECHO_T}pre-installed in \`dirname $LIPO_FOR_TARGET\`" >&6
11143   elif test "x$target" = "x$host"; then
11144     # We can use an host tool
11145     LIPO_FOR_TARGET='$(LIPO)'
11146     echo "$as_me:$LINENO: result: host tool" >&5
11147 echo "${ECHO_T}host tool" >&6
11148   else
11149     # We need a cross tool
11150     echo "$as_me:$LINENO: result: pre-installed" >&5
11151 echo "${ECHO_T}pre-installed" >&6
11152   fi
11153 fi
11154
11155 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11156 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11157 if test "x${build}" != "x${host}" ; then
11158   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11159     # We already found the complete path
11160     echo "$as_me:$LINENO: result: pre-installed in \`dirname $NM_FOR_TARGET\`" >&5
11161 echo "${ECHO_T}pre-installed in \`dirname $NM_FOR_TARGET\`" >&6
11162   else
11163     # Canadian cross, just use what we found
11164     echo "$as_me:$LINENO: result: pre-installed" >&5
11165 echo "${ECHO_T}pre-installed" >&6
11166   fi
11167 else
11168   ok=yes
11169   case " ${configdirs} " in
11170     *" binutils "*) ;;
11171     *) ok=no ;;
11172   esac
11173
11174   if test $ok = yes; then
11175     # An in-tree tool is available and we can use it
11176     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11177     echo "$as_me:$LINENO: result: just compiled" >&5
11178 echo "${ECHO_T}just compiled" >&6
11179   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11180     # We already found the complete path
11181     echo "$as_me:$LINENO: result: pre-installed in \`dirname $NM_FOR_TARGET\`" >&5
11182 echo "${ECHO_T}pre-installed in \`dirname $NM_FOR_TARGET\`" >&6
11183   elif test "x$target" = "x$host"; then
11184     # We can use an host tool
11185     NM_FOR_TARGET='$(NM)'
11186     echo "$as_me:$LINENO: result: host tool" >&5
11187 echo "${ECHO_T}host tool" >&6
11188   else
11189     # We need a cross tool
11190     echo "$as_me:$LINENO: result: pre-installed" >&5
11191 echo "${ECHO_T}pre-installed" >&6
11192   fi
11193 fi
11194
11195 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11196 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11197 if test "x${build}" != "x${host}" ; then
11198   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11199     # We already found the complete path
11200     echo "$as_me:$LINENO: result: pre-installed in \`dirname $OBJDUMP_FOR_TARGET\`" >&5
11201 echo "${ECHO_T}pre-installed in \`dirname $OBJDUMP_FOR_TARGET\`" >&6
11202   else
11203     # Canadian cross, just use what we found
11204     echo "$as_me:$LINENO: result: pre-installed" >&5
11205 echo "${ECHO_T}pre-installed" >&6
11206   fi
11207 else
11208   ok=yes
11209   case " ${configdirs} " in
11210     *" binutils "*) ;;
11211     *) ok=no ;;
11212   esac
11213
11214   if test $ok = yes; then
11215     # An in-tree tool is available and we can use it
11216     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11217     echo "$as_me:$LINENO: result: just compiled" >&5
11218 echo "${ECHO_T}just compiled" >&6
11219   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11220     # We already found the complete path
11221     echo "$as_me:$LINENO: result: pre-installed in \`dirname $OBJDUMP_FOR_TARGET\`" >&5
11222 echo "${ECHO_T}pre-installed in \`dirname $OBJDUMP_FOR_TARGET\`" >&6
11223   elif test "x$target" = "x$host"; then
11224     # We can use an host tool
11225     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11226     echo "$as_me:$LINENO: result: host tool" >&5
11227 echo "${ECHO_T}host tool" >&6
11228   else
11229     # We need a cross tool
11230     echo "$as_me:$LINENO: result: pre-installed" >&5
11231 echo "${ECHO_T}pre-installed" >&6
11232   fi
11233 fi
11234
11235 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11236 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11237 if test "x${build}" != "x${host}" ; then
11238   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11239     # We already found the complete path
11240     echo "$as_me:$LINENO: result: pre-installed in \`dirname $RANLIB_FOR_TARGET\`" >&5
11241 echo "${ECHO_T}pre-installed in \`dirname $RANLIB_FOR_TARGET\`" >&6
11242   else
11243     # Canadian cross, just use what we found
11244     echo "$as_me:$LINENO: result: pre-installed" >&5
11245 echo "${ECHO_T}pre-installed" >&6
11246   fi
11247 else
11248   ok=yes
11249   case " ${configdirs} " in
11250     *" binutils "*) ;;
11251     *) ok=no ;;
11252   esac
11253
11254   if test $ok = yes; then
11255     # An in-tree tool is available and we can use it
11256     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11257     echo "$as_me:$LINENO: result: just compiled" >&5
11258 echo "${ECHO_T}just compiled" >&6
11259   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11260     # We already found the complete path
11261     echo "$as_me:$LINENO: result: pre-installed in \`dirname $RANLIB_FOR_TARGET\`" >&5
11262 echo "${ECHO_T}pre-installed in \`dirname $RANLIB_FOR_TARGET\`" >&6
11263   elif test "x$target" = "x$host"; then
11264     # We can use an host tool
11265     RANLIB_FOR_TARGET='$(RANLIB)'
11266     echo "$as_me:$LINENO: result: host tool" >&5
11267 echo "${ECHO_T}host tool" >&6
11268   else
11269     # We need a cross tool
11270     echo "$as_me:$LINENO: result: pre-installed" >&5
11271 echo "${ECHO_T}pre-installed" >&6
11272   fi
11273 fi
11274
11275 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11276 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11277 if test "x${build}" != "x${host}" ; then
11278   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11279     # We already found the complete path
11280     echo "$as_me:$LINENO: result: pre-installed in \`dirname $STRIP_FOR_TARGET\`" >&5
11281 echo "${ECHO_T}pre-installed in \`dirname $STRIP_FOR_TARGET\`" >&6
11282   else
11283     # Canadian cross, just use what we found
11284     echo "$as_me:$LINENO: result: pre-installed" >&5
11285 echo "${ECHO_T}pre-installed" >&6
11286   fi
11287 else
11288   ok=yes
11289   case " ${configdirs} " in
11290     *" binutils "*) ;;
11291     *) ok=no ;;
11292   esac
11293
11294   if test $ok = yes; then
11295     # An in-tree tool is available and we can use it
11296     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11297     echo "$as_me:$LINENO: result: just compiled" >&5
11298 echo "${ECHO_T}just compiled" >&6
11299   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11300     # We already found the complete path
11301     echo "$as_me:$LINENO: result: pre-installed in \`dirname $STRIP_FOR_TARGET\`" >&5
11302 echo "${ECHO_T}pre-installed in \`dirname $STRIP_FOR_TARGET\`" >&6
11303   elif test "x$target" = "x$host"; then
11304     # We can use an host tool
11305     STRIP_FOR_TARGET='$(STRIP)'
11306     echo "$as_me:$LINENO: result: host tool" >&5
11307 echo "${ECHO_T}host tool" >&6
11308   else
11309     # We need a cross tool
11310     echo "$as_me:$LINENO: result: pre-installed" >&5
11311 echo "${ECHO_T}pre-installed" >&6
11312   fi
11313 fi
11314
11315 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11316 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11317 if test "x${build}" != "x${host}" ; then
11318   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11319     # We already found the complete path
11320     echo "$as_me:$LINENO: result: pre-installed in \`dirname $WINDRES_FOR_TARGET\`" >&5
11321 echo "${ECHO_T}pre-installed in \`dirname $WINDRES_FOR_TARGET\`" >&6
11322   else
11323     # Canadian cross, just use what we found
11324     echo "$as_me:$LINENO: result: pre-installed" >&5
11325 echo "${ECHO_T}pre-installed" >&6
11326   fi
11327 else
11328   ok=yes
11329   case " ${configdirs} " in
11330     *" binutils "*) ;;
11331     *) ok=no ;;
11332   esac
11333
11334   if test $ok = yes; then
11335     # An in-tree tool is available and we can use it
11336     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11337     echo "$as_me:$LINENO: result: just compiled" >&5
11338 echo "${ECHO_T}just compiled" >&6
11339   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11340     # We already found the complete path
11341     echo "$as_me:$LINENO: result: pre-installed in \`dirname $WINDRES_FOR_TARGET\`" >&5
11342 echo "${ECHO_T}pre-installed in \`dirname $WINDRES_FOR_TARGET\`" >&6
11343   elif test "x$target" = "x$host"; then
11344     # We can use an host tool
11345     WINDRES_FOR_TARGET='$(WINDRES)'
11346     echo "$as_me:$LINENO: result: host tool" >&5
11347 echo "${ECHO_T}host tool" >&6
11348   else
11349     # We need a cross tool
11350     echo "$as_me:$LINENO: result: pre-installed" >&5
11351 echo "${ECHO_T}pre-installed" >&6
11352   fi
11353 fi
11354
11355
11356
11357
11358
11359 # Certain tools may need extra flags.
11360 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
11361 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
11362 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
11363
11364 # When building target libraries, except in a Canadian cross, we use
11365 # the same toolchain as the compiler we just built.
11366 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
11367 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
11368 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
11369 if test $host = $build; then
11370   case " $configdirs " in
11371     *" gcc "*)
11372       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
11373       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
11374       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
11375       ;;
11376   esac
11377 fi
11378
11379
11380
11381
11382
11383 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
11384 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
11385 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
11386 if test "${enable_maintainer_mode+set}" = set; then
11387   enableval="$enable_maintainer_mode"
11388   USE_MAINTAINER_MODE=$enableval
11389 else
11390   USE_MAINTAINER_MODE=no
11391 fi;
11392 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
11393 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
11394
11395
11396 if test "$USE_MAINTAINER_MODE" = yes; then
11397   MAINTAINER_MODE_TRUE=
11398   MAINTAINER_MODE_FALSE='#'
11399 else
11400   MAINTAINER_MODE_TRUE='#'
11401   MAINTAINER_MODE_FALSE=
11402 fi
11403 MAINT=$MAINTAINER_MODE_TRUE
11404
11405 # ---------------------
11406 # GCC bootstrap support
11407 # ---------------------
11408
11409 # Stage specific cflags for build.
11410 stage1_cflags="-g"
11411 case $build in
11412   vax-*-*)
11413     case ${GCC} in
11414       yes) stage1_cflags="-g -Wa,-J" ;;
11415       *) stage1_cflags="-g -J" ;;
11416     esac ;;
11417 esac
11418
11419 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
11420 if test "$GCC" = yes; then
11421   saved_CFLAGS="$CFLAGS"
11422
11423   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
11424   CFLAGS="$CFLAGS -fkeep-inline-functions"
11425   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
11426 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
11427   cat >conftest.$ac_ext <<_ACEOF
11428 /* confdefs.h.  */
11429 _ACEOF
11430 cat confdefs.h >>conftest.$ac_ext
11431 cat >>conftest.$ac_ext <<_ACEOF
11432 /* end confdefs.h.  */
11433
11434 int
11435 main ()
11436 {
11437
11438   ;
11439   return 0;
11440 }
11441 _ACEOF
11442 rm -f conftest.$ac_objext
11443 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11444   (eval $ac_compile) 2>conftest.er1
11445   ac_status=$?
11446   grep -v '^ *+' conftest.er1 >conftest.err
11447   rm -f conftest.er1
11448   cat conftest.err >&5
11449   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11450   (exit $ac_status); } &&
11451          { ac_try='test -z "$ac_c_werror_flag"
11452                          || test ! -s conftest.err'
11453   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11454   (eval $ac_try) 2>&5
11455   ac_status=$?
11456   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11457   (exit $ac_status); }; } &&
11458          { ac_try='test -s conftest.$ac_objext'
11459   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11460   (eval $ac_try) 2>&5
11461   ac_status=$?
11462   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11463   (exit $ac_status); }; }; then
11464   echo "$as_me:$LINENO: result: yes" >&5
11465 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
11466 else
11467   echo "$as_me: failed program was:" >&5
11468 sed 's/^/| /' conftest.$ac_ext >&5
11469
11470 echo "$as_me:$LINENO: result: no" >&5
11471 echo "${ECHO_T}no" >&6
11472 fi
11473 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11474
11475   CFLAGS="$saved_CFLAGS"
11476 fi
11477
11478
11479
11480 # Enable --enable-checking in stage1 of the compiler.
11481 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
11482 if test "${enable_stage1_checking+set}" = set; then
11483   enableval="$enable_stage1_checking"
11484   stage1_checking=--enable-checking=${enable_stage1_checking}
11485 else
11486   if test "x$enable_checking" = xno; then
11487   stage1_checking=--enable-checking
11488 else
11489   stage1_checking=--enable-checking${enable_checking+=}$enable_checking
11490 fi
11491 fi;
11492
11493
11494 # Enable -Werror in bootstrap stage2 and later.
11495 # Check whether --enable-werror or --disable-werror was given.
11496 if test "${enable_werror+set}" = set; then
11497   enableval="$enable_werror"
11498
11499 else
11500   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
11501   enable_werror=yes
11502 else
11503   enable_werror=no
11504 fi
11505 fi;
11506 case ${enable_werror} in
11507   yes) stage2_werror_flag="--enable-werror-always" ;;
11508   *) stage2_werror_flag="" ;;
11509 esac
11510
11511
11512 # Flags needed to enable html installing and building
11513
11514 # Check whether --with-datarootdir or --without-datarootdir was given.
11515 if test "${with_datarootdir+set}" = set; then
11516   withval="$with_datarootdir"
11517   datarootdir="\${prefix}/${withval}"
11518 else
11519   datarootdir="\${prefix}/share"
11520 fi;
11521
11522
11523 # Check whether --with-docdir or --without-docdir was given.
11524 if test "${with_docdir+set}" = set; then
11525   withval="$with_docdir"
11526   docdir="\${prefix}/${withval}"
11527 else
11528   docdir="\${datarootdir}/doc"
11529 fi;
11530
11531
11532 # Check whether --with-htmldir or --without-htmldir was given.
11533 if test "${with_htmldir+set}" = set; then
11534   withval="$with_htmldir"
11535   htmldir="\${prefix}/${withval}"
11536 else
11537   htmldir="\${docdir}"
11538 fi;
11539
11540
11541
11542
11543
11544           ac_config_files="$ac_config_files Makefile"
11545 cat >confcache <<\_ACEOF
11546 # This file is a shell script that caches the results of configure
11547 # tests run on this system so they can be shared between configure
11548 # scripts and configure runs, see configure's option --config-cache.
11549 # It is not useful on other systems.  If it contains results you don't
11550 # want to keep, you may remove or edit it.
11551 #
11552 # config.status only pays attention to the cache file if you give it
11553 # the --recheck option to rerun configure.
11554 #
11555 # `ac_cv_env_foo' variables (set or unset) will be overridden when
11556 # loading this file, other *unset* `ac_cv_foo' will be assigned the
11557 # following values.
11558
11559 _ACEOF
11560
11561 # The following way of writing the cache mishandles newlines in values,
11562 # but we know of no workaround that is simple, portable, and efficient.
11563 # So, don't put newlines in cache variables' values.
11564 # Ultrix sh set writes to stderr and can't be redirected directly,
11565 # and sets the high bit in the cache file unless we assign to the vars.
11566 {
11567   (set) 2>&1 |
11568     case `(ac_space=' '; set | grep ac_space) 2>&1` in
11569     *ac_space=\ *)
11570       # `set' does not quote correctly, so add quotes (double-quote
11571       # substitution turns \\\\ into \\, and sed turns \\ into \).
11572       sed -n \
11573         "s/'/'\\\\''/g;
11574           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
11575       ;;
11576     *)
11577       # `set' quotes correctly as required by POSIX, so do not add quotes.
11578       sed -n \
11579         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
11580       ;;
11581     esac;
11582 } |
11583   sed '
11584      t clear
11585      : clear
11586      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
11587      t end
11588      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
11589      : end' >>confcache
11590 if diff $cache_file confcache >/dev/null 2>&1; then :; else
11591   if test -w $cache_file; then
11592     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
11593     cat confcache >$cache_file
11594   else
11595     echo "not updating unwritable cache $cache_file"
11596   fi
11597 fi
11598 rm -f confcache
11599
11600 test "x$prefix" = xNONE && prefix=$ac_default_prefix
11601 # Let make expand exec_prefix.
11602 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
11603
11604 # VPATH may cause trouble with some makes, so we remove $(srcdir),
11605 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
11606 # trailing colons and then remove the whole line if VPATH becomes empty
11607 # (actually we leave an empty line to preserve line numbers).
11608 if test "x$srcdir" = x.; then
11609   ac_vpsub='/^[  ]*VPATH[        ]*=/{
11610 s/:*\$(srcdir):*/:/;
11611 s/:*\${srcdir}:*/:/;
11612 s/:*@srcdir@:*/:/;
11613 s/^\([^=]*=[     ]*\):*/\1/;
11614 s/:*$//;
11615 s/^[^=]*=[       ]*$//;
11616 }'
11617 fi
11618
11619 # Transform confdefs.h into DEFS.
11620 # Protect against shell expansion while executing Makefile rules.
11621 # Protect against Makefile macro expansion.
11622 #
11623 # If the first sed substitution is executed (which looks for macros that
11624 # take arguments), then we branch to the quote section.  Otherwise,
11625 # look for a macro that doesn't take arguments.
11626 cat >confdef2opt.sed <<\_ACEOF
11627 t clear
11628 : clear
11629 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
11630 t quote
11631 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
11632 t quote
11633 d
11634 : quote
11635 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
11636 s,\[,\\&,g
11637 s,\],\\&,g
11638 s,\$,$$,g
11639 p
11640 _ACEOF
11641 # We use echo to avoid assuming a particular line-breaking character.
11642 # The extra dot is to prevent the shell from consuming trailing
11643 # line-breaks from the sub-command output.  A line-break within
11644 # single-quotes doesn't work because, if this script is created in a
11645 # platform that uses two characters for line-breaks (e.g., DOS), tr
11646 # would break.
11647 ac_LF_and_DOT=`echo; echo .`
11648 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
11649 rm -f confdef2opt.sed
11650
11651
11652 ac_libobjs=
11653 ac_ltlibobjs=
11654 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
11655   # 1. Remove the extension, and $U if already installed.
11656   ac_i=`echo "$ac_i" |
11657          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
11658   # 2. Add them.
11659   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
11660   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
11661 done
11662 LIBOBJS=$ac_libobjs
11663
11664 LTLIBOBJS=$ac_ltlibobjs
11665
11666
11667
11668 : ${CONFIG_STATUS=./config.status}
11669 ac_clean_files_save=$ac_clean_files
11670 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
11671 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
11672 echo "$as_me: creating $CONFIG_STATUS" >&6;}
11673 cat >$CONFIG_STATUS <<_ACEOF
11674 #! $SHELL
11675 # Generated by $as_me.
11676 # Run this file to recreate the current configuration.
11677 # Compiler output produced by configure, useful for debugging
11678 # configure, is in config.log if it exists.
11679
11680 debug=false
11681 ac_cs_recheck=false
11682 ac_cs_silent=false
11683 SHELL=\${CONFIG_SHELL-$SHELL}
11684 _ACEOF
11685
11686 cat >>$CONFIG_STATUS <<\_ACEOF
11687 ## --------------------- ##
11688 ## M4sh Initialization.  ##
11689 ## --------------------- ##
11690
11691 # Be Bourne compatible
11692 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
11693   emulate sh
11694   NULLCMD=:
11695   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
11696   # is contrary to our usage.  Disable this feature.
11697   alias -g '${1+"$@"}'='"$@"'
11698 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
11699   set -o posix
11700 fi
11701 DUALCASE=1; export DUALCASE # for MKS sh
11702
11703 # Support unset when possible.
11704 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
11705   as_unset=unset
11706 else
11707   as_unset=false
11708 fi
11709
11710
11711 # Work around bugs in pre-3.0 UWIN ksh.
11712 $as_unset ENV MAIL MAILPATH
11713 PS1='$ '
11714 PS2='> '
11715 PS4='+ '
11716
11717 # NLS nuisances.
11718 for as_var in \
11719   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
11720   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
11721   LC_TELEPHONE LC_TIME
11722 do
11723   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
11724     eval $as_var=C; export $as_var
11725   else
11726     $as_unset $as_var
11727   fi
11728 done
11729
11730 # Required to use basename.
11731 if expr a : '\(a\)' >/dev/null 2>&1; then
11732   as_expr=expr
11733 else
11734   as_expr=false
11735 fi
11736
11737 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
11738   as_basename=basename
11739 else
11740   as_basename=false
11741 fi
11742
11743
11744 # Name of the executable.
11745 as_me=`$as_basename "$0" ||
11746 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
11747          X"$0" : 'X\(//\)$' \| \
11748          X"$0" : 'X\(/\)$' \| \
11749          .     : '\(.\)' 2>/dev/null ||
11750 echo X/"$0" |
11751     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
11752           /^X\/\(\/\/\)$/{ s//\1/; q; }
11753           /^X\/\(\/\).*/{ s//\1/; q; }
11754           s/.*/./; q'`
11755
11756
11757 # PATH needs CR, and LINENO needs CR and PATH.
11758 # Avoid depending upon Character Ranges.
11759 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
11760 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
11761 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
11762 as_cr_digits='0123456789'
11763 as_cr_alnum=$as_cr_Letters$as_cr_digits
11764
11765 # The user is always right.
11766 if test "${PATH_SEPARATOR+set}" != set; then
11767   echo "#! /bin/sh" >conf$$.sh
11768   echo  "exit 0"   >>conf$$.sh
11769   chmod +x conf$$.sh
11770   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
11771     PATH_SEPARATOR=';'
11772   else
11773     PATH_SEPARATOR=:
11774   fi
11775   rm -f conf$$.sh
11776 fi
11777
11778
11779   as_lineno_1=$LINENO
11780   as_lineno_2=$LINENO
11781   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
11782   test "x$as_lineno_1" != "x$as_lineno_2" &&
11783   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
11784   # Find who we are.  Look in the path if we contain no path at all
11785   # relative or not.
11786   case $0 in
11787     *[\\/]* ) as_myself=$0 ;;
11788     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11789 for as_dir in $PATH
11790 do
11791   IFS=$as_save_IFS
11792   test -z "$as_dir" && as_dir=.
11793   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
11794 done
11795
11796        ;;
11797   esac
11798   # We did not find ourselves, most probably we were run as `sh COMMAND'
11799   # in which case we are not to be found in the path.
11800   if test "x$as_myself" = x; then
11801     as_myself=$0
11802   fi
11803   if test ! -f "$as_myself"; then
11804     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
11805 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
11806    { (exit 1); exit 1; }; }
11807   fi
11808   case $CONFIG_SHELL in
11809   '')
11810     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11811 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
11812 do
11813   IFS=$as_save_IFS
11814   test -z "$as_dir" && as_dir=.
11815   for as_base in sh bash ksh sh5; do
11816          case $as_dir in
11817          /*)
11818            if ("$as_dir/$as_base" -c '
11819   as_lineno_1=$LINENO
11820   as_lineno_2=$LINENO
11821   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
11822   test "x$as_lineno_1" != "x$as_lineno_2" &&
11823   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
11824              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
11825              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
11826              CONFIG_SHELL=$as_dir/$as_base
11827              export CONFIG_SHELL
11828              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
11829            fi;;
11830          esac
11831        done
11832 done
11833 ;;
11834   esac
11835
11836   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
11837   # uniformly replaced by the line number.  The first 'sed' inserts a
11838   # line-number line before each line; the second 'sed' does the real
11839   # work.  The second script uses 'N' to pair each line-number line
11840   # with the numbered line, and appends trailing '-' during
11841   # substitution so that $LINENO is not a special case at line end.
11842   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
11843   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
11844   sed '=' <$as_myself |
11845     sed '
11846       N
11847       s,$,-,
11848       : loop
11849       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
11850       t loop
11851       s,-$,,
11852       s,^['$as_cr_digits']*\n,,
11853     ' >$as_me.lineno &&
11854   chmod +x $as_me.lineno ||
11855     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
11856 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
11857    { (exit 1); exit 1; }; }
11858
11859   # Don't try to exec as it changes $[0], causing all sort of problems
11860   # (the dirname of $[0] is not the place where we might find the
11861   # original and so on.  Autoconf is especially sensible to this).
11862   . ./$as_me.lineno
11863   # Exit status is that of the last command.
11864   exit
11865 }
11866
11867
11868 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
11869   *c*,-n*) ECHO_N= ECHO_C='
11870 ' ECHO_T='      ' ;;
11871   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
11872   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
11873 esac
11874
11875 if expr a : '\(a\)' >/dev/null 2>&1; then
11876   as_expr=expr
11877 else
11878   as_expr=false
11879 fi
11880
11881 rm -f conf$$ conf$$.exe conf$$.file
11882 echo >conf$$.file
11883 if ln -s conf$$.file conf$$ 2>/dev/null; then
11884   # We could just check for DJGPP; but this test a) works b) is more generic
11885   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
11886   if test -f conf$$.exe; then
11887     # Don't use ln at all; we don't have any links
11888     as_ln_s='cp -p'
11889   else
11890     as_ln_s='ln -s'
11891   fi
11892 elif ln conf$$.file conf$$ 2>/dev/null; then
11893   as_ln_s=ln
11894 else
11895   as_ln_s='cp -p'
11896 fi
11897 rm -f conf$$ conf$$.exe conf$$.file
11898
11899 if mkdir -p . 2>/dev/null; then
11900   as_mkdir_p=:
11901 else
11902   test -d ./-p && rmdir ./-p
11903   as_mkdir_p=false
11904 fi
11905
11906 as_executable_p="test -f"
11907
11908 # Sed expression to map a string onto a valid CPP name.
11909 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
11910
11911 # Sed expression to map a string onto a valid variable name.
11912 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
11913
11914
11915 # IFS
11916 # We need space, tab and new line, in precisely that order.
11917 as_nl='
11918 '
11919 IFS="   $as_nl"
11920
11921 # CDPATH.
11922 $as_unset CDPATH
11923
11924 exec 6>&1
11925
11926 # Open the log real soon, to keep \$[0] and so on meaningful, and to
11927 # report actual input values of CONFIG_FILES etc. instead of their
11928 # values after options handling.  Logging --version etc. is OK.
11929 exec 5>>config.log
11930 {
11931   echo
11932   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
11933 ## Running $as_me. ##
11934 _ASBOX
11935 } >&5
11936 cat >&5 <<_CSEOF
11937
11938 This file was extended by $as_me, which was
11939 generated by GNU Autoconf 2.59.  Invocation command line was
11940
11941   CONFIG_FILES    = $CONFIG_FILES
11942   CONFIG_HEADERS  = $CONFIG_HEADERS
11943   CONFIG_LINKS    = $CONFIG_LINKS
11944   CONFIG_COMMANDS = $CONFIG_COMMANDS
11945   $ $0 $@
11946
11947 _CSEOF
11948 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
11949 echo >&5
11950 _ACEOF
11951
11952 # Files that config.status was made for.
11953 if test -n "$ac_config_files"; then
11954   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
11955 fi
11956
11957 if test -n "$ac_config_headers"; then
11958   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
11959 fi
11960
11961 if test -n "$ac_config_links"; then
11962   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
11963 fi
11964
11965 if test -n "$ac_config_commands"; then
11966   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
11967 fi
11968
11969 cat >>$CONFIG_STATUS <<\_ACEOF
11970
11971 ac_cs_usage="\
11972 \`$as_me' instantiates files from templates according to the
11973 current configuration.
11974
11975 Usage: $0 [OPTIONS] [FILE]...
11976
11977   -h, --help       print this help, then exit
11978   -V, --version    print version number, then exit
11979   -q, --quiet      do not print progress messages
11980   -d, --debug      don't remove temporary files
11981       --recheck    update $as_me by reconfiguring in the same conditions
11982   --file=FILE[:TEMPLATE]
11983                    instantiate the configuration file FILE
11984
11985 Configuration files:
11986 $config_files
11987
11988 Report bugs to <bug-autoconf@gnu.org>."
11989 _ACEOF
11990
11991 cat >>$CONFIG_STATUS <<_ACEOF
11992 ac_cs_version="\\
11993 config.status
11994 configured by $0, generated by GNU Autoconf 2.59,
11995   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
11996
11997 Copyright (C) 2003 Free Software Foundation, Inc.
11998 This config.status script is free software; the Free Software Foundation
11999 gives unlimited permission to copy, distribute and modify it."
12000 srcdir=$srcdir
12001 INSTALL="$INSTALL"
12002 _ACEOF
12003
12004 cat >>$CONFIG_STATUS <<\_ACEOF
12005 # If no file are specified by the user, then we need to provide default
12006 # value.  By we need to know if files were specified by the user.
12007 ac_need_defaults=:
12008 while test $# != 0
12009 do
12010   case $1 in
12011   --*=*)
12012     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12013     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12014     ac_shift=:
12015     ;;
12016   -*)
12017     ac_option=$1
12018     ac_optarg=$2
12019     ac_shift=shift
12020     ;;
12021   *) # This is not an option, so the user has probably given explicit
12022      # arguments.
12023      ac_option=$1
12024      ac_need_defaults=false;;
12025   esac
12026
12027   case $ac_option in
12028   # Handling of the options.
12029 _ACEOF
12030 cat >>$CONFIG_STATUS <<\_ACEOF
12031   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12032     ac_cs_recheck=: ;;
12033   --version | --vers* | -V )
12034     echo "$ac_cs_version"; exit 0 ;;
12035   --he | --h)
12036     # Conflict between --help and --header
12037     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12038 Try \`$0 --help' for more information." >&5
12039 echo "$as_me: error: ambiguous option: $1
12040 Try \`$0 --help' for more information." >&2;}
12041    { (exit 1); exit 1; }; };;
12042   --help | --hel | -h )
12043     echo "$ac_cs_usage"; exit 0 ;;
12044   --debug | --d* | -d )
12045     debug=: ;;
12046   --file | --fil | --fi | --f )
12047     $ac_shift
12048     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12049     ac_need_defaults=false;;
12050   --header | --heade | --head | --hea )
12051     $ac_shift
12052     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12053     ac_need_defaults=false;;
12054   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12055   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12056     ac_cs_silent=: ;;
12057
12058   # This is an error.
12059   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12060 Try \`$0 --help' for more information." >&5
12061 echo "$as_me: error: unrecognized option: $1
12062 Try \`$0 --help' for more information." >&2;}
12063    { (exit 1); exit 1; }; } ;;
12064
12065   *) ac_config_targets="$ac_config_targets $1" ;;
12066
12067   esac
12068   shift
12069 done
12070
12071 ac_configure_extra_args=
12072
12073 if $ac_cs_silent; then
12074   exec 6>/dev/null
12075   ac_configure_extra_args="$ac_configure_extra_args --silent"
12076 fi
12077
12078 _ACEOF
12079 cat >>$CONFIG_STATUS <<_ACEOF
12080 if \$ac_cs_recheck; then
12081   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12082   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12083 fi
12084
12085 _ACEOF
12086
12087
12088
12089
12090
12091 cat >>$CONFIG_STATUS <<\_ACEOF
12092 for ac_config_target in $ac_config_targets
12093 do
12094   case "$ac_config_target" in
12095   # Handling of arguments.
12096   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12097   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12098 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12099    { (exit 1); exit 1; }; };;
12100   esac
12101 done
12102
12103 # If the user did not use the arguments to specify the items to instantiate,
12104 # then the envvar interface is used.  Set only those that are not.
12105 # We use the long form for the default assignment because of an extremely
12106 # bizarre bug on SunOS 4.1.3.
12107 if $ac_need_defaults; then
12108   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12109 fi
12110
12111 # Have a temporary directory for convenience.  Make it in the build tree
12112 # simply because there is no reason to put it here, and in addition,
12113 # creating and moving files from /tmp can sometimes cause problems.
12114 # Create a temporary directory, and hook for its removal unless debugging.
12115 $debug ||
12116 {
12117   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12118   trap '{ (exit 1); exit 1; }' 1 2 13 15
12119 }
12120
12121 # Create a (secure) tmp directory for tmp files.
12122
12123 {
12124   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12125   test -n "$tmp" && test -d "$tmp"
12126 }  ||
12127 {
12128   tmp=./confstat$$-$RANDOM
12129   (umask 077 && mkdir $tmp)
12130 } ||
12131 {
12132    echo "$me: cannot create a temporary directory in ." >&2
12133    { (exit 1); exit 1; }
12134 }
12135
12136 _ACEOF
12137
12138 cat >>$CONFIG_STATUS <<_ACEOF
12139
12140 #
12141 # CONFIG_FILES section.
12142 #
12143
12144 # No need to generate the scripts if there are no CONFIG_FILES.
12145 # This happens for instance when ./config.status config.h
12146 if test -n "\$CONFIG_FILES"; then
12147   # Protect against being on the right side of a sed subst in config.status.
12148   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12149    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12150 s,@SHELL@,$SHELL,;t t
12151 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12152 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12153 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12154 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12155 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12156 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12157 s,@exec_prefix@,$exec_prefix,;t t
12158 s,@prefix@,$prefix,;t t
12159 s,@program_transform_name@,$program_transform_name,;t t
12160 s,@bindir@,$bindir,;t t
12161 s,@sbindir@,$sbindir,;t t
12162 s,@libexecdir@,$libexecdir,;t t
12163 s,@datadir@,$datadir,;t t
12164 s,@sysconfdir@,$sysconfdir,;t t
12165 s,@sharedstatedir@,$sharedstatedir,;t t
12166 s,@localstatedir@,$localstatedir,;t t
12167 s,@libdir@,$libdir,;t t
12168 s,@includedir@,$includedir,;t t
12169 s,@oldincludedir@,$oldincludedir,;t t
12170 s,@infodir@,$infodir,;t t
12171 s,@mandir@,$mandir,;t t
12172 s,@build_alias@,$build_alias,;t t
12173 s,@host_alias@,$host_alias,;t t
12174 s,@target_alias@,$target_alias,;t t
12175 s,@DEFS@,$DEFS,;t t
12176 s,@ECHO_C@,$ECHO_C,;t t
12177 s,@ECHO_N@,$ECHO_N,;t t
12178 s,@ECHO_T@,$ECHO_T,;t t
12179 s,@LIBS@,$LIBS,;t t
12180 s,@build@,$build,;t t
12181 s,@build_cpu@,$build_cpu,;t t
12182 s,@build_vendor@,$build_vendor,;t t
12183 s,@build_os@,$build_os,;t t
12184 s,@build_noncanonical@,$build_noncanonical,;t t
12185 s,@host_noncanonical@,$host_noncanonical,;t t
12186 s,@target_noncanonical@,$target_noncanonical,;t t
12187 s,@host@,$host,;t t
12188 s,@host_cpu@,$host_cpu,;t t
12189 s,@host_vendor@,$host_vendor,;t t
12190 s,@host_os@,$host_os,;t t
12191 s,@target@,$target,;t t
12192 s,@target_cpu@,$target_cpu,;t t
12193 s,@target_vendor@,$target_vendor,;t t
12194 s,@target_os@,$target_os,;t t
12195 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12196 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12197 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12198 s,@LN@,$LN,;t t
12199 s,@LN_S@,$LN_S,;t t
12200 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12201 s,@build_libsubdir@,$build_libsubdir,;t t
12202 s,@build_subdir@,$build_subdir,;t t
12203 s,@host_subdir@,$host_subdir,;t t
12204 s,@target_subdir@,$target_subdir,;t t
12205 s,@CC@,$CC,;t t
12206 s,@CFLAGS@,$CFLAGS,;t t
12207 s,@LDFLAGS@,$LDFLAGS,;t t
12208 s,@CPPFLAGS@,$CPPFLAGS,;t t
12209 s,@ac_ct_CC@,$ac_ct_CC,;t t
12210 s,@EXEEXT@,$EXEEXT,;t t
12211 s,@OBJEXT@,$OBJEXT,;t t
12212 s,@CXX@,$CXX,;t t
12213 s,@CXXFLAGS@,$CXXFLAGS,;t t
12214 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12215 s,@GNATBIND@,$GNATBIND,;t t
12216 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12217 s,@GNATMAKE@,$GNATMAKE,;t t
12218 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12219 s,@do_compare@,$do_compare,;t t
12220 s,@gmplibs@,$gmplibs,;t t
12221 s,@gmpinc@,$gmpinc,;t t
12222 s,@stage1_languages@,$stage1_languages,;t t
12223 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12224 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12225 s,@tooldir@,$tooldir,;t t
12226 s,@build_tooldir@,$build_tooldir,;t t
12227 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12228 s,@GDB_TK@,$GDB_TK,;t t
12229 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12230 s,@build_configargs@,$build_configargs,;t t
12231 s,@build_configdirs@,$build_configdirs,;t t
12232 s,@host_configargs@,$host_configargs,;t t
12233 s,@configdirs@,$configdirs,;t t
12234 s,@target_configargs@,$target_configargs,;t t
12235 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12236 s,@config_shell@,$config_shell,;t t
12237 s,@YACC@,$YACC,;t t
12238 s,@BISON@,$BISON,;t t
12239 s,@M4@,$M4,;t t
12240 s,@LEX@,$LEX,;t t
12241 s,@FLEX@,$FLEX,;t t
12242 s,@MAKEINFO@,$MAKEINFO,;t t
12243 s,@EXPECT@,$EXPECT,;t t
12244 s,@RUNTEST@,$RUNTEST,;t t
12245 s,@AR@,$AR,;t t
12246 s,@AS@,$AS,;t t
12247 s,@DLLTOOL@,$DLLTOOL,;t t
12248 s,@LD@,$LD,;t t
12249 s,@LIPO@,$LIPO,;t t
12250 s,@NM@,$NM,;t t
12251 s,@RANLIB@,$RANLIB,;t t
12252 s,@STRIP@,$STRIP,;t t
12253 s,@WINDRES@,$WINDRES,;t t
12254 s,@OBJCOPY@,$OBJCOPY,;t t
12255 s,@OBJDUMP@,$OBJDUMP,;t t
12256 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12257 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12258 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12259 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12260 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12261 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12262 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12263 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12264 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12265 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12266 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12267 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12268 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12269 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12270 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12271 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12272 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12273 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12274 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12275 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12276 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12277 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12278 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12279 s,@MAINT@,$MAINT,;t t
12280 s,@stage1_cflags@,$stage1_cflags,;t t
12281 s,@stage1_checking@,$stage1_checking,;t t
12282 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12283 s,@datarootdir@,$datarootdir,;t t
12284 s,@docdir@,$docdir,;t t
12285 s,@htmldir@,$htmldir,;t t
12286 s,@LIBOBJS@,$LIBOBJS,;t t
12287 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12288 /@serialization_dependencies@/r $serialization_dependencies
12289 s,@serialization_dependencies@,,;t t
12290 /@host_makefile_frag@/r $host_makefile_frag
12291 s,@host_makefile_frag@,,;t t
12292 /@target_makefile_frag@/r $target_makefile_frag
12293 s,@target_makefile_frag@,,;t t
12294 /@alphaieee_frag@/r $alphaieee_frag
12295 s,@alphaieee_frag@,,;t t
12296 /@ospace_frag@/r $ospace_frag
12297 s,@ospace_frag@,,;t t
12298 CEOF
12299
12300 _ACEOF
12301
12302   cat >>$CONFIG_STATUS <<\_ACEOF
12303   # Split the substitutions into bite-sized pieces for seds with
12304   # small command number limits, like on Digital OSF/1 and HP-UX.
12305   ac_max_sed_lines=48
12306   ac_sed_frag=1 # Number of current file.
12307   ac_beg=1 # First line for current file.
12308   ac_end=$ac_max_sed_lines # Line after last line for current file.
12309   ac_more_lines=:
12310   ac_sed_cmds=
12311   while $ac_more_lines; do
12312     if test $ac_beg -gt 1; then
12313       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12314     else
12315       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12316     fi
12317     if test ! -s $tmp/subs.frag; then
12318       ac_more_lines=false
12319     else
12320       # The purpose of the label and of the branching condition is to
12321       # speed up the sed processing (if there are no `@' at all, there
12322       # is no need to browse any of the substitutions).
12323       # These are the two extra sed commands mentioned above.
12324       (echo ':t
12325   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
12326       if test -z "$ac_sed_cmds"; then
12327         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
12328       else
12329         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
12330       fi
12331       ac_sed_frag=`expr $ac_sed_frag + 1`
12332       ac_beg=$ac_end
12333       ac_end=`expr $ac_end + $ac_max_sed_lines`
12334     fi
12335   done
12336   if test -z "$ac_sed_cmds"; then
12337     ac_sed_cmds=cat
12338   fi
12339 fi # test -n "$CONFIG_FILES"
12340
12341 _ACEOF
12342 cat >>$CONFIG_STATUS <<\_ACEOF
12343 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
12344   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
12345   case $ac_file in
12346   - | *:- | *:-:* ) # input from stdin
12347         cat >$tmp/stdin
12348         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12349         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12350   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12351         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12352   * )   ac_file_in=$ac_file.in ;;
12353   esac
12354
12355   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
12356   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
12357 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12358          X"$ac_file" : 'X\(//\)[^/]' \| \
12359          X"$ac_file" : 'X\(//\)$' \| \
12360          X"$ac_file" : 'X\(/\)' \| \
12361          .     : '\(.\)' 2>/dev/null ||
12362 echo X"$ac_file" |
12363     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12364           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12365           /^X\(\/\/\)$/{ s//\1/; q; }
12366           /^X\(\/\).*/{ s//\1/; q; }
12367           s/.*/./; q'`
12368   { if $as_mkdir_p; then
12369     mkdir -p "$ac_dir"
12370   else
12371     as_dir="$ac_dir"
12372     as_dirs=
12373     while test ! -d "$as_dir"; do
12374       as_dirs="$as_dir $as_dirs"
12375       as_dir=`(dirname "$as_dir") 2>/dev/null ||
12376 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12377          X"$as_dir" : 'X\(//\)[^/]' \| \
12378          X"$as_dir" : 'X\(//\)$' \| \
12379          X"$as_dir" : 'X\(/\)' \| \
12380          .     : '\(.\)' 2>/dev/null ||
12381 echo X"$as_dir" |
12382     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12383           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12384           /^X\(\/\/\)$/{ s//\1/; q; }
12385           /^X\(\/\).*/{ s//\1/; q; }
12386           s/.*/./; q'`
12387     done
12388     test ! -n "$as_dirs" || mkdir $as_dirs
12389   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
12390 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
12391    { (exit 1); exit 1; }; }; }
12392
12393   ac_builddir=.
12394
12395 if test "$ac_dir" != .; then
12396   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
12397   # A "../" for each directory in $ac_dir_suffix.
12398   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
12399 else
12400   ac_dir_suffix= ac_top_builddir=
12401 fi
12402
12403 case $srcdir in
12404   .)  # No --srcdir option.  We are building in place.
12405     ac_srcdir=.
12406     if test -z "$ac_top_builddir"; then
12407        ac_top_srcdir=.
12408     else
12409        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
12410     fi ;;
12411   [\\/]* | ?:[\\/]* )  # Absolute path.
12412     ac_srcdir=$srcdir$ac_dir_suffix;
12413     ac_top_srcdir=$srcdir ;;
12414   *) # Relative path.
12415     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
12416     ac_top_srcdir=$ac_top_builddir$srcdir ;;
12417 esac
12418
12419 # Do not use `cd foo && pwd` to compute absolute paths, because
12420 # the directories may not exist.
12421 case `pwd` in
12422 .) ac_abs_builddir="$ac_dir";;
12423 *)
12424   case "$ac_dir" in
12425   .) ac_abs_builddir=`pwd`;;
12426   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
12427   *) ac_abs_builddir=`pwd`/"$ac_dir";;
12428   esac;;
12429 esac
12430 case $ac_abs_builddir in
12431 .) ac_abs_top_builddir=${ac_top_builddir}.;;
12432 *)
12433   case ${ac_top_builddir}. in
12434   .) ac_abs_top_builddir=$ac_abs_builddir;;
12435   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
12436   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
12437   esac;;
12438 esac
12439 case $ac_abs_builddir in
12440 .) ac_abs_srcdir=$ac_srcdir;;
12441 *)
12442   case $ac_srcdir in
12443   .) ac_abs_srcdir=$ac_abs_builddir;;
12444   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
12445   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
12446   esac;;
12447 esac
12448 case $ac_abs_builddir in
12449 .) ac_abs_top_srcdir=$ac_top_srcdir;;
12450 *)
12451   case $ac_top_srcdir in
12452   .) ac_abs_top_srcdir=$ac_abs_builddir;;
12453   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
12454   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
12455   esac;;
12456 esac
12457
12458
12459   case $INSTALL in
12460   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
12461   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
12462   esac
12463
12464   if test x"$ac_file" != x-; then
12465     { echo "$as_me:$LINENO: creating $ac_file" >&5
12466 echo "$as_me: creating $ac_file" >&6;}
12467     rm -f "$ac_file"
12468   fi
12469   # Let's still pretend it is `configure' which instantiates (i.e., don't
12470   # use $as_me), people would be surprised to read:
12471   #    /* config.h.  Generated by config.status.  */
12472   if test x"$ac_file" = x-; then
12473     configure_input=
12474   else
12475     configure_input="$ac_file.  "
12476   fi
12477   configure_input=$configure_input"Generated from `echo $ac_file_in |
12478                                      sed 's,.*/,,'` by configure."
12479
12480   # First look for the input files in the build tree, otherwise in the
12481   # src tree.
12482   ac_file_inputs=`IFS=:
12483     for f in $ac_file_in; do
12484       case $f in
12485       -) echo $tmp/stdin ;;
12486       [\\/$]*)
12487          # Absolute (can't be DOS-style, as IFS=:)
12488          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
12489 echo "$as_me: error: cannot find input file: $f" >&2;}
12490    { (exit 1); exit 1; }; }
12491          echo "$f";;
12492       *) # Relative
12493          if test -f "$f"; then
12494            # Build tree
12495            echo "$f"
12496          elif test -f "$srcdir/$f"; then
12497            # Source tree
12498            echo "$srcdir/$f"
12499          else
12500            # /dev/null tree
12501            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
12502 echo "$as_me: error: cannot find input file: $f" >&2;}
12503    { (exit 1); exit 1; }; }
12504          fi;;
12505       esac
12506     done` || { (exit 1); exit 1; }
12507 _ACEOF
12508 cat >>$CONFIG_STATUS <<_ACEOF
12509   sed "$ac_vpsub
12510 $extrasub
12511 _ACEOF
12512 cat >>$CONFIG_STATUS <<\_ACEOF
12513 :t
12514 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
12515 s,@configure_input@,$configure_input,;t t
12516 s,@srcdir@,$ac_srcdir,;t t
12517 s,@abs_srcdir@,$ac_abs_srcdir,;t t
12518 s,@top_srcdir@,$ac_top_srcdir,;t t
12519 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
12520 s,@builddir@,$ac_builddir,;t t
12521 s,@abs_builddir@,$ac_abs_builddir,;t t
12522 s,@top_builddir@,$ac_top_builddir,;t t
12523 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
12524 s,@INSTALL@,$ac_INSTALL,;t t
12525 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
12526   rm -f $tmp/stdin
12527   if test x"$ac_file" != x-; then
12528     mv $tmp/out $ac_file
12529   else
12530     cat $tmp/out
12531     rm -f $tmp/out
12532   fi
12533
12534 done
12535 _ACEOF
12536
12537 cat >>$CONFIG_STATUS <<\_ACEOF
12538
12539 { (exit 0); exit 0; }
12540 _ACEOF
12541 chmod +x $CONFIG_STATUS
12542 ac_clean_files=$ac_clean_files_save
12543
12544
12545 # configure is writing to config.log, and then calls config.status.
12546 # config.status does its own redirection, appending to config.log.
12547 # Unfortunately, on DOS this fails, as config.log is still kept open
12548 # by configure, so config.status won't be able to write to it; its
12549 # output is simply discarded.  So we exec the FD to /dev/null,
12550 # effectively closing config.log, so it can be properly (re)opened and
12551 # appended to by config.status.  When coming back to configure, we
12552 # need to make the FD available again.
12553 if test "$no_create" != yes; then
12554   ac_cs_success=:
12555   ac_config_status_args=
12556   test "$silent" = yes &&
12557     ac_config_status_args="$ac_config_status_args --quiet"
12558   exec 5>/dev/null
12559   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
12560   exec 5>>config.log
12561   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
12562   # would make configure fail if this is the last instruction.
12563   $ac_cs_success || { (exit 1); exit 1; }
12564 fi
12565