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   microblaze*)
2609     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2610     ;;
2611   mips*-sde-elf*)
2612     skipdirs="$skipdirs target-libiberty"
2613     noconfigdirs="$noconfigdirs ${libgcj}"
2614     if test x$with_newlib = xyes; then
2615       noconfigdirs="$noconfigdirs gprof"
2616     fi
2617     libgloss_dir=mips
2618     ;;
2619   mips*-*-irix5*)
2620     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2621     ;;
2622   mips*-*-irix6*)
2623     # Linking libjava exceeds command-line length limits on at least
2624     # IRIX 6.2, but not on IRIX 6.5.
2625     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2626     # <oldham@codesourcery.com>
2627     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2628     ;;
2629   mips*-*-bsd*)
2630     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2631     ;;
2632   mips*-*-linux*)
2633     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2634     ;;
2635   mips*-*-*)
2636     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2637     libgloss_dir=mips
2638     ;;
2639   romp-*-*)
2640     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2641     ;;
2642   sh-*-* | sh64-*-*)
2643     case "${host}" in
2644       i[3456789]86-*-vsta) ;; # don't add gprof back in
2645       i[3456789]86-*-go32*) ;; # don't add gprof back in
2646       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2647       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2648     esac
2649     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2650     ;;
2651   sparclet-*-aout* | sparc86x-*-*)
2652     libgloss_dir=sparc
2653     ;;
2654   sparc-*-elf*)
2655     noconfigdirs="$noconfigdirs ${libgcj}"
2656     ;;
2657   sparc64-*-elf*)
2658     noconfigdirs="$noconfigdirs ${libgcj}"
2659     libgloss_dir=sparc
2660     ;;
2661   sparclite-*-*)
2662     noconfigdirs="$noconfigdirs ${libgcj}"
2663     libgloss_dir=sparc
2664     ;;
2665   sparc-*-sunos4*)
2666     noconfigdirs="$noconfigdirs ${libgcj}"
2667     if test x${is_cross_compiler} != xno ; then
2668            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2669     else
2670            use_gnu_ld=no
2671     fi
2672     ;;
2673   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2674     noconfigdirs="$noconfigdirs ${libgcj}"
2675     ;;
2676   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2677     ;;
2678   v810-*-*)
2679     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2680     ;;
2681   v850-*-*)
2682     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2683     ;;
2684   v850e-*-*)
2685     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2686     ;;
2687   v850ea-*-*)
2688     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2689     ;;
2690   vax-*-vms)
2691     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2692     ;;
2693   vax-*-*)
2694     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2695     ;;
2696   xtensa*-*-*)
2697     noconfigdirs="$noconfigdirs ${libgcj}"
2698     ;;
2699   ip2k-*-*)
2700     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2701     ;;
2702   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2703     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2704     ;;
2705   *-*-lynxos*)
2706     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2707     ;;
2708   *-*-*)
2709     noconfigdirs="$noconfigdirs ${libgcj}"
2710     ;;
2711 esac
2712
2713 # If we aren't building newlib, then don't build libgloss, since libgloss
2714 # depends upon some newlib header files.
2715 case "${noconfigdirs}" in
2716   *target-libgloss*) ;;
2717   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2718 esac
2719
2720 # Work in distributions that contain no compiler tools, like Autoconf.
2721 tentative_cc=""
2722 host_makefile_frag=/dev/null
2723 if test -d ${srcdir}/config ; then
2724 case "${host}" in
2725   m68k-hp-hpux*)
2726     # Avoid "too much defining" errors from HPUX compiler.
2727     tentative_cc="cc -Wp,-H256000"
2728     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2729     # If it's HP/UX ar, this should be harmless.
2730     RANLIB="ar ts"
2731     ;;
2732   m68k-apollo-sysv*)
2733     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2734     ;;
2735   m68k-apollo-bsd*)
2736     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2737     # chokes on bfd, the compiler won't let you assign integers to enums, and
2738     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2739     # the apollo compiler" (the preferred version of GCC could be called cc,
2740     # or whatever), but I'm not sure leaving CC as cc is any better...
2741     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2742     # Used to have BISON=yacc.
2743     tentative_cc=gcc
2744     ;;
2745   m88k-dg-dgux*)
2746     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2747     ;;
2748   m88k-harris-cxux*)
2749     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2750     tentative_cc="cc -Xa"
2751     host_makefile_frag="config/mh-cxux"
2752     ;;
2753   m88k-motorola-sysv*)
2754     ;;
2755   mips*-dec-ultrix*)
2756     tentative_cc="cc -Wf,-XNg1000"
2757     host_makefile_frag="config/mh-decstation"
2758     ;;
2759   mips*-nec-sysv4*)
2760     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2761     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2762     host_makefile_frag="config/mh-necv4"
2763     ;;
2764   mips*-sgi-irix4*)
2765     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2766     # environment.  Also bump switch table size so that cp-parse will
2767     # compile.  Bump string length limit so linker builds.
2768     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2769     ;;
2770   mips*-*-sysv4*)
2771     host_makefile_frag="config/mh-sysv4"
2772     ;;
2773   mips*-*-sysv*)
2774     # This is for a MIPS running RISC/os 4.52C.
2775
2776     # This is needed for GDB, but needs to be in the top-level make because
2777     # if a library is compiled with the bsd headers and gets linked with the
2778     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2779     # a different size).
2780     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2781     # known except to select the sysv environment.  Could we use /proc instead?
2782     # These "sysv environments" and "bsd environments" often end up being a pain.
2783     #
2784     # This is not part of CFLAGS because perhaps not all C compilers have this
2785     # option.
2786     tentative_cc="cc -systype sysv"
2787     ;;
2788   i370-ibm-opened*)
2789     tentative_cc="c89"
2790     ;;
2791   i[3456789]86-*-sysv5*)
2792     host_makefile_frag="config/mh-sysv5"
2793     ;;
2794   i[3456789]86-*-dgux*)
2795     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2796     host_makefile_frag="config/mh-dgux386"
2797     ;;
2798   i[3456789]86-ncr-sysv4.3*)
2799     # The MetaWare compiler will generate a copyright message unless you
2800     # turn it off by adding the -Hnocopyr flag.
2801     tentative_cc="cc -Hnocopyr"
2802     ;;
2803   i[3456789]86-ncr-sysv4*)
2804     # for an NCR 3000 (i486/SVR4) system.
2805     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2806     # This compiler not only emits obnoxious copyright messages every time
2807     # you run it, but it chokes and dies on a whole bunch of GNU source
2808     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2809     tentative_cc="/usr/ccs/ATT/cc"
2810     host_makefile_frag="config/mh-ncr3000"
2811     ;;
2812   i[3456789]86-*-sco3.2v5*)
2813     ;;
2814   i[3456789]86-*-sco*)
2815     # The native C compiler botches some simple uses of const.  Unfortunately,
2816     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2817     tentative_cc="cc -Dconst="
2818     host_makefile_frag="config/mh-sco"
2819     ;;
2820   i[3456789]86-*-udk*)
2821     host_makefile_frag="config/mh-sysv5"
2822     ;;
2823   i[3456789]86-*-solaris2*)
2824     host_makefile_frag="config/mh-sysv4"
2825     ;;
2826   i[3456789]86-*-msdosdjgpp*)
2827     host_makefile_frag="config/mh-djgpp"
2828     ;;
2829   *-cygwin*)
2830
2831 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2832 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2833 echo a >cygwin-cat-check
2834 if test `cat cygwin-cat-check` == a ; then
2835   rm cygwin-cat-check
2836   echo "$as_me:$LINENO: result: yes" >&5
2837 echo "${ECHO_T}yes" >&6
2838 else
2839   rm cygwin-cat-check
2840   echo "$as_me:$LINENO: result: no" >&5
2841 echo "${ECHO_T}no" >&6
2842   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2843   Please either mount the build directory in binary mode or run the following
2844   commands before running any configure script:
2845 set -o igncr
2846 export SHELLOPTS
2847   " >&5
2848 echo "$as_me: error: The cat command does not ignore carriage return characters.
2849   Please either mount the build directory in binary mode or run the following
2850   commands before running any configure script:
2851 set -o igncr
2852 export SHELLOPTS
2853   " >&2;}
2854    { (exit 1); exit 1; }; }
2855 fi
2856
2857     host_makefile_frag="config/mh-cygwin"
2858     ;;
2859   *-mingw*)
2860     host_makefile_frag="config/mh-mingw"
2861     ;;
2862   *-interix*)
2863     host_makefile_frag="config/mh-interix"
2864     ;;
2865   vax-*-ultrix2*)
2866     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2867     tentative_cc=gcc
2868     ;;
2869   *-*-solaris2*)
2870     host_makefile_frag="config/mh-solaris"
2871     ;;
2872   m68k-sun-sunos*)
2873     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2874     # without overflowing the jump tables (-J says to use a 32 bit table)
2875     tentative_cc="cc -J"
2876     ;;
2877   hppa*-hp-hpux10*)
2878     tentative_cc="cc -Wp,-H256000"
2879     host_makefile_frag="config/mh-pa-hpux10"
2880     ;;
2881   hppa*-hp-hpux* | hppa*-*-hiux*)
2882     tentative_cc="cc -Wp,-H256000"
2883     host_makefile_frag="config/mh-pa"
2884     ;;
2885   hppa*-*)
2886     host_makefile_frag="config/mh-pa"
2887     ;;
2888   *-hp-hpux* | *-*-hiux*)
2889     tentative_cc="cc -Wp,-H256000"
2890     ;;
2891   rs6000-*-lynxos*)
2892     # /bin/cc is less than useful for our purposes.  Always use GCC
2893     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2894     host_makefile_frag="config/mh-lynxrs6k"
2895     ;;
2896   powerpc-*-darwin*)
2897     host_makefile_frag="config/mh-ppc-darwin"
2898     ;;
2899   powerpc-*-aix*)
2900     host_makefile_frag="config/mh-ppc-aix"
2901     ;;
2902   rs6000-*-aix*)
2903     host_makefile_frag="config/mh-ppc-aix"
2904     ;;
2905   *-*-lynxos*)
2906     # /bin/cc is less than useful for our purposes.  Always use GCC
2907     tentative_cc="/bin/gcc"
2908     ;;
2909   *-*-sysv4*)
2910     host_makefile_frag="config/mh-sysv4"
2911     ;;
2912   # This is placed last to prevent interfering with the cases above.
2913   i[3456789]86-*-*)
2914     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2915     host_makefile_frag="config/mh-x86omitfp"
2916     ;;
2917 esac
2918 fi
2919
2920 # If we aren't going to be using gcc, see if we can extract a definition
2921 # of CC from the fragment.
2922 # Actually, use the 'pre-extracted' version above.
2923 if test -z "${CC}" && test "${build}" = "${host}" ; then
2924   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2925   found=
2926   for dir in $PATH; do
2927     test -z "$dir" && dir=.
2928     if test -f $dir/gcc; then
2929       found=yes
2930       break
2931     fi
2932   done
2933   IFS="$save_ifs"
2934   if test -z "${found}" && test -n "${tentative_cc}" ; then
2935     CC=$tentative_cc
2936   fi
2937 fi
2938
2939 if test "${build}" != "${host}" ; then
2940   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2941   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2942   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2943   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2944   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2945   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2946   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2947   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2948   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2949   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2950   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2951   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2952 else
2953   AR_FOR_BUILD="\$(AR)"
2954   AS_FOR_BUILD="\$(AS)"
2955   CC_FOR_BUILD="\$(CC)"
2956   CXX_FOR_BUILD="\$(CXX)"
2957   GCJ_FOR_BUILD="\$(GCJ)"
2958   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2959   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2960   LD_FOR_BUILD="\$(LD)"
2961   NM_FOR_BUILD="\$(NM)"
2962   RANLIB_FOR_BUILD="\$(RANLIB)"
2963   WINDRES_FOR_BUILD="\$(WINDRES)"
2964   WINDMC_FOR_BUILD="\$(WINDMC)"
2965 fi
2966
2967 ac_ext=c
2968 ac_cpp='$CPP $CPPFLAGS'
2969 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2970 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2971 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2972 if test -n "$ac_tool_prefix"; then
2973   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2974 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2975 echo "$as_me:$LINENO: checking for $ac_word" >&5
2976 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2977 if test "${ac_cv_prog_CC+set}" = set; then
2978   echo $ECHO_N "(cached) $ECHO_C" >&6
2979 else
2980   if test -n "$CC"; then
2981   ac_cv_prog_CC="$CC" # Let the user override the test.
2982 else
2983 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2984 for as_dir in $PATH
2985 do
2986   IFS=$as_save_IFS
2987   test -z "$as_dir" && as_dir=.
2988   for ac_exec_ext in '' $ac_executable_extensions; do
2989   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2990     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2991     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2992     break 2
2993   fi
2994 done
2995 done
2996
2997 fi
2998 fi
2999 CC=$ac_cv_prog_CC
3000 if test -n "$CC"; then
3001   echo "$as_me:$LINENO: result: $CC" >&5
3002 echo "${ECHO_T}$CC" >&6
3003 else
3004   echo "$as_me:$LINENO: result: no" >&5
3005 echo "${ECHO_T}no" >&6
3006 fi
3007
3008 fi
3009 if test -z "$ac_cv_prog_CC"; then
3010   ac_ct_CC=$CC
3011   # Extract the first word of "gcc", so it can be a program name with args.
3012 set dummy gcc; ac_word=$2
3013 echo "$as_me:$LINENO: checking for $ac_word" >&5
3014 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3015 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3016   echo $ECHO_N "(cached) $ECHO_C" >&6
3017 else
3018   if test -n "$ac_ct_CC"; then
3019   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3020 else
3021 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3022 for as_dir in $PATH
3023 do
3024   IFS=$as_save_IFS
3025   test -z "$as_dir" && as_dir=.
3026   for ac_exec_ext in '' $ac_executable_extensions; do
3027   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3028     ac_cv_prog_ac_ct_CC="gcc"
3029     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3030     break 2
3031   fi
3032 done
3033 done
3034
3035 fi
3036 fi
3037 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3038 if test -n "$ac_ct_CC"; then
3039   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3040 echo "${ECHO_T}$ac_ct_CC" >&6
3041 else
3042   echo "$as_me:$LINENO: result: no" >&5
3043 echo "${ECHO_T}no" >&6
3044 fi
3045
3046   CC=$ac_ct_CC
3047 else
3048   CC="$ac_cv_prog_CC"
3049 fi
3050
3051 if test -z "$CC"; then
3052   if test -n "$ac_tool_prefix"; then
3053   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3054 set dummy ${ac_tool_prefix}cc; ac_word=$2
3055 echo "$as_me:$LINENO: checking for $ac_word" >&5
3056 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3057 if test "${ac_cv_prog_CC+set}" = set; then
3058   echo $ECHO_N "(cached) $ECHO_C" >&6
3059 else
3060   if test -n "$CC"; then
3061   ac_cv_prog_CC="$CC" # Let the user override the test.
3062 else
3063 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3064 for as_dir in $PATH
3065 do
3066   IFS=$as_save_IFS
3067   test -z "$as_dir" && as_dir=.
3068   for ac_exec_ext in '' $ac_executable_extensions; do
3069   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3070     ac_cv_prog_CC="${ac_tool_prefix}cc"
3071     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3072     break 2
3073   fi
3074 done
3075 done
3076
3077 fi
3078 fi
3079 CC=$ac_cv_prog_CC
3080 if test -n "$CC"; then
3081   echo "$as_me:$LINENO: result: $CC" >&5
3082 echo "${ECHO_T}$CC" >&6
3083 else
3084   echo "$as_me:$LINENO: result: no" >&5
3085 echo "${ECHO_T}no" >&6
3086 fi
3087
3088 fi
3089 if test -z "$ac_cv_prog_CC"; then
3090   ac_ct_CC=$CC
3091   # Extract the first word of "cc", so it can be a program name with args.
3092 set dummy cc; ac_word=$2
3093 echo "$as_me:$LINENO: checking for $ac_word" >&5
3094 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3095 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3096   echo $ECHO_N "(cached) $ECHO_C" >&6
3097 else
3098   if test -n "$ac_ct_CC"; then
3099   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3100 else
3101 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3102 for as_dir in $PATH
3103 do
3104   IFS=$as_save_IFS
3105   test -z "$as_dir" && as_dir=.
3106   for ac_exec_ext in '' $ac_executable_extensions; do
3107   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3108     ac_cv_prog_ac_ct_CC="cc"
3109     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3110     break 2
3111   fi
3112 done
3113 done
3114
3115 fi
3116 fi
3117 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3118 if test -n "$ac_ct_CC"; then
3119   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3120 echo "${ECHO_T}$ac_ct_CC" >&6
3121 else
3122   echo "$as_me:$LINENO: result: no" >&5
3123 echo "${ECHO_T}no" >&6
3124 fi
3125
3126   CC=$ac_ct_CC
3127 else
3128   CC="$ac_cv_prog_CC"
3129 fi
3130
3131 fi
3132 if test -z "$CC"; then
3133   # Extract the first word of "cc", so it can be a program name with args.
3134 set dummy cc; ac_word=$2
3135 echo "$as_me:$LINENO: checking for $ac_word" >&5
3136 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3137 if test "${ac_cv_prog_CC+set}" = set; then
3138   echo $ECHO_N "(cached) $ECHO_C" >&6
3139 else
3140   if test -n "$CC"; then
3141   ac_cv_prog_CC="$CC" # Let the user override the test.
3142 else
3143   ac_prog_rejected=no
3144 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3145 for as_dir in $PATH
3146 do
3147   IFS=$as_save_IFS
3148   test -z "$as_dir" && as_dir=.
3149   for ac_exec_ext in '' $ac_executable_extensions; do
3150   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3151     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3152        ac_prog_rejected=yes
3153        continue
3154      fi
3155     ac_cv_prog_CC="cc"
3156     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3157     break 2
3158   fi
3159 done
3160 done
3161
3162 if test $ac_prog_rejected = yes; then
3163   # We found a bogon in the path, so make sure we never use it.
3164   set dummy $ac_cv_prog_CC
3165   shift
3166   if test $# != 0; then
3167     # We chose a different compiler from the bogus one.
3168     # However, it has the same basename, so the bogon will be chosen
3169     # first if we set CC to just the basename; use the full file name.
3170     shift
3171     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3172   fi
3173 fi
3174 fi
3175 fi
3176 CC=$ac_cv_prog_CC
3177 if test -n "$CC"; then
3178   echo "$as_me:$LINENO: result: $CC" >&5
3179 echo "${ECHO_T}$CC" >&6
3180 else
3181   echo "$as_me:$LINENO: result: no" >&5
3182 echo "${ECHO_T}no" >&6
3183 fi
3184
3185 fi
3186 if test -z "$CC"; then
3187   if test -n "$ac_tool_prefix"; then
3188   for ac_prog in cl
3189   do
3190     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3191 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3192 echo "$as_me:$LINENO: checking for $ac_word" >&5
3193 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3194 if test "${ac_cv_prog_CC+set}" = set; then
3195   echo $ECHO_N "(cached) $ECHO_C" >&6
3196 else
3197   if test -n "$CC"; then
3198   ac_cv_prog_CC="$CC" # Let the user override the test.
3199 else
3200 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3201 for as_dir in $PATH
3202 do
3203   IFS=$as_save_IFS
3204   test -z "$as_dir" && as_dir=.
3205   for ac_exec_ext in '' $ac_executable_extensions; do
3206   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3207     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3208     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3209     break 2
3210   fi
3211 done
3212 done
3213
3214 fi
3215 fi
3216 CC=$ac_cv_prog_CC
3217 if test -n "$CC"; then
3218   echo "$as_me:$LINENO: result: $CC" >&5
3219 echo "${ECHO_T}$CC" >&6
3220 else
3221   echo "$as_me:$LINENO: result: no" >&5
3222 echo "${ECHO_T}no" >&6
3223 fi
3224
3225     test -n "$CC" && break
3226   done
3227 fi
3228 if test -z "$CC"; then
3229   ac_ct_CC=$CC
3230   for ac_prog in cl
3231 do
3232   # Extract the first word of "$ac_prog", so it can be a program name with args.
3233 set dummy $ac_prog; ac_word=$2
3234 echo "$as_me:$LINENO: checking for $ac_word" >&5
3235 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3236 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3237   echo $ECHO_N "(cached) $ECHO_C" >&6
3238 else
3239   if test -n "$ac_ct_CC"; then
3240   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3241 else
3242 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3243 for as_dir in $PATH
3244 do
3245   IFS=$as_save_IFS
3246   test -z "$as_dir" && as_dir=.
3247   for ac_exec_ext in '' $ac_executable_extensions; do
3248   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3249     ac_cv_prog_ac_ct_CC="$ac_prog"
3250     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3251     break 2
3252   fi
3253 done
3254 done
3255
3256 fi
3257 fi
3258 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3259 if test -n "$ac_ct_CC"; then
3260   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3261 echo "${ECHO_T}$ac_ct_CC" >&6
3262 else
3263   echo "$as_me:$LINENO: result: no" >&5
3264 echo "${ECHO_T}no" >&6
3265 fi
3266
3267   test -n "$ac_ct_CC" && break
3268 done
3269
3270   CC=$ac_ct_CC
3271 fi
3272
3273 fi
3274
3275
3276 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3277 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3278 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3279 See \`config.log' for more details." >&5
3280 echo "$as_me: error: no acceptable C compiler found in \$PATH
3281 See \`config.log' for more details." >&2;}
3282    { (exit 1); exit 1; }; }; }
3283
3284 # Provide some information about the compiler.
3285 echo "$as_me:$LINENO:" \
3286      "checking for C compiler version" >&5
3287 ac_compiler=`set X $ac_compile; echo $2`
3288 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3289   (eval $ac_compiler --version </dev/null >&5) 2>&5
3290   ac_status=$?
3291   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3292   (exit $ac_status); }
3293 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3294   (eval $ac_compiler -v </dev/null >&5) 2>&5
3295   ac_status=$?
3296   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3297   (exit $ac_status); }
3298 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3299   (eval $ac_compiler -V </dev/null >&5) 2>&5
3300   ac_status=$?
3301   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3302   (exit $ac_status); }
3303
3304 cat >conftest.$ac_ext <<_ACEOF
3305 /* confdefs.h.  */
3306 _ACEOF
3307 cat confdefs.h >>conftest.$ac_ext
3308 cat >>conftest.$ac_ext <<_ACEOF
3309 /* end confdefs.h.  */
3310
3311 int
3312 main ()
3313 {
3314
3315   ;
3316   return 0;
3317 }
3318 _ACEOF
3319 ac_clean_files_save=$ac_clean_files
3320 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3321 # Try to create an executable without -o first, disregard a.out.
3322 # It will help us diagnose broken compilers, and finding out an intuition
3323 # of exeext.
3324 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3325 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3326 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3327 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3328   (eval $ac_link_default) 2>&5
3329   ac_status=$?
3330   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3331   (exit $ac_status); }; then
3332   # Find the output, starting from the most likely.  This scheme is
3333 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3334 # resort.
3335
3336 # Be careful to initialize this variable, since it used to be cached.
3337 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3338 ac_cv_exeext=
3339 # b.out is created by i960 compilers.
3340 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3341 do
3342   test -f "$ac_file" || continue
3343   case $ac_file in
3344     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3345         ;;
3346     conftest.$ac_ext )
3347         # This is the source file.
3348         ;;
3349     [ab].out )
3350         # We found the default executable, but exeext='' is most
3351         # certainly right.
3352         break;;
3353     *.* )
3354         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3355         # FIXME: I believe we export ac_cv_exeext for Libtool,
3356         # but it would be cool to find out if it's true.  Does anybody
3357         # maintain Libtool? --akim.
3358         export ac_cv_exeext
3359         break;;
3360     * )
3361         break;;
3362   esac
3363 done
3364 else
3365   echo "$as_me: failed program was:" >&5
3366 sed 's/^/| /' conftest.$ac_ext >&5
3367
3368 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3369 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3370 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3371 See \`config.log' for more details." >&5
3372 echo "$as_me: error: C compiler cannot create executables
3373 See \`config.log' for more details." >&2;}
3374    { (exit 77); exit 77; }; }; }
3375 fi
3376
3377 ac_exeext=$ac_cv_exeext
3378 echo "$as_me:$LINENO: result: $ac_file" >&5
3379 echo "${ECHO_T}$ac_file" >&6
3380
3381 # Check the compiler produces executables we can run.  If not, either
3382 # the compiler is broken, or we cross compile.
3383 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3384 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3385 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3386 # If not cross compiling, check that we can run a simple program.
3387 if test "$cross_compiling" != yes; then
3388   if { ac_try='./$ac_file'
3389   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3390   (eval $ac_try) 2>&5
3391   ac_status=$?
3392   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3393   (exit $ac_status); }; }; then
3394     cross_compiling=no
3395   else
3396     if test "$cross_compiling" = maybe; then
3397         cross_compiling=yes
3398     else
3399         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3400 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3401 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3402 If you meant to cross compile, use \`--host'.
3403 See \`config.log' for more details." >&5
3404 echo "$as_me: error: cannot run C compiled programs.
3405 If you meant to cross compile, use \`--host'.
3406 See \`config.log' for more details." >&2;}
3407    { (exit 1); exit 1; }; }; }
3408     fi
3409   fi
3410 fi
3411 echo "$as_me:$LINENO: result: yes" >&5
3412 echo "${ECHO_T}yes" >&6
3413
3414 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3415 ac_clean_files=$ac_clean_files_save
3416 # Check the compiler produces executables we can run.  If not, either
3417 # the compiler is broken, or we cross compile.
3418 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3419 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3420 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3421 echo "${ECHO_T}$cross_compiling" >&6
3422
3423 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3424 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3425 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3426   (eval $ac_link) 2>&5
3427   ac_status=$?
3428   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3429   (exit $ac_status); }; then
3430   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3431 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3432 # work properly (i.e., refer to `conftest.exe'), while it won't with
3433 # `rm'.
3434 for ac_file in conftest.exe conftest conftest.*; do
3435   test -f "$ac_file" || continue
3436   case $ac_file in
3437     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3438     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3439           export ac_cv_exeext
3440           break;;
3441     * ) break;;
3442   esac
3443 done
3444 else
3445   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3446 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3447 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3448 See \`config.log' for more details." >&5
3449 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3450 See \`config.log' for more details." >&2;}
3451    { (exit 1); exit 1; }; }; }
3452 fi
3453
3454 rm -f conftest$ac_cv_exeext
3455 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3456 echo "${ECHO_T}$ac_cv_exeext" >&6
3457
3458 rm -f conftest.$ac_ext
3459 EXEEXT=$ac_cv_exeext
3460 ac_exeext=$EXEEXT
3461 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3462 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3463 if test "${ac_cv_objext+set}" = set; then
3464   echo $ECHO_N "(cached) $ECHO_C" >&6
3465 else
3466   cat >conftest.$ac_ext <<_ACEOF
3467 /* confdefs.h.  */
3468 _ACEOF
3469 cat confdefs.h >>conftest.$ac_ext
3470 cat >>conftest.$ac_ext <<_ACEOF
3471 /* end confdefs.h.  */
3472
3473 int
3474 main ()
3475 {
3476
3477   ;
3478   return 0;
3479 }
3480 _ACEOF
3481 rm -f conftest.o conftest.obj
3482 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3483   (eval $ac_compile) 2>&5
3484   ac_status=$?
3485   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3486   (exit $ac_status); }; then
3487   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3488   case $ac_file in
3489     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3490     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3491        break;;
3492   esac
3493 done
3494 else
3495   echo "$as_me: failed program was:" >&5
3496 sed 's/^/| /' conftest.$ac_ext >&5
3497
3498 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3499 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3500 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3501 See \`config.log' for more details." >&5
3502 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3503 See \`config.log' for more details." >&2;}
3504    { (exit 1); exit 1; }; }; }
3505 fi
3506
3507 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3508 fi
3509 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3510 echo "${ECHO_T}$ac_cv_objext" >&6
3511 OBJEXT=$ac_cv_objext
3512 ac_objext=$OBJEXT
3513 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3514 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3515 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3516   echo $ECHO_N "(cached) $ECHO_C" >&6
3517 else
3518   cat >conftest.$ac_ext <<_ACEOF
3519 /* confdefs.h.  */
3520 _ACEOF
3521 cat confdefs.h >>conftest.$ac_ext
3522 cat >>conftest.$ac_ext <<_ACEOF
3523 /* end confdefs.h.  */
3524
3525 int
3526 main ()
3527 {
3528 #ifndef __GNUC__
3529        choke me
3530 #endif
3531
3532   ;
3533   return 0;
3534 }
3535 _ACEOF
3536 rm -f conftest.$ac_objext
3537 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3538   (eval $ac_compile) 2>conftest.er1
3539   ac_status=$?
3540   grep -v '^ *+' conftest.er1 >conftest.err
3541   rm -f conftest.er1
3542   cat conftest.err >&5
3543   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3544   (exit $ac_status); } &&
3545          { ac_try='test -z "$ac_c_werror_flag"
3546                          || test ! -s conftest.err'
3547   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3548   (eval $ac_try) 2>&5
3549   ac_status=$?
3550   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3551   (exit $ac_status); }; } &&
3552          { ac_try='test -s conftest.$ac_objext'
3553   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3554   (eval $ac_try) 2>&5
3555   ac_status=$?
3556   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3557   (exit $ac_status); }; }; then
3558   ac_compiler_gnu=yes
3559 else
3560   echo "$as_me: failed program was:" >&5
3561 sed 's/^/| /' conftest.$ac_ext >&5
3562
3563 ac_compiler_gnu=no
3564 fi
3565 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3566 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3567
3568 fi
3569 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3570 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3571 GCC=`test $ac_compiler_gnu = yes && echo yes`
3572 ac_test_CFLAGS=${CFLAGS+set}
3573 ac_save_CFLAGS=$CFLAGS
3574 CFLAGS="-g"
3575 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3576 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3577 if test "${ac_cv_prog_cc_g+set}" = set; then
3578   echo $ECHO_N "(cached) $ECHO_C" >&6
3579 else
3580   cat >conftest.$ac_ext <<_ACEOF
3581 /* confdefs.h.  */
3582 _ACEOF
3583 cat confdefs.h >>conftest.$ac_ext
3584 cat >>conftest.$ac_ext <<_ACEOF
3585 /* end confdefs.h.  */
3586
3587 int
3588 main ()
3589 {
3590
3591   ;
3592   return 0;
3593 }
3594 _ACEOF
3595 rm -f conftest.$ac_objext
3596 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3597   (eval $ac_compile) 2>conftest.er1
3598   ac_status=$?
3599   grep -v '^ *+' conftest.er1 >conftest.err
3600   rm -f conftest.er1
3601   cat conftest.err >&5
3602   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3603   (exit $ac_status); } &&
3604          { ac_try='test -z "$ac_c_werror_flag"
3605                          || test ! -s conftest.err'
3606   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3607   (eval $ac_try) 2>&5
3608   ac_status=$?
3609   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3610   (exit $ac_status); }; } &&
3611          { ac_try='test -s conftest.$ac_objext'
3612   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3613   (eval $ac_try) 2>&5
3614   ac_status=$?
3615   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3616   (exit $ac_status); }; }; then
3617   ac_cv_prog_cc_g=yes
3618 else
3619   echo "$as_me: failed program was:" >&5
3620 sed 's/^/| /' conftest.$ac_ext >&5
3621
3622 ac_cv_prog_cc_g=no
3623 fi
3624 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3625 fi
3626 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3627 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3628 if test "$ac_test_CFLAGS" = set; then
3629   CFLAGS=$ac_save_CFLAGS
3630 elif test $ac_cv_prog_cc_g = yes; then
3631   if test "$GCC" = yes; then
3632     CFLAGS="-g -O2"
3633   else
3634     CFLAGS="-g"
3635   fi
3636 else
3637   if test "$GCC" = yes; then
3638     CFLAGS="-O2"
3639   else
3640     CFLAGS=
3641   fi
3642 fi
3643 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3644 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3645 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3646   echo $ECHO_N "(cached) $ECHO_C" >&6
3647 else
3648   ac_cv_prog_cc_stdc=no
3649 ac_save_CC=$CC
3650 cat >conftest.$ac_ext <<_ACEOF
3651 /* confdefs.h.  */
3652 _ACEOF
3653 cat confdefs.h >>conftest.$ac_ext
3654 cat >>conftest.$ac_ext <<_ACEOF
3655 /* end confdefs.h.  */
3656 #include <stdarg.h>
3657 #include <stdio.h>
3658 #include <sys/types.h>
3659 #include <sys/stat.h>
3660 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3661 struct buf { int x; };
3662 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3663 static char *e (p, i)
3664      char **p;
3665      int i;
3666 {
3667   return p[i];
3668 }
3669 static char *f (char * (*g) (char **, int), char **p, ...)
3670 {
3671   char *s;
3672   va_list v;
3673   va_start (v,p);
3674   s = g (p, va_arg (v,int));
3675   va_end (v);
3676   return s;
3677 }
3678
3679 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3680    function prototypes and stuff, but not '\xHH' hex character constants.
3681    These don't provoke an error unfortunately, instead are silently treated
3682    as 'x'.  The following induces an error, until -std1 is added to get
3683    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3684    array size at least.  It's necessary to write '\x00'==0 to get something
3685    that's true only with -std1.  */
3686 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3687
3688 int test (int i, double x);
3689 struct s1 {int (*f) (int a);};
3690 struct s2 {int (*f) (double a);};
3691 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3692 int argc;
3693 char **argv;
3694 int
3695 main ()
3696 {
3697 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3698   ;
3699   return 0;
3700 }
3701 _ACEOF
3702 # Don't try gcc -ansi; that turns off useful extensions and
3703 # breaks some systems' header files.
3704 # AIX                   -qlanglvl=ansi
3705 # Ultrix and OSF/1      -std1
3706 # HP-UX 10.20 and later -Ae
3707 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3708 # SVR4                  -Xc -D__EXTENSIONS__
3709 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3710 do
3711   CC="$ac_save_CC $ac_arg"
3712   rm -f conftest.$ac_objext
3713 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3714   (eval $ac_compile) 2>conftest.er1
3715   ac_status=$?
3716   grep -v '^ *+' conftest.er1 >conftest.err
3717   rm -f conftest.er1
3718   cat conftest.err >&5
3719   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3720   (exit $ac_status); } &&
3721          { ac_try='test -z "$ac_c_werror_flag"
3722                          || test ! -s conftest.err'
3723   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3724   (eval $ac_try) 2>&5
3725   ac_status=$?
3726   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3727   (exit $ac_status); }; } &&
3728          { ac_try='test -s conftest.$ac_objext'
3729   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3730   (eval $ac_try) 2>&5
3731   ac_status=$?
3732   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3733   (exit $ac_status); }; }; then
3734   ac_cv_prog_cc_stdc=$ac_arg
3735 break
3736 else
3737   echo "$as_me: failed program was:" >&5
3738 sed 's/^/| /' conftest.$ac_ext >&5
3739
3740 fi
3741 rm -f conftest.err conftest.$ac_objext
3742 done
3743 rm -f conftest.$ac_ext conftest.$ac_objext
3744 CC=$ac_save_CC
3745
3746 fi
3747
3748 case "x$ac_cv_prog_cc_stdc" in
3749   x|xno)
3750     echo "$as_me:$LINENO: result: none needed" >&5
3751 echo "${ECHO_T}none needed" >&6 ;;
3752   *)
3753     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3754 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3755     CC="$CC $ac_cv_prog_cc_stdc" ;;
3756 esac
3757
3758 # Some people use a C++ compiler to compile C.  Since we use `exit',
3759 # in C++ we need to declare it.  In case someone uses the same compiler
3760 # for both compiling C and C++ we need to have the C++ compiler decide
3761 # the declaration of exit, since it's the most demanding environment.
3762 cat >conftest.$ac_ext <<_ACEOF
3763 #ifndef __cplusplus
3764   choke me
3765 #endif
3766 _ACEOF
3767 rm -f conftest.$ac_objext
3768 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3769   (eval $ac_compile) 2>conftest.er1
3770   ac_status=$?
3771   grep -v '^ *+' conftest.er1 >conftest.err
3772   rm -f conftest.er1
3773   cat conftest.err >&5
3774   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3775   (exit $ac_status); } &&
3776          { ac_try='test -z "$ac_c_werror_flag"
3777                          || test ! -s conftest.err'
3778   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3779   (eval $ac_try) 2>&5
3780   ac_status=$?
3781   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3782   (exit $ac_status); }; } &&
3783          { ac_try='test -s conftest.$ac_objext'
3784   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3785   (eval $ac_try) 2>&5
3786   ac_status=$?
3787   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3788   (exit $ac_status); }; }; then
3789   for ac_declaration in \
3790    '' \
3791    'extern "C" void std::exit (int) throw (); using std::exit;' \
3792    'extern "C" void std::exit (int); using std::exit;' \
3793    'extern "C" void exit (int) throw ();' \
3794    'extern "C" void exit (int);' \
3795    'void exit (int);'
3796 do
3797   cat >conftest.$ac_ext <<_ACEOF
3798 /* confdefs.h.  */
3799 _ACEOF
3800 cat confdefs.h >>conftest.$ac_ext
3801 cat >>conftest.$ac_ext <<_ACEOF
3802 /* end confdefs.h.  */
3803 $ac_declaration
3804 #include <stdlib.h>
3805 int
3806 main ()
3807 {
3808 exit (42);
3809   ;
3810   return 0;
3811 }
3812 _ACEOF
3813 rm -f conftest.$ac_objext
3814 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3815   (eval $ac_compile) 2>conftest.er1
3816   ac_status=$?
3817   grep -v '^ *+' conftest.er1 >conftest.err
3818   rm -f conftest.er1
3819   cat conftest.err >&5
3820   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3821   (exit $ac_status); } &&
3822          { ac_try='test -z "$ac_c_werror_flag"
3823                          || test ! -s conftest.err'
3824   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3825   (eval $ac_try) 2>&5
3826   ac_status=$?
3827   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3828   (exit $ac_status); }; } &&
3829          { ac_try='test -s conftest.$ac_objext'
3830   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3831   (eval $ac_try) 2>&5
3832   ac_status=$?
3833   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3834   (exit $ac_status); }; }; then
3835   :
3836 else
3837   echo "$as_me: failed program was:" >&5
3838 sed 's/^/| /' conftest.$ac_ext >&5
3839
3840 continue
3841 fi
3842 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3843   cat >conftest.$ac_ext <<_ACEOF
3844 /* confdefs.h.  */
3845 _ACEOF
3846 cat confdefs.h >>conftest.$ac_ext
3847 cat >>conftest.$ac_ext <<_ACEOF
3848 /* end confdefs.h.  */
3849 $ac_declaration
3850 int
3851 main ()
3852 {
3853 exit (42);
3854   ;
3855   return 0;
3856 }
3857 _ACEOF
3858 rm -f conftest.$ac_objext
3859 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3860   (eval $ac_compile) 2>conftest.er1
3861   ac_status=$?
3862   grep -v '^ *+' conftest.er1 >conftest.err
3863   rm -f conftest.er1
3864   cat conftest.err >&5
3865   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3866   (exit $ac_status); } &&
3867          { ac_try='test -z "$ac_c_werror_flag"
3868                          || test ! -s conftest.err'
3869   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3870   (eval $ac_try) 2>&5
3871   ac_status=$?
3872   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3873   (exit $ac_status); }; } &&
3874          { ac_try='test -s conftest.$ac_objext'
3875   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3876   (eval $ac_try) 2>&5
3877   ac_status=$?
3878   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3879   (exit $ac_status); }; }; then
3880   break
3881 else
3882   echo "$as_me: failed program was:" >&5
3883 sed 's/^/| /' conftest.$ac_ext >&5
3884
3885 fi
3886 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3887 done
3888 rm -f conftest*
3889 if test -n "$ac_declaration"; then
3890   echo '#ifdef __cplusplus' >>confdefs.h
3891   echo $ac_declaration      >>confdefs.h
3892   echo '#endif'             >>confdefs.h
3893 fi
3894
3895 else
3896   echo "$as_me: failed program was:" >&5
3897 sed 's/^/| /' conftest.$ac_ext >&5
3898
3899 fi
3900 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3901 ac_ext=c
3902 ac_cpp='$CPP $CPPFLAGS'
3903 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3904 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3905 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3906
3907 ac_ext=cc
3908 ac_cpp='$CXXCPP $CPPFLAGS'
3909 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3910 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3911 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3912 if test -n "$ac_tool_prefix"; then
3913   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3914   do
3915     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3916 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3917 echo "$as_me:$LINENO: checking for $ac_word" >&5
3918 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3919 if test "${ac_cv_prog_CXX+set}" = set; then
3920   echo $ECHO_N "(cached) $ECHO_C" >&6
3921 else
3922   if test -n "$CXX"; then
3923   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3924 else
3925 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3926 for as_dir in $PATH
3927 do
3928   IFS=$as_save_IFS
3929   test -z "$as_dir" && as_dir=.
3930   for ac_exec_ext in '' $ac_executable_extensions; do
3931   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3932     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3933     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3934     break 2
3935   fi
3936 done
3937 done
3938
3939 fi
3940 fi
3941 CXX=$ac_cv_prog_CXX
3942 if test -n "$CXX"; then
3943   echo "$as_me:$LINENO: result: $CXX" >&5
3944 echo "${ECHO_T}$CXX" >&6
3945 else
3946   echo "$as_me:$LINENO: result: no" >&5
3947 echo "${ECHO_T}no" >&6
3948 fi
3949
3950     test -n "$CXX" && break
3951   done
3952 fi
3953 if test -z "$CXX"; then
3954   ac_ct_CXX=$CXX
3955   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3956 do
3957   # Extract the first word of "$ac_prog", so it can be a program name with args.
3958 set dummy $ac_prog; ac_word=$2
3959 echo "$as_me:$LINENO: checking for $ac_word" >&5
3960 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3961 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3962   echo $ECHO_N "(cached) $ECHO_C" >&6
3963 else
3964   if test -n "$ac_ct_CXX"; then
3965   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3966 else
3967 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3968 for as_dir in $PATH
3969 do
3970   IFS=$as_save_IFS
3971   test -z "$as_dir" && as_dir=.
3972   for ac_exec_ext in '' $ac_executable_extensions; do
3973   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3974     ac_cv_prog_ac_ct_CXX="$ac_prog"
3975     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3976     break 2
3977   fi
3978 done
3979 done
3980
3981 fi
3982 fi
3983 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3984 if test -n "$ac_ct_CXX"; then
3985   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3986 echo "${ECHO_T}$ac_ct_CXX" >&6
3987 else
3988   echo "$as_me:$LINENO: result: no" >&5
3989 echo "${ECHO_T}no" >&6
3990 fi
3991
3992   test -n "$ac_ct_CXX" && break
3993 done
3994 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3995
3996   CXX=$ac_ct_CXX
3997 fi
3998
3999
4000 # Provide some information about the compiler.
4001 echo "$as_me:$LINENO:" \
4002      "checking for C++ compiler version" >&5
4003 ac_compiler=`set X $ac_compile; echo $2`
4004 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
4005   (eval $ac_compiler --version </dev/null >&5) 2>&5
4006   ac_status=$?
4007   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4008   (exit $ac_status); }
4009 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
4010   (eval $ac_compiler -v </dev/null >&5) 2>&5
4011   ac_status=$?
4012   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4013   (exit $ac_status); }
4014 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4015   (eval $ac_compiler -V </dev/null >&5) 2>&5
4016   ac_status=$?
4017   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4018   (exit $ac_status); }
4019
4020 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4021 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4022 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4023   echo $ECHO_N "(cached) $ECHO_C" >&6
4024 else
4025   cat >conftest.$ac_ext <<_ACEOF
4026 /* confdefs.h.  */
4027 _ACEOF
4028 cat confdefs.h >>conftest.$ac_ext
4029 cat >>conftest.$ac_ext <<_ACEOF
4030 /* end confdefs.h.  */
4031
4032 int
4033 main ()
4034 {
4035 #ifndef __GNUC__
4036        choke me
4037 #endif
4038
4039   ;
4040   return 0;
4041 }
4042 _ACEOF
4043 rm -f conftest.$ac_objext
4044 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4045   (eval $ac_compile) 2>conftest.er1
4046   ac_status=$?
4047   grep -v '^ *+' conftest.er1 >conftest.err
4048   rm -f conftest.er1
4049   cat conftest.err >&5
4050   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4051   (exit $ac_status); } &&
4052          { ac_try='test -z "$ac_cxx_werror_flag"
4053                          || test ! -s conftest.err'
4054   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4055   (eval $ac_try) 2>&5
4056   ac_status=$?
4057   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4058   (exit $ac_status); }; } &&
4059          { ac_try='test -s conftest.$ac_objext'
4060   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4061   (eval $ac_try) 2>&5
4062   ac_status=$?
4063   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4064   (exit $ac_status); }; }; then
4065   ac_compiler_gnu=yes
4066 else
4067   echo "$as_me: failed program was:" >&5
4068 sed 's/^/| /' conftest.$ac_ext >&5
4069
4070 ac_compiler_gnu=no
4071 fi
4072 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4073 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4074
4075 fi
4076 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4077 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4078 GXX=`test $ac_compiler_gnu = yes && echo yes`
4079 ac_test_CXXFLAGS=${CXXFLAGS+set}
4080 ac_save_CXXFLAGS=$CXXFLAGS
4081 CXXFLAGS="-g"
4082 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4083 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4084 if test "${ac_cv_prog_cxx_g+set}" = set; then
4085   echo $ECHO_N "(cached) $ECHO_C" >&6
4086 else
4087   cat >conftest.$ac_ext <<_ACEOF
4088 /* confdefs.h.  */
4089 _ACEOF
4090 cat confdefs.h >>conftest.$ac_ext
4091 cat >>conftest.$ac_ext <<_ACEOF
4092 /* end confdefs.h.  */
4093
4094 int
4095 main ()
4096 {
4097
4098   ;
4099   return 0;
4100 }
4101 _ACEOF
4102 rm -f conftest.$ac_objext
4103 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4104   (eval $ac_compile) 2>conftest.er1
4105   ac_status=$?
4106   grep -v '^ *+' conftest.er1 >conftest.err
4107   rm -f conftest.er1
4108   cat conftest.err >&5
4109   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4110   (exit $ac_status); } &&
4111          { ac_try='test -z "$ac_cxx_werror_flag"
4112                          || test ! -s conftest.err'
4113   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4114   (eval $ac_try) 2>&5
4115   ac_status=$?
4116   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4117   (exit $ac_status); }; } &&
4118          { ac_try='test -s conftest.$ac_objext'
4119   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4120   (eval $ac_try) 2>&5
4121   ac_status=$?
4122   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4123   (exit $ac_status); }; }; then
4124   ac_cv_prog_cxx_g=yes
4125 else
4126   echo "$as_me: failed program was:" >&5
4127 sed 's/^/| /' conftest.$ac_ext >&5
4128
4129 ac_cv_prog_cxx_g=no
4130 fi
4131 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4132 fi
4133 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4134 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4135 if test "$ac_test_CXXFLAGS" = set; then
4136   CXXFLAGS=$ac_save_CXXFLAGS
4137 elif test $ac_cv_prog_cxx_g = yes; then
4138   if test "$GXX" = yes; then
4139     CXXFLAGS="-g -O2"
4140   else
4141     CXXFLAGS="-g"
4142   fi
4143 else
4144   if test "$GXX" = yes; then
4145     CXXFLAGS="-O2"
4146   else
4147     CXXFLAGS=
4148   fi
4149 fi
4150 for ac_declaration in \
4151    '' \
4152    'extern "C" void std::exit (int) throw (); using std::exit;' \
4153    'extern "C" void std::exit (int); using std::exit;' \
4154    'extern "C" void exit (int) throw ();' \
4155    'extern "C" void exit (int);' \
4156    'void exit (int);'
4157 do
4158   cat >conftest.$ac_ext <<_ACEOF
4159 /* confdefs.h.  */
4160 _ACEOF
4161 cat confdefs.h >>conftest.$ac_ext
4162 cat >>conftest.$ac_ext <<_ACEOF
4163 /* end confdefs.h.  */
4164 $ac_declaration
4165 #include <stdlib.h>
4166 int
4167 main ()
4168 {
4169 exit (42);
4170   ;
4171   return 0;
4172 }
4173 _ACEOF
4174 rm -f conftest.$ac_objext
4175 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4176   (eval $ac_compile) 2>conftest.er1
4177   ac_status=$?
4178   grep -v '^ *+' conftest.er1 >conftest.err
4179   rm -f conftest.er1
4180   cat conftest.err >&5
4181   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4182   (exit $ac_status); } &&
4183          { ac_try='test -z "$ac_cxx_werror_flag"
4184                          || test ! -s conftest.err'
4185   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4186   (eval $ac_try) 2>&5
4187   ac_status=$?
4188   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4189   (exit $ac_status); }; } &&
4190          { ac_try='test -s conftest.$ac_objext'
4191   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4192   (eval $ac_try) 2>&5
4193   ac_status=$?
4194   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4195   (exit $ac_status); }; }; then
4196   :
4197 else
4198   echo "$as_me: failed program was:" >&5
4199 sed 's/^/| /' conftest.$ac_ext >&5
4200
4201 continue
4202 fi
4203 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4204   cat >conftest.$ac_ext <<_ACEOF
4205 /* confdefs.h.  */
4206 _ACEOF
4207 cat confdefs.h >>conftest.$ac_ext
4208 cat >>conftest.$ac_ext <<_ACEOF
4209 /* end confdefs.h.  */
4210 $ac_declaration
4211 int
4212 main ()
4213 {
4214 exit (42);
4215   ;
4216   return 0;
4217 }
4218 _ACEOF
4219 rm -f conftest.$ac_objext
4220 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4221   (eval $ac_compile) 2>conftest.er1
4222   ac_status=$?
4223   grep -v '^ *+' conftest.er1 >conftest.err
4224   rm -f conftest.er1
4225   cat conftest.err >&5
4226   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4227   (exit $ac_status); } &&
4228          { ac_try='test -z "$ac_cxx_werror_flag"
4229                          || test ! -s conftest.err'
4230   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4231   (eval $ac_try) 2>&5
4232   ac_status=$?
4233   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4234   (exit $ac_status); }; } &&
4235          { ac_try='test -s conftest.$ac_objext'
4236   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4237   (eval $ac_try) 2>&5
4238   ac_status=$?
4239   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4240   (exit $ac_status); }; }; then
4241   break
4242 else
4243   echo "$as_me: failed program was:" >&5
4244 sed 's/^/| /' conftest.$ac_ext >&5
4245
4246 fi
4247 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4248 done
4249 rm -f conftest*
4250 if test -n "$ac_declaration"; then
4251   echo '#ifdef __cplusplus' >>confdefs.h
4252   echo $ac_declaration      >>confdefs.h
4253   echo '#endif'             >>confdefs.h
4254 fi
4255
4256 ac_ext=c
4257 ac_cpp='$CPP $CPPFLAGS'
4258 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4259 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4260 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4261
4262
4263 # We must set the default linker to the linker used by gcc for the correct
4264 # operation of libtool.  If LD is not defined and we are using gcc, try to
4265 # set the LD default to the ld used by gcc.
4266 if test -z "$LD"; then
4267   if test "$GCC" = yes; then
4268     case $build in
4269     *-*-mingw*)
4270       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4271     *)
4272       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4273     esac
4274     case $gcc_prog_ld in
4275     # Accept absolute paths.
4276     [\\/]* | [A-Za-z]:[\\/]*)
4277       LD="$gcc_prog_ld" ;;
4278     esac
4279   fi
4280 fi
4281
4282
4283
4284
4285 if test -n "$ac_tool_prefix"; then
4286   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4287 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4288 echo "$as_me:$LINENO: checking for $ac_word" >&5
4289 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4290 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4291   echo $ECHO_N "(cached) $ECHO_C" >&6
4292 else
4293   if test -n "$GNATBIND"; then
4294   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4295 else
4296 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4297 for as_dir in $PATH
4298 do
4299   IFS=$as_save_IFS
4300   test -z "$as_dir" && as_dir=.
4301   for ac_exec_ext in '' $ac_executable_extensions; do
4302   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4303     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4304     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4305     break 2
4306   fi
4307 done
4308 done
4309
4310 fi
4311 fi
4312 GNATBIND=$ac_cv_prog_GNATBIND
4313 if test -n "$GNATBIND"; then
4314   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4315 echo "${ECHO_T}$GNATBIND" >&6
4316 else
4317   echo "$as_me:$LINENO: result: no" >&5
4318 echo "${ECHO_T}no" >&6
4319 fi
4320
4321 fi
4322 if test -z "$ac_cv_prog_GNATBIND"; then
4323   ac_ct_GNATBIND=$GNATBIND
4324   # Extract the first word of "gnatbind", so it can be a program name with args.
4325 set dummy gnatbind; ac_word=$2
4326 echo "$as_me:$LINENO: checking for $ac_word" >&5
4327 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4328 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4329   echo $ECHO_N "(cached) $ECHO_C" >&6
4330 else
4331   if test -n "$ac_ct_GNATBIND"; then
4332   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4333 else
4334 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4335 for as_dir in $PATH
4336 do
4337   IFS=$as_save_IFS
4338   test -z "$as_dir" && as_dir=.
4339   for ac_exec_ext in '' $ac_executable_extensions; do
4340   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4341     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4342     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4343     break 2
4344   fi
4345 done
4346 done
4347
4348   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4349 fi
4350 fi
4351 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4352 if test -n "$ac_ct_GNATBIND"; then
4353   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4354 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4355 else
4356   echo "$as_me:$LINENO: result: no" >&5
4357 echo "${ECHO_T}no" >&6
4358 fi
4359
4360   GNATBIND=$ac_ct_GNATBIND
4361 else
4362   GNATBIND="$ac_cv_prog_GNATBIND"
4363 fi
4364
4365 if test -n "$ac_tool_prefix"; then
4366   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4367 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4368 echo "$as_me:$LINENO: checking for $ac_word" >&5
4369 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4370 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4371   echo $ECHO_N "(cached) $ECHO_C" >&6
4372 else
4373   if test -n "$GNATMAKE"; then
4374   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4375 else
4376 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4377 for as_dir in $PATH
4378 do
4379   IFS=$as_save_IFS
4380   test -z "$as_dir" && as_dir=.
4381   for ac_exec_ext in '' $ac_executable_extensions; do
4382   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4383     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4384     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4385     break 2
4386   fi
4387 done
4388 done
4389
4390 fi
4391 fi
4392 GNATMAKE=$ac_cv_prog_GNATMAKE
4393 if test -n "$GNATMAKE"; then
4394   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4395 echo "${ECHO_T}$GNATMAKE" >&6
4396 else
4397   echo "$as_me:$LINENO: result: no" >&5
4398 echo "${ECHO_T}no" >&6
4399 fi
4400
4401 fi
4402 if test -z "$ac_cv_prog_GNATMAKE"; then
4403   ac_ct_GNATMAKE=$GNATMAKE
4404   # Extract the first word of "gnatmake", so it can be a program name with args.
4405 set dummy gnatmake; ac_word=$2
4406 echo "$as_me:$LINENO: checking for $ac_word" >&5
4407 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4408 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4409   echo $ECHO_N "(cached) $ECHO_C" >&6
4410 else
4411   if test -n "$ac_ct_GNATMAKE"; then
4412   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4413 else
4414 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4415 for as_dir in $PATH
4416 do
4417   IFS=$as_save_IFS
4418   test -z "$as_dir" && as_dir=.
4419   for ac_exec_ext in '' $ac_executable_extensions; do
4420   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4421     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4422     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4423     break 2
4424   fi
4425 done
4426 done
4427
4428   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4429 fi
4430 fi
4431 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4432 if test -n "$ac_ct_GNATMAKE"; then
4433   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4434 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4435 else
4436   echo "$as_me:$LINENO: result: no" >&5
4437 echo "${ECHO_T}no" >&6
4438 fi
4439
4440   GNATMAKE=$ac_ct_GNATMAKE
4441 else
4442   GNATMAKE="$ac_cv_prog_GNATMAKE"
4443 fi
4444
4445 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4446 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4447 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4448   echo $ECHO_N "(cached) $ECHO_C" >&6
4449 else
4450   cat >conftest.adb <<EOF
4451 procedure conftest is begin null; end conftest;
4452 EOF
4453 acx_cv_cc_gcc_supports_ada=no
4454 # There is a bug in old released versions of GCC which causes the
4455 # driver to exit successfully when the appropriate language module
4456 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4457 # Therefore we must check for the error message as well as an
4458 # unsuccessful exit.
4459 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4460 # given a .adb file, but produce no object file.  So we must check
4461 # if an object file was really produced to guard against this.
4462 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4463 if test x"$errors" = x && test -f conftest.$ac_objext; then
4464   acx_cv_cc_gcc_supports_ada=yes
4465 fi
4466 rm -f conftest.*
4467 fi
4468 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4469 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4470
4471 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4472   have_gnat=yes
4473 else
4474   have_gnat=no
4475 fi
4476
4477 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4478 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4479 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4480   echo $ECHO_N "(cached) $ECHO_C" >&6
4481 else
4482    echo abfoo >t1
4483   echo cdfoo >t2
4484   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4485   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4486     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4487       :
4488     else
4489       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4490     fi
4491   fi
4492   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4493     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4494       :
4495     else
4496       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4497     fi
4498   fi
4499   rm t1 t2
4500
4501 fi
4502 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4503 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4504 do_compare="$gcc_cv_prog_cmp_skip"
4505
4506
4507
4508 # Check for GMP and MPFR
4509 gmplibs="-lmpfr -lgmp"
4510 gmpinc=
4511 have_gmp=no
4512
4513 # Specify a location for mpfr
4514 # check for this first so it ends up on the link line before gmp.
4515
4516 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4517 if test "${with_mpfr_dir+set}" = set; then
4518   withval="$with_mpfr_dir"
4519   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4520 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4521 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4522 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4523    { (exit 1); exit 1; }; }
4524 fi;
4525
4526
4527 # Check whether --with-mpfr or --without-mpfr was given.
4528 if test "${with_mpfr+set}" = set; then
4529   withval="$with_mpfr"
4530
4531 fi;
4532
4533 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4534 if test "${with_mpfr_include+set}" = set; then
4535   withval="$with_mpfr_include"
4536
4537 fi;
4538
4539 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4540 if test "${with_mpfr_lib+set}" = set; then
4541   withval="$with_mpfr_lib"
4542
4543 fi;
4544
4545 if test "x$with_mpfr" != x; then
4546   gmplibs="-L$with_mpfr/lib $gmplibs"
4547   gmpinc="-I$with_mpfr/include"
4548 fi
4549 if test "x$with_mpfr_include" != x; then
4550   gmpinc="-I$with_mpfr_include"
4551 fi
4552 if test "x$with_mpfr_lib" != x; then
4553   gmplibs="-L$with_mpfr_lib $gmplibs"
4554 fi
4555 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4556   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4557   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4558   # Do not test the mpfr version.  Assume that it is sufficient, since
4559   # it is in the source tree, and the library has not been built yet
4560   # but it would be included on the link line in the version check below
4561   # hence making the test fail.
4562   have_gmp=yes
4563 fi
4564
4565 # Specify a location for gmp
4566
4567 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4568 if test "${with_gmp_dir+set}" = set; then
4569   withval="$with_gmp_dir"
4570   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4571 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4572 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4573 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4574    { (exit 1); exit 1; }; }
4575 fi;
4576
4577
4578 # Check whether --with-gmp or --without-gmp was given.
4579 if test "${with_gmp+set}" = set; then
4580   withval="$with_gmp"
4581
4582 fi;
4583
4584 # Check whether --with-gmp_include or --without-gmp_include was given.
4585 if test "${with_gmp_include+set}" = set; then
4586   withval="$with_gmp_include"
4587
4588 fi;
4589
4590 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4591 if test "${with_gmp_lib+set}" = set; then
4592   withval="$with_gmp_lib"
4593
4594 fi;
4595
4596
4597 if test "x$with_gmp" != x; then
4598   gmplibs="-L$with_gmp/lib $gmplibs"
4599   gmpinc="-I$with_gmp/include $gmpinc"
4600 fi
4601 if test "x$with_gmp_include" != x; then
4602   gmpinc="-I$with_gmp_include $gmpinc"
4603 fi
4604 if test "x$with_gmp_lib" != x; then
4605   gmplibs="-L$with_gmp_lib $gmplibs"
4606 fi
4607 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4608   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4609   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4610   # Do not test the gmp version.  Assume that it is sufficient, since
4611   # it is in the source tree, and the library has not been built yet
4612   # but it would be included on the link line in the version check below
4613   # hence making the test fail.
4614   have_gmp=yes
4615 fi
4616
4617 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4618   have_gmp=yes
4619   saved_CFLAGS="$CFLAGS"
4620   CFLAGS="$CFLAGS $gmpinc"
4621   # Check GMP actually works
4622   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4623 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4624
4625 cat >conftest.$ac_ext <<_ACEOF
4626 /* confdefs.h.  */
4627 _ACEOF
4628 cat confdefs.h >>conftest.$ac_ext
4629 cat >>conftest.$ac_ext <<_ACEOF
4630 /* end confdefs.h.  */
4631 #include "gmp.h"
4632 int
4633 main ()
4634 {
4635
4636   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 2)
4637   choke me
4638   #endif
4639
4640   ;
4641   return 0;
4642 }
4643 _ACEOF
4644 rm -f conftest.$ac_objext
4645 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4646   (eval $ac_compile) 2>conftest.er1
4647   ac_status=$?
4648   grep -v '^ *+' conftest.er1 >conftest.err
4649   rm -f conftest.er1
4650   cat conftest.err >&5
4651   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4652   (exit $ac_status); } &&
4653          { ac_try='test -z "$ac_c_werror_flag"
4654                          || test ! -s conftest.err'
4655   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4656   (eval $ac_try) 2>&5
4657   ac_status=$?
4658   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4659   (exit $ac_status); }; } &&
4660          { ac_try='test -s conftest.$ac_objext'
4661   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4662   (eval $ac_try) 2>&5
4663   ac_status=$?
4664   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4665   (exit $ac_status); }; }; then
4666   echo "$as_me:$LINENO: result: yes" >&5
4667 echo "${ECHO_T}yes" >&6
4668 else
4669   echo "$as_me: failed program was:" >&5
4670 sed 's/^/| /' conftest.$ac_ext >&5
4671
4672 echo "$as_me:$LINENO: result: no" >&5
4673 echo "${ECHO_T}no" >&6; have_gmp=no
4674 fi
4675 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4676
4677   if test x"$have_gmp" = xyes; then
4678     saved_LIBS="$LIBS"
4679     LIBS="$LIBS $gmplibs"
4680         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4681 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4682     cat >conftest.$ac_ext <<_ACEOF
4683 /* confdefs.h.  */
4684 _ACEOF
4685 cat confdefs.h >>conftest.$ac_ext
4686 cat >>conftest.$ac_ext <<_ACEOF
4687 /* end confdefs.h.  */
4688 #include <gmp.h>
4689     #include <mpfr.h>
4690 int
4691 main ()
4692 {
4693
4694     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,1)
4695     choke me
4696     #endif
4697     mpfr_t n;
4698     mpfr_t x;
4699     int t;
4700     mpfr_init (n);
4701     mpfr_init (x);
4702     mpfr_atan2 (n, n, x, GMP_RNDN);
4703     mpfr_erfc (n, x, GMP_RNDN);
4704     mpfr_subnormalize (x, t, GMP_RNDN);
4705
4706   ;
4707   return 0;
4708 }
4709 _ACEOF
4710 rm -f conftest.$ac_objext conftest$ac_exeext
4711 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4712   (eval $ac_link) 2>conftest.er1
4713   ac_status=$?
4714   grep -v '^ *+' conftest.er1 >conftest.err
4715   rm -f conftest.er1
4716   cat conftest.err >&5
4717   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4718   (exit $ac_status); } &&
4719          { ac_try='test -z "$ac_c_werror_flag"
4720                          || test ! -s conftest.err'
4721   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4722   (eval $ac_try) 2>&5
4723   ac_status=$?
4724   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4725   (exit $ac_status); }; } &&
4726          { ac_try='test -s conftest$ac_exeext'
4727   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4728   (eval $ac_try) 2>&5
4729   ac_status=$?
4730   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4731   (exit $ac_status); }; }; then
4732   cat >conftest.$ac_ext <<_ACEOF
4733 /* confdefs.h.  */
4734 _ACEOF
4735 cat confdefs.h >>conftest.$ac_ext
4736 cat >>conftest.$ac_ext <<_ACEOF
4737 /* end confdefs.h.  */
4738 #include <gmp.h>
4739     #include <mpfr.h>
4740 int
4741 main ()
4742 {
4743
4744     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4745     choke me
4746     #endif
4747     mpfr_t n; mpfr_init(n);
4748
4749   ;
4750   return 0;
4751 }
4752 _ACEOF
4753 rm -f conftest.$ac_objext conftest$ac_exeext
4754 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4755   (eval $ac_link) 2>conftest.er1
4756   ac_status=$?
4757   grep -v '^ *+' conftest.er1 >conftest.err
4758   rm -f conftest.er1
4759   cat conftest.err >&5
4760   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4761   (exit $ac_status); } &&
4762          { ac_try='test -z "$ac_c_werror_flag"
4763                          || test ! -s conftest.err'
4764   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4765   (eval $ac_try) 2>&5
4766   ac_status=$?
4767   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4768   (exit $ac_status); }; } &&
4769          { ac_try='test -s conftest$ac_exeext'
4770   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4771   (eval $ac_try) 2>&5
4772   ac_status=$?
4773   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4774   (exit $ac_status); }; }; then
4775   echo "$as_me:$LINENO: result: yes" >&5
4776 echo "${ECHO_T}yes" >&6
4777 else
4778   echo "$as_me: failed program was:" >&5
4779 sed 's/^/| /' conftest.$ac_ext >&5
4780
4781 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4782 echo "${ECHO_T}buggy but acceptable" >&6
4783 fi
4784 rm -f conftest.err conftest.$ac_objext \
4785       conftest$ac_exeext conftest.$ac_ext
4786 else
4787   echo "$as_me: failed program was:" >&5
4788 sed 's/^/| /' conftest.$ac_ext >&5
4789
4790 echo "$as_me:$LINENO: result: no" >&5
4791 echo "${ECHO_T}no" >&6; have_gmp=no
4792 fi
4793 rm -f conftest.err conftest.$ac_objext \
4794       conftest$ac_exeext conftest.$ac_ext
4795       LIBS="$saved_LIBS"
4796   fi
4797   CFLAGS="$saved_CFLAGS"
4798
4799   if test x$have_gmp != xyes; then
4800     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
4801 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4802 Copies of these libraries' source code can be found at their respective
4803 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4804 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4805 If you obtained GMP and/or MPFR from a vendor distribution package, make
4806 sure that you have installed both the libraries and the header files.
4807 They may be located in separate packages." >&5
4808 echo "$as_me: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
4809 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4810 Copies of these libraries' source code can be found at their respective
4811 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4812 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4813 If you obtained GMP and/or MPFR from a vendor distribution package, make
4814 sure that you have installed both the libraries and the header files.
4815 They may be located in separate packages." >&2;}
4816    { (exit 1); exit 1; }; }
4817   fi
4818 fi
4819
4820 # Flags needed for both GMP and/or MPFR
4821
4822
4823
4824 # Allow host libstdc++ to be specified for static linking with PPL.
4825
4826 # Check whether --with-host-libstdcxx or --without-host-libstdcxx was given.
4827 if test "${with_host_libstdcxx+set}" = set; then
4828   withval="$with_host_libstdcxx"
4829
4830 fi;
4831
4832 case $with_host_libstdcxx in
4833   no|yes)
4834     { { echo "$as_me:$LINENO: error: -with-host-libstdcxx needs an argument" >&5
4835 echo "$as_me: error: -with-host-libstdcxx needs an argument" >&2;}
4836    { (exit 1); exit 1; }; }
4837     ;;
4838 esac
4839
4840 # Check for PPL
4841 ppl_major_version=0
4842 ppl_minor_version=10
4843 ppllibs=" -lppl_c -lppl -lgmpxx $with_host_libstdcxx "
4844 pplinc=
4845
4846
4847 # Check whether --with-ppl or --without-ppl was given.
4848 if test "${with_ppl+set}" = set; then
4849   withval="$with_ppl"
4850
4851 fi;
4852
4853 # Check whether --with-ppl_include or --without-ppl_include was given.
4854 if test "${with_ppl_include+set}" = set; then
4855   withval="$with_ppl_include"
4856
4857 fi;
4858
4859 # Check whether --with-ppl_lib or --without-ppl_lib was given.
4860 if test "${with_ppl_lib+set}" = set; then
4861   withval="$with_ppl_lib"
4862
4863 fi;
4864
4865 case $with_ppl in
4866   no)
4867     ppllibs=
4868     ;;
4869   *)
4870     ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx $with_host_libstdcxx"
4871     pplinc="-I$with_ppl/include $pplinc"
4872     LIBS="$ppllibs $LIBS"
4873     ;;
4874 esac
4875 if test "x$with_ppl_include" != x; then
4876   pplinc="-I$with_ppl_include $pplinc"
4877 fi
4878 if test "x$with_ppl_lib" != x; then
4879   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx $with_host_libstdcxx"
4880   LIBS="$ppllibs $LIBS"
4881 fi
4882 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
4883   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '"$with_host_libstdcxx "
4884   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
4885   LIBS="$ppllibs $LIBS"
4886 fi
4887
4888 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
4889 if test "${enable_ppl_version_check+set}" = set; then
4890   enableval="$enable_ppl_version_check"
4891   ENABLE_PPL_CHECK=$enableval
4892 else
4893   ENABLE_PPL_CHECK=yes
4894 fi;
4895
4896 if test "${ENABLE_PPL_CHECK}" = "yes"; then
4897   saved_CFLAGS="$CFLAGS"
4898   CFLAGS="$CFLAGS $pplinc $gmpinc"
4899   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
4900 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
4901   cat >conftest.$ac_ext <<_ACEOF
4902 /* confdefs.h.  */
4903 _ACEOF
4904 cat confdefs.h >>conftest.$ac_ext
4905 cat >>conftest.$ac_ext <<_ACEOF
4906 /* end confdefs.h.  */
4907 #include "ppl_c.h"
4908 int
4909 main ()
4910 {
4911
4912   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
4913   choke me
4914   #endif
4915
4916   ;
4917   return 0;
4918 }
4919 _ACEOF
4920 rm -f conftest.$ac_objext
4921 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4922   (eval $ac_compile) 2>conftest.er1
4923   ac_status=$?
4924   grep -v '^ *+' conftest.er1 >conftest.err
4925   rm -f conftest.er1
4926   cat conftest.err >&5
4927   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4928   (exit $ac_status); } &&
4929          { ac_try='test -z "$ac_c_werror_flag"
4930                          || test ! -s conftest.err'
4931   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4932   (eval $ac_try) 2>&5
4933   ac_status=$?
4934   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4935   (exit $ac_status); }; } &&
4936          { ac_try='test -s conftest.$ac_objext'
4937   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4938   (eval $ac_try) 2>&5
4939   ac_status=$?
4940   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4941   (exit $ac_status); }; }; then
4942   echo "$as_me:$LINENO: result: yes" >&5
4943 echo "${ECHO_T}yes" >&6
4944 else
4945   echo "$as_me: failed program was:" >&5
4946 sed 's/^/| /' conftest.$ac_ext >&5
4947
4948 echo "$as_me:$LINENO: result: no" >&5
4949 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
4950 fi
4951 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4952   CFLAGS="$saved_CFLAGS"
4953 fi
4954
4955 # Flags needed for PPL
4956
4957
4958
4959
4960 # Check for CLOOG
4961 clooglibs=" -lcloog "
4962 clooginc=" -DCLOOG_PPL_BACKEND "
4963
4964
4965 # Check whether --with-cloog or --without-cloog was given.
4966 if test "${with_cloog+set}" = set; then
4967   withval="$with_cloog"
4968
4969 fi;
4970
4971 # Check whether --with-cloog_include or --without-cloog_include was given.
4972 if test "${with_cloog_include+set}" = set; then
4973   withval="$with_cloog_include"
4974
4975 fi;
4976
4977 # Check whether --with-cloog_lib or --without-cloog_lib was given.
4978 if test "${with_cloog_lib+set}" = set; then
4979   withval="$with_cloog_lib"
4980
4981 fi;
4982
4983 case $with_cloog in
4984   no)
4985     clooglibs=
4986     clooginc=
4987     ;;
4988   *)
4989     clooglibs="-L$with_cloog/lib -lcloog"
4990     clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
4991     LIBS="$clooglibs $LIBS"
4992     ;;
4993 esac
4994 if test "x$with_cloog_include" != x; then
4995   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
4996 fi
4997 if test "x$with_cloog_lib" != x; then
4998   clooglibs="-L$with_cloog_lib -lcloog"
4999   LIBS="$clooglibs $LIBS"
5000 fi
5001 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
5002   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
5003   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
5004   LIBS="$clooglibs $LIBS"
5005 fi
5006
5007 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
5008 if test "${enable_cloog_version_check+set}" = set; then
5009   enableval="$enable_cloog_version_check"
5010   ENABLE_CLOOG_CHECK=$enableval
5011 else
5012   ENABLE_CLOOG_CHECK=yes
5013 fi;
5014
5015 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
5016   saved_CFLAGS="$CFLAGS"
5017   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
5018   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
5019 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
5020   cat >conftest.$ac_ext <<_ACEOF
5021 /* confdefs.h.  */
5022 _ACEOF
5023 cat confdefs.h >>conftest.$ac_ext
5024 cat >>conftest.$ac_ext <<_ACEOF
5025 /* end confdefs.h.  */
5026 #include "cloog/cloog.h"
5027 int
5028 main ()
5029 {
5030
5031   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
5032   choke me
5033   #endif
5034
5035   ;
5036   return 0;
5037 }
5038 _ACEOF
5039 rm -f conftest.$ac_objext
5040 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5041   (eval $ac_compile) 2>conftest.er1
5042   ac_status=$?
5043   grep -v '^ *+' conftest.er1 >conftest.err
5044   rm -f conftest.er1
5045   cat conftest.err >&5
5046   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5047   (exit $ac_status); } &&
5048          { ac_try='test -z "$ac_c_werror_flag"
5049                          || test ! -s conftest.err'
5050   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5051   (eval $ac_try) 2>&5
5052   ac_status=$?
5053   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5054   (exit $ac_status); }; } &&
5055          { ac_try='test -s conftest.$ac_objext'
5056   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5057   (eval $ac_try) 2>&5
5058   ac_status=$?
5059   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5060   (exit $ac_status); }; }; then
5061   echo "$as_me:$LINENO: result: yes" >&5
5062 echo "${ECHO_T}yes" >&6
5063 else
5064   echo "$as_me: failed program was:" >&5
5065 sed 's/^/| /' conftest.$ac_ext >&5
5066
5067 echo "$as_me:$LINENO: result: no" >&5
5068 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5069 fi
5070 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5071   CFLAGS="$saved_CFLAGS"
5072 fi
5073
5074 # Flags needed for CLOOG
5075
5076
5077
5078
5079 # By default, C is the only stage 1 language.
5080 stage1_languages=,c,
5081
5082 # Figure out what language subdirectories are present.
5083 # Look if the user specified --enable-languages="..."; if not, use
5084 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5085 # go away some day.
5086 # NB:  embedded tabs in this IF block -- do not untabify
5087 if test -d ${srcdir}/gcc; then
5088   if test x"${enable_languages+set}" != xset; then
5089     if test x"${LANGUAGES+set}" = xset; then
5090       enable_languages="${LANGUAGES}"
5091         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5092     else
5093       enable_languages=all
5094     fi
5095   else
5096     if test x"${enable_languages}" = x ||
5097        test x"${enable_languages}" = xyes;
5098        then
5099       echo configure.in: --enable-languages needs at least one language argument 1>&2
5100       exit 1
5101     fi
5102   fi
5103   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5104
5105   # 'f95' is the old name for the 'fortran' language. We issue a warning
5106   # and make the substitution.
5107   case ,${enable_languages}, in
5108     *,f95,*)
5109       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5110       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5111       ;;
5112   esac
5113
5114   # First scan to see if an enabled language requires some other language.
5115   # We assume that a given config-lang.in will list all the language
5116   # front ends it requires, even if some are required indirectly.
5117   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5118     case ${lang_frag} in
5119       ..) ;;
5120       # The odd quoting in the next line works around
5121       # an apparent bug in bash 1.12 on linux.
5122       ${srcdir}/gcc/[*]/config-lang.in) ;;
5123       *)
5124         # From the config-lang.in, get $language, $lang_requires
5125         language=
5126         lang_requires=
5127         . ${lang_frag}
5128         for other in ${lang_requires} ; do
5129           case ,${enable_languages}, in
5130             *,$other,*) ;;
5131             *,all,*) ;;
5132             *,$language,*)
5133               echo " \`$other' language required by \`$language'; enabling" 1>&2
5134               enable_languages="${enable_languages},${other}"
5135               ;;
5136           esac
5137         done
5138         ;;
5139     esac
5140   done
5141
5142   new_enable_languages=,c,
5143   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5144   potential_languages=,c,
5145
5146   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5147     case ${lang_frag} in
5148       ..) ;;
5149       # The odd quoting in the next line works around
5150       # an apparent bug in bash 1.12 on linux.
5151       ${srcdir}/gcc/[*]/config-lang.in) ;;
5152       *)
5153         # From the config-lang.in, get $language, $target_libs,
5154         # $lang_dirs, $boot_language, and $build_by_default
5155         language=
5156         target_libs=
5157         lang_dirs=
5158         subdir_requires=
5159         boot_language=no
5160         build_by_default=yes
5161         . ${lang_frag}
5162         if test x${language} = x; then
5163           echo "${lang_frag} doesn't set \$language." 1>&2
5164           exit 1
5165         fi
5166
5167         case ,${enable_languages}, in
5168           *,${language},*)
5169             # Language was explicitly selected; include it.
5170             add_this_lang=yes
5171             ;;
5172           *,all,*)
5173             # 'all' was selected, select it if it is a default language
5174             add_this_lang=${build_by_default}
5175             ;;
5176           *)
5177             add_this_lang=no
5178             ;;
5179         esac
5180
5181         # Disable languages that need other directories if these aren't available.
5182         for i in $subdir_requires; do
5183           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5184           case ,${enable_languages}, in
5185             *,${language},*)
5186               # Specifically requested language; tell them.
5187               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5188 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5189    { (exit 1); exit 1; }; }
5190               ;;
5191             *)
5192               # Silently disable.
5193               add_this_lang=unsupported
5194               ;;
5195           esac
5196         done
5197
5198         # Disable Ada if no preexisting GNAT is available.
5199         case ,${enable_languages},:${language}:${have_gnat} in
5200           *,${language},*:ada:no)
5201             # Specifically requested language; tell them.
5202             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5203 echo "$as_me: error: GNAT is required to build $language" >&2;}
5204    { (exit 1); exit 1; }; }
5205             ;;
5206           *:ada:no)
5207             # Silently disable.
5208             add_this_lang=unsupported
5209             ;;
5210         esac
5211
5212         # Disable a language that is unsupported by the target.
5213         case " $unsupported_languages " in
5214           *" $language "*)
5215             add_this_lang=unsupported
5216             ;;
5217         esac
5218
5219         case $add_this_lang in
5220           unsupported)
5221             # Remove language-dependent dirs.
5222             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5223             ;;
5224           no)
5225             # Remove language-dependent dirs; still show language as supported.
5226             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5227             potential_languages="${potential_languages}${language},"
5228             ;;
5229           yes)
5230             new_enable_languages="${new_enable_languages}${language},"
5231             potential_languages="${potential_languages}${language},"
5232             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5233             case ${boot_language} in
5234               yes)
5235                 # Add to (comma-separated) list of stage 1 languages.
5236                 stage1_languages="${stage1_languages}${language},"
5237                 ;;
5238             esac
5239             ;;
5240         esac
5241         ;;
5242     esac
5243   done
5244
5245   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5246 if test "${enable_stage1_languages+set}" = set; then
5247   enableval="$enable_stage1_languages"
5248   case ,${enable_stage1_languages}, in
5249     ,no,|,,)
5250       # Set it to something that will have no effect in the loop below
5251       enable_stage1_languages=c ;;
5252     ,yes,)
5253       enable_stage1_languages=`echo $new_enable_languages | \
5254         sed -e "s/^,//" -e "s/,$//" ` ;;
5255     *,all,*)
5256       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5257         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5258   esac
5259
5260   # Add "good" languages from enable_stage1_languages to stage1_languages,
5261   # while "bad" languages go in missing_languages.  Leave no duplicates.
5262   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5263     case $potential_languages in
5264       *,$i,*)
5265         case $stage1_languages in
5266           *,$i,*) ;;
5267           *) stage1_languages="$stage1_languages$i," ;;
5268         esac ;;
5269       *)
5270         case $missing_languages in
5271           *,$i,*) ;;
5272           *) missing_languages="$missing_languages$i," ;;
5273         esac ;;
5274      esac
5275   done
5276 fi;
5277
5278   # Remove leading/trailing commas that were added for simplicity
5279   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5280   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5281   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5282   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5283
5284   if test "x$missing_languages" != x; then
5285     { { echo "$as_me:$LINENO: error:
5286 The following requested languages could not be built: ${missing_languages}
5287 Supported languages are: ${potential_languages}" >&5
5288 echo "$as_me: error:
5289 The following requested languages could not be built: ${missing_languages}
5290 Supported languages are: ${potential_languages}" >&2;}
5291    { (exit 1); exit 1; }; }
5292   fi
5293   if test "x$new_enable_languages" != "x$enable_languages"; then
5294     echo The following languages will be built: ${new_enable_languages}
5295     enable_languages="$new_enable_languages"
5296   fi
5297
5298
5299   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5300 fi
5301
5302 # Handle --disable-<component> generically.
5303 for dir in $configdirs $build_configdirs $target_configdirs ; do
5304   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5305   varname=`echo $dirname | sed -e s/+/_/g`
5306   if eval test x\${enable_${varname}} "=" xno ; then
5307     noconfigdirs="$noconfigdirs $dir"
5308   fi
5309 done
5310
5311 # Check for Boehm's garbage collector
5312 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5313 if test "${enable_objc_gc+set}" = set; then
5314   enableval="$enable_objc_gc"
5315   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5316   *,objc,*:*:yes:*target-boehm-gc*)
5317     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5318 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5319    { (exit 1); exit 1; }; }
5320     ;;
5321 esac
5322 fi;
5323
5324 # Make sure we only build Boehm's garbage collector if required.
5325 case ,${enable_languages},:${enable_objc_gc} in
5326   *,objc,*:yes)
5327     # Keep target-boehm-gc if requested for Objective-C.
5328     ;;
5329   *)
5330     # Otherwise remove target-boehm-gc depending on target-libjava.
5331     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5332       noconfigdirs="$noconfigdirs target-boehm-gc"
5333     fi
5334     ;;
5335 esac
5336
5337 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5338 # $build_configdirs and $target_configdirs.
5339 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5340
5341 notsupp=""
5342 for dir in . $skipdirs $noconfigdirs ; do
5343   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5344   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5345     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5346     if test -r $srcdir/$dirname/configure ; then
5347       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5348         true
5349       else
5350         notsupp="$notsupp $dir"
5351       fi
5352     fi
5353   fi
5354   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5355     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5356     if test -r $srcdir/$dirname/configure ; then
5357       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5358         true
5359       else
5360         notsupp="$notsupp $dir"
5361       fi
5362     fi
5363   fi
5364   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5365     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5366     if test -r $srcdir/$dirname/configure ; then
5367       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5368         true
5369       else
5370         notsupp="$notsupp $dir"
5371       fi
5372     fi
5373   fi
5374 done
5375
5376 # Sometimes the tools are distributed with libiberty but with no other
5377 # libraries.  In that case, we don't want to build target-libiberty.
5378 # Don't let libgcc imply libiberty either.
5379 if test -n "${target_configdirs}" ; then
5380   libgcc=
5381   others=
5382   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5383     if test "$i" = "libgcc"; then
5384       libgcc=target-libgcc
5385     elif test "$i" != "libiberty" ; then
5386       if test -r $srcdir/$i/configure ; then
5387         others=yes;
5388         break;
5389       fi
5390     fi
5391   done
5392   if test -z "${others}" ; then
5393     target_configdirs=$libgcc
5394   fi
5395 fi
5396
5397 # Quietly strip out all directories which aren't configurable in this tree.
5398 # This relies on all configurable subdirectories being autoconfiscated, which
5399 # is now the case.
5400 build_configdirs_all="$build_configdirs"
5401 build_configdirs=
5402 for i in ${build_configdirs_all} ; do
5403   j=`echo $i | sed -e s/build-//g`
5404   if test -f ${srcdir}/$j/configure ; then
5405     build_configdirs="${build_configdirs} $i"
5406   fi
5407 done
5408
5409 configdirs_all="$configdirs"
5410 configdirs=
5411 for i in ${configdirs_all} ; do
5412   if test -f ${srcdir}/$i/configure ; then
5413     configdirs="${configdirs} $i"
5414   fi
5415 done
5416
5417 target_configdirs_all="$target_configdirs"
5418 target_configdirs=
5419 for i in ${target_configdirs_all} ; do
5420   j=`echo $i | sed -e s/target-//g`
5421   if test -f ${srcdir}/$j/configure ; then
5422     target_configdirs="${target_configdirs} $i"
5423   fi
5424 done
5425
5426 # Produce a warning message for the subdirs we can't configure.
5427 # This isn't especially interesting in the Cygnus tree, but in the individual
5428 # FSF releases, it's important to let people know when their machine isn't
5429 # supported by the one or two programs in a package.
5430
5431 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5432   # If $appdirs is non-empty, at least one of those directories must still
5433   # be configured, or we error out.  (E.g., if the gas release supports a
5434   # specified target in some subdirs but not the gas subdir, we shouldn't
5435   # pretend that all is well.)
5436   if test -n "$appdirs" ; then
5437     for dir in $appdirs ; do
5438       if test -r $dir/Makefile.in ; then
5439         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5440           appdirs=""
5441           break
5442         fi
5443         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5444           appdirs=""
5445           break
5446         fi
5447       fi
5448     done
5449     if test -n "$appdirs" ; then
5450       echo "*** This configuration is not supported by this package." 1>&2
5451       exit 1
5452     fi
5453   fi
5454   # Okay, some application will build, or we don't care to check.  Still
5455   # notify of subdirs not getting built.
5456   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5457   echo "    ${notsupp}" 1>&2
5458   echo "    (Any other directories should still work fine.)" 1>&2
5459 fi
5460
5461 case "$host" in
5462   *msdosdjgpp*)
5463     enable_gdbtk=no ;;
5464 esac
5465
5466 # To find our prefix, in gcc_cv_tool_prefix.
5467
5468 # The user is always right.
5469 if test "${PATH_SEPARATOR+set}" != set; then
5470   echo "#! /bin/sh" >conf$$.sh
5471   echo  "exit 0"   >>conf$$.sh
5472   chmod +x conf$$.sh
5473   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5474     PATH_SEPARATOR=';'
5475   else
5476     PATH_SEPARATOR=:
5477   fi
5478   rm -f conf$$.sh
5479 fi
5480
5481
5482
5483 if test "x$exec_prefix" = xNONE; then
5484         if test "x$prefix" = xNONE; then
5485                 gcc_cv_tool_prefix=$ac_default_prefix
5486         else
5487                 gcc_cv_tool_prefix=$prefix
5488         fi
5489 else
5490         gcc_cv_tool_prefix=$exec_prefix
5491 fi
5492
5493 # If there is no compiler in the tree, use the PATH only.  In any
5494 # case, if there is no compiler in the tree nobody should use
5495 # AS_FOR_TARGET and LD_FOR_TARGET.
5496 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5497     gcc_version=`cat $srcdir/gcc/BASE-VER`
5498     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5499     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5500     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5501     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5502     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5503     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5504 else
5505     gcc_cv_tool_dirs=
5506 fi
5507
5508 if test x$build = x$target && test -n "$md_exec_prefix"; then
5509         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5510 fi
5511
5512
5513
5514 copy_dirs=
5515
5516
5517 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5518 if test "${with_build_sysroot+set}" = set; then
5519   withval="$with_build_sysroot"
5520   if test x"$withval" != x ; then
5521      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5522    fi
5523 else
5524   SYSROOT_CFLAGS_FOR_TARGET=
5525 fi;
5526
5527
5528
5529 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5530 if test "${with_debug_prefix_map+set}" = set; then
5531   withval="$with_debug_prefix_map"
5532   if test x"$withval" != x; then
5533      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5534      for debug_map in $withval; do
5535        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5536      done
5537    fi
5538 else
5539   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5540 fi;
5541
5542
5543 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5544 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5545 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5546 # We want to ensure that TARGET libraries (which we know are built with
5547 # gcc) are built with "-O2 -g", so include those options when setting
5548 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5549 if test "x$CFLAGS_FOR_TARGET" = x; then
5550   CFLAGS_FOR_TARGET=$CFLAGS
5551   case " $CFLAGS " in
5552     *" -O2 "*) ;;
5553     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5554   esac
5555   case " $CFLAGS " in
5556     *" -g "* | *" -g3 "*) ;;
5557     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5558   esac
5559 fi
5560
5561
5562 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5563   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5564   case " $CXXFLAGS " in
5565     *" -O2 "*) ;;
5566     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5567   esac
5568   case " $CXXFLAGS " in
5569     *" -g "* | *" -g3 "*) ;;
5570     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5571   esac
5572 fi
5573
5574
5575 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5576 # the named directory are copied to $(tooldir)/sys-include.
5577 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5578   if test x${is_cross_compiler} = xno ; then
5579     echo 1>&2 '***' --with-headers is only supported when cross compiling
5580     exit 1
5581   fi
5582   if test x"${with_headers}" != xyes ; then
5583     x=${gcc_cv_tool_prefix}
5584     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5585   fi
5586 fi
5587
5588 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5589 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5590 # are permitted.
5591 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5592   if test x${is_cross_compiler} = xno ; then
5593     echo 1>&2 '***' --with-libs is only supported when cross compiling
5594     exit 1
5595   fi
5596   if test x"${with_libs}" != xyes ; then
5597     # Copy the libraries in reverse order, so that files in the first named
5598     # library override files in subsequent libraries.
5599     x=${gcc_cv_tool_prefix}
5600     for l in ${with_libs}; do
5601       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5602     done
5603   fi
5604 fi
5605
5606 # Set with_gnu_as and with_gnu_ld as appropriate.
5607 #
5608 # This is done by determining whether or not the appropriate directory
5609 # is available, and by checking whether or not specific configurations
5610 # have requested that this magic not happen.
5611 #
5612 # The command line options always override the explicit settings in
5613 # configure.in, and the settings in configure.in override this magic.
5614 #
5615 # If the default for a toolchain is to use GNU as and ld, and you don't
5616 # want to do that, then you should use the --without-gnu-as and
5617 # --without-gnu-ld options for the configure script.
5618
5619 if test x${use_gnu_as} = x &&
5620    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5621   with_gnu_as=yes
5622   extra_host_args="$extra_host_args --with-gnu-as"
5623 fi
5624
5625 if test x${use_gnu_ld} = x &&
5626    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5627   with_gnu_ld=yes
5628   extra_host_args="$extra_host_args --with-gnu-ld"
5629 fi
5630
5631 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5632 # can detect this case.
5633
5634 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5635   with_newlib=yes
5636   extra_host_args="$extra_host_args --with-newlib"
5637 fi
5638
5639 # Handle ${copy_dirs}
5640 set fnord ${copy_dirs}
5641 shift
5642 while test $# != 0 ; do
5643   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5644     :
5645   else
5646     echo Copying $1 to $2
5647
5648     # Use the install script to create the directory and all required
5649     # parent directories.
5650     if test -d $2 ; then
5651       :
5652     else
5653       echo >config.temp
5654       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5655     fi
5656
5657     # Copy the directory, assuming we have tar.
5658     # FIXME: Should we use B in the second tar?  Not all systems support it.
5659     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5660
5661     # It is the responsibility of the user to correctly adjust all
5662     # symlinks.  If somebody can figure out how to handle them correctly
5663     # here, feel free to add the code.
5664
5665     echo $1 > $2/COPIED
5666   fi
5667   shift; shift
5668 done
5669
5670 # Determine a target-dependent exec_prefix that the installed
5671 # gcc will search in.  Keep this list sorted by triplet, with
5672 # the *-*-osname triplets last.
5673 md_exec_prefix=
5674 case "${target}" in
5675   alpha*-*-*vms*)
5676     md_exec_prefix=/gnu/lib/gcc-lib
5677     ;;
5678   i[34567]86-pc-msdosdjgpp*)
5679     md_exec_prefix=/dev/env/DJDIR/bin
5680     ;;
5681   i[34567]86-*-sco3.2v5*)
5682     if test $with_gnu_as = yes; then
5683       md_exec_prefix=/usr/gnu/bin
5684     else
5685       md_exec_prefix=/usr/ccs/bin/elf
5686     fi
5687     ;;
5688
5689   mn10300-*-* | \
5690   powerpc-*-chorusos* | \
5691   powerpc*-*-eabi* | \
5692   powerpc*-*-sysv* | \
5693   powerpc*-*-kaos* | \
5694   s390x-ibm-tpf*)
5695     md_exec_prefix=/usr/ccs/bin
5696     ;;
5697   sparc64-*-elf*)
5698     ;;
5699   v850*-*-*)
5700     md_exec_prefix=/usr/ccs/bin
5701     ;;
5702   xtensa*-*-elf*)
5703     ;;
5704
5705   *-*-beos* | \
5706   *-*-elf* | \
5707   *-*-hpux* | \
5708   *-*-netware* | \
5709   *-*-nto-qnx* | \
5710   *-*-rtems* | \
5711   *-*-solaris2* | \
5712   *-*-sysv[45]* | \
5713   *-*-vxworks* | \
5714   *-wrs-windiss)
5715     md_exec_prefix=/usr/ccs/bin
5716     ;;
5717 esac
5718
5719 extra_arflags_for_target=
5720 extra_nmflags_for_target=
5721 extra_ranlibflags_for_target=
5722 target_makefile_frag=/dev/null
5723 case "${target}" in
5724   mep*-*-*)
5725     target_makefile_frag="config/mt-mep"
5726     ;;
5727   spu-*-*)
5728     target_makefile_frag="config/mt-spu"
5729     ;;
5730   mips*-sde-elf*)
5731     target_makefile_frag="config/mt-sde"
5732     ;;
5733   mipsisa*-*-elfoabi*)
5734     target_makefile_frag="config/mt-mips-elfoabi"
5735     ;;
5736   mips*-*-*linux* | mips*-*-gnu*)
5737     target_makefile_frag="config/mt-mips-gnu"
5738     ;;
5739   *-*-netware*)
5740     target_makefile_frag="config/mt-netware"
5741     ;;
5742   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
5743     target_makefile_frag="config/mt-gnu"
5744     ;;
5745   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5746     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5747     # commands to handle both 32-bit and 64-bit objects.  These flags are
5748     # harmless if we're using GNU nm or ar.
5749     extra_arflags_for_target=" -X32_64"
5750     extra_nmflags_for_target=" -B -X32_64"
5751     ;;
5752   *-*-darwin*)
5753     # ranlib from Darwin requires the -c flag to look at common symbols.
5754     extra_ranlibflags_for_target=" -c"
5755     ;;
5756   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5757     target_makefile_frag="config/mt-wince"
5758     ;;
5759 esac
5760
5761 alphaieee_frag=/dev/null
5762 case $target in
5763   alpha*-*-*)
5764     # This just makes sure to use the -mieee option to build target libs.
5765     # This should probably be set individually by each library.
5766     alphaieee_frag="config/mt-alphaieee"
5767     ;;
5768 esac
5769
5770 # If --enable-target-optspace always use -Os instead of -O2 to build
5771 # the target libraries, similarly if it is not specified, use -Os
5772 # on selected platforms.
5773 ospace_frag=/dev/null
5774 case "${enable_target_optspace}:${target}" in
5775   yes:*)
5776     ospace_frag="config/mt-ospace"
5777     ;;
5778   :d30v-*)
5779     ospace_frag="config/mt-d30v"
5780     ;;
5781   :m32r-* | :d10v-* | :fr30-*)
5782     ospace_frag="config/mt-ospace"
5783     ;;
5784   no:* | :*)
5785     ;;
5786   *)
5787     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5788     ;;
5789 esac
5790
5791 # Default to using --with-stabs for certain targets.
5792 if test x${with_stabs} = x ; then
5793   case "${target}" in
5794   mips*-*-irix[56]*)
5795     ;;
5796   mips*-*-* | alpha*-*-osf*)
5797     with_stabs=yes;
5798     extra_host_args="${extra_host_args} --with-stabs"
5799     ;;
5800   esac
5801 fi
5802
5803 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5804 # them automatically.
5805 case "${host}" in
5806   hppa*64*-*-hpux11*)
5807     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5808     ;;
5809 esac
5810
5811 # Some systems (e.g., one of the i386-aix systems the gas testers are
5812 # using) don't handle "\$" correctly, so don't use it here.
5813 tooldir='${exec_prefix}'/${target_noncanonical}
5814 build_tooldir=${tooldir}
5815
5816 # Create a .gdbinit file which runs the one in srcdir
5817 # and tells GDB to look there for source files.
5818
5819 if test -r ${srcdir}/.gdbinit ; then
5820   case ${srcdir} in
5821     .) ;;
5822     *) cat > ./.gdbinit <<EOF
5823 # ${NO_EDIT}
5824 dir ${srcdir}
5825 dir .
5826 source ${srcdir}/.gdbinit
5827 EOF
5828     ;;
5829   esac
5830 fi
5831
5832 # Make sure that the compiler is able to generate an executable.  If it
5833 # can't, we are probably in trouble.  We don't care whether we can run the
5834 # executable--we might be using a cross compiler--we only care whether it
5835 # can be created.  At this point the main configure script has set CC.
5836 we_are_ok=no
5837 echo "int main () { return 0; }" > conftest.c
5838 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5839 if test $? = 0 ; then
5840   if test -s conftest || test -s conftest.exe ; then
5841     we_are_ok=yes
5842   fi
5843 fi
5844 case $we_are_ok in
5845   no)
5846     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5847     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5848     rm -f conftest*
5849     exit 1
5850     ;;
5851 esac
5852 rm -f conftest*
5853
5854 # The Solaris /usr/ucb/cc compiler does not appear to work.
5855 case "${host}" in
5856   sparc-sun-solaris2*)
5857       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5858       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5859           could_use=
5860           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5861           if test -d /opt/cygnus/bin ; then
5862               if test "$could_use" = "" ; then
5863                   could_use="/opt/cygnus/bin"
5864               else
5865                   could_use="$could_use or /opt/cygnus/bin"
5866               fi
5867           fi
5868         if test "$could_use" = "" ; then
5869             echo "Warning: compilation may fail because you're using"
5870             echo "/usr/ucb/cc.  You should change your PATH or CC "
5871             echo "variable and rerun configure."
5872         else
5873             echo "Warning: compilation may fail because you're using"
5874             echo "/usr/ucb/cc, when you should use the C compiler from"
5875             echo "$could_use.  You should change your"
5876             echo "PATH or CC variable and rerun configure."
5877         fi
5878       fi
5879   ;;
5880 esac
5881
5882 # Decide which environment variable is used to find dynamic libraries.
5883 case "${host}" in
5884   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5885   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5886   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
5887   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5888 esac
5889
5890 # On systems where the dynamic library environment variable is PATH,
5891 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
5892 # built executables to PATH.
5893 if test "$RPATH_ENVVAR" = PATH; then
5894   GCC_SHLIB_SUBDIR=/shlib
5895 else
5896   GCC_SHLIB_SUBDIR=
5897 fi
5898
5899 # Record target_configdirs and the configure arguments for target and
5900 # build configuration in Makefile.
5901 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5902 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5903
5904 # Determine whether gdb needs tk/tcl or not.
5905 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5906 # and in that case we want gdb to be built without tk.  Ugh!
5907 # In fact I believe gdb is the *only* package directly dependent on tk,
5908 # so we should be able to put the 'maybe's in unconditionally and
5909 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5910 # 100% sure that that's safe though.
5911
5912 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5913 case "$enable_gdbtk" in
5914   no)
5915     GDB_TK="" ;;
5916   yes)
5917     GDB_TK="${gdb_tk}" ;;
5918   *)
5919     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5920     # distro.  Eventually someone will fix this and move Insight, nee
5921     # gdbtk to a separate directory.
5922     if test -d ${srcdir}/gdb/gdbtk ; then
5923       GDB_TK="${gdb_tk}"
5924     else
5925       GDB_TK=""
5926     fi
5927     ;;
5928 esac
5929 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5930 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5931
5932 # Strip out unwanted targets.
5933
5934 # While at that, we remove Makefiles if we were started for recursive
5935 # configuration, so that the top-level Makefile reconfigures them,
5936 # like we used to do when configure itself was recursive.
5937
5938 # Loop over modules.  $extrasub must be used with care, limiting as
5939 # much as possible the usage of range addresses.  That's because autoconf
5940 # splits the sed script to overcome limits in the number of commands,
5941 # and relying on carefully-timed sed passes may turn out to be very hard
5942 # to maintain later.  In this particular case, you just have to be careful
5943 # not to nest @if/@endif pairs, because configure will not warn you at all.
5944
5945 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5946 if test "${enable_bootstrap+set}" = set; then
5947   enableval="$enable_bootstrap"
5948
5949 else
5950   enable_bootstrap=default
5951 fi;
5952
5953 # Issue errors and warnings for invalid/strange bootstrap combinations.
5954 case "$configdirs" in
5955   *gcc*) have_compiler=yes ;;
5956   *) have_compiler=no ;;
5957 esac
5958
5959 case "$have_compiler:$host:$target:$enable_bootstrap" in
5960   *:*:*:no) ;;
5961
5962   # Default behavior.  Enable bootstrap if we have a compiler
5963   # and we are in a native configuration.
5964   yes:$build:$build:default)
5965     enable_bootstrap=yes ;;
5966
5967   *:*:*:default)
5968     enable_bootstrap=no ;;
5969
5970   # We have a compiler and we are in a native configuration, bootstrap is ok
5971   yes:$build:$build:yes)
5972     ;;
5973
5974   # Other configurations, but we have a compiler.  Assume the user knows
5975   # what he's doing.
5976   yes:*:*:yes)
5977     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5978 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5979     ;;
5980
5981   # No compiler: if they passed --enable-bootstrap explicitly, fail
5982   no:*:*:yes)
5983     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5984 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5985    { (exit 1); exit 1; }; } ;;
5986
5987   # Fail if wrong command line
5988   *)
5989     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5990 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5991    { (exit 1); exit 1; }; }
5992     ;;
5993 esac
5994
5995 # Adjust the toplevel makefile according to whether bootstrap was selected.
5996 case "$enable_bootstrap" in
5997   yes)
5998     bootstrap_suffix=bootstrap ;;
5999   no)
6000     bootstrap_suffix=no-bootstrap ;;
6001 esac
6002
6003 for module in ${build_configdirs} ; do
6004   if test -z "${no_recursion}" \
6005      && test -f ${build_subdir}/${module}/Makefile; then
6006     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
6007     rm -f ${build_subdir}/${module}/Makefile
6008   fi
6009   extrasub="$extrasub
6010 /^@if build-$module\$/d
6011 /^@endif build-$module\$/d
6012 /^@if build-$module-$bootstrap_suffix\$/d
6013 /^@endif build-$module-$bootstrap_suffix\$/d"
6014 done
6015 for module in ${configdirs} ; do
6016   if test -z "${no_recursion}"; then
6017     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
6018       if test -f ${file}; then
6019         echo 1>&2 "*** removing ${file} to force reconfigure"
6020         rm -f ${file}
6021       fi
6022     done
6023   fi
6024   extrasub="$extrasub
6025 /^@if $module\$/d
6026 /^@endif $module\$/d
6027 /^@if $module-$bootstrap_suffix\$/d
6028 /^@endif $module-$bootstrap_suffix\$/d"
6029 done
6030 for module in ${target_configdirs} ; do
6031   if test -z "${no_recursion}" \
6032      && test -f ${target_subdir}/${module}/Makefile; then
6033     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6034     rm -f ${target_subdir}/${module}/Makefile
6035   fi
6036   extrasub="$extrasub
6037 /^@if target-$module\$/d
6038 /^@endif target-$module\$/d
6039 /^@if target-$module-$bootstrap_suffix\$/d
6040 /^@endif target-$module-$bootstrap_suffix\$/d"
6041 done
6042
6043 extrasub="$extrasub
6044 /^@if /,/^@endif /d"
6045
6046 # Create the serialization dependencies.  This uses a temporary file.
6047
6048 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6049 if test "${enable_serial_configure+set}" = set; then
6050   enableval="$enable_serial_configure"
6051
6052 fi;
6053
6054 case ${enable_serial_configure} in
6055   yes)
6056     enable_serial_build_configure=yes
6057     enable_serial_host_configure=yes
6058     enable_serial_target_configure=yes
6059     ;;
6060 esac
6061
6062 # These force 'configure's to be done one at a time, to avoid problems
6063 # with contention over a shared config.cache.
6064 rm -f serdep.tmp
6065 echo '# serdep.tmp' > serdep.tmp
6066 olditem=
6067 test "x${enable_serial_build_configure}" = xyes &&
6068 for item in ${build_configdirs} ; do
6069   case ${olditem} in
6070     "") ;;
6071     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6072   esac
6073   olditem=${item}
6074 done
6075 olditem=
6076 test "x${enable_serial_host_configure}" = xyes &&
6077 for item in ${configdirs} ; do
6078   case ${olditem} in
6079     "") ;;
6080     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6081   esac
6082   olditem=${item}
6083 done
6084 olditem=
6085 test "x${enable_serial_target_configure}" = xyes &&
6086 for item in ${target_configdirs} ; do
6087   case ${olditem} in
6088     "") ;;
6089     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6090   esac
6091   olditem=${item}
6092 done
6093 serialization_dependencies=serdep.tmp
6094
6095
6096 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6097 # target, nonopt, and variable assignments.  These are the ones we
6098 # might not want to pass down to subconfigures.  Also strip
6099 # program-prefix, program-suffix, and program-transform-name, so that
6100 # we can pass down a consistent program-transform-name.
6101 baseargs=
6102 keep_next=no
6103 skip_next=no
6104 eval "set -- $ac_configure_args"
6105 for ac_arg
6106 do
6107   if test X"$skip_next" = X"yes"; then
6108     skip_next=no
6109     continue
6110   fi
6111   if test X"$keep_next" = X"yes"; then
6112     case $ac_arg in
6113       *\'*)
6114         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6115     esac
6116     baseargs="$baseargs '$ac_arg'"
6117     keep_next=no
6118     continue
6119   fi
6120
6121   # Handle separated arguments.  Based on the logic generated by
6122   # autoconf 2.59.
6123   case $ac_arg in
6124     *=* | --config-cache | -C | -disable-* | --disable-* \
6125       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6126       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6127       | -with-* | --with-* | -without-* | --without-* | --x)
6128       separate_arg=no
6129       ;;
6130     -*)
6131       separate_arg=yes
6132       ;;
6133     *)
6134       separate_arg=no
6135       ;;
6136   esac
6137
6138   case "$ac_arg" in
6139     --no*)
6140       continue
6141       ;;
6142     --c* | \
6143     --sr* | \
6144     --ho* | \
6145     --bu* | \
6146     --t* | \
6147     --program-* | \
6148     -cache_file* | \
6149     -srcdir* | \
6150     -host* | \
6151     -build* | \
6152     -target* | \
6153     -program-prefix* | \
6154     -program-suffix* | \
6155     -program-transform-name* )
6156       skip_next=$separate_arg
6157       continue
6158       ;;
6159     -*)
6160       # An option.  Add it.
6161       case $ac_arg in
6162         *\'*)
6163           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6164       esac
6165       baseargs="$baseargs '$ac_arg'"
6166       keep_next=$separate_arg
6167       ;;
6168     *)
6169       # Either a variable assignment, or a nonopt (triplet).  Don't
6170       # pass it down; let the Makefile handle this.
6171       continue
6172       ;;
6173   esac
6174 done
6175 # Remove the initial space we just introduced and, as these will be
6176 # expanded by make, quote '$'.
6177 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6178
6179 # Add in --program-transform-name, after --program-prefix and
6180 # --program-suffix have been applied to it.  Autoconf has already
6181 # doubled dollar signs and backslashes in program_transform_name; we want
6182 # the backslashes un-doubled, and then the entire thing wrapped in single
6183 # quotes, because this will be expanded first by make and then by the shell.
6184 # Also, because we want to override the logic in subdir configure scripts to
6185 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6186 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6187 ${program_transform_name}
6188 EOF_SED
6189 gcc_transform_name=`cat conftestsed.out`
6190 rm -f conftestsed.out
6191 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6192 if test "$silent" = yes; then
6193   baseargs="$baseargs --silent"
6194 fi
6195
6196 # For the build-side libraries, we just need to pretend we're native,
6197 # and not use the same cache file.  Multilibs are neither needed nor
6198 # desired.
6199 build_configargs="--cache-file=../config.cache ${baseargs}"
6200
6201 # For host modules, accept cache file option, or specification as blank.
6202 case "${cache_file}" in
6203 "") # empty
6204   cache_file_option="" ;;
6205 /* | [A-Za-z]:[\\/]* ) # absolute path
6206   cache_file_option="--cache-file=${cache_file}" ;;
6207 *) # relative path
6208   cache_file_option="--cache-file=../${cache_file}" ;;
6209 esac
6210
6211 # Host dirs don't like to share a cache file either, horribly enough.
6212 # This seems to be due to autoconf 2.5x stupidity.
6213 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6214
6215 target_configargs=${baseargs}
6216
6217 # Passing a --with-cross-host argument lets the target libraries know
6218 # whether they are being built with a cross-compiler or being built
6219 # native.  However, it would be better to use other mechanisms to make the
6220 # sorts of decisions they want to make on this basis.  Please consider
6221 # this option to be deprecated.  FIXME.
6222 if test x${is_cross_compiler} = xyes ; then
6223   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6224 fi
6225
6226 # Default to --enable-multilib.
6227 if test x${enable_multilib} = x ; then
6228   target_configargs="--enable-multilib ${target_configargs}"
6229 fi
6230
6231 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6232 # changed from the earlier setting of with_newlib.
6233 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6234   target_configargs="--with-newlib ${target_configargs}"
6235 fi
6236
6237 # Different target subdirs use different values of certain variables
6238 # (notably CXX).  Worse, multilibs use *lots* of different values.
6239 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6240 # it doesn't automatically accept command-line overrides of them.
6241 # This means it's not safe for target subdirs to share a cache file,
6242 # which is disgusting, but there you have it.  Hopefully this can be
6243 # fixed in future.  It's still worthwhile to use a cache file for each
6244 # directory.  I think.
6245
6246 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6247 # We need to pass --target, as newer autoconf's requires consistency
6248 # for target_alias and gcc doesn't manage it consistently.
6249 target_configargs="--cache-file=./config.cache ${target_configargs}"
6250
6251 FLAGS_FOR_TARGET=
6252 case " $target_configdirs " in
6253  *" newlib "*)
6254   case " $target_configargs " in
6255   *" --with-newlib "*)
6256    case "$target" in
6257    *-cygwin*)
6258      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' ;;
6259    esac
6260
6261    # If we're not building GCC, don't discard standard headers.
6262    if test -d ${srcdir}/gcc; then
6263      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6264
6265      if test "${build}" != "${host}"; then
6266        # On Canadian crosses, CC_FOR_TARGET will have already been set
6267        # by `configure', so we won't have an opportunity to add -Bgcc/
6268        # to it.  This is right: we don't want to search that directory
6269        # for binaries, but we want the header files in there, so add
6270        # them explicitly.
6271        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6272
6273        # Someone might think of using the pre-installed headers on
6274        # Canadian crosses, in case the installed compiler is not fully
6275        # compatible with the compiler being built.  In this case, it
6276        # would be better to flag an error than risking having
6277        # incompatible object files being constructed.  We can't
6278        # guarantee that an error will be flagged, but let's hope the
6279        # compiler will do it, when presented with incompatible header
6280        # files.
6281      fi
6282    fi
6283
6284    case "${target}-${is_cross_compiler}" in
6285    i[3456789]86-*-linux*-no)
6286       # Here host == target, so we don't need to build gcc,
6287       # so we don't want to discard standard headers.
6288       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6289       ;;
6290    *)
6291       # If we're building newlib, use its generic headers last, but search
6292       # for any libc-related directories first (so make it the last -B
6293       # switch).
6294       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6295
6296       # If we're building libgloss, find the startup file, simulator library
6297       # and linker script.
6298       case " $target_configdirs " in
6299         *" libgloss "*)
6300         # Look for startup file, simulator library and maybe linker script.
6301         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6302         # Look for libnosys.a in case the target needs it.
6303         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6304         # Most targets have the linker script in the source directory.
6305         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6306         ;;
6307       esac
6308       ;;
6309    esac
6310    ;;
6311   esac
6312   ;;
6313 esac
6314 case "$target" in
6315 *-mingw*)
6316   # Can't be handled as Cygwin above since Mingw does not use newlib.
6317   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' ;;
6318 esac
6319
6320 # Allow the user to override the flags for
6321 # our build compiler if desired.
6322 if test x"${build}" = x"${host}" ; then
6323   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6324   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6325   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6326 fi
6327
6328 # On Canadian crosses, we'll be searching the right directories for
6329 # the previously-installed cross compiler, so don't bother to add
6330 # flags for directories within the install tree of the compiler
6331 # being built; programs in there won't even run.
6332 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6333   # Search for pre-installed headers if nothing else fits.
6334   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6335 fi
6336
6337 if test "x${use_gnu_ld}" = x &&
6338    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6339   # Arrange for us to find uninstalled linker scripts.
6340   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6341 fi
6342
6343 # Search for other target-specific linker scripts and such.
6344 case "${target}" in
6345   mep*)
6346     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6347     ;;
6348 esac
6349
6350 # Makefile fragments.
6351 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6352 do
6353   eval fragval=\$$frag
6354   if test $fragval != /dev/null; then
6355     eval $frag=${srcdir}/$fragval
6356   fi
6357 done
6358
6359
6360
6361
6362
6363 # Miscellanea: directories, flags, etc.
6364
6365
6366
6367
6368
6369
6370
6371
6372 # Build module lists & subconfigure args.
6373
6374
6375
6376 # Host module lists & subconfigure args.
6377
6378
6379
6380 # Target module lists & subconfigure args.
6381
6382
6383
6384 # Build tools.
6385
6386
6387
6388
6389
6390
6391
6392
6393
6394
6395
6396
6397
6398
6399
6400
6401
6402 # Generate default definitions for YACC, M4, LEX and other programs that run
6403 # on the build machine.  These are used if the Makefile can't locate these
6404 # programs in objdir.
6405 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6406
6407 for ac_prog in 'bison -y' byacc yacc
6408 do
6409   # Extract the first word of "$ac_prog", so it can be a program name with args.
6410 set dummy $ac_prog; ac_word=$2
6411 echo "$as_me:$LINENO: checking for $ac_word" >&5
6412 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6413 if test "${ac_cv_prog_YACC+set}" = set; then
6414   echo $ECHO_N "(cached) $ECHO_C" >&6
6415 else
6416   if test -n "$YACC"; then
6417   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6418 else
6419 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6420 for as_dir in $PATH
6421 do
6422   IFS=$as_save_IFS
6423   test -z "$as_dir" && as_dir=.
6424   for ac_exec_ext in '' $ac_executable_extensions; do
6425   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6426     ac_cv_prog_YACC="$ac_prog"
6427     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6428     break 2
6429   fi
6430 done
6431 done
6432
6433 fi
6434 fi
6435 YACC=$ac_cv_prog_YACC
6436 if test -n "$YACC"; then
6437   echo "$as_me:$LINENO: result: $YACC" >&5
6438 echo "${ECHO_T}$YACC" >&6
6439 else
6440   echo "$as_me:$LINENO: result: no" >&5
6441 echo "${ECHO_T}no" >&6
6442 fi
6443
6444   test -n "$YACC" && break
6445 done
6446 test -n "$YACC" || YACC="$MISSING bison -y"
6447
6448 case " $build_configdirs " in
6449   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6450   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6451 esac
6452
6453 for ac_prog in bison
6454 do
6455   # Extract the first word of "$ac_prog", so it can be a program name with args.
6456 set dummy $ac_prog; ac_word=$2
6457 echo "$as_me:$LINENO: checking for $ac_word" >&5
6458 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6459 if test "${ac_cv_prog_BISON+set}" = set; then
6460   echo $ECHO_N "(cached) $ECHO_C" >&6
6461 else
6462   if test -n "$BISON"; then
6463   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6464 else
6465 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6466 for as_dir in $PATH
6467 do
6468   IFS=$as_save_IFS
6469   test -z "$as_dir" && as_dir=.
6470   for ac_exec_ext in '' $ac_executable_extensions; do
6471   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6472     ac_cv_prog_BISON="$ac_prog"
6473     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6474     break 2
6475   fi
6476 done
6477 done
6478
6479 fi
6480 fi
6481 BISON=$ac_cv_prog_BISON
6482 if test -n "$BISON"; then
6483   echo "$as_me:$LINENO: result: $BISON" >&5
6484 echo "${ECHO_T}$BISON" >&6
6485 else
6486   echo "$as_me:$LINENO: result: no" >&5
6487 echo "${ECHO_T}no" >&6
6488 fi
6489
6490   test -n "$BISON" && break
6491 done
6492 test -n "$BISON" || BISON="$MISSING bison"
6493
6494 case " $build_configdirs " in
6495   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6496 esac
6497
6498 for ac_prog in gm4 gnum4 m4
6499 do
6500   # Extract the first word of "$ac_prog", so it can be a program name with args.
6501 set dummy $ac_prog; ac_word=$2
6502 echo "$as_me:$LINENO: checking for $ac_word" >&5
6503 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6504 if test "${ac_cv_prog_M4+set}" = set; then
6505   echo $ECHO_N "(cached) $ECHO_C" >&6
6506 else
6507   if test -n "$M4"; then
6508   ac_cv_prog_M4="$M4" # Let the user override the test.
6509 else
6510 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6511 for as_dir in $PATH
6512 do
6513   IFS=$as_save_IFS
6514   test -z "$as_dir" && as_dir=.
6515   for ac_exec_ext in '' $ac_executable_extensions; do
6516   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6517     ac_cv_prog_M4="$ac_prog"
6518     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6519     break 2
6520   fi
6521 done
6522 done
6523
6524 fi
6525 fi
6526 M4=$ac_cv_prog_M4
6527 if test -n "$M4"; then
6528   echo "$as_me:$LINENO: result: $M4" >&5
6529 echo "${ECHO_T}$M4" >&6
6530 else
6531   echo "$as_me:$LINENO: result: no" >&5
6532 echo "${ECHO_T}no" >&6
6533 fi
6534
6535   test -n "$M4" && break
6536 done
6537 test -n "$M4" || M4="$MISSING m4"
6538
6539 case " $build_configdirs " in
6540   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6541 esac
6542
6543 for ac_prog in flex lex
6544 do
6545   # Extract the first word of "$ac_prog", so it can be a program name with args.
6546 set dummy $ac_prog; ac_word=$2
6547 echo "$as_me:$LINENO: checking for $ac_word" >&5
6548 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6549 if test "${ac_cv_prog_LEX+set}" = set; then
6550   echo $ECHO_N "(cached) $ECHO_C" >&6
6551 else
6552   if test -n "$LEX"; then
6553   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6554 else
6555 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6556 for as_dir in $PATH
6557 do
6558   IFS=$as_save_IFS
6559   test -z "$as_dir" && as_dir=.
6560   for ac_exec_ext in '' $ac_executable_extensions; do
6561   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6562     ac_cv_prog_LEX="$ac_prog"
6563     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6564     break 2
6565   fi
6566 done
6567 done
6568
6569 fi
6570 fi
6571 LEX=$ac_cv_prog_LEX
6572 if test -n "$LEX"; then
6573   echo "$as_me:$LINENO: result: $LEX" >&5
6574 echo "${ECHO_T}$LEX" >&6
6575 else
6576   echo "$as_me:$LINENO: result: no" >&5
6577 echo "${ECHO_T}no" >&6
6578 fi
6579
6580   test -n "$LEX" && break
6581 done
6582 test -n "$LEX" || LEX="$MISSING flex"
6583
6584 case " $build_configdirs " in
6585   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6586   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6587 esac
6588
6589 for ac_prog in flex
6590 do
6591   # Extract the first word of "$ac_prog", so it can be a program name with args.
6592 set dummy $ac_prog; ac_word=$2
6593 echo "$as_me:$LINENO: checking for $ac_word" >&5
6594 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6595 if test "${ac_cv_prog_FLEX+set}" = set; then
6596   echo $ECHO_N "(cached) $ECHO_C" >&6
6597 else
6598   if test -n "$FLEX"; then
6599   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6600 else
6601 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6602 for as_dir in $PATH
6603 do
6604   IFS=$as_save_IFS
6605   test -z "$as_dir" && as_dir=.
6606   for ac_exec_ext in '' $ac_executable_extensions; do
6607   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6608     ac_cv_prog_FLEX="$ac_prog"
6609     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6610     break 2
6611   fi
6612 done
6613 done
6614
6615 fi
6616 fi
6617 FLEX=$ac_cv_prog_FLEX
6618 if test -n "$FLEX"; then
6619   echo "$as_me:$LINENO: result: $FLEX" >&5
6620 echo "${ECHO_T}$FLEX" >&6
6621 else
6622   echo "$as_me:$LINENO: result: no" >&5
6623 echo "${ECHO_T}no" >&6
6624 fi
6625
6626   test -n "$FLEX" && break
6627 done
6628 test -n "$FLEX" || FLEX="$MISSING flex"
6629
6630 case " $build_configdirs " in
6631   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6632 esac
6633
6634 for ac_prog in makeinfo
6635 do
6636   # Extract the first word of "$ac_prog", so it can be a program name with args.
6637 set dummy $ac_prog; ac_word=$2
6638 echo "$as_me:$LINENO: checking for $ac_word" >&5
6639 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6640 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6641   echo $ECHO_N "(cached) $ECHO_C" >&6
6642 else
6643   if test -n "$MAKEINFO"; then
6644   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6645 else
6646 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6647 for as_dir in $PATH
6648 do
6649   IFS=$as_save_IFS
6650   test -z "$as_dir" && as_dir=.
6651   for ac_exec_ext in '' $ac_executable_extensions; do
6652   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6653     ac_cv_prog_MAKEINFO="$ac_prog"
6654     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6655     break 2
6656   fi
6657 done
6658 done
6659
6660 fi
6661 fi
6662 MAKEINFO=$ac_cv_prog_MAKEINFO
6663 if test -n "$MAKEINFO"; then
6664   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6665 echo "${ECHO_T}$MAKEINFO" >&6
6666 else
6667   echo "$as_me:$LINENO: result: no" >&5
6668 echo "${ECHO_T}no" >&6
6669 fi
6670
6671   test -n "$MAKEINFO" && break
6672 done
6673 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6674
6675 case " $build_configdirs " in
6676   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6677   *)
6678
6679     # For an installed makeinfo, we require it to be from texinfo 4.7 or
6680     # higher, else we use the "missing" dummy.
6681     if ${MAKEINFO} --version \
6682        | egrep 'texinfo[^0-9]*(4\.([7-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6683       :
6684     else
6685       MAKEINFO="$MISSING makeinfo"
6686     fi
6687     ;;
6688
6689 esac
6690
6691 # FIXME: expect and dejagnu may become build tools?
6692
6693 for ac_prog in expect
6694 do
6695   # Extract the first word of "$ac_prog", so it can be a program name with args.
6696 set dummy $ac_prog; ac_word=$2
6697 echo "$as_me:$LINENO: checking for $ac_word" >&5
6698 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6699 if test "${ac_cv_prog_EXPECT+set}" = set; then
6700   echo $ECHO_N "(cached) $ECHO_C" >&6
6701 else
6702   if test -n "$EXPECT"; then
6703   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6704 else
6705 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6706 for as_dir in $PATH
6707 do
6708   IFS=$as_save_IFS
6709   test -z "$as_dir" && as_dir=.
6710   for ac_exec_ext in '' $ac_executable_extensions; do
6711   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6712     ac_cv_prog_EXPECT="$ac_prog"
6713     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6714     break 2
6715   fi
6716 done
6717 done
6718
6719 fi
6720 fi
6721 EXPECT=$ac_cv_prog_EXPECT
6722 if test -n "$EXPECT"; then
6723   echo "$as_me:$LINENO: result: $EXPECT" >&5
6724 echo "${ECHO_T}$EXPECT" >&6
6725 else
6726   echo "$as_me:$LINENO: result: no" >&5
6727 echo "${ECHO_T}no" >&6
6728 fi
6729
6730   test -n "$EXPECT" && break
6731 done
6732 test -n "$EXPECT" || EXPECT="expect"
6733
6734 case " $configdirs " in
6735   *" expect "*)
6736     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6737     ;;
6738 esac
6739
6740 for ac_prog in runtest
6741 do
6742   # Extract the first word of "$ac_prog", so it can be a program name with args.
6743 set dummy $ac_prog; ac_word=$2
6744 echo "$as_me:$LINENO: checking for $ac_word" >&5
6745 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6746 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6747   echo $ECHO_N "(cached) $ECHO_C" >&6
6748 else
6749   if test -n "$RUNTEST"; then
6750   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6751 else
6752 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6753 for as_dir in $PATH
6754 do
6755   IFS=$as_save_IFS
6756   test -z "$as_dir" && as_dir=.
6757   for ac_exec_ext in '' $ac_executable_extensions; do
6758   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6759     ac_cv_prog_RUNTEST="$ac_prog"
6760     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6761     break 2
6762   fi
6763 done
6764 done
6765
6766 fi
6767 fi
6768 RUNTEST=$ac_cv_prog_RUNTEST
6769 if test -n "$RUNTEST"; then
6770   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6771 echo "${ECHO_T}$RUNTEST" >&6
6772 else
6773   echo "$as_me:$LINENO: result: no" >&5
6774 echo "${ECHO_T}no" >&6
6775 fi
6776
6777   test -n "$RUNTEST" && break
6778 done
6779 test -n "$RUNTEST" || RUNTEST="runtest"
6780
6781 case " $configdirs " in
6782   *" dejagnu "*)
6783     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6784     ;;
6785 esac
6786
6787
6788 # Host tools.
6789 ncn_tool_prefix=
6790 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6791 ncn_target_tool_prefix=
6792 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6793
6794
6795
6796 if test -n "$AR"; then
6797   ac_cv_prog_AR=$AR
6798 elif test -n "$ac_cv_prog_AR"; then
6799   AR=$ac_cv_prog_AR
6800 fi
6801
6802 if test -n "$ac_cv_prog_AR"; then
6803   for ncn_progname in ar; do
6804     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6805 set dummy ${ncn_progname}; ac_word=$2
6806 echo "$as_me:$LINENO: checking for $ac_word" >&5
6807 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6808 if test "${ac_cv_prog_AR+set}" = set; then
6809   echo $ECHO_N "(cached) $ECHO_C" >&6
6810 else
6811   if test -n "$AR"; then
6812   ac_cv_prog_AR="$AR" # Let the user override the test.
6813 else
6814 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6815 for as_dir in $PATH
6816 do
6817   IFS=$as_save_IFS
6818   test -z "$as_dir" && as_dir=.
6819   for ac_exec_ext in '' $ac_executable_extensions; do
6820   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6821     ac_cv_prog_AR="${ncn_progname}"
6822     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6823     break 2
6824   fi
6825 done
6826 done
6827
6828 fi
6829 fi
6830 AR=$ac_cv_prog_AR
6831 if test -n "$AR"; then
6832   echo "$as_me:$LINENO: result: $AR" >&5
6833 echo "${ECHO_T}$AR" >&6
6834 else
6835   echo "$as_me:$LINENO: result: no" >&5
6836 echo "${ECHO_T}no" >&6
6837 fi
6838
6839   done
6840 fi
6841
6842 for ncn_progname in ar; do
6843   if test -n "$ncn_tool_prefix"; then
6844     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6845 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6846 echo "$as_me:$LINENO: checking for $ac_word" >&5
6847 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6848 if test "${ac_cv_prog_AR+set}" = set; then
6849   echo $ECHO_N "(cached) $ECHO_C" >&6
6850 else
6851   if test -n "$AR"; then
6852   ac_cv_prog_AR="$AR" # Let the user override the test.
6853 else
6854 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6855 for as_dir in $PATH
6856 do
6857   IFS=$as_save_IFS
6858   test -z "$as_dir" && as_dir=.
6859   for ac_exec_ext in '' $ac_executable_extensions; do
6860   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6861     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6862     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6863     break 2
6864   fi
6865 done
6866 done
6867
6868 fi
6869 fi
6870 AR=$ac_cv_prog_AR
6871 if test -n "$AR"; then
6872   echo "$as_me:$LINENO: result: $AR" >&5
6873 echo "${ECHO_T}$AR" >&6
6874 else
6875   echo "$as_me:$LINENO: result: no" >&5
6876 echo "${ECHO_T}no" >&6
6877 fi
6878
6879   fi
6880   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6881     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6882 set dummy ${ncn_progname}; ac_word=$2
6883 echo "$as_me:$LINENO: checking for $ac_word" >&5
6884 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6885 if test "${ac_cv_prog_AR+set}" = set; then
6886   echo $ECHO_N "(cached) $ECHO_C" >&6
6887 else
6888   if test -n "$AR"; then
6889   ac_cv_prog_AR="$AR" # Let the user override the test.
6890 else
6891 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6892 for as_dir in $PATH
6893 do
6894   IFS=$as_save_IFS
6895   test -z "$as_dir" && as_dir=.
6896   for ac_exec_ext in '' $ac_executable_extensions; do
6897   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6898     ac_cv_prog_AR="${ncn_progname}"
6899     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6900     break 2
6901   fi
6902 done
6903 done
6904
6905 fi
6906 fi
6907 AR=$ac_cv_prog_AR
6908 if test -n "$AR"; then
6909   echo "$as_me:$LINENO: result: $AR" >&5
6910 echo "${ECHO_T}$AR" >&6
6911 else
6912   echo "$as_me:$LINENO: result: no" >&5
6913 echo "${ECHO_T}no" >&6
6914 fi
6915
6916   fi
6917   test -n "$ac_cv_prog_AR" && break
6918 done
6919
6920 if test -z "$ac_cv_prog_AR" ; then
6921   set dummy ar
6922   if test $build = $host ; then
6923     AR="$2"
6924   else
6925     AR="${ncn_tool_prefix}$2"
6926   fi
6927 fi
6928
6929
6930
6931 if test -n "$AS"; then
6932   ac_cv_prog_AS=$AS
6933 elif test -n "$ac_cv_prog_AS"; then
6934   AS=$ac_cv_prog_AS
6935 fi
6936
6937 if test -n "$ac_cv_prog_AS"; then
6938   for ncn_progname in as; do
6939     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6940 set dummy ${ncn_progname}; ac_word=$2
6941 echo "$as_me:$LINENO: checking for $ac_word" >&5
6942 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6943 if test "${ac_cv_prog_AS+set}" = set; then
6944   echo $ECHO_N "(cached) $ECHO_C" >&6
6945 else
6946   if test -n "$AS"; then
6947   ac_cv_prog_AS="$AS" # Let the user override the test.
6948 else
6949 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6950 for as_dir in $PATH
6951 do
6952   IFS=$as_save_IFS
6953   test -z "$as_dir" && as_dir=.
6954   for ac_exec_ext in '' $ac_executable_extensions; do
6955   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6956     ac_cv_prog_AS="${ncn_progname}"
6957     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6958     break 2
6959   fi
6960 done
6961 done
6962
6963 fi
6964 fi
6965 AS=$ac_cv_prog_AS
6966 if test -n "$AS"; then
6967   echo "$as_me:$LINENO: result: $AS" >&5
6968 echo "${ECHO_T}$AS" >&6
6969 else
6970   echo "$as_me:$LINENO: result: no" >&5
6971 echo "${ECHO_T}no" >&6
6972 fi
6973
6974   done
6975 fi
6976
6977 for ncn_progname in as; do
6978   if test -n "$ncn_tool_prefix"; then
6979     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6980 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6981 echo "$as_me:$LINENO: checking for $ac_word" >&5
6982 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6983 if test "${ac_cv_prog_AS+set}" = set; then
6984   echo $ECHO_N "(cached) $ECHO_C" >&6
6985 else
6986   if test -n "$AS"; then
6987   ac_cv_prog_AS="$AS" # Let the user override the test.
6988 else
6989 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6990 for as_dir in $PATH
6991 do
6992   IFS=$as_save_IFS
6993   test -z "$as_dir" && as_dir=.
6994   for ac_exec_ext in '' $ac_executable_extensions; do
6995   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6996     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6997     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6998     break 2
6999   fi
7000 done
7001 done
7002
7003 fi
7004 fi
7005 AS=$ac_cv_prog_AS
7006 if test -n "$AS"; then
7007   echo "$as_me:$LINENO: result: $AS" >&5
7008 echo "${ECHO_T}$AS" >&6
7009 else
7010   echo "$as_me:$LINENO: result: no" >&5
7011 echo "${ECHO_T}no" >&6
7012 fi
7013
7014   fi
7015   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
7016     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7017 set dummy ${ncn_progname}; ac_word=$2
7018 echo "$as_me:$LINENO: checking for $ac_word" >&5
7019 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7020 if test "${ac_cv_prog_AS+set}" = set; then
7021   echo $ECHO_N "(cached) $ECHO_C" >&6
7022 else
7023   if test -n "$AS"; then
7024   ac_cv_prog_AS="$AS" # Let the user override the test.
7025 else
7026 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7027 for as_dir in $PATH
7028 do
7029   IFS=$as_save_IFS
7030   test -z "$as_dir" && as_dir=.
7031   for ac_exec_ext in '' $ac_executable_extensions; do
7032   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7033     ac_cv_prog_AS="${ncn_progname}"
7034     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7035     break 2
7036   fi
7037 done
7038 done
7039
7040 fi
7041 fi
7042 AS=$ac_cv_prog_AS
7043 if test -n "$AS"; then
7044   echo "$as_me:$LINENO: result: $AS" >&5
7045 echo "${ECHO_T}$AS" >&6
7046 else
7047   echo "$as_me:$LINENO: result: no" >&5
7048 echo "${ECHO_T}no" >&6
7049 fi
7050
7051   fi
7052   test -n "$ac_cv_prog_AS" && break
7053 done
7054
7055 if test -z "$ac_cv_prog_AS" ; then
7056   set dummy as
7057   if test $build = $host ; then
7058     AS="$2"
7059   else
7060     AS="${ncn_tool_prefix}$2"
7061   fi
7062 fi
7063
7064
7065
7066 if test -n "$DLLTOOL"; then
7067   ac_cv_prog_DLLTOOL=$DLLTOOL
7068 elif test -n "$ac_cv_prog_DLLTOOL"; then
7069   DLLTOOL=$ac_cv_prog_DLLTOOL
7070 fi
7071
7072 if test -n "$ac_cv_prog_DLLTOOL"; then
7073   for ncn_progname in dlltool; do
7074     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7075 set dummy ${ncn_progname}; ac_word=$2
7076 echo "$as_me:$LINENO: checking for $ac_word" >&5
7077 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7078 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7079   echo $ECHO_N "(cached) $ECHO_C" >&6
7080 else
7081   if test -n "$DLLTOOL"; then
7082   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7083 else
7084 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7085 for as_dir in $PATH
7086 do
7087   IFS=$as_save_IFS
7088   test -z "$as_dir" && as_dir=.
7089   for ac_exec_ext in '' $ac_executable_extensions; do
7090   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7091     ac_cv_prog_DLLTOOL="${ncn_progname}"
7092     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7093     break 2
7094   fi
7095 done
7096 done
7097
7098 fi
7099 fi
7100 DLLTOOL=$ac_cv_prog_DLLTOOL
7101 if test -n "$DLLTOOL"; then
7102   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7103 echo "${ECHO_T}$DLLTOOL" >&6
7104 else
7105   echo "$as_me:$LINENO: result: no" >&5
7106 echo "${ECHO_T}no" >&6
7107 fi
7108
7109   done
7110 fi
7111
7112 for ncn_progname in dlltool; do
7113   if test -n "$ncn_tool_prefix"; then
7114     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7115 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7116 echo "$as_me:$LINENO: checking for $ac_word" >&5
7117 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7118 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7119   echo $ECHO_N "(cached) $ECHO_C" >&6
7120 else
7121   if test -n "$DLLTOOL"; then
7122   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7123 else
7124 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7125 for as_dir in $PATH
7126 do
7127   IFS=$as_save_IFS
7128   test -z "$as_dir" && as_dir=.
7129   for ac_exec_ext in '' $ac_executable_extensions; do
7130   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7131     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7132     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7133     break 2
7134   fi
7135 done
7136 done
7137
7138 fi
7139 fi
7140 DLLTOOL=$ac_cv_prog_DLLTOOL
7141 if test -n "$DLLTOOL"; then
7142   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7143 echo "${ECHO_T}$DLLTOOL" >&6
7144 else
7145   echo "$as_me:$LINENO: result: no" >&5
7146 echo "${ECHO_T}no" >&6
7147 fi
7148
7149   fi
7150   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7151     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7152 set dummy ${ncn_progname}; ac_word=$2
7153 echo "$as_me:$LINENO: checking for $ac_word" >&5
7154 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7155 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7156   echo $ECHO_N "(cached) $ECHO_C" >&6
7157 else
7158   if test -n "$DLLTOOL"; then
7159   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7160 else
7161 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7162 for as_dir in $PATH
7163 do
7164   IFS=$as_save_IFS
7165   test -z "$as_dir" && as_dir=.
7166   for ac_exec_ext in '' $ac_executable_extensions; do
7167   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7168     ac_cv_prog_DLLTOOL="${ncn_progname}"
7169     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7170     break 2
7171   fi
7172 done
7173 done
7174
7175 fi
7176 fi
7177 DLLTOOL=$ac_cv_prog_DLLTOOL
7178 if test -n "$DLLTOOL"; then
7179   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7180 echo "${ECHO_T}$DLLTOOL" >&6
7181 else
7182   echo "$as_me:$LINENO: result: no" >&5
7183 echo "${ECHO_T}no" >&6
7184 fi
7185
7186   fi
7187   test -n "$ac_cv_prog_DLLTOOL" && break
7188 done
7189
7190 if test -z "$ac_cv_prog_DLLTOOL" ; then
7191   set dummy dlltool
7192   if test $build = $host ; then
7193     DLLTOOL="$2"
7194   else
7195     DLLTOOL="${ncn_tool_prefix}$2"
7196   fi
7197 fi
7198
7199
7200
7201 if test -n "$LD"; then
7202   ac_cv_prog_LD=$LD
7203 elif test -n "$ac_cv_prog_LD"; then
7204   LD=$ac_cv_prog_LD
7205 fi
7206
7207 if test -n "$ac_cv_prog_LD"; then
7208   for ncn_progname in ld; do
7209     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7210 set dummy ${ncn_progname}; ac_word=$2
7211 echo "$as_me:$LINENO: checking for $ac_word" >&5
7212 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7213 if test "${ac_cv_prog_LD+set}" = set; then
7214   echo $ECHO_N "(cached) $ECHO_C" >&6
7215 else
7216   if test -n "$LD"; then
7217   ac_cv_prog_LD="$LD" # Let the user override the test.
7218 else
7219 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7220 for as_dir in $PATH
7221 do
7222   IFS=$as_save_IFS
7223   test -z "$as_dir" && as_dir=.
7224   for ac_exec_ext in '' $ac_executable_extensions; do
7225   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7226     ac_cv_prog_LD="${ncn_progname}"
7227     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7228     break 2
7229   fi
7230 done
7231 done
7232
7233 fi
7234 fi
7235 LD=$ac_cv_prog_LD
7236 if test -n "$LD"; then
7237   echo "$as_me:$LINENO: result: $LD" >&5
7238 echo "${ECHO_T}$LD" >&6
7239 else
7240   echo "$as_me:$LINENO: result: no" >&5
7241 echo "${ECHO_T}no" >&6
7242 fi
7243
7244   done
7245 fi
7246
7247 for ncn_progname in ld; do
7248   if test -n "$ncn_tool_prefix"; then
7249     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7250 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7251 echo "$as_me:$LINENO: checking for $ac_word" >&5
7252 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7253 if test "${ac_cv_prog_LD+set}" = set; then
7254   echo $ECHO_N "(cached) $ECHO_C" >&6
7255 else
7256   if test -n "$LD"; then
7257   ac_cv_prog_LD="$LD" # Let the user override the test.
7258 else
7259 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7260 for as_dir in $PATH
7261 do
7262   IFS=$as_save_IFS
7263   test -z "$as_dir" && as_dir=.
7264   for ac_exec_ext in '' $ac_executable_extensions; do
7265   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7266     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7267     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7268     break 2
7269   fi
7270 done
7271 done
7272
7273 fi
7274 fi
7275 LD=$ac_cv_prog_LD
7276 if test -n "$LD"; then
7277   echo "$as_me:$LINENO: result: $LD" >&5
7278 echo "${ECHO_T}$LD" >&6
7279 else
7280   echo "$as_me:$LINENO: result: no" >&5
7281 echo "${ECHO_T}no" >&6
7282 fi
7283
7284   fi
7285   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7286     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7287 set dummy ${ncn_progname}; ac_word=$2
7288 echo "$as_me:$LINENO: checking for $ac_word" >&5
7289 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7290 if test "${ac_cv_prog_LD+set}" = set; then
7291   echo $ECHO_N "(cached) $ECHO_C" >&6
7292 else
7293   if test -n "$LD"; then
7294   ac_cv_prog_LD="$LD" # Let the user override the test.
7295 else
7296 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7297 for as_dir in $PATH
7298 do
7299   IFS=$as_save_IFS
7300   test -z "$as_dir" && as_dir=.
7301   for ac_exec_ext in '' $ac_executable_extensions; do
7302   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7303     ac_cv_prog_LD="${ncn_progname}"
7304     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7305     break 2
7306   fi
7307 done
7308 done
7309
7310 fi
7311 fi
7312 LD=$ac_cv_prog_LD
7313 if test -n "$LD"; then
7314   echo "$as_me:$LINENO: result: $LD" >&5
7315 echo "${ECHO_T}$LD" >&6
7316 else
7317   echo "$as_me:$LINENO: result: no" >&5
7318 echo "${ECHO_T}no" >&6
7319 fi
7320
7321   fi
7322   test -n "$ac_cv_prog_LD" && break
7323 done
7324
7325 if test -z "$ac_cv_prog_LD" ; then
7326   set dummy ld
7327   if test $build = $host ; then
7328     LD="$2"
7329   else
7330     LD="${ncn_tool_prefix}$2"
7331   fi
7332 fi
7333
7334
7335
7336 if test -n "$LIPO"; then
7337   ac_cv_prog_LIPO=$LIPO
7338 elif test -n "$ac_cv_prog_LIPO"; then
7339   LIPO=$ac_cv_prog_LIPO
7340 fi
7341
7342 if test -n "$ac_cv_prog_LIPO"; then
7343   for ncn_progname in lipo; do
7344     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7345 set dummy ${ncn_progname}; ac_word=$2
7346 echo "$as_me:$LINENO: checking for $ac_word" >&5
7347 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7348 if test "${ac_cv_prog_LIPO+set}" = set; then
7349   echo $ECHO_N "(cached) $ECHO_C" >&6
7350 else
7351   if test -n "$LIPO"; then
7352   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7353 else
7354 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7355 for as_dir in $PATH
7356 do
7357   IFS=$as_save_IFS
7358   test -z "$as_dir" && as_dir=.
7359   for ac_exec_ext in '' $ac_executable_extensions; do
7360   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7361     ac_cv_prog_LIPO="${ncn_progname}"
7362     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7363     break 2
7364   fi
7365 done
7366 done
7367
7368 fi
7369 fi
7370 LIPO=$ac_cv_prog_LIPO
7371 if test -n "$LIPO"; then
7372   echo "$as_me:$LINENO: result: $LIPO" >&5
7373 echo "${ECHO_T}$LIPO" >&6
7374 else
7375   echo "$as_me:$LINENO: result: no" >&5
7376 echo "${ECHO_T}no" >&6
7377 fi
7378
7379   done
7380 fi
7381
7382 for ncn_progname in lipo; do
7383   if test -n "$ncn_tool_prefix"; then
7384     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7385 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7386 echo "$as_me:$LINENO: checking for $ac_word" >&5
7387 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7388 if test "${ac_cv_prog_LIPO+set}" = set; then
7389   echo $ECHO_N "(cached) $ECHO_C" >&6
7390 else
7391   if test -n "$LIPO"; then
7392   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7393 else
7394 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7395 for as_dir in $PATH
7396 do
7397   IFS=$as_save_IFS
7398   test -z "$as_dir" && as_dir=.
7399   for ac_exec_ext in '' $ac_executable_extensions; do
7400   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7401     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7402     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7403     break 2
7404   fi
7405 done
7406 done
7407
7408 fi
7409 fi
7410 LIPO=$ac_cv_prog_LIPO
7411 if test -n "$LIPO"; then
7412   echo "$as_me:$LINENO: result: $LIPO" >&5
7413 echo "${ECHO_T}$LIPO" >&6
7414 else
7415   echo "$as_me:$LINENO: result: no" >&5
7416 echo "${ECHO_T}no" >&6
7417 fi
7418
7419   fi
7420   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7421     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7422 set dummy ${ncn_progname}; ac_word=$2
7423 echo "$as_me:$LINENO: checking for $ac_word" >&5
7424 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7425 if test "${ac_cv_prog_LIPO+set}" = set; then
7426   echo $ECHO_N "(cached) $ECHO_C" >&6
7427 else
7428   if test -n "$LIPO"; then
7429   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7430 else
7431 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7432 for as_dir in $PATH
7433 do
7434   IFS=$as_save_IFS
7435   test -z "$as_dir" && as_dir=.
7436   for ac_exec_ext in '' $ac_executable_extensions; do
7437   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7438     ac_cv_prog_LIPO="${ncn_progname}"
7439     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7440     break 2
7441   fi
7442 done
7443 done
7444
7445 fi
7446 fi
7447 LIPO=$ac_cv_prog_LIPO
7448 if test -n "$LIPO"; then
7449   echo "$as_me:$LINENO: result: $LIPO" >&5
7450 echo "${ECHO_T}$LIPO" >&6
7451 else
7452   echo "$as_me:$LINENO: result: no" >&5
7453 echo "${ECHO_T}no" >&6
7454 fi
7455
7456   fi
7457   test -n "$ac_cv_prog_LIPO" && break
7458 done
7459
7460 if test -z "$ac_cv_prog_LIPO" ; then
7461   set dummy lipo
7462   if test $build = $host ; then
7463     LIPO="$2"
7464   else
7465     LIPO="${ncn_tool_prefix}$2"
7466   fi
7467 fi
7468
7469
7470
7471 if test -n "$NM"; then
7472   ac_cv_prog_NM=$NM
7473 elif test -n "$ac_cv_prog_NM"; then
7474   NM=$ac_cv_prog_NM
7475 fi
7476
7477 if test -n "$ac_cv_prog_NM"; then
7478   for ncn_progname in nm; do
7479     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7480 set dummy ${ncn_progname}; ac_word=$2
7481 echo "$as_me:$LINENO: checking for $ac_word" >&5
7482 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7483 if test "${ac_cv_prog_NM+set}" = set; then
7484   echo $ECHO_N "(cached) $ECHO_C" >&6
7485 else
7486   if test -n "$NM"; then
7487   ac_cv_prog_NM="$NM" # Let the user override the test.
7488 else
7489 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7490 for as_dir in $PATH
7491 do
7492   IFS=$as_save_IFS
7493   test -z "$as_dir" && as_dir=.
7494   for ac_exec_ext in '' $ac_executable_extensions; do
7495   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7496     ac_cv_prog_NM="${ncn_progname}"
7497     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7498     break 2
7499   fi
7500 done
7501 done
7502
7503 fi
7504 fi
7505 NM=$ac_cv_prog_NM
7506 if test -n "$NM"; then
7507   echo "$as_me:$LINENO: result: $NM" >&5
7508 echo "${ECHO_T}$NM" >&6
7509 else
7510   echo "$as_me:$LINENO: result: no" >&5
7511 echo "${ECHO_T}no" >&6
7512 fi
7513
7514   done
7515 fi
7516
7517 for ncn_progname in nm; do
7518   if test -n "$ncn_tool_prefix"; then
7519     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7520 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7521 echo "$as_me:$LINENO: checking for $ac_word" >&5
7522 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7523 if test "${ac_cv_prog_NM+set}" = set; then
7524   echo $ECHO_N "(cached) $ECHO_C" >&6
7525 else
7526   if test -n "$NM"; then
7527   ac_cv_prog_NM="$NM" # Let the user override the test.
7528 else
7529 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7530 for as_dir in $PATH
7531 do
7532   IFS=$as_save_IFS
7533   test -z "$as_dir" && as_dir=.
7534   for ac_exec_ext in '' $ac_executable_extensions; do
7535   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7536     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7537     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7538     break 2
7539   fi
7540 done
7541 done
7542
7543 fi
7544 fi
7545 NM=$ac_cv_prog_NM
7546 if test -n "$NM"; then
7547   echo "$as_me:$LINENO: result: $NM" >&5
7548 echo "${ECHO_T}$NM" >&6
7549 else
7550   echo "$as_me:$LINENO: result: no" >&5
7551 echo "${ECHO_T}no" >&6
7552 fi
7553
7554   fi
7555   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7556     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7557 set dummy ${ncn_progname}; ac_word=$2
7558 echo "$as_me:$LINENO: checking for $ac_word" >&5
7559 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7560 if test "${ac_cv_prog_NM+set}" = set; then
7561   echo $ECHO_N "(cached) $ECHO_C" >&6
7562 else
7563   if test -n "$NM"; then
7564   ac_cv_prog_NM="$NM" # Let the user override the test.
7565 else
7566 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7567 for as_dir in $PATH
7568 do
7569   IFS=$as_save_IFS
7570   test -z "$as_dir" && as_dir=.
7571   for ac_exec_ext in '' $ac_executable_extensions; do
7572   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7573     ac_cv_prog_NM="${ncn_progname}"
7574     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7575     break 2
7576   fi
7577 done
7578 done
7579
7580 fi
7581 fi
7582 NM=$ac_cv_prog_NM
7583 if test -n "$NM"; then
7584   echo "$as_me:$LINENO: result: $NM" >&5
7585 echo "${ECHO_T}$NM" >&6
7586 else
7587   echo "$as_me:$LINENO: result: no" >&5
7588 echo "${ECHO_T}no" >&6
7589 fi
7590
7591   fi
7592   test -n "$ac_cv_prog_NM" && break
7593 done
7594
7595 if test -z "$ac_cv_prog_NM" ; then
7596   set dummy nm
7597   if test $build = $host ; then
7598     NM="$2"
7599   else
7600     NM="${ncn_tool_prefix}$2"
7601   fi
7602 fi
7603
7604
7605
7606 if test -n "$RANLIB"; then
7607   ac_cv_prog_RANLIB=$RANLIB
7608 elif test -n "$ac_cv_prog_RANLIB"; then
7609   RANLIB=$ac_cv_prog_RANLIB
7610 fi
7611
7612 if test -n "$ac_cv_prog_RANLIB"; then
7613   for ncn_progname in ranlib; do
7614     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7615 set dummy ${ncn_progname}; ac_word=$2
7616 echo "$as_me:$LINENO: checking for $ac_word" >&5
7617 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7618 if test "${ac_cv_prog_RANLIB+set}" = set; then
7619   echo $ECHO_N "(cached) $ECHO_C" >&6
7620 else
7621   if test -n "$RANLIB"; then
7622   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7623 else
7624 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7625 for as_dir in $PATH
7626 do
7627   IFS=$as_save_IFS
7628   test -z "$as_dir" && as_dir=.
7629   for ac_exec_ext in '' $ac_executable_extensions; do
7630   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7631     ac_cv_prog_RANLIB="${ncn_progname}"
7632     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7633     break 2
7634   fi
7635 done
7636 done
7637
7638 fi
7639 fi
7640 RANLIB=$ac_cv_prog_RANLIB
7641 if test -n "$RANLIB"; then
7642   echo "$as_me:$LINENO: result: $RANLIB" >&5
7643 echo "${ECHO_T}$RANLIB" >&6
7644 else
7645   echo "$as_me:$LINENO: result: no" >&5
7646 echo "${ECHO_T}no" >&6
7647 fi
7648
7649   done
7650 fi
7651
7652 for ncn_progname in ranlib; do
7653   if test -n "$ncn_tool_prefix"; then
7654     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7655 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7656 echo "$as_me:$LINENO: checking for $ac_word" >&5
7657 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7658 if test "${ac_cv_prog_RANLIB+set}" = set; then
7659   echo $ECHO_N "(cached) $ECHO_C" >&6
7660 else
7661   if test -n "$RANLIB"; then
7662   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7663 else
7664 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7665 for as_dir in $PATH
7666 do
7667   IFS=$as_save_IFS
7668   test -z "$as_dir" && as_dir=.
7669   for ac_exec_ext in '' $ac_executable_extensions; do
7670   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7671     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7672     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7673     break 2
7674   fi
7675 done
7676 done
7677
7678 fi
7679 fi
7680 RANLIB=$ac_cv_prog_RANLIB
7681 if test -n "$RANLIB"; then
7682   echo "$as_me:$LINENO: result: $RANLIB" >&5
7683 echo "${ECHO_T}$RANLIB" >&6
7684 else
7685   echo "$as_me:$LINENO: result: no" >&5
7686 echo "${ECHO_T}no" >&6
7687 fi
7688
7689   fi
7690   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7691     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7692 set dummy ${ncn_progname}; ac_word=$2
7693 echo "$as_me:$LINENO: checking for $ac_word" >&5
7694 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7695 if test "${ac_cv_prog_RANLIB+set}" = set; then
7696   echo $ECHO_N "(cached) $ECHO_C" >&6
7697 else
7698   if test -n "$RANLIB"; then
7699   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7700 else
7701 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7702 for as_dir in $PATH
7703 do
7704   IFS=$as_save_IFS
7705   test -z "$as_dir" && as_dir=.
7706   for ac_exec_ext in '' $ac_executable_extensions; do
7707   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7708     ac_cv_prog_RANLIB="${ncn_progname}"
7709     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7710     break 2
7711   fi
7712 done
7713 done
7714
7715 fi
7716 fi
7717 RANLIB=$ac_cv_prog_RANLIB
7718 if test -n "$RANLIB"; then
7719   echo "$as_me:$LINENO: result: $RANLIB" >&5
7720 echo "${ECHO_T}$RANLIB" >&6
7721 else
7722   echo "$as_me:$LINENO: result: no" >&5
7723 echo "${ECHO_T}no" >&6
7724 fi
7725
7726   fi
7727   test -n "$ac_cv_prog_RANLIB" && break
7728 done
7729
7730 if test -z "$ac_cv_prog_RANLIB" ; then
7731   RANLIB=":"
7732 fi
7733
7734
7735
7736 if test -n "$STRIP"; then
7737   ac_cv_prog_STRIP=$STRIP
7738 elif test -n "$ac_cv_prog_STRIP"; then
7739   STRIP=$ac_cv_prog_STRIP
7740 fi
7741
7742 if test -n "$ac_cv_prog_STRIP"; then
7743   for ncn_progname in strip; do
7744     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7745 set dummy ${ncn_progname}; ac_word=$2
7746 echo "$as_me:$LINENO: checking for $ac_word" >&5
7747 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7748 if test "${ac_cv_prog_STRIP+set}" = set; then
7749   echo $ECHO_N "(cached) $ECHO_C" >&6
7750 else
7751   if test -n "$STRIP"; then
7752   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7753 else
7754 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7755 for as_dir in $PATH
7756 do
7757   IFS=$as_save_IFS
7758   test -z "$as_dir" && as_dir=.
7759   for ac_exec_ext in '' $ac_executable_extensions; do
7760   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7761     ac_cv_prog_STRIP="${ncn_progname}"
7762     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7763     break 2
7764   fi
7765 done
7766 done
7767
7768 fi
7769 fi
7770 STRIP=$ac_cv_prog_STRIP
7771 if test -n "$STRIP"; then
7772   echo "$as_me:$LINENO: result: $STRIP" >&5
7773 echo "${ECHO_T}$STRIP" >&6
7774 else
7775   echo "$as_me:$LINENO: result: no" >&5
7776 echo "${ECHO_T}no" >&6
7777 fi
7778
7779   done
7780 fi
7781
7782 for ncn_progname in strip; do
7783   if test -n "$ncn_tool_prefix"; then
7784     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7785 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7786 echo "$as_me:$LINENO: checking for $ac_word" >&5
7787 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7788 if test "${ac_cv_prog_STRIP+set}" = set; then
7789   echo $ECHO_N "(cached) $ECHO_C" >&6
7790 else
7791   if test -n "$STRIP"; then
7792   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7793 else
7794 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7795 for as_dir in $PATH
7796 do
7797   IFS=$as_save_IFS
7798   test -z "$as_dir" && as_dir=.
7799   for ac_exec_ext in '' $ac_executable_extensions; do
7800   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7801     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7802     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7803     break 2
7804   fi
7805 done
7806 done
7807
7808 fi
7809 fi
7810 STRIP=$ac_cv_prog_STRIP
7811 if test -n "$STRIP"; then
7812   echo "$as_me:$LINENO: result: $STRIP" >&5
7813 echo "${ECHO_T}$STRIP" >&6
7814 else
7815   echo "$as_me:$LINENO: result: no" >&5
7816 echo "${ECHO_T}no" >&6
7817 fi
7818
7819   fi
7820   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7821     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7822 set dummy ${ncn_progname}; ac_word=$2
7823 echo "$as_me:$LINENO: checking for $ac_word" >&5
7824 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7825 if test "${ac_cv_prog_STRIP+set}" = set; then
7826   echo $ECHO_N "(cached) $ECHO_C" >&6
7827 else
7828   if test -n "$STRIP"; then
7829   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7830 else
7831 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7832 for as_dir in $PATH
7833 do
7834   IFS=$as_save_IFS
7835   test -z "$as_dir" && as_dir=.
7836   for ac_exec_ext in '' $ac_executable_extensions; do
7837   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7838     ac_cv_prog_STRIP="${ncn_progname}"
7839     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7840     break 2
7841   fi
7842 done
7843 done
7844
7845 fi
7846 fi
7847 STRIP=$ac_cv_prog_STRIP
7848 if test -n "$STRIP"; then
7849   echo "$as_me:$LINENO: result: $STRIP" >&5
7850 echo "${ECHO_T}$STRIP" >&6
7851 else
7852   echo "$as_me:$LINENO: result: no" >&5
7853 echo "${ECHO_T}no" >&6
7854 fi
7855
7856   fi
7857   test -n "$ac_cv_prog_STRIP" && break
7858 done
7859
7860 if test -z "$ac_cv_prog_STRIP" ; then
7861   STRIP=":"
7862 fi
7863
7864
7865
7866 if test -n "$WINDRES"; then
7867   ac_cv_prog_WINDRES=$WINDRES
7868 elif test -n "$ac_cv_prog_WINDRES"; then
7869   WINDRES=$ac_cv_prog_WINDRES
7870 fi
7871
7872 if test -n "$ac_cv_prog_WINDRES"; then
7873   for ncn_progname in windres; do
7874     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7875 set dummy ${ncn_progname}; ac_word=$2
7876 echo "$as_me:$LINENO: checking for $ac_word" >&5
7877 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7878 if test "${ac_cv_prog_WINDRES+set}" = set; then
7879   echo $ECHO_N "(cached) $ECHO_C" >&6
7880 else
7881   if test -n "$WINDRES"; then
7882   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7883 else
7884 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7885 for as_dir in $PATH
7886 do
7887   IFS=$as_save_IFS
7888   test -z "$as_dir" && as_dir=.
7889   for ac_exec_ext in '' $ac_executable_extensions; do
7890   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7891     ac_cv_prog_WINDRES="${ncn_progname}"
7892     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7893     break 2
7894   fi
7895 done
7896 done
7897
7898 fi
7899 fi
7900 WINDRES=$ac_cv_prog_WINDRES
7901 if test -n "$WINDRES"; then
7902   echo "$as_me:$LINENO: result: $WINDRES" >&5
7903 echo "${ECHO_T}$WINDRES" >&6
7904 else
7905   echo "$as_me:$LINENO: result: no" >&5
7906 echo "${ECHO_T}no" >&6
7907 fi
7908
7909   done
7910 fi
7911
7912 for ncn_progname in windres; do
7913   if test -n "$ncn_tool_prefix"; then
7914     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7915 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7916 echo "$as_me:$LINENO: checking for $ac_word" >&5
7917 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7918 if test "${ac_cv_prog_WINDRES+set}" = set; then
7919   echo $ECHO_N "(cached) $ECHO_C" >&6
7920 else
7921   if test -n "$WINDRES"; then
7922   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7923 else
7924 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7925 for as_dir in $PATH
7926 do
7927   IFS=$as_save_IFS
7928   test -z "$as_dir" && as_dir=.
7929   for ac_exec_ext in '' $ac_executable_extensions; do
7930   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7931     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7932     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7933     break 2
7934   fi
7935 done
7936 done
7937
7938 fi
7939 fi
7940 WINDRES=$ac_cv_prog_WINDRES
7941 if test -n "$WINDRES"; then
7942   echo "$as_me:$LINENO: result: $WINDRES" >&5
7943 echo "${ECHO_T}$WINDRES" >&6
7944 else
7945   echo "$as_me:$LINENO: result: no" >&5
7946 echo "${ECHO_T}no" >&6
7947 fi
7948
7949   fi
7950   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7951     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7952 set dummy ${ncn_progname}; ac_word=$2
7953 echo "$as_me:$LINENO: checking for $ac_word" >&5
7954 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7955 if test "${ac_cv_prog_WINDRES+set}" = set; then
7956   echo $ECHO_N "(cached) $ECHO_C" >&6
7957 else
7958   if test -n "$WINDRES"; then
7959   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7960 else
7961 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7962 for as_dir in $PATH
7963 do
7964   IFS=$as_save_IFS
7965   test -z "$as_dir" && as_dir=.
7966   for ac_exec_ext in '' $ac_executable_extensions; do
7967   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7968     ac_cv_prog_WINDRES="${ncn_progname}"
7969     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7970     break 2
7971   fi
7972 done
7973 done
7974
7975 fi
7976 fi
7977 WINDRES=$ac_cv_prog_WINDRES
7978 if test -n "$WINDRES"; then
7979   echo "$as_me:$LINENO: result: $WINDRES" >&5
7980 echo "${ECHO_T}$WINDRES" >&6
7981 else
7982   echo "$as_me:$LINENO: result: no" >&5
7983 echo "${ECHO_T}no" >&6
7984 fi
7985
7986   fi
7987   test -n "$ac_cv_prog_WINDRES" && break
7988 done
7989
7990 if test -z "$ac_cv_prog_WINDRES" ; then
7991   set dummy windres
7992   if test $build = $host ; then
7993     WINDRES="$2"
7994   else
7995     WINDRES="${ncn_tool_prefix}$2"
7996   fi
7997 fi
7998
7999
8000
8001 if test -n "$WINDMC"; then
8002   ac_cv_prog_WINDMC=$WINDMC
8003 elif test -n "$ac_cv_prog_WINDMC"; then
8004   WINDMC=$ac_cv_prog_WINDMC
8005 fi
8006
8007 if test -n "$ac_cv_prog_WINDMC"; then
8008   for ncn_progname in windmc; do
8009     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8010 set dummy ${ncn_progname}; ac_word=$2
8011 echo "$as_me:$LINENO: checking for $ac_word" >&5
8012 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8013 if test "${ac_cv_prog_WINDMC+set}" = set; then
8014   echo $ECHO_N "(cached) $ECHO_C" >&6
8015 else
8016   if test -n "$WINDMC"; then
8017   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8018 else
8019 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8020 for as_dir in $PATH
8021 do
8022   IFS=$as_save_IFS
8023   test -z "$as_dir" && as_dir=.
8024   for ac_exec_ext in '' $ac_executable_extensions; do
8025   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8026     ac_cv_prog_WINDMC="${ncn_progname}"
8027     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8028     break 2
8029   fi
8030 done
8031 done
8032
8033 fi
8034 fi
8035 WINDMC=$ac_cv_prog_WINDMC
8036 if test -n "$WINDMC"; then
8037   echo "$as_me:$LINENO: result: $WINDMC" >&5
8038 echo "${ECHO_T}$WINDMC" >&6
8039 else
8040   echo "$as_me:$LINENO: result: no" >&5
8041 echo "${ECHO_T}no" >&6
8042 fi
8043
8044   done
8045 fi
8046
8047 for ncn_progname in windmc; do
8048   if test -n "$ncn_tool_prefix"; then
8049     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8050 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8051 echo "$as_me:$LINENO: checking for $ac_word" >&5
8052 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8053 if test "${ac_cv_prog_WINDMC+set}" = set; then
8054   echo $ECHO_N "(cached) $ECHO_C" >&6
8055 else
8056   if test -n "$WINDMC"; then
8057   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8058 else
8059 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8060 for as_dir in $PATH
8061 do
8062   IFS=$as_save_IFS
8063   test -z "$as_dir" && as_dir=.
8064   for ac_exec_ext in '' $ac_executable_extensions; do
8065   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8066     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8067     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8068     break 2
8069   fi
8070 done
8071 done
8072
8073 fi
8074 fi
8075 WINDMC=$ac_cv_prog_WINDMC
8076 if test -n "$WINDMC"; then
8077   echo "$as_me:$LINENO: result: $WINDMC" >&5
8078 echo "${ECHO_T}$WINDMC" >&6
8079 else
8080   echo "$as_me:$LINENO: result: no" >&5
8081 echo "${ECHO_T}no" >&6
8082 fi
8083
8084   fi
8085   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8086     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8087 set dummy ${ncn_progname}; ac_word=$2
8088 echo "$as_me:$LINENO: checking for $ac_word" >&5
8089 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8090 if test "${ac_cv_prog_WINDMC+set}" = set; then
8091   echo $ECHO_N "(cached) $ECHO_C" >&6
8092 else
8093   if test -n "$WINDMC"; then
8094   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8095 else
8096 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8097 for as_dir in $PATH
8098 do
8099   IFS=$as_save_IFS
8100   test -z "$as_dir" && as_dir=.
8101   for ac_exec_ext in '' $ac_executable_extensions; do
8102   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8103     ac_cv_prog_WINDMC="${ncn_progname}"
8104     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8105     break 2
8106   fi
8107 done
8108 done
8109
8110 fi
8111 fi
8112 WINDMC=$ac_cv_prog_WINDMC
8113 if test -n "$WINDMC"; then
8114   echo "$as_me:$LINENO: result: $WINDMC" >&5
8115 echo "${ECHO_T}$WINDMC" >&6
8116 else
8117   echo "$as_me:$LINENO: result: no" >&5
8118 echo "${ECHO_T}no" >&6
8119 fi
8120
8121   fi
8122   test -n "$ac_cv_prog_WINDMC" && break
8123 done
8124
8125 if test -z "$ac_cv_prog_WINDMC" ; then
8126   set dummy windmc
8127   if test $build = $host ; then
8128     WINDMC="$2"
8129   else
8130     WINDMC="${ncn_tool_prefix}$2"
8131   fi
8132 fi
8133
8134
8135
8136 if test -n "$OBJCOPY"; then
8137   ac_cv_prog_OBJCOPY=$OBJCOPY
8138 elif test -n "$ac_cv_prog_OBJCOPY"; then
8139   OBJCOPY=$ac_cv_prog_OBJCOPY
8140 fi
8141
8142 if test -n "$ac_cv_prog_OBJCOPY"; then
8143   for ncn_progname in objcopy; do
8144     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8145 set dummy ${ncn_progname}; ac_word=$2
8146 echo "$as_me:$LINENO: checking for $ac_word" >&5
8147 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8148 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8149   echo $ECHO_N "(cached) $ECHO_C" >&6
8150 else
8151   if test -n "$OBJCOPY"; then
8152   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8153 else
8154 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8155 for as_dir in $PATH
8156 do
8157   IFS=$as_save_IFS
8158   test -z "$as_dir" && as_dir=.
8159   for ac_exec_ext in '' $ac_executable_extensions; do
8160   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8161     ac_cv_prog_OBJCOPY="${ncn_progname}"
8162     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8163     break 2
8164   fi
8165 done
8166 done
8167
8168 fi
8169 fi
8170 OBJCOPY=$ac_cv_prog_OBJCOPY
8171 if test -n "$OBJCOPY"; then
8172   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8173 echo "${ECHO_T}$OBJCOPY" >&6
8174 else
8175   echo "$as_me:$LINENO: result: no" >&5
8176 echo "${ECHO_T}no" >&6
8177 fi
8178
8179   done
8180 fi
8181
8182 for ncn_progname in objcopy; do
8183   if test -n "$ncn_tool_prefix"; then
8184     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8185 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8186 echo "$as_me:$LINENO: checking for $ac_word" >&5
8187 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8188 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8189   echo $ECHO_N "(cached) $ECHO_C" >&6
8190 else
8191   if test -n "$OBJCOPY"; then
8192   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8193 else
8194 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8195 for as_dir in $PATH
8196 do
8197   IFS=$as_save_IFS
8198   test -z "$as_dir" && as_dir=.
8199   for ac_exec_ext in '' $ac_executable_extensions; do
8200   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8201     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8202     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8203     break 2
8204   fi
8205 done
8206 done
8207
8208 fi
8209 fi
8210 OBJCOPY=$ac_cv_prog_OBJCOPY
8211 if test -n "$OBJCOPY"; then
8212   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8213 echo "${ECHO_T}$OBJCOPY" >&6
8214 else
8215   echo "$as_me:$LINENO: result: no" >&5
8216 echo "${ECHO_T}no" >&6
8217 fi
8218
8219   fi
8220   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8221     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8222 set dummy ${ncn_progname}; ac_word=$2
8223 echo "$as_me:$LINENO: checking for $ac_word" >&5
8224 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8225 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8226   echo $ECHO_N "(cached) $ECHO_C" >&6
8227 else
8228   if test -n "$OBJCOPY"; then
8229   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8230 else
8231 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8232 for as_dir in $PATH
8233 do
8234   IFS=$as_save_IFS
8235   test -z "$as_dir" && as_dir=.
8236   for ac_exec_ext in '' $ac_executable_extensions; do
8237   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8238     ac_cv_prog_OBJCOPY="${ncn_progname}"
8239     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8240     break 2
8241   fi
8242 done
8243 done
8244
8245 fi
8246 fi
8247 OBJCOPY=$ac_cv_prog_OBJCOPY
8248 if test -n "$OBJCOPY"; then
8249   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8250 echo "${ECHO_T}$OBJCOPY" >&6
8251 else
8252   echo "$as_me:$LINENO: result: no" >&5
8253 echo "${ECHO_T}no" >&6
8254 fi
8255
8256   fi
8257   test -n "$ac_cv_prog_OBJCOPY" && break
8258 done
8259
8260 if test -z "$ac_cv_prog_OBJCOPY" ; then
8261   set dummy objcopy
8262   if test $build = $host ; then
8263     OBJCOPY="$2"
8264   else
8265     OBJCOPY="${ncn_tool_prefix}$2"
8266   fi
8267 fi
8268
8269
8270
8271 if test -n "$OBJDUMP"; then
8272   ac_cv_prog_OBJDUMP=$OBJDUMP
8273 elif test -n "$ac_cv_prog_OBJDUMP"; then
8274   OBJDUMP=$ac_cv_prog_OBJDUMP
8275 fi
8276
8277 if test -n "$ac_cv_prog_OBJDUMP"; then
8278   for ncn_progname in objdump; do
8279     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8280 set dummy ${ncn_progname}; ac_word=$2
8281 echo "$as_me:$LINENO: checking for $ac_word" >&5
8282 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8283 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8284   echo $ECHO_N "(cached) $ECHO_C" >&6
8285 else
8286   if test -n "$OBJDUMP"; then
8287   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8288 else
8289 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8290 for as_dir in $PATH
8291 do
8292   IFS=$as_save_IFS
8293   test -z "$as_dir" && as_dir=.
8294   for ac_exec_ext in '' $ac_executable_extensions; do
8295   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8296     ac_cv_prog_OBJDUMP="${ncn_progname}"
8297     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8298     break 2
8299   fi
8300 done
8301 done
8302
8303 fi
8304 fi
8305 OBJDUMP=$ac_cv_prog_OBJDUMP
8306 if test -n "$OBJDUMP"; then
8307   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8308 echo "${ECHO_T}$OBJDUMP" >&6
8309 else
8310   echo "$as_me:$LINENO: result: no" >&5
8311 echo "${ECHO_T}no" >&6
8312 fi
8313
8314   done
8315 fi
8316
8317 for ncn_progname in objdump; do
8318   if test -n "$ncn_tool_prefix"; then
8319     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8320 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8321 echo "$as_me:$LINENO: checking for $ac_word" >&5
8322 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8323 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8324   echo $ECHO_N "(cached) $ECHO_C" >&6
8325 else
8326   if test -n "$OBJDUMP"; then
8327   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8328 else
8329 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8330 for as_dir in $PATH
8331 do
8332   IFS=$as_save_IFS
8333   test -z "$as_dir" && as_dir=.
8334   for ac_exec_ext in '' $ac_executable_extensions; do
8335   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8336     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8337     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8338     break 2
8339   fi
8340 done
8341 done
8342
8343 fi
8344 fi
8345 OBJDUMP=$ac_cv_prog_OBJDUMP
8346 if test -n "$OBJDUMP"; then
8347   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8348 echo "${ECHO_T}$OBJDUMP" >&6
8349 else
8350   echo "$as_me:$LINENO: result: no" >&5
8351 echo "${ECHO_T}no" >&6
8352 fi
8353
8354   fi
8355   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8356     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8357 set dummy ${ncn_progname}; ac_word=$2
8358 echo "$as_me:$LINENO: checking for $ac_word" >&5
8359 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8360 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8361   echo $ECHO_N "(cached) $ECHO_C" >&6
8362 else
8363   if test -n "$OBJDUMP"; then
8364   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8365 else
8366 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8367 for as_dir in $PATH
8368 do
8369   IFS=$as_save_IFS
8370   test -z "$as_dir" && as_dir=.
8371   for ac_exec_ext in '' $ac_executable_extensions; do
8372   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8373     ac_cv_prog_OBJDUMP="${ncn_progname}"
8374     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8375     break 2
8376   fi
8377 done
8378 done
8379
8380 fi
8381 fi
8382 OBJDUMP=$ac_cv_prog_OBJDUMP
8383 if test -n "$OBJDUMP"; then
8384   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8385 echo "${ECHO_T}$OBJDUMP" >&6
8386 else
8387   echo "$as_me:$LINENO: result: no" >&5
8388 echo "${ECHO_T}no" >&6
8389 fi
8390
8391   fi
8392   test -n "$ac_cv_prog_OBJDUMP" && break
8393 done
8394
8395 if test -z "$ac_cv_prog_OBJDUMP" ; then
8396   set dummy objdump
8397   if test $build = $host ; then
8398     OBJDUMP="$2"
8399   else
8400     OBJDUMP="${ncn_tool_prefix}$2"
8401   fi
8402 fi
8403
8404
8405
8406
8407
8408
8409 # Target tools.
8410
8411 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8412 if test "${with_build_time_tools+set}" = set; then
8413   withval="$with_build_time_tools"
8414   case x"$withval" in
8415      x/*) ;;
8416      *)
8417        with_build_time_tools=
8418        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8419 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8420        ;;
8421    esac
8422 else
8423   with_build_time_tools=
8424 fi;
8425
8426
8427
8428 if test -n "$CC_FOR_TARGET"; then
8429   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8430 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8431   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8432 fi
8433
8434 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8435   for ncn_progname in cc gcc; do
8436     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8437 set dummy ${ncn_progname}; ac_word=$2
8438 echo "$as_me:$LINENO: checking for $ac_word" >&5
8439 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8440 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8441   echo $ECHO_N "(cached) $ECHO_C" >&6
8442 else
8443   if test -n "$CC_FOR_TARGET"; then
8444   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8445 else
8446 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8447 for as_dir in $PATH
8448 do
8449   IFS=$as_save_IFS
8450   test -z "$as_dir" && as_dir=.
8451   for ac_exec_ext in '' $ac_executable_extensions; do
8452   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8453     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8454     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8455     break 2
8456   fi
8457 done
8458 done
8459
8460 fi
8461 fi
8462 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8463 if test -n "$CC_FOR_TARGET"; then
8464   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8465 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8466 else
8467   echo "$as_me:$LINENO: result: no" >&5
8468 echo "${ECHO_T}no" >&6
8469 fi
8470
8471   done
8472 fi
8473
8474 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8475   for ncn_progname in cc gcc; do
8476     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8477 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8478     if test -x $with_build_time_tools/${ncn_progname}; then
8479       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8480       echo "$as_me:$LINENO: result: yes" >&5
8481 echo "${ECHO_T}yes" >&6
8482       break
8483     else
8484       echo "$as_me:$LINENO: result: no" >&5
8485 echo "${ECHO_T}no" >&6
8486     fi
8487   done
8488 fi
8489
8490 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8491   for ncn_progname in cc gcc; do
8492     if test -n "$ncn_target_tool_prefix"; then
8493       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8494 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8495 echo "$as_me:$LINENO: checking for $ac_word" >&5
8496 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8497 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8498   echo $ECHO_N "(cached) $ECHO_C" >&6
8499 else
8500   if test -n "$CC_FOR_TARGET"; then
8501   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8502 else
8503 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8504 for as_dir in $PATH
8505 do
8506   IFS=$as_save_IFS
8507   test -z "$as_dir" && as_dir=.
8508   for ac_exec_ext in '' $ac_executable_extensions; do
8509   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8510     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8511     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8512     break 2
8513   fi
8514 done
8515 done
8516
8517 fi
8518 fi
8519 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8520 if test -n "$CC_FOR_TARGET"; then
8521   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8522 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8523 else
8524   echo "$as_me:$LINENO: result: no" >&5
8525 echo "${ECHO_T}no" >&6
8526 fi
8527
8528     fi
8529     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8530       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8531 set dummy ${ncn_progname}; ac_word=$2
8532 echo "$as_me:$LINENO: checking for $ac_word" >&5
8533 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8534 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8535   echo $ECHO_N "(cached) $ECHO_C" >&6
8536 else
8537   if test -n "$CC_FOR_TARGET"; then
8538   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8539 else
8540 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8541 for as_dir in $PATH
8542 do
8543   IFS=$as_save_IFS
8544   test -z "$as_dir" && as_dir=.
8545   for ac_exec_ext in '' $ac_executable_extensions; do
8546   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8547     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8548     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8549     break 2
8550   fi
8551 done
8552 done
8553
8554 fi
8555 fi
8556 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8557 if test -n "$CC_FOR_TARGET"; then
8558   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8559 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8560 else
8561   echo "$as_me:$LINENO: result: no" >&5
8562 echo "${ECHO_T}no" >&6
8563 fi
8564
8565     fi
8566     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8567   done
8568 fi
8569
8570 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8571   set dummy cc gcc
8572   if test $build = $target ; then
8573     CC_FOR_TARGET="$2"
8574   else
8575     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8576   fi
8577 else
8578   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8579 fi
8580
8581
8582
8583 if test -n "$CXX_FOR_TARGET"; then
8584   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8585 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8586   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8587 fi
8588
8589 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8590   for ncn_progname in c++ g++ cxx gxx; do
8591     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8592 set dummy ${ncn_progname}; ac_word=$2
8593 echo "$as_me:$LINENO: checking for $ac_word" >&5
8594 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8595 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8596   echo $ECHO_N "(cached) $ECHO_C" >&6
8597 else
8598   if test -n "$CXX_FOR_TARGET"; then
8599   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8600 else
8601 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8602 for as_dir in $PATH
8603 do
8604   IFS=$as_save_IFS
8605   test -z "$as_dir" && as_dir=.
8606   for ac_exec_ext in '' $ac_executable_extensions; do
8607   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8608     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8609     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8610     break 2
8611   fi
8612 done
8613 done
8614
8615 fi
8616 fi
8617 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8618 if test -n "$CXX_FOR_TARGET"; then
8619   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8620 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8621 else
8622   echo "$as_me:$LINENO: result: no" >&5
8623 echo "${ECHO_T}no" >&6
8624 fi
8625
8626   done
8627 fi
8628
8629 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8630   for ncn_progname in c++ g++ cxx gxx; do
8631     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8632 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8633     if test -x $with_build_time_tools/${ncn_progname}; then
8634       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8635       echo "$as_me:$LINENO: result: yes" >&5
8636 echo "${ECHO_T}yes" >&6
8637       break
8638     else
8639       echo "$as_me:$LINENO: result: no" >&5
8640 echo "${ECHO_T}no" >&6
8641     fi
8642   done
8643 fi
8644
8645 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8646   for ncn_progname in c++ g++ cxx gxx; do
8647     if test -n "$ncn_target_tool_prefix"; then
8648       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8649 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8650 echo "$as_me:$LINENO: checking for $ac_word" >&5
8651 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8652 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8653   echo $ECHO_N "(cached) $ECHO_C" >&6
8654 else
8655   if test -n "$CXX_FOR_TARGET"; then
8656   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8657 else
8658 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8659 for as_dir in $PATH
8660 do
8661   IFS=$as_save_IFS
8662   test -z "$as_dir" && as_dir=.
8663   for ac_exec_ext in '' $ac_executable_extensions; do
8664   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8665     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8666     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8667     break 2
8668   fi
8669 done
8670 done
8671
8672 fi
8673 fi
8674 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8675 if test -n "$CXX_FOR_TARGET"; then
8676   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8677 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8678 else
8679   echo "$as_me:$LINENO: result: no" >&5
8680 echo "${ECHO_T}no" >&6
8681 fi
8682
8683     fi
8684     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8685       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8686 set dummy ${ncn_progname}; ac_word=$2
8687 echo "$as_me:$LINENO: checking for $ac_word" >&5
8688 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8689 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8690   echo $ECHO_N "(cached) $ECHO_C" >&6
8691 else
8692   if test -n "$CXX_FOR_TARGET"; then
8693   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8694 else
8695 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8696 for as_dir in $PATH
8697 do
8698   IFS=$as_save_IFS
8699   test -z "$as_dir" && as_dir=.
8700   for ac_exec_ext in '' $ac_executable_extensions; do
8701   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8702     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8703     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8704     break 2
8705   fi
8706 done
8707 done
8708
8709 fi
8710 fi
8711 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8712 if test -n "$CXX_FOR_TARGET"; then
8713   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8714 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8715 else
8716   echo "$as_me:$LINENO: result: no" >&5
8717 echo "${ECHO_T}no" >&6
8718 fi
8719
8720     fi
8721     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8722   done
8723 fi
8724
8725 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8726   set dummy c++ g++ cxx gxx
8727   if test $build = $target ; then
8728     CXX_FOR_TARGET="$2"
8729   else
8730     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8731   fi
8732 else
8733   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8734 fi
8735
8736
8737
8738 if test -n "$GCC_FOR_TARGET"; then
8739   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8740 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8741   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8742 fi
8743
8744 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8745   for ncn_progname in gcc; do
8746     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8747 set dummy ${ncn_progname}; ac_word=$2
8748 echo "$as_me:$LINENO: checking for $ac_word" >&5
8749 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8750 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8751   echo $ECHO_N "(cached) $ECHO_C" >&6
8752 else
8753   if test -n "$GCC_FOR_TARGET"; then
8754   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8755 else
8756 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8757 for as_dir in $PATH
8758 do
8759   IFS=$as_save_IFS
8760   test -z "$as_dir" && as_dir=.
8761   for ac_exec_ext in '' $ac_executable_extensions; do
8762   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8763     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8764     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8765     break 2
8766   fi
8767 done
8768 done
8769
8770 fi
8771 fi
8772 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8773 if test -n "$GCC_FOR_TARGET"; then
8774   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8775 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8776 else
8777   echo "$as_me:$LINENO: result: no" >&5
8778 echo "${ECHO_T}no" >&6
8779 fi
8780
8781   done
8782 fi
8783
8784 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8785   for ncn_progname in gcc; do
8786     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8787 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8788     if test -x $with_build_time_tools/${ncn_progname}; then
8789       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8790       echo "$as_me:$LINENO: result: yes" >&5
8791 echo "${ECHO_T}yes" >&6
8792       break
8793     else
8794       echo "$as_me:$LINENO: result: no" >&5
8795 echo "${ECHO_T}no" >&6
8796     fi
8797   done
8798 fi
8799
8800 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8801   for ncn_progname in gcc; do
8802     if test -n "$ncn_target_tool_prefix"; then
8803       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8804 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8805 echo "$as_me:$LINENO: checking for $ac_word" >&5
8806 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8807 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8808   echo $ECHO_N "(cached) $ECHO_C" >&6
8809 else
8810   if test -n "$GCC_FOR_TARGET"; then
8811   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8812 else
8813 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8814 for as_dir in $PATH
8815 do
8816   IFS=$as_save_IFS
8817   test -z "$as_dir" && as_dir=.
8818   for ac_exec_ext in '' $ac_executable_extensions; do
8819   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8820     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8821     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8822     break 2
8823   fi
8824 done
8825 done
8826
8827 fi
8828 fi
8829 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8830 if test -n "$GCC_FOR_TARGET"; then
8831   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8832 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8833 else
8834   echo "$as_me:$LINENO: result: no" >&5
8835 echo "${ECHO_T}no" >&6
8836 fi
8837
8838     fi
8839     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8840       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8841 set dummy ${ncn_progname}; ac_word=$2
8842 echo "$as_me:$LINENO: checking for $ac_word" >&5
8843 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8844 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8845   echo $ECHO_N "(cached) $ECHO_C" >&6
8846 else
8847   if test -n "$GCC_FOR_TARGET"; then
8848   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8849 else
8850 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8851 for as_dir in $PATH
8852 do
8853   IFS=$as_save_IFS
8854   test -z "$as_dir" && as_dir=.
8855   for ac_exec_ext in '' $ac_executable_extensions; do
8856   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8857     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8858     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8859     break 2
8860   fi
8861 done
8862 done
8863
8864 fi
8865 fi
8866 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8867 if test -n "$GCC_FOR_TARGET"; then
8868   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8869 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8870 else
8871   echo "$as_me:$LINENO: result: no" >&5
8872 echo "${ECHO_T}no" >&6
8873 fi
8874
8875     fi
8876     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8877   done
8878 fi
8879
8880 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8881   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8882 else
8883   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8884 fi
8885
8886
8887
8888 if test -n "$GCJ_FOR_TARGET"; then
8889   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8890 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8891   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8892 fi
8893
8894 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8895   for ncn_progname in gcj; do
8896     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8897 set dummy ${ncn_progname}; ac_word=$2
8898 echo "$as_me:$LINENO: checking for $ac_word" >&5
8899 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8900 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8901   echo $ECHO_N "(cached) $ECHO_C" >&6
8902 else
8903   if test -n "$GCJ_FOR_TARGET"; then
8904   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8905 else
8906 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8907 for as_dir in $PATH
8908 do
8909   IFS=$as_save_IFS
8910   test -z "$as_dir" && as_dir=.
8911   for ac_exec_ext in '' $ac_executable_extensions; do
8912   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8913     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8914     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8915     break 2
8916   fi
8917 done
8918 done
8919
8920 fi
8921 fi
8922 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8923 if test -n "$GCJ_FOR_TARGET"; then
8924   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8925 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8926 else
8927   echo "$as_me:$LINENO: result: no" >&5
8928 echo "${ECHO_T}no" >&6
8929 fi
8930
8931   done
8932 fi
8933
8934 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8935   for ncn_progname in gcj; do
8936     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8937 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8938     if test -x $with_build_time_tools/${ncn_progname}; then
8939       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8940       echo "$as_me:$LINENO: result: yes" >&5
8941 echo "${ECHO_T}yes" >&6
8942       break
8943     else
8944       echo "$as_me:$LINENO: result: no" >&5
8945 echo "${ECHO_T}no" >&6
8946     fi
8947   done
8948 fi
8949
8950 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8951   for ncn_progname in gcj; do
8952     if test -n "$ncn_target_tool_prefix"; then
8953       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8954 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8955 echo "$as_me:$LINENO: checking for $ac_word" >&5
8956 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8957 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8958   echo $ECHO_N "(cached) $ECHO_C" >&6
8959 else
8960   if test -n "$GCJ_FOR_TARGET"; then
8961   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8962 else
8963 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8964 for as_dir in $PATH
8965 do
8966   IFS=$as_save_IFS
8967   test -z "$as_dir" && as_dir=.
8968   for ac_exec_ext in '' $ac_executable_extensions; do
8969   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8970     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8971     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8972     break 2
8973   fi
8974 done
8975 done
8976
8977 fi
8978 fi
8979 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8980 if test -n "$GCJ_FOR_TARGET"; then
8981   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8982 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8983 else
8984   echo "$as_me:$LINENO: result: no" >&5
8985 echo "${ECHO_T}no" >&6
8986 fi
8987
8988     fi
8989     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8990       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8991 set dummy ${ncn_progname}; ac_word=$2
8992 echo "$as_me:$LINENO: checking for $ac_word" >&5
8993 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8994 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8995   echo $ECHO_N "(cached) $ECHO_C" >&6
8996 else
8997   if test -n "$GCJ_FOR_TARGET"; then
8998   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8999 else
9000 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9001 for as_dir in $PATH
9002 do
9003   IFS=$as_save_IFS
9004   test -z "$as_dir" && as_dir=.
9005   for ac_exec_ext in '' $ac_executable_extensions; do
9006   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9007     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9008     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9009     break 2
9010   fi
9011 done
9012 done
9013
9014 fi
9015 fi
9016 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9017 if test -n "$GCJ_FOR_TARGET"; then
9018   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9019 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9020 else
9021   echo "$as_me:$LINENO: result: no" >&5
9022 echo "${ECHO_T}no" >&6
9023 fi
9024
9025     fi
9026     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
9027   done
9028 fi
9029
9030 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9031   set dummy gcj
9032   if test $build = $target ; then
9033     GCJ_FOR_TARGET="$2"
9034   else
9035     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9036   fi
9037 else
9038   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9039 fi
9040
9041
9042
9043 if test -n "$GFORTRAN_FOR_TARGET"; then
9044   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9045 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9046   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9047 fi
9048
9049 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9050   for ncn_progname in gfortran; do
9051     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9052 set dummy ${ncn_progname}; ac_word=$2
9053 echo "$as_me:$LINENO: checking for $ac_word" >&5
9054 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9055 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9056   echo $ECHO_N "(cached) $ECHO_C" >&6
9057 else
9058   if test -n "$GFORTRAN_FOR_TARGET"; then
9059   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9060 else
9061 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9062 for as_dir in $PATH
9063 do
9064   IFS=$as_save_IFS
9065   test -z "$as_dir" && as_dir=.
9066   for ac_exec_ext in '' $ac_executable_extensions; do
9067   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9068     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9069     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9070     break 2
9071   fi
9072 done
9073 done
9074
9075 fi
9076 fi
9077 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9078 if test -n "$GFORTRAN_FOR_TARGET"; then
9079   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9080 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9081 else
9082   echo "$as_me:$LINENO: result: no" >&5
9083 echo "${ECHO_T}no" >&6
9084 fi
9085
9086   done
9087 fi
9088
9089 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9090   for ncn_progname in gfortran; do
9091     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9092 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9093     if test -x $with_build_time_tools/${ncn_progname}; then
9094       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9095       echo "$as_me:$LINENO: result: yes" >&5
9096 echo "${ECHO_T}yes" >&6
9097       break
9098     else
9099       echo "$as_me:$LINENO: result: no" >&5
9100 echo "${ECHO_T}no" >&6
9101     fi
9102   done
9103 fi
9104
9105 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9106   for ncn_progname in gfortran; do
9107     if test -n "$ncn_target_tool_prefix"; then
9108       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9109 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9110 echo "$as_me:$LINENO: checking for $ac_word" >&5
9111 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9112 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9113   echo $ECHO_N "(cached) $ECHO_C" >&6
9114 else
9115   if test -n "$GFORTRAN_FOR_TARGET"; then
9116   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9117 else
9118 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9119 for as_dir in $PATH
9120 do
9121   IFS=$as_save_IFS
9122   test -z "$as_dir" && as_dir=.
9123   for ac_exec_ext in '' $ac_executable_extensions; do
9124   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9125     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9126     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9127     break 2
9128   fi
9129 done
9130 done
9131
9132 fi
9133 fi
9134 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9135 if test -n "$GFORTRAN_FOR_TARGET"; then
9136   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9137 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9138 else
9139   echo "$as_me:$LINENO: result: no" >&5
9140 echo "${ECHO_T}no" >&6
9141 fi
9142
9143     fi
9144     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9145       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9146 set dummy ${ncn_progname}; ac_word=$2
9147 echo "$as_me:$LINENO: checking for $ac_word" >&5
9148 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9149 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9150   echo $ECHO_N "(cached) $ECHO_C" >&6
9151 else
9152   if test -n "$GFORTRAN_FOR_TARGET"; then
9153   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9154 else
9155 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9156 for as_dir in $PATH
9157 do
9158   IFS=$as_save_IFS
9159   test -z "$as_dir" && as_dir=.
9160   for ac_exec_ext in '' $ac_executable_extensions; do
9161   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9162     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9163     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9164     break 2
9165   fi
9166 done
9167 done
9168
9169 fi
9170 fi
9171 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9172 if test -n "$GFORTRAN_FOR_TARGET"; then
9173   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9174 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9175 else
9176   echo "$as_me:$LINENO: result: no" >&5
9177 echo "${ECHO_T}no" >&6
9178 fi
9179
9180     fi
9181     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9182   done
9183 fi
9184
9185 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9186   set dummy gfortran
9187   if test $build = $target ; then
9188     GFORTRAN_FOR_TARGET="$2"
9189   else
9190     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9191   fi
9192 else
9193   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9194 fi
9195
9196
9197
9198 cat > conftest.c << \EOF
9199 #ifdef __GNUC__
9200   gcc_yay;
9201 #endif
9202 EOF
9203 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9204   have_gcc_for_target=yes
9205 else
9206   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9207   have_gcc_for_target=no
9208 fi
9209 rm conftest.c
9210
9211
9212
9213
9214 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9215   if test -n "$with_build_time_tools"; then
9216     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9217 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9218     if test -x $with_build_time_tools/ar; then
9219       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9220       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9221       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9222 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9223     else
9224       echo "$as_me:$LINENO: result: no" >&5
9225 echo "${ECHO_T}no" >&6
9226     fi
9227   elif test $build != $host && test $have_gcc_for_target = yes; then
9228     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9229     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9230     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9231   fi
9232 fi
9233 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9234   # Extract the first word of "ar", so it can be a program name with args.
9235 set dummy ar; ac_word=$2
9236 echo "$as_me:$LINENO: checking for $ac_word" >&5
9237 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9238 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9239   echo $ECHO_N "(cached) $ECHO_C" >&6
9240 else
9241   case $AR_FOR_TARGET in
9242   [\\/]* | ?:[\\/]*)
9243   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9244   ;;
9245   *)
9246   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9247 for as_dir in $gcc_cv_tool_dirs
9248 do
9249   IFS=$as_save_IFS
9250   test -z "$as_dir" && as_dir=.
9251   for ac_exec_ext in '' $ac_executable_extensions; do
9252   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9253     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9254     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9255     break 2
9256   fi
9257 done
9258 done
9259
9260   ;;
9261 esac
9262 fi
9263 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9264
9265 if test -n "$AR_FOR_TARGET"; then
9266   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9267 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9268 else
9269   echo "$as_me:$LINENO: result: no" >&5
9270 echo "${ECHO_T}no" >&6
9271 fi
9272
9273 fi
9274 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9275
9276
9277 if test -n "$AR_FOR_TARGET"; then
9278   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9279 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9280   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9281 fi
9282
9283 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9284   for ncn_progname in ar; do
9285     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9286 set dummy ${ncn_progname}; ac_word=$2
9287 echo "$as_me:$LINENO: checking for $ac_word" >&5
9288 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9289 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9290   echo $ECHO_N "(cached) $ECHO_C" >&6
9291 else
9292   if test -n "$AR_FOR_TARGET"; then
9293   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9294 else
9295 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9296 for as_dir in $PATH
9297 do
9298   IFS=$as_save_IFS
9299   test -z "$as_dir" && as_dir=.
9300   for ac_exec_ext in '' $ac_executable_extensions; do
9301   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9302     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9303     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9304     break 2
9305   fi
9306 done
9307 done
9308
9309 fi
9310 fi
9311 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9312 if test -n "$AR_FOR_TARGET"; then
9313   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9314 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9315 else
9316   echo "$as_me:$LINENO: result: no" >&5
9317 echo "${ECHO_T}no" >&6
9318 fi
9319
9320   done
9321 fi
9322
9323 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9324   for ncn_progname in ar; do
9325     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9326 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9327     if test -x $with_build_time_tools/${ncn_progname}; then
9328       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9329       echo "$as_me:$LINENO: result: yes" >&5
9330 echo "${ECHO_T}yes" >&6
9331       break
9332     else
9333       echo "$as_me:$LINENO: result: no" >&5
9334 echo "${ECHO_T}no" >&6
9335     fi
9336   done
9337 fi
9338
9339 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9340   for ncn_progname in ar; do
9341     if test -n "$ncn_target_tool_prefix"; then
9342       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9343 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9344 echo "$as_me:$LINENO: checking for $ac_word" >&5
9345 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9346 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9347   echo $ECHO_N "(cached) $ECHO_C" >&6
9348 else
9349   if test -n "$AR_FOR_TARGET"; then
9350   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9351 else
9352 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9353 for as_dir in $PATH
9354 do
9355   IFS=$as_save_IFS
9356   test -z "$as_dir" && as_dir=.
9357   for ac_exec_ext in '' $ac_executable_extensions; do
9358   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9359     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9360     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9361     break 2
9362   fi
9363 done
9364 done
9365
9366 fi
9367 fi
9368 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9369 if test -n "$AR_FOR_TARGET"; then
9370   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9371 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9372 else
9373   echo "$as_me:$LINENO: result: no" >&5
9374 echo "${ECHO_T}no" >&6
9375 fi
9376
9377     fi
9378     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9379       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9380 set dummy ${ncn_progname}; ac_word=$2
9381 echo "$as_me:$LINENO: checking for $ac_word" >&5
9382 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9383 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9384   echo $ECHO_N "(cached) $ECHO_C" >&6
9385 else
9386   if test -n "$AR_FOR_TARGET"; then
9387   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9388 else
9389 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9390 for as_dir in $PATH
9391 do
9392   IFS=$as_save_IFS
9393   test -z "$as_dir" && as_dir=.
9394   for ac_exec_ext in '' $ac_executable_extensions; do
9395   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9396     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9397     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9398     break 2
9399   fi
9400 done
9401 done
9402
9403 fi
9404 fi
9405 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9406 if test -n "$AR_FOR_TARGET"; then
9407   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9408 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9409 else
9410   echo "$as_me:$LINENO: result: no" >&5
9411 echo "${ECHO_T}no" >&6
9412 fi
9413
9414     fi
9415     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9416   done
9417 fi
9418
9419 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9420   set dummy ar
9421   if test $build = $target ; then
9422     AR_FOR_TARGET="$2"
9423   else
9424     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9425   fi
9426 else
9427   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9428 fi
9429
9430 else
9431   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9432 fi
9433
9434
9435
9436
9437 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9438   if test -n "$with_build_time_tools"; then
9439     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9440 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9441     if test -x $with_build_time_tools/as; then
9442       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9443       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9444       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9445 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9446     else
9447       echo "$as_me:$LINENO: result: no" >&5
9448 echo "${ECHO_T}no" >&6
9449     fi
9450   elif test $build != $host && test $have_gcc_for_target = yes; then
9451     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9452     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9453     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9454   fi
9455 fi
9456 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9457   # Extract the first word of "as", so it can be a program name with args.
9458 set dummy as; ac_word=$2
9459 echo "$as_me:$LINENO: checking for $ac_word" >&5
9460 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9461 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9462   echo $ECHO_N "(cached) $ECHO_C" >&6
9463 else
9464   case $AS_FOR_TARGET in
9465   [\\/]* | ?:[\\/]*)
9466   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9467   ;;
9468   *)
9469   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9470 for as_dir in $gcc_cv_tool_dirs
9471 do
9472   IFS=$as_save_IFS
9473   test -z "$as_dir" && as_dir=.
9474   for ac_exec_ext in '' $ac_executable_extensions; do
9475   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9476     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9477     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9478     break 2
9479   fi
9480 done
9481 done
9482
9483   ;;
9484 esac
9485 fi
9486 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9487
9488 if test -n "$AS_FOR_TARGET"; then
9489   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9490 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9491 else
9492   echo "$as_me:$LINENO: result: no" >&5
9493 echo "${ECHO_T}no" >&6
9494 fi
9495
9496 fi
9497 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9498
9499
9500 if test -n "$AS_FOR_TARGET"; then
9501   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9502 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9503   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9504 fi
9505
9506 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9507   for ncn_progname in as; do
9508     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9509 set dummy ${ncn_progname}; ac_word=$2
9510 echo "$as_me:$LINENO: checking for $ac_word" >&5
9511 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9512 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9513   echo $ECHO_N "(cached) $ECHO_C" >&6
9514 else
9515   if test -n "$AS_FOR_TARGET"; then
9516   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9517 else
9518 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9519 for as_dir in $PATH
9520 do
9521   IFS=$as_save_IFS
9522   test -z "$as_dir" && as_dir=.
9523   for ac_exec_ext in '' $ac_executable_extensions; do
9524   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9525     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9526     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9527     break 2
9528   fi
9529 done
9530 done
9531
9532 fi
9533 fi
9534 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9535 if test -n "$AS_FOR_TARGET"; then
9536   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9537 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9538 else
9539   echo "$as_me:$LINENO: result: no" >&5
9540 echo "${ECHO_T}no" >&6
9541 fi
9542
9543   done
9544 fi
9545
9546 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9547   for ncn_progname in as; do
9548     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9549 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9550     if test -x $with_build_time_tools/${ncn_progname}; then
9551       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9552       echo "$as_me:$LINENO: result: yes" >&5
9553 echo "${ECHO_T}yes" >&6
9554       break
9555     else
9556       echo "$as_me:$LINENO: result: no" >&5
9557 echo "${ECHO_T}no" >&6
9558     fi
9559   done
9560 fi
9561
9562 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9563   for ncn_progname in as; do
9564     if test -n "$ncn_target_tool_prefix"; then
9565       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9566 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9567 echo "$as_me:$LINENO: checking for $ac_word" >&5
9568 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9569 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9570   echo $ECHO_N "(cached) $ECHO_C" >&6
9571 else
9572   if test -n "$AS_FOR_TARGET"; then
9573   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9574 else
9575 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9576 for as_dir in $PATH
9577 do
9578   IFS=$as_save_IFS
9579   test -z "$as_dir" && as_dir=.
9580   for ac_exec_ext in '' $ac_executable_extensions; do
9581   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9582     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9583     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9584     break 2
9585   fi
9586 done
9587 done
9588
9589 fi
9590 fi
9591 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9592 if test -n "$AS_FOR_TARGET"; then
9593   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9594 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9595 else
9596   echo "$as_me:$LINENO: result: no" >&5
9597 echo "${ECHO_T}no" >&6
9598 fi
9599
9600     fi
9601     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9602       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9603 set dummy ${ncn_progname}; ac_word=$2
9604 echo "$as_me:$LINENO: checking for $ac_word" >&5
9605 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9606 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9607   echo $ECHO_N "(cached) $ECHO_C" >&6
9608 else
9609   if test -n "$AS_FOR_TARGET"; then
9610   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9611 else
9612 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9613 for as_dir in $PATH
9614 do
9615   IFS=$as_save_IFS
9616   test -z "$as_dir" && as_dir=.
9617   for ac_exec_ext in '' $ac_executable_extensions; do
9618   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9619     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9620     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9621     break 2
9622   fi
9623 done
9624 done
9625
9626 fi
9627 fi
9628 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9629 if test -n "$AS_FOR_TARGET"; then
9630   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9631 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9632 else
9633   echo "$as_me:$LINENO: result: no" >&5
9634 echo "${ECHO_T}no" >&6
9635 fi
9636
9637     fi
9638     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9639   done
9640 fi
9641
9642 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9643   set dummy as
9644   if test $build = $target ; then
9645     AS_FOR_TARGET="$2"
9646   else
9647     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9648   fi
9649 else
9650   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9651 fi
9652
9653 else
9654   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9655 fi
9656
9657
9658
9659
9660 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9661   if test -n "$with_build_time_tools"; then
9662     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9663 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9664     if test -x $with_build_time_tools/dlltool; then
9665       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9666       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9667       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9668 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9669     else
9670       echo "$as_me:$LINENO: result: no" >&5
9671 echo "${ECHO_T}no" >&6
9672     fi
9673   elif test $build != $host && test $have_gcc_for_target = yes; then
9674     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9675     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9676     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9677   fi
9678 fi
9679 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9680   # Extract the first word of "dlltool", so it can be a program name with args.
9681 set dummy dlltool; ac_word=$2
9682 echo "$as_me:$LINENO: checking for $ac_word" >&5
9683 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9684 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9685   echo $ECHO_N "(cached) $ECHO_C" >&6
9686 else
9687   case $DLLTOOL_FOR_TARGET in
9688   [\\/]* | ?:[\\/]*)
9689   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9690   ;;
9691   *)
9692   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9693 for as_dir in $gcc_cv_tool_dirs
9694 do
9695   IFS=$as_save_IFS
9696   test -z "$as_dir" && as_dir=.
9697   for ac_exec_ext in '' $ac_executable_extensions; do
9698   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9699     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9700     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9701     break 2
9702   fi
9703 done
9704 done
9705
9706   ;;
9707 esac
9708 fi
9709 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9710
9711 if test -n "$DLLTOOL_FOR_TARGET"; then
9712   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9713 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9714 else
9715   echo "$as_me:$LINENO: result: no" >&5
9716 echo "${ECHO_T}no" >&6
9717 fi
9718
9719 fi
9720 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9721
9722
9723 if test -n "$DLLTOOL_FOR_TARGET"; then
9724   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9725 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9726   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9727 fi
9728
9729 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9730   for ncn_progname in dlltool; do
9731     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9732 set dummy ${ncn_progname}; ac_word=$2
9733 echo "$as_me:$LINENO: checking for $ac_word" >&5
9734 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9735 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9736   echo $ECHO_N "(cached) $ECHO_C" >&6
9737 else
9738   if test -n "$DLLTOOL_FOR_TARGET"; then
9739   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9740 else
9741 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9742 for as_dir in $PATH
9743 do
9744   IFS=$as_save_IFS
9745   test -z "$as_dir" && as_dir=.
9746   for ac_exec_ext in '' $ac_executable_extensions; do
9747   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9748     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9749     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9750     break 2
9751   fi
9752 done
9753 done
9754
9755 fi
9756 fi
9757 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9758 if test -n "$DLLTOOL_FOR_TARGET"; then
9759   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9760 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9761 else
9762   echo "$as_me:$LINENO: result: no" >&5
9763 echo "${ECHO_T}no" >&6
9764 fi
9765
9766   done
9767 fi
9768
9769 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9770   for ncn_progname in dlltool; do
9771     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9772 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9773     if test -x $with_build_time_tools/${ncn_progname}; then
9774       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9775       echo "$as_me:$LINENO: result: yes" >&5
9776 echo "${ECHO_T}yes" >&6
9777       break
9778     else
9779       echo "$as_me:$LINENO: result: no" >&5
9780 echo "${ECHO_T}no" >&6
9781     fi
9782   done
9783 fi
9784
9785 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9786   for ncn_progname in dlltool; do
9787     if test -n "$ncn_target_tool_prefix"; then
9788       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9789 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9790 echo "$as_me:$LINENO: checking for $ac_word" >&5
9791 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9792 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9793   echo $ECHO_N "(cached) $ECHO_C" >&6
9794 else
9795   if test -n "$DLLTOOL_FOR_TARGET"; then
9796   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9797 else
9798 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9799 for as_dir in $PATH
9800 do
9801   IFS=$as_save_IFS
9802   test -z "$as_dir" && as_dir=.
9803   for ac_exec_ext in '' $ac_executable_extensions; do
9804   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9805     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9806     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9807     break 2
9808   fi
9809 done
9810 done
9811
9812 fi
9813 fi
9814 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9815 if test -n "$DLLTOOL_FOR_TARGET"; then
9816   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9817 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9818 else
9819   echo "$as_me:$LINENO: result: no" >&5
9820 echo "${ECHO_T}no" >&6
9821 fi
9822
9823     fi
9824     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9825       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9826 set dummy ${ncn_progname}; ac_word=$2
9827 echo "$as_me:$LINENO: checking for $ac_word" >&5
9828 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9829 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9830   echo $ECHO_N "(cached) $ECHO_C" >&6
9831 else
9832   if test -n "$DLLTOOL_FOR_TARGET"; then
9833   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9834 else
9835 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9836 for as_dir in $PATH
9837 do
9838   IFS=$as_save_IFS
9839   test -z "$as_dir" && as_dir=.
9840   for ac_exec_ext in '' $ac_executable_extensions; do
9841   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9842     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9843     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9844     break 2
9845   fi
9846 done
9847 done
9848
9849 fi
9850 fi
9851 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9852 if test -n "$DLLTOOL_FOR_TARGET"; then
9853   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9854 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9855 else
9856   echo "$as_me:$LINENO: result: no" >&5
9857 echo "${ECHO_T}no" >&6
9858 fi
9859
9860     fi
9861     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9862   done
9863 fi
9864
9865 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9866   set dummy dlltool
9867   if test $build = $target ; then
9868     DLLTOOL_FOR_TARGET="$2"
9869   else
9870     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9871   fi
9872 else
9873   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9874 fi
9875
9876 else
9877   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9878 fi
9879
9880
9881
9882
9883 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9884   if test -n "$with_build_time_tools"; then
9885     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9886 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9887     if test -x $with_build_time_tools/ld; then
9888       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9889       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9890       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9891 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9892     else
9893       echo "$as_me:$LINENO: result: no" >&5
9894 echo "${ECHO_T}no" >&6
9895     fi
9896   elif test $build != $host && test $have_gcc_for_target = yes; then
9897     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9898     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9899     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9900   fi
9901 fi
9902 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9903   # Extract the first word of "ld", so it can be a program name with args.
9904 set dummy ld; ac_word=$2
9905 echo "$as_me:$LINENO: checking for $ac_word" >&5
9906 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9907 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9908   echo $ECHO_N "(cached) $ECHO_C" >&6
9909 else
9910   case $LD_FOR_TARGET in
9911   [\\/]* | ?:[\\/]*)
9912   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9913   ;;
9914   *)
9915   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9916 for as_dir in $gcc_cv_tool_dirs
9917 do
9918   IFS=$as_save_IFS
9919   test -z "$as_dir" && as_dir=.
9920   for ac_exec_ext in '' $ac_executable_extensions; do
9921   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9922     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9923     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9924     break 2
9925   fi
9926 done
9927 done
9928
9929   ;;
9930 esac
9931 fi
9932 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9933
9934 if test -n "$LD_FOR_TARGET"; then
9935   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9936 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9937 else
9938   echo "$as_me:$LINENO: result: no" >&5
9939 echo "${ECHO_T}no" >&6
9940 fi
9941
9942 fi
9943 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9944
9945
9946 if test -n "$LD_FOR_TARGET"; then
9947   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9948 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9949   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9950 fi
9951
9952 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9953   for ncn_progname in ld; do
9954     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9955 set dummy ${ncn_progname}; ac_word=$2
9956 echo "$as_me:$LINENO: checking for $ac_word" >&5
9957 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9958 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9959   echo $ECHO_N "(cached) $ECHO_C" >&6
9960 else
9961   if test -n "$LD_FOR_TARGET"; then
9962   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9963 else
9964 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9965 for as_dir in $PATH
9966 do
9967   IFS=$as_save_IFS
9968   test -z "$as_dir" && as_dir=.
9969   for ac_exec_ext in '' $ac_executable_extensions; do
9970   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9971     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9972     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9973     break 2
9974   fi
9975 done
9976 done
9977
9978 fi
9979 fi
9980 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9981 if test -n "$LD_FOR_TARGET"; then
9982   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9983 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9984 else
9985   echo "$as_me:$LINENO: result: no" >&5
9986 echo "${ECHO_T}no" >&6
9987 fi
9988
9989   done
9990 fi
9991
9992 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9993   for ncn_progname in ld; do
9994     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9995 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9996     if test -x $with_build_time_tools/${ncn_progname}; then
9997       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9998       echo "$as_me:$LINENO: result: yes" >&5
9999 echo "${ECHO_T}yes" >&6
10000       break
10001     else
10002       echo "$as_me:$LINENO: result: no" >&5
10003 echo "${ECHO_T}no" >&6
10004     fi
10005   done
10006 fi
10007
10008 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
10009   for ncn_progname in ld; do
10010     if test -n "$ncn_target_tool_prefix"; then
10011       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10012 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10013 echo "$as_me:$LINENO: checking for $ac_word" >&5
10014 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10015 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10016   echo $ECHO_N "(cached) $ECHO_C" >&6
10017 else
10018   if test -n "$LD_FOR_TARGET"; then
10019   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10020 else
10021 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10022 for as_dir in $PATH
10023 do
10024   IFS=$as_save_IFS
10025   test -z "$as_dir" && as_dir=.
10026   for ac_exec_ext in '' $ac_executable_extensions; do
10027   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10028     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10029     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10030     break 2
10031   fi
10032 done
10033 done
10034
10035 fi
10036 fi
10037 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10038 if test -n "$LD_FOR_TARGET"; then
10039   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10040 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10041 else
10042   echo "$as_me:$LINENO: result: no" >&5
10043 echo "${ECHO_T}no" >&6
10044 fi
10045
10046     fi
10047     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10048       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10049 set dummy ${ncn_progname}; ac_word=$2
10050 echo "$as_me:$LINENO: checking for $ac_word" >&5
10051 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10052 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10053   echo $ECHO_N "(cached) $ECHO_C" >&6
10054 else
10055   if test -n "$LD_FOR_TARGET"; then
10056   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10057 else
10058 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10059 for as_dir in $PATH
10060 do
10061   IFS=$as_save_IFS
10062   test -z "$as_dir" && as_dir=.
10063   for ac_exec_ext in '' $ac_executable_extensions; do
10064   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10065     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10066     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10067     break 2
10068   fi
10069 done
10070 done
10071
10072 fi
10073 fi
10074 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10075 if test -n "$LD_FOR_TARGET"; then
10076   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10077 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10078 else
10079   echo "$as_me:$LINENO: result: no" >&5
10080 echo "${ECHO_T}no" >&6
10081 fi
10082
10083     fi
10084     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10085   done
10086 fi
10087
10088 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10089   set dummy ld
10090   if test $build = $target ; then
10091     LD_FOR_TARGET="$2"
10092   else
10093     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10094   fi
10095 else
10096   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10097 fi
10098
10099 else
10100   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10101 fi
10102
10103
10104
10105
10106 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10107   if test -n "$with_build_time_tools"; then
10108     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10109 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10110     if test -x $with_build_time_tools/lipo; then
10111       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10112       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10113       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10114 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10115     else
10116       echo "$as_me:$LINENO: result: no" >&5
10117 echo "${ECHO_T}no" >&6
10118     fi
10119   elif test $build != $host && test $have_gcc_for_target = yes; then
10120     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10121     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10122     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10123   fi
10124 fi
10125 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10126   # Extract the first word of "lipo", so it can be a program name with args.
10127 set dummy lipo; ac_word=$2
10128 echo "$as_me:$LINENO: checking for $ac_word" >&5
10129 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10130 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10131   echo $ECHO_N "(cached) $ECHO_C" >&6
10132 else
10133   case $LIPO_FOR_TARGET in
10134   [\\/]* | ?:[\\/]*)
10135   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10136   ;;
10137   *)
10138   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10139 for as_dir in $gcc_cv_tool_dirs
10140 do
10141   IFS=$as_save_IFS
10142   test -z "$as_dir" && as_dir=.
10143   for ac_exec_ext in '' $ac_executable_extensions; do
10144   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10145     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10146     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10147     break 2
10148   fi
10149 done
10150 done
10151
10152   ;;
10153 esac
10154 fi
10155 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10156
10157 if test -n "$LIPO_FOR_TARGET"; then
10158   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10159 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10160 else
10161   echo "$as_me:$LINENO: result: no" >&5
10162 echo "${ECHO_T}no" >&6
10163 fi
10164
10165 fi
10166 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10167
10168
10169 if test -n "$LIPO_FOR_TARGET"; then
10170   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10171 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10172   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10173 fi
10174
10175 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10176   for ncn_progname in lipo; do
10177     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10178 set dummy ${ncn_progname}; ac_word=$2
10179 echo "$as_me:$LINENO: checking for $ac_word" >&5
10180 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10181 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10182   echo $ECHO_N "(cached) $ECHO_C" >&6
10183 else
10184   if test -n "$LIPO_FOR_TARGET"; then
10185   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10186 else
10187 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10188 for as_dir in $PATH
10189 do
10190   IFS=$as_save_IFS
10191   test -z "$as_dir" && as_dir=.
10192   for ac_exec_ext in '' $ac_executable_extensions; do
10193   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10194     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10195     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10196     break 2
10197   fi
10198 done
10199 done
10200
10201 fi
10202 fi
10203 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10204 if test -n "$LIPO_FOR_TARGET"; then
10205   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10206 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10207 else
10208   echo "$as_me:$LINENO: result: no" >&5
10209 echo "${ECHO_T}no" >&6
10210 fi
10211
10212   done
10213 fi
10214
10215 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10216   for ncn_progname in lipo; do
10217     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10218 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10219     if test -x $with_build_time_tools/${ncn_progname}; then
10220       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10221       echo "$as_me:$LINENO: result: yes" >&5
10222 echo "${ECHO_T}yes" >&6
10223       break
10224     else
10225       echo "$as_me:$LINENO: result: no" >&5
10226 echo "${ECHO_T}no" >&6
10227     fi
10228   done
10229 fi
10230
10231 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10232   for ncn_progname in lipo; do
10233     if test -n "$ncn_target_tool_prefix"; then
10234       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10235 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10236 echo "$as_me:$LINENO: checking for $ac_word" >&5
10237 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10238 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10239   echo $ECHO_N "(cached) $ECHO_C" >&6
10240 else
10241   if test -n "$LIPO_FOR_TARGET"; then
10242   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10243 else
10244 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10245 for as_dir in $PATH
10246 do
10247   IFS=$as_save_IFS
10248   test -z "$as_dir" && as_dir=.
10249   for ac_exec_ext in '' $ac_executable_extensions; do
10250   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10251     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10252     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10253     break 2
10254   fi
10255 done
10256 done
10257
10258 fi
10259 fi
10260 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10261 if test -n "$LIPO_FOR_TARGET"; then
10262   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10263 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10264 else
10265   echo "$as_me:$LINENO: result: no" >&5
10266 echo "${ECHO_T}no" >&6
10267 fi
10268
10269     fi
10270     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10271       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10272 set dummy ${ncn_progname}; ac_word=$2
10273 echo "$as_me:$LINENO: checking for $ac_word" >&5
10274 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10275 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10276   echo $ECHO_N "(cached) $ECHO_C" >&6
10277 else
10278   if test -n "$LIPO_FOR_TARGET"; then
10279   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10280 else
10281 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10282 for as_dir in $PATH
10283 do
10284   IFS=$as_save_IFS
10285   test -z "$as_dir" && as_dir=.
10286   for ac_exec_ext in '' $ac_executable_extensions; do
10287   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10288     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10289     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10290     break 2
10291   fi
10292 done
10293 done
10294
10295 fi
10296 fi
10297 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10298 if test -n "$LIPO_FOR_TARGET"; then
10299   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10300 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10301 else
10302   echo "$as_me:$LINENO: result: no" >&5
10303 echo "${ECHO_T}no" >&6
10304 fi
10305
10306     fi
10307     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10308   done
10309 fi
10310
10311 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10312   set dummy lipo
10313   if test $build = $target ; then
10314     LIPO_FOR_TARGET="$2"
10315   else
10316     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10317   fi
10318 else
10319   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10320 fi
10321
10322 else
10323   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10324 fi
10325
10326
10327
10328
10329 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10330   if test -n "$with_build_time_tools"; then
10331     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10332 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10333     if test -x $with_build_time_tools/nm; then
10334       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10335       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10336       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10337 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10338     else
10339       echo "$as_me:$LINENO: result: no" >&5
10340 echo "${ECHO_T}no" >&6
10341     fi
10342   elif test $build != $host && test $have_gcc_for_target = yes; then
10343     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10344     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10345     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10346   fi
10347 fi
10348 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10349   # Extract the first word of "nm", so it can be a program name with args.
10350 set dummy nm; ac_word=$2
10351 echo "$as_me:$LINENO: checking for $ac_word" >&5
10352 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10353 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10354   echo $ECHO_N "(cached) $ECHO_C" >&6
10355 else
10356   case $NM_FOR_TARGET in
10357   [\\/]* | ?:[\\/]*)
10358   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10359   ;;
10360   *)
10361   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10362 for as_dir in $gcc_cv_tool_dirs
10363 do
10364   IFS=$as_save_IFS
10365   test -z "$as_dir" && as_dir=.
10366   for ac_exec_ext in '' $ac_executable_extensions; do
10367   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10368     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10369     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10370     break 2
10371   fi
10372 done
10373 done
10374
10375   ;;
10376 esac
10377 fi
10378 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10379
10380 if test -n "$NM_FOR_TARGET"; then
10381   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10382 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10383 else
10384   echo "$as_me:$LINENO: result: no" >&5
10385 echo "${ECHO_T}no" >&6
10386 fi
10387
10388 fi
10389 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10390
10391
10392 if test -n "$NM_FOR_TARGET"; then
10393   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10394 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10395   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10396 fi
10397
10398 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10399   for ncn_progname in nm; do
10400     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10401 set dummy ${ncn_progname}; ac_word=$2
10402 echo "$as_me:$LINENO: checking for $ac_word" >&5
10403 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10404 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10405   echo $ECHO_N "(cached) $ECHO_C" >&6
10406 else
10407   if test -n "$NM_FOR_TARGET"; then
10408   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10409 else
10410 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10411 for as_dir in $PATH
10412 do
10413   IFS=$as_save_IFS
10414   test -z "$as_dir" && as_dir=.
10415   for ac_exec_ext in '' $ac_executable_extensions; do
10416   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10417     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10418     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10419     break 2
10420   fi
10421 done
10422 done
10423
10424 fi
10425 fi
10426 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10427 if test -n "$NM_FOR_TARGET"; then
10428   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10429 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10430 else
10431   echo "$as_me:$LINENO: result: no" >&5
10432 echo "${ECHO_T}no" >&6
10433 fi
10434
10435   done
10436 fi
10437
10438 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10439   for ncn_progname in nm; do
10440     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10441 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10442     if test -x $with_build_time_tools/${ncn_progname}; then
10443       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10444       echo "$as_me:$LINENO: result: yes" >&5
10445 echo "${ECHO_T}yes" >&6
10446       break
10447     else
10448       echo "$as_me:$LINENO: result: no" >&5
10449 echo "${ECHO_T}no" >&6
10450     fi
10451   done
10452 fi
10453
10454 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10455   for ncn_progname in nm; do
10456     if test -n "$ncn_target_tool_prefix"; then
10457       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10458 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10459 echo "$as_me:$LINENO: checking for $ac_word" >&5
10460 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10461 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10462   echo $ECHO_N "(cached) $ECHO_C" >&6
10463 else
10464   if test -n "$NM_FOR_TARGET"; then
10465   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10466 else
10467 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10468 for as_dir in $PATH
10469 do
10470   IFS=$as_save_IFS
10471   test -z "$as_dir" && as_dir=.
10472   for ac_exec_ext in '' $ac_executable_extensions; do
10473   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10474     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10475     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10476     break 2
10477   fi
10478 done
10479 done
10480
10481 fi
10482 fi
10483 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10484 if test -n "$NM_FOR_TARGET"; then
10485   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10486 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10487 else
10488   echo "$as_me:$LINENO: result: no" >&5
10489 echo "${ECHO_T}no" >&6
10490 fi
10491
10492     fi
10493     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10494       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10495 set dummy ${ncn_progname}; ac_word=$2
10496 echo "$as_me:$LINENO: checking for $ac_word" >&5
10497 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10498 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10499   echo $ECHO_N "(cached) $ECHO_C" >&6
10500 else
10501   if test -n "$NM_FOR_TARGET"; then
10502   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10503 else
10504 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10505 for as_dir in $PATH
10506 do
10507   IFS=$as_save_IFS
10508   test -z "$as_dir" && as_dir=.
10509   for ac_exec_ext in '' $ac_executable_extensions; do
10510   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10511     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10512     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10513     break 2
10514   fi
10515 done
10516 done
10517
10518 fi
10519 fi
10520 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10521 if test -n "$NM_FOR_TARGET"; then
10522   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10523 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10524 else
10525   echo "$as_me:$LINENO: result: no" >&5
10526 echo "${ECHO_T}no" >&6
10527 fi
10528
10529     fi
10530     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10531   done
10532 fi
10533
10534 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10535   set dummy nm
10536   if test $build = $target ; then
10537     NM_FOR_TARGET="$2"
10538   else
10539     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10540   fi
10541 else
10542   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10543 fi
10544
10545 else
10546   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10547 fi
10548
10549
10550
10551
10552 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10553   if test -n "$with_build_time_tools"; then
10554     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10555 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10556     if test -x $with_build_time_tools/objdump; then
10557       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10558       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10559       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10560 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10561     else
10562       echo "$as_me:$LINENO: result: no" >&5
10563 echo "${ECHO_T}no" >&6
10564     fi
10565   elif test $build != $host && test $have_gcc_for_target = yes; then
10566     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10567     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10568     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10569   fi
10570 fi
10571 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10572   # Extract the first word of "objdump", so it can be a program name with args.
10573 set dummy objdump; ac_word=$2
10574 echo "$as_me:$LINENO: checking for $ac_word" >&5
10575 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10576 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10577   echo $ECHO_N "(cached) $ECHO_C" >&6
10578 else
10579   case $OBJDUMP_FOR_TARGET in
10580   [\\/]* | ?:[\\/]*)
10581   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10582   ;;
10583   *)
10584   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10585 for as_dir in $gcc_cv_tool_dirs
10586 do
10587   IFS=$as_save_IFS
10588   test -z "$as_dir" && as_dir=.
10589   for ac_exec_ext in '' $ac_executable_extensions; do
10590   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10591     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10592     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10593     break 2
10594   fi
10595 done
10596 done
10597
10598   ;;
10599 esac
10600 fi
10601 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10602
10603 if test -n "$OBJDUMP_FOR_TARGET"; then
10604   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10605 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10606 else
10607   echo "$as_me:$LINENO: result: no" >&5
10608 echo "${ECHO_T}no" >&6
10609 fi
10610
10611 fi
10612 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10613
10614
10615 if test -n "$OBJDUMP_FOR_TARGET"; then
10616   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10617 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10618   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10619 fi
10620
10621 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10622   for ncn_progname in objdump; do
10623     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10624 set dummy ${ncn_progname}; ac_word=$2
10625 echo "$as_me:$LINENO: checking for $ac_word" >&5
10626 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10627 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10628   echo $ECHO_N "(cached) $ECHO_C" >&6
10629 else
10630   if test -n "$OBJDUMP_FOR_TARGET"; then
10631   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10632 else
10633 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10634 for as_dir in $PATH
10635 do
10636   IFS=$as_save_IFS
10637   test -z "$as_dir" && as_dir=.
10638   for ac_exec_ext in '' $ac_executable_extensions; do
10639   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10640     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10641     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10642     break 2
10643   fi
10644 done
10645 done
10646
10647 fi
10648 fi
10649 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10650 if test -n "$OBJDUMP_FOR_TARGET"; then
10651   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10652 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10653 else
10654   echo "$as_me:$LINENO: result: no" >&5
10655 echo "${ECHO_T}no" >&6
10656 fi
10657
10658   done
10659 fi
10660
10661 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10662   for ncn_progname in objdump; do
10663     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10664 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10665     if test -x $with_build_time_tools/${ncn_progname}; then
10666       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10667       echo "$as_me:$LINENO: result: yes" >&5
10668 echo "${ECHO_T}yes" >&6
10669       break
10670     else
10671       echo "$as_me:$LINENO: result: no" >&5
10672 echo "${ECHO_T}no" >&6
10673     fi
10674   done
10675 fi
10676
10677 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10678   for ncn_progname in objdump; do
10679     if test -n "$ncn_target_tool_prefix"; then
10680       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10681 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10682 echo "$as_me:$LINENO: checking for $ac_word" >&5
10683 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10684 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10685   echo $ECHO_N "(cached) $ECHO_C" >&6
10686 else
10687   if test -n "$OBJDUMP_FOR_TARGET"; then
10688   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10689 else
10690 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10691 for as_dir in $PATH
10692 do
10693   IFS=$as_save_IFS
10694   test -z "$as_dir" && as_dir=.
10695   for ac_exec_ext in '' $ac_executable_extensions; do
10696   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10697     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10698     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10699     break 2
10700   fi
10701 done
10702 done
10703
10704 fi
10705 fi
10706 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10707 if test -n "$OBJDUMP_FOR_TARGET"; then
10708   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10709 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10710 else
10711   echo "$as_me:$LINENO: result: no" >&5
10712 echo "${ECHO_T}no" >&6
10713 fi
10714
10715     fi
10716     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10717       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10718 set dummy ${ncn_progname}; ac_word=$2
10719 echo "$as_me:$LINENO: checking for $ac_word" >&5
10720 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10721 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10722   echo $ECHO_N "(cached) $ECHO_C" >&6
10723 else
10724   if test -n "$OBJDUMP_FOR_TARGET"; then
10725   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10726 else
10727 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10728 for as_dir in $PATH
10729 do
10730   IFS=$as_save_IFS
10731   test -z "$as_dir" && as_dir=.
10732   for ac_exec_ext in '' $ac_executable_extensions; do
10733   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10734     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10735     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10736     break 2
10737   fi
10738 done
10739 done
10740
10741 fi
10742 fi
10743 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10744 if test -n "$OBJDUMP_FOR_TARGET"; then
10745   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10746 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10747 else
10748   echo "$as_me:$LINENO: result: no" >&5
10749 echo "${ECHO_T}no" >&6
10750 fi
10751
10752     fi
10753     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10754   done
10755 fi
10756
10757 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10758   set dummy objdump
10759   if test $build = $target ; then
10760     OBJDUMP_FOR_TARGET="$2"
10761   else
10762     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10763   fi
10764 else
10765   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10766 fi
10767
10768 else
10769   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10770 fi
10771
10772
10773
10774
10775 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10776   if test -n "$with_build_time_tools"; then
10777     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10778 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10779     if test -x $with_build_time_tools/ranlib; then
10780       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10781       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10782       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10783 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10784     else
10785       echo "$as_me:$LINENO: result: no" >&5
10786 echo "${ECHO_T}no" >&6
10787     fi
10788   elif test $build != $host && test $have_gcc_for_target = yes; then
10789     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10790     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10791     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10792   fi
10793 fi
10794 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10795   # Extract the first word of "ranlib", so it can be a program name with args.
10796 set dummy ranlib; ac_word=$2
10797 echo "$as_me:$LINENO: checking for $ac_word" >&5
10798 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10799 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10800   echo $ECHO_N "(cached) $ECHO_C" >&6
10801 else
10802   case $RANLIB_FOR_TARGET in
10803   [\\/]* | ?:[\\/]*)
10804   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10805   ;;
10806   *)
10807   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10808 for as_dir in $gcc_cv_tool_dirs
10809 do
10810   IFS=$as_save_IFS
10811   test -z "$as_dir" && as_dir=.
10812   for ac_exec_ext in '' $ac_executable_extensions; do
10813   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10814     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10815     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10816     break 2
10817   fi
10818 done
10819 done
10820
10821   ;;
10822 esac
10823 fi
10824 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10825
10826 if test -n "$RANLIB_FOR_TARGET"; then
10827   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10828 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10829 else
10830   echo "$as_me:$LINENO: result: no" >&5
10831 echo "${ECHO_T}no" >&6
10832 fi
10833
10834 fi
10835 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10836
10837
10838 if test -n "$RANLIB_FOR_TARGET"; then
10839   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10840 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10841   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10842 fi
10843
10844 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10845   for ncn_progname in ranlib; do
10846     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10847 set dummy ${ncn_progname}; ac_word=$2
10848 echo "$as_me:$LINENO: checking for $ac_word" >&5
10849 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10850 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10851   echo $ECHO_N "(cached) $ECHO_C" >&6
10852 else
10853   if test -n "$RANLIB_FOR_TARGET"; then
10854   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10855 else
10856 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10857 for as_dir in $PATH
10858 do
10859   IFS=$as_save_IFS
10860   test -z "$as_dir" && as_dir=.
10861   for ac_exec_ext in '' $ac_executable_extensions; do
10862   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10863     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10864     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10865     break 2
10866   fi
10867 done
10868 done
10869
10870 fi
10871 fi
10872 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10873 if test -n "$RANLIB_FOR_TARGET"; then
10874   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10875 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10876 else
10877   echo "$as_me:$LINENO: result: no" >&5
10878 echo "${ECHO_T}no" >&6
10879 fi
10880
10881   done
10882 fi
10883
10884 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10885   for ncn_progname in ranlib; do
10886     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10887 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10888     if test -x $with_build_time_tools/${ncn_progname}; then
10889       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10890       echo "$as_me:$LINENO: result: yes" >&5
10891 echo "${ECHO_T}yes" >&6
10892       break
10893     else
10894       echo "$as_me:$LINENO: result: no" >&5
10895 echo "${ECHO_T}no" >&6
10896     fi
10897   done
10898 fi
10899
10900 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10901   for ncn_progname in ranlib; do
10902     if test -n "$ncn_target_tool_prefix"; then
10903       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10904 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10905 echo "$as_me:$LINENO: checking for $ac_word" >&5
10906 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10907 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10908   echo $ECHO_N "(cached) $ECHO_C" >&6
10909 else
10910   if test -n "$RANLIB_FOR_TARGET"; then
10911   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10912 else
10913 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10914 for as_dir in $PATH
10915 do
10916   IFS=$as_save_IFS
10917   test -z "$as_dir" && as_dir=.
10918   for ac_exec_ext in '' $ac_executable_extensions; do
10919   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10920     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10921     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10922     break 2
10923   fi
10924 done
10925 done
10926
10927 fi
10928 fi
10929 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10930 if test -n "$RANLIB_FOR_TARGET"; then
10931   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10932 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10933 else
10934   echo "$as_me:$LINENO: result: no" >&5
10935 echo "${ECHO_T}no" >&6
10936 fi
10937
10938     fi
10939     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10940       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10941 set dummy ${ncn_progname}; ac_word=$2
10942 echo "$as_me:$LINENO: checking for $ac_word" >&5
10943 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10944 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10945   echo $ECHO_N "(cached) $ECHO_C" >&6
10946 else
10947   if test -n "$RANLIB_FOR_TARGET"; then
10948   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10949 else
10950 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10951 for as_dir in $PATH
10952 do
10953   IFS=$as_save_IFS
10954   test -z "$as_dir" && as_dir=.
10955   for ac_exec_ext in '' $ac_executable_extensions; do
10956   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10957     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10958     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10959     break 2
10960   fi
10961 done
10962 done
10963
10964 fi
10965 fi
10966 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10967 if test -n "$RANLIB_FOR_TARGET"; then
10968   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10969 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10970 else
10971   echo "$as_me:$LINENO: result: no" >&5
10972 echo "${ECHO_T}no" >&6
10973 fi
10974
10975     fi
10976     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10977   done
10978 fi
10979
10980 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10981   set dummy ranlib
10982   if test $build = $target ; then
10983     RANLIB_FOR_TARGET="$2"
10984   else
10985     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10986   fi
10987 else
10988   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10989 fi
10990
10991 else
10992   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10993 fi
10994
10995
10996
10997
10998 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10999   if test -n "$with_build_time_tools"; then
11000     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
11001 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
11002     if test -x $with_build_time_tools/strip; then
11003       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
11004       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11005       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
11006 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
11007     else
11008       echo "$as_me:$LINENO: result: no" >&5
11009 echo "${ECHO_T}no" >&6
11010     fi
11011   elif test $build != $host && test $have_gcc_for_target = yes; then
11012     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
11013     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
11014     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11015   fi
11016 fi
11017 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11018   # Extract the first word of "strip", so it can be a program name with args.
11019 set dummy strip; ac_word=$2
11020 echo "$as_me:$LINENO: checking for $ac_word" >&5
11021 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11022 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
11023   echo $ECHO_N "(cached) $ECHO_C" >&6
11024 else
11025   case $STRIP_FOR_TARGET in
11026   [\\/]* | ?:[\\/]*)
11027   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
11028   ;;
11029   *)
11030   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11031 for as_dir in $gcc_cv_tool_dirs
11032 do
11033   IFS=$as_save_IFS
11034   test -z "$as_dir" && as_dir=.
11035   for ac_exec_ext in '' $ac_executable_extensions; do
11036   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11037     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11038     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11039     break 2
11040   fi
11041 done
11042 done
11043
11044   ;;
11045 esac
11046 fi
11047 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11048
11049 if test -n "$STRIP_FOR_TARGET"; then
11050   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11051 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11052 else
11053   echo "$as_me:$LINENO: result: no" >&5
11054 echo "${ECHO_T}no" >&6
11055 fi
11056
11057 fi
11058 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11059
11060
11061 if test -n "$STRIP_FOR_TARGET"; then
11062   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11063 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11064   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11065 fi
11066
11067 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11068   for ncn_progname in strip; do
11069     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11070 set dummy ${ncn_progname}; ac_word=$2
11071 echo "$as_me:$LINENO: checking for $ac_word" >&5
11072 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11073 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11074   echo $ECHO_N "(cached) $ECHO_C" >&6
11075 else
11076   if test -n "$STRIP_FOR_TARGET"; then
11077   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11078 else
11079 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11080 for as_dir in $PATH
11081 do
11082   IFS=$as_save_IFS
11083   test -z "$as_dir" && as_dir=.
11084   for ac_exec_ext in '' $ac_executable_extensions; do
11085   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11086     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11087     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11088     break 2
11089   fi
11090 done
11091 done
11092
11093 fi
11094 fi
11095 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11096 if test -n "$STRIP_FOR_TARGET"; then
11097   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11098 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11099 else
11100   echo "$as_me:$LINENO: result: no" >&5
11101 echo "${ECHO_T}no" >&6
11102 fi
11103
11104   done
11105 fi
11106
11107 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11108   for ncn_progname in strip; do
11109     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11110 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11111     if test -x $with_build_time_tools/${ncn_progname}; then
11112       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11113       echo "$as_me:$LINENO: result: yes" >&5
11114 echo "${ECHO_T}yes" >&6
11115       break
11116     else
11117       echo "$as_me:$LINENO: result: no" >&5
11118 echo "${ECHO_T}no" >&6
11119     fi
11120   done
11121 fi
11122
11123 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11124   for ncn_progname in strip; do
11125     if test -n "$ncn_target_tool_prefix"; then
11126       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11127 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11128 echo "$as_me:$LINENO: checking for $ac_word" >&5
11129 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11130 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11131   echo $ECHO_N "(cached) $ECHO_C" >&6
11132 else
11133   if test -n "$STRIP_FOR_TARGET"; then
11134   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11135 else
11136 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11137 for as_dir in $PATH
11138 do
11139   IFS=$as_save_IFS
11140   test -z "$as_dir" && as_dir=.
11141   for ac_exec_ext in '' $ac_executable_extensions; do
11142   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11143     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11144     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11145     break 2
11146   fi
11147 done
11148 done
11149
11150 fi
11151 fi
11152 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11153 if test -n "$STRIP_FOR_TARGET"; then
11154   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11155 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11156 else
11157   echo "$as_me:$LINENO: result: no" >&5
11158 echo "${ECHO_T}no" >&6
11159 fi
11160
11161     fi
11162     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11163       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11164 set dummy ${ncn_progname}; ac_word=$2
11165 echo "$as_me:$LINENO: checking for $ac_word" >&5
11166 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11167 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11168   echo $ECHO_N "(cached) $ECHO_C" >&6
11169 else
11170   if test -n "$STRIP_FOR_TARGET"; then
11171   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11172 else
11173 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11174 for as_dir in $PATH
11175 do
11176   IFS=$as_save_IFS
11177   test -z "$as_dir" && as_dir=.
11178   for ac_exec_ext in '' $ac_executable_extensions; do
11179   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11180     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11181     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11182     break 2
11183   fi
11184 done
11185 done
11186
11187 fi
11188 fi
11189 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11190 if test -n "$STRIP_FOR_TARGET"; then
11191   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11192 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11193 else
11194   echo "$as_me:$LINENO: result: no" >&5
11195 echo "${ECHO_T}no" >&6
11196 fi
11197
11198     fi
11199     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11200   done
11201 fi
11202
11203 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11204   set dummy strip
11205   if test $build = $target ; then
11206     STRIP_FOR_TARGET="$2"
11207   else
11208     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11209   fi
11210 else
11211   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11212 fi
11213
11214 else
11215   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11216 fi
11217
11218
11219
11220
11221 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11222   if test -n "$with_build_time_tools"; then
11223     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11224 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11225     if test -x $with_build_time_tools/windres; then
11226       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11227       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11228       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11229 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11230     else
11231       echo "$as_me:$LINENO: result: no" >&5
11232 echo "${ECHO_T}no" >&6
11233     fi
11234   elif test $build != $host && test $have_gcc_for_target = yes; then
11235     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11236     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11237     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11238   fi
11239 fi
11240 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11241   # Extract the first word of "windres", so it can be a program name with args.
11242 set dummy windres; ac_word=$2
11243 echo "$as_me:$LINENO: checking for $ac_word" >&5
11244 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11245 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11246   echo $ECHO_N "(cached) $ECHO_C" >&6
11247 else
11248   case $WINDRES_FOR_TARGET in
11249   [\\/]* | ?:[\\/]*)
11250   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11251   ;;
11252   *)
11253   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11254 for as_dir in $gcc_cv_tool_dirs
11255 do
11256   IFS=$as_save_IFS
11257   test -z "$as_dir" && as_dir=.
11258   for ac_exec_ext in '' $ac_executable_extensions; do
11259   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11260     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11261     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11262     break 2
11263   fi
11264 done
11265 done
11266
11267   ;;
11268 esac
11269 fi
11270 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11271
11272 if test -n "$WINDRES_FOR_TARGET"; then
11273   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11274 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11275 else
11276   echo "$as_me:$LINENO: result: no" >&5
11277 echo "${ECHO_T}no" >&6
11278 fi
11279
11280 fi
11281 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11282
11283
11284 if test -n "$WINDRES_FOR_TARGET"; then
11285   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11286 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11287   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11288 fi
11289
11290 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11291   for ncn_progname in windres; do
11292     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11293 set dummy ${ncn_progname}; ac_word=$2
11294 echo "$as_me:$LINENO: checking for $ac_word" >&5
11295 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11296 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11297   echo $ECHO_N "(cached) $ECHO_C" >&6
11298 else
11299   if test -n "$WINDRES_FOR_TARGET"; then
11300   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11301 else
11302 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11303 for as_dir in $PATH
11304 do
11305   IFS=$as_save_IFS
11306   test -z "$as_dir" && as_dir=.
11307   for ac_exec_ext in '' $ac_executable_extensions; do
11308   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11309     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11310     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11311     break 2
11312   fi
11313 done
11314 done
11315
11316 fi
11317 fi
11318 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11319 if test -n "$WINDRES_FOR_TARGET"; then
11320   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11321 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11322 else
11323   echo "$as_me:$LINENO: result: no" >&5
11324 echo "${ECHO_T}no" >&6
11325 fi
11326
11327   done
11328 fi
11329
11330 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11331   for ncn_progname in windres; do
11332     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11333 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11334     if test -x $with_build_time_tools/${ncn_progname}; then
11335       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11336       echo "$as_me:$LINENO: result: yes" >&5
11337 echo "${ECHO_T}yes" >&6
11338       break
11339     else
11340       echo "$as_me:$LINENO: result: no" >&5
11341 echo "${ECHO_T}no" >&6
11342     fi
11343   done
11344 fi
11345
11346 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11347   for ncn_progname in windres; do
11348     if test -n "$ncn_target_tool_prefix"; then
11349       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11350 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11351 echo "$as_me:$LINENO: checking for $ac_word" >&5
11352 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11353 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11354   echo $ECHO_N "(cached) $ECHO_C" >&6
11355 else
11356   if test -n "$WINDRES_FOR_TARGET"; then
11357   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11358 else
11359 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11360 for as_dir in $PATH
11361 do
11362   IFS=$as_save_IFS
11363   test -z "$as_dir" && as_dir=.
11364   for ac_exec_ext in '' $ac_executable_extensions; do
11365   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11366     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11367     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11368     break 2
11369   fi
11370 done
11371 done
11372
11373 fi
11374 fi
11375 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11376 if test -n "$WINDRES_FOR_TARGET"; then
11377   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11378 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11379 else
11380   echo "$as_me:$LINENO: result: no" >&5
11381 echo "${ECHO_T}no" >&6
11382 fi
11383
11384     fi
11385     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11386       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11387 set dummy ${ncn_progname}; ac_word=$2
11388 echo "$as_me:$LINENO: checking for $ac_word" >&5
11389 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11390 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11391   echo $ECHO_N "(cached) $ECHO_C" >&6
11392 else
11393   if test -n "$WINDRES_FOR_TARGET"; then
11394   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11395 else
11396 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11397 for as_dir in $PATH
11398 do
11399   IFS=$as_save_IFS
11400   test -z "$as_dir" && as_dir=.
11401   for ac_exec_ext in '' $ac_executable_extensions; do
11402   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11403     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11404     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11405     break 2
11406   fi
11407 done
11408 done
11409
11410 fi
11411 fi
11412 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11413 if test -n "$WINDRES_FOR_TARGET"; then
11414   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11415 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11416 else
11417   echo "$as_me:$LINENO: result: no" >&5
11418 echo "${ECHO_T}no" >&6
11419 fi
11420
11421     fi
11422     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11423   done
11424 fi
11425
11426 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11427   set dummy windres
11428   if test $build = $target ; then
11429     WINDRES_FOR_TARGET="$2"
11430   else
11431     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11432   fi
11433 else
11434   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11435 fi
11436
11437 else
11438   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11439 fi
11440
11441
11442
11443
11444 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11445   if test -n "$with_build_time_tools"; then
11446     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11447 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11448     if test -x $with_build_time_tools/windmc; then
11449       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11450       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11451       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11452 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11453     else
11454       echo "$as_me:$LINENO: result: no" >&5
11455 echo "${ECHO_T}no" >&6
11456     fi
11457   elif test $build != $host && test $have_gcc_for_target = yes; then
11458     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11459     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11460     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11461   fi
11462 fi
11463 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11464   # Extract the first word of "windmc", so it can be a program name with args.
11465 set dummy windmc; ac_word=$2
11466 echo "$as_me:$LINENO: checking for $ac_word" >&5
11467 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11468 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11469   echo $ECHO_N "(cached) $ECHO_C" >&6
11470 else
11471   case $WINDMC_FOR_TARGET in
11472   [\\/]* | ?:[\\/]*)
11473   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11474   ;;
11475   *)
11476   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11477 for as_dir in $gcc_cv_tool_dirs
11478 do
11479   IFS=$as_save_IFS
11480   test -z "$as_dir" && as_dir=.
11481   for ac_exec_ext in '' $ac_executable_extensions; do
11482   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11483     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11484     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11485     break 2
11486   fi
11487 done
11488 done
11489
11490   ;;
11491 esac
11492 fi
11493 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11494
11495 if test -n "$WINDMC_FOR_TARGET"; then
11496   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11497 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11498 else
11499   echo "$as_me:$LINENO: result: no" >&5
11500 echo "${ECHO_T}no" >&6
11501 fi
11502
11503 fi
11504 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11505
11506
11507 if test -n "$WINDMC_FOR_TARGET"; then
11508   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11509 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11510   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11511 fi
11512
11513 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11514   for ncn_progname in windmc; do
11515     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11516 set dummy ${ncn_progname}; ac_word=$2
11517 echo "$as_me:$LINENO: checking for $ac_word" >&5
11518 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11519 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11520   echo $ECHO_N "(cached) $ECHO_C" >&6
11521 else
11522   if test -n "$WINDMC_FOR_TARGET"; then
11523   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11524 else
11525 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11526 for as_dir in $PATH
11527 do
11528   IFS=$as_save_IFS
11529   test -z "$as_dir" && as_dir=.
11530   for ac_exec_ext in '' $ac_executable_extensions; do
11531   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11532     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11533     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11534     break 2
11535   fi
11536 done
11537 done
11538
11539 fi
11540 fi
11541 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11542 if test -n "$WINDMC_FOR_TARGET"; then
11543   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11544 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11545 else
11546   echo "$as_me:$LINENO: result: no" >&5
11547 echo "${ECHO_T}no" >&6
11548 fi
11549
11550   done
11551 fi
11552
11553 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11554   for ncn_progname in windmc; do
11555     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11556 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11557     if test -x $with_build_time_tools/${ncn_progname}; then
11558       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11559       echo "$as_me:$LINENO: result: yes" >&5
11560 echo "${ECHO_T}yes" >&6
11561       break
11562     else
11563       echo "$as_me:$LINENO: result: no" >&5
11564 echo "${ECHO_T}no" >&6
11565     fi
11566   done
11567 fi
11568
11569 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11570   for ncn_progname in windmc; do
11571     if test -n "$ncn_target_tool_prefix"; then
11572       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11573 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11574 echo "$as_me:$LINENO: checking for $ac_word" >&5
11575 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11576 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11577   echo $ECHO_N "(cached) $ECHO_C" >&6
11578 else
11579   if test -n "$WINDMC_FOR_TARGET"; then
11580   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11581 else
11582 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11583 for as_dir in $PATH
11584 do
11585   IFS=$as_save_IFS
11586   test -z "$as_dir" && as_dir=.
11587   for ac_exec_ext in '' $ac_executable_extensions; do
11588   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11589     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11590     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11591     break 2
11592   fi
11593 done
11594 done
11595
11596 fi
11597 fi
11598 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11599 if test -n "$WINDMC_FOR_TARGET"; then
11600   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11601 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11602 else
11603   echo "$as_me:$LINENO: result: no" >&5
11604 echo "${ECHO_T}no" >&6
11605 fi
11606
11607     fi
11608     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11609       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11610 set dummy ${ncn_progname}; ac_word=$2
11611 echo "$as_me:$LINENO: checking for $ac_word" >&5
11612 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11613 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11614   echo $ECHO_N "(cached) $ECHO_C" >&6
11615 else
11616   if test -n "$WINDMC_FOR_TARGET"; then
11617   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11618 else
11619 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11620 for as_dir in $PATH
11621 do
11622   IFS=$as_save_IFS
11623   test -z "$as_dir" && as_dir=.
11624   for ac_exec_ext in '' $ac_executable_extensions; do
11625   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11626     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11627     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11628     break 2
11629   fi
11630 done
11631 done
11632
11633 fi
11634 fi
11635 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11636 if test -n "$WINDMC_FOR_TARGET"; then
11637   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11638 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11639 else
11640   echo "$as_me:$LINENO: result: no" >&5
11641 echo "${ECHO_T}no" >&6
11642 fi
11643
11644     fi
11645     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11646   done
11647 fi
11648
11649 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11650   set dummy windmc
11651   if test $build = $target ; then
11652     WINDMC_FOR_TARGET="$2"
11653   else
11654     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11655   fi
11656 else
11657   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11658 fi
11659
11660 else
11661   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11662 fi
11663
11664
11665 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11666
11667 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11668 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11669 if test "x${build}" != "x${host}" ; then
11670   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11671     # We already found the complete path
11672     ac_dir=`dirname $AR_FOR_TARGET`
11673     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11674 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11675   else
11676     # Canadian cross, just use what we found
11677     echo "$as_me:$LINENO: result: pre-installed" >&5
11678 echo "${ECHO_T}pre-installed" >&6
11679   fi
11680 else
11681   ok=yes
11682   case " ${configdirs} " in
11683     *" binutils "*) ;;
11684     *) ok=no ;;
11685   esac
11686
11687   if test $ok = yes; then
11688     # An in-tree tool is available and we can use it
11689     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11690     echo "$as_me:$LINENO: result: just compiled" >&5
11691 echo "${ECHO_T}just compiled" >&6
11692   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11693     # We already found the complete path
11694     ac_dir=`dirname $AR_FOR_TARGET`
11695     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11696 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11697   elif test "x$target" = "x$host"; then
11698     # We can use an host tool
11699     AR_FOR_TARGET='$(AR)'
11700     echo "$as_me:$LINENO: result: host tool" >&5
11701 echo "${ECHO_T}host tool" >&6
11702   else
11703     # We need a cross tool
11704     echo "$as_me:$LINENO: result: pre-installed" >&5
11705 echo "${ECHO_T}pre-installed" >&6
11706   fi
11707 fi
11708
11709 echo "$as_me:$LINENO: checking where to find the target as" >&5
11710 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11711 if test "x${build}" != "x${host}" ; then
11712   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11713     # We already found the complete path
11714     ac_dir=`dirname $AS_FOR_TARGET`
11715     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11716 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11717   else
11718     # Canadian cross, just use what we found
11719     echo "$as_me:$LINENO: result: pre-installed" >&5
11720 echo "${ECHO_T}pre-installed" >&6
11721   fi
11722 else
11723   ok=yes
11724   case " ${configdirs} " in
11725     *" gas "*) ;;
11726     *) ok=no ;;
11727   esac
11728
11729   if test $ok = yes; then
11730     # An in-tree tool is available and we can use it
11731     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11732     echo "$as_me:$LINENO: result: just compiled" >&5
11733 echo "${ECHO_T}just compiled" >&6
11734   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11735     # We already found the complete path
11736     ac_dir=`dirname $AS_FOR_TARGET`
11737     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11738 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11739   elif test "x$target" = "x$host"; then
11740     # We can use an host tool
11741     AS_FOR_TARGET='$(AS)'
11742     echo "$as_me:$LINENO: result: host tool" >&5
11743 echo "${ECHO_T}host tool" >&6
11744   else
11745     # We need a cross tool
11746     echo "$as_me:$LINENO: result: pre-installed" >&5
11747 echo "${ECHO_T}pre-installed" >&6
11748   fi
11749 fi
11750
11751 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11752 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11753 if test "x${build}" != "x${host}" ; then
11754   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11755     # We already found the complete path
11756     ac_dir=`dirname $CC_FOR_TARGET`
11757     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11758 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11759   else
11760     # Canadian cross, just use what we found
11761     echo "$as_me:$LINENO: result: pre-installed" >&5
11762 echo "${ECHO_T}pre-installed" >&6
11763   fi
11764 else
11765   ok=yes
11766   case " ${configdirs} " in
11767     *" gcc "*) ;;
11768     *) ok=no ;;
11769   esac
11770
11771   if test $ok = yes; then
11772     # An in-tree tool is available and we can use it
11773     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11774     echo "$as_me:$LINENO: result: just compiled" >&5
11775 echo "${ECHO_T}just compiled" >&6
11776   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11777     # We already found the complete path
11778     ac_dir=`dirname $CC_FOR_TARGET`
11779     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11780 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11781   elif test "x$target" = "x$host"; then
11782     # We can use an host tool
11783     CC_FOR_TARGET='$(CC)'
11784     echo "$as_me:$LINENO: result: host tool" >&5
11785 echo "${ECHO_T}host tool" >&6
11786   else
11787     # We need a cross tool
11788     echo "$as_me:$LINENO: result: pre-installed" >&5
11789 echo "${ECHO_T}pre-installed" >&6
11790   fi
11791 fi
11792
11793 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11794 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11795 if test "x${build}" != "x${host}" ; then
11796   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11797     # We already found the complete path
11798     ac_dir=`dirname $CXX_FOR_TARGET`
11799     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11800 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11801   else
11802     # Canadian cross, just use what we found
11803     echo "$as_me:$LINENO: result: pre-installed" >&5
11804 echo "${ECHO_T}pre-installed" >&6
11805   fi
11806 else
11807   ok=yes
11808   case " ${configdirs} " in
11809     *" gcc "*) ;;
11810     *) ok=no ;;
11811   esac
11812   case ,${enable_languages}, in
11813     *,c++,*) ;;
11814     *) ok=no ;;
11815   esac
11816   if test $ok = yes; then
11817     # An in-tree tool is available and we can use it
11818     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'
11819     echo "$as_me:$LINENO: result: just compiled" >&5
11820 echo "${ECHO_T}just compiled" >&6
11821   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11822     # We already found the complete path
11823     ac_dir=`dirname $CXX_FOR_TARGET`
11824     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11825 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11826   elif test "x$target" = "x$host"; then
11827     # We can use an host tool
11828     CXX_FOR_TARGET='$(CXX)'
11829     echo "$as_me:$LINENO: result: host tool" >&5
11830 echo "${ECHO_T}host tool" >&6
11831   else
11832     # We need a cross tool
11833     echo "$as_me:$LINENO: result: pre-installed" >&5
11834 echo "${ECHO_T}pre-installed" >&6
11835   fi
11836 fi
11837
11838 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11839 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11840 if test "x${build}" != "x${host}" ; then
11841   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11842     # We already found the complete path
11843     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11844     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11845 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11846   else
11847     # Canadian cross, just use what we found
11848     echo "$as_me:$LINENO: result: pre-installed" >&5
11849 echo "${ECHO_T}pre-installed" >&6
11850   fi
11851 else
11852   ok=yes
11853   case " ${configdirs} " in
11854     *" gcc "*) ;;
11855     *) ok=no ;;
11856   esac
11857   case ,${enable_languages}, in
11858     *,c++,*) ;;
11859     *) ok=no ;;
11860   esac
11861   if test $ok = yes; then
11862     # An in-tree tool is available and we can use it
11863     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'
11864     echo "$as_me:$LINENO: result: just compiled" >&5
11865 echo "${ECHO_T}just compiled" >&6
11866   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11867     # We already found the complete path
11868     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11869     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11870 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11871   elif test "x$target" = "x$host"; then
11872     # We can use an host tool
11873     RAW_CXX_FOR_TARGET='$(CXX)'
11874     echo "$as_me:$LINENO: result: host tool" >&5
11875 echo "${ECHO_T}host tool" >&6
11876   else
11877     # We need a cross tool
11878     echo "$as_me:$LINENO: result: pre-installed" >&5
11879 echo "${ECHO_T}pre-installed" >&6
11880   fi
11881 fi
11882
11883 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11884 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11885 if test "x${build}" != "x${host}" ; then
11886   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11887     # We already found the complete path
11888     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11889     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11890 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11891   else
11892     # Canadian cross, just use what we found
11893     echo "$as_me:$LINENO: result: pre-installed" >&5
11894 echo "${ECHO_T}pre-installed" >&6
11895   fi
11896 else
11897   ok=yes
11898   case " ${configdirs} " in
11899     *" binutils "*) ;;
11900     *) ok=no ;;
11901   esac
11902
11903   if test $ok = yes; then
11904     # An in-tree tool is available and we can use it
11905     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11906     echo "$as_me:$LINENO: result: just compiled" >&5
11907 echo "${ECHO_T}just compiled" >&6
11908   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11909     # We already found the complete path
11910     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11911     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11912 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11913   elif test "x$target" = "x$host"; then
11914     # We can use an host tool
11915     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11916     echo "$as_me:$LINENO: result: host tool" >&5
11917 echo "${ECHO_T}host tool" >&6
11918   else
11919     # We need a cross tool
11920     echo "$as_me:$LINENO: result: pre-installed" >&5
11921 echo "${ECHO_T}pre-installed" >&6
11922   fi
11923 fi
11924
11925 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11926 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11927 if test "x${build}" != "x${host}" ; then
11928   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11929     # We already found the complete path
11930     ac_dir=`dirname $GCC_FOR_TARGET`
11931     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11932 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11933   else
11934     # Canadian cross, just use what we found
11935     echo "$as_me:$LINENO: result: pre-installed" >&5
11936 echo "${ECHO_T}pre-installed" >&6
11937   fi
11938 else
11939   ok=yes
11940   case " ${configdirs} " in
11941     *" gcc "*) ;;
11942     *) ok=no ;;
11943   esac
11944
11945   if test $ok = yes; then
11946     # An in-tree tool is available and we can use it
11947     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11948     echo "$as_me:$LINENO: result: just compiled" >&5
11949 echo "${ECHO_T}just compiled" >&6
11950   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11951     # We already found the complete path
11952     ac_dir=`dirname $GCC_FOR_TARGET`
11953     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11954 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11955   elif test "x$target" = "x$host"; then
11956     # We can use an host tool
11957     GCC_FOR_TARGET='$()'
11958     echo "$as_me:$LINENO: result: host tool" >&5
11959 echo "${ECHO_T}host tool" >&6
11960   else
11961     # We need a cross tool
11962     echo "$as_me:$LINENO: result: pre-installed" >&5
11963 echo "${ECHO_T}pre-installed" >&6
11964   fi
11965 fi
11966
11967 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11968 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11969 if test "x${build}" != "x${host}" ; then
11970   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11971     # We already found the complete path
11972     ac_dir=`dirname $GCJ_FOR_TARGET`
11973     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11974 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11975   else
11976     # Canadian cross, just use what we found
11977     echo "$as_me:$LINENO: result: pre-installed" >&5
11978 echo "${ECHO_T}pre-installed" >&6
11979   fi
11980 else
11981   ok=yes
11982   case " ${configdirs} " in
11983     *" gcc "*) ;;
11984     *) ok=no ;;
11985   esac
11986   case ,${enable_languages}, in
11987     *,java,*) ;;
11988     *) ok=no ;;
11989   esac
11990   if test $ok = yes; then
11991     # An in-tree tool is available and we can use it
11992     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11993     echo "$as_me:$LINENO: result: just compiled" >&5
11994 echo "${ECHO_T}just compiled" >&6
11995   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11996     # We already found the complete path
11997     ac_dir=`dirname $GCJ_FOR_TARGET`
11998     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11999 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12000   elif test "x$target" = "x$host"; then
12001     # We can use an host tool
12002     GCJ_FOR_TARGET='$(GCJ)'
12003     echo "$as_me:$LINENO: result: host tool" >&5
12004 echo "${ECHO_T}host tool" >&6
12005   else
12006     # We need a cross tool
12007     echo "$as_me:$LINENO: result: pre-installed" >&5
12008 echo "${ECHO_T}pre-installed" >&6
12009   fi
12010 fi
12011
12012 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
12013 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
12014 if test "x${build}" != "x${host}" ; then
12015   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12016     # We already found the complete path
12017     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12018     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12019 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12020   else
12021     # Canadian cross, just use what we found
12022     echo "$as_me:$LINENO: result: pre-installed" >&5
12023 echo "${ECHO_T}pre-installed" >&6
12024   fi
12025 else
12026   ok=yes
12027   case " ${configdirs} " in
12028     *" gcc "*) ;;
12029     *) ok=no ;;
12030   esac
12031   case ,${enable_languages}, in
12032     *,fortran,*) ;;
12033     *) ok=no ;;
12034   esac
12035   if test $ok = yes; then
12036     # An in-tree tool is available and we can use it
12037     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12038     echo "$as_me:$LINENO: result: just compiled" >&5
12039 echo "${ECHO_T}just compiled" >&6
12040   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12041     # We already found the complete path
12042     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12043     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12044 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12045   elif test "x$target" = "x$host"; then
12046     # We can use an host tool
12047     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12048     echo "$as_me:$LINENO: result: host tool" >&5
12049 echo "${ECHO_T}host tool" >&6
12050   else
12051     # We need a cross tool
12052     echo "$as_me:$LINENO: result: pre-installed" >&5
12053 echo "${ECHO_T}pre-installed" >&6
12054   fi
12055 fi
12056
12057 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12058 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12059 if test "x${build}" != "x${host}" ; then
12060   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12061     # We already found the complete path
12062     ac_dir=`dirname $LD_FOR_TARGET`
12063     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12064 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12065   else
12066     # Canadian cross, just use what we found
12067     echo "$as_me:$LINENO: result: pre-installed" >&5
12068 echo "${ECHO_T}pre-installed" >&6
12069   fi
12070 else
12071   ok=yes
12072   case " ${configdirs} " in
12073     *" ld "*) ;;
12074     *) ok=no ;;
12075   esac
12076
12077   if test $ok = yes; then
12078     # An in-tree tool is available and we can use it
12079     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12080     echo "$as_me:$LINENO: result: just compiled" >&5
12081 echo "${ECHO_T}just compiled" >&6
12082   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12083     # We already found the complete path
12084     ac_dir=`dirname $LD_FOR_TARGET`
12085     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12086 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12087   elif test "x$target" = "x$host"; then
12088     # We can use an host tool
12089     LD_FOR_TARGET='$(LD)'
12090     echo "$as_me:$LINENO: result: host tool" >&5
12091 echo "${ECHO_T}host tool" >&6
12092   else
12093     # We need a cross tool
12094     echo "$as_me:$LINENO: result: pre-installed" >&5
12095 echo "${ECHO_T}pre-installed" >&6
12096   fi
12097 fi
12098
12099 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12100 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12101 if test "x${build}" != "x${host}" ; then
12102   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12103     # We already found the complete path
12104     ac_dir=`dirname $LIPO_FOR_TARGET`
12105     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12106 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12107   else
12108     # Canadian cross, just use what we found
12109     echo "$as_me:$LINENO: result: pre-installed" >&5
12110 echo "${ECHO_T}pre-installed" >&6
12111   fi
12112 else
12113   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12114     # We already found the complete path
12115     ac_dir=`dirname $LIPO_FOR_TARGET`
12116     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12117 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12118   elif test "x$target" = "x$host"; then
12119     # We can use an host tool
12120     LIPO_FOR_TARGET='$(LIPO)'
12121     echo "$as_me:$LINENO: result: host tool" >&5
12122 echo "${ECHO_T}host tool" >&6
12123   else
12124     # We need a cross tool
12125     echo "$as_me:$LINENO: result: pre-installed" >&5
12126 echo "${ECHO_T}pre-installed" >&6
12127   fi
12128 fi
12129
12130 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12131 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12132 if test "x${build}" != "x${host}" ; then
12133   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12134     # We already found the complete path
12135     ac_dir=`dirname $NM_FOR_TARGET`
12136     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12137 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12138   else
12139     # Canadian cross, just use what we found
12140     echo "$as_me:$LINENO: result: pre-installed" >&5
12141 echo "${ECHO_T}pre-installed" >&6
12142   fi
12143 else
12144   ok=yes
12145   case " ${configdirs} " in
12146     *" binutils "*) ;;
12147     *) ok=no ;;
12148   esac
12149
12150   if test $ok = yes; then
12151     # An in-tree tool is available and we can use it
12152     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12153     echo "$as_me:$LINENO: result: just compiled" >&5
12154 echo "${ECHO_T}just compiled" >&6
12155   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12156     # We already found the complete path
12157     ac_dir=`dirname $NM_FOR_TARGET`
12158     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12159 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12160   elif test "x$target" = "x$host"; then
12161     # We can use an host tool
12162     NM_FOR_TARGET='$(NM)'
12163     echo "$as_me:$LINENO: result: host tool" >&5
12164 echo "${ECHO_T}host tool" >&6
12165   else
12166     # We need a cross tool
12167     echo "$as_me:$LINENO: result: pre-installed" >&5
12168 echo "${ECHO_T}pre-installed" >&6
12169   fi
12170 fi
12171
12172 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12173 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12174 if test "x${build}" != "x${host}" ; then
12175   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12176     # We already found the complete path
12177     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12178     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12179 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12180   else
12181     # Canadian cross, just use what we found
12182     echo "$as_me:$LINENO: result: pre-installed" >&5
12183 echo "${ECHO_T}pre-installed" >&6
12184   fi
12185 else
12186   ok=yes
12187   case " ${configdirs} " in
12188     *" binutils "*) ;;
12189     *) ok=no ;;
12190   esac
12191
12192   if test $ok = yes; then
12193     # An in-tree tool is available and we can use it
12194     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12195     echo "$as_me:$LINENO: result: just compiled" >&5
12196 echo "${ECHO_T}just compiled" >&6
12197   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12198     # We already found the complete path
12199     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12200     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12201 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12202   elif test "x$target" = "x$host"; then
12203     # We can use an host tool
12204     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12205     echo "$as_me:$LINENO: result: host tool" >&5
12206 echo "${ECHO_T}host tool" >&6
12207   else
12208     # We need a cross tool
12209     echo "$as_me:$LINENO: result: pre-installed" >&5
12210 echo "${ECHO_T}pre-installed" >&6
12211   fi
12212 fi
12213
12214 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12215 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12216 if test "x${build}" != "x${host}" ; then
12217   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12218     # We already found the complete path
12219     ac_dir=`dirname $RANLIB_FOR_TARGET`
12220     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12221 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12222   else
12223     # Canadian cross, just use what we found
12224     echo "$as_me:$LINENO: result: pre-installed" >&5
12225 echo "${ECHO_T}pre-installed" >&6
12226   fi
12227 else
12228   ok=yes
12229   case " ${configdirs} " in
12230     *" binutils "*) ;;
12231     *) ok=no ;;
12232   esac
12233
12234   if test $ok = yes; then
12235     # An in-tree tool is available and we can use it
12236     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12237     echo "$as_me:$LINENO: result: just compiled" >&5
12238 echo "${ECHO_T}just compiled" >&6
12239   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12240     # We already found the complete path
12241     ac_dir=`dirname $RANLIB_FOR_TARGET`
12242     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12243 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12244   elif test "x$target" = "x$host"; then
12245     # We can use an host tool
12246     RANLIB_FOR_TARGET='$(RANLIB)'
12247     echo "$as_me:$LINENO: result: host tool" >&5
12248 echo "${ECHO_T}host tool" >&6
12249   else
12250     # We need a cross tool
12251     echo "$as_me:$LINENO: result: pre-installed" >&5
12252 echo "${ECHO_T}pre-installed" >&6
12253   fi
12254 fi
12255
12256 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12257 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12258 if test "x${build}" != "x${host}" ; then
12259   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12260     # We already found the complete path
12261     ac_dir=`dirname $STRIP_FOR_TARGET`
12262     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12263 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12264   else
12265     # Canadian cross, just use what we found
12266     echo "$as_me:$LINENO: result: pre-installed" >&5
12267 echo "${ECHO_T}pre-installed" >&6
12268   fi
12269 else
12270   ok=yes
12271   case " ${configdirs} " in
12272     *" binutils "*) ;;
12273     *) ok=no ;;
12274   esac
12275
12276   if test $ok = yes; then
12277     # An in-tree tool is available and we can use it
12278     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12279     echo "$as_me:$LINENO: result: just compiled" >&5
12280 echo "${ECHO_T}just compiled" >&6
12281   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12282     # We already found the complete path
12283     ac_dir=`dirname $STRIP_FOR_TARGET`
12284     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12285 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12286   elif test "x$target" = "x$host"; then
12287     # We can use an host tool
12288     STRIP_FOR_TARGET='$(STRIP)'
12289     echo "$as_me:$LINENO: result: host tool" >&5
12290 echo "${ECHO_T}host tool" >&6
12291   else
12292     # We need a cross tool
12293     echo "$as_me:$LINENO: result: pre-installed" >&5
12294 echo "${ECHO_T}pre-installed" >&6
12295   fi
12296 fi
12297
12298 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12299 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12300 if test "x${build}" != "x${host}" ; then
12301   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12302     # We already found the complete path
12303     ac_dir=`dirname $WINDRES_FOR_TARGET`
12304     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12305 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12306   else
12307     # Canadian cross, just use what we found
12308     echo "$as_me:$LINENO: result: pre-installed" >&5
12309 echo "${ECHO_T}pre-installed" >&6
12310   fi
12311 else
12312   ok=yes
12313   case " ${configdirs} " in
12314     *" binutils "*) ;;
12315     *) ok=no ;;
12316   esac
12317
12318   if test $ok = yes; then
12319     # An in-tree tool is available and we can use it
12320     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12321     echo "$as_me:$LINENO: result: just compiled" >&5
12322 echo "${ECHO_T}just compiled" >&6
12323   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12324     # We already found the complete path
12325     ac_dir=`dirname $WINDRES_FOR_TARGET`
12326     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12327 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12328   elif test "x$target" = "x$host"; then
12329     # We can use an host tool
12330     WINDRES_FOR_TARGET='$(WINDRES)'
12331     echo "$as_me:$LINENO: result: host tool" >&5
12332 echo "${ECHO_T}host tool" >&6
12333   else
12334     # We need a cross tool
12335     echo "$as_me:$LINENO: result: pre-installed" >&5
12336 echo "${ECHO_T}pre-installed" >&6
12337   fi
12338 fi
12339
12340 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12341 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12342 if test "x${build}" != "x${host}" ; then
12343   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12344     # We already found the complete path
12345     ac_dir=`dirname $WINDMC_FOR_TARGET`
12346     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12347 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12348   else
12349     # Canadian cross, just use what we found
12350     echo "$as_me:$LINENO: result: pre-installed" >&5
12351 echo "${ECHO_T}pre-installed" >&6
12352   fi
12353 else
12354   ok=yes
12355   case " ${configdirs} " in
12356     *" binutils "*) ;;
12357     *) ok=no ;;
12358   esac
12359
12360   if test $ok = yes; then
12361     # An in-tree tool is available and we can use it
12362     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12363     echo "$as_me:$LINENO: result: just compiled" >&5
12364 echo "${ECHO_T}just compiled" >&6
12365   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12366     # We already found the complete path
12367     ac_dir=`dirname $WINDMC_FOR_TARGET`
12368     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12369 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12370   elif test "x$target" = "x$host"; then
12371     # We can use an host tool
12372     WINDMC_FOR_TARGET='$(WINDMC)'
12373     echo "$as_me:$LINENO: result: host tool" >&5
12374 echo "${ECHO_T}host tool" >&6
12375   else
12376     # We need a cross tool
12377     echo "$as_me:$LINENO: result: pre-installed" >&5
12378 echo "${ECHO_T}pre-installed" >&6
12379   fi
12380 fi
12381
12382
12383
12384
12385
12386 # Certain tools may need extra flags.
12387 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12388 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12389 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12390
12391 # When building target libraries, except in a Canadian cross, we use
12392 # the same toolchain as the compiler we just built.
12393 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12394 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12395 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12396 if test $host = $build; then
12397   case " $configdirs " in
12398     *" gcc "*)
12399       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12400       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12401       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12402       ;;
12403   esac
12404 fi
12405
12406
12407
12408
12409
12410 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12411 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12412 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12413 if test "${enable_maintainer_mode+set}" = set; then
12414   enableval="$enable_maintainer_mode"
12415   USE_MAINTAINER_MODE=$enableval
12416 else
12417   USE_MAINTAINER_MODE=no
12418 fi;
12419 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12420 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12421
12422
12423 if test "$USE_MAINTAINER_MODE" = yes; then
12424   MAINTAINER_MODE_TRUE=
12425   MAINTAINER_MODE_FALSE='#'
12426 else
12427   MAINTAINER_MODE_TRUE='#'
12428   MAINTAINER_MODE_FALSE=
12429 fi
12430 MAINT=$MAINTAINER_MODE_TRUE
12431
12432 # ---------------------
12433 # GCC bootstrap support
12434 # ---------------------
12435
12436 # Stage specific cflags for build.
12437 stage1_cflags="-g"
12438 case $build in
12439   vax-*-*)
12440     case ${GCC} in
12441       yes) stage1_cflags="-g -Wa,-J" ;;
12442       *) stage1_cflags="-g -J" ;;
12443     esac ;;
12444 esac
12445
12446 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12447 if test "$GCC" = yes; then
12448   saved_CFLAGS="$CFLAGS"
12449
12450   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12451   CFLAGS="$CFLAGS -fkeep-inline-functions"
12452   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12453 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12454   cat >conftest.$ac_ext <<_ACEOF
12455 /* confdefs.h.  */
12456 _ACEOF
12457 cat confdefs.h >>conftest.$ac_ext
12458 cat >>conftest.$ac_ext <<_ACEOF
12459 /* end confdefs.h.  */
12460
12461 #if (__GNUC__ < 3) \
12462     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12463                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12464 #error http://gcc.gnu.org/PR29382
12465 #endif
12466
12467 int
12468 main ()
12469 {
12470
12471   ;
12472   return 0;
12473 }
12474 _ACEOF
12475 rm -f conftest.$ac_objext
12476 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12477   (eval $ac_compile) 2>conftest.er1
12478   ac_status=$?
12479   grep -v '^ *+' conftest.er1 >conftest.err
12480   rm -f conftest.er1
12481   cat conftest.err >&5
12482   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12483   (exit $ac_status); } &&
12484          { ac_try='test -z "$ac_c_werror_flag"
12485                          || test ! -s conftest.err'
12486   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12487   (eval $ac_try) 2>&5
12488   ac_status=$?
12489   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12490   (exit $ac_status); }; } &&
12491          { ac_try='test -s conftest.$ac_objext'
12492   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12493   (eval $ac_try) 2>&5
12494   ac_status=$?
12495   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12496   (exit $ac_status); }; }; then
12497   echo "$as_me:$LINENO: result: yes" >&5
12498 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12499 else
12500   echo "$as_me: failed program was:" >&5
12501 sed 's/^/| /' conftest.$ac_ext >&5
12502
12503 echo "$as_me:$LINENO: result: no" >&5
12504 echo "${ECHO_T}no" >&6
12505 fi
12506 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12507
12508   CFLAGS="$saved_CFLAGS"
12509 fi
12510
12511
12512
12513 # Enable --enable-checking in stage1 of the compiler.
12514 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12515 if test "${enable_stage1_checking+set}" = set; then
12516   enableval="$enable_stage1_checking"
12517   stage1_checking=--enable-checking=${enable_stage1_checking}
12518 else
12519   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12520   stage1_checking=--enable-checking=yes,types
12521 else
12522   stage1_checking=--enable-checking=$enable_checking,types
12523 fi
12524 fi;
12525
12526
12527 # Enable -Werror in bootstrap stage2 and later.
12528 # Check whether --enable-werror or --disable-werror was given.
12529 if test "${enable_werror+set}" = set; then
12530   enableval="$enable_werror"
12531
12532 else
12533   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12534   enable_werror=yes
12535 else
12536   enable_werror=no
12537 fi
12538 fi;
12539 case ${enable_werror} in
12540   yes) stage2_werror_flag="--enable-werror-always" ;;
12541   *) stage2_werror_flag="" ;;
12542 esac
12543
12544
12545 # Flags needed to enable html installing and building
12546
12547 # Check whether --with-datarootdir or --without-datarootdir was given.
12548 if test "${with_datarootdir+set}" = set; then
12549   withval="$with_datarootdir"
12550   datarootdir="\${prefix}/${withval}"
12551 else
12552   datarootdir="\${prefix}/share"
12553 fi;
12554
12555
12556 # Check whether --with-docdir or --without-docdir was given.
12557 if test "${with_docdir+set}" = set; then
12558   withval="$with_docdir"
12559   docdir="\${prefix}/${withval}"
12560 else
12561   docdir="\${datarootdir}/doc"
12562 fi;
12563
12564
12565 # Check whether --with-pdfdir or --without-pdfdir was given.
12566 if test "${with_pdfdir+set}" = set; then
12567   withval="$with_pdfdir"
12568   pdfdir="\${prefix}/${withval}"
12569 else
12570   pdfdir="\${docdir}"
12571 fi;
12572
12573
12574 # Check whether --with-htmldir or --without-htmldir was given.
12575 if test "${with_htmldir+set}" = set; then
12576   withval="$with_htmldir"
12577   htmldir="\${prefix}/${withval}"
12578 else
12579   htmldir="\${docdir}"
12580 fi;
12581
12582
12583
12584
12585
12586
12587           ac_config_files="$ac_config_files Makefile"
12588 cat >confcache <<\_ACEOF
12589 # This file is a shell script that caches the results of configure
12590 # tests run on this system so they can be shared between configure
12591 # scripts and configure runs, see configure's option --config-cache.
12592 # It is not useful on other systems.  If it contains results you don't
12593 # want to keep, you may remove or edit it.
12594 #
12595 # config.status only pays attention to the cache file if you give it
12596 # the --recheck option to rerun configure.
12597 #
12598 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12599 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12600 # following values.
12601
12602 _ACEOF
12603
12604 # The following way of writing the cache mishandles newlines in values,
12605 # but we know of no workaround that is simple, portable, and efficient.
12606 # So, don't put newlines in cache variables' values.
12607 # Ultrix sh set writes to stderr and can't be redirected directly,
12608 # and sets the high bit in the cache file unless we assign to the vars.
12609 {
12610   (set) 2>&1 |
12611     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12612     *ac_space=\ *)
12613       # `set' does not quote correctly, so add quotes (double-quote
12614       # substitution turns \\\\ into \\, and sed turns \\ into \).
12615       sed -n \
12616         "s/'/'\\\\''/g;
12617           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12618       ;;
12619     *)
12620       # `set' quotes correctly as required by POSIX, so do not add quotes.
12621       sed -n \
12622         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12623       ;;
12624     esac;
12625 } |
12626   sed '
12627      t clear
12628      : clear
12629      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12630      t end
12631      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12632      : end' >>confcache
12633 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12634   if test -w $cache_file; then
12635     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12636     cat confcache >$cache_file
12637   else
12638     echo "not updating unwritable cache $cache_file"
12639   fi
12640 fi
12641 rm -f confcache
12642
12643 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12644 # Let make expand exec_prefix.
12645 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12646
12647 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12648 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12649 # trailing colons and then remove the whole line if VPATH becomes empty
12650 # (actually we leave an empty line to preserve line numbers).
12651 if test "x$srcdir" = x.; then
12652   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12653 s/:*\$(srcdir):*/:/;
12654 s/:*\${srcdir}:*/:/;
12655 s/:*@srcdir@:*/:/;
12656 s/^\([^=]*=[     ]*\):*/\1/;
12657 s/:*$//;
12658 s/^[^=]*=[       ]*$//;
12659 }'
12660 fi
12661
12662 # Transform confdefs.h into DEFS.
12663 # Protect against shell expansion while executing Makefile rules.
12664 # Protect against Makefile macro expansion.
12665 #
12666 # If the first sed substitution is executed (which looks for macros that
12667 # take arguments), then we branch to the quote section.  Otherwise,
12668 # look for a macro that doesn't take arguments.
12669 cat >confdef2opt.sed <<\_ACEOF
12670 t clear
12671 : clear
12672 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12673 t quote
12674 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12675 t quote
12676 d
12677 : quote
12678 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12679 s,\[,\\&,g
12680 s,\],\\&,g
12681 s,\$,$$,g
12682 p
12683 _ACEOF
12684 # We use echo to avoid assuming a particular line-breaking character.
12685 # The extra dot is to prevent the shell from consuming trailing
12686 # line-breaks from the sub-command output.  A line-break within
12687 # single-quotes doesn't work because, if this script is created in a
12688 # platform that uses two characters for line-breaks (e.g., DOS), tr
12689 # would break.
12690 ac_LF_and_DOT=`echo; echo .`
12691 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12692 rm -f confdef2opt.sed
12693
12694
12695 ac_libobjs=
12696 ac_ltlibobjs=
12697 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12698   # 1. Remove the extension, and $U if already installed.
12699   ac_i=`echo "$ac_i" |
12700          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12701   # 2. Add them.
12702   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12703   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12704 done
12705 LIBOBJS=$ac_libobjs
12706
12707 LTLIBOBJS=$ac_ltlibobjs
12708
12709
12710
12711 : ${CONFIG_STATUS=./config.status}
12712 ac_clean_files_save=$ac_clean_files
12713 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12714 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12715 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12716 cat >$CONFIG_STATUS <<_ACEOF
12717 #! $SHELL
12718 # Generated by $as_me.
12719 # Run this file to recreate the current configuration.
12720 # Compiler output produced by configure, useful for debugging
12721 # configure, is in config.log if it exists.
12722
12723 debug=false
12724 ac_cs_recheck=false
12725 ac_cs_silent=false
12726 SHELL=\${CONFIG_SHELL-$SHELL}
12727 _ACEOF
12728
12729 cat >>$CONFIG_STATUS <<\_ACEOF
12730 ## --------------------- ##
12731 ## M4sh Initialization.  ##
12732 ## --------------------- ##
12733
12734 # Be Bourne compatible
12735 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12736   emulate sh
12737   NULLCMD=:
12738   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12739   # is contrary to our usage.  Disable this feature.
12740   alias -g '${1+"$@"}'='"$@"'
12741 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12742   set -o posix
12743 fi
12744 DUALCASE=1; export DUALCASE # for MKS sh
12745
12746 # Support unset when possible.
12747 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12748   as_unset=unset
12749 else
12750   as_unset=false
12751 fi
12752
12753
12754 # Work around bugs in pre-3.0 UWIN ksh.
12755 $as_unset ENV MAIL MAILPATH
12756 PS1='$ '
12757 PS2='> '
12758 PS4='+ '
12759
12760 # NLS nuisances.
12761 for as_var in \
12762   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12763   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12764   LC_TELEPHONE LC_TIME
12765 do
12766   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12767     eval $as_var=C; export $as_var
12768   else
12769     $as_unset $as_var
12770   fi
12771 done
12772
12773 # Required to use basename.
12774 if expr a : '\(a\)' >/dev/null 2>&1; then
12775   as_expr=expr
12776 else
12777   as_expr=false
12778 fi
12779
12780 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12781   as_basename=basename
12782 else
12783   as_basename=false
12784 fi
12785
12786
12787 # Name of the executable.
12788 as_me=`$as_basename "$0" ||
12789 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12790          X"$0" : 'X\(//\)$' \| \
12791          X"$0" : 'X\(/\)$' \| \
12792          .     : '\(.\)' 2>/dev/null ||
12793 echo X/"$0" |
12794     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12795           /^X\/\(\/\/\)$/{ s//\1/; q; }
12796           /^X\/\(\/\).*/{ s//\1/; q; }
12797           s/.*/./; q'`
12798
12799
12800 # PATH needs CR, and LINENO needs CR and PATH.
12801 # Avoid depending upon Character Ranges.
12802 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12803 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12804 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12805 as_cr_digits='0123456789'
12806 as_cr_alnum=$as_cr_Letters$as_cr_digits
12807
12808 # The user is always right.
12809 if test "${PATH_SEPARATOR+set}" != set; then
12810   echo "#! /bin/sh" >conf$$.sh
12811   echo  "exit 0"   >>conf$$.sh
12812   chmod +x conf$$.sh
12813   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12814     PATH_SEPARATOR=';'
12815   else
12816     PATH_SEPARATOR=:
12817   fi
12818   rm -f conf$$.sh
12819 fi
12820
12821
12822   as_lineno_1=$LINENO
12823   as_lineno_2=$LINENO
12824   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12825   test "x$as_lineno_1" != "x$as_lineno_2" &&
12826   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12827   # Find who we are.  Look in the path if we contain no path at all
12828   # relative or not.
12829   case $0 in
12830     *[\\/]* ) as_myself=$0 ;;
12831     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12832 for as_dir in $PATH
12833 do
12834   IFS=$as_save_IFS
12835   test -z "$as_dir" && as_dir=.
12836   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12837 done
12838
12839        ;;
12840   esac
12841   # We did not find ourselves, most probably we were run as `sh COMMAND'
12842   # in which case we are not to be found in the path.
12843   if test "x$as_myself" = x; then
12844     as_myself=$0
12845   fi
12846   if test ! -f "$as_myself"; then
12847     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12848 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12849    { (exit 1); exit 1; }; }
12850   fi
12851   case $CONFIG_SHELL in
12852   '')
12853     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12854 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12855 do
12856   IFS=$as_save_IFS
12857   test -z "$as_dir" && as_dir=.
12858   for as_base in sh bash ksh sh5; do
12859          case $as_dir in
12860          /*)
12861            if ("$as_dir/$as_base" -c '
12862   as_lineno_1=$LINENO
12863   as_lineno_2=$LINENO
12864   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12865   test "x$as_lineno_1" != "x$as_lineno_2" &&
12866   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12867              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12868              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12869              CONFIG_SHELL=$as_dir/$as_base
12870              export CONFIG_SHELL
12871              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12872            fi;;
12873          esac
12874        done
12875 done
12876 ;;
12877   esac
12878
12879   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12880   # uniformly replaced by the line number.  The first 'sed' inserts a
12881   # line-number line before each line; the second 'sed' does the real
12882   # work.  The second script uses 'N' to pair each line-number line
12883   # with the numbered line, and appends trailing '-' during
12884   # substitution so that $LINENO is not a special case at line end.
12885   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12886   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12887   sed '=' <$as_myself |
12888     sed '
12889       N
12890       s,$,-,
12891       : loop
12892       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12893       t loop
12894       s,-$,,
12895       s,^['$as_cr_digits']*\n,,
12896     ' >$as_me.lineno &&
12897   chmod +x $as_me.lineno ||
12898     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12899 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12900    { (exit 1); exit 1; }; }
12901
12902   # Don't try to exec as it changes $[0], causing all sort of problems
12903   # (the dirname of $[0] is not the place where we might find the
12904   # original and so on.  Autoconf is especially sensible to this).
12905   . ./$as_me.lineno
12906   # Exit status is that of the last command.
12907   exit
12908 }
12909
12910
12911 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12912   *c*,-n*) ECHO_N= ECHO_C='
12913 ' ECHO_T='      ' ;;
12914   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12915   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12916 esac
12917
12918 if expr a : '\(a\)' >/dev/null 2>&1; then
12919   as_expr=expr
12920 else
12921   as_expr=false
12922 fi
12923
12924 rm -f conf$$ conf$$.exe conf$$.file
12925 echo >conf$$.file
12926 if ln -s conf$$.file conf$$ 2>/dev/null; then
12927   # We could just check for DJGPP; but this test a) works b) is more generic
12928   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12929   if test -f conf$$.exe; then
12930     # Don't use ln at all; we don't have any links
12931     as_ln_s='cp -p'
12932   else
12933     as_ln_s='ln -s'
12934   fi
12935 elif ln conf$$.file conf$$ 2>/dev/null; then
12936   as_ln_s=ln
12937 else
12938   as_ln_s='cp -p'
12939 fi
12940 rm -f conf$$ conf$$.exe conf$$.file
12941
12942 if mkdir -p . 2>/dev/null; then
12943   as_mkdir_p=:
12944 else
12945   test -d ./-p && rmdir ./-p
12946   as_mkdir_p=false
12947 fi
12948
12949 as_executable_p="test -f"
12950
12951 # Sed expression to map a string onto a valid CPP name.
12952 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12953
12954 # Sed expression to map a string onto a valid variable name.
12955 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12956
12957
12958 # IFS
12959 # We need space, tab and new line, in precisely that order.
12960 as_nl='
12961 '
12962 IFS="   $as_nl"
12963
12964 # CDPATH.
12965 $as_unset CDPATH
12966
12967 exec 6>&1
12968
12969 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12970 # report actual input values of CONFIG_FILES etc. instead of their
12971 # values after options handling.  Logging --version etc. is OK.
12972 exec 5>>config.log
12973 {
12974   echo
12975   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12976 ## Running $as_me. ##
12977 _ASBOX
12978 } >&5
12979 cat >&5 <<_CSEOF
12980
12981 This file was extended by $as_me, which was
12982 generated by GNU Autoconf 2.59.  Invocation command line was
12983
12984   CONFIG_FILES    = $CONFIG_FILES
12985   CONFIG_HEADERS  = $CONFIG_HEADERS
12986   CONFIG_LINKS    = $CONFIG_LINKS
12987   CONFIG_COMMANDS = $CONFIG_COMMANDS
12988   $ $0 $@
12989
12990 _CSEOF
12991 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12992 echo >&5
12993 _ACEOF
12994
12995 # Files that config.status was made for.
12996 if test -n "$ac_config_files"; then
12997   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12998 fi
12999
13000 if test -n "$ac_config_headers"; then
13001   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
13002 fi
13003
13004 if test -n "$ac_config_links"; then
13005   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
13006 fi
13007
13008 if test -n "$ac_config_commands"; then
13009   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
13010 fi
13011
13012 cat >>$CONFIG_STATUS <<\_ACEOF
13013
13014 ac_cs_usage="\
13015 \`$as_me' instantiates files from templates according to the
13016 current configuration.
13017
13018 Usage: $0 [OPTIONS] [FILE]...
13019
13020   -h, --help       print this help, then exit
13021   -V, --version    print version number, then exit
13022   -q, --quiet      do not print progress messages
13023   -d, --debug      don't remove temporary files
13024       --recheck    update $as_me by reconfiguring in the same conditions
13025   --file=FILE[:TEMPLATE]
13026                    instantiate the configuration file FILE
13027
13028 Configuration files:
13029 $config_files
13030
13031 Report bugs to <bug-autoconf@gnu.org>."
13032 _ACEOF
13033
13034 cat >>$CONFIG_STATUS <<_ACEOF
13035 ac_cs_version="\\
13036 config.status
13037 configured by $0, generated by GNU Autoconf 2.59,
13038   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13039
13040 Copyright (C) 2003 Free Software Foundation, Inc.
13041 This config.status script is free software; the Free Software Foundation
13042 gives unlimited permission to copy, distribute and modify it."
13043 srcdir=$srcdir
13044 INSTALL="$INSTALL"
13045 _ACEOF
13046
13047 cat >>$CONFIG_STATUS <<\_ACEOF
13048 # If no file are specified by the user, then we need to provide default
13049 # value.  By we need to know if files were specified by the user.
13050 ac_need_defaults=:
13051 while test $# != 0
13052 do
13053   case $1 in
13054   --*=*)
13055     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13056     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13057     ac_shift=:
13058     ;;
13059   -*)
13060     ac_option=$1
13061     ac_optarg=$2
13062     ac_shift=shift
13063     ;;
13064   *) # This is not an option, so the user has probably given explicit
13065      # arguments.
13066      ac_option=$1
13067      ac_need_defaults=false;;
13068   esac
13069
13070   case $ac_option in
13071   # Handling of the options.
13072 _ACEOF
13073 cat >>$CONFIG_STATUS <<\_ACEOF
13074   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13075     ac_cs_recheck=: ;;
13076   --version | --vers* | -V )
13077     echo "$ac_cs_version"; exit 0 ;;
13078   --he | --h)
13079     # Conflict between --help and --header
13080     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13081 Try \`$0 --help' for more information." >&5
13082 echo "$as_me: error: ambiguous option: $1
13083 Try \`$0 --help' for more information." >&2;}
13084    { (exit 1); exit 1; }; };;
13085   --help | --hel | -h )
13086     echo "$ac_cs_usage"; exit 0 ;;
13087   --debug | --d* | -d )
13088     debug=: ;;
13089   --file | --fil | --fi | --f )
13090     $ac_shift
13091     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13092     ac_need_defaults=false;;
13093   --header | --heade | --head | --hea )
13094     $ac_shift
13095     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13096     ac_need_defaults=false;;
13097   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13098   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13099     ac_cs_silent=: ;;
13100
13101   # This is an error.
13102   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13103 Try \`$0 --help' for more information." >&5
13104 echo "$as_me: error: unrecognized option: $1
13105 Try \`$0 --help' for more information." >&2;}
13106    { (exit 1); exit 1; }; } ;;
13107
13108   *) ac_config_targets="$ac_config_targets $1" ;;
13109
13110   esac
13111   shift
13112 done
13113
13114 ac_configure_extra_args=
13115
13116 if $ac_cs_silent; then
13117   exec 6>/dev/null
13118   ac_configure_extra_args="$ac_configure_extra_args --silent"
13119 fi
13120
13121 _ACEOF
13122 cat >>$CONFIG_STATUS <<_ACEOF
13123 if \$ac_cs_recheck; then
13124   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13125   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13126 fi
13127
13128 _ACEOF
13129
13130
13131
13132
13133
13134 cat >>$CONFIG_STATUS <<\_ACEOF
13135 for ac_config_target in $ac_config_targets
13136 do
13137   case "$ac_config_target" in
13138   # Handling of arguments.
13139   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13140   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13141 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13142    { (exit 1); exit 1; }; };;
13143   esac
13144 done
13145
13146 # If the user did not use the arguments to specify the items to instantiate,
13147 # then the envvar interface is used.  Set only those that are not.
13148 # We use the long form for the default assignment because of an extremely
13149 # bizarre bug on SunOS 4.1.3.
13150 if $ac_need_defaults; then
13151   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13152 fi
13153
13154 # Have a temporary directory for convenience.  Make it in the build tree
13155 # simply because there is no reason to put it here, and in addition,
13156 # creating and moving files from /tmp can sometimes cause problems.
13157 # Create a temporary directory, and hook for its removal unless debugging.
13158 $debug ||
13159 {
13160   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13161   trap '{ (exit 1); exit 1; }' 1 2 13 15
13162 }
13163
13164 # Create a (secure) tmp directory for tmp files.
13165
13166 {
13167   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13168   test -n "$tmp" && test -d "$tmp"
13169 }  ||
13170 {
13171   tmp=./confstat$$-$RANDOM
13172   (umask 077 && mkdir $tmp)
13173 } ||
13174 {
13175    echo "$me: cannot create a temporary directory in ." >&2
13176    { (exit 1); exit 1; }
13177 }
13178
13179 _ACEOF
13180
13181 cat >>$CONFIG_STATUS <<_ACEOF
13182
13183 #
13184 # CONFIG_FILES section.
13185 #
13186
13187 # No need to generate the scripts if there are no CONFIG_FILES.
13188 # This happens for instance when ./config.status config.h
13189 if test -n "\$CONFIG_FILES"; then
13190   # Protect against being on the right side of a sed subst in config.status.
13191   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13192    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13193 s,@SHELL@,$SHELL,;t t
13194 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13195 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13196 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13197 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13198 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13199 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13200 s,@exec_prefix@,$exec_prefix,;t t
13201 s,@prefix@,$prefix,;t t
13202 s,@program_transform_name@,$program_transform_name,;t t
13203 s,@bindir@,$bindir,;t t
13204 s,@sbindir@,$sbindir,;t t
13205 s,@libexecdir@,$libexecdir,;t t
13206 s,@datadir@,$datadir,;t t
13207 s,@sysconfdir@,$sysconfdir,;t t
13208 s,@sharedstatedir@,$sharedstatedir,;t t
13209 s,@localstatedir@,$localstatedir,;t t
13210 s,@libdir@,$libdir,;t t
13211 s,@includedir@,$includedir,;t t
13212 s,@oldincludedir@,$oldincludedir,;t t
13213 s,@infodir@,$infodir,;t t
13214 s,@mandir@,$mandir,;t t
13215 s,@build_alias@,$build_alias,;t t
13216 s,@host_alias@,$host_alias,;t t
13217 s,@target_alias@,$target_alias,;t t
13218 s,@DEFS@,$DEFS,;t t
13219 s,@ECHO_C@,$ECHO_C,;t t
13220 s,@ECHO_N@,$ECHO_N,;t t
13221 s,@ECHO_T@,$ECHO_T,;t t
13222 s,@LIBS@,$LIBS,;t t
13223 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13224 s,@build@,$build,;t t
13225 s,@build_cpu@,$build_cpu,;t t
13226 s,@build_vendor@,$build_vendor,;t t
13227 s,@build_os@,$build_os,;t t
13228 s,@build_noncanonical@,$build_noncanonical,;t t
13229 s,@host_noncanonical@,$host_noncanonical,;t t
13230 s,@target_noncanonical@,$target_noncanonical,;t t
13231 s,@host@,$host,;t t
13232 s,@host_cpu@,$host_cpu,;t t
13233 s,@host_vendor@,$host_vendor,;t t
13234 s,@host_os@,$host_os,;t t
13235 s,@target@,$target,;t t
13236 s,@target_cpu@,$target_cpu,;t t
13237 s,@target_vendor@,$target_vendor,;t t
13238 s,@target_os@,$target_os,;t t
13239 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13240 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13241 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13242 s,@LN@,$LN,;t t
13243 s,@LN_S@,$LN_S,;t t
13244 s,@build_libsubdir@,$build_libsubdir,;t t
13245 s,@build_subdir@,$build_subdir,;t t
13246 s,@host_subdir@,$host_subdir,;t t
13247 s,@target_subdir@,$target_subdir,;t t
13248 s,@CC@,$CC,;t t
13249 s,@CFLAGS@,$CFLAGS,;t t
13250 s,@LDFLAGS@,$LDFLAGS,;t t
13251 s,@CPPFLAGS@,$CPPFLAGS,;t t
13252 s,@ac_ct_CC@,$ac_ct_CC,;t t
13253 s,@EXEEXT@,$EXEEXT,;t t
13254 s,@OBJEXT@,$OBJEXT,;t t
13255 s,@CXX@,$CXX,;t t
13256 s,@CXXFLAGS@,$CXXFLAGS,;t t
13257 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13258 s,@GNATBIND@,$GNATBIND,;t t
13259 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13260 s,@GNATMAKE@,$GNATMAKE,;t t
13261 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13262 s,@do_compare@,$do_compare,;t t
13263 s,@gmplibs@,$gmplibs,;t t
13264 s,@gmpinc@,$gmpinc,;t t
13265 s,@ppllibs@,$ppllibs,;t t
13266 s,@pplinc@,$pplinc,;t t
13267 s,@clooglibs@,$clooglibs,;t t
13268 s,@clooginc@,$clooginc,;t t
13269 s,@stage1_languages@,$stage1_languages,;t t
13270 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13271 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13272 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13273 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13274 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13275 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13276 s,@tooldir@,$tooldir,;t t
13277 s,@build_tooldir@,$build_tooldir,;t t
13278 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13279 s,@GDB_TK@,$GDB_TK,;t t
13280 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13281 s,@build_configargs@,$build_configargs,;t t
13282 s,@build_configdirs@,$build_configdirs,;t t
13283 s,@host_configargs@,$host_configargs,;t t
13284 s,@configdirs@,$configdirs,;t t
13285 s,@target_configargs@,$target_configargs,;t t
13286 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13287 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13288 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13289 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13290 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13291 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13292 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13293 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13294 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13295 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13296 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13297 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13298 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13299 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13300 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13301 s,@config_shell@,$config_shell,;t t
13302 s,@YACC@,$YACC,;t t
13303 s,@BISON@,$BISON,;t t
13304 s,@M4@,$M4,;t t
13305 s,@LEX@,$LEX,;t t
13306 s,@FLEX@,$FLEX,;t t
13307 s,@MAKEINFO@,$MAKEINFO,;t t
13308 s,@EXPECT@,$EXPECT,;t t
13309 s,@RUNTEST@,$RUNTEST,;t t
13310 s,@AR@,$AR,;t t
13311 s,@AS@,$AS,;t t
13312 s,@DLLTOOL@,$DLLTOOL,;t t
13313 s,@LD@,$LD,;t t
13314 s,@LIPO@,$LIPO,;t t
13315 s,@NM@,$NM,;t t
13316 s,@RANLIB@,$RANLIB,;t t
13317 s,@STRIP@,$STRIP,;t t
13318 s,@WINDRES@,$WINDRES,;t t
13319 s,@WINDMC@,$WINDMC,;t t
13320 s,@OBJCOPY@,$OBJCOPY,;t t
13321 s,@OBJDUMP@,$OBJDUMP,;t t
13322 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13323 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13324 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13325 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13326 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13327 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13328 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13329 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13330 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13331 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13332 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13333 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13334 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13335 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13336 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13337 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13338 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13339 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13340 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13341 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13342 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13343 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13344 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13345 s,@MAINT@,$MAINT,;t t
13346 s,@stage1_cflags@,$stage1_cflags,;t t
13347 s,@stage1_checking@,$stage1_checking,;t t
13348 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13349 s,@datarootdir@,$datarootdir,;t t
13350 s,@docdir@,$docdir,;t t
13351 s,@pdfdir@,$pdfdir,;t t
13352 s,@htmldir@,$htmldir,;t t
13353 s,@LIBOBJS@,$LIBOBJS,;t t
13354 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13355 /@serialization_dependencies@/r $serialization_dependencies
13356 s,@serialization_dependencies@,,;t t
13357 /@host_makefile_frag@/r $host_makefile_frag
13358 s,@host_makefile_frag@,,;t t
13359 /@target_makefile_frag@/r $target_makefile_frag
13360 s,@target_makefile_frag@,,;t t
13361 /@alphaieee_frag@/r $alphaieee_frag
13362 s,@alphaieee_frag@,,;t t
13363 /@ospace_frag@/r $ospace_frag
13364 s,@ospace_frag@,,;t t
13365 CEOF
13366
13367 _ACEOF
13368
13369   cat >>$CONFIG_STATUS <<\_ACEOF
13370   # Split the substitutions into bite-sized pieces for seds with
13371   # small command number limits, like on Digital OSF/1 and HP-UX.
13372   ac_max_sed_lines=48
13373   ac_sed_frag=1 # Number of current file.
13374   ac_beg=1 # First line for current file.
13375   ac_end=$ac_max_sed_lines # Line after last line for current file.
13376   ac_more_lines=:
13377   ac_sed_cmds=
13378   while $ac_more_lines; do
13379     if test $ac_beg -gt 1; then
13380       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13381     else
13382       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13383     fi
13384     if test ! -s $tmp/subs.frag; then
13385       ac_more_lines=false
13386     else
13387       # The purpose of the label and of the branching condition is to
13388       # speed up the sed processing (if there are no `@' at all, there
13389       # is no need to browse any of the substitutions).
13390       # These are the two extra sed commands mentioned above.
13391       (echo ':t
13392   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13393       if test -z "$ac_sed_cmds"; then
13394         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13395       else
13396         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13397       fi
13398       ac_sed_frag=`expr $ac_sed_frag + 1`
13399       ac_beg=$ac_end
13400       ac_end=`expr $ac_end + $ac_max_sed_lines`
13401     fi
13402   done
13403   if test -z "$ac_sed_cmds"; then
13404     ac_sed_cmds=cat
13405   fi
13406 fi # test -n "$CONFIG_FILES"
13407
13408 _ACEOF
13409 cat >>$CONFIG_STATUS <<\_ACEOF
13410 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13411   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13412   case $ac_file in
13413   - | *:- | *:-:* ) # input from stdin
13414         cat >$tmp/stdin
13415         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13416         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13417   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13418         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13419   * )   ac_file_in=$ac_file.in ;;
13420   esac
13421
13422   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13423   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13424 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13425          X"$ac_file" : 'X\(//\)[^/]' \| \
13426          X"$ac_file" : 'X\(//\)$' \| \
13427          X"$ac_file" : 'X\(/\)' \| \
13428          .     : '\(.\)' 2>/dev/null ||
13429 echo X"$ac_file" |
13430     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13431           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13432           /^X\(\/\/\)$/{ s//\1/; q; }
13433           /^X\(\/\).*/{ s//\1/; q; }
13434           s/.*/./; q'`
13435   { if $as_mkdir_p; then
13436     mkdir -p "$ac_dir"
13437   else
13438     as_dir="$ac_dir"
13439     as_dirs=
13440     while test ! -d "$as_dir"; do
13441       as_dirs="$as_dir $as_dirs"
13442       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13443 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13444          X"$as_dir" : 'X\(//\)[^/]' \| \
13445          X"$as_dir" : 'X\(//\)$' \| \
13446          X"$as_dir" : 'X\(/\)' \| \
13447          .     : '\(.\)' 2>/dev/null ||
13448 echo X"$as_dir" |
13449     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13450           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13451           /^X\(\/\/\)$/{ s//\1/; q; }
13452           /^X\(\/\).*/{ s//\1/; q; }
13453           s/.*/./; q'`
13454     done
13455     test ! -n "$as_dirs" || mkdir $as_dirs
13456   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13457 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13458    { (exit 1); exit 1; }; }; }
13459
13460   ac_builddir=.
13461
13462 if test "$ac_dir" != .; then
13463   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13464   # A "../" for each directory in $ac_dir_suffix.
13465   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13466 else
13467   ac_dir_suffix= ac_top_builddir=
13468 fi
13469
13470 case $srcdir in
13471   .)  # No --srcdir option.  We are building in place.
13472     ac_srcdir=.
13473     if test -z "$ac_top_builddir"; then
13474        ac_top_srcdir=.
13475     else
13476        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13477     fi ;;
13478   [\\/]* | ?:[\\/]* )  # Absolute path.
13479     ac_srcdir=$srcdir$ac_dir_suffix;
13480     ac_top_srcdir=$srcdir ;;
13481   *) # Relative path.
13482     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13483     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13484 esac
13485
13486 # Do not use `cd foo && pwd` to compute absolute paths, because
13487 # the directories may not exist.
13488 case `pwd` in
13489 .) ac_abs_builddir="$ac_dir";;
13490 *)
13491   case "$ac_dir" in
13492   .) ac_abs_builddir=`pwd`;;
13493   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13494   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13495   esac;;
13496 esac
13497 case $ac_abs_builddir in
13498 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13499 *)
13500   case ${ac_top_builddir}. in
13501   .) ac_abs_top_builddir=$ac_abs_builddir;;
13502   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13503   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13504   esac;;
13505 esac
13506 case $ac_abs_builddir in
13507 .) ac_abs_srcdir=$ac_srcdir;;
13508 *)
13509   case $ac_srcdir in
13510   .) ac_abs_srcdir=$ac_abs_builddir;;
13511   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13512   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13513   esac;;
13514 esac
13515 case $ac_abs_builddir in
13516 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13517 *)
13518   case $ac_top_srcdir in
13519   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13520   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13521   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13522   esac;;
13523 esac
13524
13525
13526   case $INSTALL in
13527   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13528   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13529   esac
13530
13531   if test x"$ac_file" != x-; then
13532     { echo "$as_me:$LINENO: creating $ac_file" >&5
13533 echo "$as_me: creating $ac_file" >&6;}
13534     rm -f "$ac_file"
13535   fi
13536   # Let's still pretend it is `configure' which instantiates (i.e., don't
13537   # use $as_me), people would be surprised to read:
13538   #    /* config.h.  Generated by config.status.  */
13539   if test x"$ac_file" = x-; then
13540     configure_input=
13541   else
13542     configure_input="$ac_file.  "
13543   fi
13544   configure_input=$configure_input"Generated from `echo $ac_file_in |
13545                                      sed 's,.*/,,'` by configure."
13546
13547   # First look for the input files in the build tree, otherwise in the
13548   # src tree.
13549   ac_file_inputs=`IFS=:
13550     for f in $ac_file_in; do
13551       case $f in
13552       -) echo $tmp/stdin ;;
13553       [\\/$]*)
13554          # Absolute (can't be DOS-style, as IFS=:)
13555          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13556 echo "$as_me: error: cannot find input file: $f" >&2;}
13557    { (exit 1); exit 1; }; }
13558          echo "$f";;
13559       *) # Relative
13560          if test -f "$f"; then
13561            # Build tree
13562            echo "$f"
13563          elif test -f "$srcdir/$f"; then
13564            # Source tree
13565            echo "$srcdir/$f"
13566          else
13567            # /dev/null tree
13568            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13569 echo "$as_me: error: cannot find input file: $f" >&2;}
13570    { (exit 1); exit 1; }; }
13571          fi;;
13572       esac
13573     done` || { (exit 1); exit 1; }
13574 _ACEOF
13575 cat >>$CONFIG_STATUS <<_ACEOF
13576   sed "$ac_vpsub
13577 $extrasub
13578 _ACEOF
13579 cat >>$CONFIG_STATUS <<\_ACEOF
13580 :t
13581 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13582 s,@configure_input@,$configure_input,;t t
13583 s,@srcdir@,$ac_srcdir,;t t
13584 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13585 s,@top_srcdir@,$ac_top_srcdir,;t t
13586 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13587 s,@builddir@,$ac_builddir,;t t
13588 s,@abs_builddir@,$ac_abs_builddir,;t t
13589 s,@top_builddir@,$ac_top_builddir,;t t
13590 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13591 s,@INSTALL@,$ac_INSTALL,;t t
13592 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13593   rm -f $tmp/stdin
13594   if test x"$ac_file" != x-; then
13595     mv $tmp/out $ac_file
13596   else
13597     cat $tmp/out
13598     rm -f $tmp/out
13599   fi
13600
13601 done
13602 _ACEOF
13603
13604 cat >>$CONFIG_STATUS <<\_ACEOF
13605
13606 { (exit 0); exit 0; }
13607 _ACEOF
13608 chmod +x $CONFIG_STATUS
13609 ac_clean_files=$ac_clean_files_save
13610
13611
13612 # configure is writing to config.log, and then calls config.status.
13613 # config.status does its own redirection, appending to config.log.
13614 # Unfortunately, on DOS this fails, as config.log is still kept open
13615 # by configure, so config.status won't be able to write to it; its
13616 # output is simply discarded.  So we exec the FD to /dev/null,
13617 # effectively closing config.log, so it can be properly (re)opened and
13618 # appended to by config.status.  When coming back to configure, we
13619 # need to make the FD available again.
13620 if test "$no_create" != yes; then
13621   ac_cs_success=:
13622   ac_config_status_args=
13623   test "$silent" = yes &&
13624     ac_config_status_args="$ac_config_status_args --quiet"
13625   exec 5>/dev/null
13626   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13627   exec 5>>config.log
13628   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13629   # would make configure fail if this is the last instruction.
13630   $ac_cs_success || { (exit 1); exit 1; }
13631 fi
13632