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 cgen 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* | *-*-nto*)
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*-*-* | arm*-*-*)
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*)
2219     noconfigdirs="$noconfigdirs ld gprof"
2220     noconfigdirs="$noconfigdirs sim target-rda"
2221     ;;
2222   x86_64-*-darwin9*)
2223     noconfigdirs="$noconfigdirs ld gas gprof"
2224     noconfigdirs="$noconfigdirs sim target-rda"
2225     ;;
2226   *-*-darwin*)
2227     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2228     noconfigdirs="$noconfigdirs sim target-rda"
2229     noconfigdirs="$noconfigdirs ${libgcj}"
2230     ;;
2231   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2232     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2233     ;;
2234   *-*-freebsd*)
2235     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2236     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2237         && test -f /usr/local/include/gmp.h; then
2238       with_gmp=/usr/local
2239     fi
2240
2241     # Skip some stuff that's unsupported on some FreeBSD configurations.
2242     case "${target}" in
2243       i*86-*-*) ;;
2244       alpha*-*-*) ;;
2245       *)
2246         noconfigdirs="$noconfigdirs ${libgcj}"
2247         ;;
2248     esac
2249     ;;
2250   *-*-kaos*)
2251     # Remove unsupported stuff on all kaOS configurations.
2252     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2253     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2254     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2255     noconfigdirs="$noconfigdirs target-libgloss"
2256     ;;
2257   *-*-netbsd*)
2258     # Skip some stuff on all NetBSD configurations.
2259     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2260
2261     # Skip some stuff that's unsupported on some NetBSD configurations.
2262     case "${target}" in
2263       i*86-*-netbsdelf*) ;;
2264       arm*-*-netbsdelf*) ;;
2265       *)
2266         noconfigdirs="$noconfigdirs ${libgcj}"
2267         ;;
2268     esac
2269     ;;
2270   *-*-netware*)
2271     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2272     ;;
2273   *-*-rtems*)
2274     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2275     ;;
2276     # The tpf target doesn't support gdb yet.
2277   *-*-tpf*)
2278     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2279     ;;
2280   *-*-uclinux*)
2281     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2282     ;;
2283   *-*-vxworks*)
2284     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2285     ;;
2286   alpha*-dec-osf*)
2287     # ld works, but does not support shared libraries.
2288     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2289     # gas doesn't generate exception information.
2290     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2291     ;;
2292   alpha*-*-*vms*)
2293     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2294     ;;
2295   alpha*-*-linux*)
2296     # newlib is not 64 bit ready
2297     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2298     ;;
2299   alpha*-*-*)
2300     # newlib is not 64 bit ready
2301     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2302     ;;
2303   am33_2.0-*-linux*)
2304     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2305     ;;
2306   sh-*-linux*)
2307     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2308     ;;
2309   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2310     noconfigdirs="$noconfigdirs ${libgcj}"
2311     noconfigdirs="$noconfigdirs target-examples"
2312     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2313     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2314     noconfigdirs="$noconfigdirs expect dejagnu"
2315     # the C++ libraries don't build on top of CE's C libraries
2316     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2317     noconfigdirs="$noconfigdirs target-newlib"
2318     case "${host}" in
2319       *-*-cygwin*) ;; # keep gdb and readline
2320       *) noconfigdirs="$noconfigdirs gdb readline"
2321          ;;
2322     esac
2323     libgloss_dir=wince
2324     ;;
2325   arc-*-*)
2326     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2327     ;;
2328   arm-semi-aof )
2329     ;;
2330   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2331     noconfigdirs="$noconfigdirs ${libgcj}"
2332     libgloss_dir=arm
2333     ;;
2334   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2335     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2336     libgloss_dir=arm
2337     ;;
2338   arm*-*-linux-gnueabi)
2339     noconfigdirs="$noconfigdirs target-qthreads"
2340     case ${with_newlib} in
2341       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2342     esac
2343     libgloss_dir=arm
2344     ;;
2345   arm*-*-symbianelf*)
2346     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2347     libgloss_dir=arm
2348     ;;
2349   arm-*-pe*)
2350     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2351     ;;
2352   thumb-*-coff)
2353     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2354     ;;
2355   thumb-*-elf)
2356     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2357     ;;
2358   thumb-*-pe)
2359     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2360     ;;
2361   arm-*-riscix*)
2362     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2363     ;;
2364   avr-*-*)
2365     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2366     ;;
2367   bfin-*-*)
2368     noconfigdirs="$noconfigdirs gdb"
2369     if test x${is_cross_compiler} != xno ; then
2370       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2371     fi
2372     ;;
2373   c4x-*-* | tic4x-*-*)
2374     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2375     ;;
2376   c54x*-*-* | tic54x-*-*)
2377     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2378     ;;
2379   cr16-*-*)
2380     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2381     ;;
2382   cris-*-* | crisv32-*-*)
2383     unsupported_languages="$unsupported_languages java"
2384     case "${target}" in
2385       *-*-aout)
2386         unsupported_languages="$unsupported_languages fortran"
2387         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2388       *-*-elf)
2389         noconfigdirs="$noconfigdirs target-boehm-gc";;
2390       *-*-linux*)
2391         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2392       *)
2393         unsupported_languages="$unsupported_languages fortran"
2394         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2395     esac
2396     libgloss_dir=cris
2397     ;;
2398   crx-*-*)
2399     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2400     ;;
2401   d10v-*-*)
2402     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2403     ;;
2404   d30v-*-*)
2405     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2406     ;;
2407   ep9312-*-elf | ep9312-*-coff)
2408     libgloss_dir=arm
2409     ;;
2410   fr30-*-elf*)
2411     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2412     ;;
2413   frv-*-*)
2414     noconfigdirs="$noconfigdirs ${libgcj}"
2415     ;;
2416   moxie-*-*)
2417     noconfigdirs="$noconfigdirs ${libgcj}"
2418     noconfigdirs="$noconfigdirs gprof"
2419     ;;
2420   h8300*-*-*)
2421     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2422     ;;
2423   h8500-*-*)
2424     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2425     ;;
2426   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2427     ;;
2428   hppa*64*-*-linux* | parisc*64*-*-linux*)
2429     # In this case, it's because the hppa64-linux target is for
2430     # the kernel only at this point and has no libc, and thus no
2431     # headers, crt*.o, etc., all of which are needed by these.
2432     noconfigdirs="$noconfigdirs target-zlib"
2433     ;;
2434   parisc*-*-linux* | hppa*-*-linux*)
2435     ;;
2436   hppa*-*-*elf* | \
2437   hppa*-*-lites* | \
2438   hppa*-*-openbsd* | \
2439   hppa*64*-*-*)
2440     noconfigdirs="$noconfigdirs ${libgcj}"
2441     ;;
2442   hppa*-hp-hpux11*)
2443     noconfigdirs="$noconfigdirs ld shellutils"
2444     ;;
2445   hppa*-*-pro*)
2446     libgloss_dir=pa
2447     ;;
2448   hppa*-*-*)
2449     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2450     # build on HP-UX 10.20.
2451     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2452     ;;
2453   i960-*-*)
2454     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2455     ;;
2456   ia64*-*-elf*)
2457     # No gdb support yet.
2458     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2459     ;;
2460   ia64*-**-hpux*)
2461     # No gdb or ld support yet.
2462     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2463     ;;
2464   ia64*-*-*vms*)
2465     # No gdb or ld support yet.
2466     noconfigdirs="$noconfigdirs ${libgcj} tix readline mmalloc libgui itcl gdb ld"
2467     ;;
2468   i370-*-opened*)
2469     ;;
2470   i[3456789]86-*-coff | i[3456789]86-*-elf)
2471     noconfigdirs="$noconfigdirs ${libgcj}"
2472     libgloss_dir=i386
2473     ;;
2474   i[3456789]86-*-linux*)
2475     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2476     # not build java stuff by default.
2477     case "${target}" in
2478       *-*-*libc1*)
2479         noconfigdirs="$noconfigdirs ${libgcj}";;
2480     esac
2481
2482     # This section makes it possible to build newlib natively on linux.
2483     # If we are using a cross compiler then don't configure newlib.
2484     if test x${is_cross_compiler} != xno ; then
2485       noconfigdirs="$noconfigdirs target-newlib"
2486     fi
2487     noconfigdirs="$noconfigdirs target-libgloss"
2488     # If we are not using a cross compiler, do configure newlib.
2489     # Note however, that newlib will only be configured in this situation
2490     # if the --with-newlib option has been given, because otherwise
2491     # 'target-newlib' will appear in skipdirs.
2492     ;;
2493   i[3456789]86-*-mingw32*)
2494     target_configdirs="$target_configdirs target-winsup"
2495     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2496     ;;
2497   x86_64-*-mingw*)
2498     target_configdirs="$target_configdirs target-winsup"
2499     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2500     ;;
2501   *-*-cygwin*)
2502     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2503     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2504     # always build newlib if winsup directory is present.
2505     if test -d "$srcdir/winsup/cygwin"; then
2506       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2507     elif test -d "$srcdir/newlib"; then
2508       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2509     fi
2510     ;;
2511   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2512   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2513     ;;
2514   i[3456789]86-*-pe)
2515     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2516     ;;
2517   i[3456789]86-*-sco3.2v5*)
2518     # The linker does not yet know about weak symbols in COFF,
2519     # and is not configured to handle mixed ELF and COFF.
2520     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2521     ;;
2522   i[3456789]86-*-sco*)
2523     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2524     ;;
2525   i[3456789]86-*-solaris2*)
2526     noconfigdirs="$noconfigdirs target-libgloss"
2527     ;;
2528   i[3456789]86-*-sysv4*)
2529     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2530     ;;
2531   i[3456789]86-*-beos*)
2532     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2533     ;;
2534   i[3456789]86-*-rdos*)
2535     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2536     ;;
2537   m32r-*-*)
2538     noconfigdirs="$noconfigdirs ${libgcj}"
2539     ;;
2540   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2541     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2542     libgloss_dir=m68hc11
2543     ;;
2544   m68k-*-elf*)
2545     noconfigdirs="$noconfigdirs ${libgcj}"
2546     ;;
2547   m68k-*-coff*)
2548     noconfigdirs="$noconfigdirs ${libgcj}"
2549     ;;
2550   m68*-*-* | fido-*-*)
2551     libgloss_dir=m68k
2552     ;;
2553   mcore-*-pe*)
2554   # The EPOC C++ environment does not support exceptions or rtti,
2555   # and so building libstdc++-v3 tends not to always work.
2556     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2557     ;;
2558   mmix-*-*)
2559     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2560     unsupported_languages="$unsupported_languages fortran java"
2561     ;;
2562   mn10200-*-*)
2563     noconfigdirs="$noconfigdirs ${libgcj}"
2564     ;;
2565   mn10300-*-*)
2566     noconfigdirs="$noconfigdirs ${libgcj}"
2567     ;;
2568   mt-*-*)
2569     noconfigdirs="$noconfigdirs sim"
2570     ;;
2571   powerpc-*-aix*)
2572     # copied from rs6000-*-* entry
2573     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2574     ;;
2575   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2576     target_configdirs="$target_configdirs target-winsup"
2577     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2578     # always build newlib.
2579     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2580     ;;
2581     # This is temporary until we can link against shared libraries
2582   powerpcle-*-solaris*)
2583     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2584     libgloss_dir=rs6000
2585     ;;
2586   powerpc-*-beos*)
2587     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2588     ;;
2589   powerpc-*-eabi)
2590     noconfigdirs="$noconfigdirs ${libgcj}"
2591     libgloss_dir=rs6000
2592     ;;
2593   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2594     libgloss_dir=rs6000
2595     ;;
2596   rs6000-*-lynxos*)
2597     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2598     ;;
2599   rs6000-*-aix*)
2600     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2601     ;;
2602   rs6000-*-*)
2603     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2604     ;;
2605   m68k-apollo-*)
2606     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2607     ;;
2608   mips*-sde-elf*)
2609     skipdirs="$skipdirs target-libiberty"
2610     noconfigdirs="$noconfigdirs ${libgcj}"
2611     if test x$with_newlib = xyes; then
2612       noconfigdirs="$noconfigdirs gprof"
2613     fi
2614     libgloss_dir=mips
2615     ;;
2616   mips*-*-irix5*)
2617     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2618     ;;
2619   mips*-*-irix6*)
2620     # Linking libjava exceeds command-line length limits on at least
2621     # IRIX 6.2, but not on IRIX 6.5.
2622     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2623     # <oldham@codesourcery.com>
2624     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2625     ;;
2626   mips*-*-bsd*)
2627     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2628     ;;
2629   mips*-*-linux*)
2630     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2631     ;;
2632   mips*-*-*)
2633     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2634     libgloss_dir=mips
2635     ;;
2636   romp-*-*)
2637     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2638     ;;
2639   sh-*-* | sh64-*-*)
2640     case "${host}" in
2641       i[3456789]86-*-vsta) ;; # don't add gprof back in
2642       i[3456789]86-*-go32*) ;; # don't add gprof back in
2643       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2644       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2645     esac
2646     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2647     ;;
2648   sparclet-*-aout* | sparc86x-*-*)
2649     libgloss_dir=sparc
2650     ;;
2651   sparc-*-elf*)
2652     noconfigdirs="$noconfigdirs ${libgcj}"
2653     ;;
2654   sparc64-*-elf*)
2655     noconfigdirs="$noconfigdirs ${libgcj}"
2656     libgloss_dir=sparc
2657     ;;
2658   sparclite-*-*)
2659     noconfigdirs="$noconfigdirs ${libgcj}"
2660     libgloss_dir=sparc
2661     ;;
2662   sparc-*-sunos4*)
2663     noconfigdirs="$noconfigdirs ${libgcj}"
2664     if test x${is_cross_compiler} != xno ; then
2665            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2666     else
2667            use_gnu_ld=no
2668     fi
2669     ;;
2670   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2671     noconfigdirs="$noconfigdirs ${libgcj}"
2672     ;;
2673   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2674     ;;
2675   v810-*-*)
2676     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2677     ;;
2678   v850-*-*)
2679     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2680     ;;
2681   v850e-*-*)
2682     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2683     ;;
2684   v850ea-*-*)
2685     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2686     ;;
2687   vax-*-vms)
2688     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2689     ;;
2690   vax-*-*)
2691     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2692     ;;
2693   xtensa*-*-*)
2694     noconfigdirs="$noconfigdirs ${libgcj}"
2695     ;;
2696   ip2k-*-*)
2697     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2698     ;;
2699   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2700     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2701     ;;
2702   *-*-lynxos*)
2703     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2704     ;;
2705   *-*-*)
2706     noconfigdirs="$noconfigdirs ${libgcj}"
2707     ;;
2708 esac
2709
2710 # If we aren't building newlib, then don't build libgloss, since libgloss
2711 # depends upon some newlib header files.
2712 case "${noconfigdirs}" in
2713   *target-libgloss*) ;;
2714   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2715 esac
2716
2717 # Work in distributions that contain no compiler tools, like Autoconf.
2718 tentative_cc=""
2719 host_makefile_frag=/dev/null
2720 if test -d ${srcdir}/config ; then
2721 case "${host}" in
2722   m68k-hp-hpux*)
2723     # Avoid "too much defining" errors from HPUX compiler.
2724     tentative_cc="cc -Wp,-H256000"
2725     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2726     # If it's HP/UX ar, this should be harmless.
2727     RANLIB="ar ts"
2728     ;;
2729   m68k-apollo-sysv*)
2730     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2731     ;;
2732   m68k-apollo-bsd*)
2733     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2734     # chokes on bfd, the compiler won't let you assign integers to enums, and
2735     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2736     # the apollo compiler" (the preferred version of GCC could be called cc,
2737     # or whatever), but I'm not sure leaving CC as cc is any better...
2738     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2739     # Used to have BISON=yacc.
2740     tentative_cc=gcc
2741     ;;
2742   m88k-dg-dgux*)
2743     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2744     ;;
2745   m88k-harris-cxux*)
2746     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2747     tentative_cc="cc -Xa"
2748     host_makefile_frag="config/mh-cxux"
2749     ;;
2750   m88k-motorola-sysv*)
2751     ;;
2752   mips*-dec-ultrix*)
2753     tentative_cc="cc -Wf,-XNg1000"
2754     host_makefile_frag="config/mh-decstation"
2755     ;;
2756   mips*-nec-sysv4*)
2757     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2758     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2759     host_makefile_frag="config/mh-necv4"
2760     ;;
2761   mips*-sgi-irix4*)
2762     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2763     # environment.  Also bump switch table size so that cp-parse will
2764     # compile.  Bump string length limit so linker builds.
2765     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2766     ;;
2767   mips*-*-sysv4*)
2768     host_makefile_frag="config/mh-sysv4"
2769     ;;
2770   mips*-*-sysv*)
2771     # This is for a MIPS running RISC/os 4.52C.
2772
2773     # This is needed for GDB, but needs to be in the top-level make because
2774     # if a library is compiled with the bsd headers and gets linked with the
2775     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2776     # a different size).
2777     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2778     # known except to select the sysv environment.  Could we use /proc instead?
2779     # These "sysv environments" and "bsd environments" often end up being a pain.
2780     #
2781     # This is not part of CFLAGS because perhaps not all C compilers have this
2782     # option.
2783     tentative_cc="cc -systype sysv"
2784     ;;
2785   i370-ibm-opened*)
2786     tentative_cc="c89"
2787     ;;
2788   i[3456789]86-*-sysv5*)
2789     host_makefile_frag="config/mh-sysv5"
2790     ;;
2791   i[3456789]86-*-dgux*)
2792     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2793     host_makefile_frag="config/mh-dgux386"
2794     ;;
2795   i[3456789]86-ncr-sysv4.3*)
2796     # The MetaWare compiler will generate a copyright message unless you
2797     # turn it off by adding the -Hnocopyr flag.
2798     tentative_cc="cc -Hnocopyr"
2799     ;;
2800   i[3456789]86-ncr-sysv4*)
2801     # for an NCR 3000 (i486/SVR4) system.
2802     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2803     # This compiler not only emits obnoxious copyright messages every time
2804     # you run it, but it chokes and dies on a whole bunch of GNU source
2805     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2806     tentative_cc="/usr/ccs/ATT/cc"
2807     host_makefile_frag="config/mh-ncr3000"
2808     ;;
2809   i[3456789]86-*-sco3.2v5*)
2810     ;;
2811   i[3456789]86-*-sco*)
2812     # The native C compiler botches some simple uses of const.  Unfortunately,
2813     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2814     tentative_cc="cc -Dconst="
2815     host_makefile_frag="config/mh-sco"
2816     ;;
2817   i[3456789]86-*-udk*)
2818     host_makefile_frag="config/mh-sysv5"
2819     ;;
2820   i[3456789]86-*-solaris2*)
2821     host_makefile_frag="config/mh-sysv4"
2822     ;;
2823   i[3456789]86-*-msdosdjgpp*)
2824     host_makefile_frag="config/mh-djgpp"
2825     ;;
2826   *-cygwin*)
2827
2828 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2829 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2830 echo a >cygwin-cat-check
2831 if test `cat cygwin-cat-check` == a ; then
2832   rm cygwin-cat-check
2833   echo "$as_me:$LINENO: result: yes" >&5
2834 echo "${ECHO_T}yes" >&6
2835 else
2836   rm cygwin-cat-check
2837   echo "$as_me:$LINENO: result: no" >&5
2838 echo "${ECHO_T}no" >&6
2839   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2840   Please either mount the build directory in binary mode or run the following
2841   commands before running any configure script:
2842 set -o igncr
2843 export SHELLOPTS
2844   " >&5
2845 echo "$as_me: error: The cat command does not ignore carriage return characters.
2846   Please either mount the build directory in binary mode or run the following
2847   commands before running any configure script:
2848 set -o igncr
2849 export SHELLOPTS
2850   " >&2;}
2851    { (exit 1); exit 1; }; }
2852 fi
2853
2854     host_makefile_frag="config/mh-cygwin"
2855     ;;
2856   *-mingw*)
2857     host_makefile_frag="config/mh-mingw"
2858     ;;
2859   *-interix*)
2860     host_makefile_frag="config/mh-interix"
2861     ;;
2862   vax-*-ultrix2*)
2863     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2864     tentative_cc=gcc
2865     ;;
2866   *-*-solaris2*)
2867     host_makefile_frag="config/mh-solaris"
2868     ;;
2869   m68k-sun-sunos*)
2870     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2871     # without overflowing the jump tables (-J says to use a 32 bit table)
2872     tentative_cc="cc -J"
2873     ;;
2874   hppa*-hp-hpux10*)
2875     tentative_cc="cc -Wp,-H256000"
2876     host_makefile_frag="config/mh-pa-hpux10"
2877     ;;
2878   hppa*-hp-hpux* | hppa*-*-hiux*)
2879     tentative_cc="cc -Wp,-H256000"
2880     host_makefile_frag="config/mh-pa"
2881     ;;
2882   hppa*-*)
2883     host_makefile_frag="config/mh-pa"
2884     ;;
2885   *-hp-hpux* | *-*-hiux*)
2886     tentative_cc="cc -Wp,-H256000"
2887     ;;
2888   rs6000-*-lynxos*)
2889     # /bin/cc is less than useful for our purposes.  Always use GCC
2890     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2891     host_makefile_frag="config/mh-lynxrs6k"
2892     ;;
2893   powerpc-*-darwin*)
2894     host_makefile_frag="config/mh-ppc-darwin"
2895     ;;
2896   powerpc-*-aix*)
2897     host_makefile_frag="config/mh-ppc-aix"
2898     ;;
2899   rs6000-*-aix*)
2900     host_makefile_frag="config/mh-ppc-aix"
2901     ;;
2902   *-*-lynxos*)
2903     # /bin/cc is less than useful for our purposes.  Always use GCC
2904     tentative_cc="/bin/gcc"
2905     ;;
2906   *-*-sysv4*)
2907     host_makefile_frag="config/mh-sysv4"
2908     ;;
2909   # This is placed last to prevent interfering with the cases above.
2910   i[3456789]86-*-*)
2911     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2912     host_makefile_frag="config/mh-x86omitfp"
2913     ;;
2914 esac
2915 fi
2916
2917 # If we aren't going to be using gcc, see if we can extract a definition
2918 # of CC from the fragment.
2919 # Actually, use the 'pre-extracted' version above.
2920 if test -z "${CC}" && test "${build}" = "${host}" ; then
2921   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2922   found=
2923   for dir in $PATH; do
2924     test -z "$dir" && dir=.
2925     if test -f $dir/gcc; then
2926       found=yes
2927       break
2928     fi
2929   done
2930   IFS="$save_ifs"
2931   if test -z "${found}" && test -n "${tentative_cc}" ; then
2932     CC=$tentative_cc
2933   fi
2934 fi
2935
2936 if test "${build}" != "${host}" ; then
2937   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2938   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2939   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2940   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2941   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2942   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2943   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2944   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2945   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2946   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2947   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2948   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2949 else
2950   AR_FOR_BUILD="\$(AR)"
2951   AS_FOR_BUILD="\$(AS)"
2952   CC_FOR_BUILD="\$(CC)"
2953   CXX_FOR_BUILD="\$(CXX)"
2954   GCJ_FOR_BUILD="\$(GCJ)"
2955   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2956   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2957   LD_FOR_BUILD="\$(LD)"
2958   NM_FOR_BUILD="\$(NM)"
2959   RANLIB_FOR_BUILD="\$(RANLIB)"
2960   WINDRES_FOR_BUILD="\$(WINDRES)"
2961   WINDMC_FOR_BUILD="\$(WINDMC)"
2962 fi
2963
2964 ac_ext=c
2965 ac_cpp='$CPP $CPPFLAGS'
2966 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2967 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2968 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2969 if test -n "$ac_tool_prefix"; then
2970   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2971 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2972 echo "$as_me:$LINENO: checking for $ac_word" >&5
2973 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2974 if test "${ac_cv_prog_CC+set}" = set; then
2975   echo $ECHO_N "(cached) $ECHO_C" >&6
2976 else
2977   if test -n "$CC"; then
2978   ac_cv_prog_CC="$CC" # Let the user override the test.
2979 else
2980 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2981 for as_dir in $PATH
2982 do
2983   IFS=$as_save_IFS
2984   test -z "$as_dir" && as_dir=.
2985   for ac_exec_ext in '' $ac_executable_extensions; do
2986   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2987     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2988     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2989     break 2
2990   fi
2991 done
2992 done
2993
2994 fi
2995 fi
2996 CC=$ac_cv_prog_CC
2997 if test -n "$CC"; then
2998   echo "$as_me:$LINENO: result: $CC" >&5
2999 echo "${ECHO_T}$CC" >&6
3000 else
3001   echo "$as_me:$LINENO: result: no" >&5
3002 echo "${ECHO_T}no" >&6
3003 fi
3004
3005 fi
3006 if test -z "$ac_cv_prog_CC"; then
3007   ac_ct_CC=$CC
3008   # Extract the first word of "gcc", so it can be a program name with args.
3009 set dummy gcc; ac_word=$2
3010 echo "$as_me:$LINENO: checking for $ac_word" >&5
3011 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3012 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3013   echo $ECHO_N "(cached) $ECHO_C" >&6
3014 else
3015   if test -n "$ac_ct_CC"; then
3016   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3017 else
3018 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3019 for as_dir in $PATH
3020 do
3021   IFS=$as_save_IFS
3022   test -z "$as_dir" && as_dir=.
3023   for ac_exec_ext in '' $ac_executable_extensions; do
3024   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3025     ac_cv_prog_ac_ct_CC="gcc"
3026     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3027     break 2
3028   fi
3029 done
3030 done
3031
3032 fi
3033 fi
3034 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3035 if test -n "$ac_ct_CC"; then
3036   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3037 echo "${ECHO_T}$ac_ct_CC" >&6
3038 else
3039   echo "$as_me:$LINENO: result: no" >&5
3040 echo "${ECHO_T}no" >&6
3041 fi
3042
3043   CC=$ac_ct_CC
3044 else
3045   CC="$ac_cv_prog_CC"
3046 fi
3047
3048 if test -z "$CC"; then
3049   if test -n "$ac_tool_prefix"; then
3050   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3051 set dummy ${ac_tool_prefix}cc; ac_word=$2
3052 echo "$as_me:$LINENO: checking for $ac_word" >&5
3053 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3054 if test "${ac_cv_prog_CC+set}" = set; then
3055   echo $ECHO_N "(cached) $ECHO_C" >&6
3056 else
3057   if test -n "$CC"; then
3058   ac_cv_prog_CC="$CC" # Let the user override the test.
3059 else
3060 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3061 for as_dir in $PATH
3062 do
3063   IFS=$as_save_IFS
3064   test -z "$as_dir" && as_dir=.
3065   for ac_exec_ext in '' $ac_executable_extensions; do
3066   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3067     ac_cv_prog_CC="${ac_tool_prefix}cc"
3068     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3069     break 2
3070   fi
3071 done
3072 done
3073
3074 fi
3075 fi
3076 CC=$ac_cv_prog_CC
3077 if test -n "$CC"; then
3078   echo "$as_me:$LINENO: result: $CC" >&5
3079 echo "${ECHO_T}$CC" >&6
3080 else
3081   echo "$as_me:$LINENO: result: no" >&5
3082 echo "${ECHO_T}no" >&6
3083 fi
3084
3085 fi
3086 if test -z "$ac_cv_prog_CC"; then
3087   ac_ct_CC=$CC
3088   # Extract the first word of "cc", so it can be a program name with args.
3089 set dummy cc; ac_word=$2
3090 echo "$as_me:$LINENO: checking for $ac_word" >&5
3091 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3092 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3093   echo $ECHO_N "(cached) $ECHO_C" >&6
3094 else
3095   if test -n "$ac_ct_CC"; then
3096   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3097 else
3098 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3099 for as_dir in $PATH
3100 do
3101   IFS=$as_save_IFS
3102   test -z "$as_dir" && as_dir=.
3103   for ac_exec_ext in '' $ac_executable_extensions; do
3104   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3105     ac_cv_prog_ac_ct_CC="cc"
3106     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3107     break 2
3108   fi
3109 done
3110 done
3111
3112 fi
3113 fi
3114 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3115 if test -n "$ac_ct_CC"; then
3116   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3117 echo "${ECHO_T}$ac_ct_CC" >&6
3118 else
3119   echo "$as_me:$LINENO: result: no" >&5
3120 echo "${ECHO_T}no" >&6
3121 fi
3122
3123   CC=$ac_ct_CC
3124 else
3125   CC="$ac_cv_prog_CC"
3126 fi
3127
3128 fi
3129 if test -z "$CC"; then
3130   # Extract the first word of "cc", so it can be a program name with args.
3131 set dummy cc; ac_word=$2
3132 echo "$as_me:$LINENO: checking for $ac_word" >&5
3133 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3134 if test "${ac_cv_prog_CC+set}" = set; then
3135   echo $ECHO_N "(cached) $ECHO_C" >&6
3136 else
3137   if test -n "$CC"; then
3138   ac_cv_prog_CC="$CC" # Let the user override the test.
3139 else
3140   ac_prog_rejected=no
3141 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3142 for as_dir in $PATH
3143 do
3144   IFS=$as_save_IFS
3145   test -z "$as_dir" && as_dir=.
3146   for ac_exec_ext in '' $ac_executable_extensions; do
3147   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3148     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3149        ac_prog_rejected=yes
3150        continue
3151      fi
3152     ac_cv_prog_CC="cc"
3153     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3154     break 2
3155   fi
3156 done
3157 done
3158
3159 if test $ac_prog_rejected = yes; then
3160   # We found a bogon in the path, so make sure we never use it.
3161   set dummy $ac_cv_prog_CC
3162   shift
3163   if test $# != 0; then
3164     # We chose a different compiler from the bogus one.
3165     # However, it has the same basename, so the bogon will be chosen
3166     # first if we set CC to just the basename; use the full file name.
3167     shift
3168     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3169   fi
3170 fi
3171 fi
3172 fi
3173 CC=$ac_cv_prog_CC
3174 if test -n "$CC"; then
3175   echo "$as_me:$LINENO: result: $CC" >&5
3176 echo "${ECHO_T}$CC" >&6
3177 else
3178   echo "$as_me:$LINENO: result: no" >&5
3179 echo "${ECHO_T}no" >&6
3180 fi
3181
3182 fi
3183 if test -z "$CC"; then
3184   if test -n "$ac_tool_prefix"; then
3185   for ac_prog in cl
3186   do
3187     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3188 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3189 echo "$as_me:$LINENO: checking for $ac_word" >&5
3190 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3191 if test "${ac_cv_prog_CC+set}" = set; then
3192   echo $ECHO_N "(cached) $ECHO_C" >&6
3193 else
3194   if test -n "$CC"; then
3195   ac_cv_prog_CC="$CC" # Let the user override the test.
3196 else
3197 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3198 for as_dir in $PATH
3199 do
3200   IFS=$as_save_IFS
3201   test -z "$as_dir" && as_dir=.
3202   for ac_exec_ext in '' $ac_executable_extensions; do
3203   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3204     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3205     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3206     break 2
3207   fi
3208 done
3209 done
3210
3211 fi
3212 fi
3213 CC=$ac_cv_prog_CC
3214 if test -n "$CC"; then
3215   echo "$as_me:$LINENO: result: $CC" >&5
3216 echo "${ECHO_T}$CC" >&6
3217 else
3218   echo "$as_me:$LINENO: result: no" >&5
3219 echo "${ECHO_T}no" >&6
3220 fi
3221
3222     test -n "$CC" && break
3223   done
3224 fi
3225 if test -z "$CC"; then
3226   ac_ct_CC=$CC
3227   for ac_prog in cl
3228 do
3229   # Extract the first word of "$ac_prog", so it can be a program name with args.
3230 set dummy $ac_prog; ac_word=$2
3231 echo "$as_me:$LINENO: checking for $ac_word" >&5
3232 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3233 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3234   echo $ECHO_N "(cached) $ECHO_C" >&6
3235 else
3236   if test -n "$ac_ct_CC"; then
3237   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3238 else
3239 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3240 for as_dir in $PATH
3241 do
3242   IFS=$as_save_IFS
3243   test -z "$as_dir" && as_dir=.
3244   for ac_exec_ext in '' $ac_executable_extensions; do
3245   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3246     ac_cv_prog_ac_ct_CC="$ac_prog"
3247     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3248     break 2
3249   fi
3250 done
3251 done
3252
3253 fi
3254 fi
3255 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3256 if test -n "$ac_ct_CC"; then
3257   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3258 echo "${ECHO_T}$ac_ct_CC" >&6
3259 else
3260   echo "$as_me:$LINENO: result: no" >&5
3261 echo "${ECHO_T}no" >&6
3262 fi
3263
3264   test -n "$ac_ct_CC" && break
3265 done
3266
3267   CC=$ac_ct_CC
3268 fi
3269
3270 fi
3271
3272
3273 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3274 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3275 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3276 See \`config.log' for more details." >&5
3277 echo "$as_me: error: no acceptable C compiler found in \$PATH
3278 See \`config.log' for more details." >&2;}
3279    { (exit 1); exit 1; }; }; }
3280
3281 # Provide some information about the compiler.
3282 echo "$as_me:$LINENO:" \
3283      "checking for C compiler version" >&5
3284 ac_compiler=`set X $ac_compile; echo $2`
3285 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3286   (eval $ac_compiler --version </dev/null >&5) 2>&5
3287   ac_status=$?
3288   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3289   (exit $ac_status); }
3290 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3291   (eval $ac_compiler -v </dev/null >&5) 2>&5
3292   ac_status=$?
3293   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3294   (exit $ac_status); }
3295 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3296   (eval $ac_compiler -V </dev/null >&5) 2>&5
3297   ac_status=$?
3298   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3299   (exit $ac_status); }
3300
3301 cat >conftest.$ac_ext <<_ACEOF
3302 /* confdefs.h.  */
3303 _ACEOF
3304 cat confdefs.h >>conftest.$ac_ext
3305 cat >>conftest.$ac_ext <<_ACEOF
3306 /* end confdefs.h.  */
3307
3308 int
3309 main ()
3310 {
3311
3312   ;
3313   return 0;
3314 }
3315 _ACEOF
3316 ac_clean_files_save=$ac_clean_files
3317 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3318 # Try to create an executable without -o first, disregard a.out.
3319 # It will help us diagnose broken compilers, and finding out an intuition
3320 # of exeext.
3321 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3322 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3323 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3324 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3325   (eval $ac_link_default) 2>&5
3326   ac_status=$?
3327   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3328   (exit $ac_status); }; then
3329   # Find the output, starting from the most likely.  This scheme is
3330 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3331 # resort.
3332
3333 # Be careful to initialize this variable, since it used to be cached.
3334 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3335 ac_cv_exeext=
3336 # b.out is created by i960 compilers.
3337 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3338 do
3339   test -f "$ac_file" || continue
3340   case $ac_file in
3341     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3342         ;;
3343     conftest.$ac_ext )
3344         # This is the source file.
3345         ;;
3346     [ab].out )
3347         # We found the default executable, but exeext='' is most
3348         # certainly right.
3349         break;;
3350     *.* )
3351         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3352         # FIXME: I believe we export ac_cv_exeext for Libtool,
3353         # but it would be cool to find out if it's true.  Does anybody
3354         # maintain Libtool? --akim.
3355         export ac_cv_exeext
3356         break;;
3357     * )
3358         break;;
3359   esac
3360 done
3361 else
3362   echo "$as_me: failed program was:" >&5
3363 sed 's/^/| /' conftest.$ac_ext >&5
3364
3365 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3366 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3367 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3368 See \`config.log' for more details." >&5
3369 echo "$as_me: error: C compiler cannot create executables
3370 See \`config.log' for more details." >&2;}
3371    { (exit 77); exit 77; }; }; }
3372 fi
3373
3374 ac_exeext=$ac_cv_exeext
3375 echo "$as_me:$LINENO: result: $ac_file" >&5
3376 echo "${ECHO_T}$ac_file" >&6
3377
3378 # Check the compiler produces executables we can run.  If not, either
3379 # the compiler is broken, or we cross compile.
3380 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3381 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3382 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3383 # If not cross compiling, check that we can run a simple program.
3384 if test "$cross_compiling" != yes; then
3385   if { ac_try='./$ac_file'
3386   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3387   (eval $ac_try) 2>&5
3388   ac_status=$?
3389   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3390   (exit $ac_status); }; }; then
3391     cross_compiling=no
3392   else
3393     if test "$cross_compiling" = maybe; then
3394         cross_compiling=yes
3395     else
3396         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3397 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3398 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3399 If you meant to cross compile, use \`--host'.
3400 See \`config.log' for more details." >&5
3401 echo "$as_me: error: cannot run C compiled programs.
3402 If you meant to cross compile, use \`--host'.
3403 See \`config.log' for more details." >&2;}
3404    { (exit 1); exit 1; }; }; }
3405     fi
3406   fi
3407 fi
3408 echo "$as_me:$LINENO: result: yes" >&5
3409 echo "${ECHO_T}yes" >&6
3410
3411 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3412 ac_clean_files=$ac_clean_files_save
3413 # Check the compiler produces executables we can run.  If not, either
3414 # the compiler is broken, or we cross compile.
3415 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3416 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3417 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3418 echo "${ECHO_T}$cross_compiling" >&6
3419
3420 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3421 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3422 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3423   (eval $ac_link) 2>&5
3424   ac_status=$?
3425   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3426   (exit $ac_status); }; then
3427   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3428 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3429 # work properly (i.e., refer to `conftest.exe'), while it won't with
3430 # `rm'.
3431 for ac_file in conftest.exe conftest conftest.*; do
3432   test -f "$ac_file" || continue
3433   case $ac_file in
3434     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3435     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3436           export ac_cv_exeext
3437           break;;
3438     * ) break;;
3439   esac
3440 done
3441 else
3442   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3443 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3444 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3445 See \`config.log' for more details." >&5
3446 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3447 See \`config.log' for more details." >&2;}
3448    { (exit 1); exit 1; }; }; }
3449 fi
3450
3451 rm -f conftest$ac_cv_exeext
3452 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3453 echo "${ECHO_T}$ac_cv_exeext" >&6
3454
3455 rm -f conftest.$ac_ext
3456 EXEEXT=$ac_cv_exeext
3457 ac_exeext=$EXEEXT
3458 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3459 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3460 if test "${ac_cv_objext+set}" = set; then
3461   echo $ECHO_N "(cached) $ECHO_C" >&6
3462 else
3463   cat >conftest.$ac_ext <<_ACEOF
3464 /* confdefs.h.  */
3465 _ACEOF
3466 cat confdefs.h >>conftest.$ac_ext
3467 cat >>conftest.$ac_ext <<_ACEOF
3468 /* end confdefs.h.  */
3469
3470 int
3471 main ()
3472 {
3473
3474   ;
3475   return 0;
3476 }
3477 _ACEOF
3478 rm -f conftest.o conftest.obj
3479 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3480   (eval $ac_compile) 2>&5
3481   ac_status=$?
3482   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3483   (exit $ac_status); }; then
3484   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3485   case $ac_file in
3486     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3487     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3488        break;;
3489   esac
3490 done
3491 else
3492   echo "$as_me: failed program was:" >&5
3493 sed 's/^/| /' conftest.$ac_ext >&5
3494
3495 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3496 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3497 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3498 See \`config.log' for more details." >&5
3499 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3500 See \`config.log' for more details." >&2;}
3501    { (exit 1); exit 1; }; }; }
3502 fi
3503
3504 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3505 fi
3506 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3507 echo "${ECHO_T}$ac_cv_objext" >&6
3508 OBJEXT=$ac_cv_objext
3509 ac_objext=$OBJEXT
3510 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3511 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3512 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3513   echo $ECHO_N "(cached) $ECHO_C" >&6
3514 else
3515   cat >conftest.$ac_ext <<_ACEOF
3516 /* confdefs.h.  */
3517 _ACEOF
3518 cat confdefs.h >>conftest.$ac_ext
3519 cat >>conftest.$ac_ext <<_ACEOF
3520 /* end confdefs.h.  */
3521
3522 int
3523 main ()
3524 {
3525 #ifndef __GNUC__
3526        choke me
3527 #endif
3528
3529   ;
3530   return 0;
3531 }
3532 _ACEOF
3533 rm -f conftest.$ac_objext
3534 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3535   (eval $ac_compile) 2>conftest.er1
3536   ac_status=$?
3537   grep -v '^ *+' conftest.er1 >conftest.err
3538   rm -f conftest.er1
3539   cat conftest.err >&5
3540   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3541   (exit $ac_status); } &&
3542          { ac_try='test -z "$ac_c_werror_flag"
3543                          || test ! -s conftest.err'
3544   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3545   (eval $ac_try) 2>&5
3546   ac_status=$?
3547   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3548   (exit $ac_status); }; } &&
3549          { ac_try='test -s conftest.$ac_objext'
3550   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3551   (eval $ac_try) 2>&5
3552   ac_status=$?
3553   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3554   (exit $ac_status); }; }; then
3555   ac_compiler_gnu=yes
3556 else
3557   echo "$as_me: failed program was:" >&5
3558 sed 's/^/| /' conftest.$ac_ext >&5
3559
3560 ac_compiler_gnu=no
3561 fi
3562 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3563 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3564
3565 fi
3566 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3567 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3568 GCC=`test $ac_compiler_gnu = yes && echo yes`
3569 ac_test_CFLAGS=${CFLAGS+set}
3570 ac_save_CFLAGS=$CFLAGS
3571 CFLAGS="-g"
3572 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3573 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3574 if test "${ac_cv_prog_cc_g+set}" = set; then
3575   echo $ECHO_N "(cached) $ECHO_C" >&6
3576 else
3577   cat >conftest.$ac_ext <<_ACEOF
3578 /* confdefs.h.  */
3579 _ACEOF
3580 cat confdefs.h >>conftest.$ac_ext
3581 cat >>conftest.$ac_ext <<_ACEOF
3582 /* end confdefs.h.  */
3583
3584 int
3585 main ()
3586 {
3587
3588   ;
3589   return 0;
3590 }
3591 _ACEOF
3592 rm -f conftest.$ac_objext
3593 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3594   (eval $ac_compile) 2>conftest.er1
3595   ac_status=$?
3596   grep -v '^ *+' conftest.er1 >conftest.err
3597   rm -f conftest.er1
3598   cat conftest.err >&5
3599   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3600   (exit $ac_status); } &&
3601          { ac_try='test -z "$ac_c_werror_flag"
3602                          || test ! -s conftest.err'
3603   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3604   (eval $ac_try) 2>&5
3605   ac_status=$?
3606   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3607   (exit $ac_status); }; } &&
3608          { ac_try='test -s conftest.$ac_objext'
3609   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3610   (eval $ac_try) 2>&5
3611   ac_status=$?
3612   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3613   (exit $ac_status); }; }; then
3614   ac_cv_prog_cc_g=yes
3615 else
3616   echo "$as_me: failed program was:" >&5
3617 sed 's/^/| /' conftest.$ac_ext >&5
3618
3619 ac_cv_prog_cc_g=no
3620 fi
3621 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3622 fi
3623 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3624 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3625 if test "$ac_test_CFLAGS" = set; then
3626   CFLAGS=$ac_save_CFLAGS
3627 elif test $ac_cv_prog_cc_g = yes; then
3628   if test "$GCC" = yes; then
3629     CFLAGS="-g -O2"
3630   else
3631     CFLAGS="-g"
3632   fi
3633 else
3634   if test "$GCC" = yes; then
3635     CFLAGS="-O2"
3636   else
3637     CFLAGS=
3638   fi
3639 fi
3640 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3641 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3642 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3643   echo $ECHO_N "(cached) $ECHO_C" >&6
3644 else
3645   ac_cv_prog_cc_stdc=no
3646 ac_save_CC=$CC
3647 cat >conftest.$ac_ext <<_ACEOF
3648 /* confdefs.h.  */
3649 _ACEOF
3650 cat confdefs.h >>conftest.$ac_ext
3651 cat >>conftest.$ac_ext <<_ACEOF
3652 /* end confdefs.h.  */
3653 #include <stdarg.h>
3654 #include <stdio.h>
3655 #include <sys/types.h>
3656 #include <sys/stat.h>
3657 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3658 struct buf { int x; };
3659 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3660 static char *e (p, i)
3661      char **p;
3662      int i;
3663 {
3664   return p[i];
3665 }
3666 static char *f (char * (*g) (char **, int), char **p, ...)
3667 {
3668   char *s;
3669   va_list v;
3670   va_start (v,p);
3671   s = g (p, va_arg (v,int));
3672   va_end (v);
3673   return s;
3674 }
3675
3676 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3677    function prototypes and stuff, but not '\xHH' hex character constants.
3678    These don't provoke an error unfortunately, instead are silently treated
3679    as 'x'.  The following induces an error, until -std1 is added to get
3680    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3681    array size at least.  It's necessary to write '\x00'==0 to get something
3682    that's true only with -std1.  */
3683 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3684
3685 int test (int i, double x);
3686 struct s1 {int (*f) (int a);};
3687 struct s2 {int (*f) (double a);};
3688 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3689 int argc;
3690 char **argv;
3691 int
3692 main ()
3693 {
3694 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3695   ;
3696   return 0;
3697 }
3698 _ACEOF
3699 # Don't try gcc -ansi; that turns off useful extensions and
3700 # breaks some systems' header files.
3701 # AIX                   -qlanglvl=ansi
3702 # Ultrix and OSF/1      -std1
3703 # HP-UX 10.20 and later -Ae
3704 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3705 # SVR4                  -Xc -D__EXTENSIONS__
3706 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3707 do
3708   CC="$ac_save_CC $ac_arg"
3709   rm -f conftest.$ac_objext
3710 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3711   (eval $ac_compile) 2>conftest.er1
3712   ac_status=$?
3713   grep -v '^ *+' conftest.er1 >conftest.err
3714   rm -f conftest.er1
3715   cat conftest.err >&5
3716   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3717   (exit $ac_status); } &&
3718          { ac_try='test -z "$ac_c_werror_flag"
3719                          || test ! -s conftest.err'
3720   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3721   (eval $ac_try) 2>&5
3722   ac_status=$?
3723   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3724   (exit $ac_status); }; } &&
3725          { ac_try='test -s conftest.$ac_objext'
3726   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3727   (eval $ac_try) 2>&5
3728   ac_status=$?
3729   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3730   (exit $ac_status); }; }; then
3731   ac_cv_prog_cc_stdc=$ac_arg
3732 break
3733 else
3734   echo "$as_me: failed program was:" >&5
3735 sed 's/^/| /' conftest.$ac_ext >&5
3736
3737 fi
3738 rm -f conftest.err conftest.$ac_objext
3739 done
3740 rm -f conftest.$ac_ext conftest.$ac_objext
3741 CC=$ac_save_CC
3742
3743 fi
3744
3745 case "x$ac_cv_prog_cc_stdc" in
3746   x|xno)
3747     echo "$as_me:$LINENO: result: none needed" >&5
3748 echo "${ECHO_T}none needed" >&6 ;;
3749   *)
3750     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3751 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3752     CC="$CC $ac_cv_prog_cc_stdc" ;;
3753 esac
3754
3755 # Some people use a C++ compiler to compile C.  Since we use `exit',
3756 # in C++ we need to declare it.  In case someone uses the same compiler
3757 # for both compiling C and C++ we need to have the C++ compiler decide
3758 # the declaration of exit, since it's the most demanding environment.
3759 cat >conftest.$ac_ext <<_ACEOF
3760 #ifndef __cplusplus
3761   choke me
3762 #endif
3763 _ACEOF
3764 rm -f conftest.$ac_objext
3765 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3766   (eval $ac_compile) 2>conftest.er1
3767   ac_status=$?
3768   grep -v '^ *+' conftest.er1 >conftest.err
3769   rm -f conftest.er1
3770   cat conftest.err >&5
3771   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3772   (exit $ac_status); } &&
3773          { ac_try='test -z "$ac_c_werror_flag"
3774                          || test ! -s conftest.err'
3775   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3776   (eval $ac_try) 2>&5
3777   ac_status=$?
3778   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3779   (exit $ac_status); }; } &&
3780          { ac_try='test -s conftest.$ac_objext'
3781   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3782   (eval $ac_try) 2>&5
3783   ac_status=$?
3784   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3785   (exit $ac_status); }; }; then
3786   for ac_declaration in \
3787    '' \
3788    'extern "C" void std::exit (int) throw (); using std::exit;' \
3789    'extern "C" void std::exit (int); using std::exit;' \
3790    'extern "C" void exit (int) throw ();' \
3791    'extern "C" void exit (int);' \
3792    'void exit (int);'
3793 do
3794   cat >conftest.$ac_ext <<_ACEOF
3795 /* confdefs.h.  */
3796 _ACEOF
3797 cat confdefs.h >>conftest.$ac_ext
3798 cat >>conftest.$ac_ext <<_ACEOF
3799 /* end confdefs.h.  */
3800 $ac_declaration
3801 #include <stdlib.h>
3802 int
3803 main ()
3804 {
3805 exit (42);
3806   ;
3807   return 0;
3808 }
3809 _ACEOF
3810 rm -f conftest.$ac_objext
3811 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3812   (eval $ac_compile) 2>conftest.er1
3813   ac_status=$?
3814   grep -v '^ *+' conftest.er1 >conftest.err
3815   rm -f conftest.er1
3816   cat conftest.err >&5
3817   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3818   (exit $ac_status); } &&
3819          { ac_try='test -z "$ac_c_werror_flag"
3820                          || test ! -s conftest.err'
3821   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3822   (eval $ac_try) 2>&5
3823   ac_status=$?
3824   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3825   (exit $ac_status); }; } &&
3826          { ac_try='test -s conftest.$ac_objext'
3827   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3828   (eval $ac_try) 2>&5
3829   ac_status=$?
3830   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3831   (exit $ac_status); }; }; then
3832   :
3833 else
3834   echo "$as_me: failed program was:" >&5
3835 sed 's/^/| /' conftest.$ac_ext >&5
3836
3837 continue
3838 fi
3839 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3840   cat >conftest.$ac_ext <<_ACEOF
3841 /* confdefs.h.  */
3842 _ACEOF
3843 cat confdefs.h >>conftest.$ac_ext
3844 cat >>conftest.$ac_ext <<_ACEOF
3845 /* end confdefs.h.  */
3846 $ac_declaration
3847 int
3848 main ()
3849 {
3850 exit (42);
3851   ;
3852   return 0;
3853 }
3854 _ACEOF
3855 rm -f conftest.$ac_objext
3856 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3857   (eval $ac_compile) 2>conftest.er1
3858   ac_status=$?
3859   grep -v '^ *+' conftest.er1 >conftest.err
3860   rm -f conftest.er1
3861   cat conftest.err >&5
3862   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3863   (exit $ac_status); } &&
3864          { ac_try='test -z "$ac_c_werror_flag"
3865                          || test ! -s conftest.err'
3866   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3867   (eval $ac_try) 2>&5
3868   ac_status=$?
3869   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3870   (exit $ac_status); }; } &&
3871          { ac_try='test -s conftest.$ac_objext'
3872   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3873   (eval $ac_try) 2>&5
3874   ac_status=$?
3875   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3876   (exit $ac_status); }; }; then
3877   break
3878 else
3879   echo "$as_me: failed program was:" >&5
3880 sed 's/^/| /' conftest.$ac_ext >&5
3881
3882 fi
3883 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3884 done
3885 rm -f conftest*
3886 if test -n "$ac_declaration"; then
3887   echo '#ifdef __cplusplus' >>confdefs.h
3888   echo $ac_declaration      >>confdefs.h
3889   echo '#endif'             >>confdefs.h
3890 fi
3891
3892 else
3893   echo "$as_me: failed program was:" >&5
3894 sed 's/^/| /' conftest.$ac_ext >&5
3895
3896 fi
3897 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3898 ac_ext=c
3899 ac_cpp='$CPP $CPPFLAGS'
3900 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3901 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3902 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3903
3904 ac_ext=cc
3905 ac_cpp='$CXXCPP $CPPFLAGS'
3906 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3907 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3908 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3909 if test -n "$ac_tool_prefix"; then
3910   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3911   do
3912     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3913 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3914 echo "$as_me:$LINENO: checking for $ac_word" >&5
3915 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3916 if test "${ac_cv_prog_CXX+set}" = set; then
3917   echo $ECHO_N "(cached) $ECHO_C" >&6
3918 else
3919   if test -n "$CXX"; then
3920   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3921 else
3922 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3923 for as_dir in $PATH
3924 do
3925   IFS=$as_save_IFS
3926   test -z "$as_dir" && as_dir=.
3927   for ac_exec_ext in '' $ac_executable_extensions; do
3928   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3929     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3930     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3931     break 2
3932   fi
3933 done
3934 done
3935
3936 fi
3937 fi
3938 CXX=$ac_cv_prog_CXX
3939 if test -n "$CXX"; then
3940   echo "$as_me:$LINENO: result: $CXX" >&5
3941 echo "${ECHO_T}$CXX" >&6
3942 else
3943   echo "$as_me:$LINENO: result: no" >&5
3944 echo "${ECHO_T}no" >&6
3945 fi
3946
3947     test -n "$CXX" && break
3948   done
3949 fi
3950 if test -z "$CXX"; then
3951   ac_ct_CXX=$CXX
3952   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3953 do
3954   # Extract the first word of "$ac_prog", so it can be a program name with args.
3955 set dummy $ac_prog; ac_word=$2
3956 echo "$as_me:$LINENO: checking for $ac_word" >&5
3957 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3958 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3959   echo $ECHO_N "(cached) $ECHO_C" >&6
3960 else
3961   if test -n "$ac_ct_CXX"; then
3962   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3963 else
3964 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3965 for as_dir in $PATH
3966 do
3967   IFS=$as_save_IFS
3968   test -z "$as_dir" && as_dir=.
3969   for ac_exec_ext in '' $ac_executable_extensions; do
3970   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3971     ac_cv_prog_ac_ct_CXX="$ac_prog"
3972     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3973     break 2
3974   fi
3975 done
3976 done
3977
3978 fi
3979 fi
3980 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3981 if test -n "$ac_ct_CXX"; then
3982   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3983 echo "${ECHO_T}$ac_ct_CXX" >&6
3984 else
3985   echo "$as_me:$LINENO: result: no" >&5
3986 echo "${ECHO_T}no" >&6
3987 fi
3988
3989   test -n "$ac_ct_CXX" && break
3990 done
3991 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3992
3993   CXX=$ac_ct_CXX
3994 fi
3995
3996
3997 # Provide some information about the compiler.
3998 echo "$as_me:$LINENO:" \
3999      "checking for C++ compiler version" >&5
4000 ac_compiler=`set X $ac_compile; echo $2`
4001 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
4002   (eval $ac_compiler --version </dev/null >&5) 2>&5
4003   ac_status=$?
4004   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4005   (exit $ac_status); }
4006 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
4007   (eval $ac_compiler -v </dev/null >&5) 2>&5
4008   ac_status=$?
4009   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4010   (exit $ac_status); }
4011 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4012   (eval $ac_compiler -V </dev/null >&5) 2>&5
4013   ac_status=$?
4014   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4015   (exit $ac_status); }
4016
4017 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4018 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4019 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4020   echo $ECHO_N "(cached) $ECHO_C" >&6
4021 else
4022   cat >conftest.$ac_ext <<_ACEOF
4023 /* confdefs.h.  */
4024 _ACEOF
4025 cat confdefs.h >>conftest.$ac_ext
4026 cat >>conftest.$ac_ext <<_ACEOF
4027 /* end confdefs.h.  */
4028
4029 int
4030 main ()
4031 {
4032 #ifndef __GNUC__
4033        choke me
4034 #endif
4035
4036   ;
4037   return 0;
4038 }
4039 _ACEOF
4040 rm -f conftest.$ac_objext
4041 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4042   (eval $ac_compile) 2>conftest.er1
4043   ac_status=$?
4044   grep -v '^ *+' conftest.er1 >conftest.err
4045   rm -f conftest.er1
4046   cat conftest.err >&5
4047   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4048   (exit $ac_status); } &&
4049          { ac_try='test -z "$ac_cxx_werror_flag"
4050                          || test ! -s conftest.err'
4051   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4052   (eval $ac_try) 2>&5
4053   ac_status=$?
4054   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4055   (exit $ac_status); }; } &&
4056          { ac_try='test -s conftest.$ac_objext'
4057   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4058   (eval $ac_try) 2>&5
4059   ac_status=$?
4060   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4061   (exit $ac_status); }; }; then
4062   ac_compiler_gnu=yes
4063 else
4064   echo "$as_me: failed program was:" >&5
4065 sed 's/^/| /' conftest.$ac_ext >&5
4066
4067 ac_compiler_gnu=no
4068 fi
4069 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4070 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4071
4072 fi
4073 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4074 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4075 GXX=`test $ac_compiler_gnu = yes && echo yes`
4076 ac_test_CXXFLAGS=${CXXFLAGS+set}
4077 ac_save_CXXFLAGS=$CXXFLAGS
4078 CXXFLAGS="-g"
4079 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4080 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4081 if test "${ac_cv_prog_cxx_g+set}" = set; then
4082   echo $ECHO_N "(cached) $ECHO_C" >&6
4083 else
4084   cat >conftest.$ac_ext <<_ACEOF
4085 /* confdefs.h.  */
4086 _ACEOF
4087 cat confdefs.h >>conftest.$ac_ext
4088 cat >>conftest.$ac_ext <<_ACEOF
4089 /* end confdefs.h.  */
4090
4091 int
4092 main ()
4093 {
4094
4095   ;
4096   return 0;
4097 }
4098 _ACEOF
4099 rm -f conftest.$ac_objext
4100 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4101   (eval $ac_compile) 2>conftest.er1
4102   ac_status=$?
4103   grep -v '^ *+' conftest.er1 >conftest.err
4104   rm -f conftest.er1
4105   cat conftest.err >&5
4106   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4107   (exit $ac_status); } &&
4108          { ac_try='test -z "$ac_cxx_werror_flag"
4109                          || test ! -s conftest.err'
4110   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4111   (eval $ac_try) 2>&5
4112   ac_status=$?
4113   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4114   (exit $ac_status); }; } &&
4115          { ac_try='test -s conftest.$ac_objext'
4116   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4117   (eval $ac_try) 2>&5
4118   ac_status=$?
4119   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4120   (exit $ac_status); }; }; then
4121   ac_cv_prog_cxx_g=yes
4122 else
4123   echo "$as_me: failed program was:" >&5
4124 sed 's/^/| /' conftest.$ac_ext >&5
4125
4126 ac_cv_prog_cxx_g=no
4127 fi
4128 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4129 fi
4130 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4131 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4132 if test "$ac_test_CXXFLAGS" = set; then
4133   CXXFLAGS=$ac_save_CXXFLAGS
4134 elif test $ac_cv_prog_cxx_g = yes; then
4135   if test "$GXX" = yes; then
4136     CXXFLAGS="-g -O2"
4137   else
4138     CXXFLAGS="-g"
4139   fi
4140 else
4141   if test "$GXX" = yes; then
4142     CXXFLAGS="-O2"
4143   else
4144     CXXFLAGS=
4145   fi
4146 fi
4147 for ac_declaration in \
4148    '' \
4149    'extern "C" void std::exit (int) throw (); using std::exit;' \
4150    'extern "C" void std::exit (int); using std::exit;' \
4151    'extern "C" void exit (int) throw ();' \
4152    'extern "C" void exit (int);' \
4153    'void exit (int);'
4154 do
4155   cat >conftest.$ac_ext <<_ACEOF
4156 /* confdefs.h.  */
4157 _ACEOF
4158 cat confdefs.h >>conftest.$ac_ext
4159 cat >>conftest.$ac_ext <<_ACEOF
4160 /* end confdefs.h.  */
4161 $ac_declaration
4162 #include <stdlib.h>
4163 int
4164 main ()
4165 {
4166 exit (42);
4167   ;
4168   return 0;
4169 }
4170 _ACEOF
4171 rm -f conftest.$ac_objext
4172 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4173   (eval $ac_compile) 2>conftest.er1
4174   ac_status=$?
4175   grep -v '^ *+' conftest.er1 >conftest.err
4176   rm -f conftest.er1
4177   cat conftest.err >&5
4178   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4179   (exit $ac_status); } &&
4180          { ac_try='test -z "$ac_cxx_werror_flag"
4181                          || test ! -s conftest.err'
4182   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4183   (eval $ac_try) 2>&5
4184   ac_status=$?
4185   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4186   (exit $ac_status); }; } &&
4187          { ac_try='test -s conftest.$ac_objext'
4188   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4189   (eval $ac_try) 2>&5
4190   ac_status=$?
4191   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4192   (exit $ac_status); }; }; then
4193   :
4194 else
4195   echo "$as_me: failed program was:" >&5
4196 sed 's/^/| /' conftest.$ac_ext >&5
4197
4198 continue
4199 fi
4200 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4201   cat >conftest.$ac_ext <<_ACEOF
4202 /* confdefs.h.  */
4203 _ACEOF
4204 cat confdefs.h >>conftest.$ac_ext
4205 cat >>conftest.$ac_ext <<_ACEOF
4206 /* end confdefs.h.  */
4207 $ac_declaration
4208 int
4209 main ()
4210 {
4211 exit (42);
4212   ;
4213   return 0;
4214 }
4215 _ACEOF
4216 rm -f conftest.$ac_objext
4217 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4218   (eval $ac_compile) 2>conftest.er1
4219   ac_status=$?
4220   grep -v '^ *+' conftest.er1 >conftest.err
4221   rm -f conftest.er1
4222   cat conftest.err >&5
4223   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4224   (exit $ac_status); } &&
4225          { ac_try='test -z "$ac_cxx_werror_flag"
4226                          || test ! -s conftest.err'
4227   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4228   (eval $ac_try) 2>&5
4229   ac_status=$?
4230   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4231   (exit $ac_status); }; } &&
4232          { ac_try='test -s conftest.$ac_objext'
4233   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4234   (eval $ac_try) 2>&5
4235   ac_status=$?
4236   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4237   (exit $ac_status); }; }; then
4238   break
4239 else
4240   echo "$as_me: failed program was:" >&5
4241 sed 's/^/| /' conftest.$ac_ext >&5
4242
4243 fi
4244 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4245 done
4246 rm -f conftest*
4247 if test -n "$ac_declaration"; then
4248   echo '#ifdef __cplusplus' >>confdefs.h
4249   echo $ac_declaration      >>confdefs.h
4250   echo '#endif'             >>confdefs.h
4251 fi
4252
4253 ac_ext=c
4254 ac_cpp='$CPP $CPPFLAGS'
4255 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4256 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4257 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4258
4259
4260 # We must set the default linker to the linker used by gcc for the correct
4261 # operation of libtool.  If LD is not defined and we are using gcc, try to
4262 # set the LD default to the ld used by gcc.
4263 if test -z "$LD"; then
4264   if test "$GCC" = yes; then
4265     case $build in
4266     *-*-mingw*)
4267       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4268     *)
4269       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4270     esac
4271     case $gcc_prog_ld in
4272     # Accept absolute paths.
4273     [\\/]* | [A-Za-z]:[\\/]*)
4274       LD="$gcc_prog_ld" ;;
4275     esac
4276   fi
4277 fi
4278
4279
4280
4281
4282 if test -n "$ac_tool_prefix"; then
4283   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4284 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4285 echo "$as_me:$LINENO: checking for $ac_word" >&5
4286 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4287 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4288   echo $ECHO_N "(cached) $ECHO_C" >&6
4289 else
4290   if test -n "$GNATBIND"; then
4291   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4292 else
4293 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4294 for as_dir in $PATH
4295 do
4296   IFS=$as_save_IFS
4297   test -z "$as_dir" && as_dir=.
4298   for ac_exec_ext in '' $ac_executable_extensions; do
4299   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4300     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4301     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4302     break 2
4303   fi
4304 done
4305 done
4306
4307 fi
4308 fi
4309 GNATBIND=$ac_cv_prog_GNATBIND
4310 if test -n "$GNATBIND"; then
4311   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4312 echo "${ECHO_T}$GNATBIND" >&6
4313 else
4314   echo "$as_me:$LINENO: result: no" >&5
4315 echo "${ECHO_T}no" >&6
4316 fi
4317
4318 fi
4319 if test -z "$ac_cv_prog_GNATBIND"; then
4320   ac_ct_GNATBIND=$GNATBIND
4321   # Extract the first word of "gnatbind", so it can be a program name with args.
4322 set dummy gnatbind; ac_word=$2
4323 echo "$as_me:$LINENO: checking for $ac_word" >&5
4324 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4325 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4326   echo $ECHO_N "(cached) $ECHO_C" >&6
4327 else
4328   if test -n "$ac_ct_GNATBIND"; then
4329   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4330 else
4331 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4332 for as_dir in $PATH
4333 do
4334   IFS=$as_save_IFS
4335   test -z "$as_dir" && as_dir=.
4336   for ac_exec_ext in '' $ac_executable_extensions; do
4337   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4338     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4339     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4340     break 2
4341   fi
4342 done
4343 done
4344
4345   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4346 fi
4347 fi
4348 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4349 if test -n "$ac_ct_GNATBIND"; then
4350   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4351 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4352 else
4353   echo "$as_me:$LINENO: result: no" >&5
4354 echo "${ECHO_T}no" >&6
4355 fi
4356
4357   GNATBIND=$ac_ct_GNATBIND
4358 else
4359   GNATBIND="$ac_cv_prog_GNATBIND"
4360 fi
4361
4362 if test -n "$ac_tool_prefix"; then
4363   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4364 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4365 echo "$as_me:$LINENO: checking for $ac_word" >&5
4366 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4367 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4368   echo $ECHO_N "(cached) $ECHO_C" >&6
4369 else
4370   if test -n "$GNATMAKE"; then
4371   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4372 else
4373 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4374 for as_dir in $PATH
4375 do
4376   IFS=$as_save_IFS
4377   test -z "$as_dir" && as_dir=.
4378   for ac_exec_ext in '' $ac_executable_extensions; do
4379   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4380     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4381     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4382     break 2
4383   fi
4384 done
4385 done
4386
4387 fi
4388 fi
4389 GNATMAKE=$ac_cv_prog_GNATMAKE
4390 if test -n "$GNATMAKE"; then
4391   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4392 echo "${ECHO_T}$GNATMAKE" >&6
4393 else
4394   echo "$as_me:$LINENO: result: no" >&5
4395 echo "${ECHO_T}no" >&6
4396 fi
4397
4398 fi
4399 if test -z "$ac_cv_prog_GNATMAKE"; then
4400   ac_ct_GNATMAKE=$GNATMAKE
4401   # Extract the first word of "gnatmake", so it can be a program name with args.
4402 set dummy gnatmake; ac_word=$2
4403 echo "$as_me:$LINENO: checking for $ac_word" >&5
4404 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4405 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4406   echo $ECHO_N "(cached) $ECHO_C" >&6
4407 else
4408   if test -n "$ac_ct_GNATMAKE"; then
4409   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4410 else
4411 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4412 for as_dir in $PATH
4413 do
4414   IFS=$as_save_IFS
4415   test -z "$as_dir" && as_dir=.
4416   for ac_exec_ext in '' $ac_executable_extensions; do
4417   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4418     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4419     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4420     break 2
4421   fi
4422 done
4423 done
4424
4425   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4426 fi
4427 fi
4428 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4429 if test -n "$ac_ct_GNATMAKE"; then
4430   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4431 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4432 else
4433   echo "$as_me:$LINENO: result: no" >&5
4434 echo "${ECHO_T}no" >&6
4435 fi
4436
4437   GNATMAKE=$ac_ct_GNATMAKE
4438 else
4439   GNATMAKE="$ac_cv_prog_GNATMAKE"
4440 fi
4441
4442 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4443 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4444 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4445   echo $ECHO_N "(cached) $ECHO_C" >&6
4446 else
4447   cat >conftest.adb <<EOF
4448 procedure conftest is begin null; end conftest;
4449 EOF
4450 acx_cv_cc_gcc_supports_ada=no
4451 # There is a bug in old released versions of GCC which causes the
4452 # driver to exit successfully when the appropriate language module
4453 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4454 # Therefore we must check for the error message as well as an
4455 # unsuccessful exit.
4456 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4457 # given a .adb file, but produce no object file.  So we must check
4458 # if an object file was really produced to guard against this.
4459 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4460 if test x"$errors" = x && test -f conftest.$ac_objext; then
4461   acx_cv_cc_gcc_supports_ada=yes
4462 fi
4463 rm -f conftest.*
4464 fi
4465 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4466 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4467
4468 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4469   have_gnat=yes
4470 else
4471   have_gnat=no
4472 fi
4473
4474 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4475 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4476 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4477   echo $ECHO_N "(cached) $ECHO_C" >&6
4478 else
4479    echo abfoo >t1
4480   echo cdfoo >t2
4481   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4482   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4483     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4484       :
4485     else
4486       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4487     fi
4488   fi
4489   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4490     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4491       :
4492     else
4493       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4494     fi
4495   fi
4496   rm t1 t2
4497
4498 fi
4499 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4500 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4501 do_compare="$gcc_cv_prog_cmp_skip"
4502
4503
4504
4505 # Check for GMP and MPFR
4506 gmplibs="-lmpfr -lgmp"
4507 gmpinc=
4508 have_gmp=no
4509
4510 # Specify a location for mpfr
4511 # check for this first so it ends up on the link line before gmp.
4512
4513 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4514 if test "${with_mpfr_dir+set}" = set; then
4515   withval="$with_mpfr_dir"
4516   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4517 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4518 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4519 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4520    { (exit 1); exit 1; }; }
4521 fi;
4522
4523
4524 # Check whether --with-mpfr or --without-mpfr was given.
4525 if test "${with_mpfr+set}" = set; then
4526   withval="$with_mpfr"
4527
4528 fi;
4529
4530 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4531 if test "${with_mpfr_include+set}" = set; then
4532   withval="$with_mpfr_include"
4533
4534 fi;
4535
4536 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4537 if test "${with_mpfr_lib+set}" = set; then
4538   withval="$with_mpfr_lib"
4539
4540 fi;
4541
4542 if test "x$with_mpfr" != x; then
4543   gmplibs="-L$with_mpfr/lib $gmplibs"
4544   gmpinc="-I$with_mpfr/include"
4545 fi
4546 if test "x$with_mpfr_include" != x; then
4547   gmpinc="-I$with_mpfr_include"
4548 fi
4549 if test "x$with_mpfr_lib" != x; then
4550   gmplibs="-L$with_mpfr_lib $gmplibs"
4551 fi
4552 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4553   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4554   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4555   # Do not test the mpfr version.  Assume that it is sufficient, since
4556   # it is in the source tree, and the library has not been built yet
4557   # but it would be included on the link line in the version check below
4558   # hence making the test fail.
4559   have_gmp=yes
4560 fi
4561
4562 # Specify a location for gmp
4563
4564 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4565 if test "${with_gmp_dir+set}" = set; then
4566   withval="$with_gmp_dir"
4567   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4568 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4569 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4570 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4571    { (exit 1); exit 1; }; }
4572 fi;
4573
4574
4575 # Check whether --with-gmp or --without-gmp was given.
4576 if test "${with_gmp+set}" = set; then
4577   withval="$with_gmp"
4578
4579 fi;
4580
4581 # Check whether --with-gmp_include or --without-gmp_include was given.
4582 if test "${with_gmp_include+set}" = set; then
4583   withval="$with_gmp_include"
4584
4585 fi;
4586
4587 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4588 if test "${with_gmp_lib+set}" = set; then
4589   withval="$with_gmp_lib"
4590
4591 fi;
4592
4593
4594 if test "x$with_gmp" != x; then
4595   gmplibs="-L$with_gmp/lib $gmplibs"
4596   gmpinc="-I$with_gmp/include $gmpinc"
4597 fi
4598 if test "x$with_gmp_include" != x; then
4599   gmpinc="-I$with_gmp_include $gmpinc"
4600 fi
4601 if test "x$with_gmp_lib" != x; then
4602   gmplibs="-L$with_gmp_lib $gmplibs"
4603 fi
4604 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4605   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4606   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4607   # Do not test the gmp version.  Assume that it is sufficient, since
4608   # it is in the source tree, and the library has not been built yet
4609   # but it would be included on the link line in the version check below
4610   # hence making the test fail.
4611   have_gmp=yes
4612 fi
4613
4614 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4615   have_gmp=yes
4616   saved_CFLAGS="$CFLAGS"
4617   CFLAGS="$CFLAGS $gmpinc"
4618   # Check GMP actually works
4619   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4620 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4621
4622 cat >conftest.$ac_ext <<_ACEOF
4623 /* confdefs.h.  */
4624 _ACEOF
4625 cat confdefs.h >>conftest.$ac_ext
4626 cat >>conftest.$ac_ext <<_ACEOF
4627 /* end confdefs.h.  */
4628 #include "gmp.h"
4629 int
4630 main ()
4631 {
4632
4633   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 2)
4634   choke me
4635   #endif
4636
4637   ;
4638   return 0;
4639 }
4640 _ACEOF
4641 rm -f conftest.$ac_objext
4642 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4643   (eval $ac_compile) 2>conftest.er1
4644   ac_status=$?
4645   grep -v '^ *+' conftest.er1 >conftest.err
4646   rm -f conftest.er1
4647   cat conftest.err >&5
4648   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4649   (exit $ac_status); } &&
4650          { ac_try='test -z "$ac_c_werror_flag"
4651                          || test ! -s conftest.err'
4652   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4653   (eval $ac_try) 2>&5
4654   ac_status=$?
4655   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4656   (exit $ac_status); }; } &&
4657          { ac_try='test -s conftest.$ac_objext'
4658   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4659   (eval $ac_try) 2>&5
4660   ac_status=$?
4661   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4662   (exit $ac_status); }; }; then
4663   echo "$as_me:$LINENO: result: yes" >&5
4664 echo "${ECHO_T}yes" >&6
4665 else
4666   echo "$as_me: failed program was:" >&5
4667 sed 's/^/| /' conftest.$ac_ext >&5
4668
4669 echo "$as_me:$LINENO: result: no" >&5
4670 echo "${ECHO_T}no" >&6; have_gmp=no
4671 fi
4672 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4673
4674   if test x"$have_gmp" = xyes; then
4675     saved_LIBS="$LIBS"
4676     LIBS="$LIBS $gmplibs"
4677         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4678 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4679     cat >conftest.$ac_ext <<_ACEOF
4680 /* confdefs.h.  */
4681 _ACEOF
4682 cat confdefs.h >>conftest.$ac_ext
4683 cat >>conftest.$ac_ext <<_ACEOF
4684 /* end confdefs.h.  */
4685 #include <gmp.h>
4686     #include <mpfr.h>
4687 int
4688 main ()
4689 {
4690
4691     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,1)
4692     choke me
4693     #endif
4694     mpfr_t n;
4695     mpfr_t x;
4696     int t;
4697     mpfr_init (n);
4698     mpfr_init (x);
4699     mpfr_atan2 (n, n, x, GMP_RNDN);
4700     mpfr_erfc (n, x, GMP_RNDN);
4701     mpfr_subnormalize (x, t, GMP_RNDN);
4702
4703   ;
4704   return 0;
4705 }
4706 _ACEOF
4707 rm -f conftest.$ac_objext conftest$ac_exeext
4708 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4709   (eval $ac_link) 2>conftest.er1
4710   ac_status=$?
4711   grep -v '^ *+' conftest.er1 >conftest.err
4712   rm -f conftest.er1
4713   cat conftest.err >&5
4714   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4715   (exit $ac_status); } &&
4716          { ac_try='test -z "$ac_c_werror_flag"
4717                          || test ! -s conftest.err'
4718   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4719   (eval $ac_try) 2>&5
4720   ac_status=$?
4721   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4722   (exit $ac_status); }; } &&
4723          { ac_try='test -s conftest$ac_exeext'
4724   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4725   (eval $ac_try) 2>&5
4726   ac_status=$?
4727   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4728   (exit $ac_status); }; }; then
4729   cat >conftest.$ac_ext <<_ACEOF
4730 /* confdefs.h.  */
4731 _ACEOF
4732 cat confdefs.h >>conftest.$ac_ext
4733 cat >>conftest.$ac_ext <<_ACEOF
4734 /* end confdefs.h.  */
4735 #include <gmp.h>
4736     #include <mpfr.h>
4737 int
4738 main ()
4739 {
4740
4741     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4742     choke me
4743     #endif
4744     mpfr_t n; mpfr_init(n);
4745
4746   ;
4747   return 0;
4748 }
4749 _ACEOF
4750 rm -f conftest.$ac_objext conftest$ac_exeext
4751 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4752   (eval $ac_link) 2>conftest.er1
4753   ac_status=$?
4754   grep -v '^ *+' conftest.er1 >conftest.err
4755   rm -f conftest.er1
4756   cat conftest.err >&5
4757   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4758   (exit $ac_status); } &&
4759          { ac_try='test -z "$ac_c_werror_flag"
4760                          || test ! -s conftest.err'
4761   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4762   (eval $ac_try) 2>&5
4763   ac_status=$?
4764   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4765   (exit $ac_status); }; } &&
4766          { ac_try='test -s conftest$ac_exeext'
4767   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4768   (eval $ac_try) 2>&5
4769   ac_status=$?
4770   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4771   (exit $ac_status); }; }; then
4772   echo "$as_me:$LINENO: result: yes" >&5
4773 echo "${ECHO_T}yes" >&6
4774 else
4775   echo "$as_me: failed program was:" >&5
4776 sed 's/^/| /' conftest.$ac_ext >&5
4777
4778 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4779 echo "${ECHO_T}buggy but acceptable" >&6
4780 fi
4781 rm -f conftest.err conftest.$ac_objext \
4782       conftest$ac_exeext conftest.$ac_ext
4783 else
4784   echo "$as_me: failed program was:" >&5
4785 sed 's/^/| /' conftest.$ac_ext >&5
4786
4787 echo "$as_me:$LINENO: result: no" >&5
4788 echo "${ECHO_T}no" >&6; have_gmp=no
4789 fi
4790 rm -f conftest.err conftest.$ac_objext \
4791       conftest$ac_exeext conftest.$ac_ext
4792       LIBS="$saved_LIBS"
4793   fi
4794   CFLAGS="$saved_CFLAGS"
4795
4796   if test x$have_gmp != xyes; then
4797     { { echo "$as_me:$LINENO: 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." >&5
4805 echo "$as_me: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
4806 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4807 Copies of these libraries' source code can be found at their respective
4808 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4809 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4810 If you obtained GMP and/or MPFR from a vendor distribution package, make
4811 sure that you have installed both the libraries and the header files.
4812 They may be located in separate packages." >&2;}
4813    { (exit 1); exit 1; }; }
4814   fi
4815 fi
4816
4817 # Flags needed for both GMP and/or MPFR
4818
4819
4820
4821 # Allow host libstdc++ to be specified for static linking with PPL.
4822
4823 # Check whether --with-host-libstdcxx or --without-host-libstdcxx was given.
4824 if test "${with_host_libstdcxx+set}" = set; then
4825   withval="$with_host_libstdcxx"
4826
4827 fi;
4828
4829 case $with_host_libstdcxx in
4830   no|yes)
4831     { { echo "$as_me:$LINENO: error: -with-host-libstdcxx needs an argument" >&5
4832 echo "$as_me: error: -with-host-libstdcxx needs an argument" >&2;}
4833    { (exit 1); exit 1; }; }
4834     ;;
4835 esac
4836
4837 # Check for PPL
4838 ppl_major_version=0
4839 ppl_minor_version=10
4840 ppllibs=" -lppl_c -lppl -lgmpxx $with_host_libstdcxx "
4841 pplinc=
4842
4843
4844 # Check whether --with-ppl or --without-ppl was given.
4845 if test "${with_ppl+set}" = set; then
4846   withval="$with_ppl"
4847
4848 fi;
4849
4850 # Check whether --with-ppl_include or --without-ppl_include was given.
4851 if test "${with_ppl_include+set}" = set; then
4852   withval="$with_ppl_include"
4853
4854 fi;
4855
4856 # Check whether --with-ppl_lib or --without-ppl_lib was given.
4857 if test "${with_ppl_lib+set}" = set; then
4858   withval="$with_ppl_lib"
4859
4860 fi;
4861
4862 case $with_ppl in
4863   no)
4864     ppllibs=
4865     ;;
4866   *)
4867     ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx $with_host_libstdcxx"
4868     pplinc="-I$with_ppl/include $pplinc"
4869     LIBS="$ppllibs $LIBS"
4870     ;;
4871 esac
4872 if test "x$with_ppl_include" != x; then
4873   pplinc="-I$with_ppl_include $pplinc"
4874 fi
4875 if test "x$with_ppl_lib" != x; then
4876   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx $with_host_libstdcxx"
4877   LIBS="$ppllibs $LIBS"
4878 fi
4879 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
4880   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '"$with_host_libstdcxx "
4881   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
4882   LIBS="$ppllibs $LIBS"
4883 fi
4884
4885 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
4886 if test "${enable_ppl_version_check+set}" = set; then
4887   enableval="$enable_ppl_version_check"
4888   ENABLE_PPL_CHECK=$enableval
4889 else
4890   ENABLE_PPL_CHECK=yes
4891 fi;
4892
4893 if test "${ENABLE_PPL_CHECK}" = "yes"; then
4894   saved_CFLAGS="$CFLAGS"
4895   CFLAGS="$CFLAGS $pplinc $gmpinc"
4896   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
4897 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
4898   cat >conftest.$ac_ext <<_ACEOF
4899 /* confdefs.h.  */
4900 _ACEOF
4901 cat confdefs.h >>conftest.$ac_ext
4902 cat >>conftest.$ac_ext <<_ACEOF
4903 /* end confdefs.h.  */
4904 #include "ppl_c.h"
4905 int
4906 main ()
4907 {
4908
4909   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
4910   choke me
4911   #endif
4912
4913   ;
4914   return 0;
4915 }
4916 _ACEOF
4917 rm -f conftest.$ac_objext
4918 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4919   (eval $ac_compile) 2>conftest.er1
4920   ac_status=$?
4921   grep -v '^ *+' conftest.er1 >conftest.err
4922   rm -f conftest.er1
4923   cat conftest.err >&5
4924   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4925   (exit $ac_status); } &&
4926          { ac_try='test -z "$ac_c_werror_flag"
4927                          || test ! -s conftest.err'
4928   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4929   (eval $ac_try) 2>&5
4930   ac_status=$?
4931   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4932   (exit $ac_status); }; } &&
4933          { ac_try='test -s conftest.$ac_objext'
4934   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4935   (eval $ac_try) 2>&5
4936   ac_status=$?
4937   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4938   (exit $ac_status); }; }; then
4939   echo "$as_me:$LINENO: result: yes" >&5
4940 echo "${ECHO_T}yes" >&6
4941 else
4942   echo "$as_me: failed program was:" >&5
4943 sed 's/^/| /' conftest.$ac_ext >&5
4944
4945 echo "$as_me:$LINENO: result: no" >&5
4946 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
4947 fi
4948 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4949   CFLAGS="$saved_CFLAGS"
4950 fi
4951
4952 # Flags needed for PPL
4953
4954
4955
4956
4957 # Check for CLOOG
4958 clooglibs=" -lcloog "
4959 clooginc=" -DCLOOG_PPL_BACKEND "
4960
4961
4962 # Check whether --with-cloog or --without-cloog was given.
4963 if test "${with_cloog+set}" = set; then
4964   withval="$with_cloog"
4965
4966 fi;
4967
4968 # Check whether --with-cloog_include or --without-cloog_include was given.
4969 if test "${with_cloog_include+set}" = set; then
4970   withval="$with_cloog_include"
4971
4972 fi;
4973
4974 # Check whether --with-cloog_lib or --without-cloog_lib was given.
4975 if test "${with_cloog_lib+set}" = set; then
4976   withval="$with_cloog_lib"
4977
4978 fi;
4979
4980 case $with_cloog in
4981   no)
4982     clooglibs=
4983     clooginc=
4984     ;;
4985   *)
4986     clooglibs="-L$with_cloog/lib -lcloog"
4987     clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
4988     LIBS="$clooglibs $LIBS"
4989     ;;
4990 esac
4991 if test "x$with_cloog_include" != x; then
4992   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
4993 fi
4994 if test "x$with_cloog_lib" != x; then
4995   clooglibs="-L$with_cloog_lib -lcloog"
4996   LIBS="$clooglibs $LIBS"
4997 fi
4998 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
4999   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
5000   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
5001   LIBS="$clooglibs $LIBS"
5002 fi
5003
5004 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
5005 if test "${enable_cloog_version_check+set}" = set; then
5006   enableval="$enable_cloog_version_check"
5007   ENABLE_CLOOG_CHECK=$enableval
5008 else
5009   ENABLE_CLOOG_CHECK=yes
5010 fi;
5011
5012 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
5013   saved_CFLAGS="$CFLAGS"
5014   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
5015   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
5016 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
5017   cat >conftest.$ac_ext <<_ACEOF
5018 /* confdefs.h.  */
5019 _ACEOF
5020 cat confdefs.h >>conftest.$ac_ext
5021 cat >>conftest.$ac_ext <<_ACEOF
5022 /* end confdefs.h.  */
5023 #include "cloog/cloog.h"
5024 int
5025 main ()
5026 {
5027
5028   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
5029   choke me
5030   #endif
5031
5032   ;
5033   return 0;
5034 }
5035 _ACEOF
5036 rm -f conftest.$ac_objext
5037 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5038   (eval $ac_compile) 2>conftest.er1
5039   ac_status=$?
5040   grep -v '^ *+' conftest.er1 >conftest.err
5041   rm -f conftest.er1
5042   cat conftest.err >&5
5043   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5044   (exit $ac_status); } &&
5045          { ac_try='test -z "$ac_c_werror_flag"
5046                          || test ! -s conftest.err'
5047   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5048   (eval $ac_try) 2>&5
5049   ac_status=$?
5050   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5051   (exit $ac_status); }; } &&
5052          { ac_try='test -s conftest.$ac_objext'
5053   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5054   (eval $ac_try) 2>&5
5055   ac_status=$?
5056   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5057   (exit $ac_status); }; }; then
5058   echo "$as_me:$LINENO: result: yes" >&5
5059 echo "${ECHO_T}yes" >&6
5060 else
5061   echo "$as_me: failed program was:" >&5
5062 sed 's/^/| /' conftest.$ac_ext >&5
5063
5064 echo "$as_me:$LINENO: result: no" >&5
5065 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5066 fi
5067 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5068   CFLAGS="$saved_CFLAGS"
5069 fi
5070
5071 # Flags needed for CLOOG
5072
5073
5074
5075
5076 # By default, C is the only stage 1 language.
5077 stage1_languages=,c,
5078
5079 # Figure out what language subdirectories are present.
5080 # Look if the user specified --enable-languages="..."; if not, use
5081 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5082 # go away some day.
5083 # NB:  embedded tabs in this IF block -- do not untabify
5084 if test -d ${srcdir}/gcc; then
5085   if test x"${enable_languages+set}" != xset; then
5086     if test x"${LANGUAGES+set}" = xset; then
5087       enable_languages="${LANGUAGES}"
5088         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5089     else
5090       enable_languages=all
5091     fi
5092   else
5093     if test x"${enable_languages}" = x ||
5094        test x"${enable_languages}" = xyes;
5095        then
5096       echo configure.in: --enable-languages needs at least one language argument 1>&2
5097       exit 1
5098     fi
5099   fi
5100   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5101
5102   # 'f95' is the old name for the 'fortran' language. We issue a warning
5103   # and make the substitution.
5104   case ,${enable_languages}, in
5105     *,f95,*)
5106       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5107       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5108       ;;
5109   esac
5110
5111   # First scan to see if an enabled language requires some other language.
5112   # We assume that a given config-lang.in will list all the language
5113   # front ends it requires, even if some are required indirectly.
5114   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5115     case ${lang_frag} in
5116       ..) ;;
5117       # The odd quoting in the next line works around
5118       # an apparent bug in bash 1.12 on linux.
5119       ${srcdir}/gcc/[*]/config-lang.in) ;;
5120       *)
5121         # From the config-lang.in, get $language, $lang_requires
5122         language=
5123         lang_requires=
5124         . ${lang_frag}
5125         for other in ${lang_requires} ; do
5126           case ,${enable_languages}, in
5127             *,$other,*) ;;
5128             *,all,*) ;;
5129             *,$language,*)
5130               echo " \`$other' language required by \`$language'; enabling" 1>&2
5131               enable_languages="${enable_languages},${other}"
5132               ;;
5133           esac
5134         done
5135         ;;
5136     esac
5137   done
5138
5139   new_enable_languages=,c,
5140   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5141   potential_languages=,c,
5142
5143   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5144     case ${lang_frag} in
5145       ..) ;;
5146       # The odd quoting in the next line works around
5147       # an apparent bug in bash 1.12 on linux.
5148       ${srcdir}/gcc/[*]/config-lang.in) ;;
5149       *)
5150         # From the config-lang.in, get $language, $target_libs,
5151         # $lang_dirs, $boot_language, and $build_by_default
5152         language=
5153         target_libs=
5154         lang_dirs=
5155         subdir_requires=
5156         boot_language=no
5157         build_by_default=yes
5158         . ${lang_frag}
5159         if test x${language} = x; then
5160           echo "${lang_frag} doesn't set \$language." 1>&2
5161           exit 1
5162         fi
5163
5164         case ,${enable_languages}, in
5165           *,${language},*)
5166             # Language was explicitly selected; include it.
5167             add_this_lang=yes
5168             ;;
5169           *,all,*)
5170             # 'all' was selected, select it if it is a default language
5171             add_this_lang=${build_by_default}
5172             ;;
5173           *)
5174             add_this_lang=no
5175             ;;
5176         esac
5177
5178         # Disable languages that need other directories if these aren't available.
5179         for i in $subdir_requires; do
5180           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5181           case ,${enable_languages}, in
5182             *,${language},*)
5183               # Specifically requested language; tell them.
5184               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5185 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5186    { (exit 1); exit 1; }; }
5187               ;;
5188             *)
5189               # Silently disable.
5190               add_this_lang=unsupported
5191               ;;
5192           esac
5193         done
5194
5195         # Disable Ada if no preexisting GNAT is available.
5196         case ,${enable_languages},:${language}:${have_gnat} in
5197           *,${language},*:ada:no)
5198             # Specifically requested language; tell them.
5199             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5200 echo "$as_me: error: GNAT is required to build $language" >&2;}
5201    { (exit 1); exit 1; }; }
5202             ;;
5203           *:ada:no)
5204             # Silently disable.
5205             add_this_lang=unsupported
5206             ;;
5207         esac
5208
5209         # Disable a language that is unsupported by the target.
5210         case " $unsupported_languages " in
5211           *" $language "*)
5212             add_this_lang=unsupported
5213             ;;
5214         esac
5215
5216         case $add_this_lang in
5217           unsupported)
5218             # Remove language-dependent dirs.
5219             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5220             ;;
5221           no)
5222             # Remove language-dependent dirs; still show language as supported.
5223             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5224             potential_languages="${potential_languages}${language},"
5225             ;;
5226           yes)
5227             new_enable_languages="${new_enable_languages}${language},"
5228             potential_languages="${potential_languages}${language},"
5229             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5230             case ${boot_language} in
5231               yes)
5232                 # Add to (comma-separated) list of stage 1 languages.
5233                 stage1_languages="${stage1_languages}${language},"
5234                 ;;
5235             esac
5236             ;;
5237         esac
5238         ;;
5239     esac
5240   done
5241
5242   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5243 if test "${enable_stage1_languages+set}" = set; then
5244   enableval="$enable_stage1_languages"
5245   case ,${enable_stage1_languages}, in
5246     ,no,|,,)
5247       # Set it to something that will have no effect in the loop below
5248       enable_stage1_languages=c ;;
5249     ,yes,)
5250       enable_stage1_languages=`echo $new_enable_languages | \
5251         sed -e "s/^,//" -e "s/,$//" ` ;;
5252     *,all,*)
5253       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5254         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5255   esac
5256
5257   # Add "good" languages from enable_stage1_languages to stage1_languages,
5258   # while "bad" languages go in missing_languages.  Leave no duplicates.
5259   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5260     case $potential_languages in
5261       *,$i,*)
5262         case $stage1_languages in
5263           *,$i,*) ;;
5264           *) stage1_languages="$stage1_languages$i," ;;
5265         esac ;;
5266       *)
5267         case $missing_languages in
5268           *,$i,*) ;;
5269           *) missing_languages="$missing_languages$i," ;;
5270         esac ;;
5271      esac
5272   done
5273 fi;
5274
5275   # Remove leading/trailing commas that were added for simplicity
5276   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5277   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5278   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5279   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5280
5281   if test "x$missing_languages" != x; then
5282     { { echo "$as_me:$LINENO: error:
5283 The following requested languages could not be built: ${missing_languages}
5284 Supported languages are: ${potential_languages}" >&5
5285 echo "$as_me: error:
5286 The following requested languages could not be built: ${missing_languages}
5287 Supported languages are: ${potential_languages}" >&2;}
5288    { (exit 1); exit 1; }; }
5289   fi
5290   if test "x$new_enable_languages" != "x$enable_languages"; then
5291     echo The following languages will be built: ${new_enable_languages}
5292     enable_languages="$new_enable_languages"
5293   fi
5294
5295
5296   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5297 fi
5298
5299 # Handle --disable-<component> generically.
5300 for dir in $configdirs $build_configdirs $target_configdirs ; do
5301   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5302   varname=`echo $dirname | sed -e s/+/_/g`
5303   if eval test x\${enable_${varname}} "=" xno ; then
5304     noconfigdirs="$noconfigdirs $dir"
5305   fi
5306 done
5307
5308 # Check for Boehm's garbage collector
5309 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5310 if test "${enable_objc_gc+set}" = set; then
5311   enableval="$enable_objc_gc"
5312   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5313   *,objc,*:*:yes:*target-boehm-gc*)
5314     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5315 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5316    { (exit 1); exit 1; }; }
5317     ;;
5318 esac
5319 fi;
5320
5321 # Make sure we only build Boehm's garbage collector if required.
5322 case ,${enable_languages},:${enable_objc_gc} in
5323   *,objc,*:yes)
5324     # Keep target-boehm-gc if requested for Objective-C.
5325     ;;
5326   *)
5327     # Otherwise remove target-boehm-gc depending on target-libjava.
5328     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5329       noconfigdirs="$noconfigdirs target-boehm-gc"
5330     fi
5331     ;;
5332 esac
5333
5334 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5335 # $build_configdirs and $target_configdirs.
5336 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5337
5338 notsupp=""
5339 for dir in . $skipdirs $noconfigdirs ; do
5340   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5341   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5342     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5343     if test -r $srcdir/$dirname/configure ; then
5344       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5345         true
5346       else
5347         notsupp="$notsupp $dir"
5348       fi
5349     fi
5350   fi
5351   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5352     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5353     if test -r $srcdir/$dirname/configure ; then
5354       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5355         true
5356       else
5357         notsupp="$notsupp $dir"
5358       fi
5359     fi
5360   fi
5361   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5362     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5363     if test -r $srcdir/$dirname/configure ; then
5364       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5365         true
5366       else
5367         notsupp="$notsupp $dir"
5368       fi
5369     fi
5370   fi
5371 done
5372
5373 # Sometimes the tools are distributed with libiberty but with no other
5374 # libraries.  In that case, we don't want to build target-libiberty.
5375 # Don't let libgcc imply libiberty either.
5376 if test -n "${target_configdirs}" ; then
5377   libgcc=
5378   others=
5379   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5380     if test "$i" = "libgcc"; then
5381       libgcc=target-libgcc
5382     elif test "$i" != "libiberty" ; then
5383       if test -r $srcdir/$i/configure ; then
5384         others=yes;
5385         break;
5386       fi
5387     fi
5388   done
5389   if test -z "${others}" ; then
5390     target_configdirs=$libgcc
5391   fi
5392 fi
5393
5394 # Quietly strip out all directories which aren't configurable in this tree.
5395 # This relies on all configurable subdirectories being autoconfiscated, which
5396 # is now the case.
5397 build_configdirs_all="$build_configdirs"
5398 build_configdirs=
5399 for i in ${build_configdirs_all} ; do
5400   j=`echo $i | sed -e s/build-//g`
5401   if test -f ${srcdir}/$j/configure ; then
5402     build_configdirs="${build_configdirs} $i"
5403   fi
5404 done
5405
5406 configdirs_all="$configdirs"
5407 configdirs=
5408 for i in ${configdirs_all} ; do
5409   if test -f ${srcdir}/$i/configure ; then
5410     configdirs="${configdirs} $i"
5411   fi
5412 done
5413
5414 target_configdirs_all="$target_configdirs"
5415 target_configdirs=
5416 for i in ${target_configdirs_all} ; do
5417   j=`echo $i | sed -e s/target-//g`
5418   if test -f ${srcdir}/$j/configure ; then
5419     target_configdirs="${target_configdirs} $i"
5420   fi
5421 done
5422
5423 # Produce a warning message for the subdirs we can't configure.
5424 # This isn't especially interesting in the Cygnus tree, but in the individual
5425 # FSF releases, it's important to let people know when their machine isn't
5426 # supported by the one or two programs in a package.
5427
5428 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5429   # If $appdirs is non-empty, at least one of those directories must still
5430   # be configured, or we error out.  (E.g., if the gas release supports a
5431   # specified target in some subdirs but not the gas subdir, we shouldn't
5432   # pretend that all is well.)
5433   if test -n "$appdirs" ; then
5434     for dir in $appdirs ; do
5435       if test -r $dir/Makefile.in ; then
5436         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5437           appdirs=""
5438           break
5439         fi
5440         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5441           appdirs=""
5442           break
5443         fi
5444       fi
5445     done
5446     if test -n "$appdirs" ; then
5447       echo "*** This configuration is not supported by this package." 1>&2
5448       exit 1
5449     fi
5450   fi
5451   # Okay, some application will build, or we don't care to check.  Still
5452   # notify of subdirs not getting built.
5453   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5454   echo "    ${notsupp}" 1>&2
5455   echo "    (Any other directories should still work fine.)" 1>&2
5456 fi
5457
5458 case "$host" in
5459   *msdosdjgpp*)
5460     enable_gdbtk=no ;;
5461 esac
5462
5463 # To find our prefix, in gcc_cv_tool_prefix.
5464
5465 # The user is always right.
5466 if test "${PATH_SEPARATOR+set}" != set; then
5467   echo "#! /bin/sh" >conf$$.sh
5468   echo  "exit 0"   >>conf$$.sh
5469   chmod +x conf$$.sh
5470   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5471     PATH_SEPARATOR=';'
5472   else
5473     PATH_SEPARATOR=:
5474   fi
5475   rm -f conf$$.sh
5476 fi
5477
5478
5479
5480 if test "x$exec_prefix" = xNONE; then
5481         if test "x$prefix" = xNONE; then
5482                 gcc_cv_tool_prefix=$ac_default_prefix
5483         else
5484                 gcc_cv_tool_prefix=$prefix
5485         fi
5486 else
5487         gcc_cv_tool_prefix=$exec_prefix
5488 fi
5489
5490 # If there is no compiler in the tree, use the PATH only.  In any
5491 # case, if there is no compiler in the tree nobody should use
5492 # AS_FOR_TARGET and LD_FOR_TARGET.
5493 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5494     gcc_version=`cat $srcdir/gcc/BASE-VER`
5495     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5496     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5497     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5498     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5499     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5500     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5501 else
5502     gcc_cv_tool_dirs=
5503 fi
5504
5505 if test x$build = x$target && test -n "$md_exec_prefix"; then
5506         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5507 fi
5508
5509
5510
5511 copy_dirs=
5512
5513
5514 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5515 if test "${with_build_sysroot+set}" = set; then
5516   withval="$with_build_sysroot"
5517   if test x"$withval" != x ; then
5518      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5519    fi
5520 else
5521   SYSROOT_CFLAGS_FOR_TARGET=
5522 fi;
5523
5524
5525
5526 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5527 if test "${with_debug_prefix_map+set}" = set; then
5528   withval="$with_debug_prefix_map"
5529   if test x"$withval" != x; then
5530      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5531      for debug_map in $withval; do
5532        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5533      done
5534    fi
5535 else
5536   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5537 fi;
5538
5539
5540 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5541 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5542 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5543 # We want to ensure that TARGET libraries (which we know are built with
5544 # gcc) are built with "-O2 -g", so include those options when setting
5545 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5546 if test "x$CFLAGS_FOR_TARGET" = x; then
5547   CFLAGS_FOR_TARGET=$CFLAGS
5548   case " $CFLAGS " in
5549     *" -O2 "*) ;;
5550     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5551   esac
5552   case " $CFLAGS " in
5553     *" -g "* | *" -g3 "*) ;;
5554     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5555   esac
5556 fi
5557
5558
5559 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5560   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5561   case " $CXXFLAGS " in
5562     *" -O2 "*) ;;
5563     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5564   esac
5565   case " $CXXFLAGS " in
5566     *" -g "* | *" -g3 "*) ;;
5567     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5568   esac
5569 fi
5570
5571
5572 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5573 # the named directory are copied to $(tooldir)/sys-include.
5574 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5575   if test x${is_cross_compiler} = xno ; then
5576     echo 1>&2 '***' --with-headers is only supported when cross compiling
5577     exit 1
5578   fi
5579   if test x"${with_headers}" != xyes ; then
5580     x=${gcc_cv_tool_prefix}
5581     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5582   fi
5583 fi
5584
5585 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5586 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5587 # are permitted.
5588 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5589   if test x${is_cross_compiler} = xno ; then
5590     echo 1>&2 '***' --with-libs is only supported when cross compiling
5591     exit 1
5592   fi
5593   if test x"${with_libs}" != xyes ; then
5594     # Copy the libraries in reverse order, so that files in the first named
5595     # library override files in subsequent libraries.
5596     x=${gcc_cv_tool_prefix}
5597     for l in ${with_libs}; do
5598       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5599     done
5600   fi
5601 fi
5602
5603 # Set with_gnu_as and with_gnu_ld as appropriate.
5604 #
5605 # This is done by determining whether or not the appropriate directory
5606 # is available, and by checking whether or not specific configurations
5607 # have requested that this magic not happen.
5608 #
5609 # The command line options always override the explicit settings in
5610 # configure.in, and the settings in configure.in override this magic.
5611 #
5612 # If the default for a toolchain is to use GNU as and ld, and you don't
5613 # want to do that, then you should use the --without-gnu-as and
5614 # --without-gnu-ld options for the configure script.
5615
5616 if test x${use_gnu_as} = x &&
5617    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5618   with_gnu_as=yes
5619   extra_host_args="$extra_host_args --with-gnu-as"
5620 fi
5621
5622 if test x${use_gnu_ld} = x &&
5623    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5624   with_gnu_ld=yes
5625   extra_host_args="$extra_host_args --with-gnu-ld"
5626 fi
5627
5628 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5629 # can detect this case.
5630
5631 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5632   with_newlib=yes
5633   extra_host_args="$extra_host_args --with-newlib"
5634 fi
5635
5636 # Handle ${copy_dirs}
5637 set fnord ${copy_dirs}
5638 shift
5639 while test $# != 0 ; do
5640   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5641     :
5642   else
5643     echo Copying $1 to $2
5644
5645     # Use the install script to create the directory and all required
5646     # parent directories.
5647     if test -d $2 ; then
5648       :
5649     else
5650       echo >config.temp
5651       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5652     fi
5653
5654     # Copy the directory, assuming we have tar.
5655     # FIXME: Should we use B in the second tar?  Not all systems support it.
5656     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5657
5658     # It is the responsibility of the user to correctly adjust all
5659     # symlinks.  If somebody can figure out how to handle them correctly
5660     # here, feel free to add the code.
5661
5662     echo $1 > $2/COPIED
5663   fi
5664   shift; shift
5665 done
5666
5667 # Determine a target-dependent exec_prefix that the installed
5668 # gcc will search in.  Keep this list sorted by triplet, with
5669 # the *-*-osname triplets last.
5670 md_exec_prefix=
5671 case "${target}" in
5672   alpha*-*-*vms*)
5673     md_exec_prefix=/gnu/lib/gcc-lib
5674     ;;
5675   i[34567]86-pc-msdosdjgpp*)
5676     md_exec_prefix=/dev/env/DJDIR/bin
5677     ;;
5678   i[34567]86-*-sco3.2v5*)
5679     if test $with_gnu_as = yes; then
5680       md_exec_prefix=/usr/gnu/bin
5681     else
5682       md_exec_prefix=/usr/ccs/bin/elf
5683     fi
5684     ;;
5685
5686   mn10300-*-* | \
5687   powerpc-*-chorusos* | \
5688   powerpc*-*-eabi* | \
5689   powerpc*-*-sysv* | \
5690   powerpc*-*-kaos* | \
5691   s390x-ibm-tpf*)
5692     md_exec_prefix=/usr/ccs/bin
5693     ;;
5694   sparc64-*-elf*)
5695     ;;
5696   v850*-*-*)
5697     md_exec_prefix=/usr/ccs/bin
5698     ;;
5699   xtensa*-*-elf*)
5700     ;;
5701
5702   *-*-beos* | \
5703   *-*-elf* | \
5704   *-*-hpux* | \
5705   *-*-netware* | \
5706   *-*-nto-qnx* | \
5707   *-*-rtems* | \
5708   *-*-solaris2* | \
5709   *-*-sysv[45]* | \
5710   *-*-vxworks* | \
5711   *-wrs-windiss)
5712     md_exec_prefix=/usr/ccs/bin
5713     ;;
5714 esac
5715
5716 extra_arflags_for_target=
5717 extra_nmflags_for_target=
5718 extra_ranlibflags_for_target=
5719 target_makefile_frag=/dev/null
5720 case "${target}" in
5721   mep*-*-*)
5722     target_makefile_frag="config/mt-mep"
5723     ;;
5724   spu-*-*)
5725     target_makefile_frag="config/mt-spu"
5726     ;;
5727   mips*-sde-elf*)
5728     target_makefile_frag="config/mt-sde"
5729     ;;
5730   mipsisa*-*-elfoabi*)
5731     target_makefile_frag="config/mt-mips-elfoabi"
5732     ;;
5733   mips*-*-*linux* | mips*-*-gnu*)
5734     target_makefile_frag="config/mt-mips-gnu"
5735     ;;
5736   *-*-netware*)
5737     target_makefile_frag="config/mt-netware"
5738     ;;
5739   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
5740     target_makefile_frag="config/mt-gnu"
5741     ;;
5742   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5743     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5744     # commands to handle both 32-bit and 64-bit objects.  These flags are
5745     # harmless if we're using GNU nm or ar.
5746     extra_arflags_for_target=" -X32_64"
5747     extra_nmflags_for_target=" -B -X32_64"
5748     ;;
5749   *-*-darwin*)
5750     # ranlib from Darwin requires the -c flag to look at common symbols.
5751     extra_ranlibflags_for_target=" -c"
5752     ;;
5753   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5754     target_makefile_frag="config/mt-wince"
5755     ;;
5756 esac
5757
5758 alphaieee_frag=/dev/null
5759 case $target in
5760   alpha*-*-*)
5761     # This just makes sure to use the -mieee option to build target libs.
5762     # This should probably be set individually by each library.
5763     alphaieee_frag="config/mt-alphaieee"
5764     ;;
5765 esac
5766
5767 # If --enable-target-optspace always use -Os instead of -O2 to build
5768 # the target libraries, similarly if it is not specified, use -Os
5769 # on selected platforms.
5770 ospace_frag=/dev/null
5771 case "${enable_target_optspace}:${target}" in
5772   yes:*)
5773     ospace_frag="config/mt-ospace"
5774     ;;
5775   :d30v-*)
5776     ospace_frag="config/mt-d30v"
5777     ;;
5778   :m32r-* | :d10v-* | :fr30-*)
5779     ospace_frag="config/mt-ospace"
5780     ;;
5781   no:* | :*)
5782     ;;
5783   *)
5784     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5785     ;;
5786 esac
5787
5788 # Default to using --with-stabs for certain targets.
5789 if test x${with_stabs} = x ; then
5790   case "${target}" in
5791   mips*-*-irix[56]*)
5792     ;;
5793   mips*-*-* | alpha*-*-osf*)
5794     with_stabs=yes;
5795     extra_host_args="${extra_host_args} --with-stabs"
5796     ;;
5797   esac
5798 fi
5799
5800 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5801 # them automatically.
5802 case "${host}" in
5803   hppa*64*-*-hpux11*)
5804     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5805     ;;
5806 esac
5807
5808 # Some systems (e.g., one of the i386-aix systems the gas testers are
5809 # using) don't handle "\$" correctly, so don't use it here.
5810 tooldir='${exec_prefix}'/${target_noncanonical}
5811 build_tooldir=${tooldir}
5812
5813 # Create a .gdbinit file which runs the one in srcdir
5814 # and tells GDB to look there for source files.
5815
5816 if test -r ${srcdir}/.gdbinit ; then
5817   case ${srcdir} in
5818     .) ;;
5819     *) cat > ./.gdbinit <<EOF
5820 # ${NO_EDIT}
5821 dir ${srcdir}
5822 dir .
5823 source ${srcdir}/.gdbinit
5824 EOF
5825     ;;
5826   esac
5827 fi
5828
5829 # Make sure that the compiler is able to generate an executable.  If it
5830 # can't, we are probably in trouble.  We don't care whether we can run the
5831 # executable--we might be using a cross compiler--we only care whether it
5832 # can be created.  At this point the main configure script has set CC.
5833 we_are_ok=no
5834 echo "int main () { return 0; }" > conftest.c
5835 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5836 if test $? = 0 ; then
5837   if test -s conftest || test -s conftest.exe ; then
5838     we_are_ok=yes
5839   fi
5840 fi
5841 case $we_are_ok in
5842   no)
5843     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5844     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5845     rm -f conftest*
5846     exit 1
5847     ;;
5848 esac
5849 rm -f conftest*
5850
5851 # The Solaris /usr/ucb/cc compiler does not appear to work.
5852 case "${host}" in
5853   sparc-sun-solaris2*)
5854       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5855       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5856           could_use=
5857           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5858           if test -d /opt/cygnus/bin ; then
5859               if test "$could_use" = "" ; then
5860                   could_use="/opt/cygnus/bin"
5861               else
5862                   could_use="$could_use or /opt/cygnus/bin"
5863               fi
5864           fi
5865         if test "$could_use" = "" ; then
5866             echo "Warning: compilation may fail because you're using"
5867             echo "/usr/ucb/cc.  You should change your PATH or CC "
5868             echo "variable and rerun configure."
5869         else
5870             echo "Warning: compilation may fail because you're using"
5871             echo "/usr/ucb/cc, when you should use the C compiler from"
5872             echo "$could_use.  You should change your"
5873             echo "PATH or CC variable and rerun configure."
5874         fi
5875       fi
5876   ;;
5877 esac
5878
5879 # Decide which environment variable is used to find dynamic libraries.
5880 case "${host}" in
5881   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5882   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5883   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
5884   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5885 esac
5886
5887 # On systems where the dynamic library environment variable is PATH,
5888 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
5889 # built executables to PATH.
5890 if test "$RPATH_ENVVAR" = PATH; then
5891   GCC_SHLIB_SUBDIR=/shlib
5892 else
5893   GCC_SHLIB_SUBDIR=
5894 fi
5895
5896 # Record target_configdirs and the configure arguments for target and
5897 # build configuration in Makefile.
5898 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5899 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5900
5901 # Determine whether gdb needs tk/tcl or not.
5902 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5903 # and in that case we want gdb to be built without tk.  Ugh!
5904 # In fact I believe gdb is the *only* package directly dependent on tk,
5905 # so we should be able to put the 'maybe's in unconditionally and
5906 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5907 # 100% sure that that's safe though.
5908
5909 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5910 case "$enable_gdbtk" in
5911   no)
5912     GDB_TK="" ;;
5913   yes)
5914     GDB_TK="${gdb_tk}" ;;
5915   *)
5916     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5917     # distro.  Eventually someone will fix this and move Insight, nee
5918     # gdbtk to a separate directory.
5919     if test -d ${srcdir}/gdb/gdbtk ; then
5920       GDB_TK="${gdb_tk}"
5921     else
5922       GDB_TK=""
5923     fi
5924     ;;
5925 esac
5926 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5927 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5928
5929 # Strip out unwanted targets.
5930
5931 # While at that, we remove Makefiles if we were started for recursive
5932 # configuration, so that the top-level Makefile reconfigures them,
5933 # like we used to do when configure itself was recursive.
5934
5935 # Loop over modules.  $extrasub must be used with care, limiting as
5936 # much as possible the usage of range addresses.  That's because autoconf
5937 # splits the sed script to overcome limits in the number of commands,
5938 # and relying on carefully-timed sed passes may turn out to be very hard
5939 # to maintain later.  In this particular case, you just have to be careful
5940 # not to nest @if/@endif pairs, because configure will not warn you at all.
5941
5942 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5943 if test "${enable_bootstrap+set}" = set; then
5944   enableval="$enable_bootstrap"
5945
5946 else
5947   enable_bootstrap=default
5948 fi;
5949
5950 # Issue errors and warnings for invalid/strange bootstrap combinations.
5951 case "$configdirs" in
5952   *gcc*) have_compiler=yes ;;
5953   *) have_compiler=no ;;
5954 esac
5955
5956 case "$have_compiler:$host:$target:$enable_bootstrap" in
5957   *:*:*:no) ;;
5958
5959   # Default behavior.  Enable bootstrap if we have a compiler
5960   # and we are in a native configuration.
5961   yes:$build:$build:default)
5962     enable_bootstrap=yes ;;
5963
5964   *:*:*:default)
5965     enable_bootstrap=no ;;
5966
5967   # We have a compiler and we are in a native configuration, bootstrap is ok
5968   yes:$build:$build:yes)
5969     ;;
5970
5971   # Other configurations, but we have a compiler.  Assume the user knows
5972   # what he's doing.
5973   yes:*:*:yes)
5974     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5975 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5976     ;;
5977
5978   # No compiler: if they passed --enable-bootstrap explicitly, fail
5979   no:*:*:yes)
5980     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5981 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5982    { (exit 1); exit 1; }; } ;;
5983
5984   # Fail if wrong command line
5985   *)
5986     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5987 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5988    { (exit 1); exit 1; }; }
5989     ;;
5990 esac
5991
5992 # Adjust the toplevel makefile according to whether bootstrap was selected.
5993 case "$enable_bootstrap" in
5994   yes)
5995     bootstrap_suffix=bootstrap ;;
5996   no)
5997     bootstrap_suffix=no-bootstrap ;;
5998 esac
5999
6000 for module in ${build_configdirs} ; do
6001   if test -z "${no_recursion}" \
6002      && test -f ${build_subdir}/${module}/Makefile; then
6003     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
6004     rm -f ${build_subdir}/${module}/Makefile
6005   fi
6006   extrasub="$extrasub
6007 /^@if build-$module\$/d
6008 /^@endif build-$module\$/d
6009 /^@if build-$module-$bootstrap_suffix\$/d
6010 /^@endif build-$module-$bootstrap_suffix\$/d"
6011 done
6012 for module in ${configdirs} ; do
6013   if test -z "${no_recursion}"; then
6014     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
6015       if test -f ${file}; then
6016         echo 1>&2 "*** removing ${file} to force reconfigure"
6017         rm -f ${file}
6018       fi
6019     done
6020   fi
6021   extrasub="$extrasub
6022 /^@if $module\$/d
6023 /^@endif $module\$/d
6024 /^@if $module-$bootstrap_suffix\$/d
6025 /^@endif $module-$bootstrap_suffix\$/d"
6026 done
6027 for module in ${target_configdirs} ; do
6028   if test -z "${no_recursion}" \
6029      && test -f ${target_subdir}/${module}/Makefile; then
6030     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6031     rm -f ${target_subdir}/${module}/Makefile
6032   fi
6033   extrasub="$extrasub
6034 /^@if target-$module\$/d
6035 /^@endif target-$module\$/d
6036 /^@if target-$module-$bootstrap_suffix\$/d
6037 /^@endif target-$module-$bootstrap_suffix\$/d"
6038 done
6039
6040 extrasub="$extrasub
6041 /^@if /,/^@endif /d"
6042
6043 # Create the serialization dependencies.  This uses a temporary file.
6044
6045 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6046 if test "${enable_serial_configure+set}" = set; then
6047   enableval="$enable_serial_configure"
6048
6049 fi;
6050
6051 case ${enable_serial_configure} in
6052   yes)
6053     enable_serial_build_configure=yes
6054     enable_serial_host_configure=yes
6055     enable_serial_target_configure=yes
6056     ;;
6057 esac
6058
6059 # These force 'configure's to be done one at a time, to avoid problems
6060 # with contention over a shared config.cache.
6061 rm -f serdep.tmp
6062 echo '# serdep.tmp' > serdep.tmp
6063 olditem=
6064 test "x${enable_serial_build_configure}" = xyes &&
6065 for item in ${build_configdirs} ; do
6066   case ${olditem} in
6067     "") ;;
6068     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6069   esac
6070   olditem=${item}
6071 done
6072 olditem=
6073 test "x${enable_serial_host_configure}" = xyes &&
6074 for item in ${configdirs} ; do
6075   case ${olditem} in
6076     "") ;;
6077     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6078   esac
6079   olditem=${item}
6080 done
6081 olditem=
6082 test "x${enable_serial_target_configure}" = xyes &&
6083 for item in ${target_configdirs} ; do
6084   case ${olditem} in
6085     "") ;;
6086     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6087   esac
6088   olditem=${item}
6089 done
6090 serialization_dependencies=serdep.tmp
6091
6092
6093 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6094 # target, nonopt, and variable assignments.  These are the ones we
6095 # might not want to pass down to subconfigures.  Also strip
6096 # program-prefix, program-suffix, and program-transform-name, so that
6097 # we can pass down a consistent program-transform-name.
6098 baseargs=
6099 keep_next=no
6100 skip_next=no
6101 eval "set -- $ac_configure_args"
6102 for ac_arg
6103 do
6104   if test X"$skip_next" = X"yes"; then
6105     skip_next=no
6106     continue
6107   fi
6108   if test X"$keep_next" = X"yes"; then
6109     case $ac_arg in
6110       *\'*)
6111         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6112     esac
6113     baseargs="$baseargs '$ac_arg'"
6114     keep_next=no
6115     continue
6116   fi
6117
6118   # Handle separated arguments.  Based on the logic generated by
6119   # autoconf 2.59.
6120   case $ac_arg in
6121     *=* | --config-cache | -C | -disable-* | --disable-* \
6122       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6123       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6124       | -with-* | --with-* | -without-* | --without-* | --x)
6125       separate_arg=no
6126       ;;
6127     -*)
6128       separate_arg=yes
6129       ;;
6130     *)
6131       separate_arg=no
6132       ;;
6133   esac
6134
6135   case "$ac_arg" in
6136     --no*)
6137       continue
6138       ;;
6139     --c* | \
6140     --sr* | \
6141     --ho* | \
6142     --bu* | \
6143     --t* | \
6144     --program-* | \
6145     -cache_file* | \
6146     -srcdir* | \
6147     -host* | \
6148     -build* | \
6149     -target* | \
6150     -program-prefix* | \
6151     -program-suffix* | \
6152     -program-transform-name* )
6153       skip_next=$separate_arg
6154       continue
6155       ;;
6156     -*)
6157       # An option.  Add it.
6158       case $ac_arg in
6159         *\'*)
6160           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6161       esac
6162       baseargs="$baseargs '$ac_arg'"
6163       keep_next=$separate_arg
6164       ;;
6165     *)
6166       # Either a variable assignment, or a nonopt (triplet).  Don't
6167       # pass it down; let the Makefile handle this.
6168       continue
6169       ;;
6170   esac
6171 done
6172 # Remove the initial space we just introduced and, as these will be
6173 # expanded by make, quote '$'.
6174 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6175
6176 # Add in --program-transform-name, after --program-prefix and
6177 # --program-suffix have been applied to it.  Autoconf has already
6178 # doubled dollar signs and backslashes in program_transform_name; we want
6179 # the backslashes un-doubled, and then the entire thing wrapped in single
6180 # quotes, because this will be expanded first by make and then by the shell.
6181 # Also, because we want to override the logic in subdir configure scripts to
6182 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6183 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6184 ${program_transform_name}
6185 EOF_SED
6186 gcc_transform_name=`cat conftestsed.out`
6187 rm -f conftestsed.out
6188 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6189 if test "$silent" = yes; then
6190   baseargs="$baseargs --silent"
6191 fi
6192
6193 # For the build-side libraries, we just need to pretend we're native,
6194 # and not use the same cache file.  Multilibs are neither needed nor
6195 # desired.
6196 build_configargs="--cache-file=../config.cache ${baseargs}"
6197
6198 # For host modules, accept cache file option, or specification as blank.
6199 case "${cache_file}" in
6200 "") # empty
6201   cache_file_option="" ;;
6202 /* | [A-Za-z]:[\\/]* ) # absolute path
6203   cache_file_option="--cache-file=${cache_file}" ;;
6204 *) # relative path
6205   cache_file_option="--cache-file=../${cache_file}" ;;
6206 esac
6207
6208 # Host dirs don't like to share a cache file either, horribly enough.
6209 # This seems to be due to autoconf 2.5x stupidity.
6210 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6211
6212 target_configargs=${baseargs}
6213
6214 # Passing a --with-cross-host argument lets the target libraries know
6215 # whether they are being built with a cross-compiler or being built
6216 # native.  However, it would be better to use other mechanisms to make the
6217 # sorts of decisions they want to make on this basis.  Please consider
6218 # this option to be deprecated.  FIXME.
6219 if test x${is_cross_compiler} = xyes ; then
6220   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6221 fi
6222
6223 # Default to --enable-multilib.
6224 if test x${enable_multilib} = x ; then
6225   target_configargs="--enable-multilib ${target_configargs}"
6226 fi
6227
6228 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6229 # changed from the earlier setting of with_newlib.
6230 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6231   target_configargs="--with-newlib ${target_configargs}"
6232 fi
6233
6234 # Different target subdirs use different values of certain variables
6235 # (notably CXX).  Worse, multilibs use *lots* of different values.
6236 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6237 # it doesn't automatically accept command-line overrides of them.
6238 # This means it's not safe for target subdirs to share a cache file,
6239 # which is disgusting, but there you have it.  Hopefully this can be
6240 # fixed in future.  It's still worthwhile to use a cache file for each
6241 # directory.  I think.
6242
6243 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6244 # We need to pass --target, as newer autoconf's requires consistency
6245 # for target_alias and gcc doesn't manage it consistently.
6246 target_configargs="--cache-file=./config.cache ${target_configargs}"
6247
6248 FLAGS_FOR_TARGET=
6249 case " $target_configdirs " in
6250  *" newlib "*)
6251   case " $target_configargs " in
6252   *" --with-newlib "*)
6253    case "$target" in
6254    *-cygwin*)
6255      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' ;;
6256    esac
6257
6258    # If we're not building GCC, don't discard standard headers.
6259    if test -d ${srcdir}/gcc; then
6260      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6261
6262      if test "${build}" != "${host}"; then
6263        # On Canadian crosses, CC_FOR_TARGET will have already been set
6264        # by `configure', so we won't have an opportunity to add -Bgcc/
6265        # to it.  This is right: we don't want to search that directory
6266        # for binaries, but we want the header files in there, so add
6267        # them explicitly.
6268        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6269
6270        # Someone might think of using the pre-installed headers on
6271        # Canadian crosses, in case the installed compiler is not fully
6272        # compatible with the compiler being built.  In this case, it
6273        # would be better to flag an error than risking having
6274        # incompatible object files being constructed.  We can't
6275        # guarantee that an error will be flagged, but let's hope the
6276        # compiler will do it, when presented with incompatible header
6277        # files.
6278      fi
6279    fi
6280
6281    case "${target}-${is_cross_compiler}" in
6282    i[3456789]86-*-linux*-no)
6283       # Here host == target, so we don't need to build gcc,
6284       # so we don't want to discard standard headers.
6285       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6286       ;;
6287    *)
6288       # If we're building newlib, use its generic headers last, but search
6289       # for any libc-related directories first (so make it the last -B
6290       # switch).
6291       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6292
6293       # If we're building libgloss, find the startup file, simulator library
6294       # and linker script.
6295       case " $target_configdirs " in
6296         *" libgloss "*)
6297         # Look for startup file, simulator library and maybe linker script.
6298         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6299         # Look for libnosys.a in case the target needs it.
6300         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6301         # Most targets have the linker script in the source directory.
6302         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6303         ;;
6304       esac
6305       ;;
6306    esac
6307    ;;
6308   esac
6309   ;;
6310 esac
6311 case "$target" in
6312 *-mingw*)
6313   # Can't be handled as Cygwin above since Mingw does not use newlib.
6314   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' ;;
6315 esac
6316
6317 # Allow the user to override the flags for
6318 # our build compiler if desired.
6319 if test x"${build}" = x"${host}" ; then
6320   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6321   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6322   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6323 fi
6324
6325 # On Canadian crosses, we'll be searching the right directories for
6326 # the previously-installed cross compiler, so don't bother to add
6327 # flags for directories within the install tree of the compiler
6328 # being built; programs in there won't even run.
6329 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6330   # Search for pre-installed headers if nothing else fits.
6331   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6332 fi
6333
6334 if test "x${use_gnu_ld}" = x &&
6335    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6336   # Arrange for us to find uninstalled linker scripts.
6337   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6338 fi
6339
6340 # Search for other target-specific linker scripts and such.
6341 case "${target}" in
6342   mep*)
6343     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6344     ;;
6345 esac
6346
6347 # Makefile fragments.
6348 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6349 do
6350   eval fragval=\$$frag
6351   if test $fragval != /dev/null; then
6352     eval $frag=${srcdir}/$fragval
6353   fi
6354 done
6355
6356
6357
6358
6359
6360 # Miscellanea: directories, flags, etc.
6361
6362
6363
6364
6365
6366
6367
6368
6369 # Build module lists & subconfigure args.
6370
6371
6372
6373 # Host module lists & subconfigure args.
6374
6375
6376
6377 # Target module lists & subconfigure args.
6378
6379
6380
6381 # Build tools.
6382
6383
6384
6385
6386
6387
6388
6389
6390
6391
6392
6393
6394
6395
6396
6397
6398
6399 # Generate default definitions for YACC, M4, LEX and other programs that run
6400 # on the build machine.  These are used if the Makefile can't locate these
6401 # programs in objdir.
6402 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6403
6404 for ac_prog in 'bison -y' byacc yacc
6405 do
6406   # Extract the first word of "$ac_prog", so it can be a program name with args.
6407 set dummy $ac_prog; ac_word=$2
6408 echo "$as_me:$LINENO: checking for $ac_word" >&5
6409 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6410 if test "${ac_cv_prog_YACC+set}" = set; then
6411   echo $ECHO_N "(cached) $ECHO_C" >&6
6412 else
6413   if test -n "$YACC"; then
6414   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6415 else
6416 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6417 for as_dir in $PATH
6418 do
6419   IFS=$as_save_IFS
6420   test -z "$as_dir" && as_dir=.
6421   for ac_exec_ext in '' $ac_executable_extensions; do
6422   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6423     ac_cv_prog_YACC="$ac_prog"
6424     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6425     break 2
6426   fi
6427 done
6428 done
6429
6430 fi
6431 fi
6432 YACC=$ac_cv_prog_YACC
6433 if test -n "$YACC"; then
6434   echo "$as_me:$LINENO: result: $YACC" >&5
6435 echo "${ECHO_T}$YACC" >&6
6436 else
6437   echo "$as_me:$LINENO: result: no" >&5
6438 echo "${ECHO_T}no" >&6
6439 fi
6440
6441   test -n "$YACC" && break
6442 done
6443 test -n "$YACC" || YACC="$MISSING bison -y"
6444
6445 case " $build_configdirs " in
6446   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6447   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6448 esac
6449
6450 for ac_prog in bison
6451 do
6452   # Extract the first word of "$ac_prog", so it can be a program name with args.
6453 set dummy $ac_prog; ac_word=$2
6454 echo "$as_me:$LINENO: checking for $ac_word" >&5
6455 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6456 if test "${ac_cv_prog_BISON+set}" = set; then
6457   echo $ECHO_N "(cached) $ECHO_C" >&6
6458 else
6459   if test -n "$BISON"; then
6460   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6461 else
6462 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6463 for as_dir in $PATH
6464 do
6465   IFS=$as_save_IFS
6466   test -z "$as_dir" && as_dir=.
6467   for ac_exec_ext in '' $ac_executable_extensions; do
6468   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6469     ac_cv_prog_BISON="$ac_prog"
6470     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6471     break 2
6472   fi
6473 done
6474 done
6475
6476 fi
6477 fi
6478 BISON=$ac_cv_prog_BISON
6479 if test -n "$BISON"; then
6480   echo "$as_me:$LINENO: result: $BISON" >&5
6481 echo "${ECHO_T}$BISON" >&6
6482 else
6483   echo "$as_me:$LINENO: result: no" >&5
6484 echo "${ECHO_T}no" >&6
6485 fi
6486
6487   test -n "$BISON" && break
6488 done
6489 test -n "$BISON" || BISON="$MISSING bison"
6490
6491 case " $build_configdirs " in
6492   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6493 esac
6494
6495 for ac_prog in gm4 gnum4 m4
6496 do
6497   # Extract the first word of "$ac_prog", so it can be a program name with args.
6498 set dummy $ac_prog; ac_word=$2
6499 echo "$as_me:$LINENO: checking for $ac_word" >&5
6500 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6501 if test "${ac_cv_prog_M4+set}" = set; then
6502   echo $ECHO_N "(cached) $ECHO_C" >&6
6503 else
6504   if test -n "$M4"; then
6505   ac_cv_prog_M4="$M4" # Let the user override the test.
6506 else
6507 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6508 for as_dir in $PATH
6509 do
6510   IFS=$as_save_IFS
6511   test -z "$as_dir" && as_dir=.
6512   for ac_exec_ext in '' $ac_executable_extensions; do
6513   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6514     ac_cv_prog_M4="$ac_prog"
6515     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6516     break 2
6517   fi
6518 done
6519 done
6520
6521 fi
6522 fi
6523 M4=$ac_cv_prog_M4
6524 if test -n "$M4"; then
6525   echo "$as_me:$LINENO: result: $M4" >&5
6526 echo "${ECHO_T}$M4" >&6
6527 else
6528   echo "$as_me:$LINENO: result: no" >&5
6529 echo "${ECHO_T}no" >&6
6530 fi
6531
6532   test -n "$M4" && break
6533 done
6534 test -n "$M4" || M4="$MISSING m4"
6535
6536 case " $build_configdirs " in
6537   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6538 esac
6539
6540 for ac_prog in flex lex
6541 do
6542   # Extract the first word of "$ac_prog", so it can be a program name with args.
6543 set dummy $ac_prog; ac_word=$2
6544 echo "$as_me:$LINENO: checking for $ac_word" >&5
6545 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6546 if test "${ac_cv_prog_LEX+set}" = set; then
6547   echo $ECHO_N "(cached) $ECHO_C" >&6
6548 else
6549   if test -n "$LEX"; then
6550   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6551 else
6552 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6553 for as_dir in $PATH
6554 do
6555   IFS=$as_save_IFS
6556   test -z "$as_dir" && as_dir=.
6557   for ac_exec_ext in '' $ac_executable_extensions; do
6558   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6559     ac_cv_prog_LEX="$ac_prog"
6560     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6561     break 2
6562   fi
6563 done
6564 done
6565
6566 fi
6567 fi
6568 LEX=$ac_cv_prog_LEX
6569 if test -n "$LEX"; then
6570   echo "$as_me:$LINENO: result: $LEX" >&5
6571 echo "${ECHO_T}$LEX" >&6
6572 else
6573   echo "$as_me:$LINENO: result: no" >&5
6574 echo "${ECHO_T}no" >&6
6575 fi
6576
6577   test -n "$LEX" && break
6578 done
6579 test -n "$LEX" || LEX="$MISSING flex"
6580
6581 case " $build_configdirs " in
6582   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6583   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6584 esac
6585
6586 for ac_prog in flex
6587 do
6588   # Extract the first word of "$ac_prog", so it can be a program name with args.
6589 set dummy $ac_prog; ac_word=$2
6590 echo "$as_me:$LINENO: checking for $ac_word" >&5
6591 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6592 if test "${ac_cv_prog_FLEX+set}" = set; then
6593   echo $ECHO_N "(cached) $ECHO_C" >&6
6594 else
6595   if test -n "$FLEX"; then
6596   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6597 else
6598 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6599 for as_dir in $PATH
6600 do
6601   IFS=$as_save_IFS
6602   test -z "$as_dir" && as_dir=.
6603   for ac_exec_ext in '' $ac_executable_extensions; do
6604   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6605     ac_cv_prog_FLEX="$ac_prog"
6606     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6607     break 2
6608   fi
6609 done
6610 done
6611
6612 fi
6613 fi
6614 FLEX=$ac_cv_prog_FLEX
6615 if test -n "$FLEX"; then
6616   echo "$as_me:$LINENO: result: $FLEX" >&5
6617 echo "${ECHO_T}$FLEX" >&6
6618 else
6619   echo "$as_me:$LINENO: result: no" >&5
6620 echo "${ECHO_T}no" >&6
6621 fi
6622
6623   test -n "$FLEX" && break
6624 done
6625 test -n "$FLEX" || FLEX="$MISSING flex"
6626
6627 case " $build_configdirs " in
6628   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6629 esac
6630
6631 for ac_prog in makeinfo
6632 do
6633   # Extract the first word of "$ac_prog", so it can be a program name with args.
6634 set dummy $ac_prog; ac_word=$2
6635 echo "$as_me:$LINENO: checking for $ac_word" >&5
6636 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6637 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6638   echo $ECHO_N "(cached) $ECHO_C" >&6
6639 else
6640   if test -n "$MAKEINFO"; then
6641   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6642 else
6643 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6644 for as_dir in $PATH
6645 do
6646   IFS=$as_save_IFS
6647   test -z "$as_dir" && as_dir=.
6648   for ac_exec_ext in '' $ac_executable_extensions; do
6649   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6650     ac_cv_prog_MAKEINFO="$ac_prog"
6651     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6652     break 2
6653   fi
6654 done
6655 done
6656
6657 fi
6658 fi
6659 MAKEINFO=$ac_cv_prog_MAKEINFO
6660 if test -n "$MAKEINFO"; then
6661   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6662 echo "${ECHO_T}$MAKEINFO" >&6
6663 else
6664   echo "$as_me:$LINENO: result: no" >&5
6665 echo "${ECHO_T}no" >&6
6666 fi
6667
6668   test -n "$MAKEINFO" && break
6669 done
6670 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6671
6672 case " $build_configdirs " in
6673   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6674   *)
6675
6676     # For an installed makeinfo, we require it to be from texinfo 4.7 or
6677     # higher, else we use the "missing" dummy.
6678     if ${MAKEINFO} --version \
6679        | egrep 'texinfo[^0-9]*(4\.([7-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6680       :
6681     else
6682       MAKEINFO="$MISSING makeinfo"
6683     fi
6684     ;;
6685
6686 esac
6687
6688 # FIXME: expect and dejagnu may become build tools?
6689
6690 for ac_prog in expect
6691 do
6692   # Extract the first word of "$ac_prog", so it can be a program name with args.
6693 set dummy $ac_prog; ac_word=$2
6694 echo "$as_me:$LINENO: checking for $ac_word" >&5
6695 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6696 if test "${ac_cv_prog_EXPECT+set}" = set; then
6697   echo $ECHO_N "(cached) $ECHO_C" >&6
6698 else
6699   if test -n "$EXPECT"; then
6700   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6701 else
6702 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6703 for as_dir in $PATH
6704 do
6705   IFS=$as_save_IFS
6706   test -z "$as_dir" && as_dir=.
6707   for ac_exec_ext in '' $ac_executable_extensions; do
6708   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6709     ac_cv_prog_EXPECT="$ac_prog"
6710     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6711     break 2
6712   fi
6713 done
6714 done
6715
6716 fi
6717 fi
6718 EXPECT=$ac_cv_prog_EXPECT
6719 if test -n "$EXPECT"; then
6720   echo "$as_me:$LINENO: result: $EXPECT" >&5
6721 echo "${ECHO_T}$EXPECT" >&6
6722 else
6723   echo "$as_me:$LINENO: result: no" >&5
6724 echo "${ECHO_T}no" >&6
6725 fi
6726
6727   test -n "$EXPECT" && break
6728 done
6729 test -n "$EXPECT" || EXPECT="expect"
6730
6731 case " $configdirs " in
6732   *" expect "*)
6733     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6734     ;;
6735 esac
6736
6737 for ac_prog in runtest
6738 do
6739   # Extract the first word of "$ac_prog", so it can be a program name with args.
6740 set dummy $ac_prog; ac_word=$2
6741 echo "$as_me:$LINENO: checking for $ac_word" >&5
6742 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6743 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6744   echo $ECHO_N "(cached) $ECHO_C" >&6
6745 else
6746   if test -n "$RUNTEST"; then
6747   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6748 else
6749 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6750 for as_dir in $PATH
6751 do
6752   IFS=$as_save_IFS
6753   test -z "$as_dir" && as_dir=.
6754   for ac_exec_ext in '' $ac_executable_extensions; do
6755   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6756     ac_cv_prog_RUNTEST="$ac_prog"
6757     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6758     break 2
6759   fi
6760 done
6761 done
6762
6763 fi
6764 fi
6765 RUNTEST=$ac_cv_prog_RUNTEST
6766 if test -n "$RUNTEST"; then
6767   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6768 echo "${ECHO_T}$RUNTEST" >&6
6769 else
6770   echo "$as_me:$LINENO: result: no" >&5
6771 echo "${ECHO_T}no" >&6
6772 fi
6773
6774   test -n "$RUNTEST" && break
6775 done
6776 test -n "$RUNTEST" || RUNTEST="runtest"
6777
6778 case " $configdirs " in
6779   *" dejagnu "*)
6780     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6781     ;;
6782 esac
6783
6784
6785 # Host tools.
6786 ncn_tool_prefix=
6787 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6788 ncn_target_tool_prefix=
6789 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6790
6791
6792
6793 if test -n "$AR"; then
6794   ac_cv_prog_AR=$AR
6795 elif test -n "$ac_cv_prog_AR"; then
6796   AR=$ac_cv_prog_AR
6797 fi
6798
6799 if test -n "$ac_cv_prog_AR"; then
6800   for ncn_progname in ar; do
6801     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6802 set dummy ${ncn_progname}; ac_word=$2
6803 echo "$as_me:$LINENO: checking for $ac_word" >&5
6804 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6805 if test "${ac_cv_prog_AR+set}" = set; then
6806   echo $ECHO_N "(cached) $ECHO_C" >&6
6807 else
6808   if test -n "$AR"; then
6809   ac_cv_prog_AR="$AR" # Let the user override the test.
6810 else
6811 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6812 for as_dir in $PATH
6813 do
6814   IFS=$as_save_IFS
6815   test -z "$as_dir" && as_dir=.
6816   for ac_exec_ext in '' $ac_executable_extensions; do
6817   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6818     ac_cv_prog_AR="${ncn_progname}"
6819     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6820     break 2
6821   fi
6822 done
6823 done
6824
6825 fi
6826 fi
6827 AR=$ac_cv_prog_AR
6828 if test -n "$AR"; then
6829   echo "$as_me:$LINENO: result: $AR" >&5
6830 echo "${ECHO_T}$AR" >&6
6831 else
6832   echo "$as_me:$LINENO: result: no" >&5
6833 echo "${ECHO_T}no" >&6
6834 fi
6835
6836   done
6837 fi
6838
6839 for ncn_progname in ar; do
6840   if test -n "$ncn_tool_prefix"; then
6841     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6842 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6843 echo "$as_me:$LINENO: checking for $ac_word" >&5
6844 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6845 if test "${ac_cv_prog_AR+set}" = set; then
6846   echo $ECHO_N "(cached) $ECHO_C" >&6
6847 else
6848   if test -n "$AR"; then
6849   ac_cv_prog_AR="$AR" # Let the user override the test.
6850 else
6851 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6852 for as_dir in $PATH
6853 do
6854   IFS=$as_save_IFS
6855   test -z "$as_dir" && as_dir=.
6856   for ac_exec_ext in '' $ac_executable_extensions; do
6857   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6858     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6859     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6860     break 2
6861   fi
6862 done
6863 done
6864
6865 fi
6866 fi
6867 AR=$ac_cv_prog_AR
6868 if test -n "$AR"; then
6869   echo "$as_me:$LINENO: result: $AR" >&5
6870 echo "${ECHO_T}$AR" >&6
6871 else
6872   echo "$as_me:$LINENO: result: no" >&5
6873 echo "${ECHO_T}no" >&6
6874 fi
6875
6876   fi
6877   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6878     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6879 set dummy ${ncn_progname}; ac_word=$2
6880 echo "$as_me:$LINENO: checking for $ac_word" >&5
6881 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6882 if test "${ac_cv_prog_AR+set}" = set; then
6883   echo $ECHO_N "(cached) $ECHO_C" >&6
6884 else
6885   if test -n "$AR"; then
6886   ac_cv_prog_AR="$AR" # Let the user override the test.
6887 else
6888 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6889 for as_dir in $PATH
6890 do
6891   IFS=$as_save_IFS
6892   test -z "$as_dir" && as_dir=.
6893   for ac_exec_ext in '' $ac_executable_extensions; do
6894   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6895     ac_cv_prog_AR="${ncn_progname}"
6896     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6897     break 2
6898   fi
6899 done
6900 done
6901
6902 fi
6903 fi
6904 AR=$ac_cv_prog_AR
6905 if test -n "$AR"; then
6906   echo "$as_me:$LINENO: result: $AR" >&5
6907 echo "${ECHO_T}$AR" >&6
6908 else
6909   echo "$as_me:$LINENO: result: no" >&5
6910 echo "${ECHO_T}no" >&6
6911 fi
6912
6913   fi
6914   test -n "$ac_cv_prog_AR" && break
6915 done
6916
6917 if test -z "$ac_cv_prog_AR" ; then
6918   set dummy ar
6919   if test $build = $host ; then
6920     AR="$2"
6921   else
6922     AR="${ncn_tool_prefix}$2"
6923   fi
6924 fi
6925
6926
6927
6928 if test -n "$AS"; then
6929   ac_cv_prog_AS=$AS
6930 elif test -n "$ac_cv_prog_AS"; then
6931   AS=$ac_cv_prog_AS
6932 fi
6933
6934 if test -n "$ac_cv_prog_AS"; then
6935   for ncn_progname in as; do
6936     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6937 set dummy ${ncn_progname}; ac_word=$2
6938 echo "$as_me:$LINENO: checking for $ac_word" >&5
6939 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6940 if test "${ac_cv_prog_AS+set}" = set; then
6941   echo $ECHO_N "(cached) $ECHO_C" >&6
6942 else
6943   if test -n "$AS"; then
6944   ac_cv_prog_AS="$AS" # Let the user override the test.
6945 else
6946 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6947 for as_dir in $PATH
6948 do
6949   IFS=$as_save_IFS
6950   test -z "$as_dir" && as_dir=.
6951   for ac_exec_ext in '' $ac_executable_extensions; do
6952   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6953     ac_cv_prog_AS="${ncn_progname}"
6954     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6955     break 2
6956   fi
6957 done
6958 done
6959
6960 fi
6961 fi
6962 AS=$ac_cv_prog_AS
6963 if test -n "$AS"; then
6964   echo "$as_me:$LINENO: result: $AS" >&5
6965 echo "${ECHO_T}$AS" >&6
6966 else
6967   echo "$as_me:$LINENO: result: no" >&5
6968 echo "${ECHO_T}no" >&6
6969 fi
6970
6971   done
6972 fi
6973
6974 for ncn_progname in as; do
6975   if test -n "$ncn_tool_prefix"; then
6976     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6977 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6978 echo "$as_me:$LINENO: checking for $ac_word" >&5
6979 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6980 if test "${ac_cv_prog_AS+set}" = set; then
6981   echo $ECHO_N "(cached) $ECHO_C" >&6
6982 else
6983   if test -n "$AS"; then
6984   ac_cv_prog_AS="$AS" # Let the user override the test.
6985 else
6986 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6987 for as_dir in $PATH
6988 do
6989   IFS=$as_save_IFS
6990   test -z "$as_dir" && as_dir=.
6991   for ac_exec_ext in '' $ac_executable_extensions; do
6992   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6993     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6994     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6995     break 2
6996   fi
6997 done
6998 done
6999
7000 fi
7001 fi
7002 AS=$ac_cv_prog_AS
7003 if test -n "$AS"; then
7004   echo "$as_me:$LINENO: result: $AS" >&5
7005 echo "${ECHO_T}$AS" >&6
7006 else
7007   echo "$as_me:$LINENO: result: no" >&5
7008 echo "${ECHO_T}no" >&6
7009 fi
7010
7011   fi
7012   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
7013     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7014 set dummy ${ncn_progname}; ac_word=$2
7015 echo "$as_me:$LINENO: checking for $ac_word" >&5
7016 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7017 if test "${ac_cv_prog_AS+set}" = set; then
7018   echo $ECHO_N "(cached) $ECHO_C" >&6
7019 else
7020   if test -n "$AS"; then
7021   ac_cv_prog_AS="$AS" # Let the user override the test.
7022 else
7023 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7024 for as_dir in $PATH
7025 do
7026   IFS=$as_save_IFS
7027   test -z "$as_dir" && as_dir=.
7028   for ac_exec_ext in '' $ac_executable_extensions; do
7029   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7030     ac_cv_prog_AS="${ncn_progname}"
7031     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7032     break 2
7033   fi
7034 done
7035 done
7036
7037 fi
7038 fi
7039 AS=$ac_cv_prog_AS
7040 if test -n "$AS"; then
7041   echo "$as_me:$LINENO: result: $AS" >&5
7042 echo "${ECHO_T}$AS" >&6
7043 else
7044   echo "$as_me:$LINENO: result: no" >&5
7045 echo "${ECHO_T}no" >&6
7046 fi
7047
7048   fi
7049   test -n "$ac_cv_prog_AS" && break
7050 done
7051
7052 if test -z "$ac_cv_prog_AS" ; then
7053   set dummy as
7054   if test $build = $host ; then
7055     AS="$2"
7056   else
7057     AS="${ncn_tool_prefix}$2"
7058   fi
7059 fi
7060
7061
7062
7063 if test -n "$DLLTOOL"; then
7064   ac_cv_prog_DLLTOOL=$DLLTOOL
7065 elif test -n "$ac_cv_prog_DLLTOOL"; then
7066   DLLTOOL=$ac_cv_prog_DLLTOOL
7067 fi
7068
7069 if test -n "$ac_cv_prog_DLLTOOL"; then
7070   for ncn_progname in dlltool; do
7071     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7072 set dummy ${ncn_progname}; ac_word=$2
7073 echo "$as_me:$LINENO: checking for $ac_word" >&5
7074 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7075 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7076   echo $ECHO_N "(cached) $ECHO_C" >&6
7077 else
7078   if test -n "$DLLTOOL"; then
7079   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7080 else
7081 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7082 for as_dir in $PATH
7083 do
7084   IFS=$as_save_IFS
7085   test -z "$as_dir" && as_dir=.
7086   for ac_exec_ext in '' $ac_executable_extensions; do
7087   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7088     ac_cv_prog_DLLTOOL="${ncn_progname}"
7089     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7090     break 2
7091   fi
7092 done
7093 done
7094
7095 fi
7096 fi
7097 DLLTOOL=$ac_cv_prog_DLLTOOL
7098 if test -n "$DLLTOOL"; then
7099   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7100 echo "${ECHO_T}$DLLTOOL" >&6
7101 else
7102   echo "$as_me:$LINENO: result: no" >&5
7103 echo "${ECHO_T}no" >&6
7104 fi
7105
7106   done
7107 fi
7108
7109 for ncn_progname in dlltool; do
7110   if test -n "$ncn_tool_prefix"; then
7111     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7112 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7113 echo "$as_me:$LINENO: checking for $ac_word" >&5
7114 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7115 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7116   echo $ECHO_N "(cached) $ECHO_C" >&6
7117 else
7118   if test -n "$DLLTOOL"; then
7119   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7120 else
7121 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7122 for as_dir in $PATH
7123 do
7124   IFS=$as_save_IFS
7125   test -z "$as_dir" && as_dir=.
7126   for ac_exec_ext in '' $ac_executable_extensions; do
7127   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7128     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7129     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7130     break 2
7131   fi
7132 done
7133 done
7134
7135 fi
7136 fi
7137 DLLTOOL=$ac_cv_prog_DLLTOOL
7138 if test -n "$DLLTOOL"; then
7139   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7140 echo "${ECHO_T}$DLLTOOL" >&6
7141 else
7142   echo "$as_me:$LINENO: result: no" >&5
7143 echo "${ECHO_T}no" >&6
7144 fi
7145
7146   fi
7147   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7148     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7149 set dummy ${ncn_progname}; ac_word=$2
7150 echo "$as_me:$LINENO: checking for $ac_word" >&5
7151 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7152 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7153   echo $ECHO_N "(cached) $ECHO_C" >&6
7154 else
7155   if test -n "$DLLTOOL"; then
7156   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7157 else
7158 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7159 for as_dir in $PATH
7160 do
7161   IFS=$as_save_IFS
7162   test -z "$as_dir" && as_dir=.
7163   for ac_exec_ext in '' $ac_executable_extensions; do
7164   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7165     ac_cv_prog_DLLTOOL="${ncn_progname}"
7166     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7167     break 2
7168   fi
7169 done
7170 done
7171
7172 fi
7173 fi
7174 DLLTOOL=$ac_cv_prog_DLLTOOL
7175 if test -n "$DLLTOOL"; then
7176   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7177 echo "${ECHO_T}$DLLTOOL" >&6
7178 else
7179   echo "$as_me:$LINENO: result: no" >&5
7180 echo "${ECHO_T}no" >&6
7181 fi
7182
7183   fi
7184   test -n "$ac_cv_prog_DLLTOOL" && break
7185 done
7186
7187 if test -z "$ac_cv_prog_DLLTOOL" ; then
7188   set dummy dlltool
7189   if test $build = $host ; then
7190     DLLTOOL="$2"
7191   else
7192     DLLTOOL="${ncn_tool_prefix}$2"
7193   fi
7194 fi
7195
7196
7197
7198 if test -n "$LD"; then
7199   ac_cv_prog_LD=$LD
7200 elif test -n "$ac_cv_prog_LD"; then
7201   LD=$ac_cv_prog_LD
7202 fi
7203
7204 if test -n "$ac_cv_prog_LD"; then
7205   for ncn_progname in ld; do
7206     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7207 set dummy ${ncn_progname}; ac_word=$2
7208 echo "$as_me:$LINENO: checking for $ac_word" >&5
7209 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7210 if test "${ac_cv_prog_LD+set}" = set; then
7211   echo $ECHO_N "(cached) $ECHO_C" >&6
7212 else
7213   if test -n "$LD"; then
7214   ac_cv_prog_LD="$LD" # Let the user override the test.
7215 else
7216 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7217 for as_dir in $PATH
7218 do
7219   IFS=$as_save_IFS
7220   test -z "$as_dir" && as_dir=.
7221   for ac_exec_ext in '' $ac_executable_extensions; do
7222   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7223     ac_cv_prog_LD="${ncn_progname}"
7224     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7225     break 2
7226   fi
7227 done
7228 done
7229
7230 fi
7231 fi
7232 LD=$ac_cv_prog_LD
7233 if test -n "$LD"; then
7234   echo "$as_me:$LINENO: result: $LD" >&5
7235 echo "${ECHO_T}$LD" >&6
7236 else
7237   echo "$as_me:$LINENO: result: no" >&5
7238 echo "${ECHO_T}no" >&6
7239 fi
7240
7241   done
7242 fi
7243
7244 for ncn_progname in ld; do
7245   if test -n "$ncn_tool_prefix"; then
7246     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7247 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7248 echo "$as_me:$LINENO: checking for $ac_word" >&5
7249 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7250 if test "${ac_cv_prog_LD+set}" = set; then
7251   echo $ECHO_N "(cached) $ECHO_C" >&6
7252 else
7253   if test -n "$LD"; then
7254   ac_cv_prog_LD="$LD" # Let the user override the test.
7255 else
7256 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7257 for as_dir in $PATH
7258 do
7259   IFS=$as_save_IFS
7260   test -z "$as_dir" && as_dir=.
7261   for ac_exec_ext in '' $ac_executable_extensions; do
7262   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7263     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7264     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7265     break 2
7266   fi
7267 done
7268 done
7269
7270 fi
7271 fi
7272 LD=$ac_cv_prog_LD
7273 if test -n "$LD"; then
7274   echo "$as_me:$LINENO: result: $LD" >&5
7275 echo "${ECHO_T}$LD" >&6
7276 else
7277   echo "$as_me:$LINENO: result: no" >&5
7278 echo "${ECHO_T}no" >&6
7279 fi
7280
7281   fi
7282   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7283     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7284 set dummy ${ncn_progname}; ac_word=$2
7285 echo "$as_me:$LINENO: checking for $ac_word" >&5
7286 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7287 if test "${ac_cv_prog_LD+set}" = set; then
7288   echo $ECHO_N "(cached) $ECHO_C" >&6
7289 else
7290   if test -n "$LD"; then
7291   ac_cv_prog_LD="$LD" # Let the user override the test.
7292 else
7293 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7294 for as_dir in $PATH
7295 do
7296   IFS=$as_save_IFS
7297   test -z "$as_dir" && as_dir=.
7298   for ac_exec_ext in '' $ac_executable_extensions; do
7299   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7300     ac_cv_prog_LD="${ncn_progname}"
7301     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7302     break 2
7303   fi
7304 done
7305 done
7306
7307 fi
7308 fi
7309 LD=$ac_cv_prog_LD
7310 if test -n "$LD"; then
7311   echo "$as_me:$LINENO: result: $LD" >&5
7312 echo "${ECHO_T}$LD" >&6
7313 else
7314   echo "$as_me:$LINENO: result: no" >&5
7315 echo "${ECHO_T}no" >&6
7316 fi
7317
7318   fi
7319   test -n "$ac_cv_prog_LD" && break
7320 done
7321
7322 if test -z "$ac_cv_prog_LD" ; then
7323   set dummy ld
7324   if test $build = $host ; then
7325     LD="$2"
7326   else
7327     LD="${ncn_tool_prefix}$2"
7328   fi
7329 fi
7330
7331
7332
7333 if test -n "$LIPO"; then
7334   ac_cv_prog_LIPO=$LIPO
7335 elif test -n "$ac_cv_prog_LIPO"; then
7336   LIPO=$ac_cv_prog_LIPO
7337 fi
7338
7339 if test -n "$ac_cv_prog_LIPO"; then
7340   for ncn_progname in lipo; do
7341     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7342 set dummy ${ncn_progname}; ac_word=$2
7343 echo "$as_me:$LINENO: checking for $ac_word" >&5
7344 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7345 if test "${ac_cv_prog_LIPO+set}" = set; then
7346   echo $ECHO_N "(cached) $ECHO_C" >&6
7347 else
7348   if test -n "$LIPO"; then
7349   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7350 else
7351 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7352 for as_dir in $PATH
7353 do
7354   IFS=$as_save_IFS
7355   test -z "$as_dir" && as_dir=.
7356   for ac_exec_ext in '' $ac_executable_extensions; do
7357   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7358     ac_cv_prog_LIPO="${ncn_progname}"
7359     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7360     break 2
7361   fi
7362 done
7363 done
7364
7365 fi
7366 fi
7367 LIPO=$ac_cv_prog_LIPO
7368 if test -n "$LIPO"; then
7369   echo "$as_me:$LINENO: result: $LIPO" >&5
7370 echo "${ECHO_T}$LIPO" >&6
7371 else
7372   echo "$as_me:$LINENO: result: no" >&5
7373 echo "${ECHO_T}no" >&6
7374 fi
7375
7376   done
7377 fi
7378
7379 for ncn_progname in lipo; do
7380   if test -n "$ncn_tool_prefix"; then
7381     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7382 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7383 echo "$as_me:$LINENO: checking for $ac_word" >&5
7384 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7385 if test "${ac_cv_prog_LIPO+set}" = set; then
7386   echo $ECHO_N "(cached) $ECHO_C" >&6
7387 else
7388   if test -n "$LIPO"; then
7389   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7390 else
7391 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7392 for as_dir in $PATH
7393 do
7394   IFS=$as_save_IFS
7395   test -z "$as_dir" && as_dir=.
7396   for ac_exec_ext in '' $ac_executable_extensions; do
7397   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7398     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7399     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7400     break 2
7401   fi
7402 done
7403 done
7404
7405 fi
7406 fi
7407 LIPO=$ac_cv_prog_LIPO
7408 if test -n "$LIPO"; then
7409   echo "$as_me:$LINENO: result: $LIPO" >&5
7410 echo "${ECHO_T}$LIPO" >&6
7411 else
7412   echo "$as_me:$LINENO: result: no" >&5
7413 echo "${ECHO_T}no" >&6
7414 fi
7415
7416   fi
7417   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7418     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7419 set dummy ${ncn_progname}; ac_word=$2
7420 echo "$as_me:$LINENO: checking for $ac_word" >&5
7421 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7422 if test "${ac_cv_prog_LIPO+set}" = set; then
7423   echo $ECHO_N "(cached) $ECHO_C" >&6
7424 else
7425   if test -n "$LIPO"; then
7426   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7427 else
7428 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7429 for as_dir in $PATH
7430 do
7431   IFS=$as_save_IFS
7432   test -z "$as_dir" && as_dir=.
7433   for ac_exec_ext in '' $ac_executable_extensions; do
7434   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7435     ac_cv_prog_LIPO="${ncn_progname}"
7436     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7437     break 2
7438   fi
7439 done
7440 done
7441
7442 fi
7443 fi
7444 LIPO=$ac_cv_prog_LIPO
7445 if test -n "$LIPO"; then
7446   echo "$as_me:$LINENO: result: $LIPO" >&5
7447 echo "${ECHO_T}$LIPO" >&6
7448 else
7449   echo "$as_me:$LINENO: result: no" >&5
7450 echo "${ECHO_T}no" >&6
7451 fi
7452
7453   fi
7454   test -n "$ac_cv_prog_LIPO" && break
7455 done
7456
7457 if test -z "$ac_cv_prog_LIPO" ; then
7458   set dummy lipo
7459   if test $build = $host ; then
7460     LIPO="$2"
7461   else
7462     LIPO="${ncn_tool_prefix}$2"
7463   fi
7464 fi
7465
7466
7467
7468 if test -n "$NM"; then
7469   ac_cv_prog_NM=$NM
7470 elif test -n "$ac_cv_prog_NM"; then
7471   NM=$ac_cv_prog_NM
7472 fi
7473
7474 if test -n "$ac_cv_prog_NM"; then
7475   for ncn_progname in nm; do
7476     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7477 set dummy ${ncn_progname}; ac_word=$2
7478 echo "$as_me:$LINENO: checking for $ac_word" >&5
7479 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7480 if test "${ac_cv_prog_NM+set}" = set; then
7481   echo $ECHO_N "(cached) $ECHO_C" >&6
7482 else
7483   if test -n "$NM"; then
7484   ac_cv_prog_NM="$NM" # Let the user override the test.
7485 else
7486 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7487 for as_dir in $PATH
7488 do
7489   IFS=$as_save_IFS
7490   test -z "$as_dir" && as_dir=.
7491   for ac_exec_ext in '' $ac_executable_extensions; do
7492   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7493     ac_cv_prog_NM="${ncn_progname}"
7494     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7495     break 2
7496   fi
7497 done
7498 done
7499
7500 fi
7501 fi
7502 NM=$ac_cv_prog_NM
7503 if test -n "$NM"; then
7504   echo "$as_me:$LINENO: result: $NM" >&5
7505 echo "${ECHO_T}$NM" >&6
7506 else
7507   echo "$as_me:$LINENO: result: no" >&5
7508 echo "${ECHO_T}no" >&6
7509 fi
7510
7511   done
7512 fi
7513
7514 for ncn_progname in nm; do
7515   if test -n "$ncn_tool_prefix"; then
7516     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7517 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7518 echo "$as_me:$LINENO: checking for $ac_word" >&5
7519 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7520 if test "${ac_cv_prog_NM+set}" = set; then
7521   echo $ECHO_N "(cached) $ECHO_C" >&6
7522 else
7523   if test -n "$NM"; then
7524   ac_cv_prog_NM="$NM" # Let the user override the test.
7525 else
7526 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7527 for as_dir in $PATH
7528 do
7529   IFS=$as_save_IFS
7530   test -z "$as_dir" && as_dir=.
7531   for ac_exec_ext in '' $ac_executable_extensions; do
7532   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7533     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7534     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7535     break 2
7536   fi
7537 done
7538 done
7539
7540 fi
7541 fi
7542 NM=$ac_cv_prog_NM
7543 if test -n "$NM"; then
7544   echo "$as_me:$LINENO: result: $NM" >&5
7545 echo "${ECHO_T}$NM" >&6
7546 else
7547   echo "$as_me:$LINENO: result: no" >&5
7548 echo "${ECHO_T}no" >&6
7549 fi
7550
7551   fi
7552   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7553     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7554 set dummy ${ncn_progname}; ac_word=$2
7555 echo "$as_me:$LINENO: checking for $ac_word" >&5
7556 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7557 if test "${ac_cv_prog_NM+set}" = set; then
7558   echo $ECHO_N "(cached) $ECHO_C" >&6
7559 else
7560   if test -n "$NM"; then
7561   ac_cv_prog_NM="$NM" # Let the user override the test.
7562 else
7563 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7564 for as_dir in $PATH
7565 do
7566   IFS=$as_save_IFS
7567   test -z "$as_dir" && as_dir=.
7568   for ac_exec_ext in '' $ac_executable_extensions; do
7569   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7570     ac_cv_prog_NM="${ncn_progname}"
7571     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7572     break 2
7573   fi
7574 done
7575 done
7576
7577 fi
7578 fi
7579 NM=$ac_cv_prog_NM
7580 if test -n "$NM"; then
7581   echo "$as_me:$LINENO: result: $NM" >&5
7582 echo "${ECHO_T}$NM" >&6
7583 else
7584   echo "$as_me:$LINENO: result: no" >&5
7585 echo "${ECHO_T}no" >&6
7586 fi
7587
7588   fi
7589   test -n "$ac_cv_prog_NM" && break
7590 done
7591
7592 if test -z "$ac_cv_prog_NM" ; then
7593   set dummy nm
7594   if test $build = $host ; then
7595     NM="$2"
7596   else
7597     NM="${ncn_tool_prefix}$2"
7598   fi
7599 fi
7600
7601
7602
7603 if test -n "$RANLIB"; then
7604   ac_cv_prog_RANLIB=$RANLIB
7605 elif test -n "$ac_cv_prog_RANLIB"; then
7606   RANLIB=$ac_cv_prog_RANLIB
7607 fi
7608
7609 if test -n "$ac_cv_prog_RANLIB"; then
7610   for ncn_progname in ranlib; do
7611     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7612 set dummy ${ncn_progname}; ac_word=$2
7613 echo "$as_me:$LINENO: checking for $ac_word" >&5
7614 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7615 if test "${ac_cv_prog_RANLIB+set}" = set; then
7616   echo $ECHO_N "(cached) $ECHO_C" >&6
7617 else
7618   if test -n "$RANLIB"; then
7619   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7620 else
7621 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7622 for as_dir in $PATH
7623 do
7624   IFS=$as_save_IFS
7625   test -z "$as_dir" && as_dir=.
7626   for ac_exec_ext in '' $ac_executable_extensions; do
7627   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7628     ac_cv_prog_RANLIB="${ncn_progname}"
7629     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7630     break 2
7631   fi
7632 done
7633 done
7634
7635 fi
7636 fi
7637 RANLIB=$ac_cv_prog_RANLIB
7638 if test -n "$RANLIB"; then
7639   echo "$as_me:$LINENO: result: $RANLIB" >&5
7640 echo "${ECHO_T}$RANLIB" >&6
7641 else
7642   echo "$as_me:$LINENO: result: no" >&5
7643 echo "${ECHO_T}no" >&6
7644 fi
7645
7646   done
7647 fi
7648
7649 for ncn_progname in ranlib; do
7650   if test -n "$ncn_tool_prefix"; then
7651     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7652 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7653 echo "$as_me:$LINENO: checking for $ac_word" >&5
7654 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7655 if test "${ac_cv_prog_RANLIB+set}" = set; then
7656   echo $ECHO_N "(cached) $ECHO_C" >&6
7657 else
7658   if test -n "$RANLIB"; then
7659   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7660 else
7661 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7662 for as_dir in $PATH
7663 do
7664   IFS=$as_save_IFS
7665   test -z "$as_dir" && as_dir=.
7666   for ac_exec_ext in '' $ac_executable_extensions; do
7667   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7668     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7669     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7670     break 2
7671   fi
7672 done
7673 done
7674
7675 fi
7676 fi
7677 RANLIB=$ac_cv_prog_RANLIB
7678 if test -n "$RANLIB"; then
7679   echo "$as_me:$LINENO: result: $RANLIB" >&5
7680 echo "${ECHO_T}$RANLIB" >&6
7681 else
7682   echo "$as_me:$LINENO: result: no" >&5
7683 echo "${ECHO_T}no" >&6
7684 fi
7685
7686   fi
7687   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7688     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7689 set dummy ${ncn_progname}; ac_word=$2
7690 echo "$as_me:$LINENO: checking for $ac_word" >&5
7691 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7692 if test "${ac_cv_prog_RANLIB+set}" = set; then
7693   echo $ECHO_N "(cached) $ECHO_C" >&6
7694 else
7695   if test -n "$RANLIB"; then
7696   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7697 else
7698 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7699 for as_dir in $PATH
7700 do
7701   IFS=$as_save_IFS
7702   test -z "$as_dir" && as_dir=.
7703   for ac_exec_ext in '' $ac_executable_extensions; do
7704   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7705     ac_cv_prog_RANLIB="${ncn_progname}"
7706     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7707     break 2
7708   fi
7709 done
7710 done
7711
7712 fi
7713 fi
7714 RANLIB=$ac_cv_prog_RANLIB
7715 if test -n "$RANLIB"; then
7716   echo "$as_me:$LINENO: result: $RANLIB" >&5
7717 echo "${ECHO_T}$RANLIB" >&6
7718 else
7719   echo "$as_me:$LINENO: result: no" >&5
7720 echo "${ECHO_T}no" >&6
7721 fi
7722
7723   fi
7724   test -n "$ac_cv_prog_RANLIB" && break
7725 done
7726
7727 if test -z "$ac_cv_prog_RANLIB" ; then
7728   RANLIB=":"
7729 fi
7730
7731
7732
7733 if test -n "$STRIP"; then
7734   ac_cv_prog_STRIP=$STRIP
7735 elif test -n "$ac_cv_prog_STRIP"; then
7736   STRIP=$ac_cv_prog_STRIP
7737 fi
7738
7739 if test -n "$ac_cv_prog_STRIP"; then
7740   for ncn_progname in strip; do
7741     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7742 set dummy ${ncn_progname}; ac_word=$2
7743 echo "$as_me:$LINENO: checking for $ac_word" >&5
7744 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7745 if test "${ac_cv_prog_STRIP+set}" = set; then
7746   echo $ECHO_N "(cached) $ECHO_C" >&6
7747 else
7748   if test -n "$STRIP"; then
7749   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7750 else
7751 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7752 for as_dir in $PATH
7753 do
7754   IFS=$as_save_IFS
7755   test -z "$as_dir" && as_dir=.
7756   for ac_exec_ext in '' $ac_executable_extensions; do
7757   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7758     ac_cv_prog_STRIP="${ncn_progname}"
7759     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7760     break 2
7761   fi
7762 done
7763 done
7764
7765 fi
7766 fi
7767 STRIP=$ac_cv_prog_STRIP
7768 if test -n "$STRIP"; then
7769   echo "$as_me:$LINENO: result: $STRIP" >&5
7770 echo "${ECHO_T}$STRIP" >&6
7771 else
7772   echo "$as_me:$LINENO: result: no" >&5
7773 echo "${ECHO_T}no" >&6
7774 fi
7775
7776   done
7777 fi
7778
7779 for ncn_progname in strip; do
7780   if test -n "$ncn_tool_prefix"; then
7781     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7782 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7783 echo "$as_me:$LINENO: checking for $ac_word" >&5
7784 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7785 if test "${ac_cv_prog_STRIP+set}" = set; then
7786   echo $ECHO_N "(cached) $ECHO_C" >&6
7787 else
7788   if test -n "$STRIP"; then
7789   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7790 else
7791 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7792 for as_dir in $PATH
7793 do
7794   IFS=$as_save_IFS
7795   test -z "$as_dir" && as_dir=.
7796   for ac_exec_ext in '' $ac_executable_extensions; do
7797   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7798     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7799     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7800     break 2
7801   fi
7802 done
7803 done
7804
7805 fi
7806 fi
7807 STRIP=$ac_cv_prog_STRIP
7808 if test -n "$STRIP"; then
7809   echo "$as_me:$LINENO: result: $STRIP" >&5
7810 echo "${ECHO_T}$STRIP" >&6
7811 else
7812   echo "$as_me:$LINENO: result: no" >&5
7813 echo "${ECHO_T}no" >&6
7814 fi
7815
7816   fi
7817   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7818     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7819 set dummy ${ncn_progname}; ac_word=$2
7820 echo "$as_me:$LINENO: checking for $ac_word" >&5
7821 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7822 if test "${ac_cv_prog_STRIP+set}" = set; then
7823   echo $ECHO_N "(cached) $ECHO_C" >&6
7824 else
7825   if test -n "$STRIP"; then
7826   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7827 else
7828 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7829 for as_dir in $PATH
7830 do
7831   IFS=$as_save_IFS
7832   test -z "$as_dir" && as_dir=.
7833   for ac_exec_ext in '' $ac_executable_extensions; do
7834   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7835     ac_cv_prog_STRIP="${ncn_progname}"
7836     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7837     break 2
7838   fi
7839 done
7840 done
7841
7842 fi
7843 fi
7844 STRIP=$ac_cv_prog_STRIP
7845 if test -n "$STRIP"; then
7846   echo "$as_me:$LINENO: result: $STRIP" >&5
7847 echo "${ECHO_T}$STRIP" >&6
7848 else
7849   echo "$as_me:$LINENO: result: no" >&5
7850 echo "${ECHO_T}no" >&6
7851 fi
7852
7853   fi
7854   test -n "$ac_cv_prog_STRIP" && break
7855 done
7856
7857 if test -z "$ac_cv_prog_STRIP" ; then
7858   STRIP=":"
7859 fi
7860
7861
7862
7863 if test -n "$WINDRES"; then
7864   ac_cv_prog_WINDRES=$WINDRES
7865 elif test -n "$ac_cv_prog_WINDRES"; then
7866   WINDRES=$ac_cv_prog_WINDRES
7867 fi
7868
7869 if test -n "$ac_cv_prog_WINDRES"; then
7870   for ncn_progname in windres; do
7871     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7872 set dummy ${ncn_progname}; ac_word=$2
7873 echo "$as_me:$LINENO: checking for $ac_word" >&5
7874 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7875 if test "${ac_cv_prog_WINDRES+set}" = set; then
7876   echo $ECHO_N "(cached) $ECHO_C" >&6
7877 else
7878   if test -n "$WINDRES"; then
7879   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7880 else
7881 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7882 for as_dir in $PATH
7883 do
7884   IFS=$as_save_IFS
7885   test -z "$as_dir" && as_dir=.
7886   for ac_exec_ext in '' $ac_executable_extensions; do
7887   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7888     ac_cv_prog_WINDRES="${ncn_progname}"
7889     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7890     break 2
7891   fi
7892 done
7893 done
7894
7895 fi
7896 fi
7897 WINDRES=$ac_cv_prog_WINDRES
7898 if test -n "$WINDRES"; then
7899   echo "$as_me:$LINENO: result: $WINDRES" >&5
7900 echo "${ECHO_T}$WINDRES" >&6
7901 else
7902   echo "$as_me:$LINENO: result: no" >&5
7903 echo "${ECHO_T}no" >&6
7904 fi
7905
7906   done
7907 fi
7908
7909 for ncn_progname in windres; do
7910   if test -n "$ncn_tool_prefix"; then
7911     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7912 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7913 echo "$as_me:$LINENO: checking for $ac_word" >&5
7914 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7915 if test "${ac_cv_prog_WINDRES+set}" = set; then
7916   echo $ECHO_N "(cached) $ECHO_C" >&6
7917 else
7918   if test -n "$WINDRES"; then
7919   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7920 else
7921 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7922 for as_dir in $PATH
7923 do
7924   IFS=$as_save_IFS
7925   test -z "$as_dir" && as_dir=.
7926   for ac_exec_ext in '' $ac_executable_extensions; do
7927   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7928     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7929     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7930     break 2
7931   fi
7932 done
7933 done
7934
7935 fi
7936 fi
7937 WINDRES=$ac_cv_prog_WINDRES
7938 if test -n "$WINDRES"; then
7939   echo "$as_me:$LINENO: result: $WINDRES" >&5
7940 echo "${ECHO_T}$WINDRES" >&6
7941 else
7942   echo "$as_me:$LINENO: result: no" >&5
7943 echo "${ECHO_T}no" >&6
7944 fi
7945
7946   fi
7947   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7948     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7949 set dummy ${ncn_progname}; ac_word=$2
7950 echo "$as_me:$LINENO: checking for $ac_word" >&5
7951 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7952 if test "${ac_cv_prog_WINDRES+set}" = set; then
7953   echo $ECHO_N "(cached) $ECHO_C" >&6
7954 else
7955   if test -n "$WINDRES"; then
7956   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7957 else
7958 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7959 for as_dir in $PATH
7960 do
7961   IFS=$as_save_IFS
7962   test -z "$as_dir" && as_dir=.
7963   for ac_exec_ext in '' $ac_executable_extensions; do
7964   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7965     ac_cv_prog_WINDRES="${ncn_progname}"
7966     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7967     break 2
7968   fi
7969 done
7970 done
7971
7972 fi
7973 fi
7974 WINDRES=$ac_cv_prog_WINDRES
7975 if test -n "$WINDRES"; then
7976   echo "$as_me:$LINENO: result: $WINDRES" >&5
7977 echo "${ECHO_T}$WINDRES" >&6
7978 else
7979   echo "$as_me:$LINENO: result: no" >&5
7980 echo "${ECHO_T}no" >&6
7981 fi
7982
7983   fi
7984   test -n "$ac_cv_prog_WINDRES" && break
7985 done
7986
7987 if test -z "$ac_cv_prog_WINDRES" ; then
7988   set dummy windres
7989   if test $build = $host ; then
7990     WINDRES="$2"
7991   else
7992     WINDRES="${ncn_tool_prefix}$2"
7993   fi
7994 fi
7995
7996
7997
7998 if test -n "$WINDMC"; then
7999   ac_cv_prog_WINDMC=$WINDMC
8000 elif test -n "$ac_cv_prog_WINDMC"; then
8001   WINDMC=$ac_cv_prog_WINDMC
8002 fi
8003
8004 if test -n "$ac_cv_prog_WINDMC"; then
8005   for ncn_progname in windmc; do
8006     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8007 set dummy ${ncn_progname}; ac_word=$2
8008 echo "$as_me:$LINENO: checking for $ac_word" >&5
8009 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8010 if test "${ac_cv_prog_WINDMC+set}" = set; then
8011   echo $ECHO_N "(cached) $ECHO_C" >&6
8012 else
8013   if test -n "$WINDMC"; then
8014   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8015 else
8016 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8017 for as_dir in $PATH
8018 do
8019   IFS=$as_save_IFS
8020   test -z "$as_dir" && as_dir=.
8021   for ac_exec_ext in '' $ac_executable_extensions; do
8022   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8023     ac_cv_prog_WINDMC="${ncn_progname}"
8024     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8025     break 2
8026   fi
8027 done
8028 done
8029
8030 fi
8031 fi
8032 WINDMC=$ac_cv_prog_WINDMC
8033 if test -n "$WINDMC"; then
8034   echo "$as_me:$LINENO: result: $WINDMC" >&5
8035 echo "${ECHO_T}$WINDMC" >&6
8036 else
8037   echo "$as_me:$LINENO: result: no" >&5
8038 echo "${ECHO_T}no" >&6
8039 fi
8040
8041   done
8042 fi
8043
8044 for ncn_progname in windmc; do
8045   if test -n "$ncn_tool_prefix"; then
8046     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8047 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8048 echo "$as_me:$LINENO: checking for $ac_word" >&5
8049 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8050 if test "${ac_cv_prog_WINDMC+set}" = set; then
8051   echo $ECHO_N "(cached) $ECHO_C" >&6
8052 else
8053   if test -n "$WINDMC"; then
8054   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8055 else
8056 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8057 for as_dir in $PATH
8058 do
8059   IFS=$as_save_IFS
8060   test -z "$as_dir" && as_dir=.
8061   for ac_exec_ext in '' $ac_executable_extensions; do
8062   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8063     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8064     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8065     break 2
8066   fi
8067 done
8068 done
8069
8070 fi
8071 fi
8072 WINDMC=$ac_cv_prog_WINDMC
8073 if test -n "$WINDMC"; then
8074   echo "$as_me:$LINENO: result: $WINDMC" >&5
8075 echo "${ECHO_T}$WINDMC" >&6
8076 else
8077   echo "$as_me:$LINENO: result: no" >&5
8078 echo "${ECHO_T}no" >&6
8079 fi
8080
8081   fi
8082   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8083     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8084 set dummy ${ncn_progname}; ac_word=$2
8085 echo "$as_me:$LINENO: checking for $ac_word" >&5
8086 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8087 if test "${ac_cv_prog_WINDMC+set}" = set; then
8088   echo $ECHO_N "(cached) $ECHO_C" >&6
8089 else
8090   if test -n "$WINDMC"; then
8091   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8092 else
8093 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8094 for as_dir in $PATH
8095 do
8096   IFS=$as_save_IFS
8097   test -z "$as_dir" && as_dir=.
8098   for ac_exec_ext in '' $ac_executable_extensions; do
8099   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8100     ac_cv_prog_WINDMC="${ncn_progname}"
8101     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8102     break 2
8103   fi
8104 done
8105 done
8106
8107 fi
8108 fi
8109 WINDMC=$ac_cv_prog_WINDMC
8110 if test -n "$WINDMC"; then
8111   echo "$as_me:$LINENO: result: $WINDMC" >&5
8112 echo "${ECHO_T}$WINDMC" >&6
8113 else
8114   echo "$as_me:$LINENO: result: no" >&5
8115 echo "${ECHO_T}no" >&6
8116 fi
8117
8118   fi
8119   test -n "$ac_cv_prog_WINDMC" && break
8120 done
8121
8122 if test -z "$ac_cv_prog_WINDMC" ; then
8123   set dummy windmc
8124   if test $build = $host ; then
8125     WINDMC="$2"
8126   else
8127     WINDMC="${ncn_tool_prefix}$2"
8128   fi
8129 fi
8130
8131
8132
8133 if test -n "$OBJCOPY"; then
8134   ac_cv_prog_OBJCOPY=$OBJCOPY
8135 elif test -n "$ac_cv_prog_OBJCOPY"; then
8136   OBJCOPY=$ac_cv_prog_OBJCOPY
8137 fi
8138
8139 if test -n "$ac_cv_prog_OBJCOPY"; then
8140   for ncn_progname in objcopy; do
8141     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8142 set dummy ${ncn_progname}; ac_word=$2
8143 echo "$as_me:$LINENO: checking for $ac_word" >&5
8144 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8145 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8146   echo $ECHO_N "(cached) $ECHO_C" >&6
8147 else
8148   if test -n "$OBJCOPY"; then
8149   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8150 else
8151 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8152 for as_dir in $PATH
8153 do
8154   IFS=$as_save_IFS
8155   test -z "$as_dir" && as_dir=.
8156   for ac_exec_ext in '' $ac_executable_extensions; do
8157   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8158     ac_cv_prog_OBJCOPY="${ncn_progname}"
8159     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8160     break 2
8161   fi
8162 done
8163 done
8164
8165 fi
8166 fi
8167 OBJCOPY=$ac_cv_prog_OBJCOPY
8168 if test -n "$OBJCOPY"; then
8169   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8170 echo "${ECHO_T}$OBJCOPY" >&6
8171 else
8172   echo "$as_me:$LINENO: result: no" >&5
8173 echo "${ECHO_T}no" >&6
8174 fi
8175
8176   done
8177 fi
8178
8179 for ncn_progname in objcopy; do
8180   if test -n "$ncn_tool_prefix"; then
8181     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8182 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8183 echo "$as_me:$LINENO: checking for $ac_word" >&5
8184 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8185 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8186   echo $ECHO_N "(cached) $ECHO_C" >&6
8187 else
8188   if test -n "$OBJCOPY"; then
8189   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8190 else
8191 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8192 for as_dir in $PATH
8193 do
8194   IFS=$as_save_IFS
8195   test -z "$as_dir" && as_dir=.
8196   for ac_exec_ext in '' $ac_executable_extensions; do
8197   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8198     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8199     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8200     break 2
8201   fi
8202 done
8203 done
8204
8205 fi
8206 fi
8207 OBJCOPY=$ac_cv_prog_OBJCOPY
8208 if test -n "$OBJCOPY"; then
8209   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8210 echo "${ECHO_T}$OBJCOPY" >&6
8211 else
8212   echo "$as_me:$LINENO: result: no" >&5
8213 echo "${ECHO_T}no" >&6
8214 fi
8215
8216   fi
8217   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8218     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8219 set dummy ${ncn_progname}; ac_word=$2
8220 echo "$as_me:$LINENO: checking for $ac_word" >&5
8221 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8222 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8223   echo $ECHO_N "(cached) $ECHO_C" >&6
8224 else
8225   if test -n "$OBJCOPY"; then
8226   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8227 else
8228 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8229 for as_dir in $PATH
8230 do
8231   IFS=$as_save_IFS
8232   test -z "$as_dir" && as_dir=.
8233   for ac_exec_ext in '' $ac_executable_extensions; do
8234   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8235     ac_cv_prog_OBJCOPY="${ncn_progname}"
8236     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8237     break 2
8238   fi
8239 done
8240 done
8241
8242 fi
8243 fi
8244 OBJCOPY=$ac_cv_prog_OBJCOPY
8245 if test -n "$OBJCOPY"; then
8246   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8247 echo "${ECHO_T}$OBJCOPY" >&6
8248 else
8249   echo "$as_me:$LINENO: result: no" >&5
8250 echo "${ECHO_T}no" >&6
8251 fi
8252
8253   fi
8254   test -n "$ac_cv_prog_OBJCOPY" && break
8255 done
8256
8257 if test -z "$ac_cv_prog_OBJCOPY" ; then
8258   set dummy objcopy
8259   if test $build = $host ; then
8260     OBJCOPY="$2"
8261   else
8262     OBJCOPY="${ncn_tool_prefix}$2"
8263   fi
8264 fi
8265
8266
8267
8268 if test -n "$OBJDUMP"; then
8269   ac_cv_prog_OBJDUMP=$OBJDUMP
8270 elif test -n "$ac_cv_prog_OBJDUMP"; then
8271   OBJDUMP=$ac_cv_prog_OBJDUMP
8272 fi
8273
8274 if test -n "$ac_cv_prog_OBJDUMP"; then
8275   for ncn_progname in objdump; do
8276     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8277 set dummy ${ncn_progname}; ac_word=$2
8278 echo "$as_me:$LINENO: checking for $ac_word" >&5
8279 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8280 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8281   echo $ECHO_N "(cached) $ECHO_C" >&6
8282 else
8283   if test -n "$OBJDUMP"; then
8284   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8285 else
8286 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8287 for as_dir in $PATH
8288 do
8289   IFS=$as_save_IFS
8290   test -z "$as_dir" && as_dir=.
8291   for ac_exec_ext in '' $ac_executable_extensions; do
8292   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8293     ac_cv_prog_OBJDUMP="${ncn_progname}"
8294     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8295     break 2
8296   fi
8297 done
8298 done
8299
8300 fi
8301 fi
8302 OBJDUMP=$ac_cv_prog_OBJDUMP
8303 if test -n "$OBJDUMP"; then
8304   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8305 echo "${ECHO_T}$OBJDUMP" >&6
8306 else
8307   echo "$as_me:$LINENO: result: no" >&5
8308 echo "${ECHO_T}no" >&6
8309 fi
8310
8311   done
8312 fi
8313
8314 for ncn_progname in objdump; do
8315   if test -n "$ncn_tool_prefix"; then
8316     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8317 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8318 echo "$as_me:$LINENO: checking for $ac_word" >&5
8319 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8320 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8321   echo $ECHO_N "(cached) $ECHO_C" >&6
8322 else
8323   if test -n "$OBJDUMP"; then
8324   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8325 else
8326 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8327 for as_dir in $PATH
8328 do
8329   IFS=$as_save_IFS
8330   test -z "$as_dir" && as_dir=.
8331   for ac_exec_ext in '' $ac_executable_extensions; do
8332   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8333     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8334     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8335     break 2
8336   fi
8337 done
8338 done
8339
8340 fi
8341 fi
8342 OBJDUMP=$ac_cv_prog_OBJDUMP
8343 if test -n "$OBJDUMP"; then
8344   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8345 echo "${ECHO_T}$OBJDUMP" >&6
8346 else
8347   echo "$as_me:$LINENO: result: no" >&5
8348 echo "${ECHO_T}no" >&6
8349 fi
8350
8351   fi
8352   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8353     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8354 set dummy ${ncn_progname}; ac_word=$2
8355 echo "$as_me:$LINENO: checking for $ac_word" >&5
8356 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8357 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8358   echo $ECHO_N "(cached) $ECHO_C" >&6
8359 else
8360   if test -n "$OBJDUMP"; then
8361   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8362 else
8363 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8364 for as_dir in $PATH
8365 do
8366   IFS=$as_save_IFS
8367   test -z "$as_dir" && as_dir=.
8368   for ac_exec_ext in '' $ac_executable_extensions; do
8369   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8370     ac_cv_prog_OBJDUMP="${ncn_progname}"
8371     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8372     break 2
8373   fi
8374 done
8375 done
8376
8377 fi
8378 fi
8379 OBJDUMP=$ac_cv_prog_OBJDUMP
8380 if test -n "$OBJDUMP"; then
8381   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8382 echo "${ECHO_T}$OBJDUMP" >&6
8383 else
8384   echo "$as_me:$LINENO: result: no" >&5
8385 echo "${ECHO_T}no" >&6
8386 fi
8387
8388   fi
8389   test -n "$ac_cv_prog_OBJDUMP" && break
8390 done
8391
8392 if test -z "$ac_cv_prog_OBJDUMP" ; then
8393   set dummy objdump
8394   if test $build = $host ; then
8395     OBJDUMP="$2"
8396   else
8397     OBJDUMP="${ncn_tool_prefix}$2"
8398   fi
8399 fi
8400
8401
8402
8403
8404
8405
8406 # Target tools.
8407
8408 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8409 if test "${with_build_time_tools+set}" = set; then
8410   withval="$with_build_time_tools"
8411   case x"$withval" in
8412      x/*) ;;
8413      *)
8414        with_build_time_tools=
8415        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8416 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8417        ;;
8418    esac
8419 else
8420   with_build_time_tools=
8421 fi;
8422
8423
8424
8425 if test -n "$CC_FOR_TARGET"; then
8426   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8427 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8428   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8429 fi
8430
8431 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8432   for ncn_progname in cc gcc; do
8433     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8434 set dummy ${ncn_progname}; ac_word=$2
8435 echo "$as_me:$LINENO: checking for $ac_word" >&5
8436 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8437 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8438   echo $ECHO_N "(cached) $ECHO_C" >&6
8439 else
8440   if test -n "$CC_FOR_TARGET"; then
8441   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8442 else
8443 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8444 for as_dir in $PATH
8445 do
8446   IFS=$as_save_IFS
8447   test -z "$as_dir" && as_dir=.
8448   for ac_exec_ext in '' $ac_executable_extensions; do
8449   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8450     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8451     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8452     break 2
8453   fi
8454 done
8455 done
8456
8457 fi
8458 fi
8459 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8460 if test -n "$CC_FOR_TARGET"; then
8461   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8462 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8463 else
8464   echo "$as_me:$LINENO: result: no" >&5
8465 echo "${ECHO_T}no" >&6
8466 fi
8467
8468   done
8469 fi
8470
8471 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8472   for ncn_progname in cc gcc; do
8473     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8474 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8475     if test -x $with_build_time_tools/${ncn_progname}; then
8476       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8477       echo "$as_me:$LINENO: result: yes" >&5
8478 echo "${ECHO_T}yes" >&6
8479       break
8480     else
8481       echo "$as_me:$LINENO: result: no" >&5
8482 echo "${ECHO_T}no" >&6
8483     fi
8484   done
8485 fi
8486
8487 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8488   for ncn_progname in cc gcc; do
8489     if test -n "$ncn_target_tool_prefix"; then
8490       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8491 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8492 echo "$as_me:$LINENO: checking for $ac_word" >&5
8493 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8494 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8495   echo $ECHO_N "(cached) $ECHO_C" >&6
8496 else
8497   if test -n "$CC_FOR_TARGET"; then
8498   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8499 else
8500 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8501 for as_dir in $PATH
8502 do
8503   IFS=$as_save_IFS
8504   test -z "$as_dir" && as_dir=.
8505   for ac_exec_ext in '' $ac_executable_extensions; do
8506   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8507     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8508     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8509     break 2
8510   fi
8511 done
8512 done
8513
8514 fi
8515 fi
8516 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8517 if test -n "$CC_FOR_TARGET"; then
8518   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8519 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8520 else
8521   echo "$as_me:$LINENO: result: no" >&5
8522 echo "${ECHO_T}no" >&6
8523 fi
8524
8525     fi
8526     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8527       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8528 set dummy ${ncn_progname}; ac_word=$2
8529 echo "$as_me:$LINENO: checking for $ac_word" >&5
8530 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8531 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8532   echo $ECHO_N "(cached) $ECHO_C" >&6
8533 else
8534   if test -n "$CC_FOR_TARGET"; then
8535   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8536 else
8537 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8538 for as_dir in $PATH
8539 do
8540   IFS=$as_save_IFS
8541   test -z "$as_dir" && as_dir=.
8542   for ac_exec_ext in '' $ac_executable_extensions; do
8543   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8544     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8545     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8546     break 2
8547   fi
8548 done
8549 done
8550
8551 fi
8552 fi
8553 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8554 if test -n "$CC_FOR_TARGET"; then
8555   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8556 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8557 else
8558   echo "$as_me:$LINENO: result: no" >&5
8559 echo "${ECHO_T}no" >&6
8560 fi
8561
8562     fi
8563     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8564   done
8565 fi
8566
8567 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8568   set dummy cc gcc
8569   if test $build = $target ; then
8570     CC_FOR_TARGET="$2"
8571   else
8572     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8573   fi
8574 else
8575   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8576 fi
8577
8578
8579
8580 if test -n "$CXX_FOR_TARGET"; then
8581   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8582 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8583   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8584 fi
8585
8586 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8587   for ncn_progname in c++ g++ cxx gxx; do
8588     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8589 set dummy ${ncn_progname}; ac_word=$2
8590 echo "$as_me:$LINENO: checking for $ac_word" >&5
8591 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8592 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8593   echo $ECHO_N "(cached) $ECHO_C" >&6
8594 else
8595   if test -n "$CXX_FOR_TARGET"; then
8596   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8597 else
8598 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8599 for as_dir in $PATH
8600 do
8601   IFS=$as_save_IFS
8602   test -z "$as_dir" && as_dir=.
8603   for ac_exec_ext in '' $ac_executable_extensions; do
8604   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8605     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8606     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8607     break 2
8608   fi
8609 done
8610 done
8611
8612 fi
8613 fi
8614 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8615 if test -n "$CXX_FOR_TARGET"; then
8616   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8617 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8618 else
8619   echo "$as_me:$LINENO: result: no" >&5
8620 echo "${ECHO_T}no" >&6
8621 fi
8622
8623   done
8624 fi
8625
8626 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8627   for ncn_progname in c++ g++ cxx gxx; do
8628     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8629 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8630     if test -x $with_build_time_tools/${ncn_progname}; then
8631       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8632       echo "$as_me:$LINENO: result: yes" >&5
8633 echo "${ECHO_T}yes" >&6
8634       break
8635     else
8636       echo "$as_me:$LINENO: result: no" >&5
8637 echo "${ECHO_T}no" >&6
8638     fi
8639   done
8640 fi
8641
8642 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8643   for ncn_progname in c++ g++ cxx gxx; do
8644     if test -n "$ncn_target_tool_prefix"; then
8645       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8646 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8647 echo "$as_me:$LINENO: checking for $ac_word" >&5
8648 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8649 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8650   echo $ECHO_N "(cached) $ECHO_C" >&6
8651 else
8652   if test -n "$CXX_FOR_TARGET"; then
8653   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8654 else
8655 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8656 for as_dir in $PATH
8657 do
8658   IFS=$as_save_IFS
8659   test -z "$as_dir" && as_dir=.
8660   for ac_exec_ext in '' $ac_executable_extensions; do
8661   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8662     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8663     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8664     break 2
8665   fi
8666 done
8667 done
8668
8669 fi
8670 fi
8671 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8672 if test -n "$CXX_FOR_TARGET"; then
8673   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8674 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8675 else
8676   echo "$as_me:$LINENO: result: no" >&5
8677 echo "${ECHO_T}no" >&6
8678 fi
8679
8680     fi
8681     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8682       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8683 set dummy ${ncn_progname}; ac_word=$2
8684 echo "$as_me:$LINENO: checking for $ac_word" >&5
8685 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8686 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8687   echo $ECHO_N "(cached) $ECHO_C" >&6
8688 else
8689   if test -n "$CXX_FOR_TARGET"; then
8690   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8691 else
8692 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8693 for as_dir in $PATH
8694 do
8695   IFS=$as_save_IFS
8696   test -z "$as_dir" && as_dir=.
8697   for ac_exec_ext in '' $ac_executable_extensions; do
8698   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8699     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8700     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8701     break 2
8702   fi
8703 done
8704 done
8705
8706 fi
8707 fi
8708 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8709 if test -n "$CXX_FOR_TARGET"; then
8710   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8711 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8712 else
8713   echo "$as_me:$LINENO: result: no" >&5
8714 echo "${ECHO_T}no" >&6
8715 fi
8716
8717     fi
8718     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8719   done
8720 fi
8721
8722 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8723   set dummy c++ g++ cxx gxx
8724   if test $build = $target ; then
8725     CXX_FOR_TARGET="$2"
8726   else
8727     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8728   fi
8729 else
8730   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8731 fi
8732
8733
8734
8735 if test -n "$GCC_FOR_TARGET"; then
8736   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8737 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8738   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8739 fi
8740
8741 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8742   for ncn_progname in gcc; do
8743     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8744 set dummy ${ncn_progname}; ac_word=$2
8745 echo "$as_me:$LINENO: checking for $ac_word" >&5
8746 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8747 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8748   echo $ECHO_N "(cached) $ECHO_C" >&6
8749 else
8750   if test -n "$GCC_FOR_TARGET"; then
8751   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8752 else
8753 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8754 for as_dir in $PATH
8755 do
8756   IFS=$as_save_IFS
8757   test -z "$as_dir" && as_dir=.
8758   for ac_exec_ext in '' $ac_executable_extensions; do
8759   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8760     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8761     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8762     break 2
8763   fi
8764 done
8765 done
8766
8767 fi
8768 fi
8769 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8770 if test -n "$GCC_FOR_TARGET"; then
8771   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8772 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8773 else
8774   echo "$as_me:$LINENO: result: no" >&5
8775 echo "${ECHO_T}no" >&6
8776 fi
8777
8778   done
8779 fi
8780
8781 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8782   for ncn_progname in gcc; do
8783     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8784 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8785     if test -x $with_build_time_tools/${ncn_progname}; then
8786       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8787       echo "$as_me:$LINENO: result: yes" >&5
8788 echo "${ECHO_T}yes" >&6
8789       break
8790     else
8791       echo "$as_me:$LINENO: result: no" >&5
8792 echo "${ECHO_T}no" >&6
8793     fi
8794   done
8795 fi
8796
8797 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8798   for ncn_progname in gcc; do
8799     if test -n "$ncn_target_tool_prefix"; then
8800       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8801 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8802 echo "$as_me:$LINENO: checking for $ac_word" >&5
8803 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8804 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8805   echo $ECHO_N "(cached) $ECHO_C" >&6
8806 else
8807   if test -n "$GCC_FOR_TARGET"; then
8808   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8809 else
8810 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8811 for as_dir in $PATH
8812 do
8813   IFS=$as_save_IFS
8814   test -z "$as_dir" && as_dir=.
8815   for ac_exec_ext in '' $ac_executable_extensions; do
8816   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8817     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8818     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8819     break 2
8820   fi
8821 done
8822 done
8823
8824 fi
8825 fi
8826 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8827 if test -n "$GCC_FOR_TARGET"; then
8828   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8829 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8830 else
8831   echo "$as_me:$LINENO: result: no" >&5
8832 echo "${ECHO_T}no" >&6
8833 fi
8834
8835     fi
8836     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8837       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8838 set dummy ${ncn_progname}; ac_word=$2
8839 echo "$as_me:$LINENO: checking for $ac_word" >&5
8840 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8841 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8842   echo $ECHO_N "(cached) $ECHO_C" >&6
8843 else
8844   if test -n "$GCC_FOR_TARGET"; then
8845   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8846 else
8847 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8848 for as_dir in $PATH
8849 do
8850   IFS=$as_save_IFS
8851   test -z "$as_dir" && as_dir=.
8852   for ac_exec_ext in '' $ac_executable_extensions; do
8853   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8854     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8855     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8856     break 2
8857   fi
8858 done
8859 done
8860
8861 fi
8862 fi
8863 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8864 if test -n "$GCC_FOR_TARGET"; then
8865   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8866 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8867 else
8868   echo "$as_me:$LINENO: result: no" >&5
8869 echo "${ECHO_T}no" >&6
8870 fi
8871
8872     fi
8873     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8874   done
8875 fi
8876
8877 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8878   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8879 else
8880   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8881 fi
8882
8883
8884
8885 if test -n "$GCJ_FOR_TARGET"; then
8886   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8887 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8888   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8889 fi
8890
8891 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8892   for ncn_progname in gcj; do
8893     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8894 set dummy ${ncn_progname}; ac_word=$2
8895 echo "$as_me:$LINENO: checking for $ac_word" >&5
8896 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8897 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8898   echo $ECHO_N "(cached) $ECHO_C" >&6
8899 else
8900   if test -n "$GCJ_FOR_TARGET"; then
8901   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8902 else
8903 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8904 for as_dir in $PATH
8905 do
8906   IFS=$as_save_IFS
8907   test -z "$as_dir" && as_dir=.
8908   for ac_exec_ext in '' $ac_executable_extensions; do
8909   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8910     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8911     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8912     break 2
8913   fi
8914 done
8915 done
8916
8917 fi
8918 fi
8919 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8920 if test -n "$GCJ_FOR_TARGET"; then
8921   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8922 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8923 else
8924   echo "$as_me:$LINENO: result: no" >&5
8925 echo "${ECHO_T}no" >&6
8926 fi
8927
8928   done
8929 fi
8930
8931 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8932   for ncn_progname in gcj; do
8933     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8934 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8935     if test -x $with_build_time_tools/${ncn_progname}; then
8936       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8937       echo "$as_me:$LINENO: result: yes" >&5
8938 echo "${ECHO_T}yes" >&6
8939       break
8940     else
8941       echo "$as_me:$LINENO: result: no" >&5
8942 echo "${ECHO_T}no" >&6
8943     fi
8944   done
8945 fi
8946
8947 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8948   for ncn_progname in gcj; do
8949     if test -n "$ncn_target_tool_prefix"; then
8950       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8951 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8952 echo "$as_me:$LINENO: checking for $ac_word" >&5
8953 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8954 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8955   echo $ECHO_N "(cached) $ECHO_C" >&6
8956 else
8957   if test -n "$GCJ_FOR_TARGET"; then
8958   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8959 else
8960 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8961 for as_dir in $PATH
8962 do
8963   IFS=$as_save_IFS
8964   test -z "$as_dir" && as_dir=.
8965   for ac_exec_ext in '' $ac_executable_extensions; do
8966   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8967     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8968     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8969     break 2
8970   fi
8971 done
8972 done
8973
8974 fi
8975 fi
8976 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8977 if test -n "$GCJ_FOR_TARGET"; then
8978   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8979 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8980 else
8981   echo "$as_me:$LINENO: result: no" >&5
8982 echo "${ECHO_T}no" >&6
8983 fi
8984
8985     fi
8986     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8987       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8988 set dummy ${ncn_progname}; ac_word=$2
8989 echo "$as_me:$LINENO: checking for $ac_word" >&5
8990 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8991 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8992   echo $ECHO_N "(cached) $ECHO_C" >&6
8993 else
8994   if test -n "$GCJ_FOR_TARGET"; then
8995   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8996 else
8997 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8998 for as_dir in $PATH
8999 do
9000   IFS=$as_save_IFS
9001   test -z "$as_dir" && as_dir=.
9002   for ac_exec_ext in '' $ac_executable_extensions; do
9003   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9004     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9005     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9006     break 2
9007   fi
9008 done
9009 done
9010
9011 fi
9012 fi
9013 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9014 if test -n "$GCJ_FOR_TARGET"; then
9015   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9016 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9017 else
9018   echo "$as_me:$LINENO: result: no" >&5
9019 echo "${ECHO_T}no" >&6
9020 fi
9021
9022     fi
9023     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
9024   done
9025 fi
9026
9027 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9028   set dummy gcj
9029   if test $build = $target ; then
9030     GCJ_FOR_TARGET="$2"
9031   else
9032     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9033   fi
9034 else
9035   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9036 fi
9037
9038
9039
9040 if test -n "$GFORTRAN_FOR_TARGET"; then
9041   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9042 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9043   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9044 fi
9045
9046 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9047   for ncn_progname in gfortran; do
9048     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9049 set dummy ${ncn_progname}; ac_word=$2
9050 echo "$as_me:$LINENO: checking for $ac_word" >&5
9051 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9052 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9053   echo $ECHO_N "(cached) $ECHO_C" >&6
9054 else
9055   if test -n "$GFORTRAN_FOR_TARGET"; then
9056   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9057 else
9058 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9059 for as_dir in $PATH
9060 do
9061   IFS=$as_save_IFS
9062   test -z "$as_dir" && as_dir=.
9063   for ac_exec_ext in '' $ac_executable_extensions; do
9064   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9065     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9066     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9067     break 2
9068   fi
9069 done
9070 done
9071
9072 fi
9073 fi
9074 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9075 if test -n "$GFORTRAN_FOR_TARGET"; then
9076   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9077 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9078 else
9079   echo "$as_me:$LINENO: result: no" >&5
9080 echo "${ECHO_T}no" >&6
9081 fi
9082
9083   done
9084 fi
9085
9086 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9087   for ncn_progname in gfortran; do
9088     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9089 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9090     if test -x $with_build_time_tools/${ncn_progname}; then
9091       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9092       echo "$as_me:$LINENO: result: yes" >&5
9093 echo "${ECHO_T}yes" >&6
9094       break
9095     else
9096       echo "$as_me:$LINENO: result: no" >&5
9097 echo "${ECHO_T}no" >&6
9098     fi
9099   done
9100 fi
9101
9102 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9103   for ncn_progname in gfortran; do
9104     if test -n "$ncn_target_tool_prefix"; then
9105       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9106 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9107 echo "$as_me:$LINENO: checking for $ac_word" >&5
9108 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9109 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9110   echo $ECHO_N "(cached) $ECHO_C" >&6
9111 else
9112   if test -n "$GFORTRAN_FOR_TARGET"; then
9113   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9114 else
9115 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9116 for as_dir in $PATH
9117 do
9118   IFS=$as_save_IFS
9119   test -z "$as_dir" && as_dir=.
9120   for ac_exec_ext in '' $ac_executable_extensions; do
9121   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9122     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9123     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9124     break 2
9125   fi
9126 done
9127 done
9128
9129 fi
9130 fi
9131 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9132 if test -n "$GFORTRAN_FOR_TARGET"; then
9133   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9134 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9135 else
9136   echo "$as_me:$LINENO: result: no" >&5
9137 echo "${ECHO_T}no" >&6
9138 fi
9139
9140     fi
9141     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9142       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9143 set dummy ${ncn_progname}; ac_word=$2
9144 echo "$as_me:$LINENO: checking for $ac_word" >&5
9145 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9146 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9147   echo $ECHO_N "(cached) $ECHO_C" >&6
9148 else
9149   if test -n "$GFORTRAN_FOR_TARGET"; then
9150   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9151 else
9152 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9153 for as_dir in $PATH
9154 do
9155   IFS=$as_save_IFS
9156   test -z "$as_dir" && as_dir=.
9157   for ac_exec_ext in '' $ac_executable_extensions; do
9158   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9159     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9160     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9161     break 2
9162   fi
9163 done
9164 done
9165
9166 fi
9167 fi
9168 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9169 if test -n "$GFORTRAN_FOR_TARGET"; then
9170   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9171 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9172 else
9173   echo "$as_me:$LINENO: result: no" >&5
9174 echo "${ECHO_T}no" >&6
9175 fi
9176
9177     fi
9178     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9179   done
9180 fi
9181
9182 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9183   set dummy gfortran
9184   if test $build = $target ; then
9185     GFORTRAN_FOR_TARGET="$2"
9186   else
9187     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9188   fi
9189 else
9190   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9191 fi
9192
9193
9194
9195 cat > conftest.c << \EOF
9196 #ifdef __GNUC__
9197   gcc_yay;
9198 #endif
9199 EOF
9200 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9201   have_gcc_for_target=yes
9202 else
9203   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9204   have_gcc_for_target=no
9205 fi
9206 rm conftest.c
9207
9208
9209
9210
9211 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9212   if test -n "$with_build_time_tools"; then
9213     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9214 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9215     if test -x $with_build_time_tools/ar; then
9216       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9217       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9218       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9219 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9220     else
9221       echo "$as_me:$LINENO: result: no" >&5
9222 echo "${ECHO_T}no" >&6
9223     fi
9224   elif test $build != $host && test $have_gcc_for_target = yes; then
9225     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9226     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9227     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9228   fi
9229 fi
9230 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9231   # Extract the first word of "ar", so it can be a program name with args.
9232 set dummy ar; ac_word=$2
9233 echo "$as_me:$LINENO: checking for $ac_word" >&5
9234 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9235 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9236   echo $ECHO_N "(cached) $ECHO_C" >&6
9237 else
9238   case $AR_FOR_TARGET in
9239   [\\/]* | ?:[\\/]*)
9240   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9241   ;;
9242   *)
9243   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9244 for as_dir in $gcc_cv_tool_dirs
9245 do
9246   IFS=$as_save_IFS
9247   test -z "$as_dir" && as_dir=.
9248   for ac_exec_ext in '' $ac_executable_extensions; do
9249   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9250     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9251     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9252     break 2
9253   fi
9254 done
9255 done
9256
9257   ;;
9258 esac
9259 fi
9260 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9261
9262 if test -n "$AR_FOR_TARGET"; then
9263   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9264 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9265 else
9266   echo "$as_me:$LINENO: result: no" >&5
9267 echo "${ECHO_T}no" >&6
9268 fi
9269
9270 fi
9271 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9272
9273
9274 if test -n "$AR_FOR_TARGET"; then
9275   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9276 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9277   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9278 fi
9279
9280 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9281   for ncn_progname in ar; do
9282     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9283 set dummy ${ncn_progname}; ac_word=$2
9284 echo "$as_me:$LINENO: checking for $ac_word" >&5
9285 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9286 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9287   echo $ECHO_N "(cached) $ECHO_C" >&6
9288 else
9289   if test -n "$AR_FOR_TARGET"; then
9290   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9291 else
9292 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9293 for as_dir in $PATH
9294 do
9295   IFS=$as_save_IFS
9296   test -z "$as_dir" && as_dir=.
9297   for ac_exec_ext in '' $ac_executable_extensions; do
9298   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9299     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9300     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9301     break 2
9302   fi
9303 done
9304 done
9305
9306 fi
9307 fi
9308 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9309 if test -n "$AR_FOR_TARGET"; then
9310   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9311 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9312 else
9313   echo "$as_me:$LINENO: result: no" >&5
9314 echo "${ECHO_T}no" >&6
9315 fi
9316
9317   done
9318 fi
9319
9320 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9321   for ncn_progname in ar; do
9322     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9323 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9324     if test -x $with_build_time_tools/${ncn_progname}; then
9325       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9326       echo "$as_me:$LINENO: result: yes" >&5
9327 echo "${ECHO_T}yes" >&6
9328       break
9329     else
9330       echo "$as_me:$LINENO: result: no" >&5
9331 echo "${ECHO_T}no" >&6
9332     fi
9333   done
9334 fi
9335
9336 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9337   for ncn_progname in ar; do
9338     if test -n "$ncn_target_tool_prefix"; then
9339       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9340 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9341 echo "$as_me:$LINENO: checking for $ac_word" >&5
9342 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9343 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9344   echo $ECHO_N "(cached) $ECHO_C" >&6
9345 else
9346   if test -n "$AR_FOR_TARGET"; then
9347   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9348 else
9349 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9350 for as_dir in $PATH
9351 do
9352   IFS=$as_save_IFS
9353   test -z "$as_dir" && as_dir=.
9354   for ac_exec_ext in '' $ac_executable_extensions; do
9355   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9356     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9357     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9358     break 2
9359   fi
9360 done
9361 done
9362
9363 fi
9364 fi
9365 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9366 if test -n "$AR_FOR_TARGET"; then
9367   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9368 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9369 else
9370   echo "$as_me:$LINENO: result: no" >&5
9371 echo "${ECHO_T}no" >&6
9372 fi
9373
9374     fi
9375     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9376       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9377 set dummy ${ncn_progname}; ac_word=$2
9378 echo "$as_me:$LINENO: checking for $ac_word" >&5
9379 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9380 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9381   echo $ECHO_N "(cached) $ECHO_C" >&6
9382 else
9383   if test -n "$AR_FOR_TARGET"; then
9384   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9385 else
9386 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9387 for as_dir in $PATH
9388 do
9389   IFS=$as_save_IFS
9390   test -z "$as_dir" && as_dir=.
9391   for ac_exec_ext in '' $ac_executable_extensions; do
9392   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9393     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9394     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9395     break 2
9396   fi
9397 done
9398 done
9399
9400 fi
9401 fi
9402 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9403 if test -n "$AR_FOR_TARGET"; then
9404   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9405 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9406 else
9407   echo "$as_me:$LINENO: result: no" >&5
9408 echo "${ECHO_T}no" >&6
9409 fi
9410
9411     fi
9412     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9413   done
9414 fi
9415
9416 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9417   set dummy ar
9418   if test $build = $target ; then
9419     AR_FOR_TARGET="$2"
9420   else
9421     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9422   fi
9423 else
9424   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9425 fi
9426
9427 else
9428   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9429 fi
9430
9431
9432
9433
9434 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9435   if test -n "$with_build_time_tools"; then
9436     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9437 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9438     if test -x $with_build_time_tools/as; then
9439       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9440       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9441       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9442 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9443     else
9444       echo "$as_me:$LINENO: result: no" >&5
9445 echo "${ECHO_T}no" >&6
9446     fi
9447   elif test $build != $host && test $have_gcc_for_target = yes; then
9448     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9449     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9450     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9451   fi
9452 fi
9453 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9454   # Extract the first word of "as", so it can be a program name with args.
9455 set dummy as; ac_word=$2
9456 echo "$as_me:$LINENO: checking for $ac_word" >&5
9457 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9458 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9459   echo $ECHO_N "(cached) $ECHO_C" >&6
9460 else
9461   case $AS_FOR_TARGET in
9462   [\\/]* | ?:[\\/]*)
9463   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9464   ;;
9465   *)
9466   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9467 for as_dir in $gcc_cv_tool_dirs
9468 do
9469   IFS=$as_save_IFS
9470   test -z "$as_dir" && as_dir=.
9471   for ac_exec_ext in '' $ac_executable_extensions; do
9472   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9473     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9474     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9475     break 2
9476   fi
9477 done
9478 done
9479
9480   ;;
9481 esac
9482 fi
9483 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9484
9485 if test -n "$AS_FOR_TARGET"; then
9486   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9487 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9488 else
9489   echo "$as_me:$LINENO: result: no" >&5
9490 echo "${ECHO_T}no" >&6
9491 fi
9492
9493 fi
9494 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9495
9496
9497 if test -n "$AS_FOR_TARGET"; then
9498   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9499 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9500   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9501 fi
9502
9503 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9504   for ncn_progname in as; do
9505     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9506 set dummy ${ncn_progname}; ac_word=$2
9507 echo "$as_me:$LINENO: checking for $ac_word" >&5
9508 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9509 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9510   echo $ECHO_N "(cached) $ECHO_C" >&6
9511 else
9512   if test -n "$AS_FOR_TARGET"; then
9513   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9514 else
9515 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9516 for as_dir in $PATH
9517 do
9518   IFS=$as_save_IFS
9519   test -z "$as_dir" && as_dir=.
9520   for ac_exec_ext in '' $ac_executable_extensions; do
9521   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9522     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9523     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9524     break 2
9525   fi
9526 done
9527 done
9528
9529 fi
9530 fi
9531 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9532 if test -n "$AS_FOR_TARGET"; then
9533   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9534 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9535 else
9536   echo "$as_me:$LINENO: result: no" >&5
9537 echo "${ECHO_T}no" >&6
9538 fi
9539
9540   done
9541 fi
9542
9543 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9544   for ncn_progname in as; do
9545     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9546 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9547     if test -x $with_build_time_tools/${ncn_progname}; then
9548       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9549       echo "$as_me:$LINENO: result: yes" >&5
9550 echo "${ECHO_T}yes" >&6
9551       break
9552     else
9553       echo "$as_me:$LINENO: result: no" >&5
9554 echo "${ECHO_T}no" >&6
9555     fi
9556   done
9557 fi
9558
9559 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9560   for ncn_progname in as; do
9561     if test -n "$ncn_target_tool_prefix"; then
9562       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9563 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9564 echo "$as_me:$LINENO: checking for $ac_word" >&5
9565 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9566 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9567   echo $ECHO_N "(cached) $ECHO_C" >&6
9568 else
9569   if test -n "$AS_FOR_TARGET"; then
9570   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9571 else
9572 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9573 for as_dir in $PATH
9574 do
9575   IFS=$as_save_IFS
9576   test -z "$as_dir" && as_dir=.
9577   for ac_exec_ext in '' $ac_executable_extensions; do
9578   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9579     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9580     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9581     break 2
9582   fi
9583 done
9584 done
9585
9586 fi
9587 fi
9588 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9589 if test -n "$AS_FOR_TARGET"; then
9590   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9591 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9592 else
9593   echo "$as_me:$LINENO: result: no" >&5
9594 echo "${ECHO_T}no" >&6
9595 fi
9596
9597     fi
9598     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9599       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9600 set dummy ${ncn_progname}; ac_word=$2
9601 echo "$as_me:$LINENO: checking for $ac_word" >&5
9602 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9603 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9604   echo $ECHO_N "(cached) $ECHO_C" >&6
9605 else
9606   if test -n "$AS_FOR_TARGET"; then
9607   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9608 else
9609 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9610 for as_dir in $PATH
9611 do
9612   IFS=$as_save_IFS
9613   test -z "$as_dir" && as_dir=.
9614   for ac_exec_ext in '' $ac_executable_extensions; do
9615   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9616     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9617     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9618     break 2
9619   fi
9620 done
9621 done
9622
9623 fi
9624 fi
9625 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9626 if test -n "$AS_FOR_TARGET"; then
9627   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9628 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9629 else
9630   echo "$as_me:$LINENO: result: no" >&5
9631 echo "${ECHO_T}no" >&6
9632 fi
9633
9634     fi
9635     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9636   done
9637 fi
9638
9639 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9640   set dummy as
9641   if test $build = $target ; then
9642     AS_FOR_TARGET="$2"
9643   else
9644     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9645   fi
9646 else
9647   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9648 fi
9649
9650 else
9651   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9652 fi
9653
9654
9655
9656
9657 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9658   if test -n "$with_build_time_tools"; then
9659     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9660 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9661     if test -x $with_build_time_tools/dlltool; then
9662       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9663       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9664       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9665 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9666     else
9667       echo "$as_me:$LINENO: result: no" >&5
9668 echo "${ECHO_T}no" >&6
9669     fi
9670   elif test $build != $host && test $have_gcc_for_target = yes; then
9671     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9672     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9673     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9674   fi
9675 fi
9676 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9677   # Extract the first word of "dlltool", so it can be a program name with args.
9678 set dummy dlltool; ac_word=$2
9679 echo "$as_me:$LINENO: checking for $ac_word" >&5
9680 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9681 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9682   echo $ECHO_N "(cached) $ECHO_C" >&6
9683 else
9684   case $DLLTOOL_FOR_TARGET in
9685   [\\/]* | ?:[\\/]*)
9686   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9687   ;;
9688   *)
9689   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9690 for as_dir in $gcc_cv_tool_dirs
9691 do
9692   IFS=$as_save_IFS
9693   test -z "$as_dir" && as_dir=.
9694   for ac_exec_ext in '' $ac_executable_extensions; do
9695   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9696     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9697     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9698     break 2
9699   fi
9700 done
9701 done
9702
9703   ;;
9704 esac
9705 fi
9706 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9707
9708 if test -n "$DLLTOOL_FOR_TARGET"; then
9709   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9710 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9711 else
9712   echo "$as_me:$LINENO: result: no" >&5
9713 echo "${ECHO_T}no" >&6
9714 fi
9715
9716 fi
9717 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9718
9719
9720 if test -n "$DLLTOOL_FOR_TARGET"; then
9721   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9722 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9723   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9724 fi
9725
9726 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9727   for ncn_progname in dlltool; do
9728     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9729 set dummy ${ncn_progname}; ac_word=$2
9730 echo "$as_me:$LINENO: checking for $ac_word" >&5
9731 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9732 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9733   echo $ECHO_N "(cached) $ECHO_C" >&6
9734 else
9735   if test -n "$DLLTOOL_FOR_TARGET"; then
9736   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9737 else
9738 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9739 for as_dir in $PATH
9740 do
9741   IFS=$as_save_IFS
9742   test -z "$as_dir" && as_dir=.
9743   for ac_exec_ext in '' $ac_executable_extensions; do
9744   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9745     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9746     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9747     break 2
9748   fi
9749 done
9750 done
9751
9752 fi
9753 fi
9754 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9755 if test -n "$DLLTOOL_FOR_TARGET"; then
9756   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9757 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9758 else
9759   echo "$as_me:$LINENO: result: no" >&5
9760 echo "${ECHO_T}no" >&6
9761 fi
9762
9763   done
9764 fi
9765
9766 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9767   for ncn_progname in dlltool; do
9768     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9769 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9770     if test -x $with_build_time_tools/${ncn_progname}; then
9771       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9772       echo "$as_me:$LINENO: result: yes" >&5
9773 echo "${ECHO_T}yes" >&6
9774       break
9775     else
9776       echo "$as_me:$LINENO: result: no" >&5
9777 echo "${ECHO_T}no" >&6
9778     fi
9779   done
9780 fi
9781
9782 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9783   for ncn_progname in dlltool; do
9784     if test -n "$ncn_target_tool_prefix"; then
9785       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9786 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9787 echo "$as_me:$LINENO: checking for $ac_word" >&5
9788 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9789 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9790   echo $ECHO_N "(cached) $ECHO_C" >&6
9791 else
9792   if test -n "$DLLTOOL_FOR_TARGET"; then
9793   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9794 else
9795 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9796 for as_dir in $PATH
9797 do
9798   IFS=$as_save_IFS
9799   test -z "$as_dir" && as_dir=.
9800   for ac_exec_ext in '' $ac_executable_extensions; do
9801   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9802     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9803     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9804     break 2
9805   fi
9806 done
9807 done
9808
9809 fi
9810 fi
9811 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9812 if test -n "$DLLTOOL_FOR_TARGET"; then
9813   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9814 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9815 else
9816   echo "$as_me:$LINENO: result: no" >&5
9817 echo "${ECHO_T}no" >&6
9818 fi
9819
9820     fi
9821     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9822       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9823 set dummy ${ncn_progname}; ac_word=$2
9824 echo "$as_me:$LINENO: checking for $ac_word" >&5
9825 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9826 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9827   echo $ECHO_N "(cached) $ECHO_C" >&6
9828 else
9829   if test -n "$DLLTOOL_FOR_TARGET"; then
9830   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9831 else
9832 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9833 for as_dir in $PATH
9834 do
9835   IFS=$as_save_IFS
9836   test -z "$as_dir" && as_dir=.
9837   for ac_exec_ext in '' $ac_executable_extensions; do
9838   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9839     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9840     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9841     break 2
9842   fi
9843 done
9844 done
9845
9846 fi
9847 fi
9848 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9849 if test -n "$DLLTOOL_FOR_TARGET"; then
9850   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9851 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9852 else
9853   echo "$as_me:$LINENO: result: no" >&5
9854 echo "${ECHO_T}no" >&6
9855 fi
9856
9857     fi
9858     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9859   done
9860 fi
9861
9862 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9863   set dummy dlltool
9864   if test $build = $target ; then
9865     DLLTOOL_FOR_TARGET="$2"
9866   else
9867     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9868   fi
9869 else
9870   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9871 fi
9872
9873 else
9874   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9875 fi
9876
9877
9878
9879
9880 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9881   if test -n "$with_build_time_tools"; then
9882     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9883 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9884     if test -x $with_build_time_tools/ld; then
9885       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9886       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9887       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9888 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9889     else
9890       echo "$as_me:$LINENO: result: no" >&5
9891 echo "${ECHO_T}no" >&6
9892     fi
9893   elif test $build != $host && test $have_gcc_for_target = yes; then
9894     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9895     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9896     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9897   fi
9898 fi
9899 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9900   # Extract the first word of "ld", so it can be a program name with args.
9901 set dummy ld; ac_word=$2
9902 echo "$as_me:$LINENO: checking for $ac_word" >&5
9903 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9904 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9905   echo $ECHO_N "(cached) $ECHO_C" >&6
9906 else
9907   case $LD_FOR_TARGET in
9908   [\\/]* | ?:[\\/]*)
9909   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9910   ;;
9911   *)
9912   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9913 for as_dir in $gcc_cv_tool_dirs
9914 do
9915   IFS=$as_save_IFS
9916   test -z "$as_dir" && as_dir=.
9917   for ac_exec_ext in '' $ac_executable_extensions; do
9918   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9919     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9920     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9921     break 2
9922   fi
9923 done
9924 done
9925
9926   ;;
9927 esac
9928 fi
9929 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9930
9931 if test -n "$LD_FOR_TARGET"; then
9932   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9933 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9934 else
9935   echo "$as_me:$LINENO: result: no" >&5
9936 echo "${ECHO_T}no" >&6
9937 fi
9938
9939 fi
9940 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9941
9942
9943 if test -n "$LD_FOR_TARGET"; then
9944   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9945 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9946   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9947 fi
9948
9949 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9950   for ncn_progname in ld; do
9951     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9952 set dummy ${ncn_progname}; ac_word=$2
9953 echo "$as_me:$LINENO: checking for $ac_word" >&5
9954 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9955 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9956   echo $ECHO_N "(cached) $ECHO_C" >&6
9957 else
9958   if test -n "$LD_FOR_TARGET"; then
9959   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9960 else
9961 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9962 for as_dir in $PATH
9963 do
9964   IFS=$as_save_IFS
9965   test -z "$as_dir" && as_dir=.
9966   for ac_exec_ext in '' $ac_executable_extensions; do
9967   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9968     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9969     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9970     break 2
9971   fi
9972 done
9973 done
9974
9975 fi
9976 fi
9977 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9978 if test -n "$LD_FOR_TARGET"; then
9979   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9980 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9981 else
9982   echo "$as_me:$LINENO: result: no" >&5
9983 echo "${ECHO_T}no" >&6
9984 fi
9985
9986   done
9987 fi
9988
9989 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9990   for ncn_progname in ld; do
9991     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9992 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9993     if test -x $with_build_time_tools/${ncn_progname}; then
9994       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9995       echo "$as_me:$LINENO: result: yes" >&5
9996 echo "${ECHO_T}yes" >&6
9997       break
9998     else
9999       echo "$as_me:$LINENO: result: no" >&5
10000 echo "${ECHO_T}no" >&6
10001     fi
10002   done
10003 fi
10004
10005 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
10006   for ncn_progname in ld; do
10007     if test -n "$ncn_target_tool_prefix"; then
10008       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10009 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10010 echo "$as_me:$LINENO: checking for $ac_word" >&5
10011 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10012 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10013   echo $ECHO_N "(cached) $ECHO_C" >&6
10014 else
10015   if test -n "$LD_FOR_TARGET"; then
10016   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10017 else
10018 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10019 for as_dir in $PATH
10020 do
10021   IFS=$as_save_IFS
10022   test -z "$as_dir" && as_dir=.
10023   for ac_exec_ext in '' $ac_executable_extensions; do
10024   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10025     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10026     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10027     break 2
10028   fi
10029 done
10030 done
10031
10032 fi
10033 fi
10034 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10035 if test -n "$LD_FOR_TARGET"; then
10036   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10037 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10038 else
10039   echo "$as_me:$LINENO: result: no" >&5
10040 echo "${ECHO_T}no" >&6
10041 fi
10042
10043     fi
10044     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10045       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10046 set dummy ${ncn_progname}; ac_word=$2
10047 echo "$as_me:$LINENO: checking for $ac_word" >&5
10048 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10049 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10050   echo $ECHO_N "(cached) $ECHO_C" >&6
10051 else
10052   if test -n "$LD_FOR_TARGET"; then
10053   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10054 else
10055 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10056 for as_dir in $PATH
10057 do
10058   IFS=$as_save_IFS
10059   test -z "$as_dir" && as_dir=.
10060   for ac_exec_ext in '' $ac_executable_extensions; do
10061   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10062     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10063     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10064     break 2
10065   fi
10066 done
10067 done
10068
10069 fi
10070 fi
10071 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10072 if test -n "$LD_FOR_TARGET"; then
10073   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10074 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10075 else
10076   echo "$as_me:$LINENO: result: no" >&5
10077 echo "${ECHO_T}no" >&6
10078 fi
10079
10080     fi
10081     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10082   done
10083 fi
10084
10085 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10086   set dummy ld
10087   if test $build = $target ; then
10088     LD_FOR_TARGET="$2"
10089   else
10090     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10091   fi
10092 else
10093   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10094 fi
10095
10096 else
10097   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10098 fi
10099
10100
10101
10102
10103 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10104   if test -n "$with_build_time_tools"; then
10105     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10106 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10107     if test -x $with_build_time_tools/lipo; then
10108       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10109       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10110       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10111 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10112     else
10113       echo "$as_me:$LINENO: result: no" >&5
10114 echo "${ECHO_T}no" >&6
10115     fi
10116   elif test $build != $host && test $have_gcc_for_target = yes; then
10117     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10118     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10119     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10120   fi
10121 fi
10122 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10123   # Extract the first word of "lipo", so it can be a program name with args.
10124 set dummy lipo; ac_word=$2
10125 echo "$as_me:$LINENO: checking for $ac_word" >&5
10126 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10127 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10128   echo $ECHO_N "(cached) $ECHO_C" >&6
10129 else
10130   case $LIPO_FOR_TARGET in
10131   [\\/]* | ?:[\\/]*)
10132   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10133   ;;
10134   *)
10135   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10136 for as_dir in $gcc_cv_tool_dirs
10137 do
10138   IFS=$as_save_IFS
10139   test -z "$as_dir" && as_dir=.
10140   for ac_exec_ext in '' $ac_executable_extensions; do
10141   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10142     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10143     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10144     break 2
10145   fi
10146 done
10147 done
10148
10149   ;;
10150 esac
10151 fi
10152 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10153
10154 if test -n "$LIPO_FOR_TARGET"; then
10155   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10156 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10157 else
10158   echo "$as_me:$LINENO: result: no" >&5
10159 echo "${ECHO_T}no" >&6
10160 fi
10161
10162 fi
10163 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10164
10165
10166 if test -n "$LIPO_FOR_TARGET"; then
10167   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10168 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10169   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10170 fi
10171
10172 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10173   for ncn_progname in lipo; do
10174     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10175 set dummy ${ncn_progname}; ac_word=$2
10176 echo "$as_me:$LINENO: checking for $ac_word" >&5
10177 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10178 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10179   echo $ECHO_N "(cached) $ECHO_C" >&6
10180 else
10181   if test -n "$LIPO_FOR_TARGET"; then
10182   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10183 else
10184 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10185 for as_dir in $PATH
10186 do
10187   IFS=$as_save_IFS
10188   test -z "$as_dir" && as_dir=.
10189   for ac_exec_ext in '' $ac_executable_extensions; do
10190   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10191     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10192     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10193     break 2
10194   fi
10195 done
10196 done
10197
10198 fi
10199 fi
10200 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10201 if test -n "$LIPO_FOR_TARGET"; then
10202   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10203 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10204 else
10205   echo "$as_me:$LINENO: result: no" >&5
10206 echo "${ECHO_T}no" >&6
10207 fi
10208
10209   done
10210 fi
10211
10212 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10213   for ncn_progname in lipo; do
10214     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10215 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10216     if test -x $with_build_time_tools/${ncn_progname}; then
10217       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10218       echo "$as_me:$LINENO: result: yes" >&5
10219 echo "${ECHO_T}yes" >&6
10220       break
10221     else
10222       echo "$as_me:$LINENO: result: no" >&5
10223 echo "${ECHO_T}no" >&6
10224     fi
10225   done
10226 fi
10227
10228 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10229   for ncn_progname in lipo; do
10230     if test -n "$ncn_target_tool_prefix"; then
10231       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10232 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10233 echo "$as_me:$LINENO: checking for $ac_word" >&5
10234 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10235 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10236   echo $ECHO_N "(cached) $ECHO_C" >&6
10237 else
10238   if test -n "$LIPO_FOR_TARGET"; then
10239   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10240 else
10241 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10242 for as_dir in $PATH
10243 do
10244   IFS=$as_save_IFS
10245   test -z "$as_dir" && as_dir=.
10246   for ac_exec_ext in '' $ac_executable_extensions; do
10247   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10248     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10249     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10250     break 2
10251   fi
10252 done
10253 done
10254
10255 fi
10256 fi
10257 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10258 if test -n "$LIPO_FOR_TARGET"; then
10259   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10260 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10261 else
10262   echo "$as_me:$LINENO: result: no" >&5
10263 echo "${ECHO_T}no" >&6
10264 fi
10265
10266     fi
10267     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10268       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10269 set dummy ${ncn_progname}; ac_word=$2
10270 echo "$as_me:$LINENO: checking for $ac_word" >&5
10271 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10272 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10273   echo $ECHO_N "(cached) $ECHO_C" >&6
10274 else
10275   if test -n "$LIPO_FOR_TARGET"; then
10276   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10277 else
10278 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10279 for as_dir in $PATH
10280 do
10281   IFS=$as_save_IFS
10282   test -z "$as_dir" && as_dir=.
10283   for ac_exec_ext in '' $ac_executable_extensions; do
10284   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10285     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10286     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10287     break 2
10288   fi
10289 done
10290 done
10291
10292 fi
10293 fi
10294 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10295 if test -n "$LIPO_FOR_TARGET"; then
10296   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10297 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10298 else
10299   echo "$as_me:$LINENO: result: no" >&5
10300 echo "${ECHO_T}no" >&6
10301 fi
10302
10303     fi
10304     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10305   done
10306 fi
10307
10308 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10309   set dummy lipo
10310   if test $build = $target ; then
10311     LIPO_FOR_TARGET="$2"
10312   else
10313     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10314   fi
10315 else
10316   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10317 fi
10318
10319 else
10320   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10321 fi
10322
10323
10324
10325
10326 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10327   if test -n "$with_build_time_tools"; then
10328     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10329 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10330     if test -x $with_build_time_tools/nm; then
10331       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10332       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10333       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10334 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10335     else
10336       echo "$as_me:$LINENO: result: no" >&5
10337 echo "${ECHO_T}no" >&6
10338     fi
10339   elif test $build != $host && test $have_gcc_for_target = yes; then
10340     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10341     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10342     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10343   fi
10344 fi
10345 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10346   # Extract the first word of "nm", so it can be a program name with args.
10347 set dummy nm; ac_word=$2
10348 echo "$as_me:$LINENO: checking for $ac_word" >&5
10349 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10350 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10351   echo $ECHO_N "(cached) $ECHO_C" >&6
10352 else
10353   case $NM_FOR_TARGET in
10354   [\\/]* | ?:[\\/]*)
10355   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10356   ;;
10357   *)
10358   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10359 for as_dir in $gcc_cv_tool_dirs
10360 do
10361   IFS=$as_save_IFS
10362   test -z "$as_dir" && as_dir=.
10363   for ac_exec_ext in '' $ac_executable_extensions; do
10364   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10365     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10366     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10367     break 2
10368   fi
10369 done
10370 done
10371
10372   ;;
10373 esac
10374 fi
10375 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10376
10377 if test -n "$NM_FOR_TARGET"; then
10378   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10379 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10380 else
10381   echo "$as_me:$LINENO: result: no" >&5
10382 echo "${ECHO_T}no" >&6
10383 fi
10384
10385 fi
10386 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10387
10388
10389 if test -n "$NM_FOR_TARGET"; then
10390   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10391 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10392   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10393 fi
10394
10395 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10396   for ncn_progname in nm; do
10397     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10398 set dummy ${ncn_progname}; ac_word=$2
10399 echo "$as_me:$LINENO: checking for $ac_word" >&5
10400 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10401 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10402   echo $ECHO_N "(cached) $ECHO_C" >&6
10403 else
10404   if test -n "$NM_FOR_TARGET"; then
10405   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10406 else
10407 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10408 for as_dir in $PATH
10409 do
10410   IFS=$as_save_IFS
10411   test -z "$as_dir" && as_dir=.
10412   for ac_exec_ext in '' $ac_executable_extensions; do
10413   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10414     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10415     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10416     break 2
10417   fi
10418 done
10419 done
10420
10421 fi
10422 fi
10423 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10424 if test -n "$NM_FOR_TARGET"; then
10425   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10426 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10427 else
10428   echo "$as_me:$LINENO: result: no" >&5
10429 echo "${ECHO_T}no" >&6
10430 fi
10431
10432   done
10433 fi
10434
10435 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10436   for ncn_progname in nm; do
10437     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10438 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10439     if test -x $with_build_time_tools/${ncn_progname}; then
10440       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10441       echo "$as_me:$LINENO: result: yes" >&5
10442 echo "${ECHO_T}yes" >&6
10443       break
10444     else
10445       echo "$as_me:$LINENO: result: no" >&5
10446 echo "${ECHO_T}no" >&6
10447     fi
10448   done
10449 fi
10450
10451 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10452   for ncn_progname in nm; do
10453     if test -n "$ncn_target_tool_prefix"; then
10454       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10455 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10456 echo "$as_me:$LINENO: checking for $ac_word" >&5
10457 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10458 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10459   echo $ECHO_N "(cached) $ECHO_C" >&6
10460 else
10461   if test -n "$NM_FOR_TARGET"; then
10462   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10463 else
10464 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10465 for as_dir in $PATH
10466 do
10467   IFS=$as_save_IFS
10468   test -z "$as_dir" && as_dir=.
10469   for ac_exec_ext in '' $ac_executable_extensions; do
10470   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10471     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10472     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10473     break 2
10474   fi
10475 done
10476 done
10477
10478 fi
10479 fi
10480 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10481 if test -n "$NM_FOR_TARGET"; then
10482   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10483 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10484 else
10485   echo "$as_me:$LINENO: result: no" >&5
10486 echo "${ECHO_T}no" >&6
10487 fi
10488
10489     fi
10490     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10491       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10492 set dummy ${ncn_progname}; ac_word=$2
10493 echo "$as_me:$LINENO: checking for $ac_word" >&5
10494 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10495 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10496   echo $ECHO_N "(cached) $ECHO_C" >&6
10497 else
10498   if test -n "$NM_FOR_TARGET"; then
10499   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10500 else
10501 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10502 for as_dir in $PATH
10503 do
10504   IFS=$as_save_IFS
10505   test -z "$as_dir" && as_dir=.
10506   for ac_exec_ext in '' $ac_executable_extensions; do
10507   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10508     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10509     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10510     break 2
10511   fi
10512 done
10513 done
10514
10515 fi
10516 fi
10517 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10518 if test -n "$NM_FOR_TARGET"; then
10519   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10520 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10521 else
10522   echo "$as_me:$LINENO: result: no" >&5
10523 echo "${ECHO_T}no" >&6
10524 fi
10525
10526     fi
10527     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10528   done
10529 fi
10530
10531 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10532   set dummy nm
10533   if test $build = $target ; then
10534     NM_FOR_TARGET="$2"
10535   else
10536     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10537   fi
10538 else
10539   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10540 fi
10541
10542 else
10543   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10544 fi
10545
10546
10547
10548
10549 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10550   if test -n "$with_build_time_tools"; then
10551     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10552 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10553     if test -x $with_build_time_tools/objdump; then
10554       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10555       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10556       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10557 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10558     else
10559       echo "$as_me:$LINENO: result: no" >&5
10560 echo "${ECHO_T}no" >&6
10561     fi
10562   elif test $build != $host && test $have_gcc_for_target = yes; then
10563     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10564     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10565     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10566   fi
10567 fi
10568 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10569   # Extract the first word of "objdump", so it can be a program name with args.
10570 set dummy objdump; ac_word=$2
10571 echo "$as_me:$LINENO: checking for $ac_word" >&5
10572 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10573 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10574   echo $ECHO_N "(cached) $ECHO_C" >&6
10575 else
10576   case $OBJDUMP_FOR_TARGET in
10577   [\\/]* | ?:[\\/]*)
10578   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10579   ;;
10580   *)
10581   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10582 for as_dir in $gcc_cv_tool_dirs
10583 do
10584   IFS=$as_save_IFS
10585   test -z "$as_dir" && as_dir=.
10586   for ac_exec_ext in '' $ac_executable_extensions; do
10587   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10588     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10589     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10590     break 2
10591   fi
10592 done
10593 done
10594
10595   ;;
10596 esac
10597 fi
10598 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10599
10600 if test -n "$OBJDUMP_FOR_TARGET"; then
10601   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10602 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10603 else
10604   echo "$as_me:$LINENO: result: no" >&5
10605 echo "${ECHO_T}no" >&6
10606 fi
10607
10608 fi
10609 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10610
10611
10612 if test -n "$OBJDUMP_FOR_TARGET"; then
10613   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10614 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10615   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10616 fi
10617
10618 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10619   for ncn_progname in objdump; do
10620     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10621 set dummy ${ncn_progname}; ac_word=$2
10622 echo "$as_me:$LINENO: checking for $ac_word" >&5
10623 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10624 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10625   echo $ECHO_N "(cached) $ECHO_C" >&6
10626 else
10627   if test -n "$OBJDUMP_FOR_TARGET"; then
10628   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10629 else
10630 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10631 for as_dir in $PATH
10632 do
10633   IFS=$as_save_IFS
10634   test -z "$as_dir" && as_dir=.
10635   for ac_exec_ext in '' $ac_executable_extensions; do
10636   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10637     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10638     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10639     break 2
10640   fi
10641 done
10642 done
10643
10644 fi
10645 fi
10646 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10647 if test -n "$OBJDUMP_FOR_TARGET"; then
10648   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10649 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10650 else
10651   echo "$as_me:$LINENO: result: no" >&5
10652 echo "${ECHO_T}no" >&6
10653 fi
10654
10655   done
10656 fi
10657
10658 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10659   for ncn_progname in objdump; do
10660     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10661 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10662     if test -x $with_build_time_tools/${ncn_progname}; then
10663       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10664       echo "$as_me:$LINENO: result: yes" >&5
10665 echo "${ECHO_T}yes" >&6
10666       break
10667     else
10668       echo "$as_me:$LINENO: result: no" >&5
10669 echo "${ECHO_T}no" >&6
10670     fi
10671   done
10672 fi
10673
10674 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10675   for ncn_progname in objdump; do
10676     if test -n "$ncn_target_tool_prefix"; then
10677       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10678 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10679 echo "$as_me:$LINENO: checking for $ac_word" >&5
10680 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10681 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10682   echo $ECHO_N "(cached) $ECHO_C" >&6
10683 else
10684   if test -n "$OBJDUMP_FOR_TARGET"; then
10685   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10686 else
10687 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10688 for as_dir in $PATH
10689 do
10690   IFS=$as_save_IFS
10691   test -z "$as_dir" && as_dir=.
10692   for ac_exec_ext in '' $ac_executable_extensions; do
10693   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10694     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10695     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10696     break 2
10697   fi
10698 done
10699 done
10700
10701 fi
10702 fi
10703 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10704 if test -n "$OBJDUMP_FOR_TARGET"; then
10705   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10706 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10707 else
10708   echo "$as_me:$LINENO: result: no" >&5
10709 echo "${ECHO_T}no" >&6
10710 fi
10711
10712     fi
10713     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10714       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10715 set dummy ${ncn_progname}; ac_word=$2
10716 echo "$as_me:$LINENO: checking for $ac_word" >&5
10717 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10718 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10719   echo $ECHO_N "(cached) $ECHO_C" >&6
10720 else
10721   if test -n "$OBJDUMP_FOR_TARGET"; then
10722   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10723 else
10724 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10725 for as_dir in $PATH
10726 do
10727   IFS=$as_save_IFS
10728   test -z "$as_dir" && as_dir=.
10729   for ac_exec_ext in '' $ac_executable_extensions; do
10730   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10731     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10732     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10733     break 2
10734   fi
10735 done
10736 done
10737
10738 fi
10739 fi
10740 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10741 if test -n "$OBJDUMP_FOR_TARGET"; then
10742   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10743 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10744 else
10745   echo "$as_me:$LINENO: result: no" >&5
10746 echo "${ECHO_T}no" >&6
10747 fi
10748
10749     fi
10750     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10751   done
10752 fi
10753
10754 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10755   set dummy objdump
10756   if test $build = $target ; then
10757     OBJDUMP_FOR_TARGET="$2"
10758   else
10759     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10760   fi
10761 else
10762   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10763 fi
10764
10765 else
10766   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10767 fi
10768
10769
10770
10771
10772 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10773   if test -n "$with_build_time_tools"; then
10774     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10775 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10776     if test -x $with_build_time_tools/ranlib; then
10777       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10778       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10779       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10780 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10781     else
10782       echo "$as_me:$LINENO: result: no" >&5
10783 echo "${ECHO_T}no" >&6
10784     fi
10785   elif test $build != $host && test $have_gcc_for_target = yes; then
10786     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10787     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10788     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10789   fi
10790 fi
10791 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10792   # Extract the first word of "ranlib", so it can be a program name with args.
10793 set dummy ranlib; ac_word=$2
10794 echo "$as_me:$LINENO: checking for $ac_word" >&5
10795 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10796 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10797   echo $ECHO_N "(cached) $ECHO_C" >&6
10798 else
10799   case $RANLIB_FOR_TARGET in
10800   [\\/]* | ?:[\\/]*)
10801   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10802   ;;
10803   *)
10804   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10805 for as_dir in $gcc_cv_tool_dirs
10806 do
10807   IFS=$as_save_IFS
10808   test -z "$as_dir" && as_dir=.
10809   for ac_exec_ext in '' $ac_executable_extensions; do
10810   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10811     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10812     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10813     break 2
10814   fi
10815 done
10816 done
10817
10818   ;;
10819 esac
10820 fi
10821 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10822
10823 if test -n "$RANLIB_FOR_TARGET"; then
10824   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10825 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10826 else
10827   echo "$as_me:$LINENO: result: no" >&5
10828 echo "${ECHO_T}no" >&6
10829 fi
10830
10831 fi
10832 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10833
10834
10835 if test -n "$RANLIB_FOR_TARGET"; then
10836   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10837 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10838   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10839 fi
10840
10841 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10842   for ncn_progname in ranlib; do
10843     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10844 set dummy ${ncn_progname}; ac_word=$2
10845 echo "$as_me:$LINENO: checking for $ac_word" >&5
10846 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10847 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10848   echo $ECHO_N "(cached) $ECHO_C" >&6
10849 else
10850   if test -n "$RANLIB_FOR_TARGET"; then
10851   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10852 else
10853 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10854 for as_dir in $PATH
10855 do
10856   IFS=$as_save_IFS
10857   test -z "$as_dir" && as_dir=.
10858   for ac_exec_ext in '' $ac_executable_extensions; do
10859   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10860     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10861     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10862     break 2
10863   fi
10864 done
10865 done
10866
10867 fi
10868 fi
10869 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10870 if test -n "$RANLIB_FOR_TARGET"; then
10871   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10872 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10873 else
10874   echo "$as_me:$LINENO: result: no" >&5
10875 echo "${ECHO_T}no" >&6
10876 fi
10877
10878   done
10879 fi
10880
10881 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10882   for ncn_progname in ranlib; do
10883     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10884 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10885     if test -x $with_build_time_tools/${ncn_progname}; then
10886       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10887       echo "$as_me:$LINENO: result: yes" >&5
10888 echo "${ECHO_T}yes" >&6
10889       break
10890     else
10891       echo "$as_me:$LINENO: result: no" >&5
10892 echo "${ECHO_T}no" >&6
10893     fi
10894   done
10895 fi
10896
10897 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10898   for ncn_progname in ranlib; do
10899     if test -n "$ncn_target_tool_prefix"; then
10900       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10901 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10902 echo "$as_me:$LINENO: checking for $ac_word" >&5
10903 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10904 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10905   echo $ECHO_N "(cached) $ECHO_C" >&6
10906 else
10907   if test -n "$RANLIB_FOR_TARGET"; then
10908   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10909 else
10910 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10911 for as_dir in $PATH
10912 do
10913   IFS=$as_save_IFS
10914   test -z "$as_dir" && as_dir=.
10915   for ac_exec_ext in '' $ac_executable_extensions; do
10916   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10917     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10918     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10919     break 2
10920   fi
10921 done
10922 done
10923
10924 fi
10925 fi
10926 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10927 if test -n "$RANLIB_FOR_TARGET"; then
10928   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10929 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10930 else
10931   echo "$as_me:$LINENO: result: no" >&5
10932 echo "${ECHO_T}no" >&6
10933 fi
10934
10935     fi
10936     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10937       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10938 set dummy ${ncn_progname}; ac_word=$2
10939 echo "$as_me:$LINENO: checking for $ac_word" >&5
10940 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10941 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10942   echo $ECHO_N "(cached) $ECHO_C" >&6
10943 else
10944   if test -n "$RANLIB_FOR_TARGET"; then
10945   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10946 else
10947 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10948 for as_dir in $PATH
10949 do
10950   IFS=$as_save_IFS
10951   test -z "$as_dir" && as_dir=.
10952   for ac_exec_ext in '' $ac_executable_extensions; do
10953   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10954     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10955     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10956     break 2
10957   fi
10958 done
10959 done
10960
10961 fi
10962 fi
10963 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10964 if test -n "$RANLIB_FOR_TARGET"; then
10965   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10966 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10967 else
10968   echo "$as_me:$LINENO: result: no" >&5
10969 echo "${ECHO_T}no" >&6
10970 fi
10971
10972     fi
10973     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10974   done
10975 fi
10976
10977 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10978   set dummy ranlib
10979   if test $build = $target ; then
10980     RANLIB_FOR_TARGET="$2"
10981   else
10982     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10983   fi
10984 else
10985   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10986 fi
10987
10988 else
10989   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10990 fi
10991
10992
10993
10994
10995 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10996   if test -n "$with_build_time_tools"; then
10997     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10998 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10999     if test -x $with_build_time_tools/strip; then
11000       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
11001       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11002       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
11003 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
11004     else
11005       echo "$as_me:$LINENO: result: no" >&5
11006 echo "${ECHO_T}no" >&6
11007     fi
11008   elif test $build != $host && test $have_gcc_for_target = yes; then
11009     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
11010     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
11011     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11012   fi
11013 fi
11014 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11015   # Extract the first word of "strip", so it can be a program name with args.
11016 set dummy strip; ac_word=$2
11017 echo "$as_me:$LINENO: checking for $ac_word" >&5
11018 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11019 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
11020   echo $ECHO_N "(cached) $ECHO_C" >&6
11021 else
11022   case $STRIP_FOR_TARGET in
11023   [\\/]* | ?:[\\/]*)
11024   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
11025   ;;
11026   *)
11027   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11028 for as_dir in $gcc_cv_tool_dirs
11029 do
11030   IFS=$as_save_IFS
11031   test -z "$as_dir" && as_dir=.
11032   for ac_exec_ext in '' $ac_executable_extensions; do
11033   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11034     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11035     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11036     break 2
11037   fi
11038 done
11039 done
11040
11041   ;;
11042 esac
11043 fi
11044 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11045
11046 if test -n "$STRIP_FOR_TARGET"; then
11047   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11048 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11049 else
11050   echo "$as_me:$LINENO: result: no" >&5
11051 echo "${ECHO_T}no" >&6
11052 fi
11053
11054 fi
11055 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11056
11057
11058 if test -n "$STRIP_FOR_TARGET"; then
11059   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11060 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11061   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11062 fi
11063
11064 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11065   for ncn_progname in strip; do
11066     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11067 set dummy ${ncn_progname}; ac_word=$2
11068 echo "$as_me:$LINENO: checking for $ac_word" >&5
11069 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11070 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11071   echo $ECHO_N "(cached) $ECHO_C" >&6
11072 else
11073   if test -n "$STRIP_FOR_TARGET"; then
11074   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11075 else
11076 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11077 for as_dir in $PATH
11078 do
11079   IFS=$as_save_IFS
11080   test -z "$as_dir" && as_dir=.
11081   for ac_exec_ext in '' $ac_executable_extensions; do
11082   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11083     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11084     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11085     break 2
11086   fi
11087 done
11088 done
11089
11090 fi
11091 fi
11092 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11093 if test -n "$STRIP_FOR_TARGET"; then
11094   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11095 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11096 else
11097   echo "$as_me:$LINENO: result: no" >&5
11098 echo "${ECHO_T}no" >&6
11099 fi
11100
11101   done
11102 fi
11103
11104 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11105   for ncn_progname in strip; do
11106     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11107 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11108     if test -x $with_build_time_tools/${ncn_progname}; then
11109       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11110       echo "$as_me:$LINENO: result: yes" >&5
11111 echo "${ECHO_T}yes" >&6
11112       break
11113     else
11114       echo "$as_me:$LINENO: result: no" >&5
11115 echo "${ECHO_T}no" >&6
11116     fi
11117   done
11118 fi
11119
11120 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11121   for ncn_progname in strip; do
11122     if test -n "$ncn_target_tool_prefix"; then
11123       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11124 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11125 echo "$as_me:$LINENO: checking for $ac_word" >&5
11126 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11127 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11128   echo $ECHO_N "(cached) $ECHO_C" >&6
11129 else
11130   if test -n "$STRIP_FOR_TARGET"; then
11131   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11132 else
11133 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11134 for as_dir in $PATH
11135 do
11136   IFS=$as_save_IFS
11137   test -z "$as_dir" && as_dir=.
11138   for ac_exec_ext in '' $ac_executable_extensions; do
11139   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11140     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11141     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11142     break 2
11143   fi
11144 done
11145 done
11146
11147 fi
11148 fi
11149 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11150 if test -n "$STRIP_FOR_TARGET"; then
11151   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11152 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11153 else
11154   echo "$as_me:$LINENO: result: no" >&5
11155 echo "${ECHO_T}no" >&6
11156 fi
11157
11158     fi
11159     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11160       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11161 set dummy ${ncn_progname}; ac_word=$2
11162 echo "$as_me:$LINENO: checking for $ac_word" >&5
11163 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11164 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11165   echo $ECHO_N "(cached) $ECHO_C" >&6
11166 else
11167   if test -n "$STRIP_FOR_TARGET"; then
11168   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11169 else
11170 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11171 for as_dir in $PATH
11172 do
11173   IFS=$as_save_IFS
11174   test -z "$as_dir" && as_dir=.
11175   for ac_exec_ext in '' $ac_executable_extensions; do
11176   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11177     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11178     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11179     break 2
11180   fi
11181 done
11182 done
11183
11184 fi
11185 fi
11186 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11187 if test -n "$STRIP_FOR_TARGET"; then
11188   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11189 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11190 else
11191   echo "$as_me:$LINENO: result: no" >&5
11192 echo "${ECHO_T}no" >&6
11193 fi
11194
11195     fi
11196     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11197   done
11198 fi
11199
11200 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11201   set dummy strip
11202   if test $build = $target ; then
11203     STRIP_FOR_TARGET="$2"
11204   else
11205     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11206   fi
11207 else
11208   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11209 fi
11210
11211 else
11212   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11213 fi
11214
11215
11216
11217
11218 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11219   if test -n "$with_build_time_tools"; then
11220     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11221 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11222     if test -x $with_build_time_tools/windres; then
11223       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11224       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11225       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11226 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11227     else
11228       echo "$as_me:$LINENO: result: no" >&5
11229 echo "${ECHO_T}no" >&6
11230     fi
11231   elif test $build != $host && test $have_gcc_for_target = yes; then
11232     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11233     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11234     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11235   fi
11236 fi
11237 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11238   # Extract the first word of "windres", so it can be a program name with args.
11239 set dummy windres; ac_word=$2
11240 echo "$as_me:$LINENO: checking for $ac_word" >&5
11241 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11242 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11243   echo $ECHO_N "(cached) $ECHO_C" >&6
11244 else
11245   case $WINDRES_FOR_TARGET in
11246   [\\/]* | ?:[\\/]*)
11247   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11248   ;;
11249   *)
11250   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11251 for as_dir in $gcc_cv_tool_dirs
11252 do
11253   IFS=$as_save_IFS
11254   test -z "$as_dir" && as_dir=.
11255   for ac_exec_ext in '' $ac_executable_extensions; do
11256   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11257     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11258     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11259     break 2
11260   fi
11261 done
11262 done
11263
11264   ;;
11265 esac
11266 fi
11267 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11268
11269 if test -n "$WINDRES_FOR_TARGET"; then
11270   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11271 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11272 else
11273   echo "$as_me:$LINENO: result: no" >&5
11274 echo "${ECHO_T}no" >&6
11275 fi
11276
11277 fi
11278 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11279
11280
11281 if test -n "$WINDRES_FOR_TARGET"; then
11282   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11283 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11284   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11285 fi
11286
11287 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11288   for ncn_progname in windres; do
11289     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11290 set dummy ${ncn_progname}; ac_word=$2
11291 echo "$as_me:$LINENO: checking for $ac_word" >&5
11292 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11293 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11294   echo $ECHO_N "(cached) $ECHO_C" >&6
11295 else
11296   if test -n "$WINDRES_FOR_TARGET"; then
11297   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11298 else
11299 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11300 for as_dir in $PATH
11301 do
11302   IFS=$as_save_IFS
11303   test -z "$as_dir" && as_dir=.
11304   for ac_exec_ext in '' $ac_executable_extensions; do
11305   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11306     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11307     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11308     break 2
11309   fi
11310 done
11311 done
11312
11313 fi
11314 fi
11315 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11316 if test -n "$WINDRES_FOR_TARGET"; then
11317   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11318 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11319 else
11320   echo "$as_me:$LINENO: result: no" >&5
11321 echo "${ECHO_T}no" >&6
11322 fi
11323
11324   done
11325 fi
11326
11327 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11328   for ncn_progname in windres; do
11329     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11330 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11331     if test -x $with_build_time_tools/${ncn_progname}; then
11332       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11333       echo "$as_me:$LINENO: result: yes" >&5
11334 echo "${ECHO_T}yes" >&6
11335       break
11336     else
11337       echo "$as_me:$LINENO: result: no" >&5
11338 echo "${ECHO_T}no" >&6
11339     fi
11340   done
11341 fi
11342
11343 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11344   for ncn_progname in windres; do
11345     if test -n "$ncn_target_tool_prefix"; then
11346       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11347 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11348 echo "$as_me:$LINENO: checking for $ac_word" >&5
11349 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11350 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11351   echo $ECHO_N "(cached) $ECHO_C" >&6
11352 else
11353   if test -n "$WINDRES_FOR_TARGET"; then
11354   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11355 else
11356 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11357 for as_dir in $PATH
11358 do
11359   IFS=$as_save_IFS
11360   test -z "$as_dir" && as_dir=.
11361   for ac_exec_ext in '' $ac_executable_extensions; do
11362   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11363     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11364     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11365     break 2
11366   fi
11367 done
11368 done
11369
11370 fi
11371 fi
11372 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11373 if test -n "$WINDRES_FOR_TARGET"; then
11374   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11375 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11376 else
11377   echo "$as_me:$LINENO: result: no" >&5
11378 echo "${ECHO_T}no" >&6
11379 fi
11380
11381     fi
11382     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11383       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11384 set dummy ${ncn_progname}; ac_word=$2
11385 echo "$as_me:$LINENO: checking for $ac_word" >&5
11386 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11387 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11388   echo $ECHO_N "(cached) $ECHO_C" >&6
11389 else
11390   if test -n "$WINDRES_FOR_TARGET"; then
11391   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11392 else
11393 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11394 for as_dir in $PATH
11395 do
11396   IFS=$as_save_IFS
11397   test -z "$as_dir" && as_dir=.
11398   for ac_exec_ext in '' $ac_executable_extensions; do
11399   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11400     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11401     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11402     break 2
11403   fi
11404 done
11405 done
11406
11407 fi
11408 fi
11409 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11410 if test -n "$WINDRES_FOR_TARGET"; then
11411   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11412 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11413 else
11414   echo "$as_me:$LINENO: result: no" >&5
11415 echo "${ECHO_T}no" >&6
11416 fi
11417
11418     fi
11419     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11420   done
11421 fi
11422
11423 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11424   set dummy windres
11425   if test $build = $target ; then
11426     WINDRES_FOR_TARGET="$2"
11427   else
11428     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11429   fi
11430 else
11431   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11432 fi
11433
11434 else
11435   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11436 fi
11437
11438
11439
11440
11441 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11442   if test -n "$with_build_time_tools"; then
11443     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11444 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11445     if test -x $with_build_time_tools/windmc; then
11446       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11447       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11448       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11449 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11450     else
11451       echo "$as_me:$LINENO: result: no" >&5
11452 echo "${ECHO_T}no" >&6
11453     fi
11454   elif test $build != $host && test $have_gcc_for_target = yes; then
11455     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11456     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11457     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11458   fi
11459 fi
11460 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11461   # Extract the first word of "windmc", so it can be a program name with args.
11462 set dummy windmc; ac_word=$2
11463 echo "$as_me:$LINENO: checking for $ac_word" >&5
11464 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11465 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11466   echo $ECHO_N "(cached) $ECHO_C" >&6
11467 else
11468   case $WINDMC_FOR_TARGET in
11469   [\\/]* | ?:[\\/]*)
11470   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11471   ;;
11472   *)
11473   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11474 for as_dir in $gcc_cv_tool_dirs
11475 do
11476   IFS=$as_save_IFS
11477   test -z "$as_dir" && as_dir=.
11478   for ac_exec_ext in '' $ac_executable_extensions; do
11479   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11480     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11481     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11482     break 2
11483   fi
11484 done
11485 done
11486
11487   ;;
11488 esac
11489 fi
11490 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11491
11492 if test -n "$WINDMC_FOR_TARGET"; then
11493   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11494 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11495 else
11496   echo "$as_me:$LINENO: result: no" >&5
11497 echo "${ECHO_T}no" >&6
11498 fi
11499
11500 fi
11501 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11502
11503
11504 if test -n "$WINDMC_FOR_TARGET"; then
11505   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11506 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11507   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11508 fi
11509
11510 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11511   for ncn_progname in windmc; do
11512     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11513 set dummy ${ncn_progname}; ac_word=$2
11514 echo "$as_me:$LINENO: checking for $ac_word" >&5
11515 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11516 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11517   echo $ECHO_N "(cached) $ECHO_C" >&6
11518 else
11519   if test -n "$WINDMC_FOR_TARGET"; then
11520   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11521 else
11522 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11523 for as_dir in $PATH
11524 do
11525   IFS=$as_save_IFS
11526   test -z "$as_dir" && as_dir=.
11527   for ac_exec_ext in '' $ac_executable_extensions; do
11528   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11529     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11530     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11531     break 2
11532   fi
11533 done
11534 done
11535
11536 fi
11537 fi
11538 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11539 if test -n "$WINDMC_FOR_TARGET"; then
11540   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11541 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11542 else
11543   echo "$as_me:$LINENO: result: no" >&5
11544 echo "${ECHO_T}no" >&6
11545 fi
11546
11547   done
11548 fi
11549
11550 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11551   for ncn_progname in windmc; do
11552     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11553 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11554     if test -x $with_build_time_tools/${ncn_progname}; then
11555       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11556       echo "$as_me:$LINENO: result: yes" >&5
11557 echo "${ECHO_T}yes" >&6
11558       break
11559     else
11560       echo "$as_me:$LINENO: result: no" >&5
11561 echo "${ECHO_T}no" >&6
11562     fi
11563   done
11564 fi
11565
11566 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11567   for ncn_progname in windmc; do
11568     if test -n "$ncn_target_tool_prefix"; then
11569       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11570 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11571 echo "$as_me:$LINENO: checking for $ac_word" >&5
11572 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11573 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11574   echo $ECHO_N "(cached) $ECHO_C" >&6
11575 else
11576   if test -n "$WINDMC_FOR_TARGET"; then
11577   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11578 else
11579 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11580 for as_dir in $PATH
11581 do
11582   IFS=$as_save_IFS
11583   test -z "$as_dir" && as_dir=.
11584   for ac_exec_ext in '' $ac_executable_extensions; do
11585   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11586     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11587     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11588     break 2
11589   fi
11590 done
11591 done
11592
11593 fi
11594 fi
11595 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11596 if test -n "$WINDMC_FOR_TARGET"; then
11597   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11598 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11599 else
11600   echo "$as_me:$LINENO: result: no" >&5
11601 echo "${ECHO_T}no" >&6
11602 fi
11603
11604     fi
11605     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11606       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11607 set dummy ${ncn_progname}; ac_word=$2
11608 echo "$as_me:$LINENO: checking for $ac_word" >&5
11609 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11610 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11611   echo $ECHO_N "(cached) $ECHO_C" >&6
11612 else
11613   if test -n "$WINDMC_FOR_TARGET"; then
11614   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11615 else
11616 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11617 for as_dir in $PATH
11618 do
11619   IFS=$as_save_IFS
11620   test -z "$as_dir" && as_dir=.
11621   for ac_exec_ext in '' $ac_executable_extensions; do
11622   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11623     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11624     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11625     break 2
11626   fi
11627 done
11628 done
11629
11630 fi
11631 fi
11632 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11633 if test -n "$WINDMC_FOR_TARGET"; then
11634   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11635 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11636 else
11637   echo "$as_me:$LINENO: result: no" >&5
11638 echo "${ECHO_T}no" >&6
11639 fi
11640
11641     fi
11642     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11643   done
11644 fi
11645
11646 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11647   set dummy windmc
11648   if test $build = $target ; then
11649     WINDMC_FOR_TARGET="$2"
11650   else
11651     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11652   fi
11653 else
11654   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11655 fi
11656
11657 else
11658   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11659 fi
11660
11661
11662 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11663
11664 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11665 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11666 if test "x${build}" != "x${host}" ; then
11667   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11668     # We already found the complete path
11669     ac_dir=`dirname $AR_FOR_TARGET`
11670     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11671 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11672   else
11673     # Canadian cross, just use what we found
11674     echo "$as_me:$LINENO: result: pre-installed" >&5
11675 echo "${ECHO_T}pre-installed" >&6
11676   fi
11677 else
11678   ok=yes
11679   case " ${configdirs} " in
11680     *" binutils "*) ;;
11681     *) ok=no ;;
11682   esac
11683
11684   if test $ok = yes; then
11685     # An in-tree tool is available and we can use it
11686     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11687     echo "$as_me:$LINENO: result: just compiled" >&5
11688 echo "${ECHO_T}just compiled" >&6
11689   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11690     # We already found the complete path
11691     ac_dir=`dirname $AR_FOR_TARGET`
11692     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11693 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11694   elif test "x$target" = "x$host"; then
11695     # We can use an host tool
11696     AR_FOR_TARGET='$(AR)'
11697     echo "$as_me:$LINENO: result: host tool" >&5
11698 echo "${ECHO_T}host tool" >&6
11699   else
11700     # We need a cross tool
11701     echo "$as_me:$LINENO: result: pre-installed" >&5
11702 echo "${ECHO_T}pre-installed" >&6
11703   fi
11704 fi
11705
11706 echo "$as_me:$LINENO: checking where to find the target as" >&5
11707 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11708 if test "x${build}" != "x${host}" ; then
11709   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11710     # We already found the complete path
11711     ac_dir=`dirname $AS_FOR_TARGET`
11712     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11713 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11714   else
11715     # Canadian cross, just use what we found
11716     echo "$as_me:$LINENO: result: pre-installed" >&5
11717 echo "${ECHO_T}pre-installed" >&6
11718   fi
11719 else
11720   ok=yes
11721   case " ${configdirs} " in
11722     *" gas "*) ;;
11723     *) ok=no ;;
11724   esac
11725
11726   if test $ok = yes; then
11727     # An in-tree tool is available and we can use it
11728     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11729     echo "$as_me:$LINENO: result: just compiled" >&5
11730 echo "${ECHO_T}just compiled" >&6
11731   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11732     # We already found the complete path
11733     ac_dir=`dirname $AS_FOR_TARGET`
11734     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11735 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11736   elif test "x$target" = "x$host"; then
11737     # We can use an host tool
11738     AS_FOR_TARGET='$(AS)'
11739     echo "$as_me:$LINENO: result: host tool" >&5
11740 echo "${ECHO_T}host tool" >&6
11741   else
11742     # We need a cross tool
11743     echo "$as_me:$LINENO: result: pre-installed" >&5
11744 echo "${ECHO_T}pre-installed" >&6
11745   fi
11746 fi
11747
11748 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11749 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11750 if test "x${build}" != "x${host}" ; then
11751   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11752     # We already found the complete path
11753     ac_dir=`dirname $CC_FOR_TARGET`
11754     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11755 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11756   else
11757     # Canadian cross, just use what we found
11758     echo "$as_me:$LINENO: result: pre-installed" >&5
11759 echo "${ECHO_T}pre-installed" >&6
11760   fi
11761 else
11762   ok=yes
11763   case " ${configdirs} " in
11764     *" gcc "*) ;;
11765     *) ok=no ;;
11766   esac
11767
11768   if test $ok = yes; then
11769     # An in-tree tool is available and we can use it
11770     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11771     echo "$as_me:$LINENO: result: just compiled" >&5
11772 echo "${ECHO_T}just compiled" >&6
11773   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11774     # We already found the complete path
11775     ac_dir=`dirname $CC_FOR_TARGET`
11776     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11777 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11778   elif test "x$target" = "x$host"; then
11779     # We can use an host tool
11780     CC_FOR_TARGET='$(CC)'
11781     echo "$as_me:$LINENO: result: host tool" >&5
11782 echo "${ECHO_T}host tool" >&6
11783   else
11784     # We need a cross tool
11785     echo "$as_me:$LINENO: result: pre-installed" >&5
11786 echo "${ECHO_T}pre-installed" >&6
11787   fi
11788 fi
11789
11790 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11791 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11792 if test "x${build}" != "x${host}" ; then
11793   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11794     # We already found the complete path
11795     ac_dir=`dirname $CXX_FOR_TARGET`
11796     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11797 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11798   else
11799     # Canadian cross, just use what we found
11800     echo "$as_me:$LINENO: result: pre-installed" >&5
11801 echo "${ECHO_T}pre-installed" >&6
11802   fi
11803 else
11804   ok=yes
11805   case " ${configdirs} " in
11806     *" gcc "*) ;;
11807     *) ok=no ;;
11808   esac
11809   case ,${enable_languages}, in
11810     *,c++,*) ;;
11811     *) ok=no ;;
11812   esac
11813   if test $ok = yes; then
11814     # An in-tree tool is available and we can use it
11815     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'
11816     echo "$as_me:$LINENO: result: just compiled" >&5
11817 echo "${ECHO_T}just compiled" >&6
11818   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11819     # We already found the complete path
11820     ac_dir=`dirname $CXX_FOR_TARGET`
11821     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11822 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11823   elif test "x$target" = "x$host"; then
11824     # We can use an host tool
11825     CXX_FOR_TARGET='$(CXX)'
11826     echo "$as_me:$LINENO: result: host tool" >&5
11827 echo "${ECHO_T}host tool" >&6
11828   else
11829     # We need a cross tool
11830     echo "$as_me:$LINENO: result: pre-installed" >&5
11831 echo "${ECHO_T}pre-installed" >&6
11832   fi
11833 fi
11834
11835 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11836 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11837 if test "x${build}" != "x${host}" ; then
11838   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11839     # We already found the complete path
11840     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11841     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11842 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11843   else
11844     # Canadian cross, just use what we found
11845     echo "$as_me:$LINENO: result: pre-installed" >&5
11846 echo "${ECHO_T}pre-installed" >&6
11847   fi
11848 else
11849   ok=yes
11850   case " ${configdirs} " in
11851     *" gcc "*) ;;
11852     *) ok=no ;;
11853   esac
11854   case ,${enable_languages}, in
11855     *,c++,*) ;;
11856     *) ok=no ;;
11857   esac
11858   if test $ok = yes; then
11859     # An in-tree tool is available and we can use it
11860     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'
11861     echo "$as_me:$LINENO: result: just compiled" >&5
11862 echo "${ECHO_T}just compiled" >&6
11863   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11864     # We already found the complete path
11865     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11866     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11867 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11868   elif test "x$target" = "x$host"; then
11869     # We can use an host tool
11870     RAW_CXX_FOR_TARGET='$(CXX)'
11871     echo "$as_me:$LINENO: result: host tool" >&5
11872 echo "${ECHO_T}host tool" >&6
11873   else
11874     # We need a cross tool
11875     echo "$as_me:$LINENO: result: pre-installed" >&5
11876 echo "${ECHO_T}pre-installed" >&6
11877   fi
11878 fi
11879
11880 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11881 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11882 if test "x${build}" != "x${host}" ; then
11883   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11884     # We already found the complete path
11885     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11886     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11887 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11888   else
11889     # Canadian cross, just use what we found
11890     echo "$as_me:$LINENO: result: pre-installed" >&5
11891 echo "${ECHO_T}pre-installed" >&6
11892   fi
11893 else
11894   ok=yes
11895   case " ${configdirs} " in
11896     *" binutils "*) ;;
11897     *) ok=no ;;
11898   esac
11899
11900   if test $ok = yes; then
11901     # An in-tree tool is available and we can use it
11902     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11903     echo "$as_me:$LINENO: result: just compiled" >&5
11904 echo "${ECHO_T}just compiled" >&6
11905   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11906     # We already found the complete path
11907     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11908     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11909 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11910   elif test "x$target" = "x$host"; then
11911     # We can use an host tool
11912     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11913     echo "$as_me:$LINENO: result: host tool" >&5
11914 echo "${ECHO_T}host tool" >&6
11915   else
11916     # We need a cross tool
11917     echo "$as_me:$LINENO: result: pre-installed" >&5
11918 echo "${ECHO_T}pre-installed" >&6
11919   fi
11920 fi
11921
11922 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11923 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11924 if test "x${build}" != "x${host}" ; then
11925   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11926     # We already found the complete path
11927     ac_dir=`dirname $GCC_FOR_TARGET`
11928     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11929 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11930   else
11931     # Canadian cross, just use what we found
11932     echo "$as_me:$LINENO: result: pre-installed" >&5
11933 echo "${ECHO_T}pre-installed" >&6
11934   fi
11935 else
11936   ok=yes
11937   case " ${configdirs} " in
11938     *" gcc "*) ;;
11939     *) ok=no ;;
11940   esac
11941
11942   if test $ok = yes; then
11943     # An in-tree tool is available and we can use it
11944     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11945     echo "$as_me:$LINENO: result: just compiled" >&5
11946 echo "${ECHO_T}just compiled" >&6
11947   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11948     # We already found the complete path
11949     ac_dir=`dirname $GCC_FOR_TARGET`
11950     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11951 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11952   elif test "x$target" = "x$host"; then
11953     # We can use an host tool
11954     GCC_FOR_TARGET='$()'
11955     echo "$as_me:$LINENO: result: host tool" >&5
11956 echo "${ECHO_T}host tool" >&6
11957   else
11958     # We need a cross tool
11959     echo "$as_me:$LINENO: result: pre-installed" >&5
11960 echo "${ECHO_T}pre-installed" >&6
11961   fi
11962 fi
11963
11964 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11965 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11966 if test "x${build}" != "x${host}" ; then
11967   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11968     # We already found the complete path
11969     ac_dir=`dirname $GCJ_FOR_TARGET`
11970     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11971 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11972   else
11973     # Canadian cross, just use what we found
11974     echo "$as_me:$LINENO: result: pre-installed" >&5
11975 echo "${ECHO_T}pre-installed" >&6
11976   fi
11977 else
11978   ok=yes
11979   case " ${configdirs} " in
11980     *" gcc "*) ;;
11981     *) ok=no ;;
11982   esac
11983   case ,${enable_languages}, in
11984     *,java,*) ;;
11985     *) ok=no ;;
11986   esac
11987   if test $ok = yes; then
11988     # An in-tree tool is available and we can use it
11989     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11990     echo "$as_me:$LINENO: result: just compiled" >&5
11991 echo "${ECHO_T}just compiled" >&6
11992   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11993     # We already found the complete path
11994     ac_dir=`dirname $GCJ_FOR_TARGET`
11995     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11996 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11997   elif test "x$target" = "x$host"; then
11998     # We can use an host tool
11999     GCJ_FOR_TARGET='$(GCJ)'
12000     echo "$as_me:$LINENO: result: host tool" >&5
12001 echo "${ECHO_T}host tool" >&6
12002   else
12003     # We need a cross tool
12004     echo "$as_me:$LINENO: result: pre-installed" >&5
12005 echo "${ECHO_T}pre-installed" >&6
12006   fi
12007 fi
12008
12009 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
12010 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
12011 if test "x${build}" != "x${host}" ; then
12012   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12013     # We already found the complete path
12014     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12015     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12016 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12017   else
12018     # Canadian cross, just use what we found
12019     echo "$as_me:$LINENO: result: pre-installed" >&5
12020 echo "${ECHO_T}pre-installed" >&6
12021   fi
12022 else
12023   ok=yes
12024   case " ${configdirs} " in
12025     *" gcc "*) ;;
12026     *) ok=no ;;
12027   esac
12028   case ,${enable_languages}, in
12029     *,fortran,*) ;;
12030     *) ok=no ;;
12031   esac
12032   if test $ok = yes; then
12033     # An in-tree tool is available and we can use it
12034     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12035     echo "$as_me:$LINENO: result: just compiled" >&5
12036 echo "${ECHO_T}just compiled" >&6
12037   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12038     # We already found the complete path
12039     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12040     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12041 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12042   elif test "x$target" = "x$host"; then
12043     # We can use an host tool
12044     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12045     echo "$as_me:$LINENO: result: host tool" >&5
12046 echo "${ECHO_T}host tool" >&6
12047   else
12048     # We need a cross tool
12049     echo "$as_me:$LINENO: result: pre-installed" >&5
12050 echo "${ECHO_T}pre-installed" >&6
12051   fi
12052 fi
12053
12054 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12055 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12056 if test "x${build}" != "x${host}" ; then
12057   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12058     # We already found the complete path
12059     ac_dir=`dirname $LD_FOR_TARGET`
12060     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12061 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12062   else
12063     # Canadian cross, just use what we found
12064     echo "$as_me:$LINENO: result: pre-installed" >&5
12065 echo "${ECHO_T}pre-installed" >&6
12066   fi
12067 else
12068   ok=yes
12069   case " ${configdirs} " in
12070     *" ld "*) ;;
12071     *) ok=no ;;
12072   esac
12073
12074   if test $ok = yes; then
12075     # An in-tree tool is available and we can use it
12076     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12077     echo "$as_me:$LINENO: result: just compiled" >&5
12078 echo "${ECHO_T}just compiled" >&6
12079   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12080     # We already found the complete path
12081     ac_dir=`dirname $LD_FOR_TARGET`
12082     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12083 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12084   elif test "x$target" = "x$host"; then
12085     # We can use an host tool
12086     LD_FOR_TARGET='$(LD)'
12087     echo "$as_me:$LINENO: result: host tool" >&5
12088 echo "${ECHO_T}host tool" >&6
12089   else
12090     # We need a cross tool
12091     echo "$as_me:$LINENO: result: pre-installed" >&5
12092 echo "${ECHO_T}pre-installed" >&6
12093   fi
12094 fi
12095
12096 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12097 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12098 if test "x${build}" != "x${host}" ; then
12099   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12100     # We already found the complete path
12101     ac_dir=`dirname $LIPO_FOR_TARGET`
12102     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12103 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12104   else
12105     # Canadian cross, just use what we found
12106     echo "$as_me:$LINENO: result: pre-installed" >&5
12107 echo "${ECHO_T}pre-installed" >&6
12108   fi
12109 else
12110   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12111     # We already found the complete path
12112     ac_dir=`dirname $LIPO_FOR_TARGET`
12113     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12114 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12115   elif test "x$target" = "x$host"; then
12116     # We can use an host tool
12117     LIPO_FOR_TARGET='$(LIPO)'
12118     echo "$as_me:$LINENO: result: host tool" >&5
12119 echo "${ECHO_T}host tool" >&6
12120   else
12121     # We need a cross tool
12122     echo "$as_me:$LINENO: result: pre-installed" >&5
12123 echo "${ECHO_T}pre-installed" >&6
12124   fi
12125 fi
12126
12127 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12128 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12129 if test "x${build}" != "x${host}" ; then
12130   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12131     # We already found the complete path
12132     ac_dir=`dirname $NM_FOR_TARGET`
12133     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12134 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12135   else
12136     # Canadian cross, just use what we found
12137     echo "$as_me:$LINENO: result: pre-installed" >&5
12138 echo "${ECHO_T}pre-installed" >&6
12139   fi
12140 else
12141   ok=yes
12142   case " ${configdirs} " in
12143     *" binutils "*) ;;
12144     *) ok=no ;;
12145   esac
12146
12147   if test $ok = yes; then
12148     # An in-tree tool is available and we can use it
12149     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12150     echo "$as_me:$LINENO: result: just compiled" >&5
12151 echo "${ECHO_T}just compiled" >&6
12152   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12153     # We already found the complete path
12154     ac_dir=`dirname $NM_FOR_TARGET`
12155     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12156 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12157   elif test "x$target" = "x$host"; then
12158     # We can use an host tool
12159     NM_FOR_TARGET='$(NM)'
12160     echo "$as_me:$LINENO: result: host tool" >&5
12161 echo "${ECHO_T}host tool" >&6
12162   else
12163     # We need a cross tool
12164     echo "$as_me:$LINENO: result: pre-installed" >&5
12165 echo "${ECHO_T}pre-installed" >&6
12166   fi
12167 fi
12168
12169 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12170 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12171 if test "x${build}" != "x${host}" ; then
12172   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12173     # We already found the complete path
12174     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12175     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12176 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12177   else
12178     # Canadian cross, just use what we found
12179     echo "$as_me:$LINENO: result: pre-installed" >&5
12180 echo "${ECHO_T}pre-installed" >&6
12181   fi
12182 else
12183   ok=yes
12184   case " ${configdirs} " in
12185     *" binutils "*) ;;
12186     *) ok=no ;;
12187   esac
12188
12189   if test $ok = yes; then
12190     # An in-tree tool is available and we can use it
12191     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12192     echo "$as_me:$LINENO: result: just compiled" >&5
12193 echo "${ECHO_T}just compiled" >&6
12194   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12195     # We already found the complete path
12196     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12197     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12198 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12199   elif test "x$target" = "x$host"; then
12200     # We can use an host tool
12201     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12202     echo "$as_me:$LINENO: result: host tool" >&5
12203 echo "${ECHO_T}host tool" >&6
12204   else
12205     # We need a cross tool
12206     echo "$as_me:$LINENO: result: pre-installed" >&5
12207 echo "${ECHO_T}pre-installed" >&6
12208   fi
12209 fi
12210
12211 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12212 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12213 if test "x${build}" != "x${host}" ; then
12214   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12215     # We already found the complete path
12216     ac_dir=`dirname $RANLIB_FOR_TARGET`
12217     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12218 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12219   else
12220     # Canadian cross, just use what we found
12221     echo "$as_me:$LINENO: result: pre-installed" >&5
12222 echo "${ECHO_T}pre-installed" >&6
12223   fi
12224 else
12225   ok=yes
12226   case " ${configdirs} " in
12227     *" binutils "*) ;;
12228     *) ok=no ;;
12229   esac
12230
12231   if test $ok = yes; then
12232     # An in-tree tool is available and we can use it
12233     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12234     echo "$as_me:$LINENO: result: just compiled" >&5
12235 echo "${ECHO_T}just compiled" >&6
12236   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12237     # We already found the complete path
12238     ac_dir=`dirname $RANLIB_FOR_TARGET`
12239     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12240 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12241   elif test "x$target" = "x$host"; then
12242     # We can use an host tool
12243     RANLIB_FOR_TARGET='$(RANLIB)'
12244     echo "$as_me:$LINENO: result: host tool" >&5
12245 echo "${ECHO_T}host tool" >&6
12246   else
12247     # We need a cross tool
12248     echo "$as_me:$LINENO: result: pre-installed" >&5
12249 echo "${ECHO_T}pre-installed" >&6
12250   fi
12251 fi
12252
12253 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12254 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12255 if test "x${build}" != "x${host}" ; then
12256   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12257     # We already found the complete path
12258     ac_dir=`dirname $STRIP_FOR_TARGET`
12259     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12260 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12261   else
12262     # Canadian cross, just use what we found
12263     echo "$as_me:$LINENO: result: pre-installed" >&5
12264 echo "${ECHO_T}pre-installed" >&6
12265   fi
12266 else
12267   ok=yes
12268   case " ${configdirs} " in
12269     *" binutils "*) ;;
12270     *) ok=no ;;
12271   esac
12272
12273   if test $ok = yes; then
12274     # An in-tree tool is available and we can use it
12275     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12276     echo "$as_me:$LINENO: result: just compiled" >&5
12277 echo "${ECHO_T}just compiled" >&6
12278   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12279     # We already found the complete path
12280     ac_dir=`dirname $STRIP_FOR_TARGET`
12281     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12282 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12283   elif test "x$target" = "x$host"; then
12284     # We can use an host tool
12285     STRIP_FOR_TARGET='$(STRIP)'
12286     echo "$as_me:$LINENO: result: host tool" >&5
12287 echo "${ECHO_T}host tool" >&6
12288   else
12289     # We need a cross tool
12290     echo "$as_me:$LINENO: result: pre-installed" >&5
12291 echo "${ECHO_T}pre-installed" >&6
12292   fi
12293 fi
12294
12295 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12296 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12297 if test "x${build}" != "x${host}" ; then
12298   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12299     # We already found the complete path
12300     ac_dir=`dirname $WINDRES_FOR_TARGET`
12301     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12302 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12303   else
12304     # Canadian cross, just use what we found
12305     echo "$as_me:$LINENO: result: pre-installed" >&5
12306 echo "${ECHO_T}pre-installed" >&6
12307   fi
12308 else
12309   ok=yes
12310   case " ${configdirs} " in
12311     *" binutils "*) ;;
12312     *) ok=no ;;
12313   esac
12314
12315   if test $ok = yes; then
12316     # An in-tree tool is available and we can use it
12317     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12318     echo "$as_me:$LINENO: result: just compiled" >&5
12319 echo "${ECHO_T}just compiled" >&6
12320   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12321     # We already found the complete path
12322     ac_dir=`dirname $WINDRES_FOR_TARGET`
12323     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12324 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12325   elif test "x$target" = "x$host"; then
12326     # We can use an host tool
12327     WINDRES_FOR_TARGET='$(WINDRES)'
12328     echo "$as_me:$LINENO: result: host tool" >&5
12329 echo "${ECHO_T}host tool" >&6
12330   else
12331     # We need a cross tool
12332     echo "$as_me:$LINENO: result: pre-installed" >&5
12333 echo "${ECHO_T}pre-installed" >&6
12334   fi
12335 fi
12336
12337 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12338 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12339 if test "x${build}" != "x${host}" ; then
12340   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12341     # We already found the complete path
12342     ac_dir=`dirname $WINDMC_FOR_TARGET`
12343     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12344 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12345   else
12346     # Canadian cross, just use what we found
12347     echo "$as_me:$LINENO: result: pre-installed" >&5
12348 echo "${ECHO_T}pre-installed" >&6
12349   fi
12350 else
12351   ok=yes
12352   case " ${configdirs} " in
12353     *" binutils "*) ;;
12354     *) ok=no ;;
12355   esac
12356
12357   if test $ok = yes; then
12358     # An in-tree tool is available and we can use it
12359     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12360     echo "$as_me:$LINENO: result: just compiled" >&5
12361 echo "${ECHO_T}just compiled" >&6
12362   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12363     # We already found the complete path
12364     ac_dir=`dirname $WINDMC_FOR_TARGET`
12365     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12366 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12367   elif test "x$target" = "x$host"; then
12368     # We can use an host tool
12369     WINDMC_FOR_TARGET='$(WINDMC)'
12370     echo "$as_me:$LINENO: result: host tool" >&5
12371 echo "${ECHO_T}host tool" >&6
12372   else
12373     # We need a cross tool
12374     echo "$as_me:$LINENO: result: pre-installed" >&5
12375 echo "${ECHO_T}pre-installed" >&6
12376   fi
12377 fi
12378
12379
12380
12381
12382
12383 # Certain tools may need extra flags.
12384 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12385 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12386 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12387
12388 # When building target libraries, except in a Canadian cross, we use
12389 # the same toolchain as the compiler we just built.
12390 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12391 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12392 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12393 if test $host = $build; then
12394   case " $configdirs " in
12395     *" gcc "*)
12396       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12397       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12398       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12399       ;;
12400   esac
12401 fi
12402
12403
12404
12405
12406
12407 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12408 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12409 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12410 if test "${enable_maintainer_mode+set}" = set; then
12411   enableval="$enable_maintainer_mode"
12412   USE_MAINTAINER_MODE=$enableval
12413 else
12414   USE_MAINTAINER_MODE=no
12415 fi;
12416 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12417 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12418
12419
12420 if test "$USE_MAINTAINER_MODE" = yes; then
12421   MAINTAINER_MODE_TRUE=
12422   MAINTAINER_MODE_FALSE='#'
12423 else
12424   MAINTAINER_MODE_TRUE='#'
12425   MAINTAINER_MODE_FALSE=
12426 fi
12427 MAINT=$MAINTAINER_MODE_TRUE
12428
12429 # ---------------------
12430 # GCC bootstrap support
12431 # ---------------------
12432
12433 # Stage specific cflags for build.
12434 stage1_cflags="-g"
12435 case $build in
12436   vax-*-*)
12437     case ${GCC} in
12438       yes) stage1_cflags="-g -Wa,-J" ;;
12439       *) stage1_cflags="-g -J" ;;
12440     esac ;;
12441 esac
12442
12443 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12444 if test "$GCC" = yes; then
12445   saved_CFLAGS="$CFLAGS"
12446
12447   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12448   CFLAGS="$CFLAGS -fkeep-inline-functions"
12449   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12450 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12451   cat >conftest.$ac_ext <<_ACEOF
12452 /* confdefs.h.  */
12453 _ACEOF
12454 cat confdefs.h >>conftest.$ac_ext
12455 cat >>conftest.$ac_ext <<_ACEOF
12456 /* end confdefs.h.  */
12457
12458 #if (__GNUC__ < 3) \
12459     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12460                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12461 #error http://gcc.gnu.org/PR29382
12462 #endif
12463
12464 int
12465 main ()
12466 {
12467
12468   ;
12469   return 0;
12470 }
12471 _ACEOF
12472 rm -f conftest.$ac_objext
12473 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12474   (eval $ac_compile) 2>conftest.er1
12475   ac_status=$?
12476   grep -v '^ *+' conftest.er1 >conftest.err
12477   rm -f conftest.er1
12478   cat conftest.err >&5
12479   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12480   (exit $ac_status); } &&
12481          { ac_try='test -z "$ac_c_werror_flag"
12482                          || test ! -s conftest.err'
12483   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12484   (eval $ac_try) 2>&5
12485   ac_status=$?
12486   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12487   (exit $ac_status); }; } &&
12488          { ac_try='test -s conftest.$ac_objext'
12489   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12490   (eval $ac_try) 2>&5
12491   ac_status=$?
12492   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12493   (exit $ac_status); }; }; then
12494   echo "$as_me:$LINENO: result: yes" >&5
12495 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12496 else
12497   echo "$as_me: failed program was:" >&5
12498 sed 's/^/| /' conftest.$ac_ext >&5
12499
12500 echo "$as_me:$LINENO: result: no" >&5
12501 echo "${ECHO_T}no" >&6
12502 fi
12503 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12504
12505   CFLAGS="$saved_CFLAGS"
12506 fi
12507
12508
12509
12510 # Enable --enable-checking in stage1 of the compiler.
12511 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12512 if test "${enable_stage1_checking+set}" = set; then
12513   enableval="$enable_stage1_checking"
12514   stage1_checking=--enable-checking=${enable_stage1_checking}
12515 else
12516   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12517   stage1_checking=--enable-checking=yes,types
12518 else
12519   stage1_checking=--enable-checking=$enable_checking,types
12520 fi
12521 fi;
12522
12523
12524 # Enable -Werror in bootstrap stage2 and later.
12525 # Check whether --enable-werror or --disable-werror was given.
12526 if test "${enable_werror+set}" = set; then
12527   enableval="$enable_werror"
12528
12529 else
12530   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12531   enable_werror=yes
12532 else
12533   enable_werror=no
12534 fi
12535 fi;
12536 case ${enable_werror} in
12537   yes) stage2_werror_flag="--enable-werror-always" ;;
12538   *) stage2_werror_flag="" ;;
12539 esac
12540
12541
12542 # Flags needed to enable html installing and building
12543
12544 # Check whether --with-datarootdir or --without-datarootdir was given.
12545 if test "${with_datarootdir+set}" = set; then
12546   withval="$with_datarootdir"
12547   datarootdir="\${prefix}/${withval}"
12548 else
12549   datarootdir="\${prefix}/share"
12550 fi;
12551
12552
12553 # Check whether --with-docdir or --without-docdir was given.
12554 if test "${with_docdir+set}" = set; then
12555   withval="$with_docdir"
12556   docdir="\${prefix}/${withval}"
12557 else
12558   docdir="\${datarootdir}/doc"
12559 fi;
12560
12561
12562 # Check whether --with-pdfdir or --without-pdfdir was given.
12563 if test "${with_pdfdir+set}" = set; then
12564   withval="$with_pdfdir"
12565   pdfdir="\${prefix}/${withval}"
12566 else
12567   pdfdir="\${docdir}"
12568 fi;
12569
12570
12571 # Check whether --with-htmldir or --without-htmldir was given.
12572 if test "${with_htmldir+set}" = set; then
12573   withval="$with_htmldir"
12574   htmldir="\${prefix}/${withval}"
12575 else
12576   htmldir="\${docdir}"
12577 fi;
12578
12579
12580
12581
12582
12583
12584           ac_config_files="$ac_config_files Makefile"
12585 cat >confcache <<\_ACEOF
12586 # This file is a shell script that caches the results of configure
12587 # tests run on this system so they can be shared between configure
12588 # scripts and configure runs, see configure's option --config-cache.
12589 # It is not useful on other systems.  If it contains results you don't
12590 # want to keep, you may remove or edit it.
12591 #
12592 # config.status only pays attention to the cache file if you give it
12593 # the --recheck option to rerun configure.
12594 #
12595 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12596 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12597 # following values.
12598
12599 _ACEOF
12600
12601 # The following way of writing the cache mishandles newlines in values,
12602 # but we know of no workaround that is simple, portable, and efficient.
12603 # So, don't put newlines in cache variables' values.
12604 # Ultrix sh set writes to stderr and can't be redirected directly,
12605 # and sets the high bit in the cache file unless we assign to the vars.
12606 {
12607   (set) 2>&1 |
12608     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12609     *ac_space=\ *)
12610       # `set' does not quote correctly, so add quotes (double-quote
12611       # substitution turns \\\\ into \\, and sed turns \\ into \).
12612       sed -n \
12613         "s/'/'\\\\''/g;
12614           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12615       ;;
12616     *)
12617       # `set' quotes correctly as required by POSIX, so do not add quotes.
12618       sed -n \
12619         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12620       ;;
12621     esac;
12622 } |
12623   sed '
12624      t clear
12625      : clear
12626      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12627      t end
12628      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12629      : end' >>confcache
12630 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12631   if test -w $cache_file; then
12632     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12633     cat confcache >$cache_file
12634   else
12635     echo "not updating unwritable cache $cache_file"
12636   fi
12637 fi
12638 rm -f confcache
12639
12640 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12641 # Let make expand exec_prefix.
12642 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12643
12644 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12645 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12646 # trailing colons and then remove the whole line if VPATH becomes empty
12647 # (actually we leave an empty line to preserve line numbers).
12648 if test "x$srcdir" = x.; then
12649   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12650 s/:*\$(srcdir):*/:/;
12651 s/:*\${srcdir}:*/:/;
12652 s/:*@srcdir@:*/:/;
12653 s/^\([^=]*=[     ]*\):*/\1/;
12654 s/:*$//;
12655 s/^[^=]*=[       ]*$//;
12656 }'
12657 fi
12658
12659 # Transform confdefs.h into DEFS.
12660 # Protect against shell expansion while executing Makefile rules.
12661 # Protect against Makefile macro expansion.
12662 #
12663 # If the first sed substitution is executed (which looks for macros that
12664 # take arguments), then we branch to the quote section.  Otherwise,
12665 # look for a macro that doesn't take arguments.
12666 cat >confdef2opt.sed <<\_ACEOF
12667 t clear
12668 : clear
12669 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12670 t quote
12671 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12672 t quote
12673 d
12674 : quote
12675 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12676 s,\[,\\&,g
12677 s,\],\\&,g
12678 s,\$,$$,g
12679 p
12680 _ACEOF
12681 # We use echo to avoid assuming a particular line-breaking character.
12682 # The extra dot is to prevent the shell from consuming trailing
12683 # line-breaks from the sub-command output.  A line-break within
12684 # single-quotes doesn't work because, if this script is created in a
12685 # platform that uses two characters for line-breaks (e.g., DOS), tr
12686 # would break.
12687 ac_LF_and_DOT=`echo; echo .`
12688 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12689 rm -f confdef2opt.sed
12690
12691
12692 ac_libobjs=
12693 ac_ltlibobjs=
12694 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12695   # 1. Remove the extension, and $U if already installed.
12696   ac_i=`echo "$ac_i" |
12697          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12698   # 2. Add them.
12699   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12700   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12701 done
12702 LIBOBJS=$ac_libobjs
12703
12704 LTLIBOBJS=$ac_ltlibobjs
12705
12706
12707
12708 : ${CONFIG_STATUS=./config.status}
12709 ac_clean_files_save=$ac_clean_files
12710 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12711 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12712 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12713 cat >$CONFIG_STATUS <<_ACEOF
12714 #! $SHELL
12715 # Generated by $as_me.
12716 # Run this file to recreate the current configuration.
12717 # Compiler output produced by configure, useful for debugging
12718 # configure, is in config.log if it exists.
12719
12720 debug=false
12721 ac_cs_recheck=false
12722 ac_cs_silent=false
12723 SHELL=\${CONFIG_SHELL-$SHELL}
12724 _ACEOF
12725
12726 cat >>$CONFIG_STATUS <<\_ACEOF
12727 ## --------------------- ##
12728 ## M4sh Initialization.  ##
12729 ## --------------------- ##
12730
12731 # Be Bourne compatible
12732 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12733   emulate sh
12734   NULLCMD=:
12735   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12736   # is contrary to our usage.  Disable this feature.
12737   alias -g '${1+"$@"}'='"$@"'
12738 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12739   set -o posix
12740 fi
12741 DUALCASE=1; export DUALCASE # for MKS sh
12742
12743 # Support unset when possible.
12744 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12745   as_unset=unset
12746 else
12747   as_unset=false
12748 fi
12749
12750
12751 # Work around bugs in pre-3.0 UWIN ksh.
12752 $as_unset ENV MAIL MAILPATH
12753 PS1='$ '
12754 PS2='> '
12755 PS4='+ '
12756
12757 # NLS nuisances.
12758 for as_var in \
12759   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12760   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12761   LC_TELEPHONE LC_TIME
12762 do
12763   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12764     eval $as_var=C; export $as_var
12765   else
12766     $as_unset $as_var
12767   fi
12768 done
12769
12770 # Required to use basename.
12771 if expr a : '\(a\)' >/dev/null 2>&1; then
12772   as_expr=expr
12773 else
12774   as_expr=false
12775 fi
12776
12777 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12778   as_basename=basename
12779 else
12780   as_basename=false
12781 fi
12782
12783
12784 # Name of the executable.
12785 as_me=`$as_basename "$0" ||
12786 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12787          X"$0" : 'X\(//\)$' \| \
12788          X"$0" : 'X\(/\)$' \| \
12789          .     : '\(.\)' 2>/dev/null ||
12790 echo X/"$0" |
12791     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12792           /^X\/\(\/\/\)$/{ s//\1/; q; }
12793           /^X\/\(\/\).*/{ s//\1/; q; }
12794           s/.*/./; q'`
12795
12796
12797 # PATH needs CR, and LINENO needs CR and PATH.
12798 # Avoid depending upon Character Ranges.
12799 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12800 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12801 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12802 as_cr_digits='0123456789'
12803 as_cr_alnum=$as_cr_Letters$as_cr_digits
12804
12805 # The user is always right.
12806 if test "${PATH_SEPARATOR+set}" != set; then
12807   echo "#! /bin/sh" >conf$$.sh
12808   echo  "exit 0"   >>conf$$.sh
12809   chmod +x conf$$.sh
12810   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12811     PATH_SEPARATOR=';'
12812   else
12813     PATH_SEPARATOR=:
12814   fi
12815   rm -f conf$$.sh
12816 fi
12817
12818
12819   as_lineno_1=$LINENO
12820   as_lineno_2=$LINENO
12821   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12822   test "x$as_lineno_1" != "x$as_lineno_2" &&
12823   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12824   # Find who we are.  Look in the path if we contain no path at all
12825   # relative or not.
12826   case $0 in
12827     *[\\/]* ) as_myself=$0 ;;
12828     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12829 for as_dir in $PATH
12830 do
12831   IFS=$as_save_IFS
12832   test -z "$as_dir" && as_dir=.
12833   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12834 done
12835
12836        ;;
12837   esac
12838   # We did not find ourselves, most probably we were run as `sh COMMAND'
12839   # in which case we are not to be found in the path.
12840   if test "x$as_myself" = x; then
12841     as_myself=$0
12842   fi
12843   if test ! -f "$as_myself"; then
12844     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12845 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12846    { (exit 1); exit 1; }; }
12847   fi
12848   case $CONFIG_SHELL in
12849   '')
12850     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12851 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12852 do
12853   IFS=$as_save_IFS
12854   test -z "$as_dir" && as_dir=.
12855   for as_base in sh bash ksh sh5; do
12856          case $as_dir in
12857          /*)
12858            if ("$as_dir/$as_base" -c '
12859   as_lineno_1=$LINENO
12860   as_lineno_2=$LINENO
12861   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12862   test "x$as_lineno_1" != "x$as_lineno_2" &&
12863   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12864              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12865              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12866              CONFIG_SHELL=$as_dir/$as_base
12867              export CONFIG_SHELL
12868              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12869            fi;;
12870          esac
12871        done
12872 done
12873 ;;
12874   esac
12875
12876   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12877   # uniformly replaced by the line number.  The first 'sed' inserts a
12878   # line-number line before each line; the second 'sed' does the real
12879   # work.  The second script uses 'N' to pair each line-number line
12880   # with the numbered line, and appends trailing '-' during
12881   # substitution so that $LINENO is not a special case at line end.
12882   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12883   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12884   sed '=' <$as_myself |
12885     sed '
12886       N
12887       s,$,-,
12888       : loop
12889       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12890       t loop
12891       s,-$,,
12892       s,^['$as_cr_digits']*\n,,
12893     ' >$as_me.lineno &&
12894   chmod +x $as_me.lineno ||
12895     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12896 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12897    { (exit 1); exit 1; }; }
12898
12899   # Don't try to exec as it changes $[0], causing all sort of problems
12900   # (the dirname of $[0] is not the place where we might find the
12901   # original and so on.  Autoconf is especially sensible to this).
12902   . ./$as_me.lineno
12903   # Exit status is that of the last command.
12904   exit
12905 }
12906
12907
12908 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12909   *c*,-n*) ECHO_N= ECHO_C='
12910 ' ECHO_T='      ' ;;
12911   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12912   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12913 esac
12914
12915 if expr a : '\(a\)' >/dev/null 2>&1; then
12916   as_expr=expr
12917 else
12918   as_expr=false
12919 fi
12920
12921 rm -f conf$$ conf$$.exe conf$$.file
12922 echo >conf$$.file
12923 if ln -s conf$$.file conf$$ 2>/dev/null; then
12924   # We could just check for DJGPP; but this test a) works b) is more generic
12925   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12926   if test -f conf$$.exe; then
12927     # Don't use ln at all; we don't have any links
12928     as_ln_s='cp -p'
12929   else
12930     as_ln_s='ln -s'
12931   fi
12932 elif ln conf$$.file conf$$ 2>/dev/null; then
12933   as_ln_s=ln
12934 else
12935   as_ln_s='cp -p'
12936 fi
12937 rm -f conf$$ conf$$.exe conf$$.file
12938
12939 if mkdir -p . 2>/dev/null; then
12940   as_mkdir_p=:
12941 else
12942   test -d ./-p && rmdir ./-p
12943   as_mkdir_p=false
12944 fi
12945
12946 as_executable_p="test -f"
12947
12948 # Sed expression to map a string onto a valid CPP name.
12949 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12950
12951 # Sed expression to map a string onto a valid variable name.
12952 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12953
12954
12955 # IFS
12956 # We need space, tab and new line, in precisely that order.
12957 as_nl='
12958 '
12959 IFS="   $as_nl"
12960
12961 # CDPATH.
12962 $as_unset CDPATH
12963
12964 exec 6>&1
12965
12966 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12967 # report actual input values of CONFIG_FILES etc. instead of their
12968 # values after options handling.  Logging --version etc. is OK.
12969 exec 5>>config.log
12970 {
12971   echo
12972   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12973 ## Running $as_me. ##
12974 _ASBOX
12975 } >&5
12976 cat >&5 <<_CSEOF
12977
12978 This file was extended by $as_me, which was
12979 generated by GNU Autoconf 2.59.  Invocation command line was
12980
12981   CONFIG_FILES    = $CONFIG_FILES
12982   CONFIG_HEADERS  = $CONFIG_HEADERS
12983   CONFIG_LINKS    = $CONFIG_LINKS
12984   CONFIG_COMMANDS = $CONFIG_COMMANDS
12985   $ $0 $@
12986
12987 _CSEOF
12988 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12989 echo >&5
12990 _ACEOF
12991
12992 # Files that config.status was made for.
12993 if test -n "$ac_config_files"; then
12994   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12995 fi
12996
12997 if test -n "$ac_config_headers"; then
12998   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12999 fi
13000
13001 if test -n "$ac_config_links"; then
13002   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
13003 fi
13004
13005 if test -n "$ac_config_commands"; then
13006   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
13007 fi
13008
13009 cat >>$CONFIG_STATUS <<\_ACEOF
13010
13011 ac_cs_usage="\
13012 \`$as_me' instantiates files from templates according to the
13013 current configuration.
13014
13015 Usage: $0 [OPTIONS] [FILE]...
13016
13017   -h, --help       print this help, then exit
13018   -V, --version    print version number, then exit
13019   -q, --quiet      do not print progress messages
13020   -d, --debug      don't remove temporary files
13021       --recheck    update $as_me by reconfiguring in the same conditions
13022   --file=FILE[:TEMPLATE]
13023                    instantiate the configuration file FILE
13024
13025 Configuration files:
13026 $config_files
13027
13028 Report bugs to <bug-autoconf@gnu.org>."
13029 _ACEOF
13030
13031 cat >>$CONFIG_STATUS <<_ACEOF
13032 ac_cs_version="\\
13033 config.status
13034 configured by $0, generated by GNU Autoconf 2.59,
13035   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13036
13037 Copyright (C) 2003 Free Software Foundation, Inc.
13038 This config.status script is free software; the Free Software Foundation
13039 gives unlimited permission to copy, distribute and modify it."
13040 srcdir=$srcdir
13041 INSTALL="$INSTALL"
13042 _ACEOF
13043
13044 cat >>$CONFIG_STATUS <<\_ACEOF
13045 # If no file are specified by the user, then we need to provide default
13046 # value.  By we need to know if files were specified by the user.
13047 ac_need_defaults=:
13048 while test $# != 0
13049 do
13050   case $1 in
13051   --*=*)
13052     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13053     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13054     ac_shift=:
13055     ;;
13056   -*)
13057     ac_option=$1
13058     ac_optarg=$2
13059     ac_shift=shift
13060     ;;
13061   *) # This is not an option, so the user has probably given explicit
13062      # arguments.
13063      ac_option=$1
13064      ac_need_defaults=false;;
13065   esac
13066
13067   case $ac_option in
13068   # Handling of the options.
13069 _ACEOF
13070 cat >>$CONFIG_STATUS <<\_ACEOF
13071   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13072     ac_cs_recheck=: ;;
13073   --version | --vers* | -V )
13074     echo "$ac_cs_version"; exit 0 ;;
13075   --he | --h)
13076     # Conflict between --help and --header
13077     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13078 Try \`$0 --help' for more information." >&5
13079 echo "$as_me: error: ambiguous option: $1
13080 Try \`$0 --help' for more information." >&2;}
13081    { (exit 1); exit 1; }; };;
13082   --help | --hel | -h )
13083     echo "$ac_cs_usage"; exit 0 ;;
13084   --debug | --d* | -d )
13085     debug=: ;;
13086   --file | --fil | --fi | --f )
13087     $ac_shift
13088     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13089     ac_need_defaults=false;;
13090   --header | --heade | --head | --hea )
13091     $ac_shift
13092     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13093     ac_need_defaults=false;;
13094   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13095   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13096     ac_cs_silent=: ;;
13097
13098   # This is an error.
13099   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13100 Try \`$0 --help' for more information." >&5
13101 echo "$as_me: error: unrecognized option: $1
13102 Try \`$0 --help' for more information." >&2;}
13103    { (exit 1); exit 1; }; } ;;
13104
13105   *) ac_config_targets="$ac_config_targets $1" ;;
13106
13107   esac
13108   shift
13109 done
13110
13111 ac_configure_extra_args=
13112
13113 if $ac_cs_silent; then
13114   exec 6>/dev/null
13115   ac_configure_extra_args="$ac_configure_extra_args --silent"
13116 fi
13117
13118 _ACEOF
13119 cat >>$CONFIG_STATUS <<_ACEOF
13120 if \$ac_cs_recheck; then
13121   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13122   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13123 fi
13124
13125 _ACEOF
13126
13127
13128
13129
13130
13131 cat >>$CONFIG_STATUS <<\_ACEOF
13132 for ac_config_target in $ac_config_targets
13133 do
13134   case "$ac_config_target" in
13135   # Handling of arguments.
13136   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13137   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13138 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13139    { (exit 1); exit 1; }; };;
13140   esac
13141 done
13142
13143 # If the user did not use the arguments to specify the items to instantiate,
13144 # then the envvar interface is used.  Set only those that are not.
13145 # We use the long form for the default assignment because of an extremely
13146 # bizarre bug on SunOS 4.1.3.
13147 if $ac_need_defaults; then
13148   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13149 fi
13150
13151 # Have a temporary directory for convenience.  Make it in the build tree
13152 # simply because there is no reason to put it here, and in addition,
13153 # creating and moving files from /tmp can sometimes cause problems.
13154 # Create a temporary directory, and hook for its removal unless debugging.
13155 $debug ||
13156 {
13157   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13158   trap '{ (exit 1); exit 1; }' 1 2 13 15
13159 }
13160
13161 # Create a (secure) tmp directory for tmp files.
13162
13163 {
13164   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13165   test -n "$tmp" && test -d "$tmp"
13166 }  ||
13167 {
13168   tmp=./confstat$$-$RANDOM
13169   (umask 077 && mkdir $tmp)
13170 } ||
13171 {
13172    echo "$me: cannot create a temporary directory in ." >&2
13173    { (exit 1); exit 1; }
13174 }
13175
13176 _ACEOF
13177
13178 cat >>$CONFIG_STATUS <<_ACEOF
13179
13180 #
13181 # CONFIG_FILES section.
13182 #
13183
13184 # No need to generate the scripts if there are no CONFIG_FILES.
13185 # This happens for instance when ./config.status config.h
13186 if test -n "\$CONFIG_FILES"; then
13187   # Protect against being on the right side of a sed subst in config.status.
13188   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13189    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13190 s,@SHELL@,$SHELL,;t t
13191 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13192 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13193 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13194 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13195 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13196 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13197 s,@exec_prefix@,$exec_prefix,;t t
13198 s,@prefix@,$prefix,;t t
13199 s,@program_transform_name@,$program_transform_name,;t t
13200 s,@bindir@,$bindir,;t t
13201 s,@sbindir@,$sbindir,;t t
13202 s,@libexecdir@,$libexecdir,;t t
13203 s,@datadir@,$datadir,;t t
13204 s,@sysconfdir@,$sysconfdir,;t t
13205 s,@sharedstatedir@,$sharedstatedir,;t t
13206 s,@localstatedir@,$localstatedir,;t t
13207 s,@libdir@,$libdir,;t t
13208 s,@includedir@,$includedir,;t t
13209 s,@oldincludedir@,$oldincludedir,;t t
13210 s,@infodir@,$infodir,;t t
13211 s,@mandir@,$mandir,;t t
13212 s,@build_alias@,$build_alias,;t t
13213 s,@host_alias@,$host_alias,;t t
13214 s,@target_alias@,$target_alias,;t t
13215 s,@DEFS@,$DEFS,;t t
13216 s,@ECHO_C@,$ECHO_C,;t t
13217 s,@ECHO_N@,$ECHO_N,;t t
13218 s,@ECHO_T@,$ECHO_T,;t t
13219 s,@LIBS@,$LIBS,;t t
13220 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13221 s,@build@,$build,;t t
13222 s,@build_cpu@,$build_cpu,;t t
13223 s,@build_vendor@,$build_vendor,;t t
13224 s,@build_os@,$build_os,;t t
13225 s,@build_noncanonical@,$build_noncanonical,;t t
13226 s,@host_noncanonical@,$host_noncanonical,;t t
13227 s,@target_noncanonical@,$target_noncanonical,;t t
13228 s,@host@,$host,;t t
13229 s,@host_cpu@,$host_cpu,;t t
13230 s,@host_vendor@,$host_vendor,;t t
13231 s,@host_os@,$host_os,;t t
13232 s,@target@,$target,;t t
13233 s,@target_cpu@,$target_cpu,;t t
13234 s,@target_vendor@,$target_vendor,;t t
13235 s,@target_os@,$target_os,;t t
13236 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13237 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13238 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13239 s,@LN@,$LN,;t t
13240 s,@LN_S@,$LN_S,;t t
13241 s,@build_libsubdir@,$build_libsubdir,;t t
13242 s,@build_subdir@,$build_subdir,;t t
13243 s,@host_subdir@,$host_subdir,;t t
13244 s,@target_subdir@,$target_subdir,;t t
13245 s,@CC@,$CC,;t t
13246 s,@CFLAGS@,$CFLAGS,;t t
13247 s,@LDFLAGS@,$LDFLAGS,;t t
13248 s,@CPPFLAGS@,$CPPFLAGS,;t t
13249 s,@ac_ct_CC@,$ac_ct_CC,;t t
13250 s,@EXEEXT@,$EXEEXT,;t t
13251 s,@OBJEXT@,$OBJEXT,;t t
13252 s,@CXX@,$CXX,;t t
13253 s,@CXXFLAGS@,$CXXFLAGS,;t t
13254 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13255 s,@GNATBIND@,$GNATBIND,;t t
13256 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13257 s,@GNATMAKE@,$GNATMAKE,;t t
13258 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13259 s,@do_compare@,$do_compare,;t t
13260 s,@gmplibs@,$gmplibs,;t t
13261 s,@gmpinc@,$gmpinc,;t t
13262 s,@ppllibs@,$ppllibs,;t t
13263 s,@pplinc@,$pplinc,;t t
13264 s,@clooglibs@,$clooglibs,;t t
13265 s,@clooginc@,$clooginc,;t t
13266 s,@stage1_languages@,$stage1_languages,;t t
13267 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13268 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13269 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13270 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13271 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13272 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13273 s,@tooldir@,$tooldir,;t t
13274 s,@build_tooldir@,$build_tooldir,;t t
13275 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13276 s,@GDB_TK@,$GDB_TK,;t t
13277 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13278 s,@build_configargs@,$build_configargs,;t t
13279 s,@build_configdirs@,$build_configdirs,;t t
13280 s,@host_configargs@,$host_configargs,;t t
13281 s,@configdirs@,$configdirs,;t t
13282 s,@target_configargs@,$target_configargs,;t t
13283 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13284 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13285 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13286 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13287 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13288 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13289 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13290 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13291 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13292 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13293 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13294 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13295 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13296 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13297 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13298 s,@config_shell@,$config_shell,;t t
13299 s,@YACC@,$YACC,;t t
13300 s,@BISON@,$BISON,;t t
13301 s,@M4@,$M4,;t t
13302 s,@LEX@,$LEX,;t t
13303 s,@FLEX@,$FLEX,;t t
13304 s,@MAKEINFO@,$MAKEINFO,;t t
13305 s,@EXPECT@,$EXPECT,;t t
13306 s,@RUNTEST@,$RUNTEST,;t t
13307 s,@AR@,$AR,;t t
13308 s,@AS@,$AS,;t t
13309 s,@DLLTOOL@,$DLLTOOL,;t t
13310 s,@LD@,$LD,;t t
13311 s,@LIPO@,$LIPO,;t t
13312 s,@NM@,$NM,;t t
13313 s,@RANLIB@,$RANLIB,;t t
13314 s,@STRIP@,$STRIP,;t t
13315 s,@WINDRES@,$WINDRES,;t t
13316 s,@WINDMC@,$WINDMC,;t t
13317 s,@OBJCOPY@,$OBJCOPY,;t t
13318 s,@OBJDUMP@,$OBJDUMP,;t t
13319 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13320 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13321 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13322 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13323 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13324 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13325 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13326 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13327 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13328 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13329 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13330 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13331 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13332 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13333 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13334 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13335 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13336 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13337 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13338 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13339 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13340 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13341 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13342 s,@MAINT@,$MAINT,;t t
13343 s,@stage1_cflags@,$stage1_cflags,;t t
13344 s,@stage1_checking@,$stage1_checking,;t t
13345 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13346 s,@datarootdir@,$datarootdir,;t t
13347 s,@docdir@,$docdir,;t t
13348 s,@pdfdir@,$pdfdir,;t t
13349 s,@htmldir@,$htmldir,;t t
13350 s,@LIBOBJS@,$LIBOBJS,;t t
13351 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13352 /@serialization_dependencies@/r $serialization_dependencies
13353 s,@serialization_dependencies@,,;t t
13354 /@host_makefile_frag@/r $host_makefile_frag
13355 s,@host_makefile_frag@,,;t t
13356 /@target_makefile_frag@/r $target_makefile_frag
13357 s,@target_makefile_frag@,,;t t
13358 /@alphaieee_frag@/r $alphaieee_frag
13359 s,@alphaieee_frag@,,;t t
13360 /@ospace_frag@/r $ospace_frag
13361 s,@ospace_frag@,,;t t
13362 CEOF
13363
13364 _ACEOF
13365
13366   cat >>$CONFIG_STATUS <<\_ACEOF
13367   # Split the substitutions into bite-sized pieces for seds with
13368   # small command number limits, like on Digital OSF/1 and HP-UX.
13369   ac_max_sed_lines=48
13370   ac_sed_frag=1 # Number of current file.
13371   ac_beg=1 # First line for current file.
13372   ac_end=$ac_max_sed_lines # Line after last line for current file.
13373   ac_more_lines=:
13374   ac_sed_cmds=
13375   while $ac_more_lines; do
13376     if test $ac_beg -gt 1; then
13377       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13378     else
13379       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13380     fi
13381     if test ! -s $tmp/subs.frag; then
13382       ac_more_lines=false
13383     else
13384       # The purpose of the label and of the branching condition is to
13385       # speed up the sed processing (if there are no `@' at all, there
13386       # is no need to browse any of the substitutions).
13387       # These are the two extra sed commands mentioned above.
13388       (echo ':t
13389   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13390       if test -z "$ac_sed_cmds"; then
13391         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13392       else
13393         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13394       fi
13395       ac_sed_frag=`expr $ac_sed_frag + 1`
13396       ac_beg=$ac_end
13397       ac_end=`expr $ac_end + $ac_max_sed_lines`
13398     fi
13399   done
13400   if test -z "$ac_sed_cmds"; then
13401     ac_sed_cmds=cat
13402   fi
13403 fi # test -n "$CONFIG_FILES"
13404
13405 _ACEOF
13406 cat >>$CONFIG_STATUS <<\_ACEOF
13407 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13408   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13409   case $ac_file in
13410   - | *:- | *:-:* ) # input from stdin
13411         cat >$tmp/stdin
13412         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13413         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13414   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13415         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13416   * )   ac_file_in=$ac_file.in ;;
13417   esac
13418
13419   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13420   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13421 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13422          X"$ac_file" : 'X\(//\)[^/]' \| \
13423          X"$ac_file" : 'X\(//\)$' \| \
13424          X"$ac_file" : 'X\(/\)' \| \
13425          .     : '\(.\)' 2>/dev/null ||
13426 echo X"$ac_file" |
13427     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13428           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13429           /^X\(\/\/\)$/{ s//\1/; q; }
13430           /^X\(\/\).*/{ s//\1/; q; }
13431           s/.*/./; q'`
13432   { if $as_mkdir_p; then
13433     mkdir -p "$ac_dir"
13434   else
13435     as_dir="$ac_dir"
13436     as_dirs=
13437     while test ! -d "$as_dir"; do
13438       as_dirs="$as_dir $as_dirs"
13439       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13440 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13441          X"$as_dir" : 'X\(//\)[^/]' \| \
13442          X"$as_dir" : 'X\(//\)$' \| \
13443          X"$as_dir" : 'X\(/\)' \| \
13444          .     : '\(.\)' 2>/dev/null ||
13445 echo X"$as_dir" |
13446     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13447           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13448           /^X\(\/\/\)$/{ s//\1/; q; }
13449           /^X\(\/\).*/{ s//\1/; q; }
13450           s/.*/./; q'`
13451     done
13452     test ! -n "$as_dirs" || mkdir $as_dirs
13453   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13454 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13455    { (exit 1); exit 1; }; }; }
13456
13457   ac_builddir=.
13458
13459 if test "$ac_dir" != .; then
13460   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13461   # A "../" for each directory in $ac_dir_suffix.
13462   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13463 else
13464   ac_dir_suffix= ac_top_builddir=
13465 fi
13466
13467 case $srcdir in
13468   .)  # No --srcdir option.  We are building in place.
13469     ac_srcdir=.
13470     if test -z "$ac_top_builddir"; then
13471        ac_top_srcdir=.
13472     else
13473        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13474     fi ;;
13475   [\\/]* | ?:[\\/]* )  # Absolute path.
13476     ac_srcdir=$srcdir$ac_dir_suffix;
13477     ac_top_srcdir=$srcdir ;;
13478   *) # Relative path.
13479     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13480     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13481 esac
13482
13483 # Do not use `cd foo && pwd` to compute absolute paths, because
13484 # the directories may not exist.
13485 case `pwd` in
13486 .) ac_abs_builddir="$ac_dir";;
13487 *)
13488   case "$ac_dir" in
13489   .) ac_abs_builddir=`pwd`;;
13490   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13491   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13492   esac;;
13493 esac
13494 case $ac_abs_builddir in
13495 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13496 *)
13497   case ${ac_top_builddir}. in
13498   .) ac_abs_top_builddir=$ac_abs_builddir;;
13499   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13500   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13501   esac;;
13502 esac
13503 case $ac_abs_builddir in
13504 .) ac_abs_srcdir=$ac_srcdir;;
13505 *)
13506   case $ac_srcdir in
13507   .) ac_abs_srcdir=$ac_abs_builddir;;
13508   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13509   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13510   esac;;
13511 esac
13512 case $ac_abs_builddir in
13513 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13514 *)
13515   case $ac_top_srcdir in
13516   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13517   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13518   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13519   esac;;
13520 esac
13521
13522
13523   case $INSTALL in
13524   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13525   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13526   esac
13527
13528   if test x"$ac_file" != x-; then
13529     { echo "$as_me:$LINENO: creating $ac_file" >&5
13530 echo "$as_me: creating $ac_file" >&6;}
13531     rm -f "$ac_file"
13532   fi
13533   # Let's still pretend it is `configure' which instantiates (i.e., don't
13534   # use $as_me), people would be surprised to read:
13535   #    /* config.h.  Generated by config.status.  */
13536   if test x"$ac_file" = x-; then
13537     configure_input=
13538   else
13539     configure_input="$ac_file.  "
13540   fi
13541   configure_input=$configure_input"Generated from `echo $ac_file_in |
13542                                      sed 's,.*/,,'` by configure."
13543
13544   # First look for the input files in the build tree, otherwise in the
13545   # src tree.
13546   ac_file_inputs=`IFS=:
13547     for f in $ac_file_in; do
13548       case $f in
13549       -) echo $tmp/stdin ;;
13550       [\\/$]*)
13551          # Absolute (can't be DOS-style, as IFS=:)
13552          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13553 echo "$as_me: error: cannot find input file: $f" >&2;}
13554    { (exit 1); exit 1; }; }
13555          echo "$f";;
13556       *) # Relative
13557          if test -f "$f"; then
13558            # Build tree
13559            echo "$f"
13560          elif test -f "$srcdir/$f"; then
13561            # Source tree
13562            echo "$srcdir/$f"
13563          else
13564            # /dev/null tree
13565            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13566 echo "$as_me: error: cannot find input file: $f" >&2;}
13567    { (exit 1); exit 1; }; }
13568          fi;;
13569       esac
13570     done` || { (exit 1); exit 1; }
13571 _ACEOF
13572 cat >>$CONFIG_STATUS <<_ACEOF
13573   sed "$ac_vpsub
13574 $extrasub
13575 _ACEOF
13576 cat >>$CONFIG_STATUS <<\_ACEOF
13577 :t
13578 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13579 s,@configure_input@,$configure_input,;t t
13580 s,@srcdir@,$ac_srcdir,;t t
13581 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13582 s,@top_srcdir@,$ac_top_srcdir,;t t
13583 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13584 s,@builddir@,$ac_builddir,;t t
13585 s,@abs_builddir@,$ac_abs_builddir,;t t
13586 s,@top_builddir@,$ac_top_builddir,;t t
13587 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13588 s,@INSTALL@,$ac_INSTALL,;t t
13589 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13590   rm -f $tmp/stdin
13591   if test x"$ac_file" != x-; then
13592     mv $tmp/out $ac_file
13593   else
13594     cat $tmp/out
13595     rm -f $tmp/out
13596   fi
13597
13598 done
13599 _ACEOF
13600
13601 cat >>$CONFIG_STATUS <<\_ACEOF
13602
13603 { (exit 0); exit 0; }
13604 _ACEOF
13605 chmod +x $CONFIG_STATUS
13606 ac_clean_files=$ac_clean_files_save
13607
13608
13609 # configure is writing to config.log, and then calls config.status.
13610 # config.status does its own redirection, appending to config.log.
13611 # Unfortunately, on DOS this fails, as config.log is still kept open
13612 # by configure, so config.status won't be able to write to it; its
13613 # output is simply discarded.  So we exec the FD to /dev/null,
13614 # effectively closing config.log, so it can be properly (re)opened and
13615 # appended to by config.status.  When coming back to configure, we
13616 # need to make the FD available again.
13617 if test "$no_create" != yes; then
13618   ac_cs_success=:
13619   ac_config_status_args=
13620   test "$silent" = yes &&
13621     ac_config_status_args="$ac_config_status_args --quiet"
13622   exec 5>/dev/null
13623   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13624   exec 5>>config.log
13625   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13626   # would make configure fail if this is the last instruction.
13627   $ac_cs_success || { (exit 1); exit 1; }
13628 fi
13629