configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS TOPLEVEL_CONFIGURE_ARGUMENTS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc ppllibs pplinc clooglibs clooginc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET RPATH_ENVVAR GCC_SHLIB_SUBDIR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277 ac_pwd=`pwd`
 278
 279 # Initialize some variables set by options.
 280 ac_init_help=
 281 ac_init_version=false
 282 # The variables have the same names as the options, with
 283 # dashes changed to underlines.
 284 cache_file=/dev/null
 285 exec_prefix=NONE
 286 no_create=
 287 no_recursion=
 288 prefix=NONE
 289 program_prefix=NONE
 290 program_suffix=NONE
 291 program_transform_name=s,x,x,
 292 silent=
 293 site=
 294 srcdir=
 295 verbose=
 296 x_includes=NONE
 297 x_libraries=NONE
 298
 299 # Installation directory options.
 300 # These are left unexpanded so users can "make install exec_prefix=/foo"
 301 # and all the variables that are supposed to be based on exec_prefix
 302 # by default will actually change.
 303 # Use braces instead of parens because sh, perl, etc. also accept them.
 304 bindir='${exec_prefix}/bin'
 305 sbindir='${exec_prefix}/sbin'
 306 libexecdir='${exec_prefix}/libexec'
 307 datadir='${prefix}/share'
 308 sysconfdir='${prefix}/etc'
 309 sharedstatedir='${prefix}/com'
 310 localstatedir='${prefix}/var'
 311 libdir='${exec_prefix}/lib'
 312 includedir='${prefix}/include'
 313 oldincludedir='/usr/include'
 314 infodir='${prefix}/info'
 315 mandir='${prefix}/man'
 316
 317 ac_prev=
 318 for ac_option
 319 do
 320   # If the previous option needs an argument, assign it.
 321   if test -n "$ac_prev"; then
 322     eval "$ac_prev=\$ac_option"
 323     ac_prev=
 324     continue
 325   fi
 326
 327   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 328
 329   # Accept the important Cygnus configure options, so we can diagnose typos.
 330
 331   case $ac_option in
 332
 333   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 334     ac_prev=bindir ;;
 335   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 336     bindir=$ac_optarg ;;
 337
 338   -build | --build | --buil | --bui | --bu)
 339     ac_prev=build_alias ;;
 340   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 341     build_alias=$ac_optarg ;;
 342
 343   -cache-file | --cache-file | --cache-fil | --cache-fi \
 344   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 345     ac_prev=cache_file ;;
 346   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 347   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 348     cache_file=$ac_optarg ;;
 349
 350   --config-cache | -C)
 351     cache_file=config.cache ;;
 352
 353   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 354     ac_prev=datadir ;;
 355   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 356   | --da=*)
 357     datadir=$ac_optarg ;;
 358
 359   -disable-* | --disable-*)
 360     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 361     # Reject names that are not valid shell variable names.
 362     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 363       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 364    { (exit 1); exit 1; }; }
 365     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 366     eval "enable_$ac_feature=no" ;;
 367
 368   -enable-* | --enable-*)
 369     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 370     # Reject names that are not valid shell variable names.
 371     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 372       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 373    { (exit 1); exit 1; }; }
 374     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 375     case $ac_option in
 376       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 377       *) ac_optarg=yes ;;
 378     esac
 379     eval "enable_$ac_feature='$ac_optarg'" ;;
 380
 381   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 382   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 383   | --exec | --exe | --ex)
 384     ac_prev=exec_prefix ;;
 385   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 386   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 387   | --exec=* | --exe=* | --ex=*)
 388     exec_prefix=$ac_optarg ;;
 389
 390   -gas | --gas | --ga | --g)
 391     # Obsolete; use --with-gas.
 392     with_gas=yes ;;
 393
 394   -help | --help | --hel | --he | -h)
 395     ac_init_help=long ;;
 396   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 397     ac_init_help=recursive ;;
 398   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 399     ac_init_help=short ;;
 400
 401   -host | --host | --hos | --ho)
 402     ac_prev=host_alias ;;
 403   -host=* | --host=* | --hos=* | --ho=*)
 404     host_alias=$ac_optarg ;;
 405
 406   -includedir | --includedir | --includedi | --included | --include \
 407   | --includ | --inclu | --incl | --inc)
 408     ac_prev=includedir ;;
 409   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 410   | --includ=* | --inclu=* | --incl=* | --inc=*)
 411     includedir=$ac_optarg ;;
 412
 413   -infodir | --infodir | --infodi | --infod | --info | --inf)
 414     ac_prev=infodir ;;
 415   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 416     infodir=$ac_optarg ;;
 417
 418   -libdir | --libdir | --libdi | --libd)
 419     ac_prev=libdir ;;
 420   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 421     libdir=$ac_optarg ;;
 422
 423   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 424   | --libexe | --libex | --libe)
 425     ac_prev=libexecdir ;;
 426   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 427   | --libexe=* | --libex=* | --libe=*)
 428     libexecdir=$ac_optarg ;;
 429
 430   -localstatedir | --localstatedir | --localstatedi | --localstated \
 431   | --localstate | --localstat | --localsta | --localst \
 432   | --locals | --local | --loca | --loc | --lo)
 433     ac_prev=localstatedir ;;
 434   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 435   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 436   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 437     localstatedir=$ac_optarg ;;
 438
 439   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 440     ac_prev=mandir ;;
 441   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 442     mandir=$ac_optarg ;;
 443
 444   -nfp | --nfp | --nf)
 445     # Obsolete; use --without-fp.
 446     with_fp=no ;;
 447
 448   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 449   | --no-cr | --no-c | -n)
 450     no_create=yes ;;
 451
 452   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 453   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 454     no_recursion=yes ;;
 455
 456   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 457   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 458   | --oldin | --oldi | --old | --ol | --o)
 459     ac_prev=oldincludedir ;;
 460   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 461   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 462   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 463     oldincludedir=$ac_optarg ;;
 464
 465   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 466     ac_prev=prefix ;;
 467   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 468     prefix=$ac_optarg ;;
 469
 470   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 471   | --program-pre | --program-pr | --program-p)
 472     ac_prev=program_prefix ;;
 473   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 474   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 475     program_prefix=$ac_optarg ;;
 476
 477   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 478   | --program-suf | --program-su | --program-s)
 479     ac_prev=program_suffix ;;
 480   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 481   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 482     program_suffix=$ac_optarg ;;
 483
 484   -program-transform-name | --program-transform-name \
 485   | --program-transform-nam | --program-transform-na \
 486   | --program-transform-n | --program-transform- \
 487   | --program-transform | --program-transfor \
 488   | --program-transfo | --program-transf \
 489   | --program-trans | --program-tran \
 490   | --progr-tra | --program-tr | --program-t)
 491     ac_prev=program_transform_name ;;
 492   -program-transform-name=* | --program-transform-name=* \
 493   | --program-transform-nam=* | --program-transform-na=* \
 494   | --program-transform-n=* | --program-transform-=* \
 495   | --program-transform=* | --program-transfor=* \
 496   | --program-transfo=* | --program-transf=* \
 497   | --program-trans=* | --program-tran=* \
 498   | --progr-tra=* | --program-tr=* | --program-t=*)
 499     program_transform_name=$ac_optarg ;;
 500
 501   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 502   | -silent | --silent | --silen | --sile | --sil)
 503     silent=yes ;;
 504
 505   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 506     ac_prev=sbindir ;;
 507   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 508   | --sbi=* | --sb=*)
 509     sbindir=$ac_optarg ;;
 510
 511   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 512   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 513   | --sharedst | --shareds | --shared | --share | --shar \
 514   | --sha | --sh)
 515     ac_prev=sharedstatedir ;;
 516   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 517   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 518   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 519   | --sha=* | --sh=*)
 520     sharedstatedir=$ac_optarg ;;
 521
 522   -site | --site | --sit)
 523     ac_prev=site ;;
 524   -site=* | --site=* | --sit=*)
 525     site=$ac_optarg ;;
 526
 527   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 528     ac_prev=srcdir ;;
 529   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 530     srcdir=$ac_optarg ;;
 531
 532   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 533   | --syscon | --sysco | --sysc | --sys | --sy)
 534     ac_prev=sysconfdir ;;
 535   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 536   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 537     sysconfdir=$ac_optarg ;;
 538
 539   -target | --target | --targe | --targ | --tar | --ta | --t)
 540     ac_prev=target_alias ;;
 541   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 542     target_alias=$ac_optarg ;;
 543
 544   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 545     verbose=yes ;;
 546
 547   -version | --version | --versio | --versi | --vers | -V)
 548     ac_init_version=: ;;
 549
 550   -with-* | --with-*)
 551     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 552     # Reject names that are not valid shell variable names.
 553     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 554       { echo "$as_me: error: invalid package name: $ac_package" >&2
 555    { (exit 1); exit 1; }; }
 556     ac_package=`echo $ac_package| sed 's/-/_/g'`
 557     case $ac_option in
 558       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 559       *) ac_optarg=yes ;;
 560     esac
 561     eval "with_$ac_package='$ac_optarg'" ;;
 562
 563   -without-* | --without-*)
 564     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 565     # Reject names that are not valid shell variable names.
 566     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 567       { echo "$as_me: error: invalid package name: $ac_package" >&2
 568    { (exit 1); exit 1; }; }
 569     ac_package=`echo $ac_package | sed 's/-/_/g'`
 570     eval "with_$ac_package=no" ;;
 571
 572   --x)
 573     # Obsolete; use --with-x.
 574     with_x=yes ;;
 575
 576   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 577   | --x-incl | --x-inc | --x-in | --x-i)
 578     ac_prev=x_includes ;;
 579   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 580   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 581     x_includes=$ac_optarg ;;
 582
 583   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 584   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 585     ac_prev=x_libraries ;;
 586   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 587   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 588     x_libraries=$ac_optarg ;;
 589
 590   -*) { echo "$as_me: error: unrecognized option: $ac_option
 591 Try \`$0 --help' for more information." >&2
 592    { (exit 1); exit 1; }; }
 593     ;;
 594
 595   *=*)
 596     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 597     # Reject names that are not valid shell variable names.
 598     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 599       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 600    { (exit 1); exit 1; }; }
 601     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 602     eval "$ac_envvar='$ac_optarg'"
 603     export $ac_envvar ;;
 604
 605   *)
 606     # FIXME: should be removed in autoconf 3.0.
 607     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 608     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 609       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 610     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 611     ;;
 612
 613   esac
 614 done
 615
 616 if test -n "$ac_prev"; then
 617   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 618   { echo "$as_me: error: missing argument to $ac_option" >&2
 619    { (exit 1); exit 1; }; }
 620 fi
 621
 622 # Be sure to have absolute paths.
 623 for ac_var in exec_prefix prefix
 624 do
 625   eval ac_val=$`echo $ac_var`
 626   case $ac_val in
 627     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 628     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 629    { (exit 1); exit 1; }; };;
 630   esac
 631 done
 632
 633 # Be sure to have absolute paths.
 634 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 635               localstatedir libdir includedir oldincludedir infodir mandir
 636 do
 637   eval ac_val=$`echo $ac_var`
 638   case $ac_val in
 639     [\\/$]* | ?:[\\/]* ) ;;
 640     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 641    { (exit 1); exit 1; }; };;
 642   esac
 643 done
 644
 645 # There might be people who depend on the old broken behavior: `$host'
 646 # used to hold the argument of --host etc.
 647 # FIXME: To remove some day.
 648 build=$build_alias
 649 host=$host_alias
 650 target=$target_alias
 651
 652 # FIXME: To remove some day.
 653 if test "x$host_alias" != x; then
 654   if test "x$build_alias" = x; then
 655     cross_compiling=maybe
 656     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 657     If a cross compiler is detected then cross compile mode will be used." >&2
 658   elif test "x$build_alias" != "x$host_alias"; then
 659     cross_compiling=yes
 660   fi
 661 fi
 662
 663 ac_tool_prefix=
 664 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 665
 666 test "$silent" = yes && exec 6>/dev/null
 667
 668
 669 # Find the source files, if location was not specified.
 670 if test -z "$srcdir"; then
 671   ac_srcdir_defaulted=yes
 672   # Try the directory containing this script, then its parent.
 673   ac_confdir=`(dirname "$0") 2>/dev/null ||
 674 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 675          X"$0" : 'X\(//\)[^/]' \| \
 676          X"$0" : 'X\(//\)$' \| \
 677          X"$0" : 'X\(/\)' \| \
 678          .     : '\(.\)' 2>/dev/null ||
 679 echo X"$0" |
 680     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 681           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 682           /^X\(\/\/\)$/{ s//\1/; q; }
 683           /^X\(\/\).*/{ s//\1/; q; }
 684           s/.*/./; q'`
 685   srcdir=$ac_confdir
 686   if test ! -r $srcdir/$ac_unique_file; then
 687     srcdir=..
 688   fi
 689 else
 690   ac_srcdir_defaulted=no
 691 fi
 692 if test ! -r $srcdir/$ac_unique_file; then
 693   if test "$ac_srcdir_defaulted" = yes; then
 694     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 695    { (exit 1); exit 1; }; }
 696   else
 697     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 698    { (exit 1); exit 1; }; }
 699   fi
 700 fi
 701 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 702   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 703    { (exit 1); exit 1; }; }
 704 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 705 ac_env_build_alias_set=${build_alias+set}
 706 ac_env_build_alias_value=$build_alias
 707 ac_cv_env_build_alias_set=${build_alias+set}
 708 ac_cv_env_build_alias_value=$build_alias
 709 ac_env_host_alias_set=${host_alias+set}
 710 ac_env_host_alias_value=$host_alias
 711 ac_cv_env_host_alias_set=${host_alias+set}
 712 ac_cv_env_host_alias_value=$host_alias
 713 ac_env_target_alias_set=${target_alias+set}
 714 ac_env_target_alias_value=$target_alias
 715 ac_cv_env_target_alias_set=${target_alias+set}
 716 ac_cv_env_target_alias_value=$target_alias
 717 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 718
 719 ac_env_CC_set=${CC+set}
 720 ac_env_CC_value=$CC
 721 ac_cv_env_CC_set=${CC+set}
 722 ac_cv_env_CC_value=$CC
 723 ac_env_CFLAGS_set=${CFLAGS+set}
 724 ac_env_CFLAGS_value=$CFLAGS
 725 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 726 ac_cv_env_CFLAGS_value=$CFLAGS
 727 ac_env_LDFLAGS_set=${LDFLAGS+set}
 728 ac_env_LDFLAGS_value=$LDFLAGS
 729 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 730 ac_cv_env_LDFLAGS_value=$LDFLAGS
 731 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 732 ac_env_CPPFLAGS_value=$CPPFLAGS
 733 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 734 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 735 ac_env_CXX_set=${CXX+set}
 736 ac_env_CXX_value=$CXX
 737 ac_cv_env_CXX_set=${CXX+set}
 738 ac_cv_env_CXX_value=$CXX
 739 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 740 ac_env_CXXFLAGS_value=$CXXFLAGS
 741 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 742 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 743 ac_env_AR_set=${AR+set}
 744 ac_env_AR_value=$AR
 745 ac_cv_env_AR_set=${AR+set}
 746 ac_cv_env_AR_value=$AR
 747 ac_env_AS_set=${AS+set}
 748 ac_env_AS_value=$AS
 749 ac_cv_env_AS_set=${AS+set}
 750 ac_cv_env_AS_value=$AS
 751 ac_env_DLLTOOL_set=${DLLTOOL+set}
 752 ac_env_DLLTOOL_value=$DLLTOOL
 753 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 754 ac_cv_env_DLLTOOL_value=$DLLTOOL
 755 ac_env_LD_set=${LD+set}
 756 ac_env_LD_value=$LD
 757 ac_cv_env_LD_set=${LD+set}
 758 ac_cv_env_LD_value=$LD
 759 ac_env_LIPO_set=${LIPO+set}
 760 ac_env_LIPO_value=$LIPO
 761 ac_cv_env_LIPO_set=${LIPO+set}
 762 ac_cv_env_LIPO_value=$LIPO
 763 ac_env_NM_set=${NM+set}
 764 ac_env_NM_value=$NM
 765 ac_cv_env_NM_set=${NM+set}
 766 ac_cv_env_NM_value=$NM
 767 ac_env_RANLIB_set=${RANLIB+set}
 768 ac_env_RANLIB_value=$RANLIB
 769 ac_cv_env_RANLIB_set=${RANLIB+set}
 770 ac_cv_env_RANLIB_value=$RANLIB
 771 ac_env_STRIP_set=${STRIP+set}
 772 ac_env_STRIP_value=$STRIP
 773 ac_cv_env_STRIP_set=${STRIP+set}
 774 ac_cv_env_STRIP_value=$STRIP
 775 ac_env_WINDRES_set=${WINDRES+set}
 776 ac_env_WINDRES_value=$WINDRES
 777 ac_cv_env_WINDRES_set=${WINDRES+set}
 778 ac_cv_env_WINDRES_value=$WINDRES
 779 ac_env_WINDMC_set=${WINDMC+set}
 780 ac_env_WINDMC_value=$WINDMC
 781 ac_cv_env_WINDMC_set=${WINDMC+set}
 782 ac_cv_env_WINDMC_value=$WINDMC
 783 ac_env_OBJCOPY_set=${OBJCOPY+set}
 784 ac_env_OBJCOPY_value=$OBJCOPY
 785 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 786 ac_cv_env_OBJCOPY_value=$OBJCOPY
 787 ac_env_OBJDUMP_set=${OBJDUMP+set}
 788 ac_env_OBJDUMP_value=$OBJDUMP
 789 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 790 ac_cv_env_OBJDUMP_value=$OBJDUMP
 791 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 792 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 793 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 794 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 795 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 796 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 797 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 798 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 799 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 800 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 801 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 802 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 803 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 804 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 805 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 806 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 807 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 808 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 809 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 810 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 811 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 812 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 813 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 814 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 815 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 816 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 817 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 818 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 819 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 820 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 821 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 822 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 823 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 824 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 825 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 826 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 827 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 828 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 829 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 830 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 831 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 832 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 833 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 834 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 835 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 836 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 837 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 838 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 839 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 840 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 841 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 842 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 843 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 844 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 845 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 846 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 847 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 848 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 849 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 850 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 851 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 852 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 853 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 854 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 855
 856 #
 857 # Report the --help message.
 858 #
 859 if test "$ac_init_help" = "long"; then
 860   # Omit some internal or obsolete options to make the list less imposing.
 861   # This message is too long to be a string in the A/UX 3.1 sh.
 862   cat <<_ACEOF
 863 \`configure' configures this package to adapt to many kinds of systems.
 864
 865 Usage: $0 [OPTION]... [VAR=VALUE]...
 866
 867 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 868 VAR=VALUE.  See below for descriptions of some of the useful variables.
 869
 870 Defaults for the options are specified in brackets.
 871
 872 Configuration:
 873   -h, --help              display this help and exit
 874       --help=short        display options specific to this package
 875       --help=recursive    display the short help of all the included packages
 876   -V, --version           display version information and exit
 877   -q, --quiet, --silent   do not print \`checking...' messages
 878       --cache-file=FILE   cache test results in FILE [disabled]
 879   -C, --config-cache      alias for \`--cache-file=config.cache'
 880   -n, --no-create         do not create output files
 881       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 882
 883 _ACEOF
 884
 885   cat <<_ACEOF
 886 Installation directories:
 887   --prefix=PREFIX         install architecture-independent files in PREFIX
 888                           [$ac_default_prefix]
 889   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 890                           [PREFIX]
 891
 892 By default, \`make install' will install all the files in
 893 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 894 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 895 for instance \`--prefix=\$HOME'.
 896
 897 For better control, use the options below.
 898
 899 Fine tuning of the installation directories:
 900   --bindir=DIR           user executables [EPREFIX/bin]
 901   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 902   --libexecdir=DIR       program executables [EPREFIX/libexec]
 903   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 904   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 905   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 906   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 907   --libdir=DIR           object code libraries [EPREFIX/lib]
 908   --includedir=DIR       C header files [PREFIX/include]
 909   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 910   --infodir=DIR          info documentation [PREFIX/info]
 911   --mandir=DIR           man documentation [PREFIX/man]
 912 _ACEOF
 913
 914   cat <<\_ACEOF
 915
 916 Program names:
 917   --program-prefix=PREFIX            prepend PREFIX to installed program names
 918   --program-suffix=SUFFIX            append SUFFIX to installed program names
 919   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 920
 921 System types:
 922   --build=BUILD     configure for building on BUILD [guessed]
 923   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 924   --target=TARGET   configure for building compilers for TARGET [HOST]
 925 _ACEOF
 926 fi
 927
 928 if test -n "$ac_init_help"; then
 929
 930   cat <<\_ACEOF
 931
 932 Optional Features:
 933   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 934   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 935   --enable-gold           use gold instead of ld
 936   --enable-libada         build libada directory
 937   --enable-libssp         build libssp directory
 938   --disable-ppl-version-check    disable check for PPL version
 939   --disable-cloog-version-check  disable check for CLooG version
 940   --enable-stage1-languages[=all]   choose additional languages to build during
 941                           stage1.  Mostly useful for compiler development.
 942   --enable-objc-gc        enable use of Boehm's garbage collector with the
 943                           GNU Objective-C runtime
 944   --enable-bootstrap      enable bootstrapping [yes if native build]
 945   --enable-serial-[{host,target,build}-]configure
 946                           force sequential configuration of
 947                           sub-packages for the host, target or build
 948                           machine, or all sub-packages
 949   --enable-maintainer-mode enable make rules and dependencies not useful
 950                           (and sometimes confusing) to the casual installer
 951   --enable-stage1-checking[=all]   choose additional checking for stage1
 952                           of the compiler
 953   --enable-werror         enable -Werror in bootstrap stage2 and later
 954
 955 Optional Packages:
 956   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 957   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 958   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 959   --with-mpfr-dir=PATH    this option has been REMOVED
 960   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 961                           Equivalent to --with-mpfr-include=PATH/include
 962                           plus --with-mpfr-lib=PATH/lib
 963   --with-mpfr-include=PATH
 964                           specify directory for installed MPFR include files
 965   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 966   --with-gmp-dir=PATH     this option has been REMOVED
 967   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 968                           Equivalent to --with-gmp-include=PATH/include
 969                           plus --with-gmp-lib=PATH/lib
 970   --with-gmp-include=PATH specify directory for installed GMP include files
 971   --with-gmp-lib=PATH     specify directory for the installed GMP library
 972   --with-host-libstdcxx=L Use linker arguments L to link with libstdc++
 973                           when linking with PPL
 974   --with-ppl=PATH         Specify prefix directory for the installed PPL package
 975                           Equivalent to --with-ppl-include=PATH/include
 976                           plus --with-ppl-lib=PATH/lib
 977   --with-ppl-include=PATH Specify directory for installed PPL include files
 978   --with-ppl-lib=PATH     Specify the directory for the installed PPL library
 979   --with-cloog=PATH       Specify prefix directory for the installed CLooG-PPL package
 980                           Equivalent to --with-cloog-include=PATH/include
 981                           plus --with-cloog-lib=PATH/lib
 982   --with-cloog-include=PATH Specify directory for installed CLooG include files
 983   --with-cloog-lib=PATH   Specify the directory for the installed CLooG library
 984   --with-build-sysroot=SYSROOT
 985                           use sysroot as the system root during the build
 986   --with-debug-prefix-map='A=B C=D ...'
 987                              map A to B, C to D ... in debug information
 988   --with-build-time-tools=PATH
 989                           use given path to find target tools during the build
 990   --with-datarootdir      use datarootdir as the data root directory.
 991   --with-docdir           install documentation in this directory.
 992   --with-pdfdir           install pdf in this directory.
 993   --with-htmldir          install html in this directory.
 994
 995 Some influential environment variables:
 996   CC          C compiler command
 997   CFLAGS      C compiler flags
 998   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 999               nonstandard directory <lib dir>
1000   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
1001               headers in a nonstandard directory <include dir>
1002   CXX         C++ compiler command
1003   CXXFLAGS    C++ compiler flags
1004   AR          AR for the host
1005   AS          AS for the host
1006   DLLTOOL     DLLTOOL for the host
1007   LD          LD for the host
1008   LIPO        LIPO for the host
1009   NM          NM for the host
1010   RANLIB      RANLIB for the host
1011   STRIP       STRIP for the host
1012   WINDRES     WINDRES for the host
1013   WINDMC      WINDMC for the host
1014   OBJCOPY     OBJCOPY for the host
1015   OBJDUMP     OBJDUMP for the host
1016   CC_FOR_TARGET
1017               CC for the target
1018   CXX_FOR_TARGET
1019               CXX for the target
1020   GCC_FOR_TARGET
1021               GCC for the target
1022   GCJ_FOR_TARGET
1023               GCJ for the target
1024   GFORTRAN_FOR_TARGET
1025               GFORTRAN for the target
1026   AR_FOR_TARGET
1027               AR for the target
1028   AS_FOR_TARGET
1029               AS for the target
1030   DLLTOOL_FOR_TARGET
1031               DLLTOOL for the target
1032   LD_FOR_TARGET
1033               LD for the target
1034   LIPO_FOR_TARGET
1035               LIPO for the target
1036   NM_FOR_TARGET
1037               NM for the target
1038   OBJDUMP_FOR_TARGET
1039               OBJDUMP for the target
1040   RANLIB_FOR_TARGET
1041               RANLIB for the target
1042   STRIP_FOR_TARGET
1043               STRIP for the target
1044   WINDRES_FOR_TARGET
1045               WINDRES for the target
1046   WINDMC_FOR_TARGET
1047               WINDMC for the target
1048
1049 Use these variables to override the choices made by `configure' or to help
1050 it to find libraries and programs with nonstandard names/locations.
1051
1052 _ACEOF
1053 fi
1054
1055 if test "$ac_init_help" = "recursive"; then
1056   # If there are subdirs, report their specific --help.
1057   ac_popdir=`pwd`
1058   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1059     test -d $ac_dir || continue
1060     ac_builddir=.
1061
1062 if test "$ac_dir" != .; then
1063   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1064   # A "../" for each directory in $ac_dir_suffix.
1065   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1066 else
1067   ac_dir_suffix= ac_top_builddir=
1068 fi
1069
1070 case $srcdir in
1071   .)  # No --srcdir option.  We are building in place.
1072     ac_srcdir=.
1073     if test -z "$ac_top_builddir"; then
1074        ac_top_srcdir=.
1075     else
1076        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1077     fi ;;
1078   [\\/]* | ?:[\\/]* )  # Absolute path.
1079     ac_srcdir=$srcdir$ac_dir_suffix;
1080     ac_top_srcdir=$srcdir ;;
1081   *) # Relative path.
1082     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1083     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1084 esac
1085
1086 # Do not use `cd foo && pwd` to compute absolute paths, because
1087 # the directories may not exist.
1088 case `pwd` in
1089 .) ac_abs_builddir="$ac_dir";;
1090 *)
1091   case "$ac_dir" in
1092   .) ac_abs_builddir=`pwd`;;
1093   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1094   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1095   esac;;
1096 esac
1097 case $ac_abs_builddir in
1098 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1099 *)
1100   case ${ac_top_builddir}. in
1101   .) ac_abs_top_builddir=$ac_abs_builddir;;
1102   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1103   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1104   esac;;
1105 esac
1106 case $ac_abs_builddir in
1107 .) ac_abs_srcdir=$ac_srcdir;;
1108 *)
1109   case $ac_srcdir in
1110   .) ac_abs_srcdir=$ac_abs_builddir;;
1111   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1112   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1113   esac;;
1114 esac
1115 case $ac_abs_builddir in
1116 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1117 *)
1118   case $ac_top_srcdir in
1119   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1120   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1121   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1122   esac;;
1123 esac
1124
1125     cd $ac_dir
1126     # Check for guested configure; otherwise get Cygnus style configure.
1127     if test -f $ac_srcdir/configure.gnu; then
1128       echo
1129       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1130     elif test -f $ac_srcdir/configure; then
1131       echo
1132       $SHELL $ac_srcdir/configure  --help=recursive
1133     elif test -f $ac_srcdir/configure.ac ||
1134            test -f $ac_srcdir/configure.in; then
1135       echo
1136       $ac_configure --help
1137     else
1138       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1139     fi
1140     cd $ac_popdir
1141   done
1142 fi
1143
1144 test -n "$ac_init_help" && exit 0
1145 if $ac_init_version; then
1146   cat <<\_ACEOF
1147
1148 Copyright (C) 2003 Free Software Foundation, Inc.
1149 This configure script is free software; the Free Software Foundation
1150 gives unlimited permission to copy, distribute and modify it.
1151 _ACEOF
1152   exit 0
1153 fi
1154 exec 5>config.log
1155 cat >&5 <<_ACEOF
1156 This file contains any messages produced by compilers while
1157 running configure, to aid debugging if configure makes a mistake.
1158
1159 It was created by $as_me, which was
1160 generated by GNU Autoconf 2.59.  Invocation command line was
1161
1162   $ $0 $@
1163
1164 _ACEOF
1165 {
1166 cat <<_ASUNAME
1167 ## --------- ##
1168 ## Platform. ##
1169 ## --------- ##
1170
1171 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1172 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1173 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1174 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1175 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1176
1177 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1178 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1179
1180 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1181 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1182 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1183 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1184 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1185 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1186 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1187
1188 _ASUNAME
1189
1190 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1191 for as_dir in $PATH
1192 do
1193   IFS=$as_save_IFS
1194   test -z "$as_dir" && as_dir=.
1195   echo "PATH: $as_dir"
1196 done
1197
1198 } >&5
1199
1200 cat >&5 <<_ACEOF
1201
1202
1203 ## ----------- ##
1204 ## Core tests. ##
1205 ## ----------- ##
1206
1207 _ACEOF
1208
1209
1210 # Keep a trace of the command line.
1211 # Strip out --no-create and --no-recursion so they do not pile up.
1212 # Strip out --silent because we don't want to record it for future runs.
1213 # Also quote any args containing shell meta-characters.
1214 # Make two passes to allow for proper duplicate-argument suppression.
1215 ac_configure_args=
1216 ac_configure_args0=
1217 ac_configure_args1=
1218 ac_sep=
1219 ac_must_keep_next=false
1220 for ac_pass in 1 2
1221 do
1222   for ac_arg
1223   do
1224     case $ac_arg in
1225     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1226     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1227     | -silent | --silent | --silen | --sile | --sil)
1228       continue ;;
1229     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1230       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1231     esac
1232     case $ac_pass in
1233     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1234     2)
1235       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1236       if test $ac_must_keep_next = true; then
1237         ac_must_keep_next=false # Got value, back to normal.
1238       else
1239         case $ac_arg in
1240           *=* | --config-cache | -C | -disable-* | --disable-* \
1241           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1242           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1243           | -with-* | --with-* | -without-* | --without-* | --x)
1244             case "$ac_configure_args0 " in
1245               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1246             esac
1247             ;;
1248           -* ) ac_must_keep_next=true ;;
1249         esac
1250       fi
1251       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1252       # Get rid of the leading space.
1253       ac_sep=" "
1254       ;;
1255     esac
1256   done
1257 done
1258 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1259 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1260
1261 # When interrupted or exit'd, cleanup temporary files, and complete
1262 # config.log.  We remove comments because anyway the quotes in there
1263 # would cause problems or look ugly.
1264 # WARNING: Be sure not to use single quotes in there, as some shells,
1265 # such as our DU 5.0 friend, will then `close' the trap.
1266 trap 'exit_status=$?
1267   # Save into config.log some information that might help in debugging.
1268   {
1269     echo
1270
1271     cat <<\_ASBOX
1272 ## ---------------- ##
1273 ## Cache variables. ##
1274 ## ---------------- ##
1275 _ASBOX
1276     echo
1277     # The following way of writing the cache mishandles newlines in values,
1278 {
1279   (set) 2>&1 |
1280     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1281     *ac_space=\ *)
1282       sed -n \
1283         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1284           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1285       ;;
1286     *)
1287       sed -n \
1288         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1289       ;;
1290     esac;
1291 }
1292     echo
1293
1294     cat <<\_ASBOX
1295 ## ----------------- ##
1296 ## Output variables. ##
1297 ## ----------------- ##
1298 _ASBOX
1299     echo
1300     for ac_var in $ac_subst_vars
1301     do
1302       eval ac_val=$`echo $ac_var`
1303       echo "$ac_var='"'"'$ac_val'"'"'"
1304     done | sort
1305     echo
1306
1307     if test -n "$ac_subst_files"; then
1308       cat <<\_ASBOX
1309 ## ------------- ##
1310 ## Output files. ##
1311 ## ------------- ##
1312 _ASBOX
1313       echo
1314       for ac_var in $ac_subst_files
1315       do
1316         eval ac_val=$`echo $ac_var`
1317         echo "$ac_var='"'"'$ac_val'"'"'"
1318       done | sort
1319       echo
1320     fi
1321
1322     if test -s confdefs.h; then
1323       cat <<\_ASBOX
1324 ## ----------- ##
1325 ## confdefs.h. ##
1326 ## ----------- ##
1327 _ASBOX
1328       echo
1329       sed "/^$/d" confdefs.h | sort
1330       echo
1331     fi
1332     test "$ac_signal" != 0 &&
1333       echo "$as_me: caught signal $ac_signal"
1334     echo "$as_me: exit $exit_status"
1335   } >&5
1336   rm -f core *.core &&
1337   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1338     exit $exit_status
1339      ' 0
1340 for ac_signal in 1 2 13 15; do
1341   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1342 done
1343 ac_signal=0
1344
1345 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1346 rm -rf conftest* confdefs.h
1347 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1348 echo >confdefs.h
1349
1350 # Predefined preprocessor variables.
1351
1352 cat >>confdefs.h <<_ACEOF
1353 #define PACKAGE_NAME "$PACKAGE_NAME"
1354 _ACEOF
1355
1356
1357 cat >>confdefs.h <<_ACEOF
1358 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1359 _ACEOF
1360
1361
1362 cat >>confdefs.h <<_ACEOF
1363 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1364 _ACEOF
1365
1366
1367 cat >>confdefs.h <<_ACEOF
1368 #define PACKAGE_STRING "$PACKAGE_STRING"
1369 _ACEOF
1370
1371
1372 cat >>confdefs.h <<_ACEOF
1373 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1374 _ACEOF
1375
1376
1377 # Let the site file select an alternate cache file if it wants to.
1378 # Prefer explicitly selected file to automatically selected ones.
1379 if test -z "$CONFIG_SITE"; then
1380   if test "x$prefix" != xNONE; then
1381     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1382   else
1383     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1384   fi
1385 fi
1386 for ac_site_file in $CONFIG_SITE; do
1387   if test -r "$ac_site_file"; then
1388     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1389 echo "$as_me: loading site script $ac_site_file" >&6;}
1390     sed 's/^/| /' "$ac_site_file" >&5
1391     . "$ac_site_file"
1392   fi
1393 done
1394
1395 if test -r "$cache_file"; then
1396   # Some versions of bash will fail to source /dev/null (special
1397   # files actually), so we avoid doing that.
1398   if test -f "$cache_file"; then
1399     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1400 echo "$as_me: loading cache $cache_file" >&6;}
1401     case $cache_file in
1402       [\\/]* | ?:[\\/]* ) . $cache_file;;
1403       *)                      . ./$cache_file;;
1404     esac
1405   fi
1406 else
1407   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1408 echo "$as_me: creating cache $cache_file" >&6;}
1409   >$cache_file
1410 fi
1411
1412 # Check that the precious variables saved in the cache have kept the same
1413 # value.
1414 ac_cache_corrupted=false
1415 for ac_var in `(set) 2>&1 |
1416                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1417   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1418   eval ac_new_set=\$ac_env_${ac_var}_set
1419   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1420   eval ac_new_val="\$ac_env_${ac_var}_value"
1421   case $ac_old_set,$ac_new_set in
1422     set,)
1423       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1424 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1425       ac_cache_corrupted=: ;;
1426     ,set)
1427       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1428 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1429       ac_cache_corrupted=: ;;
1430     ,);;
1431     *)
1432       if test "x$ac_old_val" != "x$ac_new_val"; then
1433         # differences in whitespace do not lead to failure.
1434         ac_old_val_w=`echo x $ac_old_val`
1435         ac_new_val_w=`echo x $ac_new_val`
1436         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1437           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1438 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1439           ac_cache_corrupted=:
1440         else
1441           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1442 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1443           eval $ac_var=\$ac_old_val
1444         fi
1445         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1446 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1447         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1448 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1449       fi;;
1450   esac
1451   # Pass precious variables to config.status.
1452   if test "$ac_new_set" = set; then
1453     case $ac_new_val in
1454     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1455       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1456     *) ac_arg=$ac_var=$ac_new_val ;;
1457     esac
1458     case " $ac_configure_args " in
1459       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1460       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1461     esac
1462   fi
1463 done
1464 if $ac_cache_corrupted; then
1465   { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1466 echo "$as_me: error: in \`$ac_pwd':" >&2;}
1467   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1468 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1469   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1470 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1471    { (exit 1); exit 1; }; }
1472 fi
1473
1474 ac_ext=c
1475 ac_cpp='$CPP $CPPFLAGS'
1476 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1477 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1478 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503 progname=$0
1504 # if PWD already has a value, it is probably wrong.
1505 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1506
1507 # Export original configure arguments for use by sub-configures.
1508 # Quote arguments with shell meta charatcers.
1509 TOPLEVEL_CONFIGURE_ARGUMENTS=
1510 set -- "$progname" "$@"
1511 for ac_arg
1512 do
1513   case "$ac_arg" in
1514   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1515     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1516     # if the argument is of the form -foo=baz, quote the baz part only
1517     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1518   *) ;;
1519   esac
1520   # Add the quoted argument to the list.
1521   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1522 done
1523 if test "$silent" = yes; then
1524   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1525 fi
1526 # Remove the initial space we just introduced and, as these will be
1527 # expanded by make, quote '$'.
1528 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1529
1530
1531 # Find the build, host, and target systems.
1532 ac_aux_dir=
1533 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1534   if test -f $ac_dir/install-sh; then
1535     ac_aux_dir=$ac_dir
1536     ac_install_sh="$ac_aux_dir/install-sh -c"
1537     break
1538   elif test -f $ac_dir/install.sh; then
1539     ac_aux_dir=$ac_dir
1540     ac_install_sh="$ac_aux_dir/install.sh -c"
1541     break
1542   elif test -f $ac_dir/shtool; then
1543     ac_aux_dir=$ac_dir
1544     ac_install_sh="$ac_aux_dir/shtool install -c"
1545     break
1546   fi
1547 done
1548 if test -z "$ac_aux_dir"; then
1549   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1550 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1551    { (exit 1); exit 1; }; }
1552 fi
1553 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1554 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1555 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1556
1557 # Make sure we can run config.sub.
1558 $ac_config_sub sun4 >/dev/null 2>&1 ||
1559   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1560 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1561    { (exit 1); exit 1; }; }
1562
1563 echo "$as_me:$LINENO: checking build system type" >&5
1564 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1565 if test "${ac_cv_build+set}" = set; then
1566   echo $ECHO_N "(cached) $ECHO_C" >&6
1567 else
1568   ac_cv_build_alias=$build_alias
1569 test -z "$ac_cv_build_alias" &&
1570   ac_cv_build_alias=`$ac_config_guess`
1571 test -z "$ac_cv_build_alias" &&
1572   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1573 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1574    { (exit 1); exit 1; }; }
1575 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1576   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1577 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1578    { (exit 1); exit 1; }; }
1579
1580 fi
1581 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1582 echo "${ECHO_T}$ac_cv_build" >&6
1583 build=$ac_cv_build
1584 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1585 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1586 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1587
1588
1589  case ${build_alias} in
1590   "") build_noncanonical=${build} ;;
1591   *) build_noncanonical=${build_alias} ;;
1592 esac
1593
1594
1595
1596  case ${host_alias} in
1597   "") host_noncanonical=${build_noncanonical} ;;
1598   *) host_noncanonical=${host_alias} ;;
1599 esac
1600
1601
1602
1603  case ${target_alias} in
1604   "") target_noncanonical=${host_noncanonical} ;;
1605   *) target_noncanonical=${target_alias} ;;
1606 esac
1607
1608
1609
1610
1611 test "$host_noncanonical" = "$target_noncanonical" &&
1612   test "$program_prefix$program_suffix$program_transform_name" = \
1613     NONENONEs,x,x, &&
1614   program_transform_name=s,y,y,
1615
1616 echo "$as_me:$LINENO: checking host system type" >&5
1617 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1618 if test "${ac_cv_host+set}" = set; then
1619   echo $ECHO_N "(cached) $ECHO_C" >&6
1620 else
1621   ac_cv_host_alias=$host_alias
1622 test -z "$ac_cv_host_alias" &&
1623   ac_cv_host_alias=$ac_cv_build_alias
1624 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1625   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1626 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1627    { (exit 1); exit 1; }; }
1628
1629 fi
1630 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1631 echo "${ECHO_T}$ac_cv_host" >&6
1632 host=$ac_cv_host
1633 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1634 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1635 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1636
1637
1638 echo "$as_me:$LINENO: checking target system type" >&5
1639 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1640 if test "${ac_cv_target+set}" = set; then
1641   echo $ECHO_N "(cached) $ECHO_C" >&6
1642 else
1643   ac_cv_target_alias=$target_alias
1644 test "x$ac_cv_target_alias" = "x" &&
1645   ac_cv_target_alias=$ac_cv_host_alias
1646 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1647   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1648 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1649    { (exit 1); exit 1; }; }
1650
1651 fi
1652 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1653 echo "${ECHO_T}$ac_cv_target" >&6
1654 target=$ac_cv_target
1655 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1656 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1657 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1658
1659
1660 # The aliases save the names the user supplied, while $host etc.
1661 # will get canonicalized.
1662 test -n "$target_alias" &&
1663   test "$program_prefix$program_suffix$program_transform_name" = \
1664     NONENONEs,x,x, &&
1665   program_prefix=${target_alias}-
1666 test "$program_prefix" != NONE &&
1667   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1668 # Use a double $ so make ignores it.
1669 test "$program_suffix" != NONE &&
1670   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1671 # Double any \ or $.  echo might interpret backslashes.
1672 # By default was `s,x,x', remove it if useless.
1673 cat <<\_ACEOF >conftest.sed
1674 s/[\\$]/&&/g;s/;s,x,x,$//
1675 _ACEOF
1676 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1677 rm conftest.sed
1678
1679
1680
1681 # Get 'install' or 'install-sh' and its variants.
1682 # Find a good install program.  We prefer a C program (faster),
1683 # so one script is as good as another.  But avoid the broken or
1684 # incompatible versions:
1685 # SysV /etc/install, /usr/sbin/install
1686 # SunOS /usr/etc/install
1687 # IRIX /sbin/install
1688 # AIX /bin/install
1689 # AmigaOS /C/install, which installs bootblocks on floppy discs
1690 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1691 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1692 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1693 # OS/2's system install, which has a completely different semantic
1694 # ./install, which can be erroneously created by make from ./install.sh.
1695 # Reject install programs that cannot install multiple files.
1696 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1697 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1698 if test -z "$INSTALL"; then
1699 if test "${ac_cv_path_install+set}" = set; then
1700   echo $ECHO_N "(cached) $ECHO_C" >&6
1701 else
1702   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1703 for as_dir in $PATH
1704 do
1705   IFS=$as_save_IFS
1706   test -z "$as_dir" && as_dir=.
1707   # Account for people who put trailing slashes in PATH elements.
1708 case $as_dir/ in
1709   ./ | .// | /cC/* | \
1710   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1711   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1712   /usr/ucb/* ) ;;
1713   *)
1714     # OSF1 and SCO ODT 3.0 have their own names for install.
1715     # Don't use installbsd from OSF since it installs stuff as root
1716     # by default.
1717     for ac_prog in ginstall scoinst install; do
1718       for ac_exec_ext in '' $ac_executable_extensions; do
1719         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1720           if test $ac_prog = install &&
1721             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1722             # AIX install.  It has an incompatible calling convention.
1723             :
1724           elif test $ac_prog = install &&
1725             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1726             # program-specific install script used by HP pwplus--don't use.
1727             :
1728           else
1729             rm -rf conftest.one conftest.two conftest.dir
1730             echo one > conftest.one
1731             echo two > conftest.two
1732             mkdir conftest.dir
1733             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1734               test -s conftest.one && test -s conftest.two &&
1735               test -s conftest.dir/conftest.one &&
1736               test -s conftest.dir/conftest.two
1737             then
1738               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1739               break 3
1740             fi
1741           fi
1742         fi
1743       done
1744     done
1745     ;;
1746 esac
1747 done
1748
1749 rm -rf conftest.one conftest.two conftest.dir
1750
1751 fi
1752   if test "${ac_cv_path_install+set}" = set; then
1753     INSTALL=$ac_cv_path_install
1754   else
1755     # As a last resort, use the slow shell script.  Don't cache a
1756     # value for INSTALL within a source directory, because that will
1757     # break other packages using the cache if that directory is
1758     # removed, or if the value is a relative name.
1759     INSTALL=$ac_install_sh
1760   fi
1761 fi
1762 echo "$as_me:$LINENO: result: $INSTALL" >&5
1763 echo "${ECHO_T}$INSTALL" >&6
1764
1765 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1766 # It thinks the first close brace ends the variable substitution.
1767 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1768
1769 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1770
1771 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1772
1773 echo "$as_me:$LINENO: checking whether ln works" >&5
1774 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1775 if test "${acx_cv_prog_LN+set}" = set; then
1776   echo $ECHO_N "(cached) $ECHO_C" >&6
1777 else
1778   rm -f conftestdata_t
1779 echo >conftestdata_f
1780 if ln conftestdata_f conftestdata_t 2>/dev/null
1781 then
1782   acx_cv_prog_LN=ln
1783 else
1784   acx_cv_prog_LN=no
1785 fi
1786 rm -f conftestdata_f conftestdata_t
1787
1788 fi
1789 if test $acx_cv_prog_LN = no; then
1790   LN="cp"
1791   echo "$as_me:$LINENO: result: no, using $LN" >&5
1792 echo "${ECHO_T}no, using $LN" >&6
1793 else
1794   LN="$acx_cv_prog_LN"
1795   echo "$as_me:$LINENO: result: yes" >&5
1796 echo "${ECHO_T}yes" >&6
1797 fi
1798
1799 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1800 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1801 LN_S=$as_ln_s
1802 if test "$LN_S" = "ln -s"; then
1803   echo "$as_me:$LINENO: result: yes" >&5
1804 echo "${ECHO_T}yes" >&6
1805 else
1806   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1807 echo "${ECHO_T}no, using $LN_S" >&6
1808 fi
1809
1810
1811 ### we might need to use some other shell than /bin/sh for running subshells
1812 ### If we are on Windows, search for the shell.  This will permit people
1813 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1814 ### without also having to set CONFIG_SHELL.  This code will work when
1815 ### using bash, which sets OSTYPE.
1816 case "${OSTYPE}" in
1817 *win32*)
1818   if test x${CONFIG_SHELL} = x ; then
1819     if test ! -f /bin/sh ; then
1820       if test x${SHELL} != x && test -f ${SHELL} ; then
1821         CONFIG_SHELL=${SHELL}
1822         export CONFIG_SHELL
1823       else
1824         for prog in sh sh.exe bash bash.exe; do
1825           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1826           for dir in $PATH; do
1827             test -z "$dir" && dir=.
1828             if test -f $dir/$prog; then
1829               CONFIG_SHELL=$dir/$prog
1830               export CONFIG_SHELL
1831               break
1832             fi
1833           done
1834           IFS="$save_ifs"
1835           test -n "${CONFIG_SHELL}" && break
1836         done
1837       fi
1838     fi
1839   fi
1840   ;;
1841 esac
1842
1843 config_shell=${CONFIG_SHELL-/bin/sh}
1844
1845 moveifchange=${srcdir}/move-if-change
1846
1847 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1848
1849 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1850 # a relative path.
1851 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1852   INSTALL="${srcpwd}/install-sh -c"
1853 fi
1854
1855 # Set srcdir to "." if that's what it is.
1856 # This is important for multilib support.
1857 pwd=`${PWDCMD-pwd}`
1858 if test "${pwd}" = "${srcpwd}" ; then
1859   srcdir=.
1860 fi
1861
1862 topsrcdir=$srcpwd
1863
1864 extra_host_args=
1865
1866 ### To add a new directory to the tree, first choose whether it is a target
1867 ### or a host dependent tool.  Then put it into the appropriate list
1868 ### (library or tools, host or target), doing a dependency sort.
1869
1870 # Subdirs will be configured in the order listed in build_configdirs,
1871 # configdirs, or target_configdirs; see the serialization section below.
1872
1873 # Dependency sorting is only needed when *configuration* must be done in
1874 # a particular order.  In all cases a dependency should be specified in
1875 # the Makefile, whether or not it's implicitly specified here.
1876
1877 # Double entries in build_configdirs, configdirs, or target_configdirs may
1878 # cause circular dependencies and break everything horribly.
1879
1880 # these library is used by various programs built for the build
1881 # environment
1882 #
1883 build_libs="build-libiberty"
1884
1885 # these tools are built for the build environment
1886 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1887
1888 # these libraries are used by various programs built for the host environment
1889 #
1890 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr ppl cloog libiconv"
1891
1892 # these tools are built for the host environment
1893 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1894 # know that we are building the simulator.
1895 # binutils, gas and ld appear in that order because it makes sense to run
1896 # "make check" in that particular order.
1897 # If --enable-gold is used, "gold" will replace "ld".
1898 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"
1899
1900 # libgcj represents the runtime libraries only used by gcj.
1901 libgcj="target-libffi \
1902         target-zlib \
1903         target-qthreads \
1904         target-libjava"
1905
1906 # these libraries are built for the target environment, and are built after
1907 # the host libraries and the host tools (which may be a cross compiler)
1908 #
1909 target_libraries="target-libgcc \
1910                 target-libiberty \
1911                 target-libgloss \
1912                 target-newlib \
1913                 target-libgomp \
1914                 target-libstdc++-v3 \
1915                 target-libmudflap \
1916                 target-libssp \
1917                 target-libgfortran \
1918                 target-boehm-gc \
1919                 ${libgcj} \
1920                 target-libobjc \
1921                 target-libada"
1922
1923 # these tools are built using the target libraries, and are intended to
1924 # run only in the target environment
1925 #
1926 # note: any program that *uses* libraries that are in the "target_libraries"
1927 # list belongs in this list.  those programs are also very likely
1928 # candidates for the "native_only" list which follows
1929 #
1930 target_tools="target-examples target-groff target-gperf target-rda"
1931
1932 ################################################################################
1933
1934 ## All tools belong in one of the four categories, and are assigned above
1935 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1936 ## is important because configure will choke if they ever get through.
1937 ## ${configdirs} is directories we build using the host tools.
1938 ## ${target_configdirs} is directories we build using the target tools.
1939 configdirs=`echo ${host_libs} ${host_tools}`
1940 target_configdirs=`echo ${target_libraries} ${target_tools}`
1941 build_configdirs=`echo ${build_libs} ${build_tools}`
1942
1943
1944
1945 ################################################################################
1946
1947 srcname="gnu development package"
1948
1949 # This gets set non-empty for some net releases of packages.
1950 appdirs=""
1951
1952 # Define is_cross_compiler to save on calls to 'test'.
1953 is_cross_compiler=
1954 if test x"${host}" = x"${target}" ; then
1955   is_cross_compiler=no
1956 else
1957   is_cross_compiler=yes
1958 fi
1959
1960 # Find the build and target subdir names.
1961
1962 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1963 # have matching libraries, they should use host libraries: Makefile.tpl
1964 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1965 # However, they still use the build modules, because the corresponding
1966 # host modules (e.g. bison) are only built for the host when bootstrap
1967 # finishes. So:
1968 # - build_subdir is where we find build modules, and never changes.
1969 # - build_libsubdir is where we find build libraries, and can be overridden.
1970
1971 # Prefix 'build-' so this never conflicts with target_subdir.
1972 build_subdir="build-${build_noncanonical}"
1973
1974 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1975 if test "${with_build_libsubdir+set}" = set; then
1976   withval="$with_build_libsubdir"
1977   build_libsubdir="$withval"
1978 else
1979   build_libsubdir="$build_subdir"
1980 fi;
1981 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1982 if ( test $srcdir = . && test -d gcc ) \
1983    || test -d $srcdir/../host-${host_noncanonical}; then
1984   host_subdir="host-${host_noncanonical}"
1985 else
1986   host_subdir=.
1987 fi
1988 # No prefix.
1989 target_subdir=${target_noncanonical}
1990
1991
1992 # Skipdirs are removed silently.
1993 skipdirs=
1994 # Noconfigdirs are removed loudly.
1995 noconfigdirs=""
1996
1997 use_gnu_ld=
1998 # Make sure we don't let GNU ld be added if we didn't want it.
1999 if test x$with_gnu_ld = xno ; then
2000   use_gnu_ld=no
2001   noconfigdirs="$noconfigdirs ld gold"
2002 fi
2003
2004 use_gnu_as=
2005 # Make sure we don't let GNU as be added if we didn't want it.
2006 if test x$with_gnu_as = xno ; then
2007   use_gnu_as=no
2008   noconfigdirs="$noconfigdirs gas"
2009 fi
2010
2011 # some tools are so dependent upon X11 that if we're not building with X,
2012 # it's not even worth trying to configure, much less build, that tool.
2013
2014 case ${with_x} in
2015   yes | "") ;; # the default value for this tree is that X11 is available
2016   no)
2017     skipdirs="${skipdirs} tk itcl libgui"
2018     # We won't be able to build gdbtk without X.
2019     enable_gdbtk=no
2020     ;;
2021   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2022 esac
2023
2024 # Some tools are only suitable for building in a "native" situation.
2025 # Remove these if host!=target.
2026 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"
2027
2028 # Similarly, some are only suitable for cross toolchains.
2029 # Remove these if host=target.
2030 cross_only="target-libgloss target-newlib target-opcodes"
2031
2032 case $is_cross_compiler in
2033   no) skipdirs="${skipdirs} ${cross_only}" ;;
2034   yes) skipdirs="${skipdirs} ${native_only}" ;;
2035 esac
2036
2037 # If both --with-headers and --with-libs are specified, default to
2038 # --without-newlib.
2039 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2040    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2041   if test x"${with_newlib}" = x ; then
2042     with_newlib=no
2043   fi
2044 fi
2045
2046 # Recognize --with-newlib/--without-newlib.
2047 case ${with_newlib} in
2048   no) skipdirs="${skipdirs} target-newlib" ;;
2049   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2050 esac
2051
2052 # Handle --enable-gold.
2053
2054 # Check whether --enable-gold or --disable-gold was given.
2055 if test "${enable_gold+set}" = set; then
2056   enableval="$enable_gold"
2057   ENABLE_GOLD=$enableval
2058 else
2059   ENABLE_GOLD=no
2060 fi;
2061 if test "${ENABLE_GOLD}" = "yes"; then
2062   # Check for ELF target.
2063   is_elf=no
2064   case "${target}" in
2065     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2066     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2067     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2068       case "${target}" in
2069         *-*-linux*aout* | *-*-linux*oldld*)
2070           ;;
2071         *)
2072           is_elf=yes
2073           ;;
2074       esac
2075   esac
2076
2077   if test "$is_elf" = "yes"; then
2078     # Check for target supported by gold.
2079     case "${target}" in
2080       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-*)
2081         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2082         ;;
2083     esac
2084   fi
2085 fi
2086
2087 # Configure extra directories which are host specific
2088
2089 case "${host}" in
2090   *-cygwin*)
2091     configdirs="$configdirs libtermcap" ;;
2092 esac
2093
2094 # A target can indicate whether a language isn't supported for some reason.
2095 # Only spaces may be used in this macro; not newlines or tabs.
2096 unsupported_languages=
2097
2098 # Remove more programs from consideration, based on the host or
2099 # target this usually means that a port of the program doesn't
2100 # exist yet.
2101
2102 case "${host}" in
2103   hppa*64*-*-*)
2104     noconfigdirs="$noconfigdirs byacc"
2105     ;;
2106   i[3456789]86-*-vsta)
2107     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2108     ;;
2109   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2110     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2111     ;;
2112   x86_64-*-mingw*)
2113     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2114     ;;
2115   i[3456789]86-*-mingw32*)
2116     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2117     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2118     ;;
2119   i[3456789]86-*-beos*)
2120     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2121     ;;
2122   *-*-cygwin*)
2123     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2124     ;;
2125   *-*-netbsd*)
2126     noconfigdirs="$noconfigdirs rcs"
2127     ;;
2128   ppc*-*-pe)
2129     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2130     ;;
2131   powerpc-*-beos*)
2132     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2133     ;;
2134 esac
2135
2136
2137 # Check whether --enable-libada or --disable-libada was given.
2138 if test "${enable_libada+set}" = set; then
2139   enableval="$enable_libada"
2140   ENABLE_LIBADA=$enableval
2141 else
2142   ENABLE_LIBADA=yes
2143 fi;
2144 if test "${ENABLE_LIBADA}" != "yes" ; then
2145   noconfigdirs="$noconfigdirs gnattools"
2146 fi
2147
2148 # Check whether --enable-libssp or --disable-libssp was given.
2149 if test "${enable_libssp+set}" = set; then
2150   enableval="$enable_libssp"
2151   ENABLE_LIBSSP=$enableval
2152 else
2153   ENABLE_LIBSSP=yes
2154 fi;
2155
2156 # Save it here so that, even in case of --enable-libgcj, if the Java
2157 # front-end isn't enabled, we still get libgcj disabled.
2158 libgcj_saved=$libgcj
2159 case $enable_libgcj in
2160 yes)
2161   # If we reset it here, it won't get added to noconfigdirs in the
2162   # target-specific build rules, so it will be forcibly enabled
2163   # (unless the Java language itself isn't enabled).
2164   libgcj=
2165   ;;
2166 no)
2167   # Make sure we get it printed in the list of not supported target libs.
2168   noconfigdirs="$noconfigdirs ${libgcj}"
2169   ;;
2170 esac
2171
2172
2173 # Disable libmudflap on some systems.
2174 if test x$enable_libmudflap = x ; then
2175     case "${target}" in
2176     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux* | *-*-kopensolaris*-gnu)
2177         # Enable libmudflap by default in GNU and friends.
2178         ;;
2179     *-*-freebsd*)
2180         # Enable libmudflap by default in FreeBSD.
2181         ;;
2182     *)
2183         # Disable it by default everywhere else.
2184         noconfigdirs="$noconfigdirs target-libmudflap"
2185         ;;
2186     esac
2187 fi
2188
2189 # Disable libgomp on non POSIX hosted systems.
2190 if test x$enable_libgomp = x ; then
2191     # Enable libgomp by default on hosted POSIX systems.
2192     case "${target}" in
2193     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2194         ;;
2195     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2196         ;;
2197     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2198         ;;
2199     *-*-darwin* | *-*-aix*)
2200         ;;
2201     *)
2202         noconfigdirs="$noconfigdirs target-libgomp"
2203         ;;
2204     esac
2205 fi
2206
2207 # Default libgloss CPU subdirectory.
2208 libgloss_dir="$target_cpu"
2209
2210 case "${target}" in
2211   *-*-chorusos)
2212     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2213     ;;
2214   powerpc-*-darwin*)
2215     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2216     noconfigdirs="$noconfigdirs sim target-rda"
2217     ;;
2218   i[3456789]86-*-darwin* | x86_64-*-darwin[912]*)
2219     noconfigdirs="$noconfigdirs ld gas gprof"
2220     noconfigdirs="$noconfigdirs sim target-rda"
2221     ;;
2222   *-*-darwin*)
2223     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2224     noconfigdirs="$noconfigdirs sim target-rda"
2225     noconfigdirs="$noconfigdirs ${libgcj}"
2226     ;;
2227   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2228     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2229     ;;
2230   *-*-freebsd*)
2231     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2232     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2233         && test -f /usr/local/include/gmp.h; then
2234       with_gmp=/usr/local
2235     fi
2236
2237     # Skip some stuff that's unsupported on some FreeBSD configurations.
2238     case "${target}" in
2239       i*86-*-*) ;;
2240       alpha*-*-*) ;;
2241       *)
2242         noconfigdirs="$noconfigdirs ${libgcj}"
2243         ;;
2244     esac
2245     ;;
2246   *-*-kaos*)
2247     # Remove unsupported stuff on all kaOS configurations.
2248     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2249     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2250     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2251     noconfigdirs="$noconfigdirs target-libgloss"
2252     ;;
2253   *-*-netbsd*)
2254     # Skip some stuff on all NetBSD configurations.
2255     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2256
2257     # Skip some stuff that's unsupported on some NetBSD configurations.
2258     case "${target}" in
2259       i*86-*-netbsdelf*) ;;
2260       arm*-*-netbsdelf*) ;;
2261       *)
2262         noconfigdirs="$noconfigdirs ${libgcj}"
2263         ;;
2264     esac
2265     ;;
2266   *-*-netware*)
2267     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2268     ;;
2269   *-*-rtems*)
2270     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2271     ;;
2272     # The tpf target doesn't support gdb yet.
2273   *-*-tpf*)
2274     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2275     ;;
2276   *-*-uclinux*)
2277     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2278     ;;
2279   *-*-vxworks*)
2280     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2281     ;;
2282   alpha*-dec-osf*)
2283     # ld works, but does not support shared libraries.
2284     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2285     # gas doesn't generate exception information.
2286     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2287     ;;
2288   alpha*-*-*vms*)
2289     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2290     ;;
2291   alpha*-*-linux*)
2292     # newlib is not 64 bit ready
2293     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2294     ;;
2295   alpha*-*-*)
2296     # newlib is not 64 bit ready
2297     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2298     ;;
2299   am33_2.0-*-linux*)
2300     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2301     ;;
2302   sh-*-linux*)
2303     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2304     ;;
2305   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2306     noconfigdirs="$noconfigdirs ${libgcj}"
2307     noconfigdirs="$noconfigdirs target-examples"
2308     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2309     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2310     noconfigdirs="$noconfigdirs expect dejagnu"
2311     # the C++ libraries don't build on top of CE's C libraries
2312     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2313     noconfigdirs="$noconfigdirs target-newlib"
2314     case "${host}" in
2315       *-*-cygwin*) ;; # keep gdb and readline
2316       *) noconfigdirs="$noconfigdirs gdb readline"
2317          ;;
2318     esac
2319     libgloss_dir=wince
2320     ;;
2321   arc-*-*)
2322     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2323     ;;
2324   arm-semi-aof )
2325     ;;
2326   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2327     noconfigdirs="$noconfigdirs ${libgcj}"
2328     libgloss_dir=arm
2329     ;;
2330   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2331     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2332     libgloss_dir=arm
2333     ;;
2334   arm*-*-linux-gnueabi)
2335     noconfigdirs="$noconfigdirs target-qthreads"
2336     case ${with_newlib} in
2337       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2338     esac
2339     libgloss_dir=arm
2340     ;;
2341   arm*-*-symbianelf*)
2342     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2343     libgloss_dir=arm
2344     ;;
2345   arm-*-pe*)
2346     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2347     ;;
2348   thumb-*-coff)
2349     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2350     ;;
2351   thumb-*-elf)
2352     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2353     ;;
2354   thumb-*-pe)
2355     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2356     ;;
2357   arm-*-riscix*)
2358     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2359     ;;
2360   avr-*-*)
2361     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2362     ;;
2363   bfin-*-*)
2364     noconfigdirs="$noconfigdirs gdb"
2365     if test x${is_cross_compiler} != xno ; then
2366       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2367     fi
2368     ;;
2369   c4x-*-* | tic4x-*-*)
2370     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2371     ;;
2372   c54x*-*-* | tic54x-*-*)
2373     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2374     ;;
2375   cr16-*-*)
2376     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2377     ;;
2378   cris-*-* | crisv32-*-*)
2379     unsupported_languages="$unsupported_languages java"
2380     case "${target}" in
2381       *-*-aout)
2382         unsupported_languages="$unsupported_languages fortran"
2383         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2384       *-*-elf)
2385         noconfigdirs="$noconfigdirs target-boehm-gc";;
2386       *-*-linux*)
2387         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2388       *)
2389         unsupported_languages="$unsupported_languages fortran"
2390         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2391     esac
2392     libgloss_dir=cris
2393     ;;
2394   crx-*-*)
2395     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2396     ;;
2397   d10v-*-*)
2398     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2399     ;;
2400   d30v-*-*)
2401     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2402     ;;
2403   ep9312-*-elf | ep9312-*-coff)
2404     libgloss_dir=arm
2405     ;;
2406   fr30-*-elf*)
2407     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2408     ;;
2409   frv-*-*)
2410     noconfigdirs="$noconfigdirs ${libgcj}"
2411     ;;
2412   h8300*-*-*)
2413     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2414     ;;
2415   h8500-*-*)
2416     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2417     ;;
2418   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2419     ;;
2420   hppa*64*-*-linux* | parisc*64*-*-linux*)
2421     # In this case, it's because the hppa64-linux target is for
2422     # the kernel only at this point and has no libc, and thus no
2423     # headers, crt*.o, etc., all of which are needed by these.
2424     noconfigdirs="$noconfigdirs target-zlib"
2425     ;;
2426   parisc*-*-linux* | hppa*-*-linux*)
2427     ;;
2428   hppa*-*-*elf* | \
2429   hppa*-*-lites* | \
2430   hppa*-*-openbsd* | \
2431   hppa*64*-*-*)
2432     noconfigdirs="$noconfigdirs ${libgcj}"
2433     ;;
2434   hppa*-hp-hpux11*)
2435     noconfigdirs="$noconfigdirs ld shellutils"
2436     ;;
2437   hppa*-*-pro*)
2438     libgloss_dir=pa
2439     ;;
2440   hppa*-*-*)
2441     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2442     # build on HP-UX 10.20.
2443     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2444     ;;
2445   i960-*-*)
2446     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2447     ;;
2448   ia64*-*-elf*)
2449     # No gdb support yet.
2450     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2451     ;;
2452   ia64*-**-hpux*)
2453     # No gdb or ld support yet.
2454     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2455     ;;
2456   ia64*-*-*vms*)
2457     # No gdb or ld support yet.
2458     noconfigdirs="$noconfigdirs ${libgcj} tix readline mmalloc libgui itcl gdb ld"
2459     ;;
2460   i370-*-opened*)
2461     ;;
2462   i[3456789]86-*-coff | i[3456789]86-*-elf)
2463     noconfigdirs="$noconfigdirs ${libgcj}"
2464     libgloss_dir=i386
2465     ;;
2466   i[3456789]86-*-linux*)
2467     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2468     # not build java stuff by default.
2469     case "${target}" in
2470       *-*-*libc1*)
2471         noconfigdirs="$noconfigdirs ${libgcj}";;
2472     esac
2473
2474     # This section makes it possible to build newlib natively on linux.
2475     # If we are using a cross compiler then don't configure newlib.
2476     if test x${is_cross_compiler} != xno ; then
2477       noconfigdirs="$noconfigdirs target-newlib"
2478     fi
2479     noconfigdirs="$noconfigdirs target-libgloss"
2480     # If we are not using a cross compiler, do configure newlib.
2481     # Note however, that newlib will only be configured in this situation
2482     # if the --with-newlib option has been given, because otherwise
2483     # 'target-newlib' will appear in skipdirs.
2484     ;;
2485   i[3456789]86-*-mingw32*)
2486     target_configdirs="$target_configdirs target-winsup"
2487     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2488     ;;
2489   x86_64-*-mingw*)
2490     target_configdirs="$target_configdirs target-winsup"
2491     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2492     ;;
2493   *-*-cygwin*)
2494     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2495     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2496     # always build newlib if winsup directory is present.
2497     if test -d "$srcdir/winsup/cygwin"; then
2498       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2499     elif test -d "$srcdir/newlib"; then
2500       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2501     fi
2502     ;;
2503   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2504   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2505     ;;
2506   i[3456789]86-*-pe)
2507     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2508     ;;
2509   i[3456789]86-*-sco3.2v5*)
2510     # The linker does not yet know about weak symbols in COFF,
2511     # and is not configured to handle mixed ELF and COFF.
2512     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2513     ;;
2514   i[3456789]86-*-sco*)
2515     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2516     ;;
2517   i[3456789]86-*-solaris2*)
2518     noconfigdirs="$noconfigdirs target-libgloss"
2519     ;;
2520   i[3456789]86-*-sysv4*)
2521     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2522     ;;
2523   i[3456789]86-*-beos*)
2524     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2525     ;;
2526   i[3456789]86-*-rdos*)
2527     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2528     ;;
2529   m32r-*-*)
2530     noconfigdirs="$noconfigdirs ${libgcj}"
2531     ;;
2532   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2533     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2534     libgloss_dir=m68hc11
2535     ;;
2536   m68k-*-elf*)
2537     noconfigdirs="$noconfigdirs ${libgcj}"
2538     ;;
2539   m68k-*-coff*)
2540     noconfigdirs="$noconfigdirs ${libgcj}"
2541     ;;
2542   m68*-*-* | fido-*-*)
2543     libgloss_dir=m68k
2544     ;;
2545   mcore-*-pe*)
2546   # The EPOC C++ environment does not support exceptions or rtti,
2547   # and so building libstdc++-v3 tends not to always work.
2548     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2549     ;;
2550   mmix-*-*)
2551     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2552     unsupported_languages="$unsupported_languages fortran java"
2553     ;;
2554   mn10200-*-*)
2555     noconfigdirs="$noconfigdirs ${libgcj}"
2556     ;;
2557   mn10300-*-*)
2558     noconfigdirs="$noconfigdirs ${libgcj}"
2559     ;;
2560   mt-*-*)
2561     noconfigdirs="$noconfigdirs sim"
2562     ;;
2563   powerpc-*-aix*)
2564     # copied from rs6000-*-* entry
2565     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2566     ;;
2567   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2568     target_configdirs="$target_configdirs target-winsup"
2569     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2570     # always build newlib.
2571     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2572     ;;
2573     # This is temporary until we can link against shared libraries
2574   powerpcle-*-solaris*)
2575     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2576     libgloss_dir=rs6000
2577     ;;
2578   powerpc-*-beos*)
2579     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2580     ;;
2581   powerpc-*-eabi)
2582     noconfigdirs="$noconfigdirs ${libgcj}"
2583     libgloss_dir=rs6000
2584     ;;
2585   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2586     libgloss_dir=rs6000
2587     ;;
2588   rs6000-*-lynxos*)
2589     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2590     ;;
2591   rs6000-*-aix*)
2592     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2593     ;;
2594   rs6000-*-*)
2595     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2596     ;;
2597   m68k-apollo-*)
2598     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2599     ;;
2600   mips*-sde-elf*)
2601     skipdirs="$skipdirs target-libiberty"
2602     noconfigdirs="$noconfigdirs ${libgcj}"
2603     if test x$with_newlib = xyes; then
2604       noconfigdirs="$noconfigdirs gprof"
2605     fi
2606     libgloss_dir=mips
2607     ;;
2608   mips*-*-irix5*)
2609     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2610     ;;
2611   mips*-*-irix6*)
2612     # Linking libjava exceeds command-line length limits on at least
2613     # IRIX 6.2, but not on IRIX 6.5.
2614     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2615     # <oldham@codesourcery.com>
2616     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2617     ;;
2618   mips*-*-bsd*)
2619     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2620     ;;
2621   mips*-*-linux*)
2622     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2623     ;;
2624   mips*-*-*)
2625     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2626     libgloss_dir=mips
2627     ;;
2628   romp-*-*)
2629     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2630     ;;
2631   sh-*-* | sh64-*-*)
2632     case "${host}" in
2633       i[3456789]86-*-vsta) ;; # don't add gprof back in
2634       i[3456789]86-*-go32*) ;; # don't add gprof back in
2635       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2636       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2637     esac
2638     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2639     ;;
2640   sparclet-*-aout* | sparc86x-*-*)
2641     libgloss_dir=sparc
2642     ;;
2643   sparc-*-elf*)
2644     noconfigdirs="$noconfigdirs ${libgcj}"
2645     ;;
2646   sparc64-*-elf*)
2647     noconfigdirs="$noconfigdirs ${libgcj}"
2648     libgloss_dir=sparc
2649     ;;
2650   sparclite-*-*)
2651     noconfigdirs="$noconfigdirs ${libgcj}"
2652     libgloss_dir=sparc
2653     ;;
2654   sparc-*-sunos4*)
2655     noconfigdirs="$noconfigdirs ${libgcj}"
2656     if test x${is_cross_compiler} != xno ; then
2657            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2658     else
2659            use_gnu_ld=no
2660     fi
2661     ;;
2662   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2663     noconfigdirs="$noconfigdirs ${libgcj}"
2664     ;;
2665   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2666     ;;
2667   v810-*-*)
2668     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2669     ;;
2670   v850-*-*)
2671     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2672     ;;
2673   v850e-*-*)
2674     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2675     ;;
2676   v850ea-*-*)
2677     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2678     ;;
2679   vax-*-vms)
2680     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2681     ;;
2682   vax-*-*)
2683     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2684     ;;
2685   xtensa*-*-*)
2686     noconfigdirs="$noconfigdirs ${libgcj}"
2687     ;;
2688   ip2k-*-*)
2689     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2690     ;;
2691   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2692     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2693     ;;
2694   *-*-lynxos*)
2695     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2696     ;;
2697   *-*-*)
2698     noconfigdirs="$noconfigdirs ${libgcj}"
2699     ;;
2700 esac
2701
2702 # If we aren't building newlib, then don't build libgloss, since libgloss
2703 # depends upon some newlib header files.
2704 case "${noconfigdirs}" in
2705   *target-libgloss*) ;;
2706   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2707 esac
2708
2709 # Work in distributions that contain no compiler tools, like Autoconf.
2710 tentative_cc=""
2711 host_makefile_frag=/dev/null
2712 if test -d ${srcdir}/config ; then
2713 case "${host}" in
2714   m68k-hp-hpux*)
2715     # Avoid "too much defining" errors from HPUX compiler.
2716     tentative_cc="cc -Wp,-H256000"
2717     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2718     # If it's HP/UX ar, this should be harmless.
2719     RANLIB="ar ts"
2720     ;;
2721   m68k-apollo-sysv*)
2722     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2723     ;;
2724   m68k-apollo-bsd*)
2725     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2726     # chokes on bfd, the compiler won't let you assign integers to enums, and
2727     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2728     # the apollo compiler" (the preferred version of GCC could be called cc,
2729     # or whatever), but I'm not sure leaving CC as cc is any better...
2730     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2731     # Used to have BISON=yacc.
2732     tentative_cc=gcc
2733     ;;
2734   m88k-dg-dgux*)
2735     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2736     ;;
2737   m88k-harris-cxux*)
2738     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2739     tentative_cc="cc -Xa"
2740     host_makefile_frag="config/mh-cxux"
2741     ;;
2742   m88k-motorola-sysv*)
2743     ;;
2744   mips*-dec-ultrix*)
2745     tentative_cc="cc -Wf,-XNg1000"
2746     host_makefile_frag="config/mh-decstation"
2747     ;;
2748   mips*-nec-sysv4*)
2749     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2750     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2751     host_makefile_frag="config/mh-necv4"
2752     ;;
2753   mips*-sgi-irix4*)
2754     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2755     # environment.  Also bump switch table size so that cp-parse will
2756     # compile.  Bump string length limit so linker builds.
2757     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2758     ;;
2759   mips*-*-sysv4*)
2760     host_makefile_frag="config/mh-sysv4"
2761     ;;
2762   mips*-*-sysv*)
2763     # This is for a MIPS running RISC/os 4.52C.
2764
2765     # This is needed for GDB, but needs to be in the top-level make because
2766     # if a library is compiled with the bsd headers and gets linked with the
2767     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2768     # a different size).
2769     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2770     # known except to select the sysv environment.  Could we use /proc instead?
2771     # These "sysv environments" and "bsd environments" often end up being a pain.
2772     #
2773     # This is not part of CFLAGS because perhaps not all C compilers have this
2774     # option.
2775     tentative_cc="cc -systype sysv"
2776     ;;
2777   i370-ibm-opened*)
2778     tentative_cc="c89"
2779     ;;
2780   i[3456789]86-*-sysv5*)
2781     host_makefile_frag="config/mh-sysv5"
2782     ;;
2783   i[3456789]86-*-dgux*)
2784     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2785     host_makefile_frag="config/mh-dgux386"
2786     ;;
2787   i[3456789]86-ncr-sysv4.3*)
2788     # The MetaWare compiler will generate a copyright message unless you
2789     # turn it off by adding the -Hnocopyr flag.
2790     tentative_cc="cc -Hnocopyr"
2791     ;;
2792   i[3456789]86-ncr-sysv4*)
2793     # for an NCR 3000 (i486/SVR4) system.
2794     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2795     # This compiler not only emits obnoxious copyright messages every time
2796     # you run it, but it chokes and dies on a whole bunch of GNU source
2797     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2798     tentative_cc="/usr/ccs/ATT/cc"
2799     host_makefile_frag="config/mh-ncr3000"
2800     ;;
2801   i[3456789]86-*-sco3.2v5*)
2802     ;;
2803   i[3456789]86-*-sco*)
2804     # The native C compiler botches some simple uses of const.  Unfortunately,
2805     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2806     tentative_cc="cc -Dconst="
2807     host_makefile_frag="config/mh-sco"
2808     ;;
2809   i[3456789]86-*-udk*)
2810     host_makefile_frag="config/mh-sysv5"
2811     ;;
2812   i[3456789]86-*-solaris2*)
2813     host_makefile_frag="config/mh-sysv4"
2814     ;;
2815   i[3456789]86-*-msdosdjgpp*)
2816     host_makefile_frag="config/mh-djgpp"
2817     ;;
2818   *-cygwin*)
2819
2820 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2821 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2822 echo a >cygwin-cat-check
2823 if test `cat cygwin-cat-check` == a ; then
2824   rm cygwin-cat-check
2825   echo "$as_me:$LINENO: result: yes" >&5
2826 echo "${ECHO_T}yes" >&6
2827 else
2828   rm cygwin-cat-check
2829   echo "$as_me:$LINENO: result: no" >&5
2830 echo "${ECHO_T}no" >&6
2831   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2832   Please either mount the build directory in binary mode or run the following
2833   commands before running any configure script:
2834 set -o igncr
2835 export SHELLOPTS
2836   " >&5
2837 echo "$as_me: error: The cat command does not ignore carriage return characters.
2838   Please either mount the build directory in binary mode or run the following
2839   commands before running any configure script:
2840 set -o igncr
2841 export SHELLOPTS
2842   " >&2;}
2843    { (exit 1); exit 1; }; }
2844 fi
2845
2846     host_makefile_frag="config/mh-cygwin"
2847     ;;
2848   *-mingw*)
2849     host_makefile_frag="config/mh-mingw"
2850     ;;
2851   *-interix*)
2852     host_makefile_frag="config/mh-interix"
2853     ;;
2854   vax-*-ultrix2*)
2855     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2856     tentative_cc=gcc
2857     ;;
2858   *-*-solaris2*)
2859     host_makefile_frag="config/mh-solaris"
2860     ;;
2861   m68k-sun-sunos*)
2862     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2863     # without overflowing the jump tables (-J says to use a 32 bit table)
2864     tentative_cc="cc -J"
2865     ;;
2866   hppa*-hp-hpux10*)
2867     tentative_cc="cc -Wp,-H256000"
2868     host_makefile_frag="config/mh-pa-hpux10"
2869     ;;
2870   hppa*-hp-hpux* | hppa*-*-hiux*)
2871     tentative_cc="cc -Wp,-H256000"
2872     host_makefile_frag="config/mh-pa"
2873     ;;
2874   hppa*-*)
2875     host_makefile_frag="config/mh-pa"
2876     ;;
2877   *-hp-hpux* | *-*-hiux*)
2878     tentative_cc="cc -Wp,-H256000"
2879     ;;
2880   rs6000-*-lynxos*)
2881     # /bin/cc is less than useful for our purposes.  Always use GCC
2882     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2883     host_makefile_frag="config/mh-lynxrs6k"
2884     ;;
2885   powerpc-*-darwin*)
2886     host_makefile_frag="config/mh-ppc-darwin"
2887     ;;
2888   powerpc-*-aix*)
2889     host_makefile_frag="config/mh-ppc-aix"
2890     ;;
2891   rs6000-*-aix*)
2892     host_makefile_frag="config/mh-ppc-aix"
2893     ;;
2894   *-*-lynxos*)
2895     # /bin/cc is less than useful for our purposes.  Always use GCC
2896     tentative_cc="/bin/gcc"
2897     ;;
2898   *-*-sysv4*)
2899     host_makefile_frag="config/mh-sysv4"
2900     ;;
2901   # This is placed last to prevent interfering with the cases above.
2902   i[3456789]86-*-*)
2903     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2904     host_makefile_frag="config/mh-x86omitfp"
2905     ;;
2906 esac
2907 fi
2908
2909 # If we aren't going to be using gcc, see if we can extract a definition
2910 # of CC from the fragment.
2911 # Actually, use the 'pre-extracted' version above.
2912 if test -z "${CC}" && test "${build}" = "${host}" ; then
2913   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2914   found=
2915   for dir in $PATH; do
2916     test -z "$dir" && dir=.
2917     if test -f $dir/gcc; then
2918       found=yes
2919       break
2920     fi
2921   done
2922   IFS="$save_ifs"
2923   if test -z "${found}" && test -n "${tentative_cc}" ; then
2924     CC=$tentative_cc
2925   fi
2926 fi
2927
2928 if test "${build}" != "${host}" ; then
2929   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2930   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2931   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2932   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2933   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2934   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2935   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2936   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2937   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2938   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2939   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2940   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2941 else
2942   AR_FOR_BUILD="\$(AR)"
2943   AS_FOR_BUILD="\$(AS)"
2944   CC_FOR_BUILD="\$(CC)"
2945   CXX_FOR_BUILD="\$(CXX)"
2946   GCJ_FOR_BUILD="\$(GCJ)"
2947   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2948   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2949   LD_FOR_BUILD="\$(LD)"
2950   NM_FOR_BUILD="\$(NM)"
2951   RANLIB_FOR_BUILD="\$(RANLIB)"
2952   WINDRES_FOR_BUILD="\$(WINDRES)"
2953   WINDMC_FOR_BUILD="\$(WINDMC)"
2954 fi
2955
2956 ac_ext=c
2957 ac_cpp='$CPP $CPPFLAGS'
2958 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2959 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2960 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2961 if test -n "$ac_tool_prefix"; then
2962   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2963 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2964 echo "$as_me:$LINENO: checking for $ac_word" >&5
2965 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2966 if test "${ac_cv_prog_CC+set}" = set; then
2967   echo $ECHO_N "(cached) $ECHO_C" >&6
2968 else
2969   if test -n "$CC"; then
2970   ac_cv_prog_CC="$CC" # Let the user override the test.
2971 else
2972 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2973 for as_dir in $PATH
2974 do
2975   IFS=$as_save_IFS
2976   test -z "$as_dir" && as_dir=.
2977   for ac_exec_ext in '' $ac_executable_extensions; do
2978   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2979     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2980     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2981     break 2
2982   fi
2983 done
2984 done
2985
2986 fi
2987 fi
2988 CC=$ac_cv_prog_CC
2989 if test -n "$CC"; then
2990   echo "$as_me:$LINENO: result: $CC" >&5
2991 echo "${ECHO_T}$CC" >&6
2992 else
2993   echo "$as_me:$LINENO: result: no" >&5
2994 echo "${ECHO_T}no" >&6
2995 fi
2996
2997 fi
2998 if test -z "$ac_cv_prog_CC"; then
2999   ac_ct_CC=$CC
3000   # Extract the first word of "gcc", so it can be a program name with args.
3001 set dummy gcc; ac_word=$2
3002 echo "$as_me:$LINENO: checking for $ac_word" >&5
3003 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3004 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3005   echo $ECHO_N "(cached) $ECHO_C" >&6
3006 else
3007   if test -n "$ac_ct_CC"; then
3008   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3009 else
3010 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3011 for as_dir in $PATH
3012 do
3013   IFS=$as_save_IFS
3014   test -z "$as_dir" && as_dir=.
3015   for ac_exec_ext in '' $ac_executable_extensions; do
3016   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3017     ac_cv_prog_ac_ct_CC="gcc"
3018     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3019     break 2
3020   fi
3021 done
3022 done
3023
3024 fi
3025 fi
3026 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3027 if test -n "$ac_ct_CC"; then
3028   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3029 echo "${ECHO_T}$ac_ct_CC" >&6
3030 else
3031   echo "$as_me:$LINENO: result: no" >&5
3032 echo "${ECHO_T}no" >&6
3033 fi
3034
3035   CC=$ac_ct_CC
3036 else
3037   CC="$ac_cv_prog_CC"
3038 fi
3039
3040 if test -z "$CC"; then
3041   if test -n "$ac_tool_prefix"; then
3042   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3043 set dummy ${ac_tool_prefix}cc; ac_word=$2
3044 echo "$as_me:$LINENO: checking for $ac_word" >&5
3045 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3046 if test "${ac_cv_prog_CC+set}" = set; then
3047   echo $ECHO_N "(cached) $ECHO_C" >&6
3048 else
3049   if test -n "$CC"; then
3050   ac_cv_prog_CC="$CC" # Let the user override the test.
3051 else
3052 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3053 for as_dir in $PATH
3054 do
3055   IFS=$as_save_IFS
3056   test -z "$as_dir" && as_dir=.
3057   for ac_exec_ext in '' $ac_executable_extensions; do
3058   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3059     ac_cv_prog_CC="${ac_tool_prefix}cc"
3060     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3061     break 2
3062   fi
3063 done
3064 done
3065
3066 fi
3067 fi
3068 CC=$ac_cv_prog_CC
3069 if test -n "$CC"; then
3070   echo "$as_me:$LINENO: result: $CC" >&5
3071 echo "${ECHO_T}$CC" >&6
3072 else
3073   echo "$as_me:$LINENO: result: no" >&5
3074 echo "${ECHO_T}no" >&6
3075 fi
3076
3077 fi
3078 if test -z "$ac_cv_prog_CC"; then
3079   ac_ct_CC=$CC
3080   # Extract the first word of "cc", so it can be a program name with args.
3081 set dummy cc; ac_word=$2
3082 echo "$as_me:$LINENO: checking for $ac_word" >&5
3083 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3084 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3085   echo $ECHO_N "(cached) $ECHO_C" >&6
3086 else
3087   if test -n "$ac_ct_CC"; then
3088   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3089 else
3090 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3091 for as_dir in $PATH
3092 do
3093   IFS=$as_save_IFS
3094   test -z "$as_dir" && as_dir=.
3095   for ac_exec_ext in '' $ac_executable_extensions; do
3096   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3097     ac_cv_prog_ac_ct_CC="cc"
3098     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3099     break 2
3100   fi
3101 done
3102 done
3103
3104 fi
3105 fi
3106 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3107 if test -n "$ac_ct_CC"; then
3108   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3109 echo "${ECHO_T}$ac_ct_CC" >&6
3110 else
3111   echo "$as_me:$LINENO: result: no" >&5
3112 echo "${ECHO_T}no" >&6
3113 fi
3114
3115   CC=$ac_ct_CC
3116 else
3117   CC="$ac_cv_prog_CC"
3118 fi
3119
3120 fi
3121 if test -z "$CC"; then
3122   # Extract the first word of "cc", so it can be a program name with args.
3123 set dummy cc; ac_word=$2
3124 echo "$as_me:$LINENO: checking for $ac_word" >&5
3125 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3126 if test "${ac_cv_prog_CC+set}" = set; then
3127   echo $ECHO_N "(cached) $ECHO_C" >&6
3128 else
3129   if test -n "$CC"; then
3130   ac_cv_prog_CC="$CC" # Let the user override the test.
3131 else
3132   ac_prog_rejected=no
3133 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3134 for as_dir in $PATH
3135 do
3136   IFS=$as_save_IFS
3137   test -z "$as_dir" && as_dir=.
3138   for ac_exec_ext in '' $ac_executable_extensions; do
3139   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3140     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3141        ac_prog_rejected=yes
3142        continue
3143      fi
3144     ac_cv_prog_CC="cc"
3145     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3146     break 2
3147   fi
3148 done
3149 done
3150
3151 if test $ac_prog_rejected = yes; then
3152   # We found a bogon in the path, so make sure we never use it.
3153   set dummy $ac_cv_prog_CC
3154   shift
3155   if test $# != 0; then
3156     # We chose a different compiler from the bogus one.
3157     # However, it has the same basename, so the bogon will be chosen
3158     # first if we set CC to just the basename; use the full file name.
3159     shift
3160     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3161   fi
3162 fi
3163 fi
3164 fi
3165 CC=$ac_cv_prog_CC
3166 if test -n "$CC"; then
3167   echo "$as_me:$LINENO: result: $CC" >&5
3168 echo "${ECHO_T}$CC" >&6
3169 else
3170   echo "$as_me:$LINENO: result: no" >&5
3171 echo "${ECHO_T}no" >&6
3172 fi
3173
3174 fi
3175 if test -z "$CC"; then
3176   if test -n "$ac_tool_prefix"; then
3177   for ac_prog in cl
3178   do
3179     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3180 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3181 echo "$as_me:$LINENO: checking for $ac_word" >&5
3182 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3183 if test "${ac_cv_prog_CC+set}" = set; then
3184   echo $ECHO_N "(cached) $ECHO_C" >&6
3185 else
3186   if test -n "$CC"; then
3187   ac_cv_prog_CC="$CC" # Let the user override the test.
3188 else
3189 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3190 for as_dir in $PATH
3191 do
3192   IFS=$as_save_IFS
3193   test -z "$as_dir" && as_dir=.
3194   for ac_exec_ext in '' $ac_executable_extensions; do
3195   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3196     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3197     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3198     break 2
3199   fi
3200 done
3201 done
3202
3203 fi
3204 fi
3205 CC=$ac_cv_prog_CC
3206 if test -n "$CC"; then
3207   echo "$as_me:$LINENO: result: $CC" >&5
3208 echo "${ECHO_T}$CC" >&6
3209 else
3210   echo "$as_me:$LINENO: result: no" >&5
3211 echo "${ECHO_T}no" >&6
3212 fi
3213
3214     test -n "$CC" && break
3215   done
3216 fi
3217 if test -z "$CC"; then
3218   ac_ct_CC=$CC
3219   for ac_prog in cl
3220 do
3221   # Extract the first word of "$ac_prog", so it can be a program name with args.
3222 set dummy $ac_prog; ac_word=$2
3223 echo "$as_me:$LINENO: checking for $ac_word" >&5
3224 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3225 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3226   echo $ECHO_N "(cached) $ECHO_C" >&6
3227 else
3228   if test -n "$ac_ct_CC"; then
3229   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3230 else
3231 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3232 for as_dir in $PATH
3233 do
3234   IFS=$as_save_IFS
3235   test -z "$as_dir" && as_dir=.
3236   for ac_exec_ext in '' $ac_executable_extensions; do
3237   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3238     ac_cv_prog_ac_ct_CC="$ac_prog"
3239     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3240     break 2
3241   fi
3242 done
3243 done
3244
3245 fi
3246 fi
3247 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3248 if test -n "$ac_ct_CC"; then
3249   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3250 echo "${ECHO_T}$ac_ct_CC" >&6
3251 else
3252   echo "$as_me:$LINENO: result: no" >&5
3253 echo "${ECHO_T}no" >&6
3254 fi
3255
3256   test -n "$ac_ct_CC" && break
3257 done
3258
3259   CC=$ac_ct_CC
3260 fi
3261
3262 fi
3263
3264
3265 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3266 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3267 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3268 See \`config.log' for more details." >&5
3269 echo "$as_me: error: no acceptable C compiler found in \$PATH
3270 See \`config.log' for more details." >&2;}
3271    { (exit 1); exit 1; }; }; }
3272
3273 # Provide some information about the compiler.
3274 echo "$as_me:$LINENO:" \
3275      "checking for C compiler version" >&5
3276 ac_compiler=`set X $ac_compile; echo $2`
3277 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3278   (eval $ac_compiler --version </dev/null >&5) 2>&5
3279   ac_status=$?
3280   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3281   (exit $ac_status); }
3282 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3283   (eval $ac_compiler -v </dev/null >&5) 2>&5
3284   ac_status=$?
3285   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3286   (exit $ac_status); }
3287 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3288   (eval $ac_compiler -V </dev/null >&5) 2>&5
3289   ac_status=$?
3290   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3291   (exit $ac_status); }
3292
3293 cat >conftest.$ac_ext <<_ACEOF
3294 /* confdefs.h.  */
3295 _ACEOF
3296 cat confdefs.h >>conftest.$ac_ext
3297 cat >>conftest.$ac_ext <<_ACEOF
3298 /* end confdefs.h.  */
3299
3300 int
3301 main ()
3302 {
3303
3304   ;
3305   return 0;
3306 }
3307 _ACEOF
3308 ac_clean_files_save=$ac_clean_files
3309 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3310 # Try to create an executable without -o first, disregard a.out.
3311 # It will help us diagnose broken compilers, and finding out an intuition
3312 # of exeext.
3313 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3314 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3315 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3316 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3317   (eval $ac_link_default) 2>&5
3318   ac_status=$?
3319   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3320   (exit $ac_status); }; then
3321   # Find the output, starting from the most likely.  This scheme is
3322 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3323 # resort.
3324
3325 # Be careful to initialize this variable, since it used to be cached.
3326 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3327 ac_cv_exeext=
3328 # b.out is created by i960 compilers.
3329 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3330 do
3331   test -f "$ac_file" || continue
3332   case $ac_file in
3333     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3334         ;;
3335     conftest.$ac_ext )
3336         # This is the source file.
3337         ;;
3338     [ab].out )
3339         # We found the default executable, but exeext='' is most
3340         # certainly right.
3341         break;;
3342     *.* )
3343         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3344         # FIXME: I believe we export ac_cv_exeext for Libtool,
3345         # but it would be cool to find out if it's true.  Does anybody
3346         # maintain Libtool? --akim.
3347         export ac_cv_exeext
3348         break;;
3349     * )
3350         break;;
3351   esac
3352 done
3353 else
3354   echo "$as_me: failed program was:" >&5
3355 sed 's/^/| /' conftest.$ac_ext >&5
3356
3357 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3358 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3359 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3360 See \`config.log' for more details." >&5
3361 echo "$as_me: error: C compiler cannot create executables
3362 See \`config.log' for more details." >&2;}
3363    { (exit 77); exit 77; }; }; }
3364 fi
3365
3366 ac_exeext=$ac_cv_exeext
3367 echo "$as_me:$LINENO: result: $ac_file" >&5
3368 echo "${ECHO_T}$ac_file" >&6
3369
3370 # Check the compiler produces executables we can run.  If not, either
3371 # the compiler is broken, or we cross compile.
3372 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3373 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3374 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3375 # If not cross compiling, check that we can run a simple program.
3376 if test "$cross_compiling" != yes; then
3377   if { ac_try='./$ac_file'
3378   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3379   (eval $ac_try) 2>&5
3380   ac_status=$?
3381   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3382   (exit $ac_status); }; }; then
3383     cross_compiling=no
3384   else
3385     if test "$cross_compiling" = maybe; then
3386         cross_compiling=yes
3387     else
3388         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3389 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3390 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3391 If you meant to cross compile, use \`--host'.
3392 See \`config.log' for more details." >&5
3393 echo "$as_me: error: cannot run C compiled programs.
3394 If you meant to cross compile, use \`--host'.
3395 See \`config.log' for more details." >&2;}
3396    { (exit 1); exit 1; }; }; }
3397     fi
3398   fi
3399 fi
3400 echo "$as_me:$LINENO: result: yes" >&5
3401 echo "${ECHO_T}yes" >&6
3402
3403 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3404 ac_clean_files=$ac_clean_files_save
3405 # Check the compiler produces executables we can run.  If not, either
3406 # the compiler is broken, or we cross compile.
3407 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3408 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3409 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3410 echo "${ECHO_T}$cross_compiling" >&6
3411
3412 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3413 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3414 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3415   (eval $ac_link) 2>&5
3416   ac_status=$?
3417   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3418   (exit $ac_status); }; then
3419   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3420 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3421 # work properly (i.e., refer to `conftest.exe'), while it won't with
3422 # `rm'.
3423 for ac_file in conftest.exe conftest conftest.*; do
3424   test -f "$ac_file" || continue
3425   case $ac_file in
3426     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3427     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3428           export ac_cv_exeext
3429           break;;
3430     * ) break;;
3431   esac
3432 done
3433 else
3434   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3435 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3436 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3437 See \`config.log' for more details." >&5
3438 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3439 See \`config.log' for more details." >&2;}
3440    { (exit 1); exit 1; }; }; }
3441 fi
3442
3443 rm -f conftest$ac_cv_exeext
3444 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3445 echo "${ECHO_T}$ac_cv_exeext" >&6
3446
3447 rm -f conftest.$ac_ext
3448 EXEEXT=$ac_cv_exeext
3449 ac_exeext=$EXEEXT
3450 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3451 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3452 if test "${ac_cv_objext+set}" = set; then
3453   echo $ECHO_N "(cached) $ECHO_C" >&6
3454 else
3455   cat >conftest.$ac_ext <<_ACEOF
3456 /* confdefs.h.  */
3457 _ACEOF
3458 cat confdefs.h >>conftest.$ac_ext
3459 cat >>conftest.$ac_ext <<_ACEOF
3460 /* end confdefs.h.  */
3461
3462 int
3463 main ()
3464 {
3465
3466   ;
3467   return 0;
3468 }
3469 _ACEOF
3470 rm -f conftest.o conftest.obj
3471 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3472   (eval $ac_compile) 2>&5
3473   ac_status=$?
3474   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3475   (exit $ac_status); }; then
3476   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3477   case $ac_file in
3478     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3479     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3480        break;;
3481   esac
3482 done
3483 else
3484   echo "$as_me: failed program was:" >&5
3485 sed 's/^/| /' conftest.$ac_ext >&5
3486
3487 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3488 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3489 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3490 See \`config.log' for more details." >&5
3491 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3492 See \`config.log' for more details." >&2;}
3493    { (exit 1); exit 1; }; }; }
3494 fi
3495
3496 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3497 fi
3498 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3499 echo "${ECHO_T}$ac_cv_objext" >&6
3500 OBJEXT=$ac_cv_objext
3501 ac_objext=$OBJEXT
3502 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3503 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3504 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3505   echo $ECHO_N "(cached) $ECHO_C" >&6
3506 else
3507   cat >conftest.$ac_ext <<_ACEOF
3508 /* confdefs.h.  */
3509 _ACEOF
3510 cat confdefs.h >>conftest.$ac_ext
3511 cat >>conftest.$ac_ext <<_ACEOF
3512 /* end confdefs.h.  */
3513
3514 int
3515 main ()
3516 {
3517 #ifndef __GNUC__
3518        choke me
3519 #endif
3520
3521   ;
3522   return 0;
3523 }
3524 _ACEOF
3525 rm -f conftest.$ac_objext
3526 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3527   (eval $ac_compile) 2>conftest.er1
3528   ac_status=$?
3529   grep -v '^ *+' conftest.er1 >conftest.err
3530   rm -f conftest.er1
3531   cat conftest.err >&5
3532   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3533   (exit $ac_status); } &&
3534          { ac_try='test -z "$ac_c_werror_flag"
3535                          || test ! -s conftest.err'
3536   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3537   (eval $ac_try) 2>&5
3538   ac_status=$?
3539   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3540   (exit $ac_status); }; } &&
3541          { ac_try='test -s conftest.$ac_objext'
3542   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3543   (eval $ac_try) 2>&5
3544   ac_status=$?
3545   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3546   (exit $ac_status); }; }; then
3547   ac_compiler_gnu=yes
3548 else
3549   echo "$as_me: failed program was:" >&5
3550 sed 's/^/| /' conftest.$ac_ext >&5
3551
3552 ac_compiler_gnu=no
3553 fi
3554 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3555 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3556
3557 fi
3558 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3559 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3560 GCC=`test $ac_compiler_gnu = yes && echo yes`
3561 ac_test_CFLAGS=${CFLAGS+set}
3562 ac_save_CFLAGS=$CFLAGS
3563 CFLAGS="-g"
3564 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3565 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3566 if test "${ac_cv_prog_cc_g+set}" = set; then
3567   echo $ECHO_N "(cached) $ECHO_C" >&6
3568 else
3569   cat >conftest.$ac_ext <<_ACEOF
3570 /* confdefs.h.  */
3571 _ACEOF
3572 cat confdefs.h >>conftest.$ac_ext
3573 cat >>conftest.$ac_ext <<_ACEOF
3574 /* end confdefs.h.  */
3575
3576 int
3577 main ()
3578 {
3579
3580   ;
3581   return 0;
3582 }
3583 _ACEOF
3584 rm -f conftest.$ac_objext
3585 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3586   (eval $ac_compile) 2>conftest.er1
3587   ac_status=$?
3588   grep -v '^ *+' conftest.er1 >conftest.err
3589   rm -f conftest.er1
3590   cat conftest.err >&5
3591   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3592   (exit $ac_status); } &&
3593          { ac_try='test -z "$ac_c_werror_flag"
3594                          || test ! -s conftest.err'
3595   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3596   (eval $ac_try) 2>&5
3597   ac_status=$?
3598   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3599   (exit $ac_status); }; } &&
3600          { ac_try='test -s conftest.$ac_objext'
3601   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3602   (eval $ac_try) 2>&5
3603   ac_status=$?
3604   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3605   (exit $ac_status); }; }; then
3606   ac_cv_prog_cc_g=yes
3607 else
3608   echo "$as_me: failed program was:" >&5
3609 sed 's/^/| /' conftest.$ac_ext >&5
3610
3611 ac_cv_prog_cc_g=no
3612 fi
3613 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3614 fi
3615 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3616 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3617 if test "$ac_test_CFLAGS" = set; then
3618   CFLAGS=$ac_save_CFLAGS
3619 elif test $ac_cv_prog_cc_g = yes; then
3620   if test "$GCC" = yes; then
3621     CFLAGS="-g -O2"
3622   else
3623     CFLAGS="-g"
3624   fi
3625 else
3626   if test "$GCC" = yes; then
3627     CFLAGS="-O2"
3628   else
3629     CFLAGS=
3630   fi
3631 fi
3632 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3633 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3634 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3635   echo $ECHO_N "(cached) $ECHO_C" >&6
3636 else
3637   ac_cv_prog_cc_stdc=no
3638 ac_save_CC=$CC
3639 cat >conftest.$ac_ext <<_ACEOF
3640 /* confdefs.h.  */
3641 _ACEOF
3642 cat confdefs.h >>conftest.$ac_ext
3643 cat >>conftest.$ac_ext <<_ACEOF
3644 /* end confdefs.h.  */
3645 #include <stdarg.h>
3646 #include <stdio.h>
3647 #include <sys/types.h>
3648 #include <sys/stat.h>
3649 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3650 struct buf { int x; };
3651 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3652 static char *e (p, i)
3653      char **p;
3654      int i;
3655 {
3656   return p[i];
3657 }
3658 static char *f (char * (*g) (char **, int), char **p, ...)
3659 {
3660   char *s;
3661   va_list v;
3662   va_start (v,p);
3663   s = g (p, va_arg (v,int));
3664   va_end (v);
3665   return s;
3666 }
3667
3668 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3669    function prototypes and stuff, but not '\xHH' hex character constants.
3670    These don't provoke an error unfortunately, instead are silently treated
3671    as 'x'.  The following induces an error, until -std1 is added to get
3672    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3673    array size at least.  It's necessary to write '\x00'==0 to get something
3674    that's true only with -std1.  */
3675 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3676
3677 int test (int i, double x);
3678 struct s1 {int (*f) (int a);};
3679 struct s2 {int (*f) (double a);};
3680 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3681 int argc;
3682 char **argv;
3683 int
3684 main ()
3685 {
3686 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3687   ;
3688   return 0;
3689 }
3690 _ACEOF
3691 # Don't try gcc -ansi; that turns off useful extensions and
3692 # breaks some systems' header files.
3693 # AIX                   -qlanglvl=ansi
3694 # Ultrix and OSF/1      -std1
3695 # HP-UX 10.20 and later -Ae
3696 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3697 # SVR4                  -Xc -D__EXTENSIONS__
3698 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3699 do
3700   CC="$ac_save_CC $ac_arg"
3701   rm -f conftest.$ac_objext
3702 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3703   (eval $ac_compile) 2>conftest.er1
3704   ac_status=$?
3705   grep -v '^ *+' conftest.er1 >conftest.err
3706   rm -f conftest.er1
3707   cat conftest.err >&5
3708   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3709   (exit $ac_status); } &&
3710          { ac_try='test -z "$ac_c_werror_flag"
3711                          || test ! -s conftest.err'
3712   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3713   (eval $ac_try) 2>&5
3714   ac_status=$?
3715   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3716   (exit $ac_status); }; } &&
3717          { ac_try='test -s conftest.$ac_objext'
3718   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3719   (eval $ac_try) 2>&5
3720   ac_status=$?
3721   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3722   (exit $ac_status); }; }; then
3723   ac_cv_prog_cc_stdc=$ac_arg
3724 break
3725 else
3726   echo "$as_me: failed program was:" >&5
3727 sed 's/^/| /' conftest.$ac_ext >&5
3728
3729 fi
3730 rm -f conftest.err conftest.$ac_objext
3731 done
3732 rm -f conftest.$ac_ext conftest.$ac_objext
3733 CC=$ac_save_CC
3734
3735 fi
3736
3737 case "x$ac_cv_prog_cc_stdc" in
3738   x|xno)
3739     echo "$as_me:$LINENO: result: none needed" >&5
3740 echo "${ECHO_T}none needed" >&6 ;;
3741   *)
3742     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3743 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3744     CC="$CC $ac_cv_prog_cc_stdc" ;;
3745 esac
3746
3747 # Some people use a C++ compiler to compile C.  Since we use `exit',
3748 # in C++ we need to declare it.  In case someone uses the same compiler
3749 # for both compiling C and C++ we need to have the C++ compiler decide
3750 # the declaration of exit, since it's the most demanding environment.
3751 cat >conftest.$ac_ext <<_ACEOF
3752 #ifndef __cplusplus
3753   choke me
3754 #endif
3755 _ACEOF
3756 rm -f conftest.$ac_objext
3757 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3758   (eval $ac_compile) 2>conftest.er1
3759   ac_status=$?
3760   grep -v '^ *+' conftest.er1 >conftest.err
3761   rm -f conftest.er1
3762   cat conftest.err >&5
3763   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3764   (exit $ac_status); } &&
3765          { ac_try='test -z "$ac_c_werror_flag"
3766                          || test ! -s conftest.err'
3767   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3768   (eval $ac_try) 2>&5
3769   ac_status=$?
3770   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3771   (exit $ac_status); }; } &&
3772          { ac_try='test -s conftest.$ac_objext'
3773   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3774   (eval $ac_try) 2>&5
3775   ac_status=$?
3776   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3777   (exit $ac_status); }; }; then
3778   for ac_declaration in \
3779    '' \
3780    'extern "C" void std::exit (int) throw (); using std::exit;' \
3781    'extern "C" void std::exit (int); using std::exit;' \
3782    'extern "C" void exit (int) throw ();' \
3783    'extern "C" void exit (int);' \
3784    'void exit (int);'
3785 do
3786   cat >conftest.$ac_ext <<_ACEOF
3787 /* confdefs.h.  */
3788 _ACEOF
3789 cat confdefs.h >>conftest.$ac_ext
3790 cat >>conftest.$ac_ext <<_ACEOF
3791 /* end confdefs.h.  */
3792 $ac_declaration
3793 #include <stdlib.h>
3794 int
3795 main ()
3796 {
3797 exit (42);
3798   ;
3799   return 0;
3800 }
3801 _ACEOF
3802 rm -f conftest.$ac_objext
3803 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3804   (eval $ac_compile) 2>conftest.er1
3805   ac_status=$?
3806   grep -v '^ *+' conftest.er1 >conftest.err
3807   rm -f conftest.er1
3808   cat conftest.err >&5
3809   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3810   (exit $ac_status); } &&
3811          { ac_try='test -z "$ac_c_werror_flag"
3812                          || test ! -s conftest.err'
3813   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3814   (eval $ac_try) 2>&5
3815   ac_status=$?
3816   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3817   (exit $ac_status); }; } &&
3818          { ac_try='test -s conftest.$ac_objext'
3819   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3820   (eval $ac_try) 2>&5
3821   ac_status=$?
3822   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3823   (exit $ac_status); }; }; then
3824   :
3825 else
3826   echo "$as_me: failed program was:" >&5
3827 sed 's/^/| /' conftest.$ac_ext >&5
3828
3829 continue
3830 fi
3831 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3832   cat >conftest.$ac_ext <<_ACEOF
3833 /* confdefs.h.  */
3834 _ACEOF
3835 cat confdefs.h >>conftest.$ac_ext
3836 cat >>conftest.$ac_ext <<_ACEOF
3837 /* end confdefs.h.  */
3838 $ac_declaration
3839 int
3840 main ()
3841 {
3842 exit (42);
3843   ;
3844   return 0;
3845 }
3846 _ACEOF
3847 rm -f conftest.$ac_objext
3848 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3849   (eval $ac_compile) 2>conftest.er1
3850   ac_status=$?
3851   grep -v '^ *+' conftest.er1 >conftest.err
3852   rm -f conftest.er1
3853   cat conftest.err >&5
3854   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3855   (exit $ac_status); } &&
3856          { ac_try='test -z "$ac_c_werror_flag"
3857                          || test ! -s conftest.err'
3858   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3859   (eval $ac_try) 2>&5
3860   ac_status=$?
3861   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3862   (exit $ac_status); }; } &&
3863          { ac_try='test -s conftest.$ac_objext'
3864   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3865   (eval $ac_try) 2>&5
3866   ac_status=$?
3867   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3868   (exit $ac_status); }; }; then
3869   break
3870 else
3871   echo "$as_me: failed program was:" >&5
3872 sed 's/^/| /' conftest.$ac_ext >&5
3873
3874 fi
3875 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3876 done
3877 rm -f conftest*
3878 if test -n "$ac_declaration"; then
3879   echo '#ifdef __cplusplus' >>confdefs.h
3880   echo $ac_declaration      >>confdefs.h
3881   echo '#endif'             >>confdefs.h
3882 fi
3883
3884 else
3885   echo "$as_me: failed program was:" >&5
3886 sed 's/^/| /' conftest.$ac_ext >&5
3887
3888 fi
3889 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3890 ac_ext=c
3891 ac_cpp='$CPP $CPPFLAGS'
3892 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3893 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3894 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3895
3896 ac_ext=cc
3897 ac_cpp='$CXXCPP $CPPFLAGS'
3898 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3899 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3900 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3901 if test -n "$ac_tool_prefix"; then
3902   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3903   do
3904     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3905 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3906 echo "$as_me:$LINENO: checking for $ac_word" >&5
3907 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3908 if test "${ac_cv_prog_CXX+set}" = set; then
3909   echo $ECHO_N "(cached) $ECHO_C" >&6
3910 else
3911   if test -n "$CXX"; then
3912   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3913 else
3914 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3915 for as_dir in $PATH
3916 do
3917   IFS=$as_save_IFS
3918   test -z "$as_dir" && as_dir=.
3919   for ac_exec_ext in '' $ac_executable_extensions; do
3920   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3921     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3922     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3923     break 2
3924   fi
3925 done
3926 done
3927
3928 fi
3929 fi
3930 CXX=$ac_cv_prog_CXX
3931 if test -n "$CXX"; then
3932   echo "$as_me:$LINENO: result: $CXX" >&5
3933 echo "${ECHO_T}$CXX" >&6
3934 else
3935   echo "$as_me:$LINENO: result: no" >&5
3936 echo "${ECHO_T}no" >&6
3937 fi
3938
3939     test -n "$CXX" && break
3940   done
3941 fi
3942 if test -z "$CXX"; then
3943   ac_ct_CXX=$CXX
3944   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3945 do
3946   # Extract the first word of "$ac_prog", so it can be a program name with args.
3947 set dummy $ac_prog; ac_word=$2
3948 echo "$as_me:$LINENO: checking for $ac_word" >&5
3949 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3950 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3951   echo $ECHO_N "(cached) $ECHO_C" >&6
3952 else
3953   if test -n "$ac_ct_CXX"; then
3954   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3955 else
3956 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3957 for as_dir in $PATH
3958 do
3959   IFS=$as_save_IFS
3960   test -z "$as_dir" && as_dir=.
3961   for ac_exec_ext in '' $ac_executable_extensions; do
3962   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3963     ac_cv_prog_ac_ct_CXX="$ac_prog"
3964     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3965     break 2
3966   fi
3967 done
3968 done
3969
3970 fi
3971 fi
3972 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3973 if test -n "$ac_ct_CXX"; then
3974   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3975 echo "${ECHO_T}$ac_ct_CXX" >&6
3976 else
3977   echo "$as_me:$LINENO: result: no" >&5
3978 echo "${ECHO_T}no" >&6
3979 fi
3980
3981   test -n "$ac_ct_CXX" && break
3982 done
3983 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3984
3985   CXX=$ac_ct_CXX
3986 fi
3987
3988
3989 # Provide some information about the compiler.
3990 echo "$as_me:$LINENO:" \
3991      "checking for C++ compiler version" >&5
3992 ac_compiler=`set X $ac_compile; echo $2`
3993 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3994   (eval $ac_compiler --version </dev/null >&5) 2>&5
3995   ac_status=$?
3996   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3997   (exit $ac_status); }
3998 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3999   (eval $ac_compiler -v </dev/null >&5) 2>&5
4000   ac_status=$?
4001   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4002   (exit $ac_status); }
4003 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4004   (eval $ac_compiler -V </dev/null >&5) 2>&5
4005   ac_status=$?
4006   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4007   (exit $ac_status); }
4008
4009 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4010 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4011 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4012   echo $ECHO_N "(cached) $ECHO_C" >&6
4013 else
4014   cat >conftest.$ac_ext <<_ACEOF
4015 /* confdefs.h.  */
4016 _ACEOF
4017 cat confdefs.h >>conftest.$ac_ext
4018 cat >>conftest.$ac_ext <<_ACEOF
4019 /* end confdefs.h.  */
4020
4021 int
4022 main ()
4023 {
4024 #ifndef __GNUC__
4025        choke me
4026 #endif
4027
4028   ;
4029   return 0;
4030 }
4031 _ACEOF
4032 rm -f conftest.$ac_objext
4033 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4034   (eval $ac_compile) 2>conftest.er1
4035   ac_status=$?
4036   grep -v '^ *+' conftest.er1 >conftest.err
4037   rm -f conftest.er1
4038   cat conftest.err >&5
4039   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4040   (exit $ac_status); } &&
4041          { ac_try='test -z "$ac_cxx_werror_flag"
4042                          || test ! -s conftest.err'
4043   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4044   (eval $ac_try) 2>&5
4045   ac_status=$?
4046   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4047   (exit $ac_status); }; } &&
4048          { ac_try='test -s conftest.$ac_objext'
4049   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4050   (eval $ac_try) 2>&5
4051   ac_status=$?
4052   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4053   (exit $ac_status); }; }; then
4054   ac_compiler_gnu=yes
4055 else
4056   echo "$as_me: failed program was:" >&5
4057 sed 's/^/| /' conftest.$ac_ext >&5
4058
4059 ac_compiler_gnu=no
4060 fi
4061 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4062 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4063
4064 fi
4065 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4066 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4067 GXX=`test $ac_compiler_gnu = yes && echo yes`
4068 ac_test_CXXFLAGS=${CXXFLAGS+set}
4069 ac_save_CXXFLAGS=$CXXFLAGS
4070 CXXFLAGS="-g"
4071 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4072 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4073 if test "${ac_cv_prog_cxx_g+set}" = set; then
4074   echo $ECHO_N "(cached) $ECHO_C" >&6
4075 else
4076   cat >conftest.$ac_ext <<_ACEOF
4077 /* confdefs.h.  */
4078 _ACEOF
4079 cat confdefs.h >>conftest.$ac_ext
4080 cat >>conftest.$ac_ext <<_ACEOF
4081 /* end confdefs.h.  */
4082
4083 int
4084 main ()
4085 {
4086
4087   ;
4088   return 0;
4089 }
4090 _ACEOF
4091 rm -f conftest.$ac_objext
4092 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4093   (eval $ac_compile) 2>conftest.er1
4094   ac_status=$?
4095   grep -v '^ *+' conftest.er1 >conftest.err
4096   rm -f conftest.er1
4097   cat conftest.err >&5
4098   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4099   (exit $ac_status); } &&
4100          { ac_try='test -z "$ac_cxx_werror_flag"
4101                          || test ! -s conftest.err'
4102   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4103   (eval $ac_try) 2>&5
4104   ac_status=$?
4105   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4106   (exit $ac_status); }; } &&
4107          { ac_try='test -s conftest.$ac_objext'
4108   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4109   (eval $ac_try) 2>&5
4110   ac_status=$?
4111   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4112   (exit $ac_status); }; }; then
4113   ac_cv_prog_cxx_g=yes
4114 else
4115   echo "$as_me: failed program was:" >&5
4116 sed 's/^/| /' conftest.$ac_ext >&5
4117
4118 ac_cv_prog_cxx_g=no
4119 fi
4120 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4121 fi
4122 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4123 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4124 if test "$ac_test_CXXFLAGS" = set; then
4125   CXXFLAGS=$ac_save_CXXFLAGS
4126 elif test $ac_cv_prog_cxx_g = yes; then
4127   if test "$GXX" = yes; then
4128     CXXFLAGS="-g -O2"
4129   else
4130     CXXFLAGS="-g"
4131   fi
4132 else
4133   if test "$GXX" = yes; then
4134     CXXFLAGS="-O2"
4135   else
4136     CXXFLAGS=
4137   fi
4138 fi
4139 for ac_declaration in \
4140    '' \
4141    'extern "C" void std::exit (int) throw (); using std::exit;' \
4142    'extern "C" void std::exit (int); using std::exit;' \
4143    'extern "C" void exit (int) throw ();' \
4144    'extern "C" void exit (int);' \
4145    'void exit (int);'
4146 do
4147   cat >conftest.$ac_ext <<_ACEOF
4148 /* confdefs.h.  */
4149 _ACEOF
4150 cat confdefs.h >>conftest.$ac_ext
4151 cat >>conftest.$ac_ext <<_ACEOF
4152 /* end confdefs.h.  */
4153 $ac_declaration
4154 #include <stdlib.h>
4155 int
4156 main ()
4157 {
4158 exit (42);
4159   ;
4160   return 0;
4161 }
4162 _ACEOF
4163 rm -f conftest.$ac_objext
4164 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4165   (eval $ac_compile) 2>conftest.er1
4166   ac_status=$?
4167   grep -v '^ *+' conftest.er1 >conftest.err
4168   rm -f conftest.er1
4169   cat conftest.err >&5
4170   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4171   (exit $ac_status); } &&
4172          { ac_try='test -z "$ac_cxx_werror_flag"
4173                          || test ! -s conftest.err'
4174   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4175   (eval $ac_try) 2>&5
4176   ac_status=$?
4177   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4178   (exit $ac_status); }; } &&
4179          { ac_try='test -s conftest.$ac_objext'
4180   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4181   (eval $ac_try) 2>&5
4182   ac_status=$?
4183   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4184   (exit $ac_status); }; }; then
4185   :
4186 else
4187   echo "$as_me: failed program was:" >&5
4188 sed 's/^/| /' conftest.$ac_ext >&5
4189
4190 continue
4191 fi
4192 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4193   cat >conftest.$ac_ext <<_ACEOF
4194 /* confdefs.h.  */
4195 _ACEOF
4196 cat confdefs.h >>conftest.$ac_ext
4197 cat >>conftest.$ac_ext <<_ACEOF
4198 /* end confdefs.h.  */
4199 $ac_declaration
4200 int
4201 main ()
4202 {
4203 exit (42);
4204   ;
4205   return 0;
4206 }
4207 _ACEOF
4208 rm -f conftest.$ac_objext
4209 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4210   (eval $ac_compile) 2>conftest.er1
4211   ac_status=$?
4212   grep -v '^ *+' conftest.er1 >conftest.err
4213   rm -f conftest.er1
4214   cat conftest.err >&5
4215   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4216   (exit $ac_status); } &&
4217          { ac_try='test -z "$ac_cxx_werror_flag"
4218                          || test ! -s conftest.err'
4219   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4220   (eval $ac_try) 2>&5
4221   ac_status=$?
4222   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4223   (exit $ac_status); }; } &&
4224          { ac_try='test -s conftest.$ac_objext'
4225   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4226   (eval $ac_try) 2>&5
4227   ac_status=$?
4228   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4229   (exit $ac_status); }; }; then
4230   break
4231 else
4232   echo "$as_me: failed program was:" >&5
4233 sed 's/^/| /' conftest.$ac_ext >&5
4234
4235 fi
4236 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4237 done
4238 rm -f conftest*
4239 if test -n "$ac_declaration"; then
4240   echo '#ifdef __cplusplus' >>confdefs.h
4241   echo $ac_declaration      >>confdefs.h
4242   echo '#endif'             >>confdefs.h
4243 fi
4244
4245 ac_ext=c
4246 ac_cpp='$CPP $CPPFLAGS'
4247 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4248 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4249 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4250
4251
4252 # We must set the default linker to the linker used by gcc for the correct
4253 # operation of libtool.  If LD is not defined and we are using gcc, try to
4254 # set the LD default to the ld used by gcc.
4255 if test -z "$LD"; then
4256   if test "$GCC" = yes; then
4257     case $build in
4258     *-*-mingw*)
4259       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4260     *)
4261       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4262     esac
4263     case $gcc_prog_ld in
4264     # Accept absolute paths.
4265     [\\/]* | [A-Za-z]:[\\/]*)
4266       LD="$gcc_prog_ld" ;;
4267     esac
4268   fi
4269 fi
4270
4271
4272
4273
4274 if test -n "$ac_tool_prefix"; then
4275   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4276 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4277 echo "$as_me:$LINENO: checking for $ac_word" >&5
4278 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4279 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4280   echo $ECHO_N "(cached) $ECHO_C" >&6
4281 else
4282   if test -n "$GNATBIND"; then
4283   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4284 else
4285 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4286 for as_dir in $PATH
4287 do
4288   IFS=$as_save_IFS
4289   test -z "$as_dir" && as_dir=.
4290   for ac_exec_ext in '' $ac_executable_extensions; do
4291   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4292     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4293     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4294     break 2
4295   fi
4296 done
4297 done
4298
4299 fi
4300 fi
4301 GNATBIND=$ac_cv_prog_GNATBIND
4302 if test -n "$GNATBIND"; then
4303   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4304 echo "${ECHO_T}$GNATBIND" >&6
4305 else
4306   echo "$as_me:$LINENO: result: no" >&5
4307 echo "${ECHO_T}no" >&6
4308 fi
4309
4310 fi
4311 if test -z "$ac_cv_prog_GNATBIND"; then
4312   ac_ct_GNATBIND=$GNATBIND
4313   # Extract the first word of "gnatbind", so it can be a program name with args.
4314 set dummy gnatbind; ac_word=$2
4315 echo "$as_me:$LINENO: checking for $ac_word" >&5
4316 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4317 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4318   echo $ECHO_N "(cached) $ECHO_C" >&6
4319 else
4320   if test -n "$ac_ct_GNATBIND"; then
4321   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4322 else
4323 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4324 for as_dir in $PATH
4325 do
4326   IFS=$as_save_IFS
4327   test -z "$as_dir" && as_dir=.
4328   for ac_exec_ext in '' $ac_executable_extensions; do
4329   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4330     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4331     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4332     break 2
4333   fi
4334 done
4335 done
4336
4337   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4338 fi
4339 fi
4340 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4341 if test -n "$ac_ct_GNATBIND"; then
4342   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4343 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4344 else
4345   echo "$as_me:$LINENO: result: no" >&5
4346 echo "${ECHO_T}no" >&6
4347 fi
4348
4349   GNATBIND=$ac_ct_GNATBIND
4350 else
4351   GNATBIND="$ac_cv_prog_GNATBIND"
4352 fi
4353
4354 if test -n "$ac_tool_prefix"; then
4355   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4356 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4357 echo "$as_me:$LINENO: checking for $ac_word" >&5
4358 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4359 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4360   echo $ECHO_N "(cached) $ECHO_C" >&6
4361 else
4362   if test -n "$GNATMAKE"; then
4363   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4364 else
4365 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4366 for as_dir in $PATH
4367 do
4368   IFS=$as_save_IFS
4369   test -z "$as_dir" && as_dir=.
4370   for ac_exec_ext in '' $ac_executable_extensions; do
4371   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4372     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4373     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4374     break 2
4375   fi
4376 done
4377 done
4378
4379 fi
4380 fi
4381 GNATMAKE=$ac_cv_prog_GNATMAKE
4382 if test -n "$GNATMAKE"; then
4383   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4384 echo "${ECHO_T}$GNATMAKE" >&6
4385 else
4386   echo "$as_me:$LINENO: result: no" >&5
4387 echo "${ECHO_T}no" >&6
4388 fi
4389
4390 fi
4391 if test -z "$ac_cv_prog_GNATMAKE"; then
4392   ac_ct_GNATMAKE=$GNATMAKE
4393   # Extract the first word of "gnatmake", so it can be a program name with args.
4394 set dummy gnatmake; ac_word=$2
4395 echo "$as_me:$LINENO: checking for $ac_word" >&5
4396 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4397 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4398   echo $ECHO_N "(cached) $ECHO_C" >&6
4399 else
4400   if test -n "$ac_ct_GNATMAKE"; then
4401   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4402 else
4403 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4404 for as_dir in $PATH
4405 do
4406   IFS=$as_save_IFS
4407   test -z "$as_dir" && as_dir=.
4408   for ac_exec_ext in '' $ac_executable_extensions; do
4409   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4410     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4411     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4412     break 2
4413   fi
4414 done
4415 done
4416
4417   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4418 fi
4419 fi
4420 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4421 if test -n "$ac_ct_GNATMAKE"; then
4422   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4423 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4424 else
4425   echo "$as_me:$LINENO: result: no" >&5
4426 echo "${ECHO_T}no" >&6
4427 fi
4428
4429   GNATMAKE=$ac_ct_GNATMAKE
4430 else
4431   GNATMAKE="$ac_cv_prog_GNATMAKE"
4432 fi
4433
4434 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4435 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4436 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4437   echo $ECHO_N "(cached) $ECHO_C" >&6
4438 else
4439   cat >conftest.adb <<EOF
4440 procedure conftest is begin null; end conftest;
4441 EOF
4442 acx_cv_cc_gcc_supports_ada=no
4443 # There is a bug in old released versions of GCC which causes the
4444 # driver to exit successfully when the appropriate language module
4445 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4446 # Therefore we must check for the error message as well as an
4447 # unsuccessful exit.
4448 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4449 # given a .adb file, but produce no object file.  So we must check
4450 # if an object file was really produced to guard against this.
4451 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4452 if test x"$errors" = x && test -f conftest.$ac_objext; then
4453   acx_cv_cc_gcc_supports_ada=yes
4454 fi
4455 rm -f conftest.*
4456 fi
4457 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4458 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4459
4460 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4461   have_gnat=yes
4462 else
4463   have_gnat=no
4464 fi
4465
4466 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4467 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4468 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4469   echo $ECHO_N "(cached) $ECHO_C" >&6
4470 else
4471    echo abfoo >t1
4472   echo cdfoo >t2
4473   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4474   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4475     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4476       :
4477     else
4478       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4479     fi
4480   fi
4481   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4482     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4483       :
4484     else
4485       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4486     fi
4487   fi
4488   rm t1 t2
4489
4490 fi
4491 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4492 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4493 do_compare="$gcc_cv_prog_cmp_skip"
4494
4495
4496
4497 # Check for GMP and MPFR
4498 gmplibs="-lmpfr -lgmp"
4499 gmpinc=
4500 have_gmp=no
4501
4502 # Specify a location for mpfr
4503 # check for this first so it ends up on the link line before gmp.
4504
4505 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4506 if test "${with_mpfr_dir+set}" = set; then
4507   withval="$with_mpfr_dir"
4508   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4509 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4510 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4511 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4512    { (exit 1); exit 1; }; }
4513 fi;
4514
4515
4516 # Check whether --with-mpfr or --without-mpfr was given.
4517 if test "${with_mpfr+set}" = set; then
4518   withval="$with_mpfr"
4519
4520 fi;
4521
4522 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4523 if test "${with_mpfr_include+set}" = set; then
4524   withval="$with_mpfr_include"
4525
4526 fi;
4527
4528 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4529 if test "${with_mpfr_lib+set}" = set; then
4530   withval="$with_mpfr_lib"
4531
4532 fi;
4533
4534 if test "x$with_mpfr" != x; then
4535   gmplibs="-L$with_mpfr/lib $gmplibs"
4536   gmpinc="-I$with_mpfr/include"
4537 fi
4538 if test "x$with_mpfr_include" != x; then
4539   gmpinc="-I$with_mpfr_include"
4540 fi
4541 if test "x$with_mpfr_lib" != x; then
4542   gmplibs="-L$with_mpfr_lib $gmplibs"
4543 fi
4544 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4545   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4546   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4547   # Do not test the mpfr version.  Assume that it is sufficient, since
4548   # it is in the source tree, and the library has not been built yet
4549   # but it would be included on the link line in the version check below
4550   # hence making the test fail.
4551   have_gmp=yes
4552 fi
4553
4554 # Specify a location for gmp
4555
4556 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4557 if test "${with_gmp_dir+set}" = set; then
4558   withval="$with_gmp_dir"
4559   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4560 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4561 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4562 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4563    { (exit 1); exit 1; }; }
4564 fi;
4565
4566
4567 # Check whether --with-gmp or --without-gmp was given.
4568 if test "${with_gmp+set}" = set; then
4569   withval="$with_gmp"
4570
4571 fi;
4572
4573 # Check whether --with-gmp_include or --without-gmp_include was given.
4574 if test "${with_gmp_include+set}" = set; then
4575   withval="$with_gmp_include"
4576
4577 fi;
4578
4579 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4580 if test "${with_gmp_lib+set}" = set; then
4581   withval="$with_gmp_lib"
4582
4583 fi;
4584
4585
4586 if test "x$with_gmp" != x; then
4587   gmplibs="-L$with_gmp/lib $gmplibs"
4588   gmpinc="-I$with_gmp/include $gmpinc"
4589 fi
4590 if test "x$with_gmp_include" != x; then
4591   gmpinc="-I$with_gmp_include $gmpinc"
4592 fi
4593 if test "x$with_gmp_lib" != x; then
4594   gmplibs="-L$with_gmp_lib $gmplibs"
4595 fi
4596 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4597   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4598   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4599   # Do not test the gmp version.  Assume that it is sufficient, since
4600   # it is in the source tree, and the library has not been built yet
4601   # but it would be included on the link line in the version check below
4602   # hence making the test fail.
4603   have_gmp=yes
4604 fi
4605
4606 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4607   have_gmp=yes
4608   saved_CFLAGS="$CFLAGS"
4609   CFLAGS="$CFLAGS $gmpinc"
4610   # Check GMP actually works
4611   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4612 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4613
4614 cat >conftest.$ac_ext <<_ACEOF
4615 /* confdefs.h.  */
4616 _ACEOF
4617 cat confdefs.h >>conftest.$ac_ext
4618 cat >>conftest.$ac_ext <<_ACEOF
4619 /* end confdefs.h.  */
4620 #include "gmp.h"
4621 int
4622 main ()
4623 {
4624
4625   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 2)
4626   choke me
4627   #endif
4628
4629   ;
4630   return 0;
4631 }
4632 _ACEOF
4633 rm -f conftest.$ac_objext
4634 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4635   (eval $ac_compile) 2>conftest.er1
4636   ac_status=$?
4637   grep -v '^ *+' conftest.er1 >conftest.err
4638   rm -f conftest.er1
4639   cat conftest.err >&5
4640   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4641   (exit $ac_status); } &&
4642          { ac_try='test -z "$ac_c_werror_flag"
4643                          || test ! -s conftest.err'
4644   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4645   (eval $ac_try) 2>&5
4646   ac_status=$?
4647   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4648   (exit $ac_status); }; } &&
4649          { ac_try='test -s conftest.$ac_objext'
4650   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4651   (eval $ac_try) 2>&5
4652   ac_status=$?
4653   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4654   (exit $ac_status); }; }; then
4655   echo "$as_me:$LINENO: result: yes" >&5
4656 echo "${ECHO_T}yes" >&6
4657 else
4658   echo "$as_me: failed program was:" >&5
4659 sed 's/^/| /' conftest.$ac_ext >&5
4660
4661 echo "$as_me:$LINENO: result: no" >&5
4662 echo "${ECHO_T}no" >&6; have_gmp=no
4663 fi
4664 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4665
4666   if test x"$have_gmp" = xyes; then
4667     saved_LIBS="$LIBS"
4668     LIBS="$LIBS $gmplibs"
4669         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4670 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4671     cat >conftest.$ac_ext <<_ACEOF
4672 /* confdefs.h.  */
4673 _ACEOF
4674 cat confdefs.h >>conftest.$ac_ext
4675 cat >>conftest.$ac_ext <<_ACEOF
4676 /* end confdefs.h.  */
4677 #include <gmp.h>
4678     #include <mpfr.h>
4679 int
4680 main ()
4681 {
4682
4683     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,1)
4684     choke me
4685     #endif
4686     mpfr_t n;
4687     mpfr_t x;
4688     int t;
4689     mpfr_init (n);
4690     mpfr_init (x);
4691     mpfr_atan2 (n, n, x, GMP_RNDN);
4692     mpfr_erfc (n, x, GMP_RNDN);
4693     mpfr_subnormalize (x, t, GMP_RNDN);
4694
4695   ;
4696   return 0;
4697 }
4698 _ACEOF
4699 rm -f conftest.$ac_objext conftest$ac_exeext
4700 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4701   (eval $ac_link) 2>conftest.er1
4702   ac_status=$?
4703   grep -v '^ *+' conftest.er1 >conftest.err
4704   rm -f conftest.er1
4705   cat conftest.err >&5
4706   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4707   (exit $ac_status); } &&
4708          { ac_try='test -z "$ac_c_werror_flag"
4709                          || test ! -s conftest.err'
4710   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4711   (eval $ac_try) 2>&5
4712   ac_status=$?
4713   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4714   (exit $ac_status); }; } &&
4715          { ac_try='test -s conftest$ac_exeext'
4716   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4717   (eval $ac_try) 2>&5
4718   ac_status=$?
4719   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4720   (exit $ac_status); }; }; then
4721   cat >conftest.$ac_ext <<_ACEOF
4722 /* confdefs.h.  */
4723 _ACEOF
4724 cat confdefs.h >>conftest.$ac_ext
4725 cat >>conftest.$ac_ext <<_ACEOF
4726 /* end confdefs.h.  */
4727 #include <gmp.h>
4728     #include <mpfr.h>
4729 int
4730 main ()
4731 {
4732
4733     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4734     choke me
4735     #endif
4736     mpfr_t n; mpfr_init(n);
4737
4738   ;
4739   return 0;
4740 }
4741 _ACEOF
4742 rm -f conftest.$ac_objext conftest$ac_exeext
4743 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4744   (eval $ac_link) 2>conftest.er1
4745   ac_status=$?
4746   grep -v '^ *+' conftest.er1 >conftest.err
4747   rm -f conftest.er1
4748   cat conftest.err >&5
4749   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4750   (exit $ac_status); } &&
4751          { ac_try='test -z "$ac_c_werror_flag"
4752                          || test ! -s conftest.err'
4753   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4754   (eval $ac_try) 2>&5
4755   ac_status=$?
4756   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4757   (exit $ac_status); }; } &&
4758          { ac_try='test -s conftest$ac_exeext'
4759   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4760   (eval $ac_try) 2>&5
4761   ac_status=$?
4762   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4763   (exit $ac_status); }; }; then
4764   echo "$as_me:$LINENO: result: yes" >&5
4765 echo "${ECHO_T}yes" >&6
4766 else
4767   echo "$as_me: failed program was:" >&5
4768 sed 's/^/| /' conftest.$ac_ext >&5
4769
4770 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4771 echo "${ECHO_T}buggy but acceptable" >&6
4772 fi
4773 rm -f conftest.err conftest.$ac_objext \
4774       conftest$ac_exeext conftest.$ac_ext
4775 else
4776   echo "$as_me: failed program was:" >&5
4777 sed 's/^/| /' conftest.$ac_ext >&5
4778
4779 echo "$as_me:$LINENO: result: no" >&5
4780 echo "${ECHO_T}no" >&6; have_gmp=no
4781 fi
4782 rm -f conftest.err conftest.$ac_objext \
4783       conftest$ac_exeext conftest.$ac_ext
4784       LIBS="$saved_LIBS"
4785   fi
4786   CFLAGS="$saved_CFLAGS"
4787
4788   if test x$have_gmp != xyes; then
4789     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
4790 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4791 Copies of these libraries' source code can be found at their respective
4792 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4793 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4794 If you obtained GMP and/or MPFR from a vendor distribution package, make
4795 sure that you have installed both the libraries and the header files.
4796 They may be located in separate packages." >&5
4797 echo "$as_me: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
4798 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4799 Copies of these libraries' source code can be found at their respective
4800 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4801 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4802 If you obtained GMP and/or MPFR from a vendor distribution package, make
4803 sure that you have installed both the libraries and the header files.
4804 They may be located in separate packages." >&2;}
4805    { (exit 1); exit 1; }; }
4806   fi
4807 fi
4808
4809 # Flags needed for both GMP and/or MPFR
4810
4811
4812
4813 # Allow host libstdc++ to be specified for static linking with PPL.
4814
4815 # Check whether --with-host-libstdcxx or --without-host-libstdcxx was given.
4816 if test "${with_host_libstdcxx+set}" = set; then
4817   withval="$with_host_libstdcxx"
4818
4819 fi;
4820
4821 case $with_host_libstdcxx in
4822   no|yes)
4823     { { echo "$as_me:$LINENO: error: -with-host-libstdcxx needs an argument" >&5
4824 echo "$as_me: error: -with-host-libstdcxx needs an argument" >&2;}
4825    { (exit 1); exit 1; }; }
4826     ;;
4827 esac
4828
4829 # Check for PPL
4830 ppl_major_version=0
4831 ppl_minor_version=10
4832 ppllibs=" -lppl_c -lppl -lgmpxx $with_host_libstdcxx "
4833 pplinc=
4834
4835
4836 # Check whether --with-ppl or --without-ppl was given.
4837 if test "${with_ppl+set}" = set; then
4838   withval="$with_ppl"
4839
4840 fi;
4841
4842 # Check whether --with-ppl_include or --without-ppl_include was given.
4843 if test "${with_ppl_include+set}" = set; then
4844   withval="$with_ppl_include"
4845
4846 fi;
4847
4848 # Check whether --with-ppl_lib or --without-ppl_lib was given.
4849 if test "${with_ppl_lib+set}" = set; then
4850   withval="$with_ppl_lib"
4851
4852 fi;
4853
4854 case $with_ppl in
4855   no)
4856     ppllibs=
4857     ;;
4858   *)
4859     ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx $with_host_libstdcxx"
4860     pplinc="-I$with_ppl/include $pplinc"
4861     LIBS="$ppllibs $LIBS"
4862     ;;
4863 esac
4864 if test "x$with_ppl_include" != x; then
4865   pplinc="-I$with_ppl_include $pplinc"
4866 fi
4867 if test "x$with_ppl_lib" != x; then
4868   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx $with_host_libstdcxx"
4869   LIBS="$ppllibs $LIBS"
4870 fi
4871 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
4872   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '"$with_host_libstdcxx "
4873   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
4874   LIBS="$ppllibs $LIBS"
4875 fi
4876
4877 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
4878 if test "${enable_ppl_version_check+set}" = set; then
4879   enableval="$enable_ppl_version_check"
4880   ENABLE_PPL_CHECK=$enableval
4881 else
4882   ENABLE_PPL_CHECK=yes
4883 fi;
4884
4885 if test "${ENABLE_PPL_CHECK}" = "yes"; then
4886   saved_CFLAGS="$CFLAGS"
4887   CFLAGS="$CFLAGS $pplinc $gmpinc"
4888   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
4889 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
4890   cat >conftest.$ac_ext <<_ACEOF
4891 /* confdefs.h.  */
4892 _ACEOF
4893 cat confdefs.h >>conftest.$ac_ext
4894 cat >>conftest.$ac_ext <<_ACEOF
4895 /* end confdefs.h.  */
4896 #include "ppl_c.h"
4897 int
4898 main ()
4899 {
4900
4901   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
4902   choke me
4903   #endif
4904
4905   ;
4906   return 0;
4907 }
4908 _ACEOF
4909 rm -f conftest.$ac_objext
4910 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4911   (eval $ac_compile) 2>conftest.er1
4912   ac_status=$?
4913   grep -v '^ *+' conftest.er1 >conftest.err
4914   rm -f conftest.er1
4915   cat conftest.err >&5
4916   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4917   (exit $ac_status); } &&
4918          { ac_try='test -z "$ac_c_werror_flag"
4919                          || test ! -s conftest.err'
4920   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4921   (eval $ac_try) 2>&5
4922   ac_status=$?
4923   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4924   (exit $ac_status); }; } &&
4925          { ac_try='test -s conftest.$ac_objext'
4926   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4927   (eval $ac_try) 2>&5
4928   ac_status=$?
4929   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4930   (exit $ac_status); }; }; then
4931   echo "$as_me:$LINENO: result: yes" >&5
4932 echo "${ECHO_T}yes" >&6
4933 else
4934   echo "$as_me: failed program was:" >&5
4935 sed 's/^/| /' conftest.$ac_ext >&5
4936
4937 echo "$as_me:$LINENO: result: no" >&5
4938 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
4939 fi
4940 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4941   CFLAGS="$saved_CFLAGS"
4942 fi
4943
4944 # Flags needed for PPL
4945
4946
4947
4948
4949 # Check for CLOOG
4950 clooglibs=" -lcloog "
4951 clooginc=" -DCLOOG_PPL_BACKEND "
4952
4953
4954 # Check whether --with-cloog or --without-cloog was given.
4955 if test "${with_cloog+set}" = set; then
4956   withval="$with_cloog"
4957
4958 fi;
4959
4960 # Check whether --with-cloog_include or --without-cloog_include was given.
4961 if test "${with_cloog_include+set}" = set; then
4962   withval="$with_cloog_include"
4963
4964 fi;
4965
4966 # Check whether --with-cloog_lib or --without-cloog_lib was given.
4967 if test "${with_cloog_lib+set}" = set; then
4968   withval="$with_cloog_lib"
4969
4970 fi;
4971
4972 case $with_cloog in
4973   no)
4974     clooglibs=
4975     clooginc=
4976     ;;
4977   *)
4978     clooglibs="-L$with_cloog/lib -lcloog"
4979     clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
4980     LIBS="$clooglibs $LIBS"
4981     ;;
4982 esac
4983 if test "x$with_cloog_include" != x; then
4984   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
4985 fi
4986 if test "x$with_cloog_lib" != x; then
4987   clooglibs="-L$with_cloog_lib -lcloog"
4988   LIBS="$clooglibs $LIBS"
4989 fi
4990 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
4991   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
4992   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
4993   LIBS="$clooglibs $LIBS"
4994 fi
4995
4996 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
4997 if test "${enable_cloog_version_check+set}" = set; then
4998   enableval="$enable_cloog_version_check"
4999   ENABLE_CLOOG_CHECK=$enableval
5000 else
5001   ENABLE_CLOOG_CHECK=yes
5002 fi;
5003
5004 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
5005   saved_CFLAGS="$CFLAGS"
5006   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
5007   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
5008 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
5009   cat >conftest.$ac_ext <<_ACEOF
5010 /* confdefs.h.  */
5011 _ACEOF
5012 cat confdefs.h >>conftest.$ac_ext
5013 cat >>conftest.$ac_ext <<_ACEOF
5014 /* end confdefs.h.  */
5015 #include "cloog/cloog.h"
5016 int
5017 main ()
5018 {
5019
5020   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
5021   choke me
5022   #endif
5023
5024   ;
5025   return 0;
5026 }
5027 _ACEOF
5028 rm -f conftest.$ac_objext
5029 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5030   (eval $ac_compile) 2>conftest.er1
5031   ac_status=$?
5032   grep -v '^ *+' conftest.er1 >conftest.err
5033   rm -f conftest.er1
5034   cat conftest.err >&5
5035   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5036   (exit $ac_status); } &&
5037          { ac_try='test -z "$ac_c_werror_flag"
5038                          || test ! -s conftest.err'
5039   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5040   (eval $ac_try) 2>&5
5041   ac_status=$?
5042   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5043   (exit $ac_status); }; } &&
5044          { ac_try='test -s conftest.$ac_objext'
5045   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5046   (eval $ac_try) 2>&5
5047   ac_status=$?
5048   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5049   (exit $ac_status); }; }; then
5050   echo "$as_me:$LINENO: result: yes" >&5
5051 echo "${ECHO_T}yes" >&6
5052 else
5053   echo "$as_me: failed program was:" >&5
5054 sed 's/^/| /' conftest.$ac_ext >&5
5055
5056 echo "$as_me:$LINENO: result: no" >&5
5057 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5058 fi
5059 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5060   CFLAGS="$saved_CFLAGS"
5061 fi
5062
5063 # Flags needed for CLOOG
5064
5065
5066
5067
5068 # By default, C is the only stage 1 language.
5069 stage1_languages=,c,
5070
5071 # Figure out what language subdirectories are present.
5072 # Look if the user specified --enable-languages="..."; if not, use
5073 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5074 # go away some day.
5075 # NB:  embedded tabs in this IF block -- do not untabify
5076 if test -d ${srcdir}/gcc; then
5077   if test x"${enable_languages+set}" != xset; then
5078     if test x"${LANGUAGES+set}" = xset; then
5079       enable_languages="${LANGUAGES}"
5080         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5081     else
5082       enable_languages=all
5083     fi
5084   else
5085     if test x"${enable_languages}" = x ||
5086        test x"${enable_languages}" = xyes;
5087        then
5088       echo configure.in: --enable-languages needs at least one language argument 1>&2
5089       exit 1
5090     fi
5091   fi
5092   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5093
5094   # 'f95' is the old name for the 'fortran' language. We issue a warning
5095   # and make the substitution.
5096   case ,${enable_languages}, in
5097     *,f95,*)
5098       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5099       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5100       ;;
5101   esac
5102
5103   # First scan to see if an enabled language requires some other language.
5104   # We assume that a given config-lang.in will list all the language
5105   # front ends it requires, even if some are required indirectly.
5106   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5107     case ${lang_frag} in
5108       ..) ;;
5109       # The odd quoting in the next line works around
5110       # an apparent bug in bash 1.12 on linux.
5111       ${srcdir}/gcc/[*]/config-lang.in) ;;
5112       *)
5113         # From the config-lang.in, get $language, $lang_requires
5114         language=
5115         lang_requires=
5116         . ${lang_frag}
5117         for other in ${lang_requires} ; do
5118           case ,${enable_languages}, in
5119             *,$other,*) ;;
5120             *,all,*) ;;
5121             *,$language,*)
5122               echo " \`$other' language required by \`$language'; enabling" 1>&2
5123               enable_languages="${enable_languages},${other}"
5124               ;;
5125           esac
5126         done
5127         ;;
5128     esac
5129   done
5130
5131   new_enable_languages=,c,
5132   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5133   potential_languages=,c,
5134
5135   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5136     case ${lang_frag} in
5137       ..) ;;
5138       # The odd quoting in the next line works around
5139       # an apparent bug in bash 1.12 on linux.
5140       ${srcdir}/gcc/[*]/config-lang.in) ;;
5141       *)
5142         # From the config-lang.in, get $language, $target_libs,
5143         # $lang_dirs, $boot_language, and $build_by_default
5144         language=
5145         target_libs=
5146         lang_dirs=
5147         subdir_requires=
5148         boot_language=no
5149         build_by_default=yes
5150         . ${lang_frag}
5151         if test x${language} = x; then
5152           echo "${lang_frag} doesn't set \$language." 1>&2
5153           exit 1
5154         fi
5155
5156         case ,${enable_languages}, in
5157           *,${language},*)
5158             # Language was explicitly selected; include it.
5159             add_this_lang=yes
5160             ;;
5161           *,all,*)
5162             # 'all' was selected, select it if it is a default language
5163             add_this_lang=${build_by_default}
5164             ;;
5165           *)
5166             add_this_lang=no
5167             ;;
5168         esac
5169
5170         # Disable languages that need other directories if these aren't available.
5171         for i in $subdir_requires; do
5172           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5173           case ,${enable_languages}, in
5174             *,${language},*)
5175               # Specifically requested language; tell them.
5176               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5177 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5178    { (exit 1); exit 1; }; }
5179               ;;
5180             *)
5181               # Silently disable.
5182               add_this_lang=unsupported
5183               ;;
5184           esac
5185         done
5186
5187         # Disable Ada if no preexisting GNAT is available.
5188         case ,${enable_languages},:${language}:${have_gnat} in
5189           *,${language},*:ada:no)
5190             # Specifically requested language; tell them.
5191             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5192 echo "$as_me: error: GNAT is required to build $language" >&2;}
5193    { (exit 1); exit 1; }; }
5194             ;;
5195           *:ada:no)
5196             # Silently disable.
5197             add_this_lang=unsupported
5198             ;;
5199         esac
5200
5201         # Disable a language that is unsupported by the target.
5202         case " $unsupported_languages " in
5203           *" $language "*)
5204             add_this_lang=unsupported
5205             ;;
5206         esac
5207
5208         case $add_this_lang in
5209           unsupported)
5210             # Remove language-dependent dirs.
5211             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5212             ;;
5213           no)
5214             # Remove language-dependent dirs; still show language as supported.
5215             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5216             potential_languages="${potential_languages}${language},"
5217             ;;
5218           yes)
5219             new_enable_languages="${new_enable_languages}${language},"
5220             potential_languages="${potential_languages}${language},"
5221             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5222             case ${boot_language} in
5223               yes)
5224                 # Add to (comma-separated) list of stage 1 languages.
5225                 stage1_languages="${stage1_languages}${language},"
5226                 ;;
5227             esac
5228             ;;
5229         esac
5230         ;;
5231     esac
5232   done
5233
5234   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5235 if test "${enable_stage1_languages+set}" = set; then
5236   enableval="$enable_stage1_languages"
5237   case ,${enable_stage1_languages}, in
5238     ,no,|,,)
5239       # Set it to something that will have no effect in the loop below
5240       enable_stage1_languages=c ;;
5241     ,yes,)
5242       enable_stage1_languages=`echo $new_enable_languages | \
5243         sed -e "s/^,//" -e "s/,$//" ` ;;
5244     *,all,*)
5245       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5246         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5247   esac
5248
5249   # Add "good" languages from enable_stage1_languages to stage1_languages,
5250   # while "bad" languages go in missing_languages.  Leave no duplicates.
5251   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5252     case $potential_languages in
5253       *,$i,*)
5254         case $stage1_languages in
5255           *,$i,*) ;;
5256           *) stage1_languages="$stage1_languages$i," ;;
5257         esac ;;
5258       *)
5259         case $missing_languages in
5260           *,$i,*) ;;
5261           *) missing_languages="$missing_languages$i," ;;
5262         esac ;;
5263      esac
5264   done
5265 fi;
5266
5267   # Remove leading/trailing commas that were added for simplicity
5268   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5269   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5270   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5271   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5272
5273   if test "x$missing_languages" != x; then
5274     { { echo "$as_me:$LINENO: error:
5275 The following requested languages could not be built: ${missing_languages}
5276 Supported languages are: ${potential_languages}" >&5
5277 echo "$as_me: error:
5278 The following requested languages could not be built: ${missing_languages}
5279 Supported languages are: ${potential_languages}" >&2;}
5280    { (exit 1); exit 1; }; }
5281   fi
5282   if test "x$new_enable_languages" != "x$enable_languages"; then
5283     echo The following languages will be built: ${new_enable_languages}
5284     enable_languages="$new_enable_languages"
5285   fi
5286
5287
5288   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5289 fi
5290
5291 # Handle --disable-<component> generically.
5292 for dir in $configdirs $build_configdirs $target_configdirs ; do
5293   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5294   varname=`echo $dirname | sed -e s/+/_/g`
5295   if eval test x\${enable_${varname}} "=" xno ; then
5296     noconfigdirs="$noconfigdirs $dir"
5297   fi
5298 done
5299
5300 # Check for Boehm's garbage collector
5301 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5302 if test "${enable_objc_gc+set}" = set; then
5303   enableval="$enable_objc_gc"
5304   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5305   *,objc,*:*:yes:*target-boehm-gc*)
5306     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5307 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5308    { (exit 1); exit 1; }; }
5309     ;;
5310 esac
5311 fi;
5312
5313 # Make sure we only build Boehm's garbage collector if required.
5314 case ,${enable_languages},:${enable_objc_gc} in
5315   *,objc,*:yes)
5316     # Keep target-boehm-gc if requested for Objective-C.
5317     ;;
5318   *)
5319     # Otherwise remove target-boehm-gc depending on target-libjava.
5320     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5321       noconfigdirs="$noconfigdirs target-boehm-gc"
5322     fi
5323     ;;
5324 esac
5325
5326 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5327 # $build_configdirs and $target_configdirs.
5328 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5329
5330 notsupp=""
5331 for dir in . $skipdirs $noconfigdirs ; do
5332   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5333   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5334     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5335     if test -r $srcdir/$dirname/configure ; then
5336       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5337         true
5338       else
5339         notsupp="$notsupp $dir"
5340       fi
5341     fi
5342   fi
5343   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5344     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5345     if test -r $srcdir/$dirname/configure ; then
5346       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5347         true
5348       else
5349         notsupp="$notsupp $dir"
5350       fi
5351     fi
5352   fi
5353   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5354     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5355     if test -r $srcdir/$dirname/configure ; then
5356       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5357         true
5358       else
5359         notsupp="$notsupp $dir"
5360       fi
5361     fi
5362   fi
5363 done
5364
5365 # Sometimes the tools are distributed with libiberty but with no other
5366 # libraries.  In that case, we don't want to build target-libiberty.
5367 # Don't let libgcc imply libiberty either.
5368 if test -n "${target_configdirs}" ; then
5369   libgcc=
5370   others=
5371   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5372     if test "$i" = "libgcc"; then
5373       libgcc=target-libgcc
5374     elif test "$i" != "libiberty" ; then
5375       if test -r $srcdir/$i/configure ; then
5376         others=yes;
5377         break;
5378       fi
5379     fi
5380   done
5381   if test -z "${others}" ; then
5382     target_configdirs=$libgcc
5383   fi
5384 fi
5385
5386 # Quietly strip out all directories which aren't configurable in this tree.
5387 # This relies on all configurable subdirectories being autoconfiscated, which
5388 # is now the case.
5389 build_configdirs_all="$build_configdirs"
5390 build_configdirs=
5391 for i in ${build_configdirs_all} ; do
5392   j=`echo $i | sed -e s/build-//g`
5393   if test -f ${srcdir}/$j/configure ; then
5394     build_configdirs="${build_configdirs} $i"
5395   fi
5396 done
5397
5398 configdirs_all="$configdirs"
5399 configdirs=
5400 for i in ${configdirs_all} ; do
5401   if test -f ${srcdir}/$i/configure ; then
5402     configdirs="${configdirs} $i"
5403   fi
5404 done
5405
5406 target_configdirs_all="$target_configdirs"
5407 target_configdirs=
5408 for i in ${target_configdirs_all} ; do
5409   j=`echo $i | sed -e s/target-//g`
5410   if test -f ${srcdir}/$j/configure ; then
5411     target_configdirs="${target_configdirs} $i"
5412   fi
5413 done
5414
5415 # Produce a warning message for the subdirs we can't configure.
5416 # This isn't especially interesting in the Cygnus tree, but in the individual
5417 # FSF releases, it's important to let people know when their machine isn't
5418 # supported by the one or two programs in a package.
5419
5420 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5421   # If $appdirs is non-empty, at least one of those directories must still
5422   # be configured, or we error out.  (E.g., if the gas release supports a
5423   # specified target in some subdirs but not the gas subdir, we shouldn't
5424   # pretend that all is well.)
5425   if test -n "$appdirs" ; then
5426     for dir in $appdirs ; do
5427       if test -r $dir/Makefile.in ; then
5428         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5429           appdirs=""
5430           break
5431         fi
5432         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5433           appdirs=""
5434           break
5435         fi
5436       fi
5437     done
5438     if test -n "$appdirs" ; then
5439       echo "*** This configuration is not supported by this package." 1>&2
5440       exit 1
5441     fi
5442   fi
5443   # Okay, some application will build, or we don't care to check.  Still
5444   # notify of subdirs not getting built.
5445   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5446   echo "    ${notsupp}" 1>&2
5447   echo "    (Any other directories should still work fine.)" 1>&2
5448 fi
5449
5450 case "$host" in
5451   *msdosdjgpp*)
5452     enable_gdbtk=no ;;
5453 esac
5454
5455 # To find our prefix, in gcc_cv_tool_prefix.
5456
5457 # The user is always right.
5458 if test "${PATH_SEPARATOR+set}" != set; then
5459   echo "#! /bin/sh" >conf$$.sh
5460   echo  "exit 0"   >>conf$$.sh
5461   chmod +x conf$$.sh
5462   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5463     PATH_SEPARATOR=';'
5464   else
5465     PATH_SEPARATOR=:
5466   fi
5467   rm -f conf$$.sh
5468 fi
5469
5470
5471
5472 if test "x$exec_prefix" = xNONE; then
5473         if test "x$prefix" = xNONE; then
5474                 gcc_cv_tool_prefix=$ac_default_prefix
5475         else
5476                 gcc_cv_tool_prefix=$prefix
5477         fi
5478 else
5479         gcc_cv_tool_prefix=$exec_prefix
5480 fi
5481
5482 # If there is no compiler in the tree, use the PATH only.  In any
5483 # case, if there is no compiler in the tree nobody should use
5484 # AS_FOR_TARGET and LD_FOR_TARGET.
5485 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5486     gcc_version=`cat $srcdir/gcc/BASE-VER`
5487     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5488     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5489     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5490     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5491     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5492     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5493 else
5494     gcc_cv_tool_dirs=
5495 fi
5496
5497 if test x$build = x$target && test -n "$md_exec_prefix"; then
5498         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5499 fi
5500
5501
5502
5503 copy_dirs=
5504
5505
5506 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5507 if test "${with_build_sysroot+set}" = set; then
5508   withval="$with_build_sysroot"
5509   if test x"$withval" != x ; then
5510      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5511    fi
5512 else
5513   SYSROOT_CFLAGS_FOR_TARGET=
5514 fi;
5515
5516
5517
5518 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5519 if test "${with_debug_prefix_map+set}" = set; then
5520   withval="$with_debug_prefix_map"
5521   if test x"$withval" != x; then
5522      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5523      for debug_map in $withval; do
5524        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5525      done
5526    fi
5527 else
5528   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5529 fi;
5530
5531
5532 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5533 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5534 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5535 # We want to ensure that TARGET libraries (which we know are built with
5536 # gcc) are built with "-O2 -g", so include those options when setting
5537 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5538 if test "x$CFLAGS_FOR_TARGET" = x; then
5539   CFLAGS_FOR_TARGET=$CFLAGS
5540   case " $CFLAGS " in
5541     *" -O2 "*) ;;
5542     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5543   esac
5544   case " $CFLAGS " in
5545     *" -g "* | *" -g3 "*) ;;
5546     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5547   esac
5548 fi
5549
5550
5551 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5552   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5553   case " $CXXFLAGS " in
5554     *" -O2 "*) ;;
5555     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5556   esac
5557   case " $CXXFLAGS " in
5558     *" -g "* | *" -g3 "*) ;;
5559     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5560   esac
5561 fi
5562
5563
5564 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5565 # the named directory are copied to $(tooldir)/sys-include.
5566 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5567   if test x${is_cross_compiler} = xno ; then
5568     echo 1>&2 '***' --with-headers is only supported when cross compiling
5569     exit 1
5570   fi
5571   if test x"${with_headers}" != xyes ; then
5572     x=${gcc_cv_tool_prefix}
5573     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5574   fi
5575 fi
5576
5577 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5578 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5579 # are permitted.
5580 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5581   if test x${is_cross_compiler} = xno ; then
5582     echo 1>&2 '***' --with-libs is only supported when cross compiling
5583     exit 1
5584   fi
5585   if test x"${with_libs}" != xyes ; then
5586     # Copy the libraries in reverse order, so that files in the first named
5587     # library override files in subsequent libraries.
5588     x=${gcc_cv_tool_prefix}
5589     for l in ${with_libs}; do
5590       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5591     done
5592   fi
5593 fi
5594
5595 # Set with_gnu_as and with_gnu_ld as appropriate.
5596 #
5597 # This is done by determining whether or not the appropriate directory
5598 # is available, and by checking whether or not specific configurations
5599 # have requested that this magic not happen.
5600 #
5601 # The command line options always override the explicit settings in
5602 # configure.in, and the settings in configure.in override this magic.
5603 #
5604 # If the default for a toolchain is to use GNU as and ld, and you don't
5605 # want to do that, then you should use the --without-gnu-as and
5606 # --without-gnu-ld options for the configure script.
5607
5608 if test x${use_gnu_as} = x &&
5609    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5610   with_gnu_as=yes
5611   extra_host_args="$extra_host_args --with-gnu-as"
5612 fi
5613
5614 if test x${use_gnu_ld} = x &&
5615    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5616   with_gnu_ld=yes
5617   extra_host_args="$extra_host_args --with-gnu-ld"
5618 fi
5619
5620 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5621 # can detect this case.
5622
5623 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5624   with_newlib=yes
5625   extra_host_args="$extra_host_args --with-newlib"
5626 fi
5627
5628 # Handle ${copy_dirs}
5629 set fnord ${copy_dirs}
5630 shift
5631 while test $# != 0 ; do
5632   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5633     :
5634   else
5635     echo Copying $1 to $2
5636
5637     # Use the install script to create the directory and all required
5638     # parent directories.
5639     if test -d $2 ; then
5640       :
5641     else
5642       echo >config.temp
5643       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5644     fi
5645
5646     # Copy the directory, assuming we have tar.
5647     # FIXME: Should we use B in the second tar?  Not all systems support it.
5648     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5649
5650     # It is the responsibility of the user to correctly adjust all
5651     # symlinks.  If somebody can figure out how to handle them correctly
5652     # here, feel free to add the code.
5653
5654     echo $1 > $2/COPIED
5655   fi
5656   shift; shift
5657 done
5658
5659 # Determine a target-dependent exec_prefix that the installed
5660 # gcc will search in.  Keep this list sorted by triplet, with
5661 # the *-*-osname triplets last.
5662 md_exec_prefix=
5663 case "${target}" in
5664   alpha*-*-*vms*)
5665     md_exec_prefix=/gnu/lib/gcc-lib
5666     ;;
5667   i[34567]86-pc-msdosdjgpp*)
5668     md_exec_prefix=/dev/env/DJDIR/bin
5669     ;;
5670   i[34567]86-*-sco3.2v5*)
5671     if test $with_gnu_as = yes; then
5672       md_exec_prefix=/usr/gnu/bin
5673     else
5674       md_exec_prefix=/usr/ccs/bin/elf
5675     fi
5676     ;;
5677
5678   mn10300-*-* | \
5679   powerpc-*-chorusos* | \
5680   powerpc*-*-eabi* | \
5681   powerpc*-*-sysv* | \
5682   powerpc*-*-kaos* | \
5683   s390x-ibm-tpf*)
5684     md_exec_prefix=/usr/ccs/bin
5685     ;;
5686   sparc64-*-elf*)
5687     ;;
5688   v850*-*-*)
5689     md_exec_prefix=/usr/ccs/bin
5690     ;;
5691   xtensa*-*-elf*)
5692     ;;
5693
5694   *-*-beos* | \
5695   *-*-elf* | \
5696   *-*-hpux* | \
5697   *-*-netware* | \
5698   *-*-nto-qnx* | \
5699   *-*-rtems* | \
5700   *-*-solaris2* | \
5701   *-*-sysv[45]* | \
5702   *-*-vxworks* | \
5703   *-wrs-windiss)
5704     md_exec_prefix=/usr/ccs/bin
5705     ;;
5706 esac
5707
5708 extra_arflags_for_target=
5709 extra_nmflags_for_target=
5710 extra_ranlibflags_for_target=
5711 target_makefile_frag=/dev/null
5712 case "${target}" in
5713   mep*-*-*)
5714     target_makefile_frag="config/mt-mep"
5715     ;;
5716   spu-*-*)
5717     target_makefile_frag="config/mt-spu"
5718     ;;
5719   mips*-sde-elf*)
5720     target_makefile_frag="config/mt-sde"
5721     ;;
5722   mipsisa*-*-elfoabi*)
5723     target_makefile_frag="config/mt-mips-elfoabi"
5724     ;;
5725   mips*-*-*linux* | mips*-*-gnu*)
5726     target_makefile_frag="config/mt-mips-gnu"
5727     ;;
5728   *-*-netware*)
5729     target_makefile_frag="config/mt-netware"
5730     ;;
5731   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
5732     target_makefile_frag="config/mt-gnu"
5733     ;;
5734   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5735     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5736     # commands to handle both 32-bit and 64-bit objects.  These flags are
5737     # harmless if we're using GNU nm or ar.
5738     extra_arflags_for_target=" -X32_64"
5739     extra_nmflags_for_target=" -B -X32_64"
5740     ;;
5741   *-*-darwin*)
5742     # ranlib from Darwin requires the -c flag to look at common symbols.
5743     extra_ranlibflags_for_target=" -c"
5744     ;;
5745   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5746     target_makefile_frag="config/mt-wince"
5747     ;;
5748 esac
5749
5750 alphaieee_frag=/dev/null
5751 case $target in
5752   alpha*-*-*)
5753     # This just makes sure to use the -mieee option to build target libs.
5754     # This should probably be set individually by each library.
5755     alphaieee_frag="config/mt-alphaieee"
5756     ;;
5757 esac
5758
5759 # If --enable-target-optspace always use -Os instead of -O2 to build
5760 # the target libraries, similarly if it is not specified, use -Os
5761 # on selected platforms.
5762 ospace_frag=/dev/null
5763 case "${enable_target_optspace}:${target}" in
5764   yes:*)
5765     ospace_frag="config/mt-ospace"
5766     ;;
5767   :d30v-*)
5768     ospace_frag="config/mt-d30v"
5769     ;;
5770   :m32r-* | :d10v-* | :fr30-*)
5771     ospace_frag="config/mt-ospace"
5772     ;;
5773   no:* | :*)
5774     ;;
5775   *)
5776     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5777     ;;
5778 esac
5779
5780 # Default to using --with-stabs for certain targets.
5781 if test x${with_stabs} = x ; then
5782   case "${target}" in
5783   mips*-*-irix[56]*)
5784     ;;
5785   mips*-*-* | alpha*-*-osf*)
5786     with_stabs=yes;
5787     extra_host_args="${extra_host_args} --with-stabs"
5788     ;;
5789   esac
5790 fi
5791
5792 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5793 # them automatically.
5794 case "${host}" in
5795   hppa*64*-*-hpux11*)
5796     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5797     ;;
5798 esac
5799
5800 # Some systems (e.g., one of the i386-aix systems the gas testers are
5801 # using) don't handle "\$" correctly, so don't use it here.
5802 tooldir='${exec_prefix}'/${target_noncanonical}
5803 build_tooldir=${tooldir}
5804
5805 # Create a .gdbinit file which runs the one in srcdir
5806 # and tells GDB to look there for source files.
5807
5808 if test -r ${srcdir}/.gdbinit ; then
5809   case ${srcdir} in
5810     .) ;;
5811     *) cat > ./.gdbinit <<EOF
5812 # ${NO_EDIT}
5813 dir ${srcdir}
5814 dir .
5815 source ${srcdir}/.gdbinit
5816 EOF
5817     ;;
5818   esac
5819 fi
5820
5821 # Make sure that the compiler is able to generate an executable.  If it
5822 # can't, we are probably in trouble.  We don't care whether we can run the
5823 # executable--we might be using a cross compiler--we only care whether it
5824 # can be created.  At this point the main configure script has set CC.
5825 we_are_ok=no
5826 echo "int main () { return 0; }" > conftest.c
5827 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5828 if test $? = 0 ; then
5829   if test -s conftest || test -s conftest.exe ; then
5830     we_are_ok=yes
5831   fi
5832 fi
5833 case $we_are_ok in
5834   no)
5835     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5836     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5837     rm -f conftest*
5838     exit 1
5839     ;;
5840 esac
5841 rm -f conftest*
5842
5843 # The Solaris /usr/ucb/cc compiler does not appear to work.
5844 case "${host}" in
5845   sparc-sun-solaris2*)
5846       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5847       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5848           could_use=
5849           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5850           if test -d /opt/cygnus/bin ; then
5851               if test "$could_use" = "" ; then
5852                   could_use="/opt/cygnus/bin"
5853               else
5854                   could_use="$could_use or /opt/cygnus/bin"
5855               fi
5856           fi
5857         if test "$could_use" = "" ; then
5858             echo "Warning: compilation may fail because you're using"
5859             echo "/usr/ucb/cc.  You should change your PATH or CC "
5860             echo "variable and rerun configure."
5861         else
5862             echo "Warning: compilation may fail because you're using"
5863             echo "/usr/ucb/cc, when you should use the C compiler from"
5864             echo "$could_use.  You should change your"
5865             echo "PATH or CC variable and rerun configure."
5866         fi
5867       fi
5868   ;;
5869 esac
5870
5871 # Decide which environment variable is used to find dynamic libraries.
5872 case "${host}" in
5873   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5874   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5875   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
5876   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5877 esac
5878
5879 # On systems where the dynamic library environment variable is PATH,
5880 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
5881 # built executables to PATH.
5882 if test "$RPATH_ENVVAR" = PATH; then
5883   GCC_SHLIB_SUBDIR=/shlib
5884 else
5885   GCC_SHLIB_SUBDIR=
5886 fi
5887
5888 # Record target_configdirs and the configure arguments for target and
5889 # build configuration in Makefile.
5890 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5891 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5892
5893 # Determine whether gdb needs tk/tcl or not.
5894 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5895 # and in that case we want gdb to be built without tk.  Ugh!
5896 # In fact I believe gdb is the *only* package directly dependent on tk,
5897 # so we should be able to put the 'maybe's in unconditionally and
5898 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5899 # 100% sure that that's safe though.
5900
5901 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5902 case "$enable_gdbtk" in
5903   no)
5904     GDB_TK="" ;;
5905   yes)
5906     GDB_TK="${gdb_tk}" ;;
5907   *)
5908     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5909     # distro.  Eventually someone will fix this and move Insight, nee
5910     # gdbtk to a separate directory.
5911     if test -d ${srcdir}/gdb/gdbtk ; then
5912       GDB_TK="${gdb_tk}"
5913     else
5914       GDB_TK=""
5915     fi
5916     ;;
5917 esac
5918 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5919 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5920
5921 # Strip out unwanted targets.
5922
5923 # While at that, we remove Makefiles if we were started for recursive
5924 # configuration, so that the top-level Makefile reconfigures them,
5925 # like we used to do when configure itself was recursive.
5926
5927 # Loop over modules.  $extrasub must be used with care, limiting as
5928 # much as possible the usage of range addresses.  That's because autoconf
5929 # splits the sed script to overcome limits in the number of commands,
5930 # and relying on carefully-timed sed passes may turn out to be very hard
5931 # to maintain later.  In this particular case, you just have to be careful
5932 # not to nest @if/@endif pairs, because configure will not warn you at all.
5933
5934 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5935 if test "${enable_bootstrap+set}" = set; then
5936   enableval="$enable_bootstrap"
5937
5938 else
5939   enable_bootstrap=default
5940 fi;
5941
5942 # Issue errors and warnings for invalid/strange bootstrap combinations.
5943 case "$configdirs" in
5944   *gcc*) have_compiler=yes ;;
5945   *) have_compiler=no ;;
5946 esac
5947
5948 case "$have_compiler:$host:$target:$enable_bootstrap" in
5949   *:*:*:no) ;;
5950
5951   # Default behavior.  Enable bootstrap if we have a compiler
5952   # and we are in a native configuration.
5953   yes:$build:$build:default)
5954     enable_bootstrap=yes ;;
5955
5956   *:*:*:default)
5957     enable_bootstrap=no ;;
5958
5959   # We have a compiler and we are in a native configuration, bootstrap is ok
5960   yes:$build:$build:yes)
5961     ;;
5962
5963   # Other configurations, but we have a compiler.  Assume the user knows
5964   # what he's doing.
5965   yes:*:*:yes)
5966     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5967 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5968     ;;
5969
5970   # No compiler: if they passed --enable-bootstrap explicitly, fail
5971   no:*:*:yes)
5972     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5973 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5974    { (exit 1); exit 1; }; } ;;
5975
5976   # Fail if wrong command line
5977   *)
5978     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5979 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5980    { (exit 1); exit 1; }; }
5981     ;;
5982 esac
5983
5984 # Adjust the toplevel makefile according to whether bootstrap was selected.
5985 case "$enable_bootstrap" in
5986   yes)
5987     bootstrap_suffix=bootstrap ;;
5988   no)
5989     bootstrap_suffix=no-bootstrap ;;
5990 esac
5991
5992 for module in ${build_configdirs} ; do
5993   if test -z "${no_recursion}" \
5994      && test -f ${build_subdir}/${module}/Makefile; then
5995     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5996     rm -f ${build_subdir}/${module}/Makefile
5997   fi
5998   extrasub="$extrasub
5999 /^@if build-$module\$/d
6000 /^@endif build-$module\$/d
6001 /^@if build-$module-$bootstrap_suffix\$/d
6002 /^@endif build-$module-$bootstrap_suffix\$/d"
6003 done
6004 for module in ${configdirs} ; do
6005   if test -z "${no_recursion}"; then
6006     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
6007       if test -f ${file}; then
6008         echo 1>&2 "*** removing ${file} to force reconfigure"
6009         rm -f ${file}
6010       fi
6011     done
6012   fi
6013   extrasub="$extrasub
6014 /^@if $module\$/d
6015 /^@endif $module\$/d
6016 /^@if $module-$bootstrap_suffix\$/d
6017 /^@endif $module-$bootstrap_suffix\$/d"
6018 done
6019 for module in ${target_configdirs} ; do
6020   if test -z "${no_recursion}" \
6021      && test -f ${target_subdir}/${module}/Makefile; then
6022     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6023     rm -f ${target_subdir}/${module}/Makefile
6024   fi
6025   extrasub="$extrasub
6026 /^@if target-$module\$/d
6027 /^@endif target-$module\$/d
6028 /^@if target-$module-$bootstrap_suffix\$/d
6029 /^@endif target-$module-$bootstrap_suffix\$/d"
6030 done
6031
6032 extrasub="$extrasub
6033 /^@if /,/^@endif /d"
6034
6035 # Create the serialization dependencies.  This uses a temporary file.
6036
6037 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6038 if test "${enable_serial_configure+set}" = set; then
6039   enableval="$enable_serial_configure"
6040
6041 fi;
6042
6043 case ${enable_serial_configure} in
6044   yes)
6045     enable_serial_build_configure=yes
6046     enable_serial_host_configure=yes
6047     enable_serial_target_configure=yes
6048     ;;
6049 esac
6050
6051 # These force 'configure's to be done one at a time, to avoid problems
6052 # with contention over a shared config.cache.
6053 rm -f serdep.tmp
6054 echo '# serdep.tmp' > serdep.tmp
6055 olditem=
6056 test "x${enable_serial_build_configure}" = xyes &&
6057 for item in ${build_configdirs} ; do
6058   case ${olditem} in
6059     "") ;;
6060     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6061   esac
6062   olditem=${item}
6063 done
6064 olditem=
6065 test "x${enable_serial_host_configure}" = xyes &&
6066 for item in ${configdirs} ; do
6067   case ${olditem} in
6068     "") ;;
6069     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6070   esac
6071   olditem=${item}
6072 done
6073 olditem=
6074 test "x${enable_serial_target_configure}" = xyes &&
6075 for item in ${target_configdirs} ; do
6076   case ${olditem} in
6077     "") ;;
6078     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6079   esac
6080   olditem=${item}
6081 done
6082 serialization_dependencies=serdep.tmp
6083
6084
6085 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6086 # target, nonopt, and variable assignments.  These are the ones we
6087 # might not want to pass down to subconfigures.  Also strip
6088 # program-prefix, program-suffix, and program-transform-name, so that
6089 # we can pass down a consistent program-transform-name.
6090 baseargs=
6091 keep_next=no
6092 skip_next=no
6093 eval "set -- $ac_configure_args"
6094 for ac_arg
6095 do
6096   if test X"$skip_next" = X"yes"; then
6097     skip_next=no
6098     continue
6099   fi
6100   if test X"$keep_next" = X"yes"; then
6101     case $ac_arg in
6102       *\'*)
6103         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6104     esac
6105     baseargs="$baseargs '$ac_arg'"
6106     keep_next=no
6107     continue
6108   fi
6109
6110   # Handle separated arguments.  Based on the logic generated by
6111   # autoconf 2.59.
6112   case $ac_arg in
6113     *=* | --config-cache | -C | -disable-* | --disable-* \
6114       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6115       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6116       | -with-* | --with-* | -without-* | --without-* | --x)
6117       separate_arg=no
6118       ;;
6119     -*)
6120       separate_arg=yes
6121       ;;
6122     *)
6123       separate_arg=no
6124       ;;
6125   esac
6126
6127   case "$ac_arg" in
6128     --no*)
6129       continue
6130       ;;
6131     --c* | \
6132     --sr* | \
6133     --ho* | \
6134     --bu* | \
6135     --t* | \
6136     --program-* | \
6137     -cache_file* | \
6138     -srcdir* | \
6139     -host* | \
6140     -build* | \
6141     -target* | \
6142     -program-prefix* | \
6143     -program-suffix* | \
6144     -program-transform-name* )
6145       skip_next=$separate_arg
6146       continue
6147       ;;
6148     -*)
6149       # An option.  Add it.
6150       case $ac_arg in
6151         *\'*)
6152           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6153       esac
6154       baseargs="$baseargs '$ac_arg'"
6155       keep_next=$separate_arg
6156       ;;
6157     *)
6158       # Either a variable assignment, or a nonopt (triplet).  Don't
6159       # pass it down; let the Makefile handle this.
6160       continue
6161       ;;
6162   esac
6163 done
6164 # Remove the initial space we just introduced and, as these will be
6165 # expanded by make, quote '$'.
6166 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6167
6168 # Add in --program-transform-name, after --program-prefix and
6169 # --program-suffix have been applied to it.  Autoconf has already
6170 # doubled dollar signs and backslashes in program_transform_name; we want
6171 # the backslashes un-doubled, and then the entire thing wrapped in single
6172 # quotes, because this will be expanded first by make and then by the shell.
6173 # Also, because we want to override the logic in subdir configure scripts to
6174 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6175 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6176 ${program_transform_name}
6177 EOF_SED
6178 gcc_transform_name=`cat conftestsed.out`
6179 rm -f conftestsed.out
6180 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6181 if test "$silent" = yes; then
6182   baseargs="$baseargs --silent"
6183 fi
6184
6185 # For the build-side libraries, we just need to pretend we're native,
6186 # and not use the same cache file.  Multilibs are neither needed nor
6187 # desired.
6188 build_configargs="--cache-file=../config.cache ${baseargs}"
6189
6190 # For host modules, accept cache file option, or specification as blank.
6191 case "${cache_file}" in
6192 "") # empty
6193   cache_file_option="" ;;
6194 /* | [A-Za-z]:[\\/]* ) # absolute path
6195   cache_file_option="--cache-file=${cache_file}" ;;
6196 *) # relative path
6197   cache_file_option="--cache-file=../${cache_file}" ;;
6198 esac
6199
6200 # Host dirs don't like to share a cache file either, horribly enough.
6201 # This seems to be due to autoconf 2.5x stupidity.
6202 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6203
6204 target_configargs=${baseargs}
6205
6206 # Passing a --with-cross-host argument lets the target libraries know
6207 # whether they are being built with a cross-compiler or being built
6208 # native.  However, it would be better to use other mechanisms to make the
6209 # sorts of decisions they want to make on this basis.  Please consider
6210 # this option to be deprecated.  FIXME.
6211 if test x${is_cross_compiler} = xyes ; then
6212   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6213 fi
6214
6215 # Default to --enable-multilib.
6216 if test x${enable_multilib} = x ; then
6217   target_configargs="--enable-multilib ${target_configargs}"
6218 fi
6219
6220 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6221 # changed from the earlier setting of with_newlib.
6222 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6223   target_configargs="--with-newlib ${target_configargs}"
6224 fi
6225
6226 # Different target subdirs use different values of certain variables
6227 # (notably CXX).  Worse, multilibs use *lots* of different values.
6228 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6229 # it doesn't automatically accept command-line overrides of them.
6230 # This means it's not safe for target subdirs to share a cache file,
6231 # which is disgusting, but there you have it.  Hopefully this can be
6232 # fixed in future.  It's still worthwhile to use a cache file for each
6233 # directory.  I think.
6234
6235 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6236 # We need to pass --target, as newer autoconf's requires consistency
6237 # for target_alias and gcc doesn't manage it consistently.
6238 target_configargs="--cache-file=./config.cache ${target_configargs}"
6239
6240 FLAGS_FOR_TARGET=
6241 case " $target_configdirs " in
6242  *" newlib "*)
6243   case " $target_configargs " in
6244   *" --with-newlib "*)
6245    case "$target" in
6246    *-cygwin*)
6247      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' ;;
6248    esac
6249
6250    # If we're not building GCC, don't discard standard headers.
6251    if test -d ${srcdir}/gcc; then
6252      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6253
6254      if test "${build}" != "${host}"; then
6255        # On Canadian crosses, CC_FOR_TARGET will have already been set
6256        # by `configure', so we won't have an opportunity to add -Bgcc/
6257        # to it.  This is right: we don't want to search that directory
6258        # for binaries, but we want the header files in there, so add
6259        # them explicitly.
6260        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6261
6262        # Someone might think of using the pre-installed headers on
6263        # Canadian crosses, in case the installed compiler is not fully
6264        # compatible with the compiler being built.  In this case, it
6265        # would be better to flag an error than risking having
6266        # incompatible object files being constructed.  We can't
6267        # guarantee that an error will be flagged, but let's hope the
6268        # compiler will do it, when presented with incompatible header
6269        # files.
6270      fi
6271    fi
6272
6273    case "${target}-${is_cross_compiler}" in
6274    i[3456789]86-*-linux*-no)
6275       # Here host == target, so we don't need to build gcc,
6276       # so we don't want to discard standard headers.
6277       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6278       ;;
6279    *)
6280       # If we're building newlib, use its generic headers last, but search
6281       # for any libc-related directories first (so make it the last -B
6282       # switch).
6283       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6284
6285       # If we're building libgloss, find the startup file, simulator library
6286       # and linker script.
6287       case " $target_configdirs " in
6288         *" libgloss "*)
6289         # Look for startup file, simulator library and maybe linker script.
6290         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6291         # Look for libnosys.a in case the target needs it.
6292         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6293         # Most targets have the linker script in the source directory.
6294         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6295         ;;
6296       esac
6297       ;;
6298    esac
6299    ;;
6300   esac
6301   ;;
6302 esac
6303 case "$target" in
6304 *-mingw*)
6305   # Can't be handled as Cygwin above since Mingw does not use newlib.
6306   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' ;;
6307 esac
6308
6309 # Allow the user to override the flags for
6310 # our build compiler if desired.
6311 if test x"${build}" = x"${host}" ; then
6312   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6313   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6314   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6315 fi
6316
6317 # On Canadian crosses, we'll be searching the right directories for
6318 # the previously-installed cross compiler, so don't bother to add
6319 # flags for directories within the install tree of the compiler
6320 # being built; programs in there won't even run.
6321 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6322   # Search for pre-installed headers if nothing else fits.
6323   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6324 fi
6325
6326 if test "x${use_gnu_ld}" = x &&
6327    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6328   # Arrange for us to find uninstalled linker scripts.
6329   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6330 fi
6331
6332 # Search for other target-specific linker scripts and such.
6333 case "${target}" in
6334   mep*)
6335     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6336     ;;
6337 esac
6338
6339 # Makefile fragments.
6340 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6341 do
6342   eval fragval=\$$frag
6343   if test $fragval != /dev/null; then
6344     eval $frag=${srcdir}/$fragval
6345   fi
6346 done
6347
6348
6349
6350
6351
6352 # Miscellanea: directories, flags, etc.
6353
6354
6355
6356
6357
6358
6359
6360
6361 # Build module lists & subconfigure args.
6362
6363
6364
6365 # Host module lists & subconfigure args.
6366
6367
6368
6369 # Target module lists & subconfigure args.
6370
6371
6372
6373 # Build tools.
6374
6375
6376
6377
6378
6379
6380
6381
6382
6383
6384
6385
6386
6387
6388
6389
6390
6391 # Generate default definitions for YACC, M4, LEX and other programs that run
6392 # on the build machine.  These are used if the Makefile can't locate these
6393 # programs in objdir.
6394 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6395
6396 for ac_prog in 'bison -y' byacc yacc
6397 do
6398   # Extract the first word of "$ac_prog", so it can be a program name with args.
6399 set dummy $ac_prog; ac_word=$2
6400 echo "$as_me:$LINENO: checking for $ac_word" >&5
6401 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6402 if test "${ac_cv_prog_YACC+set}" = set; then
6403   echo $ECHO_N "(cached) $ECHO_C" >&6
6404 else
6405   if test -n "$YACC"; then
6406   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6407 else
6408 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6409 for as_dir in $PATH
6410 do
6411   IFS=$as_save_IFS
6412   test -z "$as_dir" && as_dir=.
6413   for ac_exec_ext in '' $ac_executable_extensions; do
6414   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6415     ac_cv_prog_YACC="$ac_prog"
6416     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6417     break 2
6418   fi
6419 done
6420 done
6421
6422 fi
6423 fi
6424 YACC=$ac_cv_prog_YACC
6425 if test -n "$YACC"; then
6426   echo "$as_me:$LINENO: result: $YACC" >&5
6427 echo "${ECHO_T}$YACC" >&6
6428 else
6429   echo "$as_me:$LINENO: result: no" >&5
6430 echo "${ECHO_T}no" >&6
6431 fi
6432
6433   test -n "$YACC" && break
6434 done
6435 test -n "$YACC" || YACC="$MISSING bison -y"
6436
6437 case " $build_configdirs " in
6438   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6439   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6440 esac
6441
6442 for ac_prog in bison
6443 do
6444   # Extract the first word of "$ac_prog", so it can be a program name with args.
6445 set dummy $ac_prog; ac_word=$2
6446 echo "$as_me:$LINENO: checking for $ac_word" >&5
6447 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6448 if test "${ac_cv_prog_BISON+set}" = set; then
6449   echo $ECHO_N "(cached) $ECHO_C" >&6
6450 else
6451   if test -n "$BISON"; then
6452   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6453 else
6454 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6455 for as_dir in $PATH
6456 do
6457   IFS=$as_save_IFS
6458   test -z "$as_dir" && as_dir=.
6459   for ac_exec_ext in '' $ac_executable_extensions; do
6460   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6461     ac_cv_prog_BISON="$ac_prog"
6462     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6463     break 2
6464   fi
6465 done
6466 done
6467
6468 fi
6469 fi
6470 BISON=$ac_cv_prog_BISON
6471 if test -n "$BISON"; then
6472   echo "$as_me:$LINENO: result: $BISON" >&5
6473 echo "${ECHO_T}$BISON" >&6
6474 else
6475   echo "$as_me:$LINENO: result: no" >&5
6476 echo "${ECHO_T}no" >&6
6477 fi
6478
6479   test -n "$BISON" && break
6480 done
6481 test -n "$BISON" || BISON="$MISSING bison"
6482
6483 case " $build_configdirs " in
6484   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6485 esac
6486
6487 for ac_prog in gm4 gnum4 m4
6488 do
6489   # Extract the first word of "$ac_prog", so it can be a program name with args.
6490 set dummy $ac_prog; ac_word=$2
6491 echo "$as_me:$LINENO: checking for $ac_word" >&5
6492 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6493 if test "${ac_cv_prog_M4+set}" = set; then
6494   echo $ECHO_N "(cached) $ECHO_C" >&6
6495 else
6496   if test -n "$M4"; then
6497   ac_cv_prog_M4="$M4" # Let the user override the test.
6498 else
6499 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6500 for as_dir in $PATH
6501 do
6502   IFS=$as_save_IFS
6503   test -z "$as_dir" && as_dir=.
6504   for ac_exec_ext in '' $ac_executable_extensions; do
6505   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6506     ac_cv_prog_M4="$ac_prog"
6507     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6508     break 2
6509   fi
6510 done
6511 done
6512
6513 fi
6514 fi
6515 M4=$ac_cv_prog_M4
6516 if test -n "$M4"; then
6517   echo "$as_me:$LINENO: result: $M4" >&5
6518 echo "${ECHO_T}$M4" >&6
6519 else
6520   echo "$as_me:$LINENO: result: no" >&5
6521 echo "${ECHO_T}no" >&6
6522 fi
6523
6524   test -n "$M4" && break
6525 done
6526 test -n "$M4" || M4="$MISSING m4"
6527
6528 case " $build_configdirs " in
6529   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6530 esac
6531
6532 for ac_prog in flex lex
6533 do
6534   # Extract the first word of "$ac_prog", so it can be a program name with args.
6535 set dummy $ac_prog; ac_word=$2
6536 echo "$as_me:$LINENO: checking for $ac_word" >&5
6537 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6538 if test "${ac_cv_prog_LEX+set}" = set; then
6539   echo $ECHO_N "(cached) $ECHO_C" >&6
6540 else
6541   if test -n "$LEX"; then
6542   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6543 else
6544 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6545 for as_dir in $PATH
6546 do
6547   IFS=$as_save_IFS
6548   test -z "$as_dir" && as_dir=.
6549   for ac_exec_ext in '' $ac_executable_extensions; do
6550   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6551     ac_cv_prog_LEX="$ac_prog"
6552     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6553     break 2
6554   fi
6555 done
6556 done
6557
6558 fi
6559 fi
6560 LEX=$ac_cv_prog_LEX
6561 if test -n "$LEX"; then
6562   echo "$as_me:$LINENO: result: $LEX" >&5
6563 echo "${ECHO_T}$LEX" >&6
6564 else
6565   echo "$as_me:$LINENO: result: no" >&5
6566 echo "${ECHO_T}no" >&6
6567 fi
6568
6569   test -n "$LEX" && break
6570 done
6571 test -n "$LEX" || LEX="$MISSING flex"
6572
6573 case " $build_configdirs " in
6574   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6575   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6576 esac
6577
6578 for ac_prog in flex
6579 do
6580   # Extract the first word of "$ac_prog", so it can be a program name with args.
6581 set dummy $ac_prog; ac_word=$2
6582 echo "$as_me:$LINENO: checking for $ac_word" >&5
6583 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6584 if test "${ac_cv_prog_FLEX+set}" = set; then
6585   echo $ECHO_N "(cached) $ECHO_C" >&6
6586 else
6587   if test -n "$FLEX"; then
6588   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6589 else
6590 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6591 for as_dir in $PATH
6592 do
6593   IFS=$as_save_IFS
6594   test -z "$as_dir" && as_dir=.
6595   for ac_exec_ext in '' $ac_executable_extensions; do
6596   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6597     ac_cv_prog_FLEX="$ac_prog"
6598     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6599     break 2
6600   fi
6601 done
6602 done
6603
6604 fi
6605 fi
6606 FLEX=$ac_cv_prog_FLEX
6607 if test -n "$FLEX"; then
6608   echo "$as_me:$LINENO: result: $FLEX" >&5
6609 echo "${ECHO_T}$FLEX" >&6
6610 else
6611   echo "$as_me:$LINENO: result: no" >&5
6612 echo "${ECHO_T}no" >&6
6613 fi
6614
6615   test -n "$FLEX" && break
6616 done
6617 test -n "$FLEX" || FLEX="$MISSING flex"
6618
6619 case " $build_configdirs " in
6620   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6621 esac
6622
6623 for ac_prog in makeinfo
6624 do
6625   # Extract the first word of "$ac_prog", so it can be a program name with args.
6626 set dummy $ac_prog; ac_word=$2
6627 echo "$as_me:$LINENO: checking for $ac_word" >&5
6628 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6629 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6630   echo $ECHO_N "(cached) $ECHO_C" >&6
6631 else
6632   if test -n "$MAKEINFO"; then
6633   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6634 else
6635 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6636 for as_dir in $PATH
6637 do
6638   IFS=$as_save_IFS
6639   test -z "$as_dir" && as_dir=.
6640   for ac_exec_ext in '' $ac_executable_extensions; do
6641   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6642     ac_cv_prog_MAKEINFO="$ac_prog"
6643     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6644     break 2
6645   fi
6646 done
6647 done
6648
6649 fi
6650 fi
6651 MAKEINFO=$ac_cv_prog_MAKEINFO
6652 if test -n "$MAKEINFO"; then
6653   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6654 echo "${ECHO_T}$MAKEINFO" >&6
6655 else
6656   echo "$as_me:$LINENO: result: no" >&5
6657 echo "${ECHO_T}no" >&6
6658 fi
6659
6660   test -n "$MAKEINFO" && break
6661 done
6662 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6663
6664 case " $build_configdirs " in
6665   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6666   *)
6667
6668     # For an installed makeinfo, we require it to be from texinfo 4.7 or
6669     # higher, else we use the "missing" dummy.
6670     if ${MAKEINFO} --version \
6671        | egrep 'texinfo[^0-9]*(4\.([7-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6672       :
6673     else
6674       MAKEINFO="$MISSING makeinfo"
6675     fi
6676     ;;
6677
6678 esac
6679
6680 # FIXME: expect and dejagnu may become build tools?
6681
6682 for ac_prog in expect
6683 do
6684   # Extract the first word of "$ac_prog", so it can be a program name with args.
6685 set dummy $ac_prog; ac_word=$2
6686 echo "$as_me:$LINENO: checking for $ac_word" >&5
6687 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6688 if test "${ac_cv_prog_EXPECT+set}" = set; then
6689   echo $ECHO_N "(cached) $ECHO_C" >&6
6690 else
6691   if test -n "$EXPECT"; then
6692   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6693 else
6694 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6695 for as_dir in $PATH
6696 do
6697   IFS=$as_save_IFS
6698   test -z "$as_dir" && as_dir=.
6699   for ac_exec_ext in '' $ac_executable_extensions; do
6700   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6701     ac_cv_prog_EXPECT="$ac_prog"
6702     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6703     break 2
6704   fi
6705 done
6706 done
6707
6708 fi
6709 fi
6710 EXPECT=$ac_cv_prog_EXPECT
6711 if test -n "$EXPECT"; then
6712   echo "$as_me:$LINENO: result: $EXPECT" >&5
6713 echo "${ECHO_T}$EXPECT" >&6
6714 else
6715   echo "$as_me:$LINENO: result: no" >&5
6716 echo "${ECHO_T}no" >&6
6717 fi
6718
6719   test -n "$EXPECT" && break
6720 done
6721 test -n "$EXPECT" || EXPECT="expect"
6722
6723 case " $configdirs " in
6724   *" expect "*)
6725     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6726     ;;
6727 esac
6728
6729 for ac_prog in runtest
6730 do
6731   # Extract the first word of "$ac_prog", so it can be a program name with args.
6732 set dummy $ac_prog; ac_word=$2
6733 echo "$as_me:$LINENO: checking for $ac_word" >&5
6734 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6735 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6736   echo $ECHO_N "(cached) $ECHO_C" >&6
6737 else
6738   if test -n "$RUNTEST"; then
6739   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6740 else
6741 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6742 for as_dir in $PATH
6743 do
6744   IFS=$as_save_IFS
6745   test -z "$as_dir" && as_dir=.
6746   for ac_exec_ext in '' $ac_executable_extensions; do
6747   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6748     ac_cv_prog_RUNTEST="$ac_prog"
6749     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6750     break 2
6751   fi
6752 done
6753 done
6754
6755 fi
6756 fi
6757 RUNTEST=$ac_cv_prog_RUNTEST
6758 if test -n "$RUNTEST"; then
6759   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6760 echo "${ECHO_T}$RUNTEST" >&6
6761 else
6762   echo "$as_me:$LINENO: result: no" >&5
6763 echo "${ECHO_T}no" >&6
6764 fi
6765
6766   test -n "$RUNTEST" && break
6767 done
6768 test -n "$RUNTEST" || RUNTEST="runtest"
6769
6770 case " $configdirs " in
6771   *" dejagnu "*)
6772     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6773     ;;
6774 esac
6775
6776
6777 # Host tools.
6778 ncn_tool_prefix=
6779 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6780 ncn_target_tool_prefix=
6781 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6782
6783
6784
6785 if test -n "$AR"; then
6786   ac_cv_prog_AR=$AR
6787 elif test -n "$ac_cv_prog_AR"; then
6788   AR=$ac_cv_prog_AR
6789 fi
6790
6791 if test -n "$ac_cv_prog_AR"; then
6792   for ncn_progname in ar; do
6793     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6794 set dummy ${ncn_progname}; ac_word=$2
6795 echo "$as_me:$LINENO: checking for $ac_word" >&5
6796 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6797 if test "${ac_cv_prog_AR+set}" = set; then
6798   echo $ECHO_N "(cached) $ECHO_C" >&6
6799 else
6800   if test -n "$AR"; then
6801   ac_cv_prog_AR="$AR" # Let the user override the test.
6802 else
6803 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6804 for as_dir in $PATH
6805 do
6806   IFS=$as_save_IFS
6807   test -z "$as_dir" && as_dir=.
6808   for ac_exec_ext in '' $ac_executable_extensions; do
6809   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6810     ac_cv_prog_AR="${ncn_progname}"
6811     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6812     break 2
6813   fi
6814 done
6815 done
6816
6817 fi
6818 fi
6819 AR=$ac_cv_prog_AR
6820 if test -n "$AR"; then
6821   echo "$as_me:$LINENO: result: $AR" >&5
6822 echo "${ECHO_T}$AR" >&6
6823 else
6824   echo "$as_me:$LINENO: result: no" >&5
6825 echo "${ECHO_T}no" >&6
6826 fi
6827
6828   done
6829 fi
6830
6831 for ncn_progname in ar; do
6832   if test -n "$ncn_tool_prefix"; then
6833     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6834 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6835 echo "$as_me:$LINENO: checking for $ac_word" >&5
6836 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6837 if test "${ac_cv_prog_AR+set}" = set; then
6838   echo $ECHO_N "(cached) $ECHO_C" >&6
6839 else
6840   if test -n "$AR"; then
6841   ac_cv_prog_AR="$AR" # Let the user override the test.
6842 else
6843 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6844 for as_dir in $PATH
6845 do
6846   IFS=$as_save_IFS
6847   test -z "$as_dir" && as_dir=.
6848   for ac_exec_ext in '' $ac_executable_extensions; do
6849   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6850     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6851     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6852     break 2
6853   fi
6854 done
6855 done
6856
6857 fi
6858 fi
6859 AR=$ac_cv_prog_AR
6860 if test -n "$AR"; then
6861   echo "$as_me:$LINENO: result: $AR" >&5
6862 echo "${ECHO_T}$AR" >&6
6863 else
6864   echo "$as_me:$LINENO: result: no" >&5
6865 echo "${ECHO_T}no" >&6
6866 fi
6867
6868   fi
6869   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6870     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6871 set dummy ${ncn_progname}; ac_word=$2
6872 echo "$as_me:$LINENO: checking for $ac_word" >&5
6873 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6874 if test "${ac_cv_prog_AR+set}" = set; then
6875   echo $ECHO_N "(cached) $ECHO_C" >&6
6876 else
6877   if test -n "$AR"; then
6878   ac_cv_prog_AR="$AR" # Let the user override the test.
6879 else
6880 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6881 for as_dir in $PATH
6882 do
6883   IFS=$as_save_IFS
6884   test -z "$as_dir" && as_dir=.
6885   for ac_exec_ext in '' $ac_executable_extensions; do
6886   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6887     ac_cv_prog_AR="${ncn_progname}"
6888     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6889     break 2
6890   fi
6891 done
6892 done
6893
6894 fi
6895 fi
6896 AR=$ac_cv_prog_AR
6897 if test -n "$AR"; then
6898   echo "$as_me:$LINENO: result: $AR" >&5
6899 echo "${ECHO_T}$AR" >&6
6900 else
6901   echo "$as_me:$LINENO: result: no" >&5
6902 echo "${ECHO_T}no" >&6
6903 fi
6904
6905   fi
6906   test -n "$ac_cv_prog_AR" && break
6907 done
6908
6909 if test -z "$ac_cv_prog_AR" ; then
6910   set dummy ar
6911   if test $build = $host ; then
6912     AR="$2"
6913   else
6914     AR="${ncn_tool_prefix}$2"
6915   fi
6916 fi
6917
6918
6919
6920 if test -n "$AS"; then
6921   ac_cv_prog_AS=$AS
6922 elif test -n "$ac_cv_prog_AS"; then
6923   AS=$ac_cv_prog_AS
6924 fi
6925
6926 if test -n "$ac_cv_prog_AS"; then
6927   for ncn_progname in as; do
6928     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6929 set dummy ${ncn_progname}; ac_word=$2
6930 echo "$as_me:$LINENO: checking for $ac_word" >&5
6931 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6932 if test "${ac_cv_prog_AS+set}" = set; then
6933   echo $ECHO_N "(cached) $ECHO_C" >&6
6934 else
6935   if test -n "$AS"; then
6936   ac_cv_prog_AS="$AS" # Let the user override the test.
6937 else
6938 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6939 for as_dir in $PATH
6940 do
6941   IFS=$as_save_IFS
6942   test -z "$as_dir" && as_dir=.
6943   for ac_exec_ext in '' $ac_executable_extensions; do
6944   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6945     ac_cv_prog_AS="${ncn_progname}"
6946     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6947     break 2
6948   fi
6949 done
6950 done
6951
6952 fi
6953 fi
6954 AS=$ac_cv_prog_AS
6955 if test -n "$AS"; then
6956   echo "$as_me:$LINENO: result: $AS" >&5
6957 echo "${ECHO_T}$AS" >&6
6958 else
6959   echo "$as_me:$LINENO: result: no" >&5
6960 echo "${ECHO_T}no" >&6
6961 fi
6962
6963   done
6964 fi
6965
6966 for ncn_progname in as; do
6967   if test -n "$ncn_tool_prefix"; then
6968     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6969 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6970 echo "$as_me:$LINENO: checking for $ac_word" >&5
6971 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6972 if test "${ac_cv_prog_AS+set}" = set; then
6973   echo $ECHO_N "(cached) $ECHO_C" >&6
6974 else
6975   if test -n "$AS"; then
6976   ac_cv_prog_AS="$AS" # Let the user override the test.
6977 else
6978 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6979 for as_dir in $PATH
6980 do
6981   IFS=$as_save_IFS
6982   test -z "$as_dir" && as_dir=.
6983   for ac_exec_ext in '' $ac_executable_extensions; do
6984   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6985     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6986     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6987     break 2
6988   fi
6989 done
6990 done
6991
6992 fi
6993 fi
6994 AS=$ac_cv_prog_AS
6995 if test -n "$AS"; then
6996   echo "$as_me:$LINENO: result: $AS" >&5
6997 echo "${ECHO_T}$AS" >&6
6998 else
6999   echo "$as_me:$LINENO: result: no" >&5
7000 echo "${ECHO_T}no" >&6
7001 fi
7002
7003   fi
7004   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
7005     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7006 set dummy ${ncn_progname}; ac_word=$2
7007 echo "$as_me:$LINENO: checking for $ac_word" >&5
7008 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7009 if test "${ac_cv_prog_AS+set}" = set; then
7010   echo $ECHO_N "(cached) $ECHO_C" >&6
7011 else
7012   if test -n "$AS"; then
7013   ac_cv_prog_AS="$AS" # Let the user override the test.
7014 else
7015 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7016 for as_dir in $PATH
7017 do
7018   IFS=$as_save_IFS
7019   test -z "$as_dir" && as_dir=.
7020   for ac_exec_ext in '' $ac_executable_extensions; do
7021   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7022     ac_cv_prog_AS="${ncn_progname}"
7023     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7024     break 2
7025   fi
7026 done
7027 done
7028
7029 fi
7030 fi
7031 AS=$ac_cv_prog_AS
7032 if test -n "$AS"; then
7033   echo "$as_me:$LINENO: result: $AS" >&5
7034 echo "${ECHO_T}$AS" >&6
7035 else
7036   echo "$as_me:$LINENO: result: no" >&5
7037 echo "${ECHO_T}no" >&6
7038 fi
7039
7040   fi
7041   test -n "$ac_cv_prog_AS" && break
7042 done
7043
7044 if test -z "$ac_cv_prog_AS" ; then
7045   set dummy as
7046   if test $build = $host ; then
7047     AS="$2"
7048   else
7049     AS="${ncn_tool_prefix}$2"
7050   fi
7051 fi
7052
7053
7054
7055 if test -n "$DLLTOOL"; then
7056   ac_cv_prog_DLLTOOL=$DLLTOOL
7057 elif test -n "$ac_cv_prog_DLLTOOL"; then
7058   DLLTOOL=$ac_cv_prog_DLLTOOL
7059 fi
7060
7061 if test -n "$ac_cv_prog_DLLTOOL"; then
7062   for ncn_progname in dlltool; do
7063     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7064 set dummy ${ncn_progname}; ac_word=$2
7065 echo "$as_me:$LINENO: checking for $ac_word" >&5
7066 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7067 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7068   echo $ECHO_N "(cached) $ECHO_C" >&6
7069 else
7070   if test -n "$DLLTOOL"; then
7071   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7072 else
7073 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7074 for as_dir in $PATH
7075 do
7076   IFS=$as_save_IFS
7077   test -z "$as_dir" && as_dir=.
7078   for ac_exec_ext in '' $ac_executable_extensions; do
7079   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7080     ac_cv_prog_DLLTOOL="${ncn_progname}"
7081     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7082     break 2
7083   fi
7084 done
7085 done
7086
7087 fi
7088 fi
7089 DLLTOOL=$ac_cv_prog_DLLTOOL
7090 if test -n "$DLLTOOL"; then
7091   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7092 echo "${ECHO_T}$DLLTOOL" >&6
7093 else
7094   echo "$as_me:$LINENO: result: no" >&5
7095 echo "${ECHO_T}no" >&6
7096 fi
7097
7098   done
7099 fi
7100
7101 for ncn_progname in dlltool; do
7102   if test -n "$ncn_tool_prefix"; then
7103     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7104 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7105 echo "$as_me:$LINENO: checking for $ac_word" >&5
7106 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7107 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7108   echo $ECHO_N "(cached) $ECHO_C" >&6
7109 else
7110   if test -n "$DLLTOOL"; then
7111   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7112 else
7113 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7114 for as_dir in $PATH
7115 do
7116   IFS=$as_save_IFS
7117   test -z "$as_dir" && as_dir=.
7118   for ac_exec_ext in '' $ac_executable_extensions; do
7119   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7120     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7121     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7122     break 2
7123   fi
7124 done
7125 done
7126
7127 fi
7128 fi
7129 DLLTOOL=$ac_cv_prog_DLLTOOL
7130 if test -n "$DLLTOOL"; then
7131   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7132 echo "${ECHO_T}$DLLTOOL" >&6
7133 else
7134   echo "$as_me:$LINENO: result: no" >&5
7135 echo "${ECHO_T}no" >&6
7136 fi
7137
7138   fi
7139   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7140     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7141 set dummy ${ncn_progname}; ac_word=$2
7142 echo "$as_me:$LINENO: checking for $ac_word" >&5
7143 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7144 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7145   echo $ECHO_N "(cached) $ECHO_C" >&6
7146 else
7147   if test -n "$DLLTOOL"; then
7148   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7149 else
7150 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7151 for as_dir in $PATH
7152 do
7153   IFS=$as_save_IFS
7154   test -z "$as_dir" && as_dir=.
7155   for ac_exec_ext in '' $ac_executable_extensions; do
7156   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7157     ac_cv_prog_DLLTOOL="${ncn_progname}"
7158     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7159     break 2
7160   fi
7161 done
7162 done
7163
7164 fi
7165 fi
7166 DLLTOOL=$ac_cv_prog_DLLTOOL
7167 if test -n "$DLLTOOL"; then
7168   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7169 echo "${ECHO_T}$DLLTOOL" >&6
7170 else
7171   echo "$as_me:$LINENO: result: no" >&5
7172 echo "${ECHO_T}no" >&6
7173 fi
7174
7175   fi
7176   test -n "$ac_cv_prog_DLLTOOL" && break
7177 done
7178
7179 if test -z "$ac_cv_prog_DLLTOOL" ; then
7180   set dummy dlltool
7181   if test $build = $host ; then
7182     DLLTOOL="$2"
7183   else
7184     DLLTOOL="${ncn_tool_prefix}$2"
7185   fi
7186 fi
7187
7188
7189
7190 if test -n "$LD"; then
7191   ac_cv_prog_LD=$LD
7192 elif test -n "$ac_cv_prog_LD"; then
7193   LD=$ac_cv_prog_LD
7194 fi
7195
7196 if test -n "$ac_cv_prog_LD"; then
7197   for ncn_progname in ld; do
7198     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7199 set dummy ${ncn_progname}; ac_word=$2
7200 echo "$as_me:$LINENO: checking for $ac_word" >&5
7201 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7202 if test "${ac_cv_prog_LD+set}" = set; then
7203   echo $ECHO_N "(cached) $ECHO_C" >&6
7204 else
7205   if test -n "$LD"; then
7206   ac_cv_prog_LD="$LD" # Let the user override the test.
7207 else
7208 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7209 for as_dir in $PATH
7210 do
7211   IFS=$as_save_IFS
7212   test -z "$as_dir" && as_dir=.
7213   for ac_exec_ext in '' $ac_executable_extensions; do
7214   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7215     ac_cv_prog_LD="${ncn_progname}"
7216     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7217     break 2
7218   fi
7219 done
7220 done
7221
7222 fi
7223 fi
7224 LD=$ac_cv_prog_LD
7225 if test -n "$LD"; then
7226   echo "$as_me:$LINENO: result: $LD" >&5
7227 echo "${ECHO_T}$LD" >&6
7228 else
7229   echo "$as_me:$LINENO: result: no" >&5
7230 echo "${ECHO_T}no" >&6
7231 fi
7232
7233   done
7234 fi
7235
7236 for ncn_progname in ld; do
7237   if test -n "$ncn_tool_prefix"; then
7238     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7239 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7240 echo "$as_me:$LINENO: checking for $ac_word" >&5
7241 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7242 if test "${ac_cv_prog_LD+set}" = set; then
7243   echo $ECHO_N "(cached) $ECHO_C" >&6
7244 else
7245   if test -n "$LD"; then
7246   ac_cv_prog_LD="$LD" # Let the user override the test.
7247 else
7248 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7249 for as_dir in $PATH
7250 do
7251   IFS=$as_save_IFS
7252   test -z "$as_dir" && as_dir=.
7253   for ac_exec_ext in '' $ac_executable_extensions; do
7254   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7255     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7256     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7257     break 2
7258   fi
7259 done
7260 done
7261
7262 fi
7263 fi
7264 LD=$ac_cv_prog_LD
7265 if test -n "$LD"; then
7266   echo "$as_me:$LINENO: result: $LD" >&5
7267 echo "${ECHO_T}$LD" >&6
7268 else
7269   echo "$as_me:$LINENO: result: no" >&5
7270 echo "${ECHO_T}no" >&6
7271 fi
7272
7273   fi
7274   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7275     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7276 set dummy ${ncn_progname}; ac_word=$2
7277 echo "$as_me:$LINENO: checking for $ac_word" >&5
7278 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7279 if test "${ac_cv_prog_LD+set}" = set; then
7280   echo $ECHO_N "(cached) $ECHO_C" >&6
7281 else
7282   if test -n "$LD"; then
7283   ac_cv_prog_LD="$LD" # Let the user override the test.
7284 else
7285 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7286 for as_dir in $PATH
7287 do
7288   IFS=$as_save_IFS
7289   test -z "$as_dir" && as_dir=.
7290   for ac_exec_ext in '' $ac_executable_extensions; do
7291   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7292     ac_cv_prog_LD="${ncn_progname}"
7293     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7294     break 2
7295   fi
7296 done
7297 done
7298
7299 fi
7300 fi
7301 LD=$ac_cv_prog_LD
7302 if test -n "$LD"; then
7303   echo "$as_me:$LINENO: result: $LD" >&5
7304 echo "${ECHO_T}$LD" >&6
7305 else
7306   echo "$as_me:$LINENO: result: no" >&5
7307 echo "${ECHO_T}no" >&6
7308 fi
7309
7310   fi
7311   test -n "$ac_cv_prog_LD" && break
7312 done
7313
7314 if test -z "$ac_cv_prog_LD" ; then
7315   set dummy ld
7316   if test $build = $host ; then
7317     LD="$2"
7318   else
7319     LD="${ncn_tool_prefix}$2"
7320   fi
7321 fi
7322
7323
7324
7325 if test -n "$LIPO"; then
7326   ac_cv_prog_LIPO=$LIPO
7327 elif test -n "$ac_cv_prog_LIPO"; then
7328   LIPO=$ac_cv_prog_LIPO
7329 fi
7330
7331 if test -n "$ac_cv_prog_LIPO"; then
7332   for ncn_progname in lipo; do
7333     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7334 set dummy ${ncn_progname}; ac_word=$2
7335 echo "$as_me:$LINENO: checking for $ac_word" >&5
7336 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7337 if test "${ac_cv_prog_LIPO+set}" = set; then
7338   echo $ECHO_N "(cached) $ECHO_C" >&6
7339 else
7340   if test -n "$LIPO"; then
7341   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7342 else
7343 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7344 for as_dir in $PATH
7345 do
7346   IFS=$as_save_IFS
7347   test -z "$as_dir" && as_dir=.
7348   for ac_exec_ext in '' $ac_executable_extensions; do
7349   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7350     ac_cv_prog_LIPO="${ncn_progname}"
7351     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7352     break 2
7353   fi
7354 done
7355 done
7356
7357 fi
7358 fi
7359 LIPO=$ac_cv_prog_LIPO
7360 if test -n "$LIPO"; then
7361   echo "$as_me:$LINENO: result: $LIPO" >&5
7362 echo "${ECHO_T}$LIPO" >&6
7363 else
7364   echo "$as_me:$LINENO: result: no" >&5
7365 echo "${ECHO_T}no" >&6
7366 fi
7367
7368   done
7369 fi
7370
7371 for ncn_progname in lipo; do
7372   if test -n "$ncn_tool_prefix"; then
7373     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7374 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7375 echo "$as_me:$LINENO: checking for $ac_word" >&5
7376 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7377 if test "${ac_cv_prog_LIPO+set}" = set; then
7378   echo $ECHO_N "(cached) $ECHO_C" >&6
7379 else
7380   if test -n "$LIPO"; then
7381   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7382 else
7383 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7384 for as_dir in $PATH
7385 do
7386   IFS=$as_save_IFS
7387   test -z "$as_dir" && as_dir=.
7388   for ac_exec_ext in '' $ac_executable_extensions; do
7389   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7390     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7391     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7392     break 2
7393   fi
7394 done
7395 done
7396
7397 fi
7398 fi
7399 LIPO=$ac_cv_prog_LIPO
7400 if test -n "$LIPO"; then
7401   echo "$as_me:$LINENO: result: $LIPO" >&5
7402 echo "${ECHO_T}$LIPO" >&6
7403 else
7404   echo "$as_me:$LINENO: result: no" >&5
7405 echo "${ECHO_T}no" >&6
7406 fi
7407
7408   fi
7409   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7410     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7411 set dummy ${ncn_progname}; ac_word=$2
7412 echo "$as_me:$LINENO: checking for $ac_word" >&5
7413 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7414 if test "${ac_cv_prog_LIPO+set}" = set; then
7415   echo $ECHO_N "(cached) $ECHO_C" >&6
7416 else
7417   if test -n "$LIPO"; then
7418   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7419 else
7420 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7421 for as_dir in $PATH
7422 do
7423   IFS=$as_save_IFS
7424   test -z "$as_dir" && as_dir=.
7425   for ac_exec_ext in '' $ac_executable_extensions; do
7426   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7427     ac_cv_prog_LIPO="${ncn_progname}"
7428     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7429     break 2
7430   fi
7431 done
7432 done
7433
7434 fi
7435 fi
7436 LIPO=$ac_cv_prog_LIPO
7437 if test -n "$LIPO"; then
7438   echo "$as_me:$LINENO: result: $LIPO" >&5
7439 echo "${ECHO_T}$LIPO" >&6
7440 else
7441   echo "$as_me:$LINENO: result: no" >&5
7442 echo "${ECHO_T}no" >&6
7443 fi
7444
7445   fi
7446   test -n "$ac_cv_prog_LIPO" && break
7447 done
7448
7449 if test -z "$ac_cv_prog_LIPO" ; then
7450   set dummy lipo
7451   if test $build = $host ; then
7452     LIPO="$2"
7453   else
7454     LIPO="${ncn_tool_prefix}$2"
7455   fi
7456 fi
7457
7458
7459
7460 if test -n "$NM"; then
7461   ac_cv_prog_NM=$NM
7462 elif test -n "$ac_cv_prog_NM"; then
7463   NM=$ac_cv_prog_NM
7464 fi
7465
7466 if test -n "$ac_cv_prog_NM"; then
7467   for ncn_progname in nm; do
7468     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7469 set dummy ${ncn_progname}; ac_word=$2
7470 echo "$as_me:$LINENO: checking for $ac_word" >&5
7471 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7472 if test "${ac_cv_prog_NM+set}" = set; then
7473   echo $ECHO_N "(cached) $ECHO_C" >&6
7474 else
7475   if test -n "$NM"; then
7476   ac_cv_prog_NM="$NM" # Let the user override the test.
7477 else
7478 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7479 for as_dir in $PATH
7480 do
7481   IFS=$as_save_IFS
7482   test -z "$as_dir" && as_dir=.
7483   for ac_exec_ext in '' $ac_executable_extensions; do
7484   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7485     ac_cv_prog_NM="${ncn_progname}"
7486     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7487     break 2
7488   fi
7489 done
7490 done
7491
7492 fi
7493 fi
7494 NM=$ac_cv_prog_NM
7495 if test -n "$NM"; then
7496   echo "$as_me:$LINENO: result: $NM" >&5
7497 echo "${ECHO_T}$NM" >&6
7498 else
7499   echo "$as_me:$LINENO: result: no" >&5
7500 echo "${ECHO_T}no" >&6
7501 fi
7502
7503   done
7504 fi
7505
7506 for ncn_progname in nm; do
7507   if test -n "$ncn_tool_prefix"; then
7508     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7509 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7510 echo "$as_me:$LINENO: checking for $ac_word" >&5
7511 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7512 if test "${ac_cv_prog_NM+set}" = set; then
7513   echo $ECHO_N "(cached) $ECHO_C" >&6
7514 else
7515   if test -n "$NM"; then
7516   ac_cv_prog_NM="$NM" # Let the user override the test.
7517 else
7518 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7519 for as_dir in $PATH
7520 do
7521   IFS=$as_save_IFS
7522   test -z "$as_dir" && as_dir=.
7523   for ac_exec_ext in '' $ac_executable_extensions; do
7524   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7525     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7526     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7527     break 2
7528   fi
7529 done
7530 done
7531
7532 fi
7533 fi
7534 NM=$ac_cv_prog_NM
7535 if test -n "$NM"; then
7536   echo "$as_me:$LINENO: result: $NM" >&5
7537 echo "${ECHO_T}$NM" >&6
7538 else
7539   echo "$as_me:$LINENO: result: no" >&5
7540 echo "${ECHO_T}no" >&6
7541 fi
7542
7543   fi
7544   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7545     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7546 set dummy ${ncn_progname}; ac_word=$2
7547 echo "$as_me:$LINENO: checking for $ac_word" >&5
7548 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7549 if test "${ac_cv_prog_NM+set}" = set; then
7550   echo $ECHO_N "(cached) $ECHO_C" >&6
7551 else
7552   if test -n "$NM"; then
7553   ac_cv_prog_NM="$NM" # Let the user override the test.
7554 else
7555 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7556 for as_dir in $PATH
7557 do
7558   IFS=$as_save_IFS
7559   test -z "$as_dir" && as_dir=.
7560   for ac_exec_ext in '' $ac_executable_extensions; do
7561   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7562     ac_cv_prog_NM="${ncn_progname}"
7563     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7564     break 2
7565   fi
7566 done
7567 done
7568
7569 fi
7570 fi
7571 NM=$ac_cv_prog_NM
7572 if test -n "$NM"; then
7573   echo "$as_me:$LINENO: result: $NM" >&5
7574 echo "${ECHO_T}$NM" >&6
7575 else
7576   echo "$as_me:$LINENO: result: no" >&5
7577 echo "${ECHO_T}no" >&6
7578 fi
7579
7580   fi
7581   test -n "$ac_cv_prog_NM" && break
7582 done
7583
7584 if test -z "$ac_cv_prog_NM" ; then
7585   set dummy nm
7586   if test $build = $host ; then
7587     NM="$2"
7588   else
7589     NM="${ncn_tool_prefix}$2"
7590   fi
7591 fi
7592
7593
7594
7595 if test -n "$RANLIB"; then
7596   ac_cv_prog_RANLIB=$RANLIB
7597 elif test -n "$ac_cv_prog_RANLIB"; then
7598   RANLIB=$ac_cv_prog_RANLIB
7599 fi
7600
7601 if test -n "$ac_cv_prog_RANLIB"; then
7602   for ncn_progname in ranlib; do
7603     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7604 set dummy ${ncn_progname}; ac_word=$2
7605 echo "$as_me:$LINENO: checking for $ac_word" >&5
7606 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7607 if test "${ac_cv_prog_RANLIB+set}" = set; then
7608   echo $ECHO_N "(cached) $ECHO_C" >&6
7609 else
7610   if test -n "$RANLIB"; then
7611   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7612 else
7613 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7614 for as_dir in $PATH
7615 do
7616   IFS=$as_save_IFS
7617   test -z "$as_dir" && as_dir=.
7618   for ac_exec_ext in '' $ac_executable_extensions; do
7619   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7620     ac_cv_prog_RANLIB="${ncn_progname}"
7621     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7622     break 2
7623   fi
7624 done
7625 done
7626
7627 fi
7628 fi
7629 RANLIB=$ac_cv_prog_RANLIB
7630 if test -n "$RANLIB"; then
7631   echo "$as_me:$LINENO: result: $RANLIB" >&5
7632 echo "${ECHO_T}$RANLIB" >&6
7633 else
7634   echo "$as_me:$LINENO: result: no" >&5
7635 echo "${ECHO_T}no" >&6
7636 fi
7637
7638   done
7639 fi
7640
7641 for ncn_progname in ranlib; do
7642   if test -n "$ncn_tool_prefix"; then
7643     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7644 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7645 echo "$as_me:$LINENO: checking for $ac_word" >&5
7646 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7647 if test "${ac_cv_prog_RANLIB+set}" = set; then
7648   echo $ECHO_N "(cached) $ECHO_C" >&6
7649 else
7650   if test -n "$RANLIB"; then
7651   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7652 else
7653 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7654 for as_dir in $PATH
7655 do
7656   IFS=$as_save_IFS
7657   test -z "$as_dir" && as_dir=.
7658   for ac_exec_ext in '' $ac_executable_extensions; do
7659   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7660     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7661     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7662     break 2
7663   fi
7664 done
7665 done
7666
7667 fi
7668 fi
7669 RANLIB=$ac_cv_prog_RANLIB
7670 if test -n "$RANLIB"; then
7671   echo "$as_me:$LINENO: result: $RANLIB" >&5
7672 echo "${ECHO_T}$RANLIB" >&6
7673 else
7674   echo "$as_me:$LINENO: result: no" >&5
7675 echo "${ECHO_T}no" >&6
7676 fi
7677
7678   fi
7679   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7680     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7681 set dummy ${ncn_progname}; ac_word=$2
7682 echo "$as_me:$LINENO: checking for $ac_word" >&5
7683 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7684 if test "${ac_cv_prog_RANLIB+set}" = set; then
7685   echo $ECHO_N "(cached) $ECHO_C" >&6
7686 else
7687   if test -n "$RANLIB"; then
7688   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7689 else
7690 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7691 for as_dir in $PATH
7692 do
7693   IFS=$as_save_IFS
7694   test -z "$as_dir" && as_dir=.
7695   for ac_exec_ext in '' $ac_executable_extensions; do
7696   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7697     ac_cv_prog_RANLIB="${ncn_progname}"
7698     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7699     break 2
7700   fi
7701 done
7702 done
7703
7704 fi
7705 fi
7706 RANLIB=$ac_cv_prog_RANLIB
7707 if test -n "$RANLIB"; then
7708   echo "$as_me:$LINENO: result: $RANLIB" >&5
7709 echo "${ECHO_T}$RANLIB" >&6
7710 else
7711   echo "$as_me:$LINENO: result: no" >&5
7712 echo "${ECHO_T}no" >&6
7713 fi
7714
7715   fi
7716   test -n "$ac_cv_prog_RANLIB" && break
7717 done
7718
7719 if test -z "$ac_cv_prog_RANLIB" ; then
7720   RANLIB=":"
7721 fi
7722
7723
7724
7725 if test -n "$STRIP"; then
7726   ac_cv_prog_STRIP=$STRIP
7727 elif test -n "$ac_cv_prog_STRIP"; then
7728   STRIP=$ac_cv_prog_STRIP
7729 fi
7730
7731 if test -n "$ac_cv_prog_STRIP"; then
7732   for ncn_progname in strip; do
7733     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7734 set dummy ${ncn_progname}; ac_word=$2
7735 echo "$as_me:$LINENO: checking for $ac_word" >&5
7736 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7737 if test "${ac_cv_prog_STRIP+set}" = set; then
7738   echo $ECHO_N "(cached) $ECHO_C" >&6
7739 else
7740   if test -n "$STRIP"; then
7741   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7742 else
7743 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7744 for as_dir in $PATH
7745 do
7746   IFS=$as_save_IFS
7747   test -z "$as_dir" && as_dir=.
7748   for ac_exec_ext in '' $ac_executable_extensions; do
7749   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7750     ac_cv_prog_STRIP="${ncn_progname}"
7751     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7752     break 2
7753   fi
7754 done
7755 done
7756
7757 fi
7758 fi
7759 STRIP=$ac_cv_prog_STRIP
7760 if test -n "$STRIP"; then
7761   echo "$as_me:$LINENO: result: $STRIP" >&5
7762 echo "${ECHO_T}$STRIP" >&6
7763 else
7764   echo "$as_me:$LINENO: result: no" >&5
7765 echo "${ECHO_T}no" >&6
7766 fi
7767
7768   done
7769 fi
7770
7771 for ncn_progname in strip; do
7772   if test -n "$ncn_tool_prefix"; then
7773     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7774 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7775 echo "$as_me:$LINENO: checking for $ac_word" >&5
7776 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7777 if test "${ac_cv_prog_STRIP+set}" = set; then
7778   echo $ECHO_N "(cached) $ECHO_C" >&6
7779 else
7780   if test -n "$STRIP"; then
7781   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7782 else
7783 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7784 for as_dir in $PATH
7785 do
7786   IFS=$as_save_IFS
7787   test -z "$as_dir" && as_dir=.
7788   for ac_exec_ext in '' $ac_executable_extensions; do
7789   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7790     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7791     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7792     break 2
7793   fi
7794 done
7795 done
7796
7797 fi
7798 fi
7799 STRIP=$ac_cv_prog_STRIP
7800 if test -n "$STRIP"; then
7801   echo "$as_me:$LINENO: result: $STRIP" >&5
7802 echo "${ECHO_T}$STRIP" >&6
7803 else
7804   echo "$as_me:$LINENO: result: no" >&5
7805 echo "${ECHO_T}no" >&6
7806 fi
7807
7808   fi
7809   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7810     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7811 set dummy ${ncn_progname}; ac_word=$2
7812 echo "$as_me:$LINENO: checking for $ac_word" >&5
7813 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7814 if test "${ac_cv_prog_STRIP+set}" = set; then
7815   echo $ECHO_N "(cached) $ECHO_C" >&6
7816 else
7817   if test -n "$STRIP"; then
7818   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7819 else
7820 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7821 for as_dir in $PATH
7822 do
7823   IFS=$as_save_IFS
7824   test -z "$as_dir" && as_dir=.
7825   for ac_exec_ext in '' $ac_executable_extensions; do
7826   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7827     ac_cv_prog_STRIP="${ncn_progname}"
7828     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7829     break 2
7830   fi
7831 done
7832 done
7833
7834 fi
7835 fi
7836 STRIP=$ac_cv_prog_STRIP
7837 if test -n "$STRIP"; then
7838   echo "$as_me:$LINENO: result: $STRIP" >&5
7839 echo "${ECHO_T}$STRIP" >&6
7840 else
7841   echo "$as_me:$LINENO: result: no" >&5
7842 echo "${ECHO_T}no" >&6
7843 fi
7844
7845   fi
7846   test -n "$ac_cv_prog_STRIP" && break
7847 done
7848
7849 if test -z "$ac_cv_prog_STRIP" ; then
7850   STRIP=":"
7851 fi
7852
7853
7854
7855 if test -n "$WINDRES"; then
7856   ac_cv_prog_WINDRES=$WINDRES
7857 elif test -n "$ac_cv_prog_WINDRES"; then
7858   WINDRES=$ac_cv_prog_WINDRES
7859 fi
7860
7861 if test -n "$ac_cv_prog_WINDRES"; then
7862   for ncn_progname in windres; do
7863     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7864 set dummy ${ncn_progname}; ac_word=$2
7865 echo "$as_me:$LINENO: checking for $ac_word" >&5
7866 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7867 if test "${ac_cv_prog_WINDRES+set}" = set; then
7868   echo $ECHO_N "(cached) $ECHO_C" >&6
7869 else
7870   if test -n "$WINDRES"; then
7871   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7872 else
7873 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7874 for as_dir in $PATH
7875 do
7876   IFS=$as_save_IFS
7877   test -z "$as_dir" && as_dir=.
7878   for ac_exec_ext in '' $ac_executable_extensions; do
7879   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7880     ac_cv_prog_WINDRES="${ncn_progname}"
7881     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7882     break 2
7883   fi
7884 done
7885 done
7886
7887 fi
7888 fi
7889 WINDRES=$ac_cv_prog_WINDRES
7890 if test -n "$WINDRES"; then
7891   echo "$as_me:$LINENO: result: $WINDRES" >&5
7892 echo "${ECHO_T}$WINDRES" >&6
7893 else
7894   echo "$as_me:$LINENO: result: no" >&5
7895 echo "${ECHO_T}no" >&6
7896 fi
7897
7898   done
7899 fi
7900
7901 for ncn_progname in windres; do
7902   if test -n "$ncn_tool_prefix"; then
7903     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7904 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7905 echo "$as_me:$LINENO: checking for $ac_word" >&5
7906 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7907 if test "${ac_cv_prog_WINDRES+set}" = set; then
7908   echo $ECHO_N "(cached) $ECHO_C" >&6
7909 else
7910   if test -n "$WINDRES"; then
7911   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7912 else
7913 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7914 for as_dir in $PATH
7915 do
7916   IFS=$as_save_IFS
7917   test -z "$as_dir" && as_dir=.
7918   for ac_exec_ext in '' $ac_executable_extensions; do
7919   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7920     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7921     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7922     break 2
7923   fi
7924 done
7925 done
7926
7927 fi
7928 fi
7929 WINDRES=$ac_cv_prog_WINDRES
7930 if test -n "$WINDRES"; then
7931   echo "$as_me:$LINENO: result: $WINDRES" >&5
7932 echo "${ECHO_T}$WINDRES" >&6
7933 else
7934   echo "$as_me:$LINENO: result: no" >&5
7935 echo "${ECHO_T}no" >&6
7936 fi
7937
7938   fi
7939   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7940     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7941 set dummy ${ncn_progname}; ac_word=$2
7942 echo "$as_me:$LINENO: checking for $ac_word" >&5
7943 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7944 if test "${ac_cv_prog_WINDRES+set}" = set; then
7945   echo $ECHO_N "(cached) $ECHO_C" >&6
7946 else
7947   if test -n "$WINDRES"; then
7948   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7949 else
7950 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7951 for as_dir in $PATH
7952 do
7953   IFS=$as_save_IFS
7954   test -z "$as_dir" && as_dir=.
7955   for ac_exec_ext in '' $ac_executable_extensions; do
7956   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7957     ac_cv_prog_WINDRES="${ncn_progname}"
7958     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7959     break 2
7960   fi
7961 done
7962 done
7963
7964 fi
7965 fi
7966 WINDRES=$ac_cv_prog_WINDRES
7967 if test -n "$WINDRES"; then
7968   echo "$as_me:$LINENO: result: $WINDRES" >&5
7969 echo "${ECHO_T}$WINDRES" >&6
7970 else
7971   echo "$as_me:$LINENO: result: no" >&5
7972 echo "${ECHO_T}no" >&6
7973 fi
7974
7975   fi
7976   test -n "$ac_cv_prog_WINDRES" && break
7977 done
7978
7979 if test -z "$ac_cv_prog_WINDRES" ; then
7980   set dummy windres
7981   if test $build = $host ; then
7982     WINDRES="$2"
7983   else
7984     WINDRES="${ncn_tool_prefix}$2"
7985   fi
7986 fi
7987
7988
7989
7990 if test -n "$WINDMC"; then
7991   ac_cv_prog_WINDMC=$WINDMC
7992 elif test -n "$ac_cv_prog_WINDMC"; then
7993   WINDMC=$ac_cv_prog_WINDMC
7994 fi
7995
7996 if test -n "$ac_cv_prog_WINDMC"; then
7997   for ncn_progname in windmc; do
7998     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7999 set dummy ${ncn_progname}; ac_word=$2
8000 echo "$as_me:$LINENO: checking for $ac_word" >&5
8001 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8002 if test "${ac_cv_prog_WINDMC+set}" = set; then
8003   echo $ECHO_N "(cached) $ECHO_C" >&6
8004 else
8005   if test -n "$WINDMC"; then
8006   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8007 else
8008 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8009 for as_dir in $PATH
8010 do
8011   IFS=$as_save_IFS
8012   test -z "$as_dir" && as_dir=.
8013   for ac_exec_ext in '' $ac_executable_extensions; do
8014   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8015     ac_cv_prog_WINDMC="${ncn_progname}"
8016     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8017     break 2
8018   fi
8019 done
8020 done
8021
8022 fi
8023 fi
8024 WINDMC=$ac_cv_prog_WINDMC
8025 if test -n "$WINDMC"; then
8026   echo "$as_me:$LINENO: result: $WINDMC" >&5
8027 echo "${ECHO_T}$WINDMC" >&6
8028 else
8029   echo "$as_me:$LINENO: result: no" >&5
8030 echo "${ECHO_T}no" >&6
8031 fi
8032
8033   done
8034 fi
8035
8036 for ncn_progname in windmc; do
8037   if test -n "$ncn_tool_prefix"; then
8038     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8039 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8040 echo "$as_me:$LINENO: checking for $ac_word" >&5
8041 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8042 if test "${ac_cv_prog_WINDMC+set}" = set; then
8043   echo $ECHO_N "(cached) $ECHO_C" >&6
8044 else
8045   if test -n "$WINDMC"; then
8046   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8047 else
8048 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8049 for as_dir in $PATH
8050 do
8051   IFS=$as_save_IFS
8052   test -z "$as_dir" && as_dir=.
8053   for ac_exec_ext in '' $ac_executable_extensions; do
8054   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8055     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8056     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8057     break 2
8058   fi
8059 done
8060 done
8061
8062 fi
8063 fi
8064 WINDMC=$ac_cv_prog_WINDMC
8065 if test -n "$WINDMC"; then
8066   echo "$as_me:$LINENO: result: $WINDMC" >&5
8067 echo "${ECHO_T}$WINDMC" >&6
8068 else
8069   echo "$as_me:$LINENO: result: no" >&5
8070 echo "${ECHO_T}no" >&6
8071 fi
8072
8073   fi
8074   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8075     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8076 set dummy ${ncn_progname}; ac_word=$2
8077 echo "$as_me:$LINENO: checking for $ac_word" >&5
8078 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8079 if test "${ac_cv_prog_WINDMC+set}" = set; then
8080   echo $ECHO_N "(cached) $ECHO_C" >&6
8081 else
8082   if test -n "$WINDMC"; then
8083   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8084 else
8085 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8086 for as_dir in $PATH
8087 do
8088   IFS=$as_save_IFS
8089   test -z "$as_dir" && as_dir=.
8090   for ac_exec_ext in '' $ac_executable_extensions; do
8091   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8092     ac_cv_prog_WINDMC="${ncn_progname}"
8093     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8094     break 2
8095   fi
8096 done
8097 done
8098
8099 fi
8100 fi
8101 WINDMC=$ac_cv_prog_WINDMC
8102 if test -n "$WINDMC"; then
8103   echo "$as_me:$LINENO: result: $WINDMC" >&5
8104 echo "${ECHO_T}$WINDMC" >&6
8105 else
8106   echo "$as_me:$LINENO: result: no" >&5
8107 echo "${ECHO_T}no" >&6
8108 fi
8109
8110   fi
8111   test -n "$ac_cv_prog_WINDMC" && break
8112 done
8113
8114 if test -z "$ac_cv_prog_WINDMC" ; then
8115   set dummy windmc
8116   if test $build = $host ; then
8117     WINDMC="$2"
8118   else
8119     WINDMC="${ncn_tool_prefix}$2"
8120   fi
8121 fi
8122
8123
8124
8125 if test -n "$OBJCOPY"; then
8126   ac_cv_prog_OBJCOPY=$OBJCOPY
8127 elif test -n "$ac_cv_prog_OBJCOPY"; then
8128   OBJCOPY=$ac_cv_prog_OBJCOPY
8129 fi
8130
8131 if test -n "$ac_cv_prog_OBJCOPY"; then
8132   for ncn_progname in objcopy; do
8133     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8134 set dummy ${ncn_progname}; ac_word=$2
8135 echo "$as_me:$LINENO: checking for $ac_word" >&5
8136 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8137 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8138   echo $ECHO_N "(cached) $ECHO_C" >&6
8139 else
8140   if test -n "$OBJCOPY"; then
8141   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8142 else
8143 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8144 for as_dir in $PATH
8145 do
8146   IFS=$as_save_IFS
8147   test -z "$as_dir" && as_dir=.
8148   for ac_exec_ext in '' $ac_executable_extensions; do
8149   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8150     ac_cv_prog_OBJCOPY="${ncn_progname}"
8151     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8152     break 2
8153   fi
8154 done
8155 done
8156
8157 fi
8158 fi
8159 OBJCOPY=$ac_cv_prog_OBJCOPY
8160 if test -n "$OBJCOPY"; then
8161   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8162 echo "${ECHO_T}$OBJCOPY" >&6
8163 else
8164   echo "$as_me:$LINENO: result: no" >&5
8165 echo "${ECHO_T}no" >&6
8166 fi
8167
8168   done
8169 fi
8170
8171 for ncn_progname in objcopy; do
8172   if test -n "$ncn_tool_prefix"; then
8173     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8174 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8175 echo "$as_me:$LINENO: checking for $ac_word" >&5
8176 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8177 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8178   echo $ECHO_N "(cached) $ECHO_C" >&6
8179 else
8180   if test -n "$OBJCOPY"; then
8181   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8182 else
8183 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8184 for as_dir in $PATH
8185 do
8186   IFS=$as_save_IFS
8187   test -z "$as_dir" && as_dir=.
8188   for ac_exec_ext in '' $ac_executable_extensions; do
8189   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8190     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8191     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8192     break 2
8193   fi
8194 done
8195 done
8196
8197 fi
8198 fi
8199 OBJCOPY=$ac_cv_prog_OBJCOPY
8200 if test -n "$OBJCOPY"; then
8201   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8202 echo "${ECHO_T}$OBJCOPY" >&6
8203 else
8204   echo "$as_me:$LINENO: result: no" >&5
8205 echo "${ECHO_T}no" >&6
8206 fi
8207
8208   fi
8209   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8210     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8211 set dummy ${ncn_progname}; ac_word=$2
8212 echo "$as_me:$LINENO: checking for $ac_word" >&5
8213 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8214 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8215   echo $ECHO_N "(cached) $ECHO_C" >&6
8216 else
8217   if test -n "$OBJCOPY"; then
8218   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8219 else
8220 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8221 for as_dir in $PATH
8222 do
8223   IFS=$as_save_IFS
8224   test -z "$as_dir" && as_dir=.
8225   for ac_exec_ext in '' $ac_executable_extensions; do
8226   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8227     ac_cv_prog_OBJCOPY="${ncn_progname}"
8228     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8229     break 2
8230   fi
8231 done
8232 done
8233
8234 fi
8235 fi
8236 OBJCOPY=$ac_cv_prog_OBJCOPY
8237 if test -n "$OBJCOPY"; then
8238   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8239 echo "${ECHO_T}$OBJCOPY" >&6
8240 else
8241   echo "$as_me:$LINENO: result: no" >&5
8242 echo "${ECHO_T}no" >&6
8243 fi
8244
8245   fi
8246   test -n "$ac_cv_prog_OBJCOPY" && break
8247 done
8248
8249 if test -z "$ac_cv_prog_OBJCOPY" ; then
8250   set dummy objcopy
8251   if test $build = $host ; then
8252     OBJCOPY="$2"
8253   else
8254     OBJCOPY="${ncn_tool_prefix}$2"
8255   fi
8256 fi
8257
8258
8259
8260 if test -n "$OBJDUMP"; then
8261   ac_cv_prog_OBJDUMP=$OBJDUMP
8262 elif test -n "$ac_cv_prog_OBJDUMP"; then
8263   OBJDUMP=$ac_cv_prog_OBJDUMP
8264 fi
8265
8266 if test -n "$ac_cv_prog_OBJDUMP"; then
8267   for ncn_progname in objdump; do
8268     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8269 set dummy ${ncn_progname}; ac_word=$2
8270 echo "$as_me:$LINENO: checking for $ac_word" >&5
8271 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8272 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8273   echo $ECHO_N "(cached) $ECHO_C" >&6
8274 else
8275   if test -n "$OBJDUMP"; then
8276   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8277 else
8278 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8279 for as_dir in $PATH
8280 do
8281   IFS=$as_save_IFS
8282   test -z "$as_dir" && as_dir=.
8283   for ac_exec_ext in '' $ac_executable_extensions; do
8284   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8285     ac_cv_prog_OBJDUMP="${ncn_progname}"
8286     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8287     break 2
8288   fi
8289 done
8290 done
8291
8292 fi
8293 fi
8294 OBJDUMP=$ac_cv_prog_OBJDUMP
8295 if test -n "$OBJDUMP"; then
8296   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8297 echo "${ECHO_T}$OBJDUMP" >&6
8298 else
8299   echo "$as_me:$LINENO: result: no" >&5
8300 echo "${ECHO_T}no" >&6
8301 fi
8302
8303   done
8304 fi
8305
8306 for ncn_progname in objdump; do
8307   if test -n "$ncn_tool_prefix"; then
8308     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8309 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8310 echo "$as_me:$LINENO: checking for $ac_word" >&5
8311 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8312 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8313   echo $ECHO_N "(cached) $ECHO_C" >&6
8314 else
8315   if test -n "$OBJDUMP"; then
8316   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8317 else
8318 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8319 for as_dir in $PATH
8320 do
8321   IFS=$as_save_IFS
8322   test -z "$as_dir" && as_dir=.
8323   for ac_exec_ext in '' $ac_executable_extensions; do
8324   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8325     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8326     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8327     break 2
8328   fi
8329 done
8330 done
8331
8332 fi
8333 fi
8334 OBJDUMP=$ac_cv_prog_OBJDUMP
8335 if test -n "$OBJDUMP"; then
8336   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8337 echo "${ECHO_T}$OBJDUMP" >&6
8338 else
8339   echo "$as_me:$LINENO: result: no" >&5
8340 echo "${ECHO_T}no" >&6
8341 fi
8342
8343   fi
8344   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8345     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8346 set dummy ${ncn_progname}; ac_word=$2
8347 echo "$as_me:$LINENO: checking for $ac_word" >&5
8348 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8349 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8350   echo $ECHO_N "(cached) $ECHO_C" >&6
8351 else
8352   if test -n "$OBJDUMP"; then
8353   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8354 else
8355 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8356 for as_dir in $PATH
8357 do
8358   IFS=$as_save_IFS
8359   test -z "$as_dir" && as_dir=.
8360   for ac_exec_ext in '' $ac_executable_extensions; do
8361   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8362     ac_cv_prog_OBJDUMP="${ncn_progname}"
8363     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8364     break 2
8365   fi
8366 done
8367 done
8368
8369 fi
8370 fi
8371 OBJDUMP=$ac_cv_prog_OBJDUMP
8372 if test -n "$OBJDUMP"; then
8373   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8374 echo "${ECHO_T}$OBJDUMP" >&6
8375 else
8376   echo "$as_me:$LINENO: result: no" >&5
8377 echo "${ECHO_T}no" >&6
8378 fi
8379
8380   fi
8381   test -n "$ac_cv_prog_OBJDUMP" && break
8382 done
8383
8384 if test -z "$ac_cv_prog_OBJDUMP" ; then
8385   set dummy objdump
8386   if test $build = $host ; then
8387     OBJDUMP="$2"
8388   else
8389     OBJDUMP="${ncn_tool_prefix}$2"
8390   fi
8391 fi
8392
8393
8394
8395
8396
8397
8398 # Target tools.
8399
8400 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8401 if test "${with_build_time_tools+set}" = set; then
8402   withval="$with_build_time_tools"
8403   case x"$withval" in
8404      x/*) ;;
8405      *)
8406        with_build_time_tools=
8407        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8408 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8409        ;;
8410    esac
8411 else
8412   with_build_time_tools=
8413 fi;
8414
8415
8416
8417 if test -n "$CC_FOR_TARGET"; then
8418   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8419 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8420   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8421 fi
8422
8423 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8424   for ncn_progname in cc gcc; do
8425     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8426 set dummy ${ncn_progname}; ac_word=$2
8427 echo "$as_me:$LINENO: checking for $ac_word" >&5
8428 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8429 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8430   echo $ECHO_N "(cached) $ECHO_C" >&6
8431 else
8432   if test -n "$CC_FOR_TARGET"; then
8433   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8434 else
8435 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8436 for as_dir in $PATH
8437 do
8438   IFS=$as_save_IFS
8439   test -z "$as_dir" && as_dir=.
8440   for ac_exec_ext in '' $ac_executable_extensions; do
8441   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8442     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8443     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8444     break 2
8445   fi
8446 done
8447 done
8448
8449 fi
8450 fi
8451 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8452 if test -n "$CC_FOR_TARGET"; then
8453   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8454 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8455 else
8456   echo "$as_me:$LINENO: result: no" >&5
8457 echo "${ECHO_T}no" >&6
8458 fi
8459
8460   done
8461 fi
8462
8463 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8464   for ncn_progname in cc gcc; do
8465     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8466 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8467     if test -x $with_build_time_tools/${ncn_progname}; then
8468       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8469       echo "$as_me:$LINENO: result: yes" >&5
8470 echo "${ECHO_T}yes" >&6
8471       break
8472     else
8473       echo "$as_me:$LINENO: result: no" >&5
8474 echo "${ECHO_T}no" >&6
8475     fi
8476   done
8477 fi
8478
8479 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8480   for ncn_progname in cc gcc; do
8481     if test -n "$ncn_target_tool_prefix"; then
8482       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8483 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8484 echo "$as_me:$LINENO: checking for $ac_word" >&5
8485 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8486 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8487   echo $ECHO_N "(cached) $ECHO_C" >&6
8488 else
8489   if test -n "$CC_FOR_TARGET"; then
8490   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8491 else
8492 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8493 for as_dir in $PATH
8494 do
8495   IFS=$as_save_IFS
8496   test -z "$as_dir" && as_dir=.
8497   for ac_exec_ext in '' $ac_executable_extensions; do
8498   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8499     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8500     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8501     break 2
8502   fi
8503 done
8504 done
8505
8506 fi
8507 fi
8508 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8509 if test -n "$CC_FOR_TARGET"; then
8510   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8511 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8512 else
8513   echo "$as_me:$LINENO: result: no" >&5
8514 echo "${ECHO_T}no" >&6
8515 fi
8516
8517     fi
8518     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8519       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8520 set dummy ${ncn_progname}; ac_word=$2
8521 echo "$as_me:$LINENO: checking for $ac_word" >&5
8522 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8523 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8524   echo $ECHO_N "(cached) $ECHO_C" >&6
8525 else
8526   if test -n "$CC_FOR_TARGET"; then
8527   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8528 else
8529 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8530 for as_dir in $PATH
8531 do
8532   IFS=$as_save_IFS
8533   test -z "$as_dir" && as_dir=.
8534   for ac_exec_ext in '' $ac_executable_extensions; do
8535   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8536     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8537     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8538     break 2
8539   fi
8540 done
8541 done
8542
8543 fi
8544 fi
8545 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8546 if test -n "$CC_FOR_TARGET"; then
8547   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8548 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8549 else
8550   echo "$as_me:$LINENO: result: no" >&5
8551 echo "${ECHO_T}no" >&6
8552 fi
8553
8554     fi
8555     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8556   done
8557 fi
8558
8559 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8560   set dummy cc gcc
8561   if test $build = $target ; then
8562     CC_FOR_TARGET="$2"
8563   else
8564     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8565   fi
8566 else
8567   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8568 fi
8569
8570
8571
8572 if test -n "$CXX_FOR_TARGET"; then
8573   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8574 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8575   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8576 fi
8577
8578 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8579   for ncn_progname in c++ g++ cxx gxx; do
8580     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8581 set dummy ${ncn_progname}; ac_word=$2
8582 echo "$as_me:$LINENO: checking for $ac_word" >&5
8583 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8584 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8585   echo $ECHO_N "(cached) $ECHO_C" >&6
8586 else
8587   if test -n "$CXX_FOR_TARGET"; then
8588   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8589 else
8590 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8591 for as_dir in $PATH
8592 do
8593   IFS=$as_save_IFS
8594   test -z "$as_dir" && as_dir=.
8595   for ac_exec_ext in '' $ac_executable_extensions; do
8596   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8597     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8598     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8599     break 2
8600   fi
8601 done
8602 done
8603
8604 fi
8605 fi
8606 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8607 if test -n "$CXX_FOR_TARGET"; then
8608   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8609 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8610 else
8611   echo "$as_me:$LINENO: result: no" >&5
8612 echo "${ECHO_T}no" >&6
8613 fi
8614
8615   done
8616 fi
8617
8618 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8619   for ncn_progname in c++ g++ cxx gxx; do
8620     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8621 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8622     if test -x $with_build_time_tools/${ncn_progname}; then
8623       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8624       echo "$as_me:$LINENO: result: yes" >&5
8625 echo "${ECHO_T}yes" >&6
8626       break
8627     else
8628       echo "$as_me:$LINENO: result: no" >&5
8629 echo "${ECHO_T}no" >&6
8630     fi
8631   done
8632 fi
8633
8634 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8635   for ncn_progname in c++ g++ cxx gxx; do
8636     if test -n "$ncn_target_tool_prefix"; then
8637       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8638 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8639 echo "$as_me:$LINENO: checking for $ac_word" >&5
8640 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8641 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8642   echo $ECHO_N "(cached) $ECHO_C" >&6
8643 else
8644   if test -n "$CXX_FOR_TARGET"; then
8645   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8646 else
8647 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8648 for as_dir in $PATH
8649 do
8650   IFS=$as_save_IFS
8651   test -z "$as_dir" && as_dir=.
8652   for ac_exec_ext in '' $ac_executable_extensions; do
8653   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8654     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8655     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8656     break 2
8657   fi
8658 done
8659 done
8660
8661 fi
8662 fi
8663 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8664 if test -n "$CXX_FOR_TARGET"; then
8665   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8666 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8667 else
8668   echo "$as_me:$LINENO: result: no" >&5
8669 echo "${ECHO_T}no" >&6
8670 fi
8671
8672     fi
8673     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8674       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8675 set dummy ${ncn_progname}; ac_word=$2
8676 echo "$as_me:$LINENO: checking for $ac_word" >&5
8677 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8678 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8679   echo $ECHO_N "(cached) $ECHO_C" >&6
8680 else
8681   if test -n "$CXX_FOR_TARGET"; then
8682   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8683 else
8684 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8685 for as_dir in $PATH
8686 do
8687   IFS=$as_save_IFS
8688   test -z "$as_dir" && as_dir=.
8689   for ac_exec_ext in '' $ac_executable_extensions; do
8690   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8691     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8692     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8693     break 2
8694   fi
8695 done
8696 done
8697
8698 fi
8699 fi
8700 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8701 if test -n "$CXX_FOR_TARGET"; then
8702   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8703 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8704 else
8705   echo "$as_me:$LINENO: result: no" >&5
8706 echo "${ECHO_T}no" >&6
8707 fi
8708
8709     fi
8710     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8711   done
8712 fi
8713
8714 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8715   set dummy c++ g++ cxx gxx
8716   if test $build = $target ; then
8717     CXX_FOR_TARGET="$2"
8718   else
8719     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8720   fi
8721 else
8722   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8723 fi
8724
8725
8726
8727 if test -n "$GCC_FOR_TARGET"; then
8728   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8729 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8730   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8731 fi
8732
8733 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8734   for ncn_progname in gcc; do
8735     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8736 set dummy ${ncn_progname}; ac_word=$2
8737 echo "$as_me:$LINENO: checking for $ac_word" >&5
8738 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8739 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8740   echo $ECHO_N "(cached) $ECHO_C" >&6
8741 else
8742   if test -n "$GCC_FOR_TARGET"; then
8743   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8744 else
8745 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8746 for as_dir in $PATH
8747 do
8748   IFS=$as_save_IFS
8749   test -z "$as_dir" && as_dir=.
8750   for ac_exec_ext in '' $ac_executable_extensions; do
8751   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8752     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8753     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8754     break 2
8755   fi
8756 done
8757 done
8758
8759 fi
8760 fi
8761 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8762 if test -n "$GCC_FOR_TARGET"; then
8763   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8764 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8765 else
8766   echo "$as_me:$LINENO: result: no" >&5
8767 echo "${ECHO_T}no" >&6
8768 fi
8769
8770   done
8771 fi
8772
8773 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8774   for ncn_progname in gcc; do
8775     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8776 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8777     if test -x $with_build_time_tools/${ncn_progname}; then
8778       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8779       echo "$as_me:$LINENO: result: yes" >&5
8780 echo "${ECHO_T}yes" >&6
8781       break
8782     else
8783       echo "$as_me:$LINENO: result: no" >&5
8784 echo "${ECHO_T}no" >&6
8785     fi
8786   done
8787 fi
8788
8789 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8790   for ncn_progname in gcc; do
8791     if test -n "$ncn_target_tool_prefix"; then
8792       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8793 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8794 echo "$as_me:$LINENO: checking for $ac_word" >&5
8795 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8796 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8797   echo $ECHO_N "(cached) $ECHO_C" >&6
8798 else
8799   if test -n "$GCC_FOR_TARGET"; then
8800   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8801 else
8802 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8803 for as_dir in $PATH
8804 do
8805   IFS=$as_save_IFS
8806   test -z "$as_dir" && as_dir=.
8807   for ac_exec_ext in '' $ac_executable_extensions; do
8808   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8809     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8810     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8811     break 2
8812   fi
8813 done
8814 done
8815
8816 fi
8817 fi
8818 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8819 if test -n "$GCC_FOR_TARGET"; then
8820   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8821 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8822 else
8823   echo "$as_me:$LINENO: result: no" >&5
8824 echo "${ECHO_T}no" >&6
8825 fi
8826
8827     fi
8828     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8829       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8830 set dummy ${ncn_progname}; ac_word=$2
8831 echo "$as_me:$LINENO: checking for $ac_word" >&5
8832 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8833 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8834   echo $ECHO_N "(cached) $ECHO_C" >&6
8835 else
8836   if test -n "$GCC_FOR_TARGET"; then
8837   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8838 else
8839 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8840 for as_dir in $PATH
8841 do
8842   IFS=$as_save_IFS
8843   test -z "$as_dir" && as_dir=.
8844   for ac_exec_ext in '' $ac_executable_extensions; do
8845   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8846     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8847     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8848     break 2
8849   fi
8850 done
8851 done
8852
8853 fi
8854 fi
8855 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8856 if test -n "$GCC_FOR_TARGET"; then
8857   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8858 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8859 else
8860   echo "$as_me:$LINENO: result: no" >&5
8861 echo "${ECHO_T}no" >&6
8862 fi
8863
8864     fi
8865     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8866   done
8867 fi
8868
8869 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8870   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8871 else
8872   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8873 fi
8874
8875
8876
8877 if test -n "$GCJ_FOR_TARGET"; then
8878   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8879 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8880   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8881 fi
8882
8883 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8884   for ncn_progname in gcj; do
8885     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8886 set dummy ${ncn_progname}; ac_word=$2
8887 echo "$as_me:$LINENO: checking for $ac_word" >&5
8888 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8889 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8890   echo $ECHO_N "(cached) $ECHO_C" >&6
8891 else
8892   if test -n "$GCJ_FOR_TARGET"; then
8893   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8894 else
8895 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8896 for as_dir in $PATH
8897 do
8898   IFS=$as_save_IFS
8899   test -z "$as_dir" && as_dir=.
8900   for ac_exec_ext in '' $ac_executable_extensions; do
8901   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8902     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8903     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8904     break 2
8905   fi
8906 done
8907 done
8908
8909 fi
8910 fi
8911 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8912 if test -n "$GCJ_FOR_TARGET"; then
8913   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8914 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8915 else
8916   echo "$as_me:$LINENO: result: no" >&5
8917 echo "${ECHO_T}no" >&6
8918 fi
8919
8920   done
8921 fi
8922
8923 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8924   for ncn_progname in gcj; do
8925     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8926 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8927     if test -x $with_build_time_tools/${ncn_progname}; then
8928       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8929       echo "$as_me:$LINENO: result: yes" >&5
8930 echo "${ECHO_T}yes" >&6
8931       break
8932     else
8933       echo "$as_me:$LINENO: result: no" >&5
8934 echo "${ECHO_T}no" >&6
8935     fi
8936   done
8937 fi
8938
8939 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8940   for ncn_progname in gcj; do
8941     if test -n "$ncn_target_tool_prefix"; then
8942       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8943 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8944 echo "$as_me:$LINENO: checking for $ac_word" >&5
8945 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8946 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8947   echo $ECHO_N "(cached) $ECHO_C" >&6
8948 else
8949   if test -n "$GCJ_FOR_TARGET"; then
8950   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8951 else
8952 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8953 for as_dir in $PATH
8954 do
8955   IFS=$as_save_IFS
8956   test -z "$as_dir" && as_dir=.
8957   for ac_exec_ext in '' $ac_executable_extensions; do
8958   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8959     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8960     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8961     break 2
8962   fi
8963 done
8964 done
8965
8966 fi
8967 fi
8968 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8969 if test -n "$GCJ_FOR_TARGET"; then
8970   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8971 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8972 else
8973   echo "$as_me:$LINENO: result: no" >&5
8974 echo "${ECHO_T}no" >&6
8975 fi
8976
8977     fi
8978     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8979       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8980 set dummy ${ncn_progname}; ac_word=$2
8981 echo "$as_me:$LINENO: checking for $ac_word" >&5
8982 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8983 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8984   echo $ECHO_N "(cached) $ECHO_C" >&6
8985 else
8986   if test -n "$GCJ_FOR_TARGET"; then
8987   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8988 else
8989 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8990 for as_dir in $PATH
8991 do
8992   IFS=$as_save_IFS
8993   test -z "$as_dir" && as_dir=.
8994   for ac_exec_ext in '' $ac_executable_extensions; do
8995   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8996     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8997     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8998     break 2
8999   fi
9000 done
9001 done
9002
9003 fi
9004 fi
9005 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9006 if test -n "$GCJ_FOR_TARGET"; then
9007   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9008 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9009 else
9010   echo "$as_me:$LINENO: result: no" >&5
9011 echo "${ECHO_T}no" >&6
9012 fi
9013
9014     fi
9015     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
9016   done
9017 fi
9018
9019 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9020   set dummy gcj
9021   if test $build = $target ; then
9022     GCJ_FOR_TARGET="$2"
9023   else
9024     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9025   fi
9026 else
9027   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9028 fi
9029
9030
9031
9032 if test -n "$GFORTRAN_FOR_TARGET"; then
9033   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9034 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9035   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9036 fi
9037
9038 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9039   for ncn_progname in gfortran; do
9040     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9041 set dummy ${ncn_progname}; ac_word=$2
9042 echo "$as_me:$LINENO: checking for $ac_word" >&5
9043 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9044 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9045   echo $ECHO_N "(cached) $ECHO_C" >&6
9046 else
9047   if test -n "$GFORTRAN_FOR_TARGET"; then
9048   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9049 else
9050 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9051 for as_dir in $PATH
9052 do
9053   IFS=$as_save_IFS
9054   test -z "$as_dir" && as_dir=.
9055   for ac_exec_ext in '' $ac_executable_extensions; do
9056   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9057     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9058     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9059     break 2
9060   fi
9061 done
9062 done
9063
9064 fi
9065 fi
9066 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9067 if test -n "$GFORTRAN_FOR_TARGET"; then
9068   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9069 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9070 else
9071   echo "$as_me:$LINENO: result: no" >&5
9072 echo "${ECHO_T}no" >&6
9073 fi
9074
9075   done
9076 fi
9077
9078 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9079   for ncn_progname in gfortran; do
9080     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9081 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9082     if test -x $with_build_time_tools/${ncn_progname}; then
9083       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9084       echo "$as_me:$LINENO: result: yes" >&5
9085 echo "${ECHO_T}yes" >&6
9086       break
9087     else
9088       echo "$as_me:$LINENO: result: no" >&5
9089 echo "${ECHO_T}no" >&6
9090     fi
9091   done
9092 fi
9093
9094 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9095   for ncn_progname in gfortran; do
9096     if test -n "$ncn_target_tool_prefix"; then
9097       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9098 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9099 echo "$as_me:$LINENO: checking for $ac_word" >&5
9100 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9101 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9102   echo $ECHO_N "(cached) $ECHO_C" >&6
9103 else
9104   if test -n "$GFORTRAN_FOR_TARGET"; then
9105   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9106 else
9107 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9108 for as_dir in $PATH
9109 do
9110   IFS=$as_save_IFS
9111   test -z "$as_dir" && as_dir=.
9112   for ac_exec_ext in '' $ac_executable_extensions; do
9113   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9114     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9115     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9116     break 2
9117   fi
9118 done
9119 done
9120
9121 fi
9122 fi
9123 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9124 if test -n "$GFORTRAN_FOR_TARGET"; then
9125   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9126 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9127 else
9128   echo "$as_me:$LINENO: result: no" >&5
9129 echo "${ECHO_T}no" >&6
9130 fi
9131
9132     fi
9133     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9134       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9135 set dummy ${ncn_progname}; ac_word=$2
9136 echo "$as_me:$LINENO: checking for $ac_word" >&5
9137 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9138 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9139   echo $ECHO_N "(cached) $ECHO_C" >&6
9140 else
9141   if test -n "$GFORTRAN_FOR_TARGET"; then
9142   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9143 else
9144 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9145 for as_dir in $PATH
9146 do
9147   IFS=$as_save_IFS
9148   test -z "$as_dir" && as_dir=.
9149   for ac_exec_ext in '' $ac_executable_extensions; do
9150   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9151     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9152     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9153     break 2
9154   fi
9155 done
9156 done
9157
9158 fi
9159 fi
9160 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9161 if test -n "$GFORTRAN_FOR_TARGET"; then
9162   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9163 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9164 else
9165   echo "$as_me:$LINENO: result: no" >&5
9166 echo "${ECHO_T}no" >&6
9167 fi
9168
9169     fi
9170     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9171   done
9172 fi
9173
9174 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9175   set dummy gfortran
9176   if test $build = $target ; then
9177     GFORTRAN_FOR_TARGET="$2"
9178   else
9179     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9180   fi
9181 else
9182   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9183 fi
9184
9185
9186
9187 cat > conftest.c << \EOF
9188 #ifdef __GNUC__
9189   gcc_yay;
9190 #endif
9191 EOF
9192 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9193   have_gcc_for_target=yes
9194 else
9195   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9196   have_gcc_for_target=no
9197 fi
9198 rm conftest.c
9199
9200
9201
9202
9203 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9204   if test -n "$with_build_time_tools"; then
9205     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9206 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9207     if test -x $with_build_time_tools/ar; then
9208       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9209       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9210       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9211 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9212     else
9213       echo "$as_me:$LINENO: result: no" >&5
9214 echo "${ECHO_T}no" >&6
9215     fi
9216   elif test $build != $host && test $have_gcc_for_target = yes; then
9217     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9218     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9219     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9220   fi
9221 fi
9222 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9223   # Extract the first word of "ar", so it can be a program name with args.
9224 set dummy ar; ac_word=$2
9225 echo "$as_me:$LINENO: checking for $ac_word" >&5
9226 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9227 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9228   echo $ECHO_N "(cached) $ECHO_C" >&6
9229 else
9230   case $AR_FOR_TARGET in
9231   [\\/]* | ?:[\\/]*)
9232   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9233   ;;
9234   *)
9235   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9236 for as_dir in $gcc_cv_tool_dirs
9237 do
9238   IFS=$as_save_IFS
9239   test -z "$as_dir" && as_dir=.
9240   for ac_exec_ext in '' $ac_executable_extensions; do
9241   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9242     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9243     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9244     break 2
9245   fi
9246 done
9247 done
9248
9249   ;;
9250 esac
9251 fi
9252 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9253
9254 if test -n "$AR_FOR_TARGET"; then
9255   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9256 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9257 else
9258   echo "$as_me:$LINENO: result: no" >&5
9259 echo "${ECHO_T}no" >&6
9260 fi
9261
9262 fi
9263 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9264
9265
9266 if test -n "$AR_FOR_TARGET"; then
9267   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9268 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9269   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9270 fi
9271
9272 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9273   for ncn_progname in ar; do
9274     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9275 set dummy ${ncn_progname}; ac_word=$2
9276 echo "$as_me:$LINENO: checking for $ac_word" >&5
9277 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9278 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9279   echo $ECHO_N "(cached) $ECHO_C" >&6
9280 else
9281   if test -n "$AR_FOR_TARGET"; then
9282   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9283 else
9284 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9285 for as_dir in $PATH
9286 do
9287   IFS=$as_save_IFS
9288   test -z "$as_dir" && as_dir=.
9289   for ac_exec_ext in '' $ac_executable_extensions; do
9290   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9291     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9292     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9293     break 2
9294   fi
9295 done
9296 done
9297
9298 fi
9299 fi
9300 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9301 if test -n "$AR_FOR_TARGET"; then
9302   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9303 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9304 else
9305   echo "$as_me:$LINENO: result: no" >&5
9306 echo "${ECHO_T}no" >&6
9307 fi
9308
9309   done
9310 fi
9311
9312 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9313   for ncn_progname in ar; do
9314     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9315 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9316     if test -x $with_build_time_tools/${ncn_progname}; then
9317       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9318       echo "$as_me:$LINENO: result: yes" >&5
9319 echo "${ECHO_T}yes" >&6
9320       break
9321     else
9322       echo "$as_me:$LINENO: result: no" >&5
9323 echo "${ECHO_T}no" >&6
9324     fi
9325   done
9326 fi
9327
9328 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9329   for ncn_progname in ar; do
9330     if test -n "$ncn_target_tool_prefix"; then
9331       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9332 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9333 echo "$as_me:$LINENO: checking for $ac_word" >&5
9334 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9335 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9336   echo $ECHO_N "(cached) $ECHO_C" >&6
9337 else
9338   if test -n "$AR_FOR_TARGET"; then
9339   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9340 else
9341 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9342 for as_dir in $PATH
9343 do
9344   IFS=$as_save_IFS
9345   test -z "$as_dir" && as_dir=.
9346   for ac_exec_ext in '' $ac_executable_extensions; do
9347   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9348     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9349     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9350     break 2
9351   fi
9352 done
9353 done
9354
9355 fi
9356 fi
9357 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9358 if test -n "$AR_FOR_TARGET"; then
9359   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9360 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9361 else
9362   echo "$as_me:$LINENO: result: no" >&5
9363 echo "${ECHO_T}no" >&6
9364 fi
9365
9366     fi
9367     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9368       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9369 set dummy ${ncn_progname}; ac_word=$2
9370 echo "$as_me:$LINENO: checking for $ac_word" >&5
9371 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9372 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9373   echo $ECHO_N "(cached) $ECHO_C" >&6
9374 else
9375   if test -n "$AR_FOR_TARGET"; then
9376   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9377 else
9378 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9379 for as_dir in $PATH
9380 do
9381   IFS=$as_save_IFS
9382   test -z "$as_dir" && as_dir=.
9383   for ac_exec_ext in '' $ac_executable_extensions; do
9384   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9385     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9386     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9387     break 2
9388   fi
9389 done
9390 done
9391
9392 fi
9393 fi
9394 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9395 if test -n "$AR_FOR_TARGET"; then
9396   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9397 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9398 else
9399   echo "$as_me:$LINENO: result: no" >&5
9400 echo "${ECHO_T}no" >&6
9401 fi
9402
9403     fi
9404     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9405   done
9406 fi
9407
9408 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9409   set dummy ar
9410   if test $build = $target ; then
9411     AR_FOR_TARGET="$2"
9412   else
9413     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9414   fi
9415 else
9416   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9417 fi
9418
9419 else
9420   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9421 fi
9422
9423
9424
9425
9426 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9427   if test -n "$with_build_time_tools"; then
9428     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9429 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9430     if test -x $with_build_time_tools/as; then
9431       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9432       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9433       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9434 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9435     else
9436       echo "$as_me:$LINENO: result: no" >&5
9437 echo "${ECHO_T}no" >&6
9438     fi
9439   elif test $build != $host && test $have_gcc_for_target = yes; then
9440     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9441     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9442     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9443   fi
9444 fi
9445 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9446   # Extract the first word of "as", so it can be a program name with args.
9447 set dummy as; ac_word=$2
9448 echo "$as_me:$LINENO: checking for $ac_word" >&5
9449 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9450 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9451   echo $ECHO_N "(cached) $ECHO_C" >&6
9452 else
9453   case $AS_FOR_TARGET in
9454   [\\/]* | ?:[\\/]*)
9455   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9456   ;;
9457   *)
9458   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9459 for as_dir in $gcc_cv_tool_dirs
9460 do
9461   IFS=$as_save_IFS
9462   test -z "$as_dir" && as_dir=.
9463   for ac_exec_ext in '' $ac_executable_extensions; do
9464   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9465     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9466     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9467     break 2
9468   fi
9469 done
9470 done
9471
9472   ;;
9473 esac
9474 fi
9475 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9476
9477 if test -n "$AS_FOR_TARGET"; then
9478   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9479 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9480 else
9481   echo "$as_me:$LINENO: result: no" >&5
9482 echo "${ECHO_T}no" >&6
9483 fi
9484
9485 fi
9486 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9487
9488
9489 if test -n "$AS_FOR_TARGET"; then
9490   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9491 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9492   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9493 fi
9494
9495 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9496   for ncn_progname in as; do
9497     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9498 set dummy ${ncn_progname}; ac_word=$2
9499 echo "$as_me:$LINENO: checking for $ac_word" >&5
9500 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9501 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9502   echo $ECHO_N "(cached) $ECHO_C" >&6
9503 else
9504   if test -n "$AS_FOR_TARGET"; then
9505   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9506 else
9507 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9508 for as_dir in $PATH
9509 do
9510   IFS=$as_save_IFS
9511   test -z "$as_dir" && as_dir=.
9512   for ac_exec_ext in '' $ac_executable_extensions; do
9513   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9514     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9515     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9516     break 2
9517   fi
9518 done
9519 done
9520
9521 fi
9522 fi
9523 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9524 if test -n "$AS_FOR_TARGET"; then
9525   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9526 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9527 else
9528   echo "$as_me:$LINENO: result: no" >&5
9529 echo "${ECHO_T}no" >&6
9530 fi
9531
9532   done
9533 fi
9534
9535 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9536   for ncn_progname in as; do
9537     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9538 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9539     if test -x $with_build_time_tools/${ncn_progname}; then
9540       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9541       echo "$as_me:$LINENO: result: yes" >&5
9542 echo "${ECHO_T}yes" >&6
9543       break
9544     else
9545       echo "$as_me:$LINENO: result: no" >&5
9546 echo "${ECHO_T}no" >&6
9547     fi
9548   done
9549 fi
9550
9551 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9552   for ncn_progname in as; do
9553     if test -n "$ncn_target_tool_prefix"; then
9554       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9555 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9556 echo "$as_me:$LINENO: checking for $ac_word" >&5
9557 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9558 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9559   echo $ECHO_N "(cached) $ECHO_C" >&6
9560 else
9561   if test -n "$AS_FOR_TARGET"; then
9562   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9563 else
9564 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9565 for as_dir in $PATH
9566 do
9567   IFS=$as_save_IFS
9568   test -z "$as_dir" && as_dir=.
9569   for ac_exec_ext in '' $ac_executable_extensions; do
9570   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9571     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9572     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9573     break 2
9574   fi
9575 done
9576 done
9577
9578 fi
9579 fi
9580 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9581 if test -n "$AS_FOR_TARGET"; then
9582   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9583 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9584 else
9585   echo "$as_me:$LINENO: result: no" >&5
9586 echo "${ECHO_T}no" >&6
9587 fi
9588
9589     fi
9590     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9591       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9592 set dummy ${ncn_progname}; ac_word=$2
9593 echo "$as_me:$LINENO: checking for $ac_word" >&5
9594 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9595 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9596   echo $ECHO_N "(cached) $ECHO_C" >&6
9597 else
9598   if test -n "$AS_FOR_TARGET"; then
9599   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9600 else
9601 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9602 for as_dir in $PATH
9603 do
9604   IFS=$as_save_IFS
9605   test -z "$as_dir" && as_dir=.
9606   for ac_exec_ext in '' $ac_executable_extensions; do
9607   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9608     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9609     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9610     break 2
9611   fi
9612 done
9613 done
9614
9615 fi
9616 fi
9617 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9618 if test -n "$AS_FOR_TARGET"; then
9619   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9620 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9621 else
9622   echo "$as_me:$LINENO: result: no" >&5
9623 echo "${ECHO_T}no" >&6
9624 fi
9625
9626     fi
9627     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9628   done
9629 fi
9630
9631 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9632   set dummy as
9633   if test $build = $target ; then
9634     AS_FOR_TARGET="$2"
9635   else
9636     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9637   fi
9638 else
9639   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9640 fi
9641
9642 else
9643   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9644 fi
9645
9646
9647
9648
9649 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9650   if test -n "$with_build_time_tools"; then
9651     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9652 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9653     if test -x $with_build_time_tools/dlltool; then
9654       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9655       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9656       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9657 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9658     else
9659       echo "$as_me:$LINENO: result: no" >&5
9660 echo "${ECHO_T}no" >&6
9661     fi
9662   elif test $build != $host && test $have_gcc_for_target = yes; then
9663     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9664     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9665     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9666   fi
9667 fi
9668 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9669   # Extract the first word of "dlltool", so it can be a program name with args.
9670 set dummy dlltool; ac_word=$2
9671 echo "$as_me:$LINENO: checking for $ac_word" >&5
9672 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9673 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9674   echo $ECHO_N "(cached) $ECHO_C" >&6
9675 else
9676   case $DLLTOOL_FOR_TARGET in
9677   [\\/]* | ?:[\\/]*)
9678   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9679   ;;
9680   *)
9681   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9682 for as_dir in $gcc_cv_tool_dirs
9683 do
9684   IFS=$as_save_IFS
9685   test -z "$as_dir" && as_dir=.
9686   for ac_exec_ext in '' $ac_executable_extensions; do
9687   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9688     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9689     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9690     break 2
9691   fi
9692 done
9693 done
9694
9695   ;;
9696 esac
9697 fi
9698 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9699
9700 if test -n "$DLLTOOL_FOR_TARGET"; then
9701   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9702 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9703 else
9704   echo "$as_me:$LINENO: result: no" >&5
9705 echo "${ECHO_T}no" >&6
9706 fi
9707
9708 fi
9709 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9710
9711
9712 if test -n "$DLLTOOL_FOR_TARGET"; then
9713   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9714 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9715   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9716 fi
9717
9718 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9719   for ncn_progname in dlltool; do
9720     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9721 set dummy ${ncn_progname}; ac_word=$2
9722 echo "$as_me:$LINENO: checking for $ac_word" >&5
9723 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9724 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9725   echo $ECHO_N "(cached) $ECHO_C" >&6
9726 else
9727   if test -n "$DLLTOOL_FOR_TARGET"; then
9728   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9729 else
9730 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9731 for as_dir in $PATH
9732 do
9733   IFS=$as_save_IFS
9734   test -z "$as_dir" && as_dir=.
9735   for ac_exec_ext in '' $ac_executable_extensions; do
9736   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9737     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9738     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9739     break 2
9740   fi
9741 done
9742 done
9743
9744 fi
9745 fi
9746 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9747 if test -n "$DLLTOOL_FOR_TARGET"; then
9748   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9749 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9750 else
9751   echo "$as_me:$LINENO: result: no" >&5
9752 echo "${ECHO_T}no" >&6
9753 fi
9754
9755   done
9756 fi
9757
9758 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9759   for ncn_progname in dlltool; do
9760     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9761 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9762     if test -x $with_build_time_tools/${ncn_progname}; then
9763       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9764       echo "$as_me:$LINENO: result: yes" >&5
9765 echo "${ECHO_T}yes" >&6
9766       break
9767     else
9768       echo "$as_me:$LINENO: result: no" >&5
9769 echo "${ECHO_T}no" >&6
9770     fi
9771   done
9772 fi
9773
9774 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9775   for ncn_progname in dlltool; do
9776     if test -n "$ncn_target_tool_prefix"; then
9777       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9778 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9779 echo "$as_me:$LINENO: checking for $ac_word" >&5
9780 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9781 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9782   echo $ECHO_N "(cached) $ECHO_C" >&6
9783 else
9784   if test -n "$DLLTOOL_FOR_TARGET"; then
9785   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9786 else
9787 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9788 for as_dir in $PATH
9789 do
9790   IFS=$as_save_IFS
9791   test -z "$as_dir" && as_dir=.
9792   for ac_exec_ext in '' $ac_executable_extensions; do
9793   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9794     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9795     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9796     break 2
9797   fi
9798 done
9799 done
9800
9801 fi
9802 fi
9803 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9804 if test -n "$DLLTOOL_FOR_TARGET"; then
9805   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9806 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9807 else
9808   echo "$as_me:$LINENO: result: no" >&5
9809 echo "${ECHO_T}no" >&6
9810 fi
9811
9812     fi
9813     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9814       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9815 set dummy ${ncn_progname}; ac_word=$2
9816 echo "$as_me:$LINENO: checking for $ac_word" >&5
9817 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9818 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9819   echo $ECHO_N "(cached) $ECHO_C" >&6
9820 else
9821   if test -n "$DLLTOOL_FOR_TARGET"; then
9822   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9823 else
9824 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9825 for as_dir in $PATH
9826 do
9827   IFS=$as_save_IFS
9828   test -z "$as_dir" && as_dir=.
9829   for ac_exec_ext in '' $ac_executable_extensions; do
9830   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9831     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9832     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9833     break 2
9834   fi
9835 done
9836 done
9837
9838 fi
9839 fi
9840 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9841 if test -n "$DLLTOOL_FOR_TARGET"; then
9842   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9843 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9844 else
9845   echo "$as_me:$LINENO: result: no" >&5
9846 echo "${ECHO_T}no" >&6
9847 fi
9848
9849     fi
9850     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9851   done
9852 fi
9853
9854 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9855   set dummy dlltool
9856   if test $build = $target ; then
9857     DLLTOOL_FOR_TARGET="$2"
9858   else
9859     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9860   fi
9861 else
9862   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9863 fi
9864
9865 else
9866   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9867 fi
9868
9869
9870
9871
9872 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9873   if test -n "$with_build_time_tools"; then
9874     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9875 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9876     if test -x $with_build_time_tools/ld; then
9877       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9878       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9879       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9880 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9881     else
9882       echo "$as_me:$LINENO: result: no" >&5
9883 echo "${ECHO_T}no" >&6
9884     fi
9885   elif test $build != $host && test $have_gcc_for_target = yes; then
9886     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9887     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9888     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9889   fi
9890 fi
9891 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9892   # Extract the first word of "ld", so it can be a program name with args.
9893 set dummy ld; ac_word=$2
9894 echo "$as_me:$LINENO: checking for $ac_word" >&5
9895 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9896 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9897   echo $ECHO_N "(cached) $ECHO_C" >&6
9898 else
9899   case $LD_FOR_TARGET in
9900   [\\/]* | ?:[\\/]*)
9901   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9902   ;;
9903   *)
9904   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9905 for as_dir in $gcc_cv_tool_dirs
9906 do
9907   IFS=$as_save_IFS
9908   test -z "$as_dir" && as_dir=.
9909   for ac_exec_ext in '' $ac_executable_extensions; do
9910   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9911     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9912     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9913     break 2
9914   fi
9915 done
9916 done
9917
9918   ;;
9919 esac
9920 fi
9921 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9922
9923 if test -n "$LD_FOR_TARGET"; then
9924   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9925 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9926 else
9927   echo "$as_me:$LINENO: result: no" >&5
9928 echo "${ECHO_T}no" >&6
9929 fi
9930
9931 fi
9932 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9933
9934
9935 if test -n "$LD_FOR_TARGET"; then
9936   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9937 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9938   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9939 fi
9940
9941 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9942   for ncn_progname in ld; do
9943     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9944 set dummy ${ncn_progname}; ac_word=$2
9945 echo "$as_me:$LINENO: checking for $ac_word" >&5
9946 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9947 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9948   echo $ECHO_N "(cached) $ECHO_C" >&6
9949 else
9950   if test -n "$LD_FOR_TARGET"; then
9951   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9952 else
9953 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9954 for as_dir in $PATH
9955 do
9956   IFS=$as_save_IFS
9957   test -z "$as_dir" && as_dir=.
9958   for ac_exec_ext in '' $ac_executable_extensions; do
9959   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9960     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9961     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9962     break 2
9963   fi
9964 done
9965 done
9966
9967 fi
9968 fi
9969 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9970 if test -n "$LD_FOR_TARGET"; then
9971   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9972 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9973 else
9974   echo "$as_me:$LINENO: result: no" >&5
9975 echo "${ECHO_T}no" >&6
9976 fi
9977
9978   done
9979 fi
9980
9981 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9982   for ncn_progname in ld; do
9983     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9984 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9985     if test -x $with_build_time_tools/${ncn_progname}; then
9986       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9987       echo "$as_me:$LINENO: result: yes" >&5
9988 echo "${ECHO_T}yes" >&6
9989       break
9990     else
9991       echo "$as_me:$LINENO: result: no" >&5
9992 echo "${ECHO_T}no" >&6
9993     fi
9994   done
9995 fi
9996
9997 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9998   for ncn_progname in ld; do
9999     if test -n "$ncn_target_tool_prefix"; then
10000       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10001 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10002 echo "$as_me:$LINENO: checking for $ac_word" >&5
10003 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10004 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10005   echo $ECHO_N "(cached) $ECHO_C" >&6
10006 else
10007   if test -n "$LD_FOR_TARGET"; then
10008   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10009 else
10010 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10011 for as_dir in $PATH
10012 do
10013   IFS=$as_save_IFS
10014   test -z "$as_dir" && as_dir=.
10015   for ac_exec_ext in '' $ac_executable_extensions; do
10016   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10017     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10018     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10019     break 2
10020   fi
10021 done
10022 done
10023
10024 fi
10025 fi
10026 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10027 if test -n "$LD_FOR_TARGET"; then
10028   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10029 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10030 else
10031   echo "$as_me:$LINENO: result: no" >&5
10032 echo "${ECHO_T}no" >&6
10033 fi
10034
10035     fi
10036     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10037       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10038 set dummy ${ncn_progname}; ac_word=$2
10039 echo "$as_me:$LINENO: checking for $ac_word" >&5
10040 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10041 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10042   echo $ECHO_N "(cached) $ECHO_C" >&6
10043 else
10044   if test -n "$LD_FOR_TARGET"; then
10045   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10046 else
10047 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10048 for as_dir in $PATH
10049 do
10050   IFS=$as_save_IFS
10051   test -z "$as_dir" && as_dir=.
10052   for ac_exec_ext in '' $ac_executable_extensions; do
10053   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10054     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10055     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10056     break 2
10057   fi
10058 done
10059 done
10060
10061 fi
10062 fi
10063 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10064 if test -n "$LD_FOR_TARGET"; then
10065   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10066 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10067 else
10068   echo "$as_me:$LINENO: result: no" >&5
10069 echo "${ECHO_T}no" >&6
10070 fi
10071
10072     fi
10073     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10074   done
10075 fi
10076
10077 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10078   set dummy ld
10079   if test $build = $target ; then
10080     LD_FOR_TARGET="$2"
10081   else
10082     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10083   fi
10084 else
10085   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10086 fi
10087
10088 else
10089   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10090 fi
10091
10092
10093
10094
10095 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10096   if test -n "$with_build_time_tools"; then
10097     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10098 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10099     if test -x $with_build_time_tools/lipo; then
10100       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10101       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10102       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10103 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10104     else
10105       echo "$as_me:$LINENO: result: no" >&5
10106 echo "${ECHO_T}no" >&6
10107     fi
10108   elif test $build != $host && test $have_gcc_for_target = yes; then
10109     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10110     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10111     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10112   fi
10113 fi
10114 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10115   # Extract the first word of "lipo", so it can be a program name with args.
10116 set dummy lipo; ac_word=$2
10117 echo "$as_me:$LINENO: checking for $ac_word" >&5
10118 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10119 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10120   echo $ECHO_N "(cached) $ECHO_C" >&6
10121 else
10122   case $LIPO_FOR_TARGET in
10123   [\\/]* | ?:[\\/]*)
10124   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10125   ;;
10126   *)
10127   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10128 for as_dir in $gcc_cv_tool_dirs
10129 do
10130   IFS=$as_save_IFS
10131   test -z "$as_dir" && as_dir=.
10132   for ac_exec_ext in '' $ac_executable_extensions; do
10133   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10134     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10135     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10136     break 2
10137   fi
10138 done
10139 done
10140
10141   ;;
10142 esac
10143 fi
10144 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10145
10146 if test -n "$LIPO_FOR_TARGET"; then
10147   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10148 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10149 else
10150   echo "$as_me:$LINENO: result: no" >&5
10151 echo "${ECHO_T}no" >&6
10152 fi
10153
10154 fi
10155 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10156
10157
10158 if test -n "$LIPO_FOR_TARGET"; then
10159   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10160 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10161   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10162 fi
10163
10164 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10165   for ncn_progname in lipo; do
10166     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10167 set dummy ${ncn_progname}; ac_word=$2
10168 echo "$as_me:$LINENO: checking for $ac_word" >&5
10169 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10170 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10171   echo $ECHO_N "(cached) $ECHO_C" >&6
10172 else
10173   if test -n "$LIPO_FOR_TARGET"; then
10174   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10175 else
10176 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10177 for as_dir in $PATH
10178 do
10179   IFS=$as_save_IFS
10180   test -z "$as_dir" && as_dir=.
10181   for ac_exec_ext in '' $ac_executable_extensions; do
10182   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10183     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10184     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10185     break 2
10186   fi
10187 done
10188 done
10189
10190 fi
10191 fi
10192 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10193 if test -n "$LIPO_FOR_TARGET"; then
10194   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10195 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10196 else
10197   echo "$as_me:$LINENO: result: no" >&5
10198 echo "${ECHO_T}no" >&6
10199 fi
10200
10201   done
10202 fi
10203
10204 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10205   for ncn_progname in lipo; do
10206     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10207 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10208     if test -x $with_build_time_tools/${ncn_progname}; then
10209       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10210       echo "$as_me:$LINENO: result: yes" >&5
10211 echo "${ECHO_T}yes" >&6
10212       break
10213     else
10214       echo "$as_me:$LINENO: result: no" >&5
10215 echo "${ECHO_T}no" >&6
10216     fi
10217   done
10218 fi
10219
10220 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10221   for ncn_progname in lipo; do
10222     if test -n "$ncn_target_tool_prefix"; then
10223       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10224 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10225 echo "$as_me:$LINENO: checking for $ac_word" >&5
10226 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10227 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10228   echo $ECHO_N "(cached) $ECHO_C" >&6
10229 else
10230   if test -n "$LIPO_FOR_TARGET"; then
10231   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10232 else
10233 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10234 for as_dir in $PATH
10235 do
10236   IFS=$as_save_IFS
10237   test -z "$as_dir" && as_dir=.
10238   for ac_exec_ext in '' $ac_executable_extensions; do
10239   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10240     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10241     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10242     break 2
10243   fi
10244 done
10245 done
10246
10247 fi
10248 fi
10249 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10250 if test -n "$LIPO_FOR_TARGET"; then
10251   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10252 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10253 else
10254   echo "$as_me:$LINENO: result: no" >&5
10255 echo "${ECHO_T}no" >&6
10256 fi
10257
10258     fi
10259     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10260       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10261 set dummy ${ncn_progname}; ac_word=$2
10262 echo "$as_me:$LINENO: checking for $ac_word" >&5
10263 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10264 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10265   echo $ECHO_N "(cached) $ECHO_C" >&6
10266 else
10267   if test -n "$LIPO_FOR_TARGET"; then
10268   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10269 else
10270 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10271 for as_dir in $PATH
10272 do
10273   IFS=$as_save_IFS
10274   test -z "$as_dir" && as_dir=.
10275   for ac_exec_ext in '' $ac_executable_extensions; do
10276   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10277     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10278     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10279     break 2
10280   fi
10281 done
10282 done
10283
10284 fi
10285 fi
10286 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10287 if test -n "$LIPO_FOR_TARGET"; then
10288   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10289 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10290 else
10291   echo "$as_me:$LINENO: result: no" >&5
10292 echo "${ECHO_T}no" >&6
10293 fi
10294
10295     fi
10296     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10297   done
10298 fi
10299
10300 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10301   set dummy lipo
10302   if test $build = $target ; then
10303     LIPO_FOR_TARGET="$2"
10304   else
10305     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10306   fi
10307 else
10308   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10309 fi
10310
10311 else
10312   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10313 fi
10314
10315
10316
10317
10318 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10319   if test -n "$with_build_time_tools"; then
10320     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10321 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10322     if test -x $with_build_time_tools/nm; then
10323       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10324       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10325       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10326 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10327     else
10328       echo "$as_me:$LINENO: result: no" >&5
10329 echo "${ECHO_T}no" >&6
10330     fi
10331   elif test $build != $host && test $have_gcc_for_target = yes; then
10332     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10333     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10334     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10335   fi
10336 fi
10337 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10338   # Extract the first word of "nm", so it can be a program name with args.
10339 set dummy nm; ac_word=$2
10340 echo "$as_me:$LINENO: checking for $ac_word" >&5
10341 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10342 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10343   echo $ECHO_N "(cached) $ECHO_C" >&6
10344 else
10345   case $NM_FOR_TARGET in
10346   [\\/]* | ?:[\\/]*)
10347   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10348   ;;
10349   *)
10350   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10351 for as_dir in $gcc_cv_tool_dirs
10352 do
10353   IFS=$as_save_IFS
10354   test -z "$as_dir" && as_dir=.
10355   for ac_exec_ext in '' $ac_executable_extensions; do
10356   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10357     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10358     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10359     break 2
10360   fi
10361 done
10362 done
10363
10364   ;;
10365 esac
10366 fi
10367 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10368
10369 if test -n "$NM_FOR_TARGET"; then
10370   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10371 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10372 else
10373   echo "$as_me:$LINENO: result: no" >&5
10374 echo "${ECHO_T}no" >&6
10375 fi
10376
10377 fi
10378 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10379
10380
10381 if test -n "$NM_FOR_TARGET"; then
10382   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10383 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10384   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10385 fi
10386
10387 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10388   for ncn_progname in nm; do
10389     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10390 set dummy ${ncn_progname}; ac_word=$2
10391 echo "$as_me:$LINENO: checking for $ac_word" >&5
10392 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10393 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10394   echo $ECHO_N "(cached) $ECHO_C" >&6
10395 else
10396   if test -n "$NM_FOR_TARGET"; then
10397   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10398 else
10399 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10400 for as_dir in $PATH
10401 do
10402   IFS=$as_save_IFS
10403   test -z "$as_dir" && as_dir=.
10404   for ac_exec_ext in '' $ac_executable_extensions; do
10405   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10406     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10407     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10408     break 2
10409   fi
10410 done
10411 done
10412
10413 fi
10414 fi
10415 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10416 if test -n "$NM_FOR_TARGET"; then
10417   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10418 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10419 else
10420   echo "$as_me:$LINENO: result: no" >&5
10421 echo "${ECHO_T}no" >&6
10422 fi
10423
10424   done
10425 fi
10426
10427 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10428   for ncn_progname in nm; do
10429     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10430 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10431     if test -x $with_build_time_tools/${ncn_progname}; then
10432       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10433       echo "$as_me:$LINENO: result: yes" >&5
10434 echo "${ECHO_T}yes" >&6
10435       break
10436     else
10437       echo "$as_me:$LINENO: result: no" >&5
10438 echo "${ECHO_T}no" >&6
10439     fi
10440   done
10441 fi
10442
10443 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10444   for ncn_progname in nm; do
10445     if test -n "$ncn_target_tool_prefix"; then
10446       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10447 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10448 echo "$as_me:$LINENO: checking for $ac_word" >&5
10449 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10450 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10451   echo $ECHO_N "(cached) $ECHO_C" >&6
10452 else
10453   if test -n "$NM_FOR_TARGET"; then
10454   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10455 else
10456 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10457 for as_dir in $PATH
10458 do
10459   IFS=$as_save_IFS
10460   test -z "$as_dir" && as_dir=.
10461   for ac_exec_ext in '' $ac_executable_extensions; do
10462   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10463     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10464     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10465     break 2
10466   fi
10467 done
10468 done
10469
10470 fi
10471 fi
10472 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10473 if test -n "$NM_FOR_TARGET"; then
10474   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10475 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10476 else
10477   echo "$as_me:$LINENO: result: no" >&5
10478 echo "${ECHO_T}no" >&6
10479 fi
10480
10481     fi
10482     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10483       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10484 set dummy ${ncn_progname}; ac_word=$2
10485 echo "$as_me:$LINENO: checking for $ac_word" >&5
10486 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10487 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10488   echo $ECHO_N "(cached) $ECHO_C" >&6
10489 else
10490   if test -n "$NM_FOR_TARGET"; then
10491   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10492 else
10493 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10494 for as_dir in $PATH
10495 do
10496   IFS=$as_save_IFS
10497   test -z "$as_dir" && as_dir=.
10498   for ac_exec_ext in '' $ac_executable_extensions; do
10499   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10500     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10501     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10502     break 2
10503   fi
10504 done
10505 done
10506
10507 fi
10508 fi
10509 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10510 if test -n "$NM_FOR_TARGET"; then
10511   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10512 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10513 else
10514   echo "$as_me:$LINENO: result: no" >&5
10515 echo "${ECHO_T}no" >&6
10516 fi
10517
10518     fi
10519     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10520   done
10521 fi
10522
10523 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10524   set dummy nm
10525   if test $build = $target ; then
10526     NM_FOR_TARGET="$2"
10527   else
10528     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10529   fi
10530 else
10531   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10532 fi
10533
10534 else
10535   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10536 fi
10537
10538
10539
10540
10541 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10542   if test -n "$with_build_time_tools"; then
10543     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10544 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10545     if test -x $with_build_time_tools/objdump; then
10546       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10547       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10548       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10549 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10550     else
10551       echo "$as_me:$LINENO: result: no" >&5
10552 echo "${ECHO_T}no" >&6
10553     fi
10554   elif test $build != $host && test $have_gcc_for_target = yes; then
10555     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10556     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10557     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10558   fi
10559 fi
10560 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10561   # Extract the first word of "objdump", so it can be a program name with args.
10562 set dummy objdump; ac_word=$2
10563 echo "$as_me:$LINENO: checking for $ac_word" >&5
10564 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10565 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10566   echo $ECHO_N "(cached) $ECHO_C" >&6
10567 else
10568   case $OBJDUMP_FOR_TARGET in
10569   [\\/]* | ?:[\\/]*)
10570   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10571   ;;
10572   *)
10573   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10574 for as_dir in $gcc_cv_tool_dirs
10575 do
10576   IFS=$as_save_IFS
10577   test -z "$as_dir" && as_dir=.
10578   for ac_exec_ext in '' $ac_executable_extensions; do
10579   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10580     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10581     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10582     break 2
10583   fi
10584 done
10585 done
10586
10587   ;;
10588 esac
10589 fi
10590 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10591
10592 if test -n "$OBJDUMP_FOR_TARGET"; then
10593   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10594 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10595 else
10596   echo "$as_me:$LINENO: result: no" >&5
10597 echo "${ECHO_T}no" >&6
10598 fi
10599
10600 fi
10601 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10602
10603
10604 if test -n "$OBJDUMP_FOR_TARGET"; then
10605   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10606 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10607   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10608 fi
10609
10610 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10611   for ncn_progname in objdump; do
10612     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10613 set dummy ${ncn_progname}; ac_word=$2
10614 echo "$as_me:$LINENO: checking for $ac_word" >&5
10615 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10616 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10617   echo $ECHO_N "(cached) $ECHO_C" >&6
10618 else
10619   if test -n "$OBJDUMP_FOR_TARGET"; then
10620   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10621 else
10622 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10623 for as_dir in $PATH
10624 do
10625   IFS=$as_save_IFS
10626   test -z "$as_dir" && as_dir=.
10627   for ac_exec_ext in '' $ac_executable_extensions; do
10628   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10629     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10630     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10631     break 2
10632   fi
10633 done
10634 done
10635
10636 fi
10637 fi
10638 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10639 if test -n "$OBJDUMP_FOR_TARGET"; then
10640   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10641 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10642 else
10643   echo "$as_me:$LINENO: result: no" >&5
10644 echo "${ECHO_T}no" >&6
10645 fi
10646
10647   done
10648 fi
10649
10650 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10651   for ncn_progname in objdump; do
10652     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10653 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10654     if test -x $with_build_time_tools/${ncn_progname}; then
10655       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10656       echo "$as_me:$LINENO: result: yes" >&5
10657 echo "${ECHO_T}yes" >&6
10658       break
10659     else
10660       echo "$as_me:$LINENO: result: no" >&5
10661 echo "${ECHO_T}no" >&6
10662     fi
10663   done
10664 fi
10665
10666 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10667   for ncn_progname in objdump; do
10668     if test -n "$ncn_target_tool_prefix"; then
10669       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10670 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10671 echo "$as_me:$LINENO: checking for $ac_word" >&5
10672 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10673 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10674   echo $ECHO_N "(cached) $ECHO_C" >&6
10675 else
10676   if test -n "$OBJDUMP_FOR_TARGET"; then
10677   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10678 else
10679 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10680 for as_dir in $PATH
10681 do
10682   IFS=$as_save_IFS
10683   test -z "$as_dir" && as_dir=.
10684   for ac_exec_ext in '' $ac_executable_extensions; do
10685   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10686     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10687     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10688     break 2
10689   fi
10690 done
10691 done
10692
10693 fi
10694 fi
10695 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10696 if test -n "$OBJDUMP_FOR_TARGET"; then
10697   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10698 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10699 else
10700   echo "$as_me:$LINENO: result: no" >&5
10701 echo "${ECHO_T}no" >&6
10702 fi
10703
10704     fi
10705     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10706       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10707 set dummy ${ncn_progname}; ac_word=$2
10708 echo "$as_me:$LINENO: checking for $ac_word" >&5
10709 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10710 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10711   echo $ECHO_N "(cached) $ECHO_C" >&6
10712 else
10713   if test -n "$OBJDUMP_FOR_TARGET"; then
10714   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10715 else
10716 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10717 for as_dir in $PATH
10718 do
10719   IFS=$as_save_IFS
10720   test -z "$as_dir" && as_dir=.
10721   for ac_exec_ext in '' $ac_executable_extensions; do
10722   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10723     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10724     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10725     break 2
10726   fi
10727 done
10728 done
10729
10730 fi
10731 fi
10732 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10733 if test -n "$OBJDUMP_FOR_TARGET"; then
10734   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10735 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10736 else
10737   echo "$as_me:$LINENO: result: no" >&5
10738 echo "${ECHO_T}no" >&6
10739 fi
10740
10741     fi
10742     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10743   done
10744 fi
10745
10746 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10747   set dummy objdump
10748   if test $build = $target ; then
10749     OBJDUMP_FOR_TARGET="$2"
10750   else
10751     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10752   fi
10753 else
10754   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10755 fi
10756
10757 else
10758   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10759 fi
10760
10761
10762
10763
10764 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10765   if test -n "$with_build_time_tools"; then
10766     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10767 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10768     if test -x $with_build_time_tools/ranlib; then
10769       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10770       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10771       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10772 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10773     else
10774       echo "$as_me:$LINENO: result: no" >&5
10775 echo "${ECHO_T}no" >&6
10776     fi
10777   elif test $build != $host && test $have_gcc_for_target = yes; then
10778     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10779     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10780     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10781   fi
10782 fi
10783 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10784   # Extract the first word of "ranlib", so it can be a program name with args.
10785 set dummy ranlib; ac_word=$2
10786 echo "$as_me:$LINENO: checking for $ac_word" >&5
10787 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10788 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10789   echo $ECHO_N "(cached) $ECHO_C" >&6
10790 else
10791   case $RANLIB_FOR_TARGET in
10792   [\\/]* | ?:[\\/]*)
10793   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10794   ;;
10795   *)
10796   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10797 for as_dir in $gcc_cv_tool_dirs
10798 do
10799   IFS=$as_save_IFS
10800   test -z "$as_dir" && as_dir=.
10801   for ac_exec_ext in '' $ac_executable_extensions; do
10802   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10803     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10804     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10805     break 2
10806   fi
10807 done
10808 done
10809
10810   ;;
10811 esac
10812 fi
10813 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10814
10815 if test -n "$RANLIB_FOR_TARGET"; then
10816   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10817 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10818 else
10819   echo "$as_me:$LINENO: result: no" >&5
10820 echo "${ECHO_T}no" >&6
10821 fi
10822
10823 fi
10824 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10825
10826
10827 if test -n "$RANLIB_FOR_TARGET"; then
10828   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10829 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10830   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10831 fi
10832
10833 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10834   for ncn_progname in ranlib; do
10835     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10836 set dummy ${ncn_progname}; ac_word=$2
10837 echo "$as_me:$LINENO: checking for $ac_word" >&5
10838 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10839 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10840   echo $ECHO_N "(cached) $ECHO_C" >&6
10841 else
10842   if test -n "$RANLIB_FOR_TARGET"; then
10843   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10844 else
10845 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10846 for as_dir in $PATH
10847 do
10848   IFS=$as_save_IFS
10849   test -z "$as_dir" && as_dir=.
10850   for ac_exec_ext in '' $ac_executable_extensions; do
10851   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10852     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10853     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10854     break 2
10855   fi
10856 done
10857 done
10858
10859 fi
10860 fi
10861 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10862 if test -n "$RANLIB_FOR_TARGET"; then
10863   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10864 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10865 else
10866   echo "$as_me:$LINENO: result: no" >&5
10867 echo "${ECHO_T}no" >&6
10868 fi
10869
10870   done
10871 fi
10872
10873 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10874   for ncn_progname in ranlib; do
10875     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10876 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10877     if test -x $with_build_time_tools/${ncn_progname}; then
10878       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10879       echo "$as_me:$LINENO: result: yes" >&5
10880 echo "${ECHO_T}yes" >&6
10881       break
10882     else
10883       echo "$as_me:$LINENO: result: no" >&5
10884 echo "${ECHO_T}no" >&6
10885     fi
10886   done
10887 fi
10888
10889 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10890   for ncn_progname in ranlib; do
10891     if test -n "$ncn_target_tool_prefix"; then
10892       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10893 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10894 echo "$as_me:$LINENO: checking for $ac_word" >&5
10895 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10896 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10897   echo $ECHO_N "(cached) $ECHO_C" >&6
10898 else
10899   if test -n "$RANLIB_FOR_TARGET"; then
10900   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10901 else
10902 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10903 for as_dir in $PATH
10904 do
10905   IFS=$as_save_IFS
10906   test -z "$as_dir" && as_dir=.
10907   for ac_exec_ext in '' $ac_executable_extensions; do
10908   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10909     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10910     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10911     break 2
10912   fi
10913 done
10914 done
10915
10916 fi
10917 fi
10918 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10919 if test -n "$RANLIB_FOR_TARGET"; then
10920   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10921 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10922 else
10923   echo "$as_me:$LINENO: result: no" >&5
10924 echo "${ECHO_T}no" >&6
10925 fi
10926
10927     fi
10928     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10929       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10930 set dummy ${ncn_progname}; ac_word=$2
10931 echo "$as_me:$LINENO: checking for $ac_word" >&5
10932 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10933 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10934   echo $ECHO_N "(cached) $ECHO_C" >&6
10935 else
10936   if test -n "$RANLIB_FOR_TARGET"; then
10937   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10938 else
10939 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10940 for as_dir in $PATH
10941 do
10942   IFS=$as_save_IFS
10943   test -z "$as_dir" && as_dir=.
10944   for ac_exec_ext in '' $ac_executable_extensions; do
10945   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10946     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10947     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10948     break 2
10949   fi
10950 done
10951 done
10952
10953 fi
10954 fi
10955 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10956 if test -n "$RANLIB_FOR_TARGET"; then
10957   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10958 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10959 else
10960   echo "$as_me:$LINENO: result: no" >&5
10961 echo "${ECHO_T}no" >&6
10962 fi
10963
10964     fi
10965     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10966   done
10967 fi
10968
10969 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10970   set dummy ranlib
10971   if test $build = $target ; then
10972     RANLIB_FOR_TARGET="$2"
10973   else
10974     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10975   fi
10976 else
10977   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10978 fi
10979
10980 else
10981   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10982 fi
10983
10984
10985
10986
10987 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10988   if test -n "$with_build_time_tools"; then
10989     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10990 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10991     if test -x $with_build_time_tools/strip; then
10992       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10993       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10994       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10995 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10996     else
10997       echo "$as_me:$LINENO: result: no" >&5
10998 echo "${ECHO_T}no" >&6
10999     fi
11000   elif test $build != $host && test $have_gcc_for_target = yes; then
11001     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
11002     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
11003     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11004   fi
11005 fi
11006 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11007   # Extract the first word of "strip", so it can be a program name with args.
11008 set dummy strip; ac_word=$2
11009 echo "$as_me:$LINENO: checking for $ac_word" >&5
11010 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11011 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
11012   echo $ECHO_N "(cached) $ECHO_C" >&6
11013 else
11014   case $STRIP_FOR_TARGET in
11015   [\\/]* | ?:[\\/]*)
11016   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
11017   ;;
11018   *)
11019   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11020 for as_dir in $gcc_cv_tool_dirs
11021 do
11022   IFS=$as_save_IFS
11023   test -z "$as_dir" && as_dir=.
11024   for ac_exec_ext in '' $ac_executable_extensions; do
11025   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11026     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11027     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11028     break 2
11029   fi
11030 done
11031 done
11032
11033   ;;
11034 esac
11035 fi
11036 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11037
11038 if test -n "$STRIP_FOR_TARGET"; then
11039   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11040 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11041 else
11042   echo "$as_me:$LINENO: result: no" >&5
11043 echo "${ECHO_T}no" >&6
11044 fi
11045
11046 fi
11047 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11048
11049
11050 if test -n "$STRIP_FOR_TARGET"; then
11051   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11052 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11053   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11054 fi
11055
11056 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11057   for ncn_progname in strip; do
11058     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11059 set dummy ${ncn_progname}; ac_word=$2
11060 echo "$as_me:$LINENO: checking for $ac_word" >&5
11061 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11062 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11063   echo $ECHO_N "(cached) $ECHO_C" >&6
11064 else
11065   if test -n "$STRIP_FOR_TARGET"; then
11066   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11067 else
11068 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11069 for as_dir in $PATH
11070 do
11071   IFS=$as_save_IFS
11072   test -z "$as_dir" && as_dir=.
11073   for ac_exec_ext in '' $ac_executable_extensions; do
11074   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11075     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11076     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11077     break 2
11078   fi
11079 done
11080 done
11081
11082 fi
11083 fi
11084 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11085 if test -n "$STRIP_FOR_TARGET"; then
11086   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11087 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11088 else
11089   echo "$as_me:$LINENO: result: no" >&5
11090 echo "${ECHO_T}no" >&6
11091 fi
11092
11093   done
11094 fi
11095
11096 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11097   for ncn_progname in strip; do
11098     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11099 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11100     if test -x $with_build_time_tools/${ncn_progname}; then
11101       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11102       echo "$as_me:$LINENO: result: yes" >&5
11103 echo "${ECHO_T}yes" >&6
11104       break
11105     else
11106       echo "$as_me:$LINENO: result: no" >&5
11107 echo "${ECHO_T}no" >&6
11108     fi
11109   done
11110 fi
11111
11112 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11113   for ncn_progname in strip; do
11114     if test -n "$ncn_target_tool_prefix"; then
11115       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11116 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11117 echo "$as_me:$LINENO: checking for $ac_word" >&5
11118 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11119 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11120   echo $ECHO_N "(cached) $ECHO_C" >&6
11121 else
11122   if test -n "$STRIP_FOR_TARGET"; then
11123   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11124 else
11125 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11126 for as_dir in $PATH
11127 do
11128   IFS=$as_save_IFS
11129   test -z "$as_dir" && as_dir=.
11130   for ac_exec_ext in '' $ac_executable_extensions; do
11131   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11132     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11133     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11134     break 2
11135   fi
11136 done
11137 done
11138
11139 fi
11140 fi
11141 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11142 if test -n "$STRIP_FOR_TARGET"; then
11143   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11144 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11145 else
11146   echo "$as_me:$LINENO: result: no" >&5
11147 echo "${ECHO_T}no" >&6
11148 fi
11149
11150     fi
11151     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11152       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11153 set dummy ${ncn_progname}; ac_word=$2
11154 echo "$as_me:$LINENO: checking for $ac_word" >&5
11155 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11156 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11157   echo $ECHO_N "(cached) $ECHO_C" >&6
11158 else
11159   if test -n "$STRIP_FOR_TARGET"; then
11160   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11161 else
11162 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11163 for as_dir in $PATH
11164 do
11165   IFS=$as_save_IFS
11166   test -z "$as_dir" && as_dir=.
11167   for ac_exec_ext in '' $ac_executable_extensions; do
11168   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11169     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11170     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11171     break 2
11172   fi
11173 done
11174 done
11175
11176 fi
11177 fi
11178 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11179 if test -n "$STRIP_FOR_TARGET"; then
11180   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11181 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11182 else
11183   echo "$as_me:$LINENO: result: no" >&5
11184 echo "${ECHO_T}no" >&6
11185 fi
11186
11187     fi
11188     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11189   done
11190 fi
11191
11192 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11193   set dummy strip
11194   if test $build = $target ; then
11195     STRIP_FOR_TARGET="$2"
11196   else
11197     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11198   fi
11199 else
11200   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11201 fi
11202
11203 else
11204   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11205 fi
11206
11207
11208
11209
11210 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11211   if test -n "$with_build_time_tools"; then
11212     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11213 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11214     if test -x $with_build_time_tools/windres; then
11215       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11216       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11217       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11218 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11219     else
11220       echo "$as_me:$LINENO: result: no" >&5
11221 echo "${ECHO_T}no" >&6
11222     fi
11223   elif test $build != $host && test $have_gcc_for_target = yes; then
11224     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11225     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11226     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11227   fi
11228 fi
11229 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11230   # Extract the first word of "windres", so it can be a program name with args.
11231 set dummy windres; ac_word=$2
11232 echo "$as_me:$LINENO: checking for $ac_word" >&5
11233 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11234 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11235   echo $ECHO_N "(cached) $ECHO_C" >&6
11236 else
11237   case $WINDRES_FOR_TARGET in
11238   [\\/]* | ?:[\\/]*)
11239   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11240   ;;
11241   *)
11242   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11243 for as_dir in $gcc_cv_tool_dirs
11244 do
11245   IFS=$as_save_IFS
11246   test -z "$as_dir" && as_dir=.
11247   for ac_exec_ext in '' $ac_executable_extensions; do
11248   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11249     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11250     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11251     break 2
11252   fi
11253 done
11254 done
11255
11256   ;;
11257 esac
11258 fi
11259 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11260
11261 if test -n "$WINDRES_FOR_TARGET"; then
11262   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11263 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11264 else
11265   echo "$as_me:$LINENO: result: no" >&5
11266 echo "${ECHO_T}no" >&6
11267 fi
11268
11269 fi
11270 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11271
11272
11273 if test -n "$WINDRES_FOR_TARGET"; then
11274   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11275 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11276   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11277 fi
11278
11279 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11280   for ncn_progname in windres; do
11281     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11282 set dummy ${ncn_progname}; ac_word=$2
11283 echo "$as_me:$LINENO: checking for $ac_word" >&5
11284 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11285 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11286   echo $ECHO_N "(cached) $ECHO_C" >&6
11287 else
11288   if test -n "$WINDRES_FOR_TARGET"; then
11289   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11290 else
11291 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11292 for as_dir in $PATH
11293 do
11294   IFS=$as_save_IFS
11295   test -z "$as_dir" && as_dir=.
11296   for ac_exec_ext in '' $ac_executable_extensions; do
11297   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11298     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11299     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11300     break 2
11301   fi
11302 done
11303 done
11304
11305 fi
11306 fi
11307 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11308 if test -n "$WINDRES_FOR_TARGET"; then
11309   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11310 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11311 else
11312   echo "$as_me:$LINENO: result: no" >&5
11313 echo "${ECHO_T}no" >&6
11314 fi
11315
11316   done
11317 fi
11318
11319 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11320   for ncn_progname in windres; do
11321     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11322 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11323     if test -x $with_build_time_tools/${ncn_progname}; then
11324       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11325       echo "$as_me:$LINENO: result: yes" >&5
11326 echo "${ECHO_T}yes" >&6
11327       break
11328     else
11329       echo "$as_me:$LINENO: result: no" >&5
11330 echo "${ECHO_T}no" >&6
11331     fi
11332   done
11333 fi
11334
11335 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11336   for ncn_progname in windres; do
11337     if test -n "$ncn_target_tool_prefix"; then
11338       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11339 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11340 echo "$as_me:$LINENO: checking for $ac_word" >&5
11341 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11342 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11343   echo $ECHO_N "(cached) $ECHO_C" >&6
11344 else
11345   if test -n "$WINDRES_FOR_TARGET"; then
11346   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11347 else
11348 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11349 for as_dir in $PATH
11350 do
11351   IFS=$as_save_IFS
11352   test -z "$as_dir" && as_dir=.
11353   for ac_exec_ext in '' $ac_executable_extensions; do
11354   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11355     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11356     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11357     break 2
11358   fi
11359 done
11360 done
11361
11362 fi
11363 fi
11364 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11365 if test -n "$WINDRES_FOR_TARGET"; then
11366   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11367 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11368 else
11369   echo "$as_me:$LINENO: result: no" >&5
11370 echo "${ECHO_T}no" >&6
11371 fi
11372
11373     fi
11374     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11375       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11376 set dummy ${ncn_progname}; ac_word=$2
11377 echo "$as_me:$LINENO: checking for $ac_word" >&5
11378 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11379 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11380   echo $ECHO_N "(cached) $ECHO_C" >&6
11381 else
11382   if test -n "$WINDRES_FOR_TARGET"; then
11383   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11384 else
11385 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11386 for as_dir in $PATH
11387 do
11388   IFS=$as_save_IFS
11389   test -z "$as_dir" && as_dir=.
11390   for ac_exec_ext in '' $ac_executable_extensions; do
11391   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11392     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11393     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11394     break 2
11395   fi
11396 done
11397 done
11398
11399 fi
11400 fi
11401 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11402 if test -n "$WINDRES_FOR_TARGET"; then
11403   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11404 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11405 else
11406   echo "$as_me:$LINENO: result: no" >&5
11407 echo "${ECHO_T}no" >&6
11408 fi
11409
11410     fi
11411     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11412   done
11413 fi
11414
11415 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11416   set dummy windres
11417   if test $build = $target ; then
11418     WINDRES_FOR_TARGET="$2"
11419   else
11420     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11421   fi
11422 else
11423   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11424 fi
11425
11426 else
11427   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11428 fi
11429
11430
11431
11432
11433 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11434   if test -n "$with_build_time_tools"; then
11435     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11436 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11437     if test -x $with_build_time_tools/windmc; then
11438       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11439       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11440       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11441 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11442     else
11443       echo "$as_me:$LINENO: result: no" >&5
11444 echo "${ECHO_T}no" >&6
11445     fi
11446   elif test $build != $host && test $have_gcc_for_target = yes; then
11447     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11448     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11449     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11450   fi
11451 fi
11452 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11453   # Extract the first word of "windmc", so it can be a program name with args.
11454 set dummy windmc; ac_word=$2
11455 echo "$as_me:$LINENO: checking for $ac_word" >&5
11456 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11457 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11458   echo $ECHO_N "(cached) $ECHO_C" >&6
11459 else
11460   case $WINDMC_FOR_TARGET in
11461   [\\/]* | ?:[\\/]*)
11462   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11463   ;;
11464   *)
11465   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11466 for as_dir in $gcc_cv_tool_dirs
11467 do
11468   IFS=$as_save_IFS
11469   test -z "$as_dir" && as_dir=.
11470   for ac_exec_ext in '' $ac_executable_extensions; do
11471   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11472     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11473     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11474     break 2
11475   fi
11476 done
11477 done
11478
11479   ;;
11480 esac
11481 fi
11482 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11483
11484 if test -n "$WINDMC_FOR_TARGET"; then
11485   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11486 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11487 else
11488   echo "$as_me:$LINENO: result: no" >&5
11489 echo "${ECHO_T}no" >&6
11490 fi
11491
11492 fi
11493 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11494
11495
11496 if test -n "$WINDMC_FOR_TARGET"; then
11497   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11498 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11499   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11500 fi
11501
11502 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11503   for ncn_progname in windmc; do
11504     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11505 set dummy ${ncn_progname}; ac_word=$2
11506 echo "$as_me:$LINENO: checking for $ac_word" >&5
11507 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11508 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11509   echo $ECHO_N "(cached) $ECHO_C" >&6
11510 else
11511   if test -n "$WINDMC_FOR_TARGET"; then
11512   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11513 else
11514 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11515 for as_dir in $PATH
11516 do
11517   IFS=$as_save_IFS
11518   test -z "$as_dir" && as_dir=.
11519   for ac_exec_ext in '' $ac_executable_extensions; do
11520   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11521     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11522     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11523     break 2
11524   fi
11525 done
11526 done
11527
11528 fi
11529 fi
11530 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11531 if test -n "$WINDMC_FOR_TARGET"; then
11532   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11533 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11534 else
11535   echo "$as_me:$LINENO: result: no" >&5
11536 echo "${ECHO_T}no" >&6
11537 fi
11538
11539   done
11540 fi
11541
11542 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11543   for ncn_progname in windmc; do
11544     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11545 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11546     if test -x $with_build_time_tools/${ncn_progname}; then
11547       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11548       echo "$as_me:$LINENO: result: yes" >&5
11549 echo "${ECHO_T}yes" >&6
11550       break
11551     else
11552       echo "$as_me:$LINENO: result: no" >&5
11553 echo "${ECHO_T}no" >&6
11554     fi
11555   done
11556 fi
11557
11558 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11559   for ncn_progname in windmc; do
11560     if test -n "$ncn_target_tool_prefix"; then
11561       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11562 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11563 echo "$as_me:$LINENO: checking for $ac_word" >&5
11564 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11565 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11566   echo $ECHO_N "(cached) $ECHO_C" >&6
11567 else
11568   if test -n "$WINDMC_FOR_TARGET"; then
11569   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11570 else
11571 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11572 for as_dir in $PATH
11573 do
11574   IFS=$as_save_IFS
11575   test -z "$as_dir" && as_dir=.
11576   for ac_exec_ext in '' $ac_executable_extensions; do
11577   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11578     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11579     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11580     break 2
11581   fi
11582 done
11583 done
11584
11585 fi
11586 fi
11587 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11588 if test -n "$WINDMC_FOR_TARGET"; then
11589   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11590 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11591 else
11592   echo "$as_me:$LINENO: result: no" >&5
11593 echo "${ECHO_T}no" >&6
11594 fi
11595
11596     fi
11597     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11598       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11599 set dummy ${ncn_progname}; ac_word=$2
11600 echo "$as_me:$LINENO: checking for $ac_word" >&5
11601 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11602 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11603   echo $ECHO_N "(cached) $ECHO_C" >&6
11604 else
11605   if test -n "$WINDMC_FOR_TARGET"; then
11606   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11607 else
11608 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11609 for as_dir in $PATH
11610 do
11611   IFS=$as_save_IFS
11612   test -z "$as_dir" && as_dir=.
11613   for ac_exec_ext in '' $ac_executable_extensions; do
11614   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11615     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11616     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11617     break 2
11618   fi
11619 done
11620 done
11621
11622 fi
11623 fi
11624 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11625 if test -n "$WINDMC_FOR_TARGET"; then
11626   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11627 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11628 else
11629   echo "$as_me:$LINENO: result: no" >&5
11630 echo "${ECHO_T}no" >&6
11631 fi
11632
11633     fi
11634     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11635   done
11636 fi
11637
11638 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11639   set dummy windmc
11640   if test $build = $target ; then
11641     WINDMC_FOR_TARGET="$2"
11642   else
11643     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11644   fi
11645 else
11646   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11647 fi
11648
11649 else
11650   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11651 fi
11652
11653
11654 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11655
11656 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11657 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11658 if test "x${build}" != "x${host}" ; then
11659   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11660     # We already found the complete path
11661     ac_dir=`dirname $AR_FOR_TARGET`
11662     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11663 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11664   else
11665     # Canadian cross, just use what we found
11666     echo "$as_me:$LINENO: result: pre-installed" >&5
11667 echo "${ECHO_T}pre-installed" >&6
11668   fi
11669 else
11670   ok=yes
11671   case " ${configdirs} " in
11672     *" binutils "*) ;;
11673     *) ok=no ;;
11674   esac
11675
11676   if test $ok = yes; then
11677     # An in-tree tool is available and we can use it
11678     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11679     echo "$as_me:$LINENO: result: just compiled" >&5
11680 echo "${ECHO_T}just compiled" >&6
11681   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11682     # We already found the complete path
11683     ac_dir=`dirname $AR_FOR_TARGET`
11684     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11685 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11686   elif test "x$target" = "x$host"; then
11687     # We can use an host tool
11688     AR_FOR_TARGET='$(AR)'
11689     echo "$as_me:$LINENO: result: host tool" >&5
11690 echo "${ECHO_T}host tool" >&6
11691   else
11692     # We need a cross tool
11693     echo "$as_me:$LINENO: result: pre-installed" >&5
11694 echo "${ECHO_T}pre-installed" >&6
11695   fi
11696 fi
11697
11698 echo "$as_me:$LINENO: checking where to find the target as" >&5
11699 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11700 if test "x${build}" != "x${host}" ; then
11701   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11702     # We already found the complete path
11703     ac_dir=`dirname $AS_FOR_TARGET`
11704     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11705 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11706   else
11707     # Canadian cross, just use what we found
11708     echo "$as_me:$LINENO: result: pre-installed" >&5
11709 echo "${ECHO_T}pre-installed" >&6
11710   fi
11711 else
11712   ok=yes
11713   case " ${configdirs} " in
11714     *" gas "*) ;;
11715     *) ok=no ;;
11716   esac
11717
11718   if test $ok = yes; then
11719     # An in-tree tool is available and we can use it
11720     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11721     echo "$as_me:$LINENO: result: just compiled" >&5
11722 echo "${ECHO_T}just compiled" >&6
11723   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11724     # We already found the complete path
11725     ac_dir=`dirname $AS_FOR_TARGET`
11726     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11727 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11728   elif test "x$target" = "x$host"; then
11729     # We can use an host tool
11730     AS_FOR_TARGET='$(AS)'
11731     echo "$as_me:$LINENO: result: host tool" >&5
11732 echo "${ECHO_T}host tool" >&6
11733   else
11734     # We need a cross tool
11735     echo "$as_me:$LINENO: result: pre-installed" >&5
11736 echo "${ECHO_T}pre-installed" >&6
11737   fi
11738 fi
11739
11740 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11741 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11742 if test "x${build}" != "x${host}" ; then
11743   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11744     # We already found the complete path
11745     ac_dir=`dirname $CC_FOR_TARGET`
11746     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11747 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11748   else
11749     # Canadian cross, just use what we found
11750     echo "$as_me:$LINENO: result: pre-installed" >&5
11751 echo "${ECHO_T}pre-installed" >&6
11752   fi
11753 else
11754   ok=yes
11755   case " ${configdirs} " in
11756     *" gcc "*) ;;
11757     *) ok=no ;;
11758   esac
11759
11760   if test $ok = yes; then
11761     # An in-tree tool is available and we can use it
11762     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11763     echo "$as_me:$LINENO: result: just compiled" >&5
11764 echo "${ECHO_T}just compiled" >&6
11765   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11766     # We already found the complete path
11767     ac_dir=`dirname $CC_FOR_TARGET`
11768     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11769 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11770   elif test "x$target" = "x$host"; then
11771     # We can use an host tool
11772     CC_FOR_TARGET='$(CC)'
11773     echo "$as_me:$LINENO: result: host tool" >&5
11774 echo "${ECHO_T}host tool" >&6
11775   else
11776     # We need a cross tool
11777     echo "$as_me:$LINENO: result: pre-installed" >&5
11778 echo "${ECHO_T}pre-installed" >&6
11779   fi
11780 fi
11781
11782 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11783 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11784 if test "x${build}" != "x${host}" ; then
11785   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11786     # We already found the complete path
11787     ac_dir=`dirname $CXX_FOR_TARGET`
11788     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11789 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11790   else
11791     # Canadian cross, just use what we found
11792     echo "$as_me:$LINENO: result: pre-installed" >&5
11793 echo "${ECHO_T}pre-installed" >&6
11794   fi
11795 else
11796   ok=yes
11797   case " ${configdirs} " in
11798     *" gcc "*) ;;
11799     *) ok=no ;;
11800   esac
11801   case ,${enable_languages}, in
11802     *,c++,*) ;;
11803     *) ok=no ;;
11804   esac
11805   if test $ok = yes; then
11806     # An in-tree tool is available and we can use it
11807     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'
11808     echo "$as_me:$LINENO: result: just compiled" >&5
11809 echo "${ECHO_T}just compiled" >&6
11810   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11811     # We already found the complete path
11812     ac_dir=`dirname $CXX_FOR_TARGET`
11813     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11814 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11815   elif test "x$target" = "x$host"; then
11816     # We can use an host tool
11817     CXX_FOR_TARGET='$(CXX)'
11818     echo "$as_me:$LINENO: result: host tool" >&5
11819 echo "${ECHO_T}host tool" >&6
11820   else
11821     # We need a cross tool
11822     echo "$as_me:$LINENO: result: pre-installed" >&5
11823 echo "${ECHO_T}pre-installed" >&6
11824   fi
11825 fi
11826
11827 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11828 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11829 if test "x${build}" != "x${host}" ; then
11830   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11831     # We already found the complete path
11832     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11833     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11834 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11835   else
11836     # Canadian cross, just use what we found
11837     echo "$as_me:$LINENO: result: pre-installed" >&5
11838 echo "${ECHO_T}pre-installed" >&6
11839   fi
11840 else
11841   ok=yes
11842   case " ${configdirs} " in
11843     *" gcc "*) ;;
11844     *) ok=no ;;
11845   esac
11846   case ,${enable_languages}, in
11847     *,c++,*) ;;
11848     *) ok=no ;;
11849   esac
11850   if test $ok = yes; then
11851     # An in-tree tool is available and we can use it
11852     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'
11853     echo "$as_me:$LINENO: result: just compiled" >&5
11854 echo "${ECHO_T}just compiled" >&6
11855   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11856     # We already found the complete path
11857     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11858     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11859 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11860   elif test "x$target" = "x$host"; then
11861     # We can use an host tool
11862     RAW_CXX_FOR_TARGET='$(CXX)'
11863     echo "$as_me:$LINENO: result: host tool" >&5
11864 echo "${ECHO_T}host tool" >&6
11865   else
11866     # We need a cross tool
11867     echo "$as_me:$LINENO: result: pre-installed" >&5
11868 echo "${ECHO_T}pre-installed" >&6
11869   fi
11870 fi
11871
11872 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11873 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11874 if test "x${build}" != "x${host}" ; then
11875   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11876     # We already found the complete path
11877     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11878     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11879 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11880   else
11881     # Canadian cross, just use what we found
11882     echo "$as_me:$LINENO: result: pre-installed" >&5
11883 echo "${ECHO_T}pre-installed" >&6
11884   fi
11885 else
11886   ok=yes
11887   case " ${configdirs} " in
11888     *" binutils "*) ;;
11889     *) ok=no ;;
11890   esac
11891
11892   if test $ok = yes; then
11893     # An in-tree tool is available and we can use it
11894     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11895     echo "$as_me:$LINENO: result: just compiled" >&5
11896 echo "${ECHO_T}just compiled" >&6
11897   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11898     # We already found the complete path
11899     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11900     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11901 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11902   elif test "x$target" = "x$host"; then
11903     # We can use an host tool
11904     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11905     echo "$as_me:$LINENO: result: host tool" >&5
11906 echo "${ECHO_T}host tool" >&6
11907   else
11908     # We need a cross tool
11909     echo "$as_me:$LINENO: result: pre-installed" >&5
11910 echo "${ECHO_T}pre-installed" >&6
11911   fi
11912 fi
11913
11914 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11915 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11916 if test "x${build}" != "x${host}" ; then
11917   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11918     # We already found the complete path
11919     ac_dir=`dirname $GCC_FOR_TARGET`
11920     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11921 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11922   else
11923     # Canadian cross, just use what we found
11924     echo "$as_me:$LINENO: result: pre-installed" >&5
11925 echo "${ECHO_T}pre-installed" >&6
11926   fi
11927 else
11928   ok=yes
11929   case " ${configdirs} " in
11930     *" gcc "*) ;;
11931     *) ok=no ;;
11932   esac
11933
11934   if test $ok = yes; then
11935     # An in-tree tool is available and we can use it
11936     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11937     echo "$as_me:$LINENO: result: just compiled" >&5
11938 echo "${ECHO_T}just compiled" >&6
11939   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11940     # We already found the complete path
11941     ac_dir=`dirname $GCC_FOR_TARGET`
11942     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11943 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11944   elif test "x$target" = "x$host"; then
11945     # We can use an host tool
11946     GCC_FOR_TARGET='$()'
11947     echo "$as_me:$LINENO: result: host tool" >&5
11948 echo "${ECHO_T}host tool" >&6
11949   else
11950     # We need a cross tool
11951     echo "$as_me:$LINENO: result: pre-installed" >&5
11952 echo "${ECHO_T}pre-installed" >&6
11953   fi
11954 fi
11955
11956 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11957 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11958 if test "x${build}" != "x${host}" ; then
11959   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11960     # We already found the complete path
11961     ac_dir=`dirname $GCJ_FOR_TARGET`
11962     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11963 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11964   else
11965     # Canadian cross, just use what we found
11966     echo "$as_me:$LINENO: result: pre-installed" >&5
11967 echo "${ECHO_T}pre-installed" >&6
11968   fi
11969 else
11970   ok=yes
11971   case " ${configdirs} " in
11972     *" gcc "*) ;;
11973     *) ok=no ;;
11974   esac
11975   case ,${enable_languages}, in
11976     *,java,*) ;;
11977     *) ok=no ;;
11978   esac
11979   if test $ok = yes; then
11980     # An in-tree tool is available and we can use it
11981     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11982     echo "$as_me:$LINENO: result: just compiled" >&5
11983 echo "${ECHO_T}just compiled" >&6
11984   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11985     # We already found the complete path
11986     ac_dir=`dirname $GCJ_FOR_TARGET`
11987     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11988 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11989   elif test "x$target" = "x$host"; then
11990     # We can use an host tool
11991     GCJ_FOR_TARGET='$(GCJ)'
11992     echo "$as_me:$LINENO: result: host tool" >&5
11993 echo "${ECHO_T}host tool" >&6
11994   else
11995     # We need a cross tool
11996     echo "$as_me:$LINENO: result: pre-installed" >&5
11997 echo "${ECHO_T}pre-installed" >&6
11998   fi
11999 fi
12000
12001 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
12002 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
12003 if test "x${build}" != "x${host}" ; then
12004   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12005     # We already found the complete path
12006     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12007     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12008 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12009   else
12010     # Canadian cross, just use what we found
12011     echo "$as_me:$LINENO: result: pre-installed" >&5
12012 echo "${ECHO_T}pre-installed" >&6
12013   fi
12014 else
12015   ok=yes
12016   case " ${configdirs} " in
12017     *" gcc "*) ;;
12018     *) ok=no ;;
12019   esac
12020   case ,${enable_languages}, in
12021     *,fortran,*) ;;
12022     *) ok=no ;;
12023   esac
12024   if test $ok = yes; then
12025     # An in-tree tool is available and we can use it
12026     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12027     echo "$as_me:$LINENO: result: just compiled" >&5
12028 echo "${ECHO_T}just compiled" >&6
12029   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12030     # We already found the complete path
12031     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12032     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12033 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12034   elif test "x$target" = "x$host"; then
12035     # We can use an host tool
12036     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12037     echo "$as_me:$LINENO: result: host tool" >&5
12038 echo "${ECHO_T}host tool" >&6
12039   else
12040     # We need a cross tool
12041     echo "$as_me:$LINENO: result: pre-installed" >&5
12042 echo "${ECHO_T}pre-installed" >&6
12043   fi
12044 fi
12045
12046 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12047 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12048 if test "x${build}" != "x${host}" ; then
12049   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12050     # We already found the complete path
12051     ac_dir=`dirname $LD_FOR_TARGET`
12052     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12053 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12054   else
12055     # Canadian cross, just use what we found
12056     echo "$as_me:$LINENO: result: pre-installed" >&5
12057 echo "${ECHO_T}pre-installed" >&6
12058   fi
12059 else
12060   ok=yes
12061   case " ${configdirs} " in
12062     *" ld "*) ;;
12063     *) ok=no ;;
12064   esac
12065
12066   if test $ok = yes; then
12067     # An in-tree tool is available and we can use it
12068     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12069     echo "$as_me:$LINENO: result: just compiled" >&5
12070 echo "${ECHO_T}just compiled" >&6
12071   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12072     # We already found the complete path
12073     ac_dir=`dirname $LD_FOR_TARGET`
12074     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12075 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12076   elif test "x$target" = "x$host"; then
12077     # We can use an host tool
12078     LD_FOR_TARGET='$(LD)'
12079     echo "$as_me:$LINENO: result: host tool" >&5
12080 echo "${ECHO_T}host tool" >&6
12081   else
12082     # We need a cross tool
12083     echo "$as_me:$LINENO: result: pre-installed" >&5
12084 echo "${ECHO_T}pre-installed" >&6
12085   fi
12086 fi
12087
12088 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12089 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12090 if test "x${build}" != "x${host}" ; then
12091   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12092     # We already found the complete path
12093     ac_dir=`dirname $LIPO_FOR_TARGET`
12094     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12095 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12096   else
12097     # Canadian cross, just use what we found
12098     echo "$as_me:$LINENO: result: pre-installed" >&5
12099 echo "${ECHO_T}pre-installed" >&6
12100   fi
12101 else
12102   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12103     # We already found the complete path
12104     ac_dir=`dirname $LIPO_FOR_TARGET`
12105     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12106 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12107   elif test "x$target" = "x$host"; then
12108     # We can use an host tool
12109     LIPO_FOR_TARGET='$(LIPO)'
12110     echo "$as_me:$LINENO: result: host tool" >&5
12111 echo "${ECHO_T}host tool" >&6
12112   else
12113     # We need a cross tool
12114     echo "$as_me:$LINENO: result: pre-installed" >&5
12115 echo "${ECHO_T}pre-installed" >&6
12116   fi
12117 fi
12118
12119 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12120 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12121 if test "x${build}" != "x${host}" ; then
12122   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12123     # We already found the complete path
12124     ac_dir=`dirname $NM_FOR_TARGET`
12125     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12126 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12127   else
12128     # Canadian cross, just use what we found
12129     echo "$as_me:$LINENO: result: pre-installed" >&5
12130 echo "${ECHO_T}pre-installed" >&6
12131   fi
12132 else
12133   ok=yes
12134   case " ${configdirs} " in
12135     *" binutils "*) ;;
12136     *) ok=no ;;
12137   esac
12138
12139   if test $ok = yes; then
12140     # An in-tree tool is available and we can use it
12141     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12142     echo "$as_me:$LINENO: result: just compiled" >&5
12143 echo "${ECHO_T}just compiled" >&6
12144   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12145     # We already found the complete path
12146     ac_dir=`dirname $NM_FOR_TARGET`
12147     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12148 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12149   elif test "x$target" = "x$host"; then
12150     # We can use an host tool
12151     NM_FOR_TARGET='$(NM)'
12152     echo "$as_me:$LINENO: result: host tool" >&5
12153 echo "${ECHO_T}host tool" >&6
12154   else
12155     # We need a cross tool
12156     echo "$as_me:$LINENO: result: pre-installed" >&5
12157 echo "${ECHO_T}pre-installed" >&6
12158   fi
12159 fi
12160
12161 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12162 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12163 if test "x${build}" != "x${host}" ; then
12164   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12165     # We already found the complete path
12166     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12167     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12168 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12169   else
12170     # Canadian cross, just use what we found
12171     echo "$as_me:$LINENO: result: pre-installed" >&5
12172 echo "${ECHO_T}pre-installed" >&6
12173   fi
12174 else
12175   ok=yes
12176   case " ${configdirs} " in
12177     *" binutils "*) ;;
12178     *) ok=no ;;
12179   esac
12180
12181   if test $ok = yes; then
12182     # An in-tree tool is available and we can use it
12183     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12184     echo "$as_me:$LINENO: result: just compiled" >&5
12185 echo "${ECHO_T}just compiled" >&6
12186   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12187     # We already found the complete path
12188     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12189     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12190 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12191   elif test "x$target" = "x$host"; then
12192     # We can use an host tool
12193     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12194     echo "$as_me:$LINENO: result: host tool" >&5
12195 echo "${ECHO_T}host tool" >&6
12196   else
12197     # We need a cross tool
12198     echo "$as_me:$LINENO: result: pre-installed" >&5
12199 echo "${ECHO_T}pre-installed" >&6
12200   fi
12201 fi
12202
12203 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12204 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12205 if test "x${build}" != "x${host}" ; then
12206   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12207     # We already found the complete path
12208     ac_dir=`dirname $RANLIB_FOR_TARGET`
12209     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12210 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12211   else
12212     # Canadian cross, just use what we found
12213     echo "$as_me:$LINENO: result: pre-installed" >&5
12214 echo "${ECHO_T}pre-installed" >&6
12215   fi
12216 else
12217   ok=yes
12218   case " ${configdirs} " in
12219     *" binutils "*) ;;
12220     *) ok=no ;;
12221   esac
12222
12223   if test $ok = yes; then
12224     # An in-tree tool is available and we can use it
12225     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12226     echo "$as_me:$LINENO: result: just compiled" >&5
12227 echo "${ECHO_T}just compiled" >&6
12228   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12229     # We already found the complete path
12230     ac_dir=`dirname $RANLIB_FOR_TARGET`
12231     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12232 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12233   elif test "x$target" = "x$host"; then
12234     # We can use an host tool
12235     RANLIB_FOR_TARGET='$(RANLIB)'
12236     echo "$as_me:$LINENO: result: host tool" >&5
12237 echo "${ECHO_T}host tool" >&6
12238   else
12239     # We need a cross tool
12240     echo "$as_me:$LINENO: result: pre-installed" >&5
12241 echo "${ECHO_T}pre-installed" >&6
12242   fi
12243 fi
12244
12245 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12246 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12247 if test "x${build}" != "x${host}" ; then
12248   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12249     # We already found the complete path
12250     ac_dir=`dirname $STRIP_FOR_TARGET`
12251     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12252 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12253   else
12254     # Canadian cross, just use what we found
12255     echo "$as_me:$LINENO: result: pre-installed" >&5
12256 echo "${ECHO_T}pre-installed" >&6
12257   fi
12258 else
12259   ok=yes
12260   case " ${configdirs} " in
12261     *" binutils "*) ;;
12262     *) ok=no ;;
12263   esac
12264
12265   if test $ok = yes; then
12266     # An in-tree tool is available and we can use it
12267     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12268     echo "$as_me:$LINENO: result: just compiled" >&5
12269 echo "${ECHO_T}just compiled" >&6
12270   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12271     # We already found the complete path
12272     ac_dir=`dirname $STRIP_FOR_TARGET`
12273     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12274 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12275   elif test "x$target" = "x$host"; then
12276     # We can use an host tool
12277     STRIP_FOR_TARGET='$(STRIP)'
12278     echo "$as_me:$LINENO: result: host tool" >&5
12279 echo "${ECHO_T}host tool" >&6
12280   else
12281     # We need a cross tool
12282     echo "$as_me:$LINENO: result: pre-installed" >&5
12283 echo "${ECHO_T}pre-installed" >&6
12284   fi
12285 fi
12286
12287 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12288 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12289 if test "x${build}" != "x${host}" ; then
12290   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12291     # We already found the complete path
12292     ac_dir=`dirname $WINDRES_FOR_TARGET`
12293     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12294 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12295   else
12296     # Canadian cross, just use what we found
12297     echo "$as_me:$LINENO: result: pre-installed" >&5
12298 echo "${ECHO_T}pre-installed" >&6
12299   fi
12300 else
12301   ok=yes
12302   case " ${configdirs} " in
12303     *" binutils "*) ;;
12304     *) ok=no ;;
12305   esac
12306
12307   if test $ok = yes; then
12308     # An in-tree tool is available and we can use it
12309     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12310     echo "$as_me:$LINENO: result: just compiled" >&5
12311 echo "${ECHO_T}just compiled" >&6
12312   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12313     # We already found the complete path
12314     ac_dir=`dirname $WINDRES_FOR_TARGET`
12315     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12316 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12317   elif test "x$target" = "x$host"; then
12318     # We can use an host tool
12319     WINDRES_FOR_TARGET='$(WINDRES)'
12320     echo "$as_me:$LINENO: result: host tool" >&5
12321 echo "${ECHO_T}host tool" >&6
12322   else
12323     # We need a cross tool
12324     echo "$as_me:$LINENO: result: pre-installed" >&5
12325 echo "${ECHO_T}pre-installed" >&6
12326   fi
12327 fi
12328
12329 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12330 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12331 if test "x${build}" != "x${host}" ; then
12332   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12333     # We already found the complete path
12334     ac_dir=`dirname $WINDMC_FOR_TARGET`
12335     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12336 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12337   else
12338     # Canadian cross, just use what we found
12339     echo "$as_me:$LINENO: result: pre-installed" >&5
12340 echo "${ECHO_T}pre-installed" >&6
12341   fi
12342 else
12343   ok=yes
12344   case " ${configdirs} " in
12345     *" binutils "*) ;;
12346     *) ok=no ;;
12347   esac
12348
12349   if test $ok = yes; then
12350     # An in-tree tool is available and we can use it
12351     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12352     echo "$as_me:$LINENO: result: just compiled" >&5
12353 echo "${ECHO_T}just compiled" >&6
12354   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12355     # We already found the complete path
12356     ac_dir=`dirname $WINDMC_FOR_TARGET`
12357     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12358 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12359   elif test "x$target" = "x$host"; then
12360     # We can use an host tool
12361     WINDMC_FOR_TARGET='$(WINDMC)'
12362     echo "$as_me:$LINENO: result: host tool" >&5
12363 echo "${ECHO_T}host tool" >&6
12364   else
12365     # We need a cross tool
12366     echo "$as_me:$LINENO: result: pre-installed" >&5
12367 echo "${ECHO_T}pre-installed" >&6
12368   fi
12369 fi
12370
12371
12372
12373
12374
12375 # Certain tools may need extra flags.
12376 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12377 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12378 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12379
12380 # When building target libraries, except in a Canadian cross, we use
12381 # the same toolchain as the compiler we just built.
12382 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12383 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12384 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12385 if test $host = $build; then
12386   case " $configdirs " in
12387     *" gcc "*)
12388       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12389       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12390       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12391       ;;
12392   esac
12393 fi
12394
12395
12396
12397
12398
12399 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12400 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12401 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12402 if test "${enable_maintainer_mode+set}" = set; then
12403   enableval="$enable_maintainer_mode"
12404   USE_MAINTAINER_MODE=$enableval
12405 else
12406   USE_MAINTAINER_MODE=no
12407 fi;
12408 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12409 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12410
12411
12412 if test "$USE_MAINTAINER_MODE" = yes; then
12413   MAINTAINER_MODE_TRUE=
12414   MAINTAINER_MODE_FALSE='#'
12415 else
12416   MAINTAINER_MODE_TRUE='#'
12417   MAINTAINER_MODE_FALSE=
12418 fi
12419 MAINT=$MAINTAINER_MODE_TRUE
12420
12421 # ---------------------
12422 # GCC bootstrap support
12423 # ---------------------
12424
12425 # Stage specific cflags for build.
12426 stage1_cflags="-g"
12427 case $build in
12428   vax-*-*)
12429     case ${GCC} in
12430       yes) stage1_cflags="-g -Wa,-J" ;;
12431       *) stage1_cflags="-g -J" ;;
12432     esac ;;
12433 esac
12434
12435 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12436 if test "$GCC" = yes; then
12437   saved_CFLAGS="$CFLAGS"
12438
12439   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12440   CFLAGS="$CFLAGS -fkeep-inline-functions"
12441   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12442 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12443   cat >conftest.$ac_ext <<_ACEOF
12444 /* confdefs.h.  */
12445 _ACEOF
12446 cat confdefs.h >>conftest.$ac_ext
12447 cat >>conftest.$ac_ext <<_ACEOF
12448 /* end confdefs.h.  */
12449
12450 #if (__GNUC__ < 3) \
12451     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12452                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12453 #error http://gcc.gnu.org/PR29382
12454 #endif
12455
12456 int
12457 main ()
12458 {
12459
12460   ;
12461   return 0;
12462 }
12463 _ACEOF
12464 rm -f conftest.$ac_objext
12465 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12466   (eval $ac_compile) 2>conftest.er1
12467   ac_status=$?
12468   grep -v '^ *+' conftest.er1 >conftest.err
12469   rm -f conftest.er1
12470   cat conftest.err >&5
12471   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12472   (exit $ac_status); } &&
12473          { ac_try='test -z "$ac_c_werror_flag"
12474                          || test ! -s conftest.err'
12475   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12476   (eval $ac_try) 2>&5
12477   ac_status=$?
12478   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12479   (exit $ac_status); }; } &&
12480          { ac_try='test -s conftest.$ac_objext'
12481   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12482   (eval $ac_try) 2>&5
12483   ac_status=$?
12484   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12485   (exit $ac_status); }; }; then
12486   echo "$as_me:$LINENO: result: yes" >&5
12487 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12488 else
12489   echo "$as_me: failed program was:" >&5
12490 sed 's/^/| /' conftest.$ac_ext >&5
12491
12492 echo "$as_me:$LINENO: result: no" >&5
12493 echo "${ECHO_T}no" >&6
12494 fi
12495 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12496
12497   CFLAGS="$saved_CFLAGS"
12498 fi
12499
12500
12501
12502 # Enable --enable-checking in stage1 of the compiler.
12503 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12504 if test "${enable_stage1_checking+set}" = set; then
12505   enableval="$enable_stage1_checking"
12506   stage1_checking=--enable-checking=${enable_stage1_checking}
12507 else
12508   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12509   stage1_checking=--enable-checking=yes,types
12510 else
12511   stage1_checking=--enable-checking=$enable_checking,types
12512 fi
12513 fi;
12514
12515
12516 # Enable -Werror in bootstrap stage2 and later.
12517 # Check whether --enable-werror or --disable-werror was given.
12518 if test "${enable_werror+set}" = set; then
12519   enableval="$enable_werror"
12520
12521 else
12522   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12523   enable_werror=yes
12524 else
12525   enable_werror=no
12526 fi
12527 fi;
12528 case ${enable_werror} in
12529   yes) stage2_werror_flag="--enable-werror-always" ;;
12530   *) stage2_werror_flag="" ;;
12531 esac
12532
12533
12534 # Flags needed to enable html installing and building
12535
12536 # Check whether --with-datarootdir or --without-datarootdir was given.
12537 if test "${with_datarootdir+set}" = set; then
12538   withval="$with_datarootdir"
12539   datarootdir="\${prefix}/${withval}"
12540 else
12541   datarootdir="\${prefix}/share"
12542 fi;
12543
12544
12545 # Check whether --with-docdir or --without-docdir was given.
12546 if test "${with_docdir+set}" = set; then
12547   withval="$with_docdir"
12548   docdir="\${prefix}/${withval}"
12549 else
12550   docdir="\${datarootdir}/doc"
12551 fi;
12552
12553
12554 # Check whether --with-pdfdir or --without-pdfdir was given.
12555 if test "${with_pdfdir+set}" = set; then
12556   withval="$with_pdfdir"
12557   pdfdir="\${prefix}/${withval}"
12558 else
12559   pdfdir="\${docdir}"
12560 fi;
12561
12562
12563 # Check whether --with-htmldir or --without-htmldir was given.
12564 if test "${with_htmldir+set}" = set; then
12565   withval="$with_htmldir"
12566   htmldir="\${prefix}/${withval}"
12567 else
12568   htmldir="\${docdir}"
12569 fi;
12570
12571
12572
12573
12574
12575
12576           ac_config_files="$ac_config_files Makefile"
12577 cat >confcache <<\_ACEOF
12578 # This file is a shell script that caches the results of configure
12579 # tests run on this system so they can be shared between configure
12580 # scripts and configure runs, see configure's option --config-cache.
12581 # It is not useful on other systems.  If it contains results you don't
12582 # want to keep, you may remove or edit it.
12583 #
12584 # config.status only pays attention to the cache file if you give it
12585 # the --recheck option to rerun configure.
12586 #
12587 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12588 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12589 # following values.
12590
12591 _ACEOF
12592
12593 # The following way of writing the cache mishandles newlines in values,
12594 # but we know of no workaround that is simple, portable, and efficient.
12595 # So, don't put newlines in cache variables' values.
12596 # Ultrix sh set writes to stderr and can't be redirected directly,
12597 # and sets the high bit in the cache file unless we assign to the vars.
12598 {
12599   (set) 2>&1 |
12600     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12601     *ac_space=\ *)
12602       # `set' does not quote correctly, so add quotes (double-quote
12603       # substitution turns \\\\ into \\, and sed turns \\ into \).
12604       sed -n \
12605         "s/'/'\\\\''/g;
12606           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12607       ;;
12608     *)
12609       # `set' quotes correctly as required by POSIX, so do not add quotes.
12610       sed -n \
12611         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12612       ;;
12613     esac;
12614 } |
12615   sed '
12616      t clear
12617      : clear
12618      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12619      t end
12620      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12621      : end' >>confcache
12622 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12623   if test -w $cache_file; then
12624     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12625     cat confcache >$cache_file
12626   else
12627     echo "not updating unwritable cache $cache_file"
12628   fi
12629 fi
12630 rm -f confcache
12631
12632 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12633 # Let make expand exec_prefix.
12634 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12635
12636 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12637 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12638 # trailing colons and then remove the whole line if VPATH becomes empty
12639 # (actually we leave an empty line to preserve line numbers).
12640 if test "x$srcdir" = x.; then
12641   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12642 s/:*\$(srcdir):*/:/;
12643 s/:*\${srcdir}:*/:/;
12644 s/:*@srcdir@:*/:/;
12645 s/^\([^=]*=[     ]*\):*/\1/;
12646 s/:*$//;
12647 s/^[^=]*=[       ]*$//;
12648 }'
12649 fi
12650
12651 # Transform confdefs.h into DEFS.
12652 # Protect against shell expansion while executing Makefile rules.
12653 # Protect against Makefile macro expansion.
12654 #
12655 # If the first sed substitution is executed (which looks for macros that
12656 # take arguments), then we branch to the quote section.  Otherwise,
12657 # look for a macro that doesn't take arguments.
12658 cat >confdef2opt.sed <<\_ACEOF
12659 t clear
12660 : clear
12661 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12662 t quote
12663 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12664 t quote
12665 d
12666 : quote
12667 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12668 s,\[,\\&,g
12669 s,\],\\&,g
12670 s,\$,$$,g
12671 p
12672 _ACEOF
12673 # We use echo to avoid assuming a particular line-breaking character.
12674 # The extra dot is to prevent the shell from consuming trailing
12675 # line-breaks from the sub-command output.  A line-break within
12676 # single-quotes doesn't work because, if this script is created in a
12677 # platform that uses two characters for line-breaks (e.g., DOS), tr
12678 # would break.
12679 ac_LF_and_DOT=`echo; echo .`
12680 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12681 rm -f confdef2opt.sed
12682
12683
12684 ac_libobjs=
12685 ac_ltlibobjs=
12686 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12687   # 1. Remove the extension, and $U if already installed.
12688   ac_i=`echo "$ac_i" |
12689          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12690   # 2. Add them.
12691   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12692   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12693 done
12694 LIBOBJS=$ac_libobjs
12695
12696 LTLIBOBJS=$ac_ltlibobjs
12697
12698
12699
12700 : ${CONFIG_STATUS=./config.status}
12701 ac_clean_files_save=$ac_clean_files
12702 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12703 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12704 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12705 cat >$CONFIG_STATUS <<_ACEOF
12706 #! $SHELL
12707 # Generated by $as_me.
12708 # Run this file to recreate the current configuration.
12709 # Compiler output produced by configure, useful for debugging
12710 # configure, is in config.log if it exists.
12711
12712 debug=false
12713 ac_cs_recheck=false
12714 ac_cs_silent=false
12715 SHELL=\${CONFIG_SHELL-$SHELL}
12716 _ACEOF
12717
12718 cat >>$CONFIG_STATUS <<\_ACEOF
12719 ## --------------------- ##
12720 ## M4sh Initialization.  ##
12721 ## --------------------- ##
12722
12723 # Be Bourne compatible
12724 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12725   emulate sh
12726   NULLCMD=:
12727   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12728   # is contrary to our usage.  Disable this feature.
12729   alias -g '${1+"$@"}'='"$@"'
12730 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12731   set -o posix
12732 fi
12733 DUALCASE=1; export DUALCASE # for MKS sh
12734
12735 # Support unset when possible.
12736 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12737   as_unset=unset
12738 else
12739   as_unset=false
12740 fi
12741
12742
12743 # Work around bugs in pre-3.0 UWIN ksh.
12744 $as_unset ENV MAIL MAILPATH
12745 PS1='$ '
12746 PS2='> '
12747 PS4='+ '
12748
12749 # NLS nuisances.
12750 for as_var in \
12751   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12752   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12753   LC_TELEPHONE LC_TIME
12754 do
12755   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12756     eval $as_var=C; export $as_var
12757   else
12758     $as_unset $as_var
12759   fi
12760 done
12761
12762 # Required to use basename.
12763 if expr a : '\(a\)' >/dev/null 2>&1; then
12764   as_expr=expr
12765 else
12766   as_expr=false
12767 fi
12768
12769 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12770   as_basename=basename
12771 else
12772   as_basename=false
12773 fi
12774
12775
12776 # Name of the executable.
12777 as_me=`$as_basename "$0" ||
12778 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12779          X"$0" : 'X\(//\)$' \| \
12780          X"$0" : 'X\(/\)$' \| \
12781          .     : '\(.\)' 2>/dev/null ||
12782 echo X/"$0" |
12783     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12784           /^X\/\(\/\/\)$/{ s//\1/; q; }
12785           /^X\/\(\/\).*/{ s//\1/; q; }
12786           s/.*/./; q'`
12787
12788
12789 # PATH needs CR, and LINENO needs CR and PATH.
12790 # Avoid depending upon Character Ranges.
12791 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12792 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12793 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12794 as_cr_digits='0123456789'
12795 as_cr_alnum=$as_cr_Letters$as_cr_digits
12796
12797 # The user is always right.
12798 if test "${PATH_SEPARATOR+set}" != set; then
12799   echo "#! /bin/sh" >conf$$.sh
12800   echo  "exit 0"   >>conf$$.sh
12801   chmod +x conf$$.sh
12802   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12803     PATH_SEPARATOR=';'
12804   else
12805     PATH_SEPARATOR=:
12806   fi
12807   rm -f conf$$.sh
12808 fi
12809
12810
12811   as_lineno_1=$LINENO
12812   as_lineno_2=$LINENO
12813   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12814   test "x$as_lineno_1" != "x$as_lineno_2" &&
12815   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12816   # Find who we are.  Look in the path if we contain no path at all
12817   # relative or not.
12818   case $0 in
12819     *[\\/]* ) as_myself=$0 ;;
12820     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12821 for as_dir in $PATH
12822 do
12823   IFS=$as_save_IFS
12824   test -z "$as_dir" && as_dir=.
12825   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12826 done
12827
12828        ;;
12829   esac
12830   # We did not find ourselves, most probably we were run as `sh COMMAND'
12831   # in which case we are not to be found in the path.
12832   if test "x$as_myself" = x; then
12833     as_myself=$0
12834   fi
12835   if test ! -f "$as_myself"; then
12836     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12837 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12838    { (exit 1); exit 1; }; }
12839   fi
12840   case $CONFIG_SHELL in
12841   '')
12842     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12843 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12844 do
12845   IFS=$as_save_IFS
12846   test -z "$as_dir" && as_dir=.
12847   for as_base in sh bash ksh sh5; do
12848          case $as_dir in
12849          /*)
12850            if ("$as_dir/$as_base" -c '
12851   as_lineno_1=$LINENO
12852   as_lineno_2=$LINENO
12853   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12854   test "x$as_lineno_1" != "x$as_lineno_2" &&
12855   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12856              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12857              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12858              CONFIG_SHELL=$as_dir/$as_base
12859              export CONFIG_SHELL
12860              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12861            fi;;
12862          esac
12863        done
12864 done
12865 ;;
12866   esac
12867
12868   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12869   # uniformly replaced by the line number.  The first 'sed' inserts a
12870   # line-number line before each line; the second 'sed' does the real
12871   # work.  The second script uses 'N' to pair each line-number line
12872   # with the numbered line, and appends trailing '-' during
12873   # substitution so that $LINENO is not a special case at line end.
12874   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12875   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12876   sed '=' <$as_myself |
12877     sed '
12878       N
12879       s,$,-,
12880       : loop
12881       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12882       t loop
12883       s,-$,,
12884       s,^['$as_cr_digits']*\n,,
12885     ' >$as_me.lineno &&
12886   chmod +x $as_me.lineno ||
12887     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12888 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12889    { (exit 1); exit 1; }; }
12890
12891   # Don't try to exec as it changes $[0], causing all sort of problems
12892   # (the dirname of $[0] is not the place where we might find the
12893   # original and so on.  Autoconf is especially sensible to this).
12894   . ./$as_me.lineno
12895   # Exit status is that of the last command.
12896   exit
12897 }
12898
12899
12900 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12901   *c*,-n*) ECHO_N= ECHO_C='
12902 ' ECHO_T='      ' ;;
12903   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12904   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12905 esac
12906
12907 if expr a : '\(a\)' >/dev/null 2>&1; then
12908   as_expr=expr
12909 else
12910   as_expr=false
12911 fi
12912
12913 rm -f conf$$ conf$$.exe conf$$.file
12914 echo >conf$$.file
12915 if ln -s conf$$.file conf$$ 2>/dev/null; then
12916   # We could just check for DJGPP; but this test a) works b) is more generic
12917   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12918   if test -f conf$$.exe; then
12919     # Don't use ln at all; we don't have any links
12920     as_ln_s='cp -p'
12921   else
12922     as_ln_s='ln -s'
12923   fi
12924 elif ln conf$$.file conf$$ 2>/dev/null; then
12925   as_ln_s=ln
12926 else
12927   as_ln_s='cp -p'
12928 fi
12929 rm -f conf$$ conf$$.exe conf$$.file
12930
12931 if mkdir -p . 2>/dev/null; then
12932   as_mkdir_p=:
12933 else
12934   test -d ./-p && rmdir ./-p
12935   as_mkdir_p=false
12936 fi
12937
12938 as_executable_p="test -f"
12939
12940 # Sed expression to map a string onto a valid CPP name.
12941 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12942
12943 # Sed expression to map a string onto a valid variable name.
12944 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12945
12946
12947 # IFS
12948 # We need space, tab and new line, in precisely that order.
12949 as_nl='
12950 '
12951 IFS="   $as_nl"
12952
12953 # CDPATH.
12954 $as_unset CDPATH
12955
12956 exec 6>&1
12957
12958 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12959 # report actual input values of CONFIG_FILES etc. instead of their
12960 # values after options handling.  Logging --version etc. is OK.
12961 exec 5>>config.log
12962 {
12963   echo
12964   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12965 ## Running $as_me. ##
12966 _ASBOX
12967 } >&5
12968 cat >&5 <<_CSEOF
12969
12970 This file was extended by $as_me, which was
12971 generated by GNU Autoconf 2.59.  Invocation command line was
12972
12973   CONFIG_FILES    = $CONFIG_FILES
12974   CONFIG_HEADERS  = $CONFIG_HEADERS
12975   CONFIG_LINKS    = $CONFIG_LINKS
12976   CONFIG_COMMANDS = $CONFIG_COMMANDS
12977   $ $0 $@
12978
12979 _CSEOF
12980 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12981 echo >&5
12982 _ACEOF
12983
12984 # Files that config.status was made for.
12985 if test -n "$ac_config_files"; then
12986   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12987 fi
12988
12989 if test -n "$ac_config_headers"; then
12990   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12991 fi
12992
12993 if test -n "$ac_config_links"; then
12994   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12995 fi
12996
12997 if test -n "$ac_config_commands"; then
12998   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12999 fi
13000
13001 cat >>$CONFIG_STATUS <<\_ACEOF
13002
13003 ac_cs_usage="\
13004 \`$as_me' instantiates files from templates according to the
13005 current configuration.
13006
13007 Usage: $0 [OPTIONS] [FILE]...
13008
13009   -h, --help       print this help, then exit
13010   -V, --version    print version number, then exit
13011   -q, --quiet      do not print progress messages
13012   -d, --debug      don't remove temporary files
13013       --recheck    update $as_me by reconfiguring in the same conditions
13014   --file=FILE[:TEMPLATE]
13015                    instantiate the configuration file FILE
13016
13017 Configuration files:
13018 $config_files
13019
13020 Report bugs to <bug-autoconf@gnu.org>."
13021 _ACEOF
13022
13023 cat >>$CONFIG_STATUS <<_ACEOF
13024 ac_cs_version="\\
13025 config.status
13026 configured by $0, generated by GNU Autoconf 2.59,
13027   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13028
13029 Copyright (C) 2003 Free Software Foundation, Inc.
13030 This config.status script is free software; the Free Software Foundation
13031 gives unlimited permission to copy, distribute and modify it."
13032 srcdir=$srcdir
13033 INSTALL="$INSTALL"
13034 _ACEOF
13035
13036 cat >>$CONFIG_STATUS <<\_ACEOF
13037 # If no file are specified by the user, then we need to provide default
13038 # value.  By we need to know if files were specified by the user.
13039 ac_need_defaults=:
13040 while test $# != 0
13041 do
13042   case $1 in
13043   --*=*)
13044     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13045     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13046     ac_shift=:
13047     ;;
13048   -*)
13049     ac_option=$1
13050     ac_optarg=$2
13051     ac_shift=shift
13052     ;;
13053   *) # This is not an option, so the user has probably given explicit
13054      # arguments.
13055      ac_option=$1
13056      ac_need_defaults=false;;
13057   esac
13058
13059   case $ac_option in
13060   # Handling of the options.
13061 _ACEOF
13062 cat >>$CONFIG_STATUS <<\_ACEOF
13063   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13064     ac_cs_recheck=: ;;
13065   --version | --vers* | -V )
13066     echo "$ac_cs_version"; exit 0 ;;
13067   --he | --h)
13068     # Conflict between --help and --header
13069     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13070 Try \`$0 --help' for more information." >&5
13071 echo "$as_me: error: ambiguous option: $1
13072 Try \`$0 --help' for more information." >&2;}
13073    { (exit 1); exit 1; }; };;
13074   --help | --hel | -h )
13075     echo "$ac_cs_usage"; exit 0 ;;
13076   --debug | --d* | -d )
13077     debug=: ;;
13078   --file | --fil | --fi | --f )
13079     $ac_shift
13080     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13081     ac_need_defaults=false;;
13082   --header | --heade | --head | --hea )
13083     $ac_shift
13084     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13085     ac_need_defaults=false;;
13086   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13087   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13088     ac_cs_silent=: ;;
13089
13090   # This is an error.
13091   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13092 Try \`$0 --help' for more information." >&5
13093 echo "$as_me: error: unrecognized option: $1
13094 Try \`$0 --help' for more information." >&2;}
13095    { (exit 1); exit 1; }; } ;;
13096
13097   *) ac_config_targets="$ac_config_targets $1" ;;
13098
13099   esac
13100   shift
13101 done
13102
13103 ac_configure_extra_args=
13104
13105 if $ac_cs_silent; then
13106   exec 6>/dev/null
13107   ac_configure_extra_args="$ac_configure_extra_args --silent"
13108 fi
13109
13110 _ACEOF
13111 cat >>$CONFIG_STATUS <<_ACEOF
13112 if \$ac_cs_recheck; then
13113   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13114   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13115 fi
13116
13117 _ACEOF
13118
13119
13120
13121
13122
13123 cat >>$CONFIG_STATUS <<\_ACEOF
13124 for ac_config_target in $ac_config_targets
13125 do
13126   case "$ac_config_target" in
13127   # Handling of arguments.
13128   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13129   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13130 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13131    { (exit 1); exit 1; }; };;
13132   esac
13133 done
13134
13135 # If the user did not use the arguments to specify the items to instantiate,
13136 # then the envvar interface is used.  Set only those that are not.
13137 # We use the long form for the default assignment because of an extremely
13138 # bizarre bug on SunOS 4.1.3.
13139 if $ac_need_defaults; then
13140   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13141 fi
13142
13143 # Have a temporary directory for convenience.  Make it in the build tree
13144 # simply because there is no reason to put it here, and in addition,
13145 # creating and moving files from /tmp can sometimes cause problems.
13146 # Create a temporary directory, and hook for its removal unless debugging.
13147 $debug ||
13148 {
13149   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13150   trap '{ (exit 1); exit 1; }' 1 2 13 15
13151 }
13152
13153 # Create a (secure) tmp directory for tmp files.
13154
13155 {
13156   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13157   test -n "$tmp" && test -d "$tmp"
13158 }  ||
13159 {
13160   tmp=./confstat$$-$RANDOM
13161   (umask 077 && mkdir $tmp)
13162 } ||
13163 {
13164    echo "$me: cannot create a temporary directory in ." >&2
13165    { (exit 1); exit 1; }
13166 }
13167
13168 _ACEOF
13169
13170 cat >>$CONFIG_STATUS <<_ACEOF
13171
13172 #
13173 # CONFIG_FILES section.
13174 #
13175
13176 # No need to generate the scripts if there are no CONFIG_FILES.
13177 # This happens for instance when ./config.status config.h
13178 if test -n "\$CONFIG_FILES"; then
13179   # Protect against being on the right side of a sed subst in config.status.
13180   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13181    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13182 s,@SHELL@,$SHELL,;t t
13183 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13184 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13185 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13186 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13187 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13188 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13189 s,@exec_prefix@,$exec_prefix,;t t
13190 s,@prefix@,$prefix,;t t
13191 s,@program_transform_name@,$program_transform_name,;t t
13192 s,@bindir@,$bindir,;t t
13193 s,@sbindir@,$sbindir,;t t
13194 s,@libexecdir@,$libexecdir,;t t
13195 s,@datadir@,$datadir,;t t
13196 s,@sysconfdir@,$sysconfdir,;t t
13197 s,@sharedstatedir@,$sharedstatedir,;t t
13198 s,@localstatedir@,$localstatedir,;t t
13199 s,@libdir@,$libdir,;t t
13200 s,@includedir@,$includedir,;t t
13201 s,@oldincludedir@,$oldincludedir,;t t
13202 s,@infodir@,$infodir,;t t
13203 s,@mandir@,$mandir,;t t
13204 s,@build_alias@,$build_alias,;t t
13205 s,@host_alias@,$host_alias,;t t
13206 s,@target_alias@,$target_alias,;t t
13207 s,@DEFS@,$DEFS,;t t
13208 s,@ECHO_C@,$ECHO_C,;t t
13209 s,@ECHO_N@,$ECHO_N,;t t
13210 s,@ECHO_T@,$ECHO_T,;t t
13211 s,@LIBS@,$LIBS,;t t
13212 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13213 s,@build@,$build,;t t
13214 s,@build_cpu@,$build_cpu,;t t
13215 s,@build_vendor@,$build_vendor,;t t
13216 s,@build_os@,$build_os,;t t
13217 s,@build_noncanonical@,$build_noncanonical,;t t
13218 s,@host_noncanonical@,$host_noncanonical,;t t
13219 s,@target_noncanonical@,$target_noncanonical,;t t
13220 s,@host@,$host,;t t
13221 s,@host_cpu@,$host_cpu,;t t
13222 s,@host_vendor@,$host_vendor,;t t
13223 s,@host_os@,$host_os,;t t
13224 s,@target@,$target,;t t
13225 s,@target_cpu@,$target_cpu,;t t
13226 s,@target_vendor@,$target_vendor,;t t
13227 s,@target_os@,$target_os,;t t
13228 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13229 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13230 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13231 s,@LN@,$LN,;t t
13232 s,@LN_S@,$LN_S,;t t
13233 s,@build_libsubdir@,$build_libsubdir,;t t
13234 s,@build_subdir@,$build_subdir,;t t
13235 s,@host_subdir@,$host_subdir,;t t
13236 s,@target_subdir@,$target_subdir,;t t
13237 s,@CC@,$CC,;t t
13238 s,@CFLAGS@,$CFLAGS,;t t
13239 s,@LDFLAGS@,$LDFLAGS,;t t
13240 s,@CPPFLAGS@,$CPPFLAGS,;t t
13241 s,@ac_ct_CC@,$ac_ct_CC,;t t
13242 s,@EXEEXT@,$EXEEXT,;t t
13243 s,@OBJEXT@,$OBJEXT,;t t
13244 s,@CXX@,$CXX,;t t
13245 s,@CXXFLAGS@,$CXXFLAGS,;t t
13246 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13247 s,@GNATBIND@,$GNATBIND,;t t
13248 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13249 s,@GNATMAKE@,$GNATMAKE,;t t
13250 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13251 s,@do_compare@,$do_compare,;t t
13252 s,@gmplibs@,$gmplibs,;t t
13253 s,@gmpinc@,$gmpinc,;t t
13254 s,@ppllibs@,$ppllibs,;t t
13255 s,@pplinc@,$pplinc,;t t
13256 s,@clooglibs@,$clooglibs,;t t
13257 s,@clooginc@,$clooginc,;t t
13258 s,@stage1_languages@,$stage1_languages,;t t
13259 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13260 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13261 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13262 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13263 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13264 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13265 s,@tooldir@,$tooldir,;t t
13266 s,@build_tooldir@,$build_tooldir,;t t
13267 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13268 s,@GDB_TK@,$GDB_TK,;t t
13269 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13270 s,@build_configargs@,$build_configargs,;t t
13271 s,@build_configdirs@,$build_configdirs,;t t
13272 s,@host_configargs@,$host_configargs,;t t
13273 s,@configdirs@,$configdirs,;t t
13274 s,@target_configargs@,$target_configargs,;t t
13275 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13276 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13277 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13278 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13279 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13280 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13281 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13282 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13283 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13284 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13285 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13286 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13287 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13288 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13289 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13290 s,@config_shell@,$config_shell,;t t
13291 s,@YACC@,$YACC,;t t
13292 s,@BISON@,$BISON,;t t
13293 s,@M4@,$M4,;t t
13294 s,@LEX@,$LEX,;t t
13295 s,@FLEX@,$FLEX,;t t
13296 s,@MAKEINFO@,$MAKEINFO,;t t
13297 s,@EXPECT@,$EXPECT,;t t
13298 s,@RUNTEST@,$RUNTEST,;t t
13299 s,@AR@,$AR,;t t
13300 s,@AS@,$AS,;t t
13301 s,@DLLTOOL@,$DLLTOOL,;t t
13302 s,@LD@,$LD,;t t
13303 s,@LIPO@,$LIPO,;t t
13304 s,@NM@,$NM,;t t
13305 s,@RANLIB@,$RANLIB,;t t
13306 s,@STRIP@,$STRIP,;t t
13307 s,@WINDRES@,$WINDRES,;t t
13308 s,@WINDMC@,$WINDMC,;t t
13309 s,@OBJCOPY@,$OBJCOPY,;t t
13310 s,@OBJDUMP@,$OBJDUMP,;t t
13311 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13312 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13313 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13314 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13315 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13316 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13317 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13318 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13319 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13320 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13321 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13322 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13323 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13324 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13325 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13326 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13327 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13328 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13329 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13330 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13331 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13332 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13333 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13334 s,@MAINT@,$MAINT,;t t
13335 s,@stage1_cflags@,$stage1_cflags,;t t
13336 s,@stage1_checking@,$stage1_checking,;t t
13337 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13338 s,@datarootdir@,$datarootdir,;t t
13339 s,@docdir@,$docdir,;t t
13340 s,@pdfdir@,$pdfdir,;t t
13341 s,@htmldir@,$htmldir,;t t
13342 s,@LIBOBJS@,$LIBOBJS,;t t
13343 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13344 /@serialization_dependencies@/r $serialization_dependencies
13345 s,@serialization_dependencies@,,;t t
13346 /@host_makefile_frag@/r $host_makefile_frag
13347 s,@host_makefile_frag@,,;t t
13348 /@target_makefile_frag@/r $target_makefile_frag
13349 s,@target_makefile_frag@,,;t t
13350 /@alphaieee_frag@/r $alphaieee_frag
13351 s,@alphaieee_frag@,,;t t
13352 /@ospace_frag@/r $ospace_frag
13353 s,@ospace_frag@,,;t t
13354 CEOF
13355
13356 _ACEOF
13357
13358   cat >>$CONFIG_STATUS <<\_ACEOF
13359   # Split the substitutions into bite-sized pieces for seds with
13360   # small command number limits, like on Digital OSF/1 and HP-UX.
13361   ac_max_sed_lines=48
13362   ac_sed_frag=1 # Number of current file.
13363   ac_beg=1 # First line for current file.
13364   ac_end=$ac_max_sed_lines # Line after last line for current file.
13365   ac_more_lines=:
13366   ac_sed_cmds=
13367   while $ac_more_lines; do
13368     if test $ac_beg -gt 1; then
13369       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13370     else
13371       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13372     fi
13373     if test ! -s $tmp/subs.frag; then
13374       ac_more_lines=false
13375     else
13376       # The purpose of the label and of the branching condition is to
13377       # speed up the sed processing (if there are no `@' at all, there
13378       # is no need to browse any of the substitutions).
13379       # These are the two extra sed commands mentioned above.
13380       (echo ':t
13381   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13382       if test -z "$ac_sed_cmds"; then
13383         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13384       else
13385         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13386       fi
13387       ac_sed_frag=`expr $ac_sed_frag + 1`
13388       ac_beg=$ac_end
13389       ac_end=`expr $ac_end + $ac_max_sed_lines`
13390     fi
13391   done
13392   if test -z "$ac_sed_cmds"; then
13393     ac_sed_cmds=cat
13394   fi
13395 fi # test -n "$CONFIG_FILES"
13396
13397 _ACEOF
13398 cat >>$CONFIG_STATUS <<\_ACEOF
13399 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13400   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13401   case $ac_file in
13402   - | *:- | *:-:* ) # input from stdin
13403         cat >$tmp/stdin
13404         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13405         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13406   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13407         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13408   * )   ac_file_in=$ac_file.in ;;
13409   esac
13410
13411   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13412   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13413 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13414          X"$ac_file" : 'X\(//\)[^/]' \| \
13415          X"$ac_file" : 'X\(//\)$' \| \
13416          X"$ac_file" : 'X\(/\)' \| \
13417          .     : '\(.\)' 2>/dev/null ||
13418 echo X"$ac_file" |
13419     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13420           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13421           /^X\(\/\/\)$/{ s//\1/; q; }
13422           /^X\(\/\).*/{ s//\1/; q; }
13423           s/.*/./; q'`
13424   { if $as_mkdir_p; then
13425     mkdir -p "$ac_dir"
13426   else
13427     as_dir="$ac_dir"
13428     as_dirs=
13429     while test ! -d "$as_dir"; do
13430       as_dirs="$as_dir $as_dirs"
13431       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13432 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13433          X"$as_dir" : 'X\(//\)[^/]' \| \
13434          X"$as_dir" : 'X\(//\)$' \| \
13435          X"$as_dir" : 'X\(/\)' \| \
13436          .     : '\(.\)' 2>/dev/null ||
13437 echo X"$as_dir" |
13438     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13439           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13440           /^X\(\/\/\)$/{ s//\1/; q; }
13441           /^X\(\/\).*/{ s//\1/; q; }
13442           s/.*/./; q'`
13443     done
13444     test ! -n "$as_dirs" || mkdir $as_dirs
13445   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13446 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13447    { (exit 1); exit 1; }; }; }
13448
13449   ac_builddir=.
13450
13451 if test "$ac_dir" != .; then
13452   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13453   # A "../" for each directory in $ac_dir_suffix.
13454   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13455 else
13456   ac_dir_suffix= ac_top_builddir=
13457 fi
13458
13459 case $srcdir in
13460   .)  # No --srcdir option.  We are building in place.
13461     ac_srcdir=.
13462     if test -z "$ac_top_builddir"; then
13463        ac_top_srcdir=.
13464     else
13465        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13466     fi ;;
13467   [\\/]* | ?:[\\/]* )  # Absolute path.
13468     ac_srcdir=$srcdir$ac_dir_suffix;
13469     ac_top_srcdir=$srcdir ;;
13470   *) # Relative path.
13471     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13472     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13473 esac
13474
13475 # Do not use `cd foo && pwd` to compute absolute paths, because
13476 # the directories may not exist.
13477 case `pwd` in
13478 .) ac_abs_builddir="$ac_dir";;
13479 *)
13480   case "$ac_dir" in
13481   .) ac_abs_builddir=`pwd`;;
13482   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13483   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13484   esac;;
13485 esac
13486 case $ac_abs_builddir in
13487 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13488 *)
13489   case ${ac_top_builddir}. in
13490   .) ac_abs_top_builddir=$ac_abs_builddir;;
13491   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13492   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13493   esac;;
13494 esac
13495 case $ac_abs_builddir in
13496 .) ac_abs_srcdir=$ac_srcdir;;
13497 *)
13498   case $ac_srcdir in
13499   .) ac_abs_srcdir=$ac_abs_builddir;;
13500   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13501   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13502   esac;;
13503 esac
13504 case $ac_abs_builddir in
13505 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13506 *)
13507   case $ac_top_srcdir in
13508   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13509   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13510   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13511   esac;;
13512 esac
13513
13514
13515   case $INSTALL in
13516   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13517   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13518   esac
13519
13520   if test x"$ac_file" != x-; then
13521     { echo "$as_me:$LINENO: creating $ac_file" >&5
13522 echo "$as_me: creating $ac_file" >&6;}
13523     rm -f "$ac_file"
13524   fi
13525   # Let's still pretend it is `configure' which instantiates (i.e., don't
13526   # use $as_me), people would be surprised to read:
13527   #    /* config.h.  Generated by config.status.  */
13528   if test x"$ac_file" = x-; then
13529     configure_input=
13530   else
13531     configure_input="$ac_file.  "
13532   fi
13533   configure_input=$configure_input"Generated from `echo $ac_file_in |
13534                                      sed 's,.*/,,'` by configure."
13535
13536   # First look for the input files in the build tree, otherwise in the
13537   # src tree.
13538   ac_file_inputs=`IFS=:
13539     for f in $ac_file_in; do
13540       case $f in
13541       -) echo $tmp/stdin ;;
13542       [\\/$]*)
13543          # Absolute (can't be DOS-style, as IFS=:)
13544          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13545 echo "$as_me: error: cannot find input file: $f" >&2;}
13546    { (exit 1); exit 1; }; }
13547          echo "$f";;
13548       *) # Relative
13549          if test -f "$f"; then
13550            # Build tree
13551            echo "$f"
13552          elif test -f "$srcdir/$f"; then
13553            # Source tree
13554            echo "$srcdir/$f"
13555          else
13556            # /dev/null tree
13557            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13558 echo "$as_me: error: cannot find input file: $f" >&2;}
13559    { (exit 1); exit 1; }; }
13560          fi;;
13561       esac
13562     done` || { (exit 1); exit 1; }
13563 _ACEOF
13564 cat >>$CONFIG_STATUS <<_ACEOF
13565   sed "$ac_vpsub
13566 $extrasub
13567 _ACEOF
13568 cat >>$CONFIG_STATUS <<\_ACEOF
13569 :t
13570 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13571 s,@configure_input@,$configure_input,;t t
13572 s,@srcdir@,$ac_srcdir,;t t
13573 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13574 s,@top_srcdir@,$ac_top_srcdir,;t t
13575 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13576 s,@builddir@,$ac_builddir,;t t
13577 s,@abs_builddir@,$ac_abs_builddir,;t t
13578 s,@top_builddir@,$ac_top_builddir,;t t
13579 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13580 s,@INSTALL@,$ac_INSTALL,;t t
13581 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13582   rm -f $tmp/stdin
13583   if test x"$ac_file" != x-; then
13584     mv $tmp/out $ac_file
13585   else
13586     cat $tmp/out
13587     rm -f $tmp/out
13588   fi
13589
13590 done
13591 _ACEOF
13592
13593 cat >>$CONFIG_STATUS <<\_ACEOF
13594
13595 { (exit 0); exit 0; }
13596 _ACEOF
13597 chmod +x $CONFIG_STATUS
13598 ac_clean_files=$ac_clean_files_save
13599
13600
13601 # configure is writing to config.log, and then calls config.status.
13602 # config.status does its own redirection, appending to config.log.
13603 # Unfortunately, on DOS this fails, as config.log is still kept open
13604 # by configure, so config.status won't be able to write to it; its
13605 # output is simply discarded.  So we exec the FD to /dev/null,
13606 # effectively closing config.log, so it can be properly (re)opened and
13607 # appended to by config.status.  When coming back to configure, we
13608 # need to make the FD available again.
13609 if test "$no_create" != yes; then
13610   ac_cs_success=:
13611   ac_config_status_args=
13612   test "$silent" = yes &&
13613     ac_config_status_args="$ac_config_status_args --quiet"
13614   exec 5>/dev/null
13615   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13616   exec 5>>config.log
13617   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13618   # would make configure fail if this is the last instruction.
13619   $ac_cs_success || { (exit 1); exit 1; }
13620 fi
13621