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 extra_mpfr_configure_flags ppllibs pplinc clooglibs clooginc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET RPATH_ENVVAR GCC_SHLIB_SUBDIR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277 ac_pwd=`pwd`
 278
 279 # Initialize some variables set by options.
 280 ac_init_help=
 281 ac_init_version=false
 282 # The variables have the same names as the options, with
 283 # dashes changed to underlines.
 284 cache_file=/dev/null
 285 exec_prefix=NONE
 286 no_create=
 287 no_recursion=
 288 prefix=NONE
 289 program_prefix=NONE
 290 program_suffix=NONE
 291 program_transform_name=s,x,x,
 292 silent=
 293 site=
 294 srcdir=
 295 verbose=
 296 x_includes=NONE
 297 x_libraries=NONE
 298
 299 # Installation directory options.
 300 # These are left unexpanded so users can "make install exec_prefix=/foo"
 301 # and all the variables that are supposed to be based on exec_prefix
 302 # by default will actually change.
 303 # Use braces instead of parens because sh, perl, etc. also accept them.
 304 bindir='${exec_prefix}/bin'
 305 sbindir='${exec_prefix}/sbin'
 306 libexecdir='${exec_prefix}/libexec'
 307 datadir='${prefix}/share'
 308 sysconfdir='${prefix}/etc'
 309 sharedstatedir='${prefix}/com'
 310 localstatedir='${prefix}/var'
 311 libdir='${exec_prefix}/lib'
 312 includedir='${prefix}/include'
 313 oldincludedir='/usr/include'
 314 infodir='${prefix}/info'
 315 mandir='${prefix}/man'
 316
 317 ac_prev=
 318 for ac_option
 319 do
 320   # If the previous option needs an argument, assign it.
 321   if test -n "$ac_prev"; then
 322     eval "$ac_prev=\$ac_option"
 323     ac_prev=
 324     continue
 325   fi
 326
 327   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 328
 329   # Accept the important Cygnus configure options, so we can diagnose typos.
 330
 331   case $ac_option in
 332
 333   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 334     ac_prev=bindir ;;
 335   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 336     bindir=$ac_optarg ;;
 337
 338   -build | --build | --buil | --bui | --bu)
 339     ac_prev=build_alias ;;
 340   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 341     build_alias=$ac_optarg ;;
 342
 343   -cache-file | --cache-file | --cache-fil | --cache-fi \
 344   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 345     ac_prev=cache_file ;;
 346   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 347   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 348     cache_file=$ac_optarg ;;
 349
 350   --config-cache | -C)
 351     cache_file=config.cache ;;
 352
 353   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 354     ac_prev=datadir ;;
 355   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 356   | --da=*)
 357     datadir=$ac_optarg ;;
 358
 359   -disable-* | --disable-*)
 360     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 361     # Reject names that are not valid shell variable names.
 362     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 363       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 364    { (exit 1); exit 1; }; }
 365     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 366     eval "enable_$ac_feature=no" ;;
 367
 368   -enable-* | --enable-*)
 369     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 370     # Reject names that are not valid shell variable names.
 371     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 372       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 373    { (exit 1); exit 1; }; }
 374     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 375     case $ac_option in
 376       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 377       *) ac_optarg=yes ;;
 378     esac
 379     eval "enable_$ac_feature='$ac_optarg'" ;;
 380
 381   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 382   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 383   | --exec | --exe | --ex)
 384     ac_prev=exec_prefix ;;
 385   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 386   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 387   | --exec=* | --exe=* | --ex=*)
 388     exec_prefix=$ac_optarg ;;
 389
 390   -gas | --gas | --ga | --g)
 391     # Obsolete; use --with-gas.
 392     with_gas=yes ;;
 393
 394   -help | --help | --hel | --he | -h)
 395     ac_init_help=long ;;
 396   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 397     ac_init_help=recursive ;;
 398   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 399     ac_init_help=short ;;
 400
 401   -host | --host | --hos | --ho)
 402     ac_prev=host_alias ;;
 403   -host=* | --host=* | --hos=* | --ho=*)
 404     host_alias=$ac_optarg ;;
 405
 406   -includedir | --includedir | --includedi | --included | --include \
 407   | --includ | --inclu | --incl | --inc)
 408     ac_prev=includedir ;;
 409   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 410   | --includ=* | --inclu=* | --incl=* | --inc=*)
 411     includedir=$ac_optarg ;;
 412
 413   -infodir | --infodir | --infodi | --infod | --info | --inf)
 414     ac_prev=infodir ;;
 415   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 416     infodir=$ac_optarg ;;
 417
 418   -libdir | --libdir | --libdi | --libd)
 419     ac_prev=libdir ;;
 420   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 421     libdir=$ac_optarg ;;
 422
 423   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 424   | --libexe | --libex | --libe)
 425     ac_prev=libexecdir ;;
 426   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 427   | --libexe=* | --libex=* | --libe=*)
 428     libexecdir=$ac_optarg ;;
 429
 430   -localstatedir | --localstatedir | --localstatedi | --localstated \
 431   | --localstate | --localstat | --localsta | --localst \
 432   | --locals | --local | --loca | --loc | --lo)
 433     ac_prev=localstatedir ;;
 434   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 435   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 436   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 437     localstatedir=$ac_optarg ;;
 438
 439   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 440     ac_prev=mandir ;;
 441   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 442     mandir=$ac_optarg ;;
 443
 444   -nfp | --nfp | --nf)
 445     # Obsolete; use --without-fp.
 446     with_fp=no ;;
 447
 448   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 449   | --no-cr | --no-c | -n)
 450     no_create=yes ;;
 451
 452   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 453   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 454     no_recursion=yes ;;
 455
 456   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 457   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 458   | --oldin | --oldi | --old | --ol | --o)
 459     ac_prev=oldincludedir ;;
 460   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 461   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 462   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 463     oldincludedir=$ac_optarg ;;
 464
 465   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 466     ac_prev=prefix ;;
 467   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 468     prefix=$ac_optarg ;;
 469
 470   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 471   | --program-pre | --program-pr | --program-p)
 472     ac_prev=program_prefix ;;
 473   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 474   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 475     program_prefix=$ac_optarg ;;
 476
 477   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 478   | --program-suf | --program-su | --program-s)
 479     ac_prev=program_suffix ;;
 480   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 481   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 482     program_suffix=$ac_optarg ;;
 483
 484   -program-transform-name | --program-transform-name \
 485   | --program-transform-nam | --program-transform-na \
 486   | --program-transform-n | --program-transform- \
 487   | --program-transform | --program-transfor \
 488   | --program-transfo | --program-transf \
 489   | --program-trans | --program-tran \
 490   | --progr-tra | --program-tr | --program-t)
 491     ac_prev=program_transform_name ;;
 492   -program-transform-name=* | --program-transform-name=* \
 493   | --program-transform-nam=* | --program-transform-na=* \
 494   | --program-transform-n=* | --program-transform-=* \
 495   | --program-transform=* | --program-transfor=* \
 496   | --program-transfo=* | --program-transf=* \
 497   | --program-trans=* | --program-tran=* \
 498   | --progr-tra=* | --program-tr=* | --program-t=*)
 499     program_transform_name=$ac_optarg ;;
 500
 501   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 502   | -silent | --silent | --silen | --sile | --sil)
 503     silent=yes ;;
 504
 505   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 506     ac_prev=sbindir ;;
 507   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 508   | --sbi=* | --sb=*)
 509     sbindir=$ac_optarg ;;
 510
 511   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 512   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 513   | --sharedst | --shareds | --shared | --share | --shar \
 514   | --sha | --sh)
 515     ac_prev=sharedstatedir ;;
 516   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 517   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 518   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 519   | --sha=* | --sh=*)
 520     sharedstatedir=$ac_optarg ;;
 521
 522   -site | --site | --sit)
 523     ac_prev=site ;;
 524   -site=* | --site=* | --sit=*)
 525     site=$ac_optarg ;;
 526
 527   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 528     ac_prev=srcdir ;;
 529   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 530     srcdir=$ac_optarg ;;
 531
 532   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 533   | --syscon | --sysco | --sysc | --sys | --sy)
 534     ac_prev=sysconfdir ;;
 535   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 536   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 537     sysconfdir=$ac_optarg ;;
 538
 539   -target | --target | --targe | --targ | --tar | --ta | --t)
 540     ac_prev=target_alias ;;
 541   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 542     target_alias=$ac_optarg ;;
 543
 544   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 545     verbose=yes ;;
 546
 547   -version | --version | --versio | --versi | --vers | -V)
 548     ac_init_version=: ;;
 549
 550   -with-* | --with-*)
 551     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 552     # Reject names that are not valid shell variable names.
 553     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 554       { echo "$as_me: error: invalid package name: $ac_package" >&2
 555    { (exit 1); exit 1; }; }
 556     ac_package=`echo $ac_package| sed 's/-/_/g'`
 557     case $ac_option in
 558       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 559       *) ac_optarg=yes ;;
 560     esac
 561     eval "with_$ac_package='$ac_optarg'" ;;
 562
 563   -without-* | --without-*)
 564     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 565     # Reject names that are not valid shell variable names.
 566     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 567       { echo "$as_me: error: invalid package name: $ac_package" >&2
 568    { (exit 1); exit 1; }; }
 569     ac_package=`echo $ac_package | sed 's/-/_/g'`
 570     eval "with_$ac_package=no" ;;
 571
 572   --x)
 573     # Obsolete; use --with-x.
 574     with_x=yes ;;
 575
 576   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 577   | --x-incl | --x-inc | --x-in | --x-i)
 578     ac_prev=x_includes ;;
 579   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 580   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 581     x_includes=$ac_optarg ;;
 582
 583   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 584   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 585     ac_prev=x_libraries ;;
 586   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 587   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 588     x_libraries=$ac_optarg ;;
 589
 590   -*) { echo "$as_me: error: unrecognized option: $ac_option
 591 Try \`$0 --help' for more information." >&2
 592    { (exit 1); exit 1; }; }
 593     ;;
 594
 595   *=*)
 596     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 597     # Reject names that are not valid shell variable names.
 598     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 599       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 600    { (exit 1); exit 1; }; }
 601     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 602     eval "$ac_envvar='$ac_optarg'"
 603     export $ac_envvar ;;
 604
 605   *)
 606     # FIXME: should be removed in autoconf 3.0.
 607     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 608     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 609       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 610     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 611     ;;
 612
 613   esac
 614 done
 615
 616 if test -n "$ac_prev"; then
 617   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 618   { echo "$as_me: error: missing argument to $ac_option" >&2
 619    { (exit 1); exit 1; }; }
 620 fi
 621
 622 # Be sure to have absolute paths.
 623 for ac_var in exec_prefix prefix
 624 do
 625   eval ac_val=$`echo $ac_var`
 626   case $ac_val in
 627     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 628     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 629    { (exit 1); exit 1; }; };;
 630   esac
 631 done
 632
 633 # Be sure to have absolute paths.
 634 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 635               localstatedir libdir includedir oldincludedir infodir mandir
 636 do
 637   eval ac_val=$`echo $ac_var`
 638   case $ac_val in
 639     [\\/$]* | ?:[\\/]* ) ;;
 640     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 641    { (exit 1); exit 1; }; };;
 642   esac
 643 done
 644
 645 # There might be people who depend on the old broken behavior: `$host'
 646 # used to hold the argument of --host etc.
 647 # FIXME: To remove some day.
 648 build=$build_alias
 649 host=$host_alias
 650 target=$target_alias
 651
 652 # FIXME: To remove some day.
 653 if test "x$host_alias" != x; then
 654   if test "x$build_alias" = x; then
 655     cross_compiling=maybe
 656     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 657     If a cross compiler is detected then cross compile mode will be used." >&2
 658   elif test "x$build_alias" != "x$host_alias"; then
 659     cross_compiling=yes
 660   fi
 661 fi
 662
 663 ac_tool_prefix=
 664 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 665
 666 test "$silent" = yes && exec 6>/dev/null
 667
 668
 669 # Find the source files, if location was not specified.
 670 if test -z "$srcdir"; then
 671   ac_srcdir_defaulted=yes
 672   # Try the directory containing this script, then its parent.
 673   ac_confdir=`(dirname "$0") 2>/dev/null ||
 674 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 675          X"$0" : 'X\(//\)[^/]' \| \
 676          X"$0" : 'X\(//\)$' \| \
 677          X"$0" : 'X\(/\)' \| \
 678          .     : '\(.\)' 2>/dev/null ||
 679 echo X"$0" |
 680     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 681           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 682           /^X\(\/\/\)$/{ s//\1/; q; }
 683           /^X\(\/\).*/{ s//\1/; q; }
 684           s/.*/./; q'`
 685   srcdir=$ac_confdir
 686   if test ! -r $srcdir/$ac_unique_file; then
 687     srcdir=..
 688   fi
 689 else
 690   ac_srcdir_defaulted=no
 691 fi
 692 if test ! -r $srcdir/$ac_unique_file; then
 693   if test "$ac_srcdir_defaulted" = yes; then
 694     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 695    { (exit 1); exit 1; }; }
 696   else
 697     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 698    { (exit 1); exit 1; }; }
 699   fi
 700 fi
 701 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 702   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 703    { (exit 1); exit 1; }; }
 704 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 705 ac_env_build_alias_set=${build_alias+set}
 706 ac_env_build_alias_value=$build_alias
 707 ac_cv_env_build_alias_set=${build_alias+set}
 708 ac_cv_env_build_alias_value=$build_alias
 709 ac_env_host_alias_set=${host_alias+set}
 710 ac_env_host_alias_value=$host_alias
 711 ac_cv_env_host_alias_set=${host_alias+set}
 712 ac_cv_env_host_alias_value=$host_alias
 713 ac_env_target_alias_set=${target_alias+set}
 714 ac_env_target_alias_value=$target_alias
 715 ac_cv_env_target_alias_set=${target_alias+set}
 716 ac_cv_env_target_alias_value=$target_alias
 717 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 718
 719 ac_env_CC_set=${CC+set}
 720 ac_env_CC_value=$CC
 721 ac_cv_env_CC_set=${CC+set}
 722 ac_cv_env_CC_value=$CC
 723 ac_env_CFLAGS_set=${CFLAGS+set}
 724 ac_env_CFLAGS_value=$CFLAGS
 725 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 726 ac_cv_env_CFLAGS_value=$CFLAGS
 727 ac_env_LDFLAGS_set=${LDFLAGS+set}
 728 ac_env_LDFLAGS_value=$LDFLAGS
 729 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 730 ac_cv_env_LDFLAGS_value=$LDFLAGS
 731 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 732 ac_env_CPPFLAGS_value=$CPPFLAGS
 733 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 734 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 735 ac_env_CXX_set=${CXX+set}
 736 ac_env_CXX_value=$CXX
 737 ac_cv_env_CXX_set=${CXX+set}
 738 ac_cv_env_CXX_value=$CXX
 739 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 740 ac_env_CXXFLAGS_value=$CXXFLAGS
 741 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 742 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 743 ac_env_AR_set=${AR+set}
 744 ac_env_AR_value=$AR
 745 ac_cv_env_AR_set=${AR+set}
 746 ac_cv_env_AR_value=$AR
 747 ac_env_AS_set=${AS+set}
 748 ac_env_AS_value=$AS
 749 ac_cv_env_AS_set=${AS+set}
 750 ac_cv_env_AS_value=$AS
 751 ac_env_DLLTOOL_set=${DLLTOOL+set}
 752 ac_env_DLLTOOL_value=$DLLTOOL
 753 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 754 ac_cv_env_DLLTOOL_value=$DLLTOOL
 755 ac_env_LD_set=${LD+set}
 756 ac_env_LD_value=$LD
 757 ac_cv_env_LD_set=${LD+set}
 758 ac_cv_env_LD_value=$LD
 759 ac_env_LIPO_set=${LIPO+set}
 760 ac_env_LIPO_value=$LIPO
 761 ac_cv_env_LIPO_set=${LIPO+set}
 762 ac_cv_env_LIPO_value=$LIPO
 763 ac_env_NM_set=${NM+set}
 764 ac_env_NM_value=$NM
 765 ac_cv_env_NM_set=${NM+set}
 766 ac_cv_env_NM_value=$NM
 767 ac_env_RANLIB_set=${RANLIB+set}
 768 ac_env_RANLIB_value=$RANLIB
 769 ac_cv_env_RANLIB_set=${RANLIB+set}
 770 ac_cv_env_RANLIB_value=$RANLIB
 771 ac_env_STRIP_set=${STRIP+set}
 772 ac_env_STRIP_value=$STRIP
 773 ac_cv_env_STRIP_set=${STRIP+set}
 774 ac_cv_env_STRIP_value=$STRIP
 775 ac_env_WINDRES_set=${WINDRES+set}
 776 ac_env_WINDRES_value=$WINDRES
 777 ac_cv_env_WINDRES_set=${WINDRES+set}
 778 ac_cv_env_WINDRES_value=$WINDRES
 779 ac_env_WINDMC_set=${WINDMC+set}
 780 ac_env_WINDMC_value=$WINDMC
 781 ac_cv_env_WINDMC_set=${WINDMC+set}
 782 ac_cv_env_WINDMC_value=$WINDMC
 783 ac_env_OBJCOPY_set=${OBJCOPY+set}
 784 ac_env_OBJCOPY_value=$OBJCOPY
 785 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 786 ac_cv_env_OBJCOPY_value=$OBJCOPY
 787 ac_env_OBJDUMP_set=${OBJDUMP+set}
 788 ac_env_OBJDUMP_value=$OBJDUMP
 789 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 790 ac_cv_env_OBJDUMP_value=$OBJDUMP
 791 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 792 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 793 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 794 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 795 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 796 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 797 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 798 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 799 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 800 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 801 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 802 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 803 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 804 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 805 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 806 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 807 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 808 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 809 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 810 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 811 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 812 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 813 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 814 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 815 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 816 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 817 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 818 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 819 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 820 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 821 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 822 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 823 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 824 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 825 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 826 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 827 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 828 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 829 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 830 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 831 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 832 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 833 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 834 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 835 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 836 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 837 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 838 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 839 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 840 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 841 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 842 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 843 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 844 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 845 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 846 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 847 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 848 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 849 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 850 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 851 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 852 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 853 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 854 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 855
 856 #
 857 # Report the --help message.
 858 #
 859 if test "$ac_init_help" = "long"; then
 860   # Omit some internal or obsolete options to make the list less imposing.
 861   # This message is too long to be a string in the A/UX 3.1 sh.
 862   cat <<_ACEOF
 863 \`configure' configures this package to adapt to many kinds of systems.
 864
 865 Usage: $0 [OPTION]... [VAR=VALUE]...
 866
 867 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 868 VAR=VALUE.  See below for descriptions of some of the useful variables.
 869
 870 Defaults for the options are specified in brackets.
 871
 872 Configuration:
 873   -h, --help              display this help and exit
 874       --help=short        display options specific to this package
 875       --help=recursive    display the short help of all the included packages
 876   -V, --version           display version information and exit
 877   -q, --quiet, --silent   do not print \`checking...' messages
 878       --cache-file=FILE   cache test results in FILE [disabled]
 879   -C, --config-cache      alias for \`--cache-file=config.cache'
 880   -n, --no-create         do not create output files
 881       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 882
 883 _ACEOF
 884
 885   cat <<_ACEOF
 886 Installation directories:
 887   --prefix=PREFIX         install architecture-independent files in PREFIX
 888                           [$ac_default_prefix]
 889   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 890                           [PREFIX]
 891
 892 By default, \`make install' will install all the files in
 893 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 894 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 895 for instance \`--prefix=\$HOME'.
 896
 897 For better control, use the options below.
 898
 899 Fine tuning of the installation directories:
 900   --bindir=DIR           user executables [EPREFIX/bin]
 901   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 902   --libexecdir=DIR       program executables [EPREFIX/libexec]
 903   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 904   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 905   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 906   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 907   --libdir=DIR           object code libraries [EPREFIX/lib]
 908   --includedir=DIR       C header files [PREFIX/include]
 909   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 910   --infodir=DIR          info documentation [PREFIX/info]
 911   --mandir=DIR           man documentation [PREFIX/man]
 912 _ACEOF
 913
 914   cat <<\_ACEOF
 915
 916 Program names:
 917   --program-prefix=PREFIX            prepend PREFIX to installed program names
 918   --program-suffix=SUFFIX            append SUFFIX to installed program names
 919   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 920
 921 System types:
 922   --build=BUILD     configure for building on BUILD [guessed]
 923   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 924   --target=TARGET   configure for building compilers for TARGET [HOST]
 925 _ACEOF
 926 fi
 927
 928 if test -n "$ac_init_help"; then
 929
 930   cat <<\_ACEOF
 931
 932 Optional Features:
 933   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 934   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 935   --enable-gold           use gold instead of ld
 936   --enable-libada         build libada directory
 937   --enable-libssp         build libssp directory
 938   --disable-ppl-version-check    disable check for PPL version
 939   --disable-cloog-version-check  disable check for CLooG version
 940   --enable-stage1-languages[=all]   choose additional languages to build during
 941                           stage1.  Mostly useful for compiler development.
 942   --enable-objc-gc        enable use of Boehm's garbage collector with the
 943                           GNU Objective-C runtime
 944   --enable-bootstrap      enable bootstrapping [yes if native build]
 945   --enable-serial-[{host,target,build}-]configure
 946                           force sequential configuration of
 947                           sub-packages for the host, target or build
 948                           machine, or all sub-packages
 949   --enable-maintainer-mode enable make rules and dependencies not useful
 950                           (and sometimes confusing) to the casual installer
 951   --enable-stage1-checking[=all]   choose additional checking for stage1
 952                           of the compiler
 953   --enable-werror         enable -Werror in bootstrap stage2 and later
 954
 955 Optional Packages:
 956   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 957   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 958   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 959   --with-mpfr-dir=PATH    this option has been REMOVED
 960   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 961                           Equivalent to --with-mpfr-include=PATH/include
 962                           plus --with-mpfr-lib=PATH/lib
 963   --with-mpfr-include=PATH
 964                           specify directory for installed MPFR include files
 965   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 966   --with-gmp-dir=PATH     this option has been REMOVED
 967   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 968                           Equivalent to --with-gmp-include=PATH/include
 969                           plus --with-gmp-lib=PATH/lib
 970   --with-gmp-include=PATH specify directory for installed GMP include files
 971   --with-gmp-lib=PATH     specify directory for the installed GMP library
 972   --with-host-libstdcxx=L Use linker arguments L to link with libstdc++
 973                           when linking with PPL
 974   --with-ppl=PATH         Specify prefix directory for the installed PPL package
 975                           Equivalent to --with-ppl-include=PATH/include
 976                           plus --with-ppl-lib=PATH/lib
 977   --with-ppl-include=PATH Specify directory for installed PPL include files
 978   --with-ppl-lib=PATH     Specify the directory for the installed PPL library
 979   --with-cloog=PATH       Specify prefix directory for the installed CLooG-PPL package
 980                           Equivalent to --with-cloog-include=PATH/include
 981                           plus --with-cloog-lib=PATH/lib
 982   --with-cloog-include=PATH Specify directory for installed CLooG include files
 983   --with-cloog-lib=PATH   Specify the directory for the installed CLooG library
 984   --with-build-sysroot=SYSROOT
 985                           use sysroot as the system root during the build
 986   --with-debug-prefix-map='A=B C=D ...'
 987                              map A to B, C to D ... in debug information
 988   --with-build-time-tools=PATH
 989                           use given path to find target tools during the build
 990   --with-datarootdir      use datarootdir as the data root directory.
 991   --with-docdir           install documentation in this directory.
 992   --with-pdfdir           install pdf in this directory.
 993   --with-htmldir          install html in this directory.
 994
 995 Some influential environment variables:
 996   CC          C compiler command
 997   CFLAGS      C compiler flags
 998   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 999               nonstandard directory <lib dir>
1000   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
1001               headers in a nonstandard directory <include dir>
1002   CXX         C++ compiler command
1003   CXXFLAGS    C++ compiler flags
1004   AR          AR for the host
1005   AS          AS for the host
1006   DLLTOOL     DLLTOOL for the host
1007   LD          LD for the host
1008   LIPO        LIPO for the host
1009   NM          NM for the host
1010   RANLIB      RANLIB for the host
1011   STRIP       STRIP for the host
1012   WINDRES     WINDRES for the host
1013   WINDMC      WINDMC for the host
1014   OBJCOPY     OBJCOPY for the host
1015   OBJDUMP     OBJDUMP for the host
1016   CC_FOR_TARGET
1017               CC for the target
1018   CXX_FOR_TARGET
1019               CXX for the target
1020   GCC_FOR_TARGET
1021               GCC for the target
1022   GCJ_FOR_TARGET
1023               GCJ for the target
1024   GFORTRAN_FOR_TARGET
1025               GFORTRAN for the target
1026   AR_FOR_TARGET
1027               AR for the target
1028   AS_FOR_TARGET
1029               AS for the target
1030   DLLTOOL_FOR_TARGET
1031               DLLTOOL for the target
1032   LD_FOR_TARGET
1033               LD for the target
1034   LIPO_FOR_TARGET
1035               LIPO for the target
1036   NM_FOR_TARGET
1037               NM for the target
1038   OBJDUMP_FOR_TARGET
1039               OBJDUMP for the target
1040   RANLIB_FOR_TARGET
1041               RANLIB for the target
1042   STRIP_FOR_TARGET
1043               STRIP for the target
1044   WINDRES_FOR_TARGET
1045               WINDRES for the target
1046   WINDMC_FOR_TARGET
1047               WINDMC for the target
1048
1049 Use these variables to override the choices made by `configure' or to help
1050 it to find libraries and programs with nonstandard names/locations.
1051
1052 _ACEOF
1053 fi
1054
1055 if test "$ac_init_help" = "recursive"; then
1056   # If there are subdirs, report their specific --help.
1057   ac_popdir=`pwd`
1058   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1059     test -d $ac_dir || continue
1060     ac_builddir=.
1061
1062 if test "$ac_dir" != .; then
1063   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1064   # A "../" for each directory in $ac_dir_suffix.
1065   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1066 else
1067   ac_dir_suffix= ac_top_builddir=
1068 fi
1069
1070 case $srcdir in
1071   .)  # No --srcdir option.  We are building in place.
1072     ac_srcdir=.
1073     if test -z "$ac_top_builddir"; then
1074        ac_top_srcdir=.
1075     else
1076        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1077     fi ;;
1078   [\\/]* | ?:[\\/]* )  # Absolute path.
1079     ac_srcdir=$srcdir$ac_dir_suffix;
1080     ac_top_srcdir=$srcdir ;;
1081   *) # Relative path.
1082     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1083     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1084 esac
1085
1086 # Do not use `cd foo && pwd` to compute absolute paths, because
1087 # the directories may not exist.
1088 case `pwd` in
1089 .) ac_abs_builddir="$ac_dir";;
1090 *)
1091   case "$ac_dir" in
1092   .) ac_abs_builddir=`pwd`;;
1093   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1094   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1095   esac;;
1096 esac
1097 case $ac_abs_builddir in
1098 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1099 *)
1100   case ${ac_top_builddir}. in
1101   .) ac_abs_top_builddir=$ac_abs_builddir;;
1102   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1103   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1104   esac;;
1105 esac
1106 case $ac_abs_builddir in
1107 .) ac_abs_srcdir=$ac_srcdir;;
1108 *)
1109   case $ac_srcdir in
1110   .) ac_abs_srcdir=$ac_abs_builddir;;
1111   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1112   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1113   esac;;
1114 esac
1115 case $ac_abs_builddir in
1116 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1117 *)
1118   case $ac_top_srcdir in
1119   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1120   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1121   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1122   esac;;
1123 esac
1124
1125     cd $ac_dir
1126     # Check for guested configure; otherwise get Cygnus style configure.
1127     if test -f $ac_srcdir/configure.gnu; then
1128       echo
1129       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1130     elif test -f $ac_srcdir/configure; then
1131       echo
1132       $SHELL $ac_srcdir/configure  --help=recursive
1133     elif test -f $ac_srcdir/configure.ac ||
1134            test -f $ac_srcdir/configure.in; then
1135       echo
1136       $ac_configure --help
1137     else
1138       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1139     fi
1140     cd $ac_popdir
1141   done
1142 fi
1143
1144 test -n "$ac_init_help" && exit 0
1145 if $ac_init_version; then
1146   cat <<\_ACEOF
1147
1148 Copyright (C) 2003 Free Software Foundation, Inc.
1149 This configure script is free software; the Free Software Foundation
1150 gives unlimited permission to copy, distribute and modify it.
1151 _ACEOF
1152   exit 0
1153 fi
1154 exec 5>config.log
1155 cat >&5 <<_ACEOF
1156 This file contains any messages produced by compilers while
1157 running configure, to aid debugging if configure makes a mistake.
1158
1159 It was created by $as_me, which was
1160 generated by GNU Autoconf 2.59.  Invocation command line was
1161
1162   $ $0 $@
1163
1164 _ACEOF
1165 {
1166 cat <<_ASUNAME
1167 ## --------- ##
1168 ## Platform. ##
1169 ## --------- ##
1170
1171 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1172 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1173 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1174 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1175 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1176
1177 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1178 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1179
1180 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1181 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1182 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1183 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1184 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1185 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1186 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1187
1188 _ASUNAME
1189
1190 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1191 for as_dir in $PATH
1192 do
1193   IFS=$as_save_IFS
1194   test -z "$as_dir" && as_dir=.
1195   echo "PATH: $as_dir"
1196 done
1197
1198 } >&5
1199
1200 cat >&5 <<_ACEOF
1201
1202
1203 ## ----------- ##
1204 ## Core tests. ##
1205 ## ----------- ##
1206
1207 _ACEOF
1208
1209
1210 # Keep a trace of the command line.
1211 # Strip out --no-create and --no-recursion so they do not pile up.
1212 # Strip out --silent because we don't want to record it for future runs.
1213 # Also quote any args containing shell meta-characters.
1214 # Make two passes to allow for proper duplicate-argument suppression.
1215 ac_configure_args=
1216 ac_configure_args0=
1217 ac_configure_args1=
1218 ac_sep=
1219 ac_must_keep_next=false
1220 for ac_pass in 1 2
1221 do
1222   for ac_arg
1223   do
1224     case $ac_arg in
1225     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1226     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1227     | -silent | --silent | --silen | --sile | --sil)
1228       continue ;;
1229     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1230       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1231     esac
1232     case $ac_pass in
1233     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1234     2)
1235       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1236       if test $ac_must_keep_next = true; then
1237         ac_must_keep_next=false # Got value, back to normal.
1238       else
1239         case $ac_arg in
1240           *=* | --config-cache | -C | -disable-* | --disable-* \
1241           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1242           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1243           | -with-* | --with-* | -without-* | --without-* | --x)
1244             case "$ac_configure_args0 " in
1245               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1246             esac
1247             ;;
1248           -* ) ac_must_keep_next=true ;;
1249         esac
1250       fi
1251       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1252       # Get rid of the leading space.
1253       ac_sep=" "
1254       ;;
1255     esac
1256   done
1257 done
1258 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1259 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1260
1261 # When interrupted or exit'd, cleanup temporary files, and complete
1262 # config.log.  We remove comments because anyway the quotes in there
1263 # would cause problems or look ugly.
1264 # WARNING: Be sure not to use single quotes in there, as some shells,
1265 # such as our DU 5.0 friend, will then `close' the trap.
1266 trap 'exit_status=$?
1267   # Save into config.log some information that might help in debugging.
1268   {
1269     echo
1270
1271     cat <<\_ASBOX
1272 ## ---------------- ##
1273 ## Cache variables. ##
1274 ## ---------------- ##
1275 _ASBOX
1276     echo
1277     # The following way of writing the cache mishandles newlines in values,
1278 {
1279   (set) 2>&1 |
1280     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1281     *ac_space=\ *)
1282       sed -n \
1283         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1284           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1285       ;;
1286     *)
1287       sed -n \
1288         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1289       ;;
1290     esac;
1291 }
1292     echo
1293
1294     cat <<\_ASBOX
1295 ## ----------------- ##
1296 ## Output variables. ##
1297 ## ----------------- ##
1298 _ASBOX
1299     echo
1300     for ac_var in $ac_subst_vars
1301     do
1302       eval ac_val=$`echo $ac_var`
1303       echo "$ac_var='"'"'$ac_val'"'"'"
1304     done | sort
1305     echo
1306
1307     if test -n "$ac_subst_files"; then
1308       cat <<\_ASBOX
1309 ## ------------- ##
1310 ## Output files. ##
1311 ## ------------- ##
1312 _ASBOX
1313       echo
1314       for ac_var in $ac_subst_files
1315       do
1316         eval ac_val=$`echo $ac_var`
1317         echo "$ac_var='"'"'$ac_val'"'"'"
1318       done | sort
1319       echo
1320     fi
1321
1322     if test -s confdefs.h; then
1323       cat <<\_ASBOX
1324 ## ----------- ##
1325 ## confdefs.h. ##
1326 ## ----------- ##
1327 _ASBOX
1328       echo
1329       sed "/^$/d" confdefs.h | sort
1330       echo
1331     fi
1332     test "$ac_signal" != 0 &&
1333       echo "$as_me: caught signal $ac_signal"
1334     echo "$as_me: exit $exit_status"
1335   } >&5
1336   rm -f core *.core &&
1337   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1338     exit $exit_status
1339      ' 0
1340 for ac_signal in 1 2 13 15; do
1341   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1342 done
1343 ac_signal=0
1344
1345 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1346 rm -rf conftest* confdefs.h
1347 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1348 echo >confdefs.h
1349
1350 # Predefined preprocessor variables.
1351
1352 cat >>confdefs.h <<_ACEOF
1353 #define PACKAGE_NAME "$PACKAGE_NAME"
1354 _ACEOF
1355
1356
1357 cat >>confdefs.h <<_ACEOF
1358 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1359 _ACEOF
1360
1361
1362 cat >>confdefs.h <<_ACEOF
1363 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1364 _ACEOF
1365
1366
1367 cat >>confdefs.h <<_ACEOF
1368 #define PACKAGE_STRING "$PACKAGE_STRING"
1369 _ACEOF
1370
1371
1372 cat >>confdefs.h <<_ACEOF
1373 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1374 _ACEOF
1375
1376
1377 # Let the site file select an alternate cache file if it wants to.
1378 # Prefer explicitly selected file to automatically selected ones.
1379 if test -z "$CONFIG_SITE"; then
1380   if test "x$prefix" != xNONE; then
1381     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1382   else
1383     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1384   fi
1385 fi
1386 for ac_site_file in $CONFIG_SITE; do
1387   if test -r "$ac_site_file"; then
1388     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1389 echo "$as_me: loading site script $ac_site_file" >&6;}
1390     sed 's/^/| /' "$ac_site_file" >&5
1391     . "$ac_site_file"
1392   fi
1393 done
1394
1395 if test -r "$cache_file"; then
1396   # Some versions of bash will fail to source /dev/null (special
1397   # files actually), so we avoid doing that.
1398   if test -f "$cache_file"; then
1399     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1400 echo "$as_me: loading cache $cache_file" >&6;}
1401     case $cache_file in
1402       [\\/]* | ?:[\\/]* ) . $cache_file;;
1403       *)                      . ./$cache_file;;
1404     esac
1405   fi
1406 else
1407   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1408 echo "$as_me: creating cache $cache_file" >&6;}
1409   >$cache_file
1410 fi
1411
1412 # Check that the precious variables saved in the cache have kept the same
1413 # value.
1414 ac_cache_corrupted=false
1415 for ac_var in `(set) 2>&1 |
1416                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1417   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1418   eval ac_new_set=\$ac_env_${ac_var}_set
1419   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1420   eval ac_new_val="\$ac_env_${ac_var}_value"
1421   case $ac_old_set,$ac_new_set in
1422     set,)
1423       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1424 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1425       ac_cache_corrupted=: ;;
1426     ,set)
1427       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1428 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1429       ac_cache_corrupted=: ;;
1430     ,);;
1431     *)
1432       if test "x$ac_old_val" != "x$ac_new_val"; then
1433         # differences in whitespace do not lead to failure.
1434         ac_old_val_w=`echo x $ac_old_val`
1435         ac_new_val_w=`echo x $ac_new_val`
1436         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1437           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1438 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1439           ac_cache_corrupted=:
1440         else
1441           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1442 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1443           eval $ac_var=\$ac_old_val
1444         fi
1445         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1446 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1447         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1448 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1449       fi;;
1450   esac
1451   # Pass precious variables to config.status.
1452   if test "$ac_new_set" = set; then
1453     case $ac_new_val in
1454     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1455       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1456     *) ac_arg=$ac_var=$ac_new_val ;;
1457     esac
1458     case " $ac_configure_args " in
1459       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1460       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1461     esac
1462   fi
1463 done
1464 if $ac_cache_corrupted; then
1465   { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1466 echo "$as_me: error: in \`$ac_pwd':" >&2;}
1467   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1468 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1469   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1470 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1471    { (exit 1); exit 1; }; }
1472 fi
1473
1474 ac_ext=c
1475 ac_cpp='$CPP $CPPFLAGS'
1476 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1477 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1478 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503 progname=$0
1504 # if PWD already has a value, it is probably wrong.
1505 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1506
1507 # Export original configure arguments for use by sub-configures.
1508 # Quote arguments with shell meta charatcers.
1509 TOPLEVEL_CONFIGURE_ARGUMENTS=
1510 set -- "$progname" "$@"
1511 for ac_arg
1512 do
1513   case "$ac_arg" in
1514   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1515     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1516     # if the argument is of the form -foo=baz, quote the baz part only
1517     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1518   *) ;;
1519   esac
1520   # Add the quoted argument to the list.
1521   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1522 done
1523 if test "$silent" = yes; then
1524   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1525 fi
1526 # Remove the initial space we just introduced and, as these will be
1527 # expanded by make, quote '$'.
1528 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1529
1530
1531 # Find the build, host, and target systems.
1532 ac_aux_dir=
1533 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1534   if test -f $ac_dir/install-sh; then
1535     ac_aux_dir=$ac_dir
1536     ac_install_sh="$ac_aux_dir/install-sh -c"
1537     break
1538   elif test -f $ac_dir/install.sh; then
1539     ac_aux_dir=$ac_dir
1540     ac_install_sh="$ac_aux_dir/install.sh -c"
1541     break
1542   elif test -f $ac_dir/shtool; then
1543     ac_aux_dir=$ac_dir
1544     ac_install_sh="$ac_aux_dir/shtool install -c"
1545     break
1546   fi
1547 done
1548 if test -z "$ac_aux_dir"; then
1549   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1550 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1551    { (exit 1); exit 1; }; }
1552 fi
1553 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1554 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1555 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1556
1557 # Make sure we can run config.sub.
1558 $ac_config_sub sun4 >/dev/null 2>&1 ||
1559   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1560 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1561    { (exit 1); exit 1; }; }
1562
1563 echo "$as_me:$LINENO: checking build system type" >&5
1564 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1565 if test "${ac_cv_build+set}" = set; then
1566   echo $ECHO_N "(cached) $ECHO_C" >&6
1567 else
1568   ac_cv_build_alias=$build_alias
1569 test -z "$ac_cv_build_alias" &&
1570   ac_cv_build_alias=`$ac_config_guess`
1571 test -z "$ac_cv_build_alias" &&
1572   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1573 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1574    { (exit 1); exit 1; }; }
1575 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1576   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1577 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1578    { (exit 1); exit 1; }; }
1579
1580 fi
1581 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1582 echo "${ECHO_T}$ac_cv_build" >&6
1583 build=$ac_cv_build
1584 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1585 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1586 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1587
1588
1589  case ${build_alias} in
1590   "") build_noncanonical=${build} ;;
1591   *) build_noncanonical=${build_alias} ;;
1592 esac
1593
1594
1595
1596  case ${host_alias} in
1597   "") host_noncanonical=${build_noncanonical} ;;
1598   *) host_noncanonical=${host_alias} ;;
1599 esac
1600
1601
1602
1603  case ${target_alias} in
1604   "") target_noncanonical=${host_noncanonical} ;;
1605   *) target_noncanonical=${target_alias} ;;
1606 esac
1607
1608
1609
1610
1611 test "$host_noncanonical" = "$target_noncanonical" &&
1612   test "$program_prefix$program_suffix$program_transform_name" = \
1613     NONENONEs,x,x, &&
1614   program_transform_name=s,y,y,
1615
1616 echo "$as_me:$LINENO: checking host system type" >&5
1617 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1618 if test "${ac_cv_host+set}" = set; then
1619   echo $ECHO_N "(cached) $ECHO_C" >&6
1620 else
1621   ac_cv_host_alias=$host_alias
1622 test -z "$ac_cv_host_alias" &&
1623   ac_cv_host_alias=$ac_cv_build_alias
1624 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1625   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1626 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1627    { (exit 1); exit 1; }; }
1628
1629 fi
1630 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1631 echo "${ECHO_T}$ac_cv_host" >&6
1632 host=$ac_cv_host
1633 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1634 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1635 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1636
1637
1638 echo "$as_me:$LINENO: checking target system type" >&5
1639 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1640 if test "${ac_cv_target+set}" = set; then
1641   echo $ECHO_N "(cached) $ECHO_C" >&6
1642 else
1643   ac_cv_target_alias=$target_alias
1644 test "x$ac_cv_target_alias" = "x" &&
1645   ac_cv_target_alias=$ac_cv_host_alias
1646 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1647   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1648 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1649    { (exit 1); exit 1; }; }
1650
1651 fi
1652 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1653 echo "${ECHO_T}$ac_cv_target" >&6
1654 target=$ac_cv_target
1655 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1656 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1657 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1658
1659
1660 # The aliases save the names the user supplied, while $host etc.
1661 # will get canonicalized.
1662 test -n "$target_alias" &&
1663   test "$program_prefix$program_suffix$program_transform_name" = \
1664     NONENONEs,x,x, &&
1665   program_prefix=${target_alias}-
1666 test "$program_prefix" != NONE &&
1667   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1668 # Use a double $ so make ignores it.
1669 test "$program_suffix" != NONE &&
1670   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1671 # Double any \ or $.  echo might interpret backslashes.
1672 # By default was `s,x,x', remove it if useless.
1673 cat <<\_ACEOF >conftest.sed
1674 s/[\\$]/&&/g;s/;s,x,x,$//
1675 _ACEOF
1676 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1677 rm conftest.sed
1678
1679
1680
1681 # Get 'install' or 'install-sh' and its variants.
1682 # Find a good install program.  We prefer a C program (faster),
1683 # so one script is as good as another.  But avoid the broken or
1684 # incompatible versions:
1685 # SysV /etc/install, /usr/sbin/install
1686 # SunOS /usr/etc/install
1687 # IRIX /sbin/install
1688 # AIX /bin/install
1689 # AmigaOS /C/install, which installs bootblocks on floppy discs
1690 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1691 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1692 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1693 # OS/2's system install, which has a completely different semantic
1694 # ./install, which can be erroneously created by make from ./install.sh.
1695 # Reject install programs that cannot install multiple files.
1696 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1697 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1698 if test -z "$INSTALL"; then
1699 if test "${ac_cv_path_install+set}" = set; then
1700   echo $ECHO_N "(cached) $ECHO_C" >&6
1701 else
1702   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1703 for as_dir in $PATH
1704 do
1705   IFS=$as_save_IFS
1706   test -z "$as_dir" && as_dir=.
1707   # Account for people who put trailing slashes in PATH elements.
1708 case $as_dir/ in
1709   ./ | .// | /cC/* | \
1710   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1711   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1712   /usr/ucb/* ) ;;
1713   *)
1714     # OSF1 and SCO ODT 3.0 have their own names for install.
1715     # Don't use installbsd from OSF since it installs stuff as root
1716     # by default.
1717     for ac_prog in ginstall scoinst install; do
1718       for ac_exec_ext in '' $ac_executable_extensions; do
1719         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1720           if test $ac_prog = install &&
1721             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1722             # AIX install.  It has an incompatible calling convention.
1723             :
1724           elif test $ac_prog = install &&
1725             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1726             # program-specific install script used by HP pwplus--don't use.
1727             :
1728           else
1729             rm -rf conftest.one conftest.two conftest.dir
1730             echo one > conftest.one
1731             echo two > conftest.two
1732             mkdir conftest.dir
1733             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1734               test -s conftest.one && test -s conftest.two &&
1735               test -s conftest.dir/conftest.one &&
1736               test -s conftest.dir/conftest.two
1737             then
1738               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1739               break 3
1740             fi
1741           fi
1742         fi
1743       done
1744     done
1745     ;;
1746 esac
1747 done
1748
1749 rm -rf conftest.one conftest.two conftest.dir
1750
1751 fi
1752   if test "${ac_cv_path_install+set}" = set; then
1753     INSTALL=$ac_cv_path_install
1754   else
1755     # As a last resort, use the slow shell script.  Don't cache a
1756     # value for INSTALL within a source directory, because that will
1757     # break other packages using the cache if that directory is
1758     # removed, or if the value is a relative name.
1759     INSTALL=$ac_install_sh
1760   fi
1761 fi
1762 echo "$as_me:$LINENO: result: $INSTALL" >&5
1763 echo "${ECHO_T}$INSTALL" >&6
1764
1765 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1766 # It thinks the first close brace ends the variable substitution.
1767 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1768
1769 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1770
1771 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1772
1773 echo "$as_me:$LINENO: checking whether ln works" >&5
1774 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1775 if test "${acx_cv_prog_LN+set}" = set; then
1776   echo $ECHO_N "(cached) $ECHO_C" >&6
1777 else
1778   rm -f conftestdata_t
1779 echo >conftestdata_f
1780 if ln conftestdata_f conftestdata_t 2>/dev/null
1781 then
1782   acx_cv_prog_LN=ln
1783 else
1784   acx_cv_prog_LN=no
1785 fi
1786 rm -f conftestdata_f conftestdata_t
1787
1788 fi
1789 if test $acx_cv_prog_LN = no; then
1790   LN="cp"
1791   echo "$as_me:$LINENO: result: no, using $LN" >&5
1792 echo "${ECHO_T}no, using $LN" >&6
1793 else
1794   LN="$acx_cv_prog_LN"
1795   echo "$as_me:$LINENO: result: yes" >&5
1796 echo "${ECHO_T}yes" >&6
1797 fi
1798
1799 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1800 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1801 LN_S=$as_ln_s
1802 if test "$LN_S" = "ln -s"; then
1803   echo "$as_me:$LINENO: result: yes" >&5
1804 echo "${ECHO_T}yes" >&6
1805 else
1806   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1807 echo "${ECHO_T}no, using $LN_S" >&6
1808 fi
1809
1810
1811 ### we might need to use some other shell than /bin/sh for running subshells
1812 ### If we are on Windows, search for the shell.  This will permit people
1813 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1814 ### without also having to set CONFIG_SHELL.  This code will work when
1815 ### using bash, which sets OSTYPE.
1816 case "${OSTYPE}" in
1817 *win32*)
1818   if test x${CONFIG_SHELL} = x ; then
1819     if test ! -f /bin/sh ; then
1820       if test x${SHELL} != x && test -f ${SHELL} ; then
1821         CONFIG_SHELL=${SHELL}
1822         export CONFIG_SHELL
1823       else
1824         for prog in sh sh.exe bash bash.exe; do
1825           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1826           for dir in $PATH; do
1827             test -z "$dir" && dir=.
1828             if test -f $dir/$prog; then
1829               CONFIG_SHELL=$dir/$prog
1830               export CONFIG_SHELL
1831               break
1832             fi
1833           done
1834           IFS="$save_ifs"
1835           test -n "${CONFIG_SHELL}" && break
1836         done
1837       fi
1838     fi
1839   fi
1840   ;;
1841 esac
1842
1843 config_shell=${CONFIG_SHELL-/bin/sh}
1844
1845 moveifchange=${srcdir}/move-if-change
1846
1847 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1848
1849 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1850 # a relative path.
1851 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1852   INSTALL="${srcpwd}/install-sh -c"
1853 fi
1854
1855 # Set srcdir to "." if that's what it is.
1856 # This is important for multilib support.
1857 pwd=`${PWDCMD-pwd}`
1858 if test "${pwd}" = "${srcpwd}" ; then
1859   srcdir=.
1860 fi
1861
1862 topsrcdir=$srcpwd
1863
1864 extra_host_args=
1865
1866 ### To add a new directory to the tree, first choose whether it is a target
1867 ### or a host dependent tool.  Then put it into the appropriate list
1868 ### (library or tools, host or target), doing a dependency sort.
1869
1870 # Subdirs will be configured in the order listed in build_configdirs,
1871 # configdirs, or target_configdirs; see the serialization section below.
1872
1873 # Dependency sorting is only needed when *configuration* must be done in
1874 # a particular order.  In all cases a dependency should be specified in
1875 # the Makefile, whether or not it's implicitly specified here.
1876
1877 # Double entries in build_configdirs, configdirs, or target_configdirs may
1878 # cause circular dependencies and break everything horribly.
1879
1880 # these library is used by various programs built for the build
1881 # environment
1882 #
1883 build_libs="build-libiberty"
1884
1885 # these tools are built for the build environment
1886 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1887
1888 # these libraries are used by various programs built for the host environment
1889 #
1890 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr ppl cloog libiconv"
1891
1892 # these tools are built for the host environment
1893 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1894 # know that we are building the simulator.
1895 # binutils, gas and ld appear in that order because it makes sense to run
1896 # "make check" in that particular order.
1897 # If --enable-gold is used, "gold" will replace "ld".
1898 host_tools="texinfo byacc flex bison binutils gas ld fixincludes gcc sid sim gdb make patch prms send-pr gprof etc expect dejagnu ash bash bzip2 m4 autoconf automake libtool diff rcs fileutils shellutils time textutils wdiff find uudecode hello tar gzip indent recode release sed utils guile perl gawk findutils gettext zip fastjar gnattools"
1899
1900 # libgcj represents the runtime libraries only used by gcj.
1901 libgcj="target-libffi \
1902         target-zlib \
1903         target-qthreads \
1904         target-libjava"
1905
1906 # these libraries are built for the target environment, and are built after
1907 # the host libraries and the host tools (which may be a cross compiler)
1908 #
1909 target_libraries="target-libgcc \
1910                 target-libiberty \
1911                 target-libgloss \
1912                 target-newlib \
1913                 target-libgomp \
1914                 target-libstdc++-v3 \
1915                 target-libmudflap \
1916                 target-libssp \
1917                 target-libgfortran \
1918                 target-boehm-gc \
1919                 ${libgcj} \
1920                 target-libobjc \
1921                 target-libada"
1922
1923 # these tools are built using the target libraries, and are intended to
1924 # run only in the target environment
1925 #
1926 # note: any program that *uses* libraries that are in the "target_libraries"
1927 # list belongs in this list.  those programs are also very likely
1928 # candidates for the "native_only" list which follows
1929 #
1930 target_tools="target-examples target-groff target-gperf target-rda"
1931
1932 ################################################################################
1933
1934 ## All tools belong in one of the four categories, and are assigned above
1935 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1936 ## is important because configure will choke if they ever get through.
1937 ## ${configdirs} is directories we build using the host tools.
1938 ## ${target_configdirs} is directories we build using the target tools.
1939 configdirs=`echo ${host_libs} ${host_tools}`
1940 target_configdirs=`echo ${target_libraries} ${target_tools}`
1941 build_configdirs=`echo ${build_libs} ${build_tools}`
1942
1943
1944
1945 ################################################################################
1946
1947 srcname="gnu development package"
1948
1949 # This gets set non-empty for some net releases of packages.
1950 appdirs=""
1951
1952 # Define is_cross_compiler to save on calls to 'test'.
1953 is_cross_compiler=
1954 if test x"${host}" = x"${target}" ; then
1955   is_cross_compiler=no
1956 else
1957   is_cross_compiler=yes
1958 fi
1959
1960 # Find the build and target subdir names.
1961
1962 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1963 # have matching libraries, they should use host libraries: Makefile.tpl
1964 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1965 # However, they still use the build modules, because the corresponding
1966 # host modules (e.g. bison) are only built for the host when bootstrap
1967 # finishes. So:
1968 # - build_subdir is where we find build modules, and never changes.
1969 # - build_libsubdir is where we find build libraries, and can be overridden.
1970
1971 # Prefix 'build-' so this never conflicts with target_subdir.
1972 build_subdir="build-${build_noncanonical}"
1973
1974 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1975 if test "${with_build_libsubdir+set}" = set; then
1976   withval="$with_build_libsubdir"
1977   build_libsubdir="$withval"
1978 else
1979   build_libsubdir="$build_subdir"
1980 fi;
1981 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1982 if ( test $srcdir = . && test -d gcc ) \
1983    || test -d $srcdir/../host-${host_noncanonical}; then
1984   host_subdir="host-${host_noncanonical}"
1985 else
1986   host_subdir=.
1987 fi
1988 # No prefix.
1989 target_subdir=${target_noncanonical}
1990
1991
1992 # Skipdirs are removed silently.
1993 skipdirs=
1994 # Noconfigdirs are removed loudly.
1995 noconfigdirs=""
1996
1997 use_gnu_ld=
1998 # Make sure we don't let GNU ld be added if we didn't want it.
1999 if test x$with_gnu_ld = xno ; then
2000   use_gnu_ld=no
2001   noconfigdirs="$noconfigdirs ld gold"
2002 fi
2003
2004 use_gnu_as=
2005 # Make sure we don't let GNU as be added if we didn't want it.
2006 if test x$with_gnu_as = xno ; then
2007   use_gnu_as=no
2008   noconfigdirs="$noconfigdirs gas"
2009 fi
2010
2011 # some tools are so dependent upon X11 that if we're not building with X,
2012 # it's not even worth trying to configure, much less build, that tool.
2013
2014 case ${with_x} in
2015   yes | "") ;; # the default value for this tree is that X11 is available
2016   no)
2017     skipdirs="${skipdirs} tk itcl libgui"
2018     # We won't be able to build gdbtk without X.
2019     enable_gdbtk=no
2020     ;;
2021   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2022 esac
2023
2024 # Some tools are only suitable for building in a "native" situation.
2025 # Remove these if host!=target.
2026 native_only="autoconf automake libtool fileutils find gawk gettext gzip hello indent m4 rcs recode sed shellutils tar textutils uudecode wdiff target-groff guile perl time ash bash bzip2 prms gnuserv target-gperf"
2027
2028 # Similarly, some are only suitable for cross toolchains.
2029 # Remove these if host=target.
2030 cross_only="target-libgloss target-newlib target-opcodes"
2031
2032 case $is_cross_compiler in
2033   no) skipdirs="${skipdirs} ${cross_only}" ;;
2034   yes) skipdirs="${skipdirs} ${native_only}" ;;
2035 esac
2036
2037 # If both --with-headers and --with-libs are specified, default to
2038 # --without-newlib.
2039 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2040    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2041   if test x"${with_newlib}" = x ; then
2042     with_newlib=no
2043   fi
2044 fi
2045
2046 # Recognize --with-newlib/--without-newlib.
2047 case ${with_newlib} in
2048   no) skipdirs="${skipdirs} target-newlib" ;;
2049   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2050 esac
2051
2052 # Handle --enable-gold.
2053
2054 # Check whether --enable-gold or --disable-gold was given.
2055 if test "${enable_gold+set}" = set; then
2056   enableval="$enable_gold"
2057   ENABLE_GOLD=$enableval
2058 else
2059   ENABLE_GOLD=no
2060 fi;
2061 if test "${ENABLE_GOLD}" = "yes"; then
2062   # Check for ELF target.
2063   is_elf=no
2064   case "${target}" in
2065     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2066     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2067     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2068       case "${target}" in
2069         *-*-linux*aout* | *-*-linux*oldld*)
2070           ;;
2071         *)
2072           is_elf=yes
2073           ;;
2074       esac
2075   esac
2076
2077   if test "$is_elf" = "yes"; then
2078     # Check for target supported by gold.
2079     case "${target}" in
2080       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-*)
2081         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2082         ;;
2083     esac
2084   fi
2085 fi
2086
2087 # Configure extra directories which are host specific
2088
2089 case "${host}" in
2090   *-cygwin*)
2091     configdirs="$configdirs libtermcap" ;;
2092 esac
2093
2094 # A target can indicate whether a language isn't supported for some reason.
2095 # Only spaces may be used in this macro; not newlines or tabs.
2096 unsupported_languages=
2097
2098 # Remove more programs from consideration, based on the host or
2099 # target this usually means that a port of the program doesn't
2100 # exist yet.
2101
2102 case "${host}" in
2103   hppa*64*-*-*)
2104     noconfigdirs="$noconfigdirs byacc"
2105     ;;
2106   i[3456789]86-*-vsta)
2107     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2108     ;;
2109   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2110     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2111     ;;
2112   x86_64-*-mingw*)
2113     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2114     ;;
2115   i[3456789]86-*-mingw32*)
2116     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2117     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2118     ;;
2119   i[3456789]86-*-beos*)
2120     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2121     ;;
2122   *-*-cygwin*)
2123     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2124     ;;
2125   *-*-netbsd*)
2126     noconfigdirs="$noconfigdirs rcs"
2127     ;;
2128   ppc*-*-pe)
2129     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2130     ;;
2131   powerpc-*-beos*)
2132     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2133     ;;
2134 esac
2135
2136
2137 # Check whether --enable-libada or --disable-libada was given.
2138 if test "${enable_libada+set}" = set; then
2139   enableval="$enable_libada"
2140   ENABLE_LIBADA=$enableval
2141 else
2142   ENABLE_LIBADA=yes
2143 fi;
2144 if test "${ENABLE_LIBADA}" != "yes" ; then
2145   noconfigdirs="$noconfigdirs gnattools"
2146 fi
2147
2148 # Check whether --enable-libssp or --disable-libssp was given.
2149 if test "${enable_libssp+set}" = set; then
2150   enableval="$enable_libssp"
2151   ENABLE_LIBSSP=$enableval
2152 else
2153   ENABLE_LIBSSP=yes
2154 fi;
2155
2156 # Save it here so that, even in case of --enable-libgcj, if the Java
2157 # front-end isn't enabled, we still get libgcj disabled.
2158 libgcj_saved=$libgcj
2159 case $enable_libgcj in
2160 yes)
2161   # If we reset it here, it won't get added to noconfigdirs in the
2162   # target-specific build rules, so it will be forcibly enabled
2163   # (unless the Java language itself isn't enabled).
2164   libgcj=
2165   ;;
2166 no)
2167   # Make sure we get it printed in the list of not supported target libs.
2168   noconfigdirs="$noconfigdirs ${libgcj}"
2169   ;;
2170 esac
2171
2172
2173 # Disable libmudflap on some systems.
2174 if test x$enable_libmudflap = x ; then
2175     case "${target}" in
2176     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux* | *-*-kopensolaris*-gnu)
2177         # Enable libmudflap by default in GNU and friends.
2178         ;;
2179     *-*-freebsd*)
2180         # Enable libmudflap by default in FreeBSD.
2181         ;;
2182     *)
2183         # Disable it by default everywhere else.
2184         noconfigdirs="$noconfigdirs target-libmudflap"
2185         ;;
2186     esac
2187 fi
2188
2189 # Disable libgomp on non POSIX hosted systems.
2190 if test x$enable_libgomp = x ; then
2191     # Enable libgomp by default on hosted POSIX systems.
2192     case "${target}" in
2193     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2194         ;;
2195     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2196         ;;
2197     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2198         ;;
2199     *-*-darwin* | *-*-aix*)
2200         ;;
2201     *)
2202         noconfigdirs="$noconfigdirs target-libgomp"
2203         ;;
2204     esac
2205 fi
2206
2207 # Default libgloss CPU subdirectory.
2208 libgloss_dir="$target_cpu"
2209
2210 case "${target}" in
2211   *-*-chorusos)
2212     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2213     ;;
2214   powerpc-*-darwin*)
2215     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2216     noconfigdirs="$noconfigdirs sim target-rda"
2217     ;;
2218   i[3456789]86-*-darwin* | x86_64-*-darwin[912]*)
2219     noconfigdirs="$noconfigdirs ld gas gprof"
2220     noconfigdirs="$noconfigdirs sim target-rda"
2221     ;;
2222   *-*-darwin*)
2223     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2224     noconfigdirs="$noconfigdirs sim target-rda"
2225     noconfigdirs="$noconfigdirs ${libgcj}"
2226     ;;
2227   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2228     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2229     ;;
2230   *-*-freebsd*)
2231     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2232     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2233         && test -f /usr/local/include/gmp.h; then
2234       with_gmp=/usr/local
2235     fi
2236
2237     # Skip some stuff that's unsupported on some FreeBSD configurations.
2238     case "${target}" in
2239       i*86-*-*) ;;
2240       alpha*-*-*) ;;
2241       *)
2242         noconfigdirs="$noconfigdirs ${libgcj}"
2243         ;;
2244     esac
2245     ;;
2246   *-*-kaos*)
2247     # Remove unsupported stuff on all kaOS configurations.
2248     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2249     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2250     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2251     noconfigdirs="$noconfigdirs target-libgloss"
2252     ;;
2253   *-*-netbsd*)
2254     # Skip some stuff on all NetBSD configurations.
2255     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2256
2257     # Skip some stuff that's unsupported on some NetBSD configurations.
2258     case "${target}" in
2259       i*86-*-netbsdelf*) ;;
2260       arm*-*-netbsdelf*) ;;
2261       *)
2262         noconfigdirs="$noconfigdirs ${libgcj}"
2263         ;;
2264     esac
2265     ;;
2266   *-*-netware*)
2267     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2268     ;;
2269   *-*-rtems*)
2270     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2271     ;;
2272     # The tpf target doesn't support gdb yet.
2273   *-*-tpf*)
2274     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2275     ;;
2276   *-*-uclinux*)
2277     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2278     ;;
2279   *-*-vxworks*)
2280     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2281     ;;
2282   alpha*-dec-osf*)
2283     # ld works, but does not support shared libraries.
2284     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2285     # gas doesn't generate exception information.
2286     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2287     ;;
2288   alpha*-*-*vms*)
2289     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2290     ;;
2291   alpha*-*-linux*)
2292     # newlib is not 64 bit ready
2293     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2294     ;;
2295   alpha*-*-*)
2296     # newlib is not 64 bit ready
2297     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2298     ;;
2299   am33_2.0-*-linux*)
2300     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2301     ;;
2302   sh-*-linux*)
2303     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2304     ;;
2305   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2306     noconfigdirs="$noconfigdirs ${libgcj}"
2307     noconfigdirs="$noconfigdirs target-examples"
2308     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2309     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2310     noconfigdirs="$noconfigdirs expect dejagnu"
2311     # the C++ libraries don't build on top of CE's C libraries
2312     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2313     noconfigdirs="$noconfigdirs target-newlib"
2314     case "${host}" in
2315       *-*-cygwin*) ;; # keep gdb and readline
2316       *) noconfigdirs="$noconfigdirs gdb readline"
2317          ;;
2318     esac
2319     libgloss_dir=wince
2320     ;;
2321   arc-*-*)
2322     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2323     ;;
2324   arm-semi-aof )
2325     ;;
2326   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2327     noconfigdirs="$noconfigdirs ${libgcj}"
2328     libgloss_dir=arm
2329     ;;
2330   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2331     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2332     libgloss_dir=arm
2333     ;;
2334   arm*-*-linux-gnueabi)
2335     noconfigdirs="$noconfigdirs target-qthreads"
2336     case ${with_newlib} in
2337       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2338     esac
2339     libgloss_dir=arm
2340     ;;
2341   arm*-*-symbianelf*)
2342     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2343     libgloss_dir=arm
2344     ;;
2345   arm-*-pe*)
2346     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2347     ;;
2348   thumb-*-coff)
2349     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2350     ;;
2351   thumb-*-elf)
2352     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2353     ;;
2354   thumb-*-pe)
2355     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2356     ;;
2357   arm-*-riscix*)
2358     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2359     ;;
2360   avr-*-*)
2361     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2362     ;;
2363   bfin-*-*)
2364     noconfigdirs="$noconfigdirs gdb"
2365     if test x${is_cross_compiler} != xno ; then
2366       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2367     fi
2368     ;;
2369   c4x-*-* | tic4x-*-*)
2370     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2371     ;;
2372   c54x*-*-* | tic54x-*-*)
2373     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2374     ;;
2375   cr16-*-*)
2376     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2377     ;;
2378   cris-*-* | crisv32-*-*)
2379     unsupported_languages="$unsupported_languages java"
2380     case "${target}" in
2381       *-*-aout)
2382         unsupported_languages="$unsupported_languages fortran"
2383         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2384       *-*-elf)
2385         noconfigdirs="$noconfigdirs target-boehm-gc";;
2386       *-*-linux*)
2387         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2388       *)
2389         unsupported_languages="$unsupported_languages fortran"
2390         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2391     esac
2392     libgloss_dir=cris
2393     ;;
2394   crx-*-*)
2395     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2396     ;;
2397   d10v-*-*)
2398     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2399     ;;
2400   d30v-*-*)
2401     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2402     ;;
2403   ep9312-*-elf | ep9312-*-coff)
2404     libgloss_dir=arm
2405     ;;
2406   fr30-*-elf*)
2407     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2408     ;;
2409   frv-*-*)
2410     noconfigdirs="$noconfigdirs ${libgcj}"
2411     ;;
2412   moxie-*-*)
2413     noconfigdirs="$noconfigdirs ${libgcj}"
2414     noconfigdirs="$noconfigdirs gprof"
2415     ;;
2416   h8300*-*-*)
2417     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2418     ;;
2419   h8500-*-*)
2420     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2421     ;;
2422   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2423     ;;
2424   hppa*64*-*-linux* | parisc*64*-*-linux*)
2425     # In this case, it's because the hppa64-linux target is for
2426     # the kernel only at this point and has no libc, and thus no
2427     # headers, crt*.o, etc., all of which are needed by these.
2428     noconfigdirs="$noconfigdirs target-zlib"
2429     ;;
2430   parisc*-*-linux* | hppa*-*-linux*)
2431     ;;
2432   hppa*-*-*elf* | \
2433   hppa*-*-lites* | \
2434   hppa*-*-openbsd* | \
2435   hppa*64*-*-*)
2436     noconfigdirs="$noconfigdirs ${libgcj}"
2437     ;;
2438   hppa*-hp-hpux11*)
2439     noconfigdirs="$noconfigdirs ld shellutils"
2440     ;;
2441   hppa*-*-pro*)
2442     libgloss_dir=pa
2443     ;;
2444   hppa*-*-*)
2445     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2446     # build on HP-UX 10.20.
2447     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2448     ;;
2449   i960-*-*)
2450     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2451     ;;
2452   ia64*-*-elf*)
2453     # No gdb support yet.
2454     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2455     ;;
2456   ia64*-**-hpux*)
2457     # No gdb or ld support yet.
2458     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2459     ;;
2460   ia64*-*-*vms*)
2461     # No gdb or ld support yet.
2462     noconfigdirs="$noconfigdirs ${libgcj} tix readline mmalloc libgui itcl gdb ld"
2463     ;;
2464   i370-*-opened*)
2465     ;;
2466   i[3456789]86-*-coff | i[3456789]86-*-elf)
2467     noconfigdirs="$noconfigdirs ${libgcj}"
2468     libgloss_dir=i386
2469     ;;
2470   i[3456789]86-*-linux*)
2471     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2472     # not build java stuff by default.
2473     case "${target}" in
2474       *-*-*libc1*)
2475         noconfigdirs="$noconfigdirs ${libgcj}";;
2476     esac
2477
2478     # This section makes it possible to build newlib natively on linux.
2479     # If we are using a cross compiler then don't configure newlib.
2480     if test x${is_cross_compiler} != xno ; then
2481       noconfigdirs="$noconfigdirs target-newlib"
2482     fi
2483     noconfigdirs="$noconfigdirs target-libgloss"
2484     # If we are not using a cross compiler, do configure newlib.
2485     # Note however, that newlib will only be configured in this situation
2486     # if the --with-newlib option has been given, because otherwise
2487     # 'target-newlib' will appear in skipdirs.
2488     ;;
2489   i[3456789]86-*-mingw32*)
2490     target_configdirs="$target_configdirs target-winsup"
2491     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2492     ;;
2493   x86_64-*-mingw*)
2494     target_configdirs="$target_configdirs target-winsup"
2495     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2496     ;;
2497   *-*-cygwin*)
2498     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2499     noconfigdirs="$noconfigdirs target-gperf target-libgloss"
2500     # always build newlib if winsup directory is present.
2501     if test -d "$srcdir/winsup/cygwin"; then
2502       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2503     elif test -d "$srcdir/newlib"; then
2504       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2505     fi
2506     ;;
2507   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2508   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2509     ;;
2510   i[3456789]86-*-pe)
2511     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2512     ;;
2513   i[3456789]86-*-sco3.2v5*)
2514     # The linker does not yet know about weak symbols in COFF,
2515     # and is not configured to handle mixed ELF and COFF.
2516     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2517     ;;
2518   i[3456789]86-*-sco*)
2519     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2520     ;;
2521   i[3456789]86-*-solaris2*)
2522     noconfigdirs="$noconfigdirs target-libgloss"
2523     ;;
2524   i[3456789]86-*-sysv4*)
2525     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2526     ;;
2527   i[3456789]86-*-beos*)
2528     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2529     ;;
2530   i[3456789]86-*-rdos*)
2531     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2532     ;;
2533   m32r-*-*)
2534     noconfigdirs="$noconfigdirs ${libgcj}"
2535     ;;
2536   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2537     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2538     libgloss_dir=m68hc11
2539     ;;
2540   m68k-*-elf*)
2541     noconfigdirs="$noconfigdirs ${libgcj}"
2542     ;;
2543   m68k-*-coff*)
2544     noconfigdirs="$noconfigdirs ${libgcj}"
2545     ;;
2546   m68*-*-* | fido-*-*)
2547     libgloss_dir=m68k
2548     ;;
2549   mcore-*-pe*)
2550   # The EPOC C++ environment does not support exceptions or rtti,
2551   # and so building libstdc++-v3 tends not to always work.
2552     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2553     ;;
2554   mmix-*-*)
2555     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2556     unsupported_languages="$unsupported_languages fortran java"
2557     ;;
2558   mn10200-*-*)
2559     noconfigdirs="$noconfigdirs ${libgcj}"
2560     ;;
2561   mn10300-*-*)
2562     noconfigdirs="$noconfigdirs ${libgcj}"
2563     ;;
2564   mt-*-*)
2565     noconfigdirs="$noconfigdirs sim"
2566     ;;
2567   powerpc-*-aix*)
2568     # copied from rs6000-*-* entry
2569     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2570     ;;
2571   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2572     target_configdirs="$target_configdirs target-winsup"
2573     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2574     # always build newlib.
2575     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2576     ;;
2577     # This is temporary until we can link against shared libraries
2578   powerpcle-*-solaris*)
2579     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2580     libgloss_dir=rs6000
2581     ;;
2582   powerpc-*-beos*)
2583     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2584     ;;
2585   powerpc-*-eabi)
2586     noconfigdirs="$noconfigdirs ${libgcj}"
2587     libgloss_dir=rs6000
2588     ;;
2589   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2590     libgloss_dir=rs6000
2591     ;;
2592   rs6000-*-lynxos*)
2593     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2594     ;;
2595   rs6000-*-aix*)
2596     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2597     ;;
2598   rs6000-*-*)
2599     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2600     ;;
2601   m68k-apollo-*)
2602     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2603     ;;
2604   mips*-sde-elf*)
2605     skipdirs="$skipdirs target-libiberty"
2606     noconfigdirs="$noconfigdirs ${libgcj}"
2607     if test x$with_newlib = xyes; then
2608       noconfigdirs="$noconfigdirs gprof"
2609     fi
2610     libgloss_dir=mips
2611     ;;
2612   mips*-*-irix5*)
2613     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2614     ;;
2615   mips*-*-irix6*)
2616     # Linking libjava exceeds command-line length limits on at least
2617     # IRIX 6.2, but not on IRIX 6.5.
2618     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2619     # <oldham@codesourcery.com>
2620     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2621     ;;
2622   mips*-*-bsd*)
2623     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2624     ;;
2625   mips*-*-linux*)
2626     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2627     ;;
2628   mips*-*-*)
2629     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2630     libgloss_dir=mips
2631     ;;
2632   romp-*-*)
2633     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2634     ;;
2635   sh-*-* | sh64-*-*)
2636     case "${host}" in
2637       i[3456789]86-*-vsta) ;; # don't add gprof back in
2638       i[3456789]86-*-go32*) ;; # don't add gprof back in
2639       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2640       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2641     esac
2642     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2643     ;;
2644   sparclet-*-aout* | sparc86x-*-*)
2645     libgloss_dir=sparc
2646     ;;
2647   sparc-*-elf*)
2648     noconfigdirs="$noconfigdirs ${libgcj}"
2649     ;;
2650   sparc64-*-elf*)
2651     noconfigdirs="$noconfigdirs ${libgcj}"
2652     libgloss_dir=sparc
2653     ;;
2654   sparclite-*-*)
2655     noconfigdirs="$noconfigdirs ${libgcj}"
2656     libgloss_dir=sparc
2657     ;;
2658   sparc-*-sunos4*)
2659     noconfigdirs="$noconfigdirs ${libgcj}"
2660     if test x${is_cross_compiler} != xno ; then
2661            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2662     else
2663            use_gnu_ld=no
2664     fi
2665     ;;
2666   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2667     noconfigdirs="$noconfigdirs ${libgcj}"
2668     ;;
2669   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2670     ;;
2671   v810-*-*)
2672     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2673     ;;
2674   v850-*-*)
2675     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2676     ;;
2677   v850e-*-*)
2678     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2679     ;;
2680   v850ea-*-*)
2681     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2682     ;;
2683   vax-*-vms)
2684     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2685     ;;
2686   vax-*-*)
2687     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2688     ;;
2689   xtensa*-*-*)
2690     noconfigdirs="$noconfigdirs ${libgcj}"
2691     ;;
2692   ip2k-*-*)
2693     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2694     ;;
2695   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2696     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2697     ;;
2698   *-*-lynxos*)
2699     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2700     ;;
2701   *-*-*)
2702     noconfigdirs="$noconfigdirs ${libgcj}"
2703     ;;
2704 esac
2705
2706 # If we aren't building newlib, then don't build libgloss, since libgloss
2707 # depends upon some newlib header files.
2708 case "${noconfigdirs}" in
2709   *target-libgloss*) ;;
2710   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2711 esac
2712
2713 # Work in distributions that contain no compiler tools, like Autoconf.
2714 tentative_cc=""
2715 host_makefile_frag=/dev/null
2716 if test -d ${srcdir}/config ; then
2717 case "${host}" in
2718   m68k-hp-hpux*)
2719     # Avoid "too much defining" errors from HPUX compiler.
2720     tentative_cc="cc -Wp,-H256000"
2721     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2722     # If it's HP/UX ar, this should be harmless.
2723     RANLIB="ar ts"
2724     ;;
2725   m68k-apollo-sysv*)
2726     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2727     ;;
2728   m68k-apollo-bsd*)
2729     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2730     # chokes on bfd, the compiler won't let you assign integers to enums, and
2731     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2732     # the apollo compiler" (the preferred version of GCC could be called cc,
2733     # or whatever), but I'm not sure leaving CC as cc is any better...
2734     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2735     # Used to have BISON=yacc.
2736     tentative_cc=gcc
2737     ;;
2738   m88k-dg-dgux*)
2739     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2740     ;;
2741   m88k-harris-cxux*)
2742     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2743     tentative_cc="cc -Xa"
2744     host_makefile_frag="config/mh-cxux"
2745     ;;
2746   m88k-motorola-sysv*)
2747     ;;
2748   mips*-dec-ultrix*)
2749     tentative_cc="cc -Wf,-XNg1000"
2750     host_makefile_frag="config/mh-decstation"
2751     ;;
2752   mips*-nec-sysv4*)
2753     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2754     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2755     host_makefile_frag="config/mh-necv4"
2756     ;;
2757   mips*-sgi-irix4*)
2758     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2759     # environment.  Also bump switch table size so that cp-parse will
2760     # compile.  Bump string length limit so linker builds.
2761     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2762     ;;
2763   mips*-*-sysv4*)
2764     host_makefile_frag="config/mh-sysv4"
2765     ;;
2766   mips*-*-sysv*)
2767     # This is for a MIPS running RISC/os 4.52C.
2768
2769     # This is needed for GDB, but needs to be in the top-level make because
2770     # if a library is compiled with the bsd headers and gets linked with the
2771     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2772     # a different size).
2773     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2774     # known except to select the sysv environment.  Could we use /proc instead?
2775     # These "sysv environments" and "bsd environments" often end up being a pain.
2776     #
2777     # This is not part of CFLAGS because perhaps not all C compilers have this
2778     # option.
2779     tentative_cc="cc -systype sysv"
2780     ;;
2781   i370-ibm-opened*)
2782     tentative_cc="c89"
2783     ;;
2784   i[3456789]86-*-sysv5*)
2785     host_makefile_frag="config/mh-sysv5"
2786     ;;
2787   i[3456789]86-*-dgux*)
2788     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2789     host_makefile_frag="config/mh-dgux386"
2790     ;;
2791   i[3456789]86-ncr-sysv4.3*)
2792     # The MetaWare compiler will generate a copyright message unless you
2793     # turn it off by adding the -Hnocopyr flag.
2794     tentative_cc="cc -Hnocopyr"
2795     ;;
2796   i[3456789]86-ncr-sysv4*)
2797     # for an NCR 3000 (i486/SVR4) system.
2798     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2799     # This compiler not only emits obnoxious copyright messages every time
2800     # you run it, but it chokes and dies on a whole bunch of GNU source
2801     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2802     tentative_cc="/usr/ccs/ATT/cc"
2803     host_makefile_frag="config/mh-ncr3000"
2804     ;;
2805   i[3456789]86-*-sco3.2v5*)
2806     ;;
2807   i[3456789]86-*-sco*)
2808     # The native C compiler botches some simple uses of const.  Unfortunately,
2809     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2810     tentative_cc="cc -Dconst="
2811     host_makefile_frag="config/mh-sco"
2812     ;;
2813   i[3456789]86-*-udk*)
2814     host_makefile_frag="config/mh-sysv5"
2815     ;;
2816   i[3456789]86-*-solaris2*)
2817     host_makefile_frag="config/mh-sysv4"
2818     ;;
2819   i[3456789]86-*-msdosdjgpp*)
2820     host_makefile_frag="config/mh-djgpp"
2821     ;;
2822   *-cygwin*)
2823
2824 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2825 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2826 echo a >cygwin-cat-check
2827 if test `cat cygwin-cat-check` == a ; then
2828   rm cygwin-cat-check
2829   echo "$as_me:$LINENO: result: yes" >&5
2830 echo "${ECHO_T}yes" >&6
2831 else
2832   rm cygwin-cat-check
2833   echo "$as_me:$LINENO: result: no" >&5
2834 echo "${ECHO_T}no" >&6
2835   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2836   Please either mount the build directory in binary mode or run the following
2837   commands before running any configure script:
2838 set -o igncr
2839 export SHELLOPTS
2840   " >&5
2841 echo "$as_me: error: The cat command does not ignore carriage return characters.
2842   Please either mount the build directory in binary mode or run the following
2843   commands before running any configure script:
2844 set -o igncr
2845 export SHELLOPTS
2846   " >&2;}
2847    { (exit 1); exit 1; }; }
2848 fi
2849
2850     host_makefile_frag="config/mh-cygwin"
2851     ;;
2852   *-mingw*)
2853     host_makefile_frag="config/mh-mingw"
2854     ;;
2855   *-interix*)
2856     host_makefile_frag="config/mh-interix"
2857     ;;
2858   vax-*-ultrix2*)
2859     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2860     tentative_cc=gcc
2861     ;;
2862   *-*-solaris2*)
2863     host_makefile_frag="config/mh-solaris"
2864     ;;
2865   m68k-sun-sunos*)
2866     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2867     # without overflowing the jump tables (-J says to use a 32 bit table)
2868     tentative_cc="cc -J"
2869     ;;
2870   hppa*-hp-hpux10*)
2871     tentative_cc="cc -Wp,-H256000"
2872     host_makefile_frag="config/mh-pa-hpux10"
2873     ;;
2874   hppa*-hp-hpux* | hppa*-*-hiux*)
2875     tentative_cc="cc -Wp,-H256000"
2876     host_makefile_frag="config/mh-pa"
2877     ;;
2878   hppa*-*)
2879     host_makefile_frag="config/mh-pa"
2880     ;;
2881   *-hp-hpux* | *-*-hiux*)
2882     tentative_cc="cc -Wp,-H256000"
2883     ;;
2884   rs6000-*-lynxos*)
2885     # /bin/cc is less than useful for our purposes.  Always use GCC
2886     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2887     host_makefile_frag="config/mh-lynxrs6k"
2888     ;;
2889   powerpc-*-darwin*)
2890     host_makefile_frag="config/mh-ppc-darwin"
2891     ;;
2892   powerpc-*-aix*)
2893     host_makefile_frag="config/mh-ppc-aix"
2894     ;;
2895   rs6000-*-aix*)
2896     host_makefile_frag="config/mh-ppc-aix"
2897     ;;
2898   *-*-lynxos*)
2899     # /bin/cc is less than useful for our purposes.  Always use GCC
2900     tentative_cc="/bin/gcc"
2901     ;;
2902   *-*-sysv4*)
2903     host_makefile_frag="config/mh-sysv4"
2904     ;;
2905   # This is placed last to prevent interfering with the cases above.
2906   i[3456789]86-*-*)
2907     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2908     host_makefile_frag="config/mh-x86omitfp"
2909     ;;
2910 esac
2911 fi
2912
2913 # If we aren't going to be using gcc, see if we can extract a definition
2914 # of CC from the fragment.
2915 # Actually, use the 'pre-extracted' version above.
2916 if test -z "${CC}" && test "${build}" = "${host}" ; then
2917   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2918   found=
2919   for dir in $PATH; do
2920     test -z "$dir" && dir=.
2921     if test -f $dir/gcc; then
2922       found=yes
2923       break
2924     fi
2925   done
2926   IFS="$save_ifs"
2927   if test -z "${found}" && test -n "${tentative_cc}" ; then
2928     CC=$tentative_cc
2929   fi
2930 fi
2931
2932 if test "${build}" != "${host}" ; then
2933   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2934   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2935   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2936   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2937   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2938   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2939   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2940   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2941   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2942   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2943   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2944   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2945 else
2946   AR_FOR_BUILD="\$(AR)"
2947   AS_FOR_BUILD="\$(AS)"
2948   CC_FOR_BUILD="\$(CC)"
2949   CXX_FOR_BUILD="\$(CXX)"
2950   GCJ_FOR_BUILD="\$(GCJ)"
2951   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2952   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2953   LD_FOR_BUILD="\$(LD)"
2954   NM_FOR_BUILD="\$(NM)"
2955   RANLIB_FOR_BUILD="\$(RANLIB)"
2956   WINDRES_FOR_BUILD="\$(WINDRES)"
2957   WINDMC_FOR_BUILD="\$(WINDMC)"
2958 fi
2959
2960 ac_ext=c
2961 ac_cpp='$CPP $CPPFLAGS'
2962 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2963 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2964 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2965 if test -n "$ac_tool_prefix"; then
2966   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2967 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2968 echo "$as_me:$LINENO: checking for $ac_word" >&5
2969 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2970 if test "${ac_cv_prog_CC+set}" = set; then
2971   echo $ECHO_N "(cached) $ECHO_C" >&6
2972 else
2973   if test -n "$CC"; then
2974   ac_cv_prog_CC="$CC" # Let the user override the test.
2975 else
2976 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2977 for as_dir in $PATH
2978 do
2979   IFS=$as_save_IFS
2980   test -z "$as_dir" && as_dir=.
2981   for ac_exec_ext in '' $ac_executable_extensions; do
2982   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2983     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2984     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2985     break 2
2986   fi
2987 done
2988 done
2989
2990 fi
2991 fi
2992 CC=$ac_cv_prog_CC
2993 if test -n "$CC"; then
2994   echo "$as_me:$LINENO: result: $CC" >&5
2995 echo "${ECHO_T}$CC" >&6
2996 else
2997   echo "$as_me:$LINENO: result: no" >&5
2998 echo "${ECHO_T}no" >&6
2999 fi
3000
3001 fi
3002 if test -z "$ac_cv_prog_CC"; then
3003   ac_ct_CC=$CC
3004   # Extract the first word of "gcc", so it can be a program name with args.
3005 set dummy gcc; ac_word=$2
3006 echo "$as_me:$LINENO: checking for $ac_word" >&5
3007 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3008 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3009   echo $ECHO_N "(cached) $ECHO_C" >&6
3010 else
3011   if test -n "$ac_ct_CC"; then
3012   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3013 else
3014 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3015 for as_dir in $PATH
3016 do
3017   IFS=$as_save_IFS
3018   test -z "$as_dir" && as_dir=.
3019   for ac_exec_ext in '' $ac_executable_extensions; do
3020   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3021     ac_cv_prog_ac_ct_CC="gcc"
3022     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3023     break 2
3024   fi
3025 done
3026 done
3027
3028 fi
3029 fi
3030 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3031 if test -n "$ac_ct_CC"; then
3032   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3033 echo "${ECHO_T}$ac_ct_CC" >&6
3034 else
3035   echo "$as_me:$LINENO: result: no" >&5
3036 echo "${ECHO_T}no" >&6
3037 fi
3038
3039   CC=$ac_ct_CC
3040 else
3041   CC="$ac_cv_prog_CC"
3042 fi
3043
3044 if test -z "$CC"; then
3045   if test -n "$ac_tool_prefix"; then
3046   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3047 set dummy ${ac_tool_prefix}cc; ac_word=$2
3048 echo "$as_me:$LINENO: checking for $ac_word" >&5
3049 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3050 if test "${ac_cv_prog_CC+set}" = set; then
3051   echo $ECHO_N "(cached) $ECHO_C" >&6
3052 else
3053   if test -n "$CC"; then
3054   ac_cv_prog_CC="$CC" # Let the user override the test.
3055 else
3056 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3057 for as_dir in $PATH
3058 do
3059   IFS=$as_save_IFS
3060   test -z "$as_dir" && as_dir=.
3061   for ac_exec_ext in '' $ac_executable_extensions; do
3062   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3063     ac_cv_prog_CC="${ac_tool_prefix}cc"
3064     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3065     break 2
3066   fi
3067 done
3068 done
3069
3070 fi
3071 fi
3072 CC=$ac_cv_prog_CC
3073 if test -n "$CC"; then
3074   echo "$as_me:$LINENO: result: $CC" >&5
3075 echo "${ECHO_T}$CC" >&6
3076 else
3077   echo "$as_me:$LINENO: result: no" >&5
3078 echo "${ECHO_T}no" >&6
3079 fi
3080
3081 fi
3082 if test -z "$ac_cv_prog_CC"; then
3083   ac_ct_CC=$CC
3084   # Extract the first word of "cc", so it can be a program name with args.
3085 set dummy cc; ac_word=$2
3086 echo "$as_me:$LINENO: checking for $ac_word" >&5
3087 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3088 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3089   echo $ECHO_N "(cached) $ECHO_C" >&6
3090 else
3091   if test -n "$ac_ct_CC"; then
3092   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3093 else
3094 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3095 for as_dir in $PATH
3096 do
3097   IFS=$as_save_IFS
3098   test -z "$as_dir" && as_dir=.
3099   for ac_exec_ext in '' $ac_executable_extensions; do
3100   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3101     ac_cv_prog_ac_ct_CC="cc"
3102     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3103     break 2
3104   fi
3105 done
3106 done
3107
3108 fi
3109 fi
3110 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3111 if test -n "$ac_ct_CC"; then
3112   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3113 echo "${ECHO_T}$ac_ct_CC" >&6
3114 else
3115   echo "$as_me:$LINENO: result: no" >&5
3116 echo "${ECHO_T}no" >&6
3117 fi
3118
3119   CC=$ac_ct_CC
3120 else
3121   CC="$ac_cv_prog_CC"
3122 fi
3123
3124 fi
3125 if test -z "$CC"; then
3126   # Extract the first word of "cc", so it can be a program name with args.
3127 set dummy cc; ac_word=$2
3128 echo "$as_me:$LINENO: checking for $ac_word" >&5
3129 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3130 if test "${ac_cv_prog_CC+set}" = set; then
3131   echo $ECHO_N "(cached) $ECHO_C" >&6
3132 else
3133   if test -n "$CC"; then
3134   ac_cv_prog_CC="$CC" # Let the user override the test.
3135 else
3136   ac_prog_rejected=no
3137 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3138 for as_dir in $PATH
3139 do
3140   IFS=$as_save_IFS
3141   test -z "$as_dir" && as_dir=.
3142   for ac_exec_ext in '' $ac_executable_extensions; do
3143   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3144     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3145        ac_prog_rejected=yes
3146        continue
3147      fi
3148     ac_cv_prog_CC="cc"
3149     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3150     break 2
3151   fi
3152 done
3153 done
3154
3155 if test $ac_prog_rejected = yes; then
3156   # We found a bogon in the path, so make sure we never use it.
3157   set dummy $ac_cv_prog_CC
3158   shift
3159   if test $# != 0; then
3160     # We chose a different compiler from the bogus one.
3161     # However, it has the same basename, so the bogon will be chosen
3162     # first if we set CC to just the basename; use the full file name.
3163     shift
3164     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3165   fi
3166 fi
3167 fi
3168 fi
3169 CC=$ac_cv_prog_CC
3170 if test -n "$CC"; then
3171   echo "$as_me:$LINENO: result: $CC" >&5
3172 echo "${ECHO_T}$CC" >&6
3173 else
3174   echo "$as_me:$LINENO: result: no" >&5
3175 echo "${ECHO_T}no" >&6
3176 fi
3177
3178 fi
3179 if test -z "$CC"; then
3180   if test -n "$ac_tool_prefix"; then
3181   for ac_prog in cl
3182   do
3183     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3184 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3185 echo "$as_me:$LINENO: checking for $ac_word" >&5
3186 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3187 if test "${ac_cv_prog_CC+set}" = set; then
3188   echo $ECHO_N "(cached) $ECHO_C" >&6
3189 else
3190   if test -n "$CC"; then
3191   ac_cv_prog_CC="$CC" # Let the user override the test.
3192 else
3193 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3194 for as_dir in $PATH
3195 do
3196   IFS=$as_save_IFS
3197   test -z "$as_dir" && as_dir=.
3198   for ac_exec_ext in '' $ac_executable_extensions; do
3199   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3200     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3201     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3202     break 2
3203   fi
3204 done
3205 done
3206
3207 fi
3208 fi
3209 CC=$ac_cv_prog_CC
3210 if test -n "$CC"; then
3211   echo "$as_me:$LINENO: result: $CC" >&5
3212 echo "${ECHO_T}$CC" >&6
3213 else
3214   echo "$as_me:$LINENO: result: no" >&5
3215 echo "${ECHO_T}no" >&6
3216 fi
3217
3218     test -n "$CC" && break
3219   done
3220 fi
3221 if test -z "$CC"; then
3222   ac_ct_CC=$CC
3223   for ac_prog in cl
3224 do
3225   # Extract the first word of "$ac_prog", so it can be a program name with args.
3226 set dummy $ac_prog; ac_word=$2
3227 echo "$as_me:$LINENO: checking for $ac_word" >&5
3228 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3229 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3230   echo $ECHO_N "(cached) $ECHO_C" >&6
3231 else
3232   if test -n "$ac_ct_CC"; then
3233   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3234 else
3235 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3236 for as_dir in $PATH
3237 do
3238   IFS=$as_save_IFS
3239   test -z "$as_dir" && as_dir=.
3240   for ac_exec_ext in '' $ac_executable_extensions; do
3241   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3242     ac_cv_prog_ac_ct_CC="$ac_prog"
3243     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3244     break 2
3245   fi
3246 done
3247 done
3248
3249 fi
3250 fi
3251 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3252 if test -n "$ac_ct_CC"; then
3253   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3254 echo "${ECHO_T}$ac_ct_CC" >&6
3255 else
3256   echo "$as_me:$LINENO: result: no" >&5
3257 echo "${ECHO_T}no" >&6
3258 fi
3259
3260   test -n "$ac_ct_CC" && break
3261 done
3262
3263   CC=$ac_ct_CC
3264 fi
3265
3266 fi
3267
3268
3269 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3270 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3271 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3272 See \`config.log' for more details." >&5
3273 echo "$as_me: error: no acceptable C compiler found in \$PATH
3274 See \`config.log' for more details." >&2;}
3275    { (exit 1); exit 1; }; }; }
3276
3277 # Provide some information about the compiler.
3278 echo "$as_me:$LINENO:" \
3279      "checking for C compiler version" >&5
3280 ac_compiler=`set X $ac_compile; echo $2`
3281 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3282   (eval $ac_compiler --version </dev/null >&5) 2>&5
3283   ac_status=$?
3284   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3285   (exit $ac_status); }
3286 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3287   (eval $ac_compiler -v </dev/null >&5) 2>&5
3288   ac_status=$?
3289   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3290   (exit $ac_status); }
3291 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3292   (eval $ac_compiler -V </dev/null >&5) 2>&5
3293   ac_status=$?
3294   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3295   (exit $ac_status); }
3296
3297 cat >conftest.$ac_ext <<_ACEOF
3298 /* confdefs.h.  */
3299 _ACEOF
3300 cat confdefs.h >>conftest.$ac_ext
3301 cat >>conftest.$ac_ext <<_ACEOF
3302 /* end confdefs.h.  */
3303
3304 int
3305 main ()
3306 {
3307
3308   ;
3309   return 0;
3310 }
3311 _ACEOF
3312 ac_clean_files_save=$ac_clean_files
3313 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3314 # Try to create an executable without -o first, disregard a.out.
3315 # It will help us diagnose broken compilers, and finding out an intuition
3316 # of exeext.
3317 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3318 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3319 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3320 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3321   (eval $ac_link_default) 2>&5
3322   ac_status=$?
3323   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3324   (exit $ac_status); }; then
3325   # Find the output, starting from the most likely.  This scheme is
3326 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3327 # resort.
3328
3329 # Be careful to initialize this variable, since it used to be cached.
3330 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3331 ac_cv_exeext=
3332 # b.out is created by i960 compilers.
3333 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3334 do
3335   test -f "$ac_file" || continue
3336   case $ac_file in
3337     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3338         ;;
3339     conftest.$ac_ext )
3340         # This is the source file.
3341         ;;
3342     [ab].out )
3343         # We found the default executable, but exeext='' is most
3344         # certainly right.
3345         break;;
3346     *.* )
3347         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3348         # FIXME: I believe we export ac_cv_exeext for Libtool,
3349         # but it would be cool to find out if it's true.  Does anybody
3350         # maintain Libtool? --akim.
3351         export ac_cv_exeext
3352         break;;
3353     * )
3354         break;;
3355   esac
3356 done
3357 else
3358   echo "$as_me: failed program was:" >&5
3359 sed 's/^/| /' conftest.$ac_ext >&5
3360
3361 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3362 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3363 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3364 See \`config.log' for more details." >&5
3365 echo "$as_me: error: C compiler cannot create executables
3366 See \`config.log' for more details." >&2;}
3367    { (exit 77); exit 77; }; }; }
3368 fi
3369
3370 ac_exeext=$ac_cv_exeext
3371 echo "$as_me:$LINENO: result: $ac_file" >&5
3372 echo "${ECHO_T}$ac_file" >&6
3373
3374 # Check the compiler produces executables we can run.  If not, either
3375 # the compiler is broken, or we cross compile.
3376 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3377 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3378 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3379 # If not cross compiling, check that we can run a simple program.
3380 if test "$cross_compiling" != yes; then
3381   if { ac_try='./$ac_file'
3382   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3383   (eval $ac_try) 2>&5
3384   ac_status=$?
3385   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3386   (exit $ac_status); }; }; then
3387     cross_compiling=no
3388   else
3389     if test "$cross_compiling" = maybe; then
3390         cross_compiling=yes
3391     else
3392         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3393 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3394 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3395 If you meant to cross compile, use \`--host'.
3396 See \`config.log' for more details." >&5
3397 echo "$as_me: error: cannot run C compiled programs.
3398 If you meant to cross compile, use \`--host'.
3399 See \`config.log' for more details." >&2;}
3400    { (exit 1); exit 1; }; }; }
3401     fi
3402   fi
3403 fi
3404 echo "$as_me:$LINENO: result: yes" >&5
3405 echo "${ECHO_T}yes" >&6
3406
3407 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3408 ac_clean_files=$ac_clean_files_save
3409 # Check the compiler produces executables we can run.  If not, either
3410 # the compiler is broken, or we cross compile.
3411 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3412 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3413 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3414 echo "${ECHO_T}$cross_compiling" >&6
3415
3416 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3417 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3418 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3419   (eval $ac_link) 2>&5
3420   ac_status=$?
3421   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3422   (exit $ac_status); }; then
3423   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3424 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3425 # work properly (i.e., refer to `conftest.exe'), while it won't with
3426 # `rm'.
3427 for ac_file in conftest.exe conftest conftest.*; do
3428   test -f "$ac_file" || continue
3429   case $ac_file in
3430     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3431     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3432           export ac_cv_exeext
3433           break;;
3434     * ) break;;
3435   esac
3436 done
3437 else
3438   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3439 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3440 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3441 See \`config.log' for more details." >&5
3442 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3443 See \`config.log' for more details." >&2;}
3444    { (exit 1); exit 1; }; }; }
3445 fi
3446
3447 rm -f conftest$ac_cv_exeext
3448 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3449 echo "${ECHO_T}$ac_cv_exeext" >&6
3450
3451 rm -f conftest.$ac_ext
3452 EXEEXT=$ac_cv_exeext
3453 ac_exeext=$EXEEXT
3454 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3455 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3456 if test "${ac_cv_objext+set}" = set; then
3457   echo $ECHO_N "(cached) $ECHO_C" >&6
3458 else
3459   cat >conftest.$ac_ext <<_ACEOF
3460 /* confdefs.h.  */
3461 _ACEOF
3462 cat confdefs.h >>conftest.$ac_ext
3463 cat >>conftest.$ac_ext <<_ACEOF
3464 /* end confdefs.h.  */
3465
3466 int
3467 main ()
3468 {
3469
3470   ;
3471   return 0;
3472 }
3473 _ACEOF
3474 rm -f conftest.o conftest.obj
3475 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3476   (eval $ac_compile) 2>&5
3477   ac_status=$?
3478   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3479   (exit $ac_status); }; then
3480   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3481   case $ac_file in
3482     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3483     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3484        break;;
3485   esac
3486 done
3487 else
3488   echo "$as_me: failed program was:" >&5
3489 sed 's/^/| /' conftest.$ac_ext >&5
3490
3491 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3492 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3493 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3494 See \`config.log' for more details." >&5
3495 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3496 See \`config.log' for more details." >&2;}
3497    { (exit 1); exit 1; }; }; }
3498 fi
3499
3500 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3501 fi
3502 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3503 echo "${ECHO_T}$ac_cv_objext" >&6
3504 OBJEXT=$ac_cv_objext
3505 ac_objext=$OBJEXT
3506 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3507 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3508 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3509   echo $ECHO_N "(cached) $ECHO_C" >&6
3510 else
3511   cat >conftest.$ac_ext <<_ACEOF
3512 /* confdefs.h.  */
3513 _ACEOF
3514 cat confdefs.h >>conftest.$ac_ext
3515 cat >>conftest.$ac_ext <<_ACEOF
3516 /* end confdefs.h.  */
3517
3518 int
3519 main ()
3520 {
3521 #ifndef __GNUC__
3522        choke me
3523 #endif
3524
3525   ;
3526   return 0;
3527 }
3528 _ACEOF
3529 rm -f conftest.$ac_objext
3530 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3531   (eval $ac_compile) 2>conftest.er1
3532   ac_status=$?
3533   grep -v '^ *+' conftest.er1 >conftest.err
3534   rm -f conftest.er1
3535   cat conftest.err >&5
3536   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3537   (exit $ac_status); } &&
3538          { ac_try='test -z "$ac_c_werror_flag"
3539                          || test ! -s conftest.err'
3540   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3541   (eval $ac_try) 2>&5
3542   ac_status=$?
3543   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3544   (exit $ac_status); }; } &&
3545          { ac_try='test -s conftest.$ac_objext'
3546   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3547   (eval $ac_try) 2>&5
3548   ac_status=$?
3549   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3550   (exit $ac_status); }; }; then
3551   ac_compiler_gnu=yes
3552 else
3553   echo "$as_me: failed program was:" >&5
3554 sed 's/^/| /' conftest.$ac_ext >&5
3555
3556 ac_compiler_gnu=no
3557 fi
3558 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3559 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3560
3561 fi
3562 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3563 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3564 GCC=`test $ac_compiler_gnu = yes && echo yes`
3565 ac_test_CFLAGS=${CFLAGS+set}
3566 ac_save_CFLAGS=$CFLAGS
3567 CFLAGS="-g"
3568 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3569 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3570 if test "${ac_cv_prog_cc_g+set}" = set; then
3571   echo $ECHO_N "(cached) $ECHO_C" >&6
3572 else
3573   cat >conftest.$ac_ext <<_ACEOF
3574 /* confdefs.h.  */
3575 _ACEOF
3576 cat confdefs.h >>conftest.$ac_ext
3577 cat >>conftest.$ac_ext <<_ACEOF
3578 /* end confdefs.h.  */
3579
3580 int
3581 main ()
3582 {
3583
3584   ;
3585   return 0;
3586 }
3587 _ACEOF
3588 rm -f conftest.$ac_objext
3589 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3590   (eval $ac_compile) 2>conftest.er1
3591   ac_status=$?
3592   grep -v '^ *+' conftest.er1 >conftest.err
3593   rm -f conftest.er1
3594   cat conftest.err >&5
3595   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3596   (exit $ac_status); } &&
3597          { ac_try='test -z "$ac_c_werror_flag"
3598                          || test ! -s conftest.err'
3599   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3600   (eval $ac_try) 2>&5
3601   ac_status=$?
3602   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3603   (exit $ac_status); }; } &&
3604          { ac_try='test -s conftest.$ac_objext'
3605   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3606   (eval $ac_try) 2>&5
3607   ac_status=$?
3608   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3609   (exit $ac_status); }; }; then
3610   ac_cv_prog_cc_g=yes
3611 else
3612   echo "$as_me: failed program was:" >&5
3613 sed 's/^/| /' conftest.$ac_ext >&5
3614
3615 ac_cv_prog_cc_g=no
3616 fi
3617 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3618 fi
3619 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3620 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3621 if test "$ac_test_CFLAGS" = set; then
3622   CFLAGS=$ac_save_CFLAGS
3623 elif test $ac_cv_prog_cc_g = yes; then
3624   if test "$GCC" = yes; then
3625     CFLAGS="-g -O2"
3626   else
3627     CFLAGS="-g"
3628   fi
3629 else
3630   if test "$GCC" = yes; then
3631     CFLAGS="-O2"
3632   else
3633     CFLAGS=
3634   fi
3635 fi
3636 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3637 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3638 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3639   echo $ECHO_N "(cached) $ECHO_C" >&6
3640 else
3641   ac_cv_prog_cc_stdc=no
3642 ac_save_CC=$CC
3643 cat >conftest.$ac_ext <<_ACEOF
3644 /* confdefs.h.  */
3645 _ACEOF
3646 cat confdefs.h >>conftest.$ac_ext
3647 cat >>conftest.$ac_ext <<_ACEOF
3648 /* end confdefs.h.  */
3649 #include <stdarg.h>
3650 #include <stdio.h>
3651 #include <sys/types.h>
3652 #include <sys/stat.h>
3653 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3654 struct buf { int x; };
3655 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3656 static char *e (p, i)
3657      char **p;
3658      int i;
3659 {
3660   return p[i];
3661 }
3662 static char *f (char * (*g) (char **, int), char **p, ...)
3663 {
3664   char *s;
3665   va_list v;
3666   va_start (v,p);
3667   s = g (p, va_arg (v,int));
3668   va_end (v);
3669   return s;
3670 }
3671
3672 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3673    function prototypes and stuff, but not '\xHH' hex character constants.
3674    These don't provoke an error unfortunately, instead are silently treated
3675    as 'x'.  The following induces an error, until -std1 is added to get
3676    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3677    array size at least.  It's necessary to write '\x00'==0 to get something
3678    that's true only with -std1.  */
3679 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3680
3681 int test (int i, double x);
3682 struct s1 {int (*f) (int a);};
3683 struct s2 {int (*f) (double a);};
3684 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3685 int argc;
3686 char **argv;
3687 int
3688 main ()
3689 {
3690 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3691   ;
3692   return 0;
3693 }
3694 _ACEOF
3695 # Don't try gcc -ansi; that turns off useful extensions and
3696 # breaks some systems' header files.
3697 # AIX                   -qlanglvl=ansi
3698 # Ultrix and OSF/1      -std1
3699 # HP-UX 10.20 and later -Ae
3700 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3701 # SVR4                  -Xc -D__EXTENSIONS__
3702 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3703 do
3704   CC="$ac_save_CC $ac_arg"
3705   rm -f conftest.$ac_objext
3706 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3707   (eval $ac_compile) 2>conftest.er1
3708   ac_status=$?
3709   grep -v '^ *+' conftest.er1 >conftest.err
3710   rm -f conftest.er1
3711   cat conftest.err >&5
3712   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3713   (exit $ac_status); } &&
3714          { ac_try='test -z "$ac_c_werror_flag"
3715                          || test ! -s conftest.err'
3716   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3717   (eval $ac_try) 2>&5
3718   ac_status=$?
3719   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3720   (exit $ac_status); }; } &&
3721          { ac_try='test -s conftest.$ac_objext'
3722   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3723   (eval $ac_try) 2>&5
3724   ac_status=$?
3725   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3726   (exit $ac_status); }; }; then
3727   ac_cv_prog_cc_stdc=$ac_arg
3728 break
3729 else
3730   echo "$as_me: failed program was:" >&5
3731 sed 's/^/| /' conftest.$ac_ext >&5
3732
3733 fi
3734 rm -f conftest.err conftest.$ac_objext
3735 done
3736 rm -f conftest.$ac_ext conftest.$ac_objext
3737 CC=$ac_save_CC
3738
3739 fi
3740
3741 case "x$ac_cv_prog_cc_stdc" in
3742   x|xno)
3743     echo "$as_me:$LINENO: result: none needed" >&5
3744 echo "${ECHO_T}none needed" >&6 ;;
3745   *)
3746     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3747 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3748     CC="$CC $ac_cv_prog_cc_stdc" ;;
3749 esac
3750
3751 # Some people use a C++ compiler to compile C.  Since we use `exit',
3752 # in C++ we need to declare it.  In case someone uses the same compiler
3753 # for both compiling C and C++ we need to have the C++ compiler decide
3754 # the declaration of exit, since it's the most demanding environment.
3755 cat >conftest.$ac_ext <<_ACEOF
3756 #ifndef __cplusplus
3757   choke me
3758 #endif
3759 _ACEOF
3760 rm -f conftest.$ac_objext
3761 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3762   (eval $ac_compile) 2>conftest.er1
3763   ac_status=$?
3764   grep -v '^ *+' conftest.er1 >conftest.err
3765   rm -f conftest.er1
3766   cat conftest.err >&5
3767   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3768   (exit $ac_status); } &&
3769          { ac_try='test -z "$ac_c_werror_flag"
3770                          || test ! -s conftest.err'
3771   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3772   (eval $ac_try) 2>&5
3773   ac_status=$?
3774   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3775   (exit $ac_status); }; } &&
3776          { ac_try='test -s conftest.$ac_objext'
3777   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3778   (eval $ac_try) 2>&5
3779   ac_status=$?
3780   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3781   (exit $ac_status); }; }; then
3782   for ac_declaration in \
3783    '' \
3784    'extern "C" void std::exit (int) throw (); using std::exit;' \
3785    'extern "C" void std::exit (int); using std::exit;' \
3786    'extern "C" void exit (int) throw ();' \
3787    'extern "C" void exit (int);' \
3788    'void exit (int);'
3789 do
3790   cat >conftest.$ac_ext <<_ACEOF
3791 /* confdefs.h.  */
3792 _ACEOF
3793 cat confdefs.h >>conftest.$ac_ext
3794 cat >>conftest.$ac_ext <<_ACEOF
3795 /* end confdefs.h.  */
3796 $ac_declaration
3797 #include <stdlib.h>
3798 int
3799 main ()
3800 {
3801 exit (42);
3802   ;
3803   return 0;
3804 }
3805 _ACEOF
3806 rm -f conftest.$ac_objext
3807 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3808   (eval $ac_compile) 2>conftest.er1
3809   ac_status=$?
3810   grep -v '^ *+' conftest.er1 >conftest.err
3811   rm -f conftest.er1
3812   cat conftest.err >&5
3813   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3814   (exit $ac_status); } &&
3815          { ac_try='test -z "$ac_c_werror_flag"
3816                          || test ! -s conftest.err'
3817   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3818   (eval $ac_try) 2>&5
3819   ac_status=$?
3820   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3821   (exit $ac_status); }; } &&
3822          { ac_try='test -s conftest.$ac_objext'
3823   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3824   (eval $ac_try) 2>&5
3825   ac_status=$?
3826   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3827   (exit $ac_status); }; }; then
3828   :
3829 else
3830   echo "$as_me: failed program was:" >&5
3831 sed 's/^/| /' conftest.$ac_ext >&5
3832
3833 continue
3834 fi
3835 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3836   cat >conftest.$ac_ext <<_ACEOF
3837 /* confdefs.h.  */
3838 _ACEOF
3839 cat confdefs.h >>conftest.$ac_ext
3840 cat >>conftest.$ac_ext <<_ACEOF
3841 /* end confdefs.h.  */
3842 $ac_declaration
3843 int
3844 main ()
3845 {
3846 exit (42);
3847   ;
3848   return 0;
3849 }
3850 _ACEOF
3851 rm -f conftest.$ac_objext
3852 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3853   (eval $ac_compile) 2>conftest.er1
3854   ac_status=$?
3855   grep -v '^ *+' conftest.er1 >conftest.err
3856   rm -f conftest.er1
3857   cat conftest.err >&5
3858   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3859   (exit $ac_status); } &&
3860          { ac_try='test -z "$ac_c_werror_flag"
3861                          || test ! -s conftest.err'
3862   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3863   (eval $ac_try) 2>&5
3864   ac_status=$?
3865   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3866   (exit $ac_status); }; } &&
3867          { ac_try='test -s conftest.$ac_objext'
3868   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3869   (eval $ac_try) 2>&5
3870   ac_status=$?
3871   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3872   (exit $ac_status); }; }; then
3873   break
3874 else
3875   echo "$as_me: failed program was:" >&5
3876 sed 's/^/| /' conftest.$ac_ext >&5
3877
3878 fi
3879 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3880 done
3881 rm -f conftest*
3882 if test -n "$ac_declaration"; then
3883   echo '#ifdef __cplusplus' >>confdefs.h
3884   echo $ac_declaration      >>confdefs.h
3885   echo '#endif'             >>confdefs.h
3886 fi
3887
3888 else
3889   echo "$as_me: failed program was:" >&5
3890 sed 's/^/| /' conftest.$ac_ext >&5
3891
3892 fi
3893 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3894 ac_ext=c
3895 ac_cpp='$CPP $CPPFLAGS'
3896 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3897 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3898 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3899
3900 ac_ext=cc
3901 ac_cpp='$CXXCPP $CPPFLAGS'
3902 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3903 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3904 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3905 if test -n "$ac_tool_prefix"; then
3906   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3907   do
3908     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3909 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3910 echo "$as_me:$LINENO: checking for $ac_word" >&5
3911 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3912 if test "${ac_cv_prog_CXX+set}" = set; then
3913   echo $ECHO_N "(cached) $ECHO_C" >&6
3914 else
3915   if test -n "$CXX"; then
3916   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3917 else
3918 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3919 for as_dir in $PATH
3920 do
3921   IFS=$as_save_IFS
3922   test -z "$as_dir" && as_dir=.
3923   for ac_exec_ext in '' $ac_executable_extensions; do
3924   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3925     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3926     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3927     break 2
3928   fi
3929 done
3930 done
3931
3932 fi
3933 fi
3934 CXX=$ac_cv_prog_CXX
3935 if test -n "$CXX"; then
3936   echo "$as_me:$LINENO: result: $CXX" >&5
3937 echo "${ECHO_T}$CXX" >&6
3938 else
3939   echo "$as_me:$LINENO: result: no" >&5
3940 echo "${ECHO_T}no" >&6
3941 fi
3942
3943     test -n "$CXX" && break
3944   done
3945 fi
3946 if test -z "$CXX"; then
3947   ac_ct_CXX=$CXX
3948   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3949 do
3950   # Extract the first word of "$ac_prog", so it can be a program name with args.
3951 set dummy $ac_prog; ac_word=$2
3952 echo "$as_me:$LINENO: checking for $ac_word" >&5
3953 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3954 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3955   echo $ECHO_N "(cached) $ECHO_C" >&6
3956 else
3957   if test -n "$ac_ct_CXX"; then
3958   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3959 else
3960 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3961 for as_dir in $PATH
3962 do
3963   IFS=$as_save_IFS
3964   test -z "$as_dir" && as_dir=.
3965   for ac_exec_ext in '' $ac_executable_extensions; do
3966   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3967     ac_cv_prog_ac_ct_CXX="$ac_prog"
3968     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3969     break 2
3970   fi
3971 done
3972 done
3973
3974 fi
3975 fi
3976 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3977 if test -n "$ac_ct_CXX"; then
3978   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3979 echo "${ECHO_T}$ac_ct_CXX" >&6
3980 else
3981   echo "$as_me:$LINENO: result: no" >&5
3982 echo "${ECHO_T}no" >&6
3983 fi
3984
3985   test -n "$ac_ct_CXX" && break
3986 done
3987 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3988
3989   CXX=$ac_ct_CXX
3990 fi
3991
3992
3993 # Provide some information about the compiler.
3994 echo "$as_me:$LINENO:" \
3995      "checking for C++ compiler version" >&5
3996 ac_compiler=`set X $ac_compile; echo $2`
3997 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3998   (eval $ac_compiler --version </dev/null >&5) 2>&5
3999   ac_status=$?
4000   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4001   (exit $ac_status); }
4002 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
4003   (eval $ac_compiler -v </dev/null >&5) 2>&5
4004   ac_status=$?
4005   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4006   (exit $ac_status); }
4007 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4008   (eval $ac_compiler -V </dev/null >&5) 2>&5
4009   ac_status=$?
4010   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4011   (exit $ac_status); }
4012
4013 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4014 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4015 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4016   echo $ECHO_N "(cached) $ECHO_C" >&6
4017 else
4018   cat >conftest.$ac_ext <<_ACEOF
4019 /* confdefs.h.  */
4020 _ACEOF
4021 cat confdefs.h >>conftest.$ac_ext
4022 cat >>conftest.$ac_ext <<_ACEOF
4023 /* end confdefs.h.  */
4024
4025 int
4026 main ()
4027 {
4028 #ifndef __GNUC__
4029        choke me
4030 #endif
4031
4032   ;
4033   return 0;
4034 }
4035 _ACEOF
4036 rm -f conftest.$ac_objext
4037 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4038   (eval $ac_compile) 2>conftest.er1
4039   ac_status=$?
4040   grep -v '^ *+' conftest.er1 >conftest.err
4041   rm -f conftest.er1
4042   cat conftest.err >&5
4043   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4044   (exit $ac_status); } &&
4045          { ac_try='test -z "$ac_cxx_werror_flag"
4046                          || test ! -s conftest.err'
4047   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4048   (eval $ac_try) 2>&5
4049   ac_status=$?
4050   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4051   (exit $ac_status); }; } &&
4052          { ac_try='test -s conftest.$ac_objext'
4053   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4054   (eval $ac_try) 2>&5
4055   ac_status=$?
4056   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4057   (exit $ac_status); }; }; then
4058   ac_compiler_gnu=yes
4059 else
4060   echo "$as_me: failed program was:" >&5
4061 sed 's/^/| /' conftest.$ac_ext >&5
4062
4063 ac_compiler_gnu=no
4064 fi
4065 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4066 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4067
4068 fi
4069 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4070 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4071 GXX=`test $ac_compiler_gnu = yes && echo yes`
4072 ac_test_CXXFLAGS=${CXXFLAGS+set}
4073 ac_save_CXXFLAGS=$CXXFLAGS
4074 CXXFLAGS="-g"
4075 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4076 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4077 if test "${ac_cv_prog_cxx_g+set}" = set; then
4078   echo $ECHO_N "(cached) $ECHO_C" >&6
4079 else
4080   cat >conftest.$ac_ext <<_ACEOF
4081 /* confdefs.h.  */
4082 _ACEOF
4083 cat confdefs.h >>conftest.$ac_ext
4084 cat >>conftest.$ac_ext <<_ACEOF
4085 /* end confdefs.h.  */
4086
4087 int
4088 main ()
4089 {
4090
4091   ;
4092   return 0;
4093 }
4094 _ACEOF
4095 rm -f conftest.$ac_objext
4096 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4097   (eval $ac_compile) 2>conftest.er1
4098   ac_status=$?
4099   grep -v '^ *+' conftest.er1 >conftest.err
4100   rm -f conftest.er1
4101   cat conftest.err >&5
4102   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4103   (exit $ac_status); } &&
4104          { ac_try='test -z "$ac_cxx_werror_flag"
4105                          || test ! -s conftest.err'
4106   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4107   (eval $ac_try) 2>&5
4108   ac_status=$?
4109   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4110   (exit $ac_status); }; } &&
4111          { ac_try='test -s conftest.$ac_objext'
4112   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4113   (eval $ac_try) 2>&5
4114   ac_status=$?
4115   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4116   (exit $ac_status); }; }; then
4117   ac_cv_prog_cxx_g=yes
4118 else
4119   echo "$as_me: failed program was:" >&5
4120 sed 's/^/| /' conftest.$ac_ext >&5
4121
4122 ac_cv_prog_cxx_g=no
4123 fi
4124 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4125 fi
4126 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4127 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4128 if test "$ac_test_CXXFLAGS" = set; then
4129   CXXFLAGS=$ac_save_CXXFLAGS
4130 elif test $ac_cv_prog_cxx_g = yes; then
4131   if test "$GXX" = yes; then
4132     CXXFLAGS="-g -O2"
4133   else
4134     CXXFLAGS="-g"
4135   fi
4136 else
4137   if test "$GXX" = yes; then
4138     CXXFLAGS="-O2"
4139   else
4140     CXXFLAGS=
4141   fi
4142 fi
4143 for ac_declaration in \
4144    '' \
4145    'extern "C" void std::exit (int) throw (); using std::exit;' \
4146    'extern "C" void std::exit (int); using std::exit;' \
4147    'extern "C" void exit (int) throw ();' \
4148    'extern "C" void exit (int);' \
4149    'void exit (int);'
4150 do
4151   cat >conftest.$ac_ext <<_ACEOF
4152 /* confdefs.h.  */
4153 _ACEOF
4154 cat confdefs.h >>conftest.$ac_ext
4155 cat >>conftest.$ac_ext <<_ACEOF
4156 /* end confdefs.h.  */
4157 $ac_declaration
4158 #include <stdlib.h>
4159 int
4160 main ()
4161 {
4162 exit (42);
4163   ;
4164   return 0;
4165 }
4166 _ACEOF
4167 rm -f conftest.$ac_objext
4168 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4169   (eval $ac_compile) 2>conftest.er1
4170   ac_status=$?
4171   grep -v '^ *+' conftest.er1 >conftest.err
4172   rm -f conftest.er1
4173   cat conftest.err >&5
4174   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4175   (exit $ac_status); } &&
4176          { ac_try='test -z "$ac_cxx_werror_flag"
4177                          || test ! -s conftest.err'
4178   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4179   (eval $ac_try) 2>&5
4180   ac_status=$?
4181   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4182   (exit $ac_status); }; } &&
4183          { ac_try='test -s conftest.$ac_objext'
4184   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4185   (eval $ac_try) 2>&5
4186   ac_status=$?
4187   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4188   (exit $ac_status); }; }; then
4189   :
4190 else
4191   echo "$as_me: failed program was:" >&5
4192 sed 's/^/| /' conftest.$ac_ext >&5
4193
4194 continue
4195 fi
4196 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4197   cat >conftest.$ac_ext <<_ACEOF
4198 /* confdefs.h.  */
4199 _ACEOF
4200 cat confdefs.h >>conftest.$ac_ext
4201 cat >>conftest.$ac_ext <<_ACEOF
4202 /* end confdefs.h.  */
4203 $ac_declaration
4204 int
4205 main ()
4206 {
4207 exit (42);
4208   ;
4209   return 0;
4210 }
4211 _ACEOF
4212 rm -f conftest.$ac_objext
4213 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4214   (eval $ac_compile) 2>conftest.er1
4215   ac_status=$?
4216   grep -v '^ *+' conftest.er1 >conftest.err
4217   rm -f conftest.er1
4218   cat conftest.err >&5
4219   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4220   (exit $ac_status); } &&
4221          { ac_try='test -z "$ac_cxx_werror_flag"
4222                          || test ! -s conftest.err'
4223   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4224   (eval $ac_try) 2>&5
4225   ac_status=$?
4226   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4227   (exit $ac_status); }; } &&
4228          { ac_try='test -s conftest.$ac_objext'
4229   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4230   (eval $ac_try) 2>&5
4231   ac_status=$?
4232   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4233   (exit $ac_status); }; }; then
4234   break
4235 else
4236   echo "$as_me: failed program was:" >&5
4237 sed 's/^/| /' conftest.$ac_ext >&5
4238
4239 fi
4240 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4241 done
4242 rm -f conftest*
4243 if test -n "$ac_declaration"; then
4244   echo '#ifdef __cplusplus' >>confdefs.h
4245   echo $ac_declaration      >>confdefs.h
4246   echo '#endif'             >>confdefs.h
4247 fi
4248
4249 ac_ext=c
4250 ac_cpp='$CPP $CPPFLAGS'
4251 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4252 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4253 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4254
4255
4256 # We must set the default linker to the linker used by gcc for the correct
4257 # operation of libtool.  If LD is not defined and we are using gcc, try to
4258 # set the LD default to the ld used by gcc.
4259 if test -z "$LD"; then
4260   if test "$GCC" = yes; then
4261     case $build in
4262     *-*-mingw*)
4263       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4264     *)
4265       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4266     esac
4267     case $gcc_prog_ld in
4268     # Accept absolute paths.
4269     [\\/]* | [A-Za-z]:[\\/]*)
4270       LD="$gcc_prog_ld" ;;
4271     esac
4272   fi
4273 fi
4274
4275
4276
4277
4278 if test -n "$ac_tool_prefix"; then
4279   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4280 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4281 echo "$as_me:$LINENO: checking for $ac_word" >&5
4282 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4283 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4284   echo $ECHO_N "(cached) $ECHO_C" >&6
4285 else
4286   if test -n "$GNATBIND"; then
4287   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4288 else
4289 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4290 for as_dir in $PATH
4291 do
4292   IFS=$as_save_IFS
4293   test -z "$as_dir" && as_dir=.
4294   for ac_exec_ext in '' $ac_executable_extensions; do
4295   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4296     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4297     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4298     break 2
4299   fi
4300 done
4301 done
4302
4303 fi
4304 fi
4305 GNATBIND=$ac_cv_prog_GNATBIND
4306 if test -n "$GNATBIND"; then
4307   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4308 echo "${ECHO_T}$GNATBIND" >&6
4309 else
4310   echo "$as_me:$LINENO: result: no" >&5
4311 echo "${ECHO_T}no" >&6
4312 fi
4313
4314 fi
4315 if test -z "$ac_cv_prog_GNATBIND"; then
4316   ac_ct_GNATBIND=$GNATBIND
4317   # Extract the first word of "gnatbind", so it can be a program name with args.
4318 set dummy gnatbind; ac_word=$2
4319 echo "$as_me:$LINENO: checking for $ac_word" >&5
4320 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4321 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4322   echo $ECHO_N "(cached) $ECHO_C" >&6
4323 else
4324   if test -n "$ac_ct_GNATBIND"; then
4325   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4326 else
4327 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4328 for as_dir in $PATH
4329 do
4330   IFS=$as_save_IFS
4331   test -z "$as_dir" && as_dir=.
4332   for ac_exec_ext in '' $ac_executable_extensions; do
4333   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4334     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4335     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4336     break 2
4337   fi
4338 done
4339 done
4340
4341   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4342 fi
4343 fi
4344 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4345 if test -n "$ac_ct_GNATBIND"; then
4346   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4347 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4348 else
4349   echo "$as_me:$LINENO: result: no" >&5
4350 echo "${ECHO_T}no" >&6
4351 fi
4352
4353   GNATBIND=$ac_ct_GNATBIND
4354 else
4355   GNATBIND="$ac_cv_prog_GNATBIND"
4356 fi
4357
4358 if test -n "$ac_tool_prefix"; then
4359   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4360 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4361 echo "$as_me:$LINENO: checking for $ac_word" >&5
4362 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4363 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4364   echo $ECHO_N "(cached) $ECHO_C" >&6
4365 else
4366   if test -n "$GNATMAKE"; then
4367   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4368 else
4369 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4370 for as_dir in $PATH
4371 do
4372   IFS=$as_save_IFS
4373   test -z "$as_dir" && as_dir=.
4374   for ac_exec_ext in '' $ac_executable_extensions; do
4375   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4376     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4377     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4378     break 2
4379   fi
4380 done
4381 done
4382
4383 fi
4384 fi
4385 GNATMAKE=$ac_cv_prog_GNATMAKE
4386 if test -n "$GNATMAKE"; then
4387   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4388 echo "${ECHO_T}$GNATMAKE" >&6
4389 else
4390   echo "$as_me:$LINENO: result: no" >&5
4391 echo "${ECHO_T}no" >&6
4392 fi
4393
4394 fi
4395 if test -z "$ac_cv_prog_GNATMAKE"; then
4396   ac_ct_GNATMAKE=$GNATMAKE
4397   # Extract the first word of "gnatmake", so it can be a program name with args.
4398 set dummy gnatmake; ac_word=$2
4399 echo "$as_me:$LINENO: checking for $ac_word" >&5
4400 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4401 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4402   echo $ECHO_N "(cached) $ECHO_C" >&6
4403 else
4404   if test -n "$ac_ct_GNATMAKE"; then
4405   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4406 else
4407 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4408 for as_dir in $PATH
4409 do
4410   IFS=$as_save_IFS
4411   test -z "$as_dir" && as_dir=.
4412   for ac_exec_ext in '' $ac_executable_extensions; do
4413   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4414     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4415     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4416     break 2
4417   fi
4418 done
4419 done
4420
4421   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4422 fi
4423 fi
4424 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4425 if test -n "$ac_ct_GNATMAKE"; then
4426   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4427 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4428 else
4429   echo "$as_me:$LINENO: result: no" >&5
4430 echo "${ECHO_T}no" >&6
4431 fi
4432
4433   GNATMAKE=$ac_ct_GNATMAKE
4434 else
4435   GNATMAKE="$ac_cv_prog_GNATMAKE"
4436 fi
4437
4438 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4439 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4440 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4441   echo $ECHO_N "(cached) $ECHO_C" >&6
4442 else
4443   cat >conftest.adb <<EOF
4444 procedure conftest is begin null; end conftest;
4445 EOF
4446 acx_cv_cc_gcc_supports_ada=no
4447 # There is a bug in old released versions of GCC which causes the
4448 # driver to exit successfully when the appropriate language module
4449 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4450 # Therefore we must check for the error message as well as an
4451 # unsuccessful exit.
4452 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4453 # given a .adb file, but produce no object file.  So we must check
4454 # if an object file was really produced to guard against this.
4455 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4456 if test x"$errors" = x && test -f conftest.$ac_objext; then
4457   acx_cv_cc_gcc_supports_ada=yes
4458 fi
4459 rm -f conftest.*
4460 fi
4461 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4462 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4463
4464 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4465   have_gnat=yes
4466 else
4467   have_gnat=no
4468 fi
4469
4470 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4471 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4472 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4473   echo $ECHO_N "(cached) $ECHO_C" >&6
4474 else
4475    echo abfoo >t1
4476   echo cdfoo >t2
4477   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4478   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4479     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4480       :
4481     else
4482       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4483     fi
4484   fi
4485   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4486     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4487       :
4488     else
4489       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4490     fi
4491   fi
4492   rm t1 t2
4493
4494 fi
4495 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4496 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4497 do_compare="$gcc_cv_prog_cmp_skip"
4498
4499
4500
4501 # Check for GMP and MPFR
4502 gmplibs="-lmpfr -lgmp"
4503 gmpinc=
4504 have_gmp=no
4505
4506 # Specify a location for mpfr
4507 # check for this first so it ends up on the link line before gmp.
4508
4509 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4510 if test "${with_mpfr_dir+set}" = set; then
4511   withval="$with_mpfr_dir"
4512   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4513 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4514 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4515 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4516    { (exit 1); exit 1; }; }
4517 fi;
4518
4519
4520 # Check whether --with-mpfr or --without-mpfr was given.
4521 if test "${with_mpfr+set}" = set; then
4522   withval="$with_mpfr"
4523
4524 fi;
4525
4526 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4527 if test "${with_mpfr_include+set}" = set; then
4528   withval="$with_mpfr_include"
4529
4530 fi;
4531
4532 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4533 if test "${with_mpfr_lib+set}" = set; then
4534   withval="$with_mpfr_lib"
4535
4536 fi;
4537
4538 if test "x$with_mpfr" != x; then
4539   gmplibs="-L$with_mpfr/lib $gmplibs"
4540   gmpinc="-I$with_mpfr/include"
4541 fi
4542 if test "x$with_mpfr_include" != x; then
4543   gmpinc="-I$with_mpfr_include"
4544 fi
4545 if test "x$with_mpfr_lib" != x; then
4546   gmplibs="-L$with_mpfr_lib $gmplibs"
4547 fi
4548 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4549   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4550   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4551   # Do not test the mpfr version.  Assume that it is sufficient, since
4552   # it is in the source tree, and the library has not been built yet
4553   # but it would be included on the link line in the version check below
4554   # hence making the test fail.
4555   have_gmp=yes
4556 fi
4557
4558 # Specify a location for gmp
4559
4560 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4561 if test "${with_gmp_dir+set}" = set; then
4562   withval="$with_gmp_dir"
4563   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4564 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4565 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4566 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4567    { (exit 1); exit 1; }; }
4568 fi;
4569
4570
4571 # Check whether --with-gmp or --without-gmp was given.
4572 if test "${with_gmp+set}" = set; then
4573   withval="$with_gmp"
4574
4575 fi;
4576
4577 # Check whether --with-gmp_include or --without-gmp_include was given.
4578 if test "${with_gmp_include+set}" = set; then
4579   withval="$with_gmp_include"
4580
4581 fi;
4582
4583 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4584 if test "${with_gmp_lib+set}" = set; then
4585   withval="$with_gmp_lib"
4586
4587 fi;
4588
4589
4590 if test "x$with_gmp" != x; then
4591   gmplibs="-L$with_gmp/lib $gmplibs"
4592   gmpinc="-I$with_gmp/include $gmpinc"
4593 fi
4594 if test "x$with_gmp_include" != x; then
4595   gmpinc="-I$with_gmp_include $gmpinc"
4596 fi
4597 if test "x$with_gmp_lib" != x; then
4598   gmplibs="-L$with_gmp_lib $gmplibs"
4599 fi
4600 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4601   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4602   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4603   extra_mpfr_configure_flags='--with-gmp-build=$$r/$(HOST_SUBDIR)/gmp'
4604   # Do not test the gmp version.  Assume that it is sufficient, since
4605   # it is in the source tree, and the library has not been built yet
4606   # but it would be included on the link line in the version check below
4607   # hence making the test fail.
4608   have_gmp=yes
4609 fi
4610
4611 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4612   have_gmp=yes
4613   saved_CFLAGS="$CFLAGS"
4614   CFLAGS="$CFLAGS $gmpinc"
4615   # Check GMP actually works
4616   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4617 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4618
4619 cat >conftest.$ac_ext <<_ACEOF
4620 /* confdefs.h.  */
4621 _ACEOF
4622 cat confdefs.h >>conftest.$ac_ext
4623 cat >>conftest.$ac_ext <<_ACEOF
4624 /* end confdefs.h.  */
4625 #include "gmp.h"
4626 int
4627 main ()
4628 {
4629
4630   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 2)
4631   choke me
4632   #endif
4633
4634   ;
4635   return 0;
4636 }
4637 _ACEOF
4638 rm -f conftest.$ac_objext
4639 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4640   (eval $ac_compile) 2>conftest.er1
4641   ac_status=$?
4642   grep -v '^ *+' conftest.er1 >conftest.err
4643   rm -f conftest.er1
4644   cat conftest.err >&5
4645   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4646   (exit $ac_status); } &&
4647          { ac_try='test -z "$ac_c_werror_flag"
4648                          || test ! -s conftest.err'
4649   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4650   (eval $ac_try) 2>&5
4651   ac_status=$?
4652   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4653   (exit $ac_status); }; } &&
4654          { ac_try='test -s conftest.$ac_objext'
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); }; }; then
4660   echo "$as_me:$LINENO: result: yes" >&5
4661 echo "${ECHO_T}yes" >&6
4662 else
4663   echo "$as_me: failed program was:" >&5
4664 sed 's/^/| /' conftest.$ac_ext >&5
4665
4666 echo "$as_me:$LINENO: result: no" >&5
4667 echo "${ECHO_T}no" >&6; have_gmp=no
4668 fi
4669 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4670
4671   if test x"$have_gmp" = xyes; then
4672     saved_LIBS="$LIBS"
4673     LIBS="$LIBS $gmplibs"
4674         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4675 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4676     cat >conftest.$ac_ext <<_ACEOF
4677 /* confdefs.h.  */
4678 _ACEOF
4679 cat confdefs.h >>conftest.$ac_ext
4680 cat >>conftest.$ac_ext <<_ACEOF
4681 /* end confdefs.h.  */
4682 #include <gmp.h>
4683     #include <mpfr.h>
4684 int
4685 main ()
4686 {
4687
4688     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,1)
4689     choke me
4690     #endif
4691     mpfr_t n;
4692     mpfr_t x;
4693     int t;
4694     mpfr_init (n);
4695     mpfr_init (x);
4696     mpfr_atan2 (n, n, x, GMP_RNDN);
4697     mpfr_erfc (n, x, GMP_RNDN);
4698     mpfr_subnormalize (x, t, GMP_RNDN);
4699
4700   ;
4701   return 0;
4702 }
4703 _ACEOF
4704 rm -f conftest.$ac_objext conftest$ac_exeext
4705 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4706   (eval $ac_link) 2>conftest.er1
4707   ac_status=$?
4708   grep -v '^ *+' conftest.er1 >conftest.err
4709   rm -f conftest.er1
4710   cat conftest.err >&5
4711   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4712   (exit $ac_status); } &&
4713          { ac_try='test -z "$ac_c_werror_flag"
4714                          || test ! -s conftest.err'
4715   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4716   (eval $ac_try) 2>&5
4717   ac_status=$?
4718   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4719   (exit $ac_status); }; } &&
4720          { ac_try='test -s conftest$ac_exeext'
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); }; }; then
4726   cat >conftest.$ac_ext <<_ACEOF
4727 /* confdefs.h.  */
4728 _ACEOF
4729 cat confdefs.h >>conftest.$ac_ext
4730 cat >>conftest.$ac_ext <<_ACEOF
4731 /* end confdefs.h.  */
4732 #include <gmp.h>
4733     #include <mpfr.h>
4734 int
4735 main ()
4736 {
4737
4738     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4739     choke me
4740     #endif
4741     mpfr_t n; mpfr_init(n);
4742
4743   ;
4744   return 0;
4745 }
4746 _ACEOF
4747 rm -f conftest.$ac_objext conftest$ac_exeext
4748 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4749   (eval $ac_link) 2>conftest.er1
4750   ac_status=$?
4751   grep -v '^ *+' conftest.er1 >conftest.err
4752   rm -f conftest.er1
4753   cat conftest.err >&5
4754   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4755   (exit $ac_status); } &&
4756          { ac_try='test -z "$ac_c_werror_flag"
4757                          || test ! -s conftest.err'
4758   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4759   (eval $ac_try) 2>&5
4760   ac_status=$?
4761   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4762   (exit $ac_status); }; } &&
4763          { ac_try='test -s conftest$ac_exeext'
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); }; }; then
4769   echo "$as_me:$LINENO: result: yes" >&5
4770 echo "${ECHO_T}yes" >&6
4771 else
4772   echo "$as_me: failed program was:" >&5
4773 sed 's/^/| /' conftest.$ac_ext >&5
4774
4775 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4776 echo "${ECHO_T}buggy but acceptable" >&6
4777 fi
4778 rm -f conftest.err conftest.$ac_objext \
4779       conftest$ac_exeext conftest.$ac_ext
4780 else
4781   echo "$as_me: failed program was:" >&5
4782 sed 's/^/| /' conftest.$ac_ext >&5
4783
4784 echo "$as_me:$LINENO: result: no" >&5
4785 echo "${ECHO_T}no" >&6; have_gmp=no
4786 fi
4787 rm -f conftest.err conftest.$ac_objext \
4788       conftest$ac_exeext conftest.$ac_ext
4789       LIBS="$saved_LIBS"
4790   fi
4791   CFLAGS="$saved_CFLAGS"
4792
4793   if test x$have_gmp != xyes; then
4794     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
4795 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4796 Copies of these libraries' source code can be found at their respective
4797 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4798 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4799 If you obtained GMP and/or MPFR from a vendor distribution package, make
4800 sure that you have installed both the libraries and the header files.
4801 They may be located in separate packages." >&5
4802 echo "$as_me: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
4803 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4804 Copies of these libraries' source code can be found at their respective
4805 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4806 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4807 If you obtained GMP and/or MPFR from a vendor distribution package, make
4808 sure that you have installed both the libraries and the header files.
4809 They may be located in separate packages." >&2;}
4810    { (exit 1); exit 1; }; }
4811   fi
4812 fi
4813
4814 # Flags needed for both GMP and/or MPFR
4815
4816
4817
4818
4819 # Allow host libstdc++ to be specified for static linking with PPL.
4820
4821 # Check whether --with-host-libstdcxx or --without-host-libstdcxx was given.
4822 if test "${with_host_libstdcxx+set}" = set; then
4823   withval="$with_host_libstdcxx"
4824
4825 fi;
4826
4827 case $with_host_libstdcxx in
4828   no|yes)
4829     { { echo "$as_me:$LINENO: error: -with-host-libstdcxx needs an argument" >&5
4830 echo "$as_me: error: -with-host-libstdcxx needs an argument" >&2;}
4831    { (exit 1); exit 1; }; }
4832     ;;
4833 esac
4834
4835 # Check for PPL
4836 ppl_major_version=0
4837 ppl_minor_version=10
4838 ppllibs=" -lppl_c -lppl -lgmpxx $with_host_libstdcxx "
4839 pplinc=
4840
4841
4842 # Check whether --with-ppl or --without-ppl was given.
4843 if test "${with_ppl+set}" = set; then
4844   withval="$with_ppl"
4845
4846 else
4847   with_ppl=no
4848 fi;
4849
4850 # Check whether --with-ppl_include or --without-ppl_include was given.
4851 if test "${with_ppl_include+set}" = set; then
4852   withval="$with_ppl_include"
4853
4854 fi;
4855
4856 # Check whether --with-ppl_lib or --without-ppl_lib was given.
4857 if test "${with_ppl_lib+set}" = set; then
4858   withval="$with_ppl_lib"
4859
4860 fi;
4861
4862 case $with_ppl in
4863   no)
4864     ppllibs=
4865     ;;
4866   *)
4867     ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx $with_host_libstdcxx"
4868     pplinc="-I$with_ppl/include $pplinc"
4869     LIBS="$ppllibs $LIBS"
4870     ;;
4871 esac
4872 if test "x$with_ppl_include" != x; then
4873   pplinc="-I$with_ppl_include $pplinc"
4874 fi
4875 if test "x$with_ppl_lib" != x; then
4876   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx $with_host_libstdcxx"
4877   LIBS="$ppllibs $LIBS"
4878 fi
4879 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
4880   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '"$with_host_libstdcxx "
4881   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
4882   LIBS="$ppllibs $LIBS"
4883 fi
4884
4885 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
4886 if test "${enable_ppl_version_check+set}" = set; then
4887   enableval="$enable_ppl_version_check"
4888   ENABLE_PPL_CHECK=$enableval
4889 else
4890   ENABLE_PPL_CHECK=yes
4891 fi;
4892
4893 if test "${ENABLE_PPL_CHECK}" = "yes"; then
4894   saved_CFLAGS="$CFLAGS"
4895   CFLAGS="$CFLAGS $pplinc $gmpinc"
4896   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
4897 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
4898   cat >conftest.$ac_ext <<_ACEOF
4899 /* confdefs.h.  */
4900 _ACEOF
4901 cat confdefs.h >>conftest.$ac_ext
4902 cat >>conftest.$ac_ext <<_ACEOF
4903 /* end confdefs.h.  */
4904 #include "ppl_c.h"
4905 int
4906 main ()
4907 {
4908
4909   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
4910   choke me
4911   #endif
4912
4913   ;
4914   return 0;
4915 }
4916 _ACEOF
4917 rm -f conftest.$ac_objext
4918 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4919   (eval $ac_compile) 2>conftest.er1
4920   ac_status=$?
4921   grep -v '^ *+' conftest.er1 >conftest.err
4922   rm -f conftest.er1
4923   cat conftest.err >&5
4924   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4925   (exit $ac_status); } &&
4926          { ac_try='test -z "$ac_c_werror_flag"
4927                          || test ! -s conftest.err'
4928   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4929   (eval $ac_try) 2>&5
4930   ac_status=$?
4931   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4932   (exit $ac_status); }; } &&
4933          { ac_try='test -s conftest.$ac_objext'
4934   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4935   (eval $ac_try) 2>&5
4936   ac_status=$?
4937   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4938   (exit $ac_status); }; }; then
4939   echo "$as_me:$LINENO: result: yes" >&5
4940 echo "${ECHO_T}yes" >&6
4941 else
4942   echo "$as_me: failed program was:" >&5
4943 sed 's/^/| /' conftest.$ac_ext >&5
4944
4945 echo "$as_me:$LINENO: result: no" >&5
4946 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
4947 fi
4948 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4949   CFLAGS="$saved_CFLAGS"
4950 fi
4951
4952 # Flags needed for PPL
4953
4954
4955
4956
4957 # Check for CLOOG
4958 clooglibs=" -lcloog "
4959 clooginc=" -DCLOOG_PPL_BACKEND "
4960
4961
4962 # Check whether --with-cloog or --without-cloog was given.
4963 if test "${with_cloog+set}" = set; then
4964   withval="$with_cloog"
4965
4966 else
4967   with_cloog=no
4968 fi;
4969
4970 # Check whether --with-cloog_include or --without-cloog_include was given.
4971 if test "${with_cloog_include+set}" = set; then
4972   withval="$with_cloog_include"
4973
4974 fi;
4975
4976 # Check whether --with-cloog_lib or --without-cloog_lib was given.
4977 if test "${with_cloog_lib+set}" = set; then
4978   withval="$with_cloog_lib"
4979
4980 fi;
4981
4982 case $with_cloog in
4983   no)
4984     clooglibs=
4985     clooginc=
4986     ;;
4987   *)
4988     clooglibs="-L$with_cloog/lib -lcloog"
4989     clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
4990     LIBS="$clooglibs $LIBS"
4991     ;;
4992 esac
4993 if test "x$with_cloog_include" != x; then
4994   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
4995 fi
4996 if test "x$with_cloog_lib" != x; then
4997   clooglibs="-L$with_cloog_lib -lcloog"
4998   LIBS="$clooglibs $LIBS"
4999 fi
5000 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
5001   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
5002   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
5003   LIBS="$clooglibs $LIBS"
5004 fi
5005
5006 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
5007 if test "${enable_cloog_version_check+set}" = set; then
5008   enableval="$enable_cloog_version_check"
5009   ENABLE_CLOOG_CHECK=$enableval
5010 else
5011   ENABLE_CLOOG_CHECK=yes
5012 fi;
5013
5014 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
5015   saved_CFLAGS="$CFLAGS"
5016   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
5017   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
5018 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
5019   cat >conftest.$ac_ext <<_ACEOF
5020 /* confdefs.h.  */
5021 _ACEOF
5022 cat confdefs.h >>conftest.$ac_ext
5023 cat >>conftest.$ac_ext <<_ACEOF
5024 /* end confdefs.h.  */
5025 #include "cloog/cloog.h"
5026 int
5027 main ()
5028 {
5029
5030   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
5031   choke me
5032   #endif
5033
5034   ;
5035   return 0;
5036 }
5037 _ACEOF
5038 rm -f conftest.$ac_objext
5039 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5040   (eval $ac_compile) 2>conftest.er1
5041   ac_status=$?
5042   grep -v '^ *+' conftest.er1 >conftest.err
5043   rm -f conftest.er1
5044   cat conftest.err >&5
5045   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5046   (exit $ac_status); } &&
5047          { ac_try='test -z "$ac_c_werror_flag"
5048                          || test ! -s conftest.err'
5049   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5050   (eval $ac_try) 2>&5
5051   ac_status=$?
5052   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5053   (exit $ac_status); }; } &&
5054          { ac_try='test -s conftest.$ac_objext'
5055   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5056   (eval $ac_try) 2>&5
5057   ac_status=$?
5058   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5059   (exit $ac_status); }; }; then
5060   echo "$as_me:$LINENO: result: yes" >&5
5061 echo "${ECHO_T}yes" >&6
5062 else
5063   echo "$as_me: failed program was:" >&5
5064 sed 's/^/| /' conftest.$ac_ext >&5
5065
5066 echo "$as_me:$LINENO: result: no" >&5
5067 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5068 fi
5069 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5070   CFLAGS="$saved_CFLAGS"
5071 fi
5072
5073 # Flags needed for CLOOG
5074
5075
5076
5077
5078 # By default, C is the only stage 1 language.
5079 stage1_languages=,c,
5080
5081 # Figure out what language subdirectories are present.
5082 # Look if the user specified --enable-languages="..."; if not, use
5083 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5084 # go away some day.
5085 # NB:  embedded tabs in this IF block -- do not untabify
5086 if test -d ${srcdir}/gcc; then
5087   if test x"${enable_languages+set}" != xset; then
5088     if test x"${LANGUAGES+set}" = xset; then
5089       enable_languages="${LANGUAGES}"
5090         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5091     else
5092       enable_languages=all
5093     fi
5094   else
5095     if test x"${enable_languages}" = x ||
5096        test x"${enable_languages}" = xyes;
5097        then
5098       echo configure.in: --enable-languages needs at least one language argument 1>&2
5099       exit 1
5100     fi
5101   fi
5102   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5103
5104   # 'f95' is the old name for the 'fortran' language. We issue a warning
5105   # and make the substitution.
5106   case ,${enable_languages}, in
5107     *,f95,*)
5108       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5109       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5110       ;;
5111   esac
5112
5113   # First scan to see if an enabled language requires some other language.
5114   # We assume that a given config-lang.in will list all the language
5115   # front ends it requires, even if some are required indirectly.
5116   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5117     case ${lang_frag} in
5118       ..) ;;
5119       # The odd quoting in the next line works around
5120       # an apparent bug in bash 1.12 on linux.
5121       ${srcdir}/gcc/[*]/config-lang.in) ;;
5122       *)
5123         # From the config-lang.in, get $language, $lang_requires
5124         language=
5125         lang_requires=
5126         . ${lang_frag}
5127         for other in ${lang_requires} ; do
5128           case ,${enable_languages}, in
5129             *,$other,*) ;;
5130             *,all,*) ;;
5131             *,$language,*)
5132               echo " \`$other' language required by \`$language'; enabling" 1>&2
5133               enable_languages="${enable_languages},${other}"
5134               ;;
5135           esac
5136         done
5137         ;;
5138     esac
5139   done
5140
5141   new_enable_languages=,c,
5142   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5143   potential_languages=,c,
5144
5145   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5146     case ${lang_frag} in
5147       ..) ;;
5148       # The odd quoting in the next line works around
5149       # an apparent bug in bash 1.12 on linux.
5150       ${srcdir}/gcc/[*]/config-lang.in) ;;
5151       *)
5152         # From the config-lang.in, get $language, $target_libs,
5153         # $lang_dirs, $boot_language, and $build_by_default
5154         language=
5155         target_libs=
5156         lang_dirs=
5157         subdir_requires=
5158         boot_language=no
5159         build_by_default=yes
5160         . ${lang_frag}
5161         if test x${language} = x; then
5162           echo "${lang_frag} doesn't set \$language." 1>&2
5163           exit 1
5164         fi
5165
5166         case ,${enable_languages}, in
5167           *,${language},*)
5168             # Language was explicitly selected; include it.
5169             add_this_lang=yes
5170             ;;
5171           *,all,*)
5172             # 'all' was selected, select it if it is a default language
5173             add_this_lang=${build_by_default}
5174             ;;
5175           *)
5176             add_this_lang=no
5177             ;;
5178         esac
5179
5180         # Disable languages that need other directories if these aren't available.
5181         for i in $subdir_requires; do
5182           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5183           case ,${enable_languages}, in
5184             *,${language},*)
5185               # Specifically requested language; tell them.
5186               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5187 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5188    { (exit 1); exit 1; }; }
5189               ;;
5190             *)
5191               # Silently disable.
5192               add_this_lang=unsupported
5193               ;;
5194           esac
5195         done
5196
5197         # Disable Ada if no preexisting GNAT is available.
5198         case ,${enable_languages},:${language}:${have_gnat} in
5199           *,${language},*:ada:no)
5200             # Specifically requested language; tell them.
5201             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5202 echo "$as_me: error: GNAT is required to build $language" >&2;}
5203    { (exit 1); exit 1; }; }
5204             ;;
5205           *:ada:no)
5206             # Silently disable.
5207             add_this_lang=unsupported
5208             ;;
5209         esac
5210
5211         # Disable a language that is unsupported by the target.
5212         case " $unsupported_languages " in
5213           *" $language "*)
5214             add_this_lang=unsupported
5215             ;;
5216         esac
5217
5218         case $add_this_lang in
5219           unsupported)
5220             # Remove language-dependent dirs.
5221             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5222             ;;
5223           no)
5224             # Remove language-dependent dirs; still show language as supported.
5225             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5226             potential_languages="${potential_languages}${language},"
5227             ;;
5228           yes)
5229             new_enable_languages="${new_enable_languages}${language},"
5230             potential_languages="${potential_languages}${language},"
5231             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5232             case ${boot_language} in
5233               yes)
5234                 # Add to (comma-separated) list of stage 1 languages.
5235                 stage1_languages="${stage1_languages}${language},"
5236                 ;;
5237             esac
5238             ;;
5239         esac
5240         ;;
5241     esac
5242   done
5243
5244   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5245 if test "${enable_stage1_languages+set}" = set; then
5246   enableval="$enable_stage1_languages"
5247   case ,${enable_stage1_languages}, in
5248     ,no,|,,)
5249       # Set it to something that will have no effect in the loop below
5250       enable_stage1_languages=c ;;
5251     ,yes,)
5252       enable_stage1_languages=`echo $new_enable_languages | \
5253         sed -e "s/^,//" -e "s/,$//" ` ;;
5254     *,all,*)
5255       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5256         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5257   esac
5258
5259   # Add "good" languages from enable_stage1_languages to stage1_languages,
5260   # while "bad" languages go in missing_languages.  Leave no duplicates.
5261   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5262     case $potential_languages in
5263       *,$i,*)
5264         case $stage1_languages in
5265           *,$i,*) ;;
5266           *) stage1_languages="$stage1_languages$i," ;;
5267         esac ;;
5268       *)
5269         case $missing_languages in
5270           *,$i,*) ;;
5271           *) missing_languages="$missing_languages$i," ;;
5272         esac ;;
5273      esac
5274   done
5275 fi;
5276
5277   # Remove leading/trailing commas that were added for simplicity
5278   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5279   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5280   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5281   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5282
5283   if test "x$missing_languages" != x; then
5284     { { echo "$as_me:$LINENO: error:
5285 The following requested languages could not be built: ${missing_languages}
5286 Supported languages are: ${potential_languages}" >&5
5287 echo "$as_me: error:
5288 The following requested languages could not be built: ${missing_languages}
5289 Supported languages are: ${potential_languages}" >&2;}
5290    { (exit 1); exit 1; }; }
5291   fi
5292   if test "x$new_enable_languages" != "x$enable_languages"; then
5293     echo The following languages will be built: ${new_enable_languages}
5294     enable_languages="$new_enable_languages"
5295   fi
5296
5297
5298   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5299 fi
5300
5301 # Handle --disable-<component> generically.
5302 for dir in $configdirs $build_configdirs $target_configdirs ; do
5303   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5304   varname=`echo $dirname | sed -e s/+/_/g`
5305   if eval test x\${enable_${varname}} "=" xno ; then
5306     noconfigdirs="$noconfigdirs $dir"
5307   fi
5308 done
5309
5310 # Check for Boehm's garbage collector
5311 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5312 if test "${enable_objc_gc+set}" = set; then
5313   enableval="$enable_objc_gc"
5314   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5315   *,objc,*:*:yes:*target-boehm-gc*)
5316     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5317 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5318    { (exit 1); exit 1; }; }
5319     ;;
5320 esac
5321 fi;
5322
5323 # Make sure we only build Boehm's garbage collector if required.
5324 case ,${enable_languages},:${enable_objc_gc} in
5325   *,objc,*:yes)
5326     # Keep target-boehm-gc if requested for Objective-C.
5327     ;;
5328   *)
5329     # Otherwise remove target-boehm-gc depending on target-libjava.
5330     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5331       noconfigdirs="$noconfigdirs target-boehm-gc"
5332     fi
5333     ;;
5334 esac
5335
5336 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5337 # $build_configdirs and $target_configdirs.
5338 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5339
5340 notsupp=""
5341 for dir in . $skipdirs $noconfigdirs ; do
5342   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5343   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5344     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5345     if test -r $srcdir/$dirname/configure ; then
5346       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5347         true
5348       else
5349         notsupp="$notsupp $dir"
5350       fi
5351     fi
5352   fi
5353   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5354     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5355     if test -r $srcdir/$dirname/configure ; then
5356       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5357         true
5358       else
5359         notsupp="$notsupp $dir"
5360       fi
5361     fi
5362   fi
5363   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5364     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5365     if test -r $srcdir/$dirname/configure ; then
5366       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5367         true
5368       else
5369         notsupp="$notsupp $dir"
5370       fi
5371     fi
5372   fi
5373 done
5374
5375 # Sometimes the tools are distributed with libiberty but with no other
5376 # libraries.  In that case, we don't want to build target-libiberty.
5377 # Don't let libgcc imply libiberty either.
5378 if test -n "${target_configdirs}" ; then
5379   libgcc=
5380   others=
5381   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5382     if test "$i" = "libgcc"; then
5383       libgcc=target-libgcc
5384     elif test "$i" != "libiberty" ; then
5385       if test -r $srcdir/$i/configure ; then
5386         others=yes;
5387         break;
5388       fi
5389     fi
5390   done
5391   if test -z "${others}" ; then
5392     target_configdirs=$libgcc
5393   fi
5394 fi
5395
5396 # Quietly strip out all directories which aren't configurable in this tree.
5397 # This relies on all configurable subdirectories being autoconfiscated, which
5398 # is now the case.
5399 build_configdirs_all="$build_configdirs"
5400 build_configdirs=
5401 for i in ${build_configdirs_all} ; do
5402   j=`echo $i | sed -e s/build-//g`
5403   if test -f ${srcdir}/$j/configure ; then
5404     build_configdirs="${build_configdirs} $i"
5405   fi
5406 done
5407
5408 configdirs_all="$configdirs"
5409 configdirs=
5410 for i in ${configdirs_all} ; do
5411   if test -f ${srcdir}/$i/configure ; then
5412     configdirs="${configdirs} $i"
5413   fi
5414 done
5415
5416 target_configdirs_all="$target_configdirs"
5417 target_configdirs=
5418 for i in ${target_configdirs_all} ; do
5419   j=`echo $i | sed -e s/target-//g`
5420   if test -f ${srcdir}/$j/configure ; then
5421     target_configdirs="${target_configdirs} $i"
5422   fi
5423 done
5424
5425 # Produce a warning message for the subdirs we can't configure.
5426 # This isn't especially interesting in the Cygnus tree, but in the individual
5427 # FSF releases, it's important to let people know when their machine isn't
5428 # supported by the one or two programs in a package.
5429
5430 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5431   # If $appdirs is non-empty, at least one of those directories must still
5432   # be configured, or we error out.  (E.g., if the gas release supports a
5433   # specified target in some subdirs but not the gas subdir, we shouldn't
5434   # pretend that all is well.)
5435   if test -n "$appdirs" ; then
5436     for dir in $appdirs ; do
5437       if test -r $dir/Makefile.in ; then
5438         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5439           appdirs=""
5440           break
5441         fi
5442         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5443           appdirs=""
5444           break
5445         fi
5446       fi
5447     done
5448     if test -n "$appdirs" ; then
5449       echo "*** This configuration is not supported by this package." 1>&2
5450       exit 1
5451     fi
5452   fi
5453   # Okay, some application will build, or we don't care to check.  Still
5454   # notify of subdirs not getting built.
5455   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5456   echo "    ${notsupp}" 1>&2
5457   echo "    (Any other directories should still work fine.)" 1>&2
5458 fi
5459
5460 case "$host" in
5461   *msdosdjgpp*)
5462     enable_gdbtk=no ;;
5463 esac
5464
5465 # To find our prefix, in gcc_cv_tool_prefix.
5466
5467 # The user is always right.
5468 if test "${PATH_SEPARATOR+set}" != set; then
5469   echo "#! /bin/sh" >conf$$.sh
5470   echo  "exit 0"   >>conf$$.sh
5471   chmod +x conf$$.sh
5472   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5473     PATH_SEPARATOR=';'
5474   else
5475     PATH_SEPARATOR=:
5476   fi
5477   rm -f conf$$.sh
5478 fi
5479
5480
5481
5482 if test "x$exec_prefix" = xNONE; then
5483         if test "x$prefix" = xNONE; then
5484                 gcc_cv_tool_prefix=$ac_default_prefix
5485         else
5486                 gcc_cv_tool_prefix=$prefix
5487         fi
5488 else
5489         gcc_cv_tool_prefix=$exec_prefix
5490 fi
5491
5492 # If there is no compiler in the tree, use the PATH only.  In any
5493 # case, if there is no compiler in the tree nobody should use
5494 # AS_FOR_TARGET and LD_FOR_TARGET.
5495 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5496     gcc_version=`cat $srcdir/gcc/BASE-VER`
5497     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5498     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5499     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5500     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5501     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5502     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5503 else
5504     gcc_cv_tool_dirs=
5505 fi
5506
5507 if test x$build = x$target && test -n "$md_exec_prefix"; then
5508         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5509 fi
5510
5511
5512
5513 copy_dirs=
5514
5515
5516 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5517 if test "${with_build_sysroot+set}" = set; then
5518   withval="$with_build_sysroot"
5519   if test x"$withval" != x ; then
5520      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5521    fi
5522 else
5523   SYSROOT_CFLAGS_FOR_TARGET=
5524 fi;
5525
5526
5527
5528 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5529 if test "${with_debug_prefix_map+set}" = set; then
5530   withval="$with_debug_prefix_map"
5531   if test x"$withval" != x; then
5532      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5533      for debug_map in $withval; do
5534        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5535      done
5536    fi
5537 else
5538   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5539 fi;
5540
5541
5542 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5543 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5544 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5545 # We want to ensure that TARGET libraries (which we know are built with
5546 # gcc) are built with "-O2 -g", so include those options when setting
5547 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5548 if test "x$CFLAGS_FOR_TARGET" = x; then
5549   CFLAGS_FOR_TARGET=$CFLAGS
5550   case " $CFLAGS " in
5551     *" -O2 "*) ;;
5552     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5553   esac
5554   case " $CFLAGS " in
5555     *" -g "* | *" -g3 "*) ;;
5556     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5557   esac
5558 fi
5559
5560
5561 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5562   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5563   case " $CXXFLAGS " in
5564     *" -O2 "*) ;;
5565     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5566   esac
5567   case " $CXXFLAGS " in
5568     *" -g "* | *" -g3 "*) ;;
5569     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5570   esac
5571 fi
5572
5573
5574 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5575 # the named directory are copied to $(tooldir)/sys-include.
5576 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5577   if test x${is_cross_compiler} = xno ; then
5578     echo 1>&2 '***' --with-headers is only supported when cross compiling
5579     exit 1
5580   fi
5581   if test x"${with_headers}" != xyes ; then
5582     x=${gcc_cv_tool_prefix}
5583     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5584   fi
5585 fi
5586
5587 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5588 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5589 # are permitted.
5590 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5591   if test x${is_cross_compiler} = xno ; then
5592     echo 1>&2 '***' --with-libs is only supported when cross compiling
5593     exit 1
5594   fi
5595   if test x"${with_libs}" != xyes ; then
5596     # Copy the libraries in reverse order, so that files in the first named
5597     # library override files in subsequent libraries.
5598     x=${gcc_cv_tool_prefix}
5599     for l in ${with_libs}; do
5600       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5601     done
5602   fi
5603 fi
5604
5605 # Set with_gnu_as and with_gnu_ld as appropriate.
5606 #
5607 # This is done by determining whether or not the appropriate directory
5608 # is available, and by checking whether or not specific configurations
5609 # have requested that this magic not happen.
5610 #
5611 # The command line options always override the explicit settings in
5612 # configure.in, and the settings in configure.in override this magic.
5613 #
5614 # If the default for a toolchain is to use GNU as and ld, and you don't
5615 # want to do that, then you should use the --without-gnu-as and
5616 # --without-gnu-ld options for the configure script.
5617
5618 if test x${use_gnu_as} = x &&
5619    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5620   with_gnu_as=yes
5621   extra_host_args="$extra_host_args --with-gnu-as"
5622 fi
5623
5624 if test x${use_gnu_ld} = x &&
5625    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5626   with_gnu_ld=yes
5627   extra_host_args="$extra_host_args --with-gnu-ld"
5628 fi
5629
5630 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5631 # can detect this case.
5632
5633 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5634   with_newlib=yes
5635   extra_host_args="$extra_host_args --with-newlib"
5636 fi
5637
5638 # Handle ${copy_dirs}
5639 set fnord ${copy_dirs}
5640 shift
5641 while test $# != 0 ; do
5642   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5643     :
5644   else
5645     echo Copying $1 to $2
5646
5647     # Use the install script to create the directory and all required
5648     # parent directories.
5649     if test -d $2 ; then
5650       :
5651     else
5652       echo >config.temp
5653       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5654     fi
5655
5656     # Copy the directory, assuming we have tar.
5657     # FIXME: Should we use B in the second tar?  Not all systems support it.
5658     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5659
5660     # It is the responsibility of the user to correctly adjust all
5661     # symlinks.  If somebody can figure out how to handle them correctly
5662     # here, feel free to add the code.
5663
5664     echo $1 > $2/COPIED
5665   fi
5666   shift; shift
5667 done
5668
5669 # Determine a target-dependent exec_prefix that the installed
5670 # gcc will search in.  Keep this list sorted by triplet, with
5671 # the *-*-osname triplets last.
5672 md_exec_prefix=
5673 case "${target}" in
5674   alpha*-*-*vms*)
5675     md_exec_prefix=/gnu/lib/gcc-lib
5676     ;;
5677   i[34567]86-pc-msdosdjgpp*)
5678     md_exec_prefix=/dev/env/DJDIR/bin
5679     ;;
5680   i[34567]86-*-sco3.2v5*)
5681     if test $with_gnu_as = yes; then
5682       md_exec_prefix=/usr/gnu/bin
5683     else
5684       md_exec_prefix=/usr/ccs/bin/elf
5685     fi
5686     ;;
5687
5688   mn10300-*-* | \
5689   powerpc-*-chorusos* | \
5690   powerpc*-*-eabi* | \
5691   powerpc*-*-sysv* | \
5692   powerpc*-*-kaos* | \
5693   s390x-ibm-tpf*)
5694     md_exec_prefix=/usr/ccs/bin
5695     ;;
5696   sparc64-*-elf*)
5697     ;;
5698   v850*-*-*)
5699     md_exec_prefix=/usr/ccs/bin
5700     ;;
5701   xtensa*-*-elf*)
5702     ;;
5703
5704   *-*-beos* | \
5705   *-*-elf* | \
5706   *-*-hpux* | \
5707   *-*-netware* | \
5708   *-*-nto-qnx* | \
5709   *-*-rtems* | \
5710   *-*-solaris2* | \
5711   *-*-sysv[45]* | \
5712   *-*-vxworks* | \
5713   *-wrs-windiss)
5714     md_exec_prefix=/usr/ccs/bin
5715     ;;
5716 esac
5717
5718 extra_arflags_for_target=
5719 extra_nmflags_for_target=
5720 extra_ranlibflags_for_target=
5721 target_makefile_frag=/dev/null
5722 case "${target}" in
5723   mep*-*-*)
5724     target_makefile_frag="config/mt-mep"
5725     ;;
5726   spu-*-*)
5727     target_makefile_frag="config/mt-spu"
5728     ;;
5729   mips*-sde-elf*)
5730     target_makefile_frag="config/mt-sde"
5731     ;;
5732   mipsisa*-*-elfoabi*)
5733     target_makefile_frag="config/mt-mips-elfoabi"
5734     ;;
5735   mips*-*-*linux* | mips*-*-gnu*)
5736     target_makefile_frag="config/mt-mips-gnu"
5737     ;;
5738   *-*-netware*)
5739     target_makefile_frag="config/mt-netware"
5740     ;;
5741   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
5742     target_makefile_frag="config/mt-gnu"
5743     ;;
5744   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5745     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5746     # commands to handle both 32-bit and 64-bit objects.  These flags are
5747     # harmless if we're using GNU nm or ar.
5748     extra_arflags_for_target=" -X32_64"
5749     extra_nmflags_for_target=" -B -X32_64"
5750     ;;
5751   *-*-darwin*)
5752     # ranlib from Darwin requires the -c flag to look at common symbols.
5753     extra_ranlibflags_for_target=" -c"
5754     ;;
5755   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5756     target_makefile_frag="config/mt-wince"
5757     ;;
5758 esac
5759
5760 alphaieee_frag=/dev/null
5761 case $target in
5762   alpha*-*-*)
5763     # This just makes sure to use the -mieee option to build target libs.
5764     # This should probably be set individually by each library.
5765     alphaieee_frag="config/mt-alphaieee"
5766     ;;
5767 esac
5768
5769 # If --enable-target-optspace always use -Os instead of -O2 to build
5770 # the target libraries, similarly if it is not specified, use -Os
5771 # on selected platforms.
5772 ospace_frag=/dev/null
5773 case "${enable_target_optspace}:${target}" in
5774   yes:*)
5775     ospace_frag="config/mt-ospace"
5776     ;;
5777   :d30v-*)
5778     ospace_frag="config/mt-d30v"
5779     ;;
5780   :m32r-* | :d10v-* | :fr30-*)
5781     ospace_frag="config/mt-ospace"
5782     ;;
5783   no:* | :*)
5784     ;;
5785   *)
5786     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5787     ;;
5788 esac
5789
5790 # Default to using --with-stabs for certain targets.
5791 if test x${with_stabs} = x ; then
5792   case "${target}" in
5793   mips*-*-irix[56]*)
5794     ;;
5795   mips*-*-* | alpha*-*-osf*)
5796     with_stabs=yes;
5797     extra_host_args="${extra_host_args} --with-stabs"
5798     ;;
5799   esac
5800 fi
5801
5802 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5803 # them automatically.
5804 case "${host}" in
5805   hppa*64*-*-hpux11*)
5806     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5807     ;;
5808 esac
5809
5810 # Some systems (e.g., one of the i386-aix systems the gas testers are
5811 # using) don't handle "\$" correctly, so don't use it here.
5812 tooldir='${exec_prefix}'/${target_noncanonical}
5813 build_tooldir=${tooldir}
5814
5815 # Create a .gdbinit file which runs the one in srcdir
5816 # and tells GDB to look there for source files.
5817
5818 if test -r ${srcdir}/.gdbinit ; then
5819   case ${srcdir} in
5820     .) ;;
5821     *) cat > ./.gdbinit <<EOF
5822 # ${NO_EDIT}
5823 dir ${srcdir}
5824 dir .
5825 source ${srcdir}/.gdbinit
5826 EOF
5827     ;;
5828   esac
5829 fi
5830
5831 # Make sure that the compiler is able to generate an executable.  If it
5832 # can't, we are probably in trouble.  We don't care whether we can run the
5833 # executable--we might be using a cross compiler--we only care whether it
5834 # can be created.  At this point the main configure script has set CC.
5835 we_are_ok=no
5836 echo "int main () { return 0; }" > conftest.c
5837 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5838 if test $? = 0 ; then
5839   if test -s conftest || test -s conftest.exe ; then
5840     we_are_ok=yes
5841   fi
5842 fi
5843 case $we_are_ok in
5844   no)
5845     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5846     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5847     rm -f conftest*
5848     exit 1
5849     ;;
5850 esac
5851 rm -f conftest*
5852
5853 # The Solaris /usr/ucb/cc compiler does not appear to work.
5854 case "${host}" in
5855   sparc-sun-solaris2*)
5856       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5857       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5858           could_use=
5859           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5860           if test -d /opt/cygnus/bin ; then
5861               if test "$could_use" = "" ; then
5862                   could_use="/opt/cygnus/bin"
5863               else
5864                   could_use="$could_use or /opt/cygnus/bin"
5865               fi
5866           fi
5867         if test "$could_use" = "" ; then
5868             echo "Warning: compilation may fail because you're using"
5869             echo "/usr/ucb/cc.  You should change your PATH or CC "
5870             echo "variable and rerun configure."
5871         else
5872             echo "Warning: compilation may fail because you're using"
5873             echo "/usr/ucb/cc, when you should use the C compiler from"
5874             echo "$could_use.  You should change your"
5875             echo "PATH or CC variable and rerun configure."
5876         fi
5877       fi
5878   ;;
5879 esac
5880
5881 # Decide which environment variable is used to find dynamic libraries.
5882 case "${host}" in
5883   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5884   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5885   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
5886   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5887 esac
5888
5889 # On systems where the dynamic library environment variable is PATH,
5890 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
5891 # built executables to PATH.
5892 if test "$RPATH_ENVVAR" = PATH; then
5893   GCC_SHLIB_SUBDIR=/shlib
5894 else
5895   GCC_SHLIB_SUBDIR=
5896 fi
5897
5898 # Record target_configdirs and the configure arguments for target and
5899 # build configuration in Makefile.
5900 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5901 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5902
5903 # Determine whether gdb needs tk/tcl or not.
5904 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5905 # and in that case we want gdb to be built without tk.  Ugh!
5906 # In fact I believe gdb is the *only* package directly dependent on tk,
5907 # so we should be able to put the 'maybe's in unconditionally and
5908 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5909 # 100% sure that that's safe though.
5910
5911 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5912 case "$enable_gdbtk" in
5913   no)
5914     GDB_TK="" ;;
5915   yes)
5916     GDB_TK="${gdb_tk}" ;;
5917   *)
5918     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5919     # distro.  Eventually someone will fix this and move Insight, nee
5920     # gdbtk to a separate directory.
5921     if test -d ${srcdir}/gdb/gdbtk ; then
5922       GDB_TK="${gdb_tk}"
5923     else
5924       GDB_TK=""
5925     fi
5926     ;;
5927 esac
5928 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5929 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5930
5931 # Strip out unwanted targets.
5932
5933 # While at that, we remove Makefiles if we were started for recursive
5934 # configuration, so that the top-level Makefile reconfigures them,
5935 # like we used to do when configure itself was recursive.
5936
5937 # Loop over modules.  $extrasub must be used with care, limiting as
5938 # much as possible the usage of range addresses.  That's because autoconf
5939 # splits the sed script to overcome limits in the number of commands,
5940 # and relying on carefully-timed sed passes may turn out to be very hard
5941 # to maintain later.  In this particular case, you just have to be careful
5942 # not to nest @if/@endif pairs, because configure will not warn you at all.
5943
5944 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5945 if test "${enable_bootstrap+set}" = set; then
5946   enableval="$enable_bootstrap"
5947
5948 else
5949   enable_bootstrap=default
5950 fi;
5951
5952 # Issue errors and warnings for invalid/strange bootstrap combinations.
5953 case "$configdirs" in
5954   *gcc*) have_compiler=yes ;;
5955   *) have_compiler=no ;;
5956 esac
5957
5958 case "$have_compiler:$host:$target:$enable_bootstrap" in
5959   *:*:*:no) ;;
5960
5961   # Default behavior.  Enable bootstrap if we have a compiler
5962   # and we are in a native configuration.
5963   yes:$build:$build:default)
5964     enable_bootstrap=yes ;;
5965
5966   *:*:*:default)
5967     enable_bootstrap=no ;;
5968
5969   # We have a compiler and we are in a native configuration, bootstrap is ok
5970   yes:$build:$build:yes)
5971     ;;
5972
5973   # Other configurations, but we have a compiler.  Assume the user knows
5974   # what he's doing.
5975   yes:*:*:yes)
5976     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5977 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5978     ;;
5979
5980   # No compiler: if they passed --enable-bootstrap explicitly, fail
5981   no:*:*:yes)
5982     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5983 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5984    { (exit 1); exit 1; }; } ;;
5985
5986   # Fail if wrong command line
5987   *)
5988     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5989 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5990    { (exit 1); exit 1; }; }
5991     ;;
5992 esac
5993
5994 # Adjust the toplevel makefile according to whether bootstrap was selected.
5995 case "$enable_bootstrap" in
5996   yes)
5997     bootstrap_suffix=bootstrap ;;
5998   no)
5999     bootstrap_suffix=no-bootstrap ;;
6000 esac
6001
6002 for module in ${build_configdirs} ; do
6003   if test -z "${no_recursion}" \
6004      && test -f ${build_subdir}/${module}/Makefile; then
6005     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
6006     rm -f ${build_subdir}/${module}/Makefile
6007   fi
6008   extrasub="$extrasub
6009 /^@if build-$module\$/d
6010 /^@endif build-$module\$/d
6011 /^@if build-$module-$bootstrap_suffix\$/d
6012 /^@endif build-$module-$bootstrap_suffix\$/d"
6013 done
6014 for module in ${configdirs} ; do
6015   if test -z "${no_recursion}"; then
6016     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
6017       if test -f ${file}; then
6018         echo 1>&2 "*** removing ${file} to force reconfigure"
6019         rm -f ${file}
6020       fi
6021     done
6022   fi
6023   extrasub="$extrasub
6024 /^@if $module\$/d
6025 /^@endif $module\$/d
6026 /^@if $module-$bootstrap_suffix\$/d
6027 /^@endif $module-$bootstrap_suffix\$/d"
6028 done
6029 for module in ${target_configdirs} ; do
6030   if test -z "${no_recursion}" \
6031      && test -f ${target_subdir}/${module}/Makefile; then
6032     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6033     rm -f ${target_subdir}/${module}/Makefile
6034   fi
6035   extrasub="$extrasub
6036 /^@if target-$module\$/d
6037 /^@endif target-$module\$/d
6038 /^@if target-$module-$bootstrap_suffix\$/d
6039 /^@endif target-$module-$bootstrap_suffix\$/d"
6040 done
6041
6042 extrasub="$extrasub
6043 /^@if /,/^@endif /d"
6044
6045 # Create the serialization dependencies.  This uses a temporary file.
6046
6047 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6048 if test "${enable_serial_configure+set}" = set; then
6049   enableval="$enable_serial_configure"
6050
6051 fi;
6052
6053 case ${enable_serial_configure} in
6054   yes)
6055     enable_serial_build_configure=yes
6056     enable_serial_host_configure=yes
6057     enable_serial_target_configure=yes
6058     ;;
6059 esac
6060
6061 # These force 'configure's to be done one at a time, to avoid problems
6062 # with contention over a shared config.cache.
6063 rm -f serdep.tmp
6064 echo '# serdep.tmp' > serdep.tmp
6065 olditem=
6066 test "x${enable_serial_build_configure}" = xyes &&
6067 for item in ${build_configdirs} ; do
6068   case ${olditem} in
6069     "") ;;
6070     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6071   esac
6072   olditem=${item}
6073 done
6074 olditem=
6075 test "x${enable_serial_host_configure}" = xyes &&
6076 for item in ${configdirs} ; do
6077   case ${olditem} in
6078     "") ;;
6079     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6080   esac
6081   olditem=${item}
6082 done
6083 olditem=
6084 test "x${enable_serial_target_configure}" = xyes &&
6085 for item in ${target_configdirs} ; do
6086   case ${olditem} in
6087     "") ;;
6088     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6089   esac
6090   olditem=${item}
6091 done
6092 serialization_dependencies=serdep.tmp
6093
6094
6095 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6096 # target, nonopt, and variable assignments.  These are the ones we
6097 # might not want to pass down to subconfigures.  Also strip
6098 # program-prefix, program-suffix, and program-transform-name, so that
6099 # we can pass down a consistent program-transform-name.
6100 baseargs=
6101 keep_next=no
6102 skip_next=no
6103 eval "set -- $ac_configure_args"
6104 for ac_arg
6105 do
6106   if test X"$skip_next" = X"yes"; then
6107     skip_next=no
6108     continue
6109   fi
6110   if test X"$keep_next" = X"yes"; then
6111     case $ac_arg in
6112       *\'*)
6113         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6114     esac
6115     baseargs="$baseargs '$ac_arg'"
6116     keep_next=no
6117     continue
6118   fi
6119
6120   # Handle separated arguments.  Based on the logic generated by
6121   # autoconf 2.59.
6122   case $ac_arg in
6123     *=* | --config-cache | -C | -disable-* | --disable-* \
6124       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6125       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6126       | -with-* | --with-* | -without-* | --without-* | --x)
6127       separate_arg=no
6128       ;;
6129     -*)
6130       separate_arg=yes
6131       ;;
6132     *)
6133       separate_arg=no
6134       ;;
6135   esac
6136
6137   case "$ac_arg" in
6138     --no*)
6139       continue
6140       ;;
6141     --c* | \
6142     --sr* | \
6143     --ho* | \
6144     --bu* | \
6145     --t* | \
6146     --program-* | \
6147     -cache_file* | \
6148     -srcdir* | \
6149     -host* | \
6150     -build* | \
6151     -target* | \
6152     -program-prefix* | \
6153     -program-suffix* | \
6154     -program-transform-name* )
6155       skip_next=$separate_arg
6156       continue
6157       ;;
6158     -*)
6159       # An option.  Add it.
6160       case $ac_arg in
6161         *\'*)
6162           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6163       esac
6164       baseargs="$baseargs '$ac_arg'"
6165       keep_next=$separate_arg
6166       ;;
6167     *)
6168       # Either a variable assignment, or a nonopt (triplet).  Don't
6169       # pass it down; let the Makefile handle this.
6170       continue
6171       ;;
6172   esac
6173 done
6174 # Remove the initial space we just introduced and, as these will be
6175 # expanded by make, quote '$'.
6176 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6177
6178 # Add in --program-transform-name, after --program-prefix and
6179 # --program-suffix have been applied to it.  Autoconf has already
6180 # doubled dollar signs and backslashes in program_transform_name; we want
6181 # the backslashes un-doubled, and then the entire thing wrapped in single
6182 # quotes, because this will be expanded first by make and then by the shell.
6183 # Also, because we want to override the logic in subdir configure scripts to
6184 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6185 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6186 ${program_transform_name}
6187 EOF_SED
6188 gcc_transform_name=`cat conftestsed.out`
6189 rm -f conftestsed.out
6190 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6191 if test "$silent" = yes; then
6192   baseargs="$baseargs --silent"
6193 fi
6194
6195 # For the build-side libraries, we just need to pretend we're native,
6196 # and not use the same cache file.  Multilibs are neither needed nor
6197 # desired.
6198 build_configargs="--cache-file=../config.cache ${baseargs}"
6199
6200 # For host modules, accept cache file option, or specification as blank.
6201 case "${cache_file}" in
6202 "") # empty
6203   cache_file_option="" ;;
6204 /* | [A-Za-z]:[\\/]* ) # absolute path
6205   cache_file_option="--cache-file=${cache_file}" ;;
6206 *) # relative path
6207   cache_file_option="--cache-file=../${cache_file}" ;;
6208 esac
6209
6210 # Host dirs don't like to share a cache file either, horribly enough.
6211 # This seems to be due to autoconf 2.5x stupidity.
6212 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6213
6214 target_configargs=${baseargs}
6215
6216 # Passing a --with-cross-host argument lets the target libraries know
6217 # whether they are being built with a cross-compiler or being built
6218 # native.  However, it would be better to use other mechanisms to make the
6219 # sorts of decisions they want to make on this basis.  Please consider
6220 # this option to be deprecated.  FIXME.
6221 if test x${is_cross_compiler} = xyes ; then
6222   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6223 fi
6224
6225 # Default to --enable-multilib.
6226 if test x${enable_multilib} = x ; then
6227   target_configargs="--enable-multilib ${target_configargs}"
6228 fi
6229
6230 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6231 # changed from the earlier setting of with_newlib.
6232 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6233   target_configargs="--with-newlib ${target_configargs}"
6234 fi
6235
6236 # Different target subdirs use different values of certain variables
6237 # (notably CXX).  Worse, multilibs use *lots* of different values.
6238 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6239 # it doesn't automatically accept command-line overrides of them.
6240 # This means it's not safe for target subdirs to share a cache file,
6241 # which is disgusting, but there you have it.  Hopefully this can be
6242 # fixed in future.  It's still worthwhile to use a cache file for each
6243 # directory.  I think.
6244
6245 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6246 # We need to pass --target, as newer autoconf's requires consistency
6247 # for target_alias and gcc doesn't manage it consistently.
6248 target_configargs="--cache-file=./config.cache ${target_configargs}"
6249
6250 FLAGS_FOR_TARGET=
6251 case " $target_configdirs " in
6252  *" newlib "*)
6253   case " $target_configargs " in
6254   *" --with-newlib "*)
6255    case "$target" in
6256    *-cygwin*)
6257      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' ;;
6258    esac
6259
6260    # If we're not building GCC, don't discard standard headers.
6261    if test -d ${srcdir}/gcc; then
6262      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6263
6264      if test "${build}" != "${host}"; then
6265        # On Canadian crosses, CC_FOR_TARGET will have already been set
6266        # by `configure', so we won't have an opportunity to add -Bgcc/
6267        # to it.  This is right: we don't want to search that directory
6268        # for binaries, but we want the header files in there, so add
6269        # them explicitly.
6270        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6271
6272        # Someone might think of using the pre-installed headers on
6273        # Canadian crosses, in case the installed compiler is not fully
6274        # compatible with the compiler being built.  In this case, it
6275        # would be better to flag an error than risking having
6276        # incompatible object files being constructed.  We can't
6277        # guarantee that an error will be flagged, but let's hope the
6278        # compiler will do it, when presented with incompatible header
6279        # files.
6280      fi
6281    fi
6282
6283    case "${target}-${is_cross_compiler}" in
6284    i[3456789]86-*-linux*-no)
6285       # Here host == target, so we don't need to build gcc,
6286       # so we don't want to discard standard headers.
6287       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6288       ;;
6289    *)
6290       # If we're building newlib, use its generic headers last, but search
6291       # for any libc-related directories first (so make it the last -B
6292       # switch).
6293       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6294
6295       # If we're building libgloss, find the startup file, simulator library
6296       # and linker script.
6297       case " $target_configdirs " in
6298         *" libgloss "*)
6299         # Look for startup file, simulator library and maybe linker script.
6300         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6301         # Look for libnosys.a in case the target needs it.
6302         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6303         # Most targets have the linker script in the source directory.
6304         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6305         ;;
6306       esac
6307       ;;
6308    esac
6309    ;;
6310   esac
6311   ;;
6312 esac
6313 case "$target" in
6314 *-mingw*)
6315   # Can't be handled as Cygwin above since Mingw does not use newlib.
6316   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' ;;
6317 esac
6318
6319 # Allow the user to override the flags for
6320 # our build compiler if desired.
6321 if test x"${build}" = x"${host}" ; then
6322   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6323   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6324   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6325 fi
6326
6327 # On Canadian crosses, we'll be searching the right directories for
6328 # the previously-installed cross compiler, so don't bother to add
6329 # flags for directories within the install tree of the compiler
6330 # being built; programs in there won't even run.
6331 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6332   # Search for pre-installed headers if nothing else fits.
6333   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6334 fi
6335
6336 if test "x${use_gnu_ld}" = x &&
6337    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6338   # Arrange for us to find uninstalled linker scripts.
6339   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6340 fi
6341
6342 # Search for other target-specific linker scripts and such.
6343 case "${target}" in
6344   mep*)
6345     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6346     ;;
6347 esac
6348
6349 # Makefile fragments.
6350 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6351 do
6352   eval fragval=\$$frag
6353   if test $fragval != /dev/null; then
6354     eval $frag=${srcdir}/$fragval
6355   fi
6356 done
6357
6358
6359
6360
6361
6362 # Miscellanea: directories, flags, etc.
6363
6364
6365
6366
6367
6368
6369
6370
6371 # Build module lists & subconfigure args.
6372
6373
6374
6375 # Host module lists & subconfigure args.
6376
6377
6378
6379 # Target module lists & subconfigure args.
6380
6381
6382
6383 # Build tools.
6384
6385
6386
6387
6388
6389
6390
6391
6392
6393
6394
6395
6396
6397
6398
6399
6400
6401 # Generate default definitions for YACC, M4, LEX and other programs that run
6402 # on the build machine.  These are used if the Makefile can't locate these
6403 # programs in objdir.
6404 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6405
6406 for ac_prog in 'bison -y' byacc yacc
6407 do
6408   # Extract the first word of "$ac_prog", so it can be a program name with args.
6409 set dummy $ac_prog; ac_word=$2
6410 echo "$as_me:$LINENO: checking for $ac_word" >&5
6411 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6412 if test "${ac_cv_prog_YACC+set}" = set; then
6413   echo $ECHO_N "(cached) $ECHO_C" >&6
6414 else
6415   if test -n "$YACC"; then
6416   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6417 else
6418 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6419 for as_dir in $PATH
6420 do
6421   IFS=$as_save_IFS
6422   test -z "$as_dir" && as_dir=.
6423   for ac_exec_ext in '' $ac_executable_extensions; do
6424   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6425     ac_cv_prog_YACC="$ac_prog"
6426     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6427     break 2
6428   fi
6429 done
6430 done
6431
6432 fi
6433 fi
6434 YACC=$ac_cv_prog_YACC
6435 if test -n "$YACC"; then
6436   echo "$as_me:$LINENO: result: $YACC" >&5
6437 echo "${ECHO_T}$YACC" >&6
6438 else
6439   echo "$as_me:$LINENO: result: no" >&5
6440 echo "${ECHO_T}no" >&6
6441 fi
6442
6443   test -n "$YACC" && break
6444 done
6445 test -n "$YACC" || YACC="$MISSING bison -y"
6446
6447 case " $build_configdirs " in
6448   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6449   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6450 esac
6451
6452 for ac_prog in bison
6453 do
6454   # Extract the first word of "$ac_prog", so it can be a program name with args.
6455 set dummy $ac_prog; ac_word=$2
6456 echo "$as_me:$LINENO: checking for $ac_word" >&5
6457 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6458 if test "${ac_cv_prog_BISON+set}" = set; then
6459   echo $ECHO_N "(cached) $ECHO_C" >&6
6460 else
6461   if test -n "$BISON"; then
6462   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6463 else
6464 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6465 for as_dir in $PATH
6466 do
6467   IFS=$as_save_IFS
6468   test -z "$as_dir" && as_dir=.
6469   for ac_exec_ext in '' $ac_executable_extensions; do
6470   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6471     ac_cv_prog_BISON="$ac_prog"
6472     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6473     break 2
6474   fi
6475 done
6476 done
6477
6478 fi
6479 fi
6480 BISON=$ac_cv_prog_BISON
6481 if test -n "$BISON"; then
6482   echo "$as_me:$LINENO: result: $BISON" >&5
6483 echo "${ECHO_T}$BISON" >&6
6484 else
6485   echo "$as_me:$LINENO: result: no" >&5
6486 echo "${ECHO_T}no" >&6
6487 fi
6488
6489   test -n "$BISON" && break
6490 done
6491 test -n "$BISON" || BISON="$MISSING bison"
6492
6493 case " $build_configdirs " in
6494   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6495 esac
6496
6497 for ac_prog in gm4 gnum4 m4
6498 do
6499   # Extract the first word of "$ac_prog", so it can be a program name with args.
6500 set dummy $ac_prog; ac_word=$2
6501 echo "$as_me:$LINENO: checking for $ac_word" >&5
6502 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6503 if test "${ac_cv_prog_M4+set}" = set; then
6504   echo $ECHO_N "(cached) $ECHO_C" >&6
6505 else
6506   if test -n "$M4"; then
6507   ac_cv_prog_M4="$M4" # Let the user override the test.
6508 else
6509 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6510 for as_dir in $PATH
6511 do
6512   IFS=$as_save_IFS
6513   test -z "$as_dir" && as_dir=.
6514   for ac_exec_ext in '' $ac_executable_extensions; do
6515   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6516     ac_cv_prog_M4="$ac_prog"
6517     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6518     break 2
6519   fi
6520 done
6521 done
6522
6523 fi
6524 fi
6525 M4=$ac_cv_prog_M4
6526 if test -n "$M4"; then
6527   echo "$as_me:$LINENO: result: $M4" >&5
6528 echo "${ECHO_T}$M4" >&6
6529 else
6530   echo "$as_me:$LINENO: result: no" >&5
6531 echo "${ECHO_T}no" >&6
6532 fi
6533
6534   test -n "$M4" && break
6535 done
6536 test -n "$M4" || M4="$MISSING m4"
6537
6538 case " $build_configdirs " in
6539   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6540 esac
6541
6542 for ac_prog in flex lex
6543 do
6544   # Extract the first word of "$ac_prog", so it can be a program name with args.
6545 set dummy $ac_prog; ac_word=$2
6546 echo "$as_me:$LINENO: checking for $ac_word" >&5
6547 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6548 if test "${ac_cv_prog_LEX+set}" = set; then
6549   echo $ECHO_N "(cached) $ECHO_C" >&6
6550 else
6551   if test -n "$LEX"; then
6552   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6553 else
6554 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6555 for as_dir in $PATH
6556 do
6557   IFS=$as_save_IFS
6558   test -z "$as_dir" && as_dir=.
6559   for ac_exec_ext in '' $ac_executable_extensions; do
6560   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6561     ac_cv_prog_LEX="$ac_prog"
6562     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6563     break 2
6564   fi
6565 done
6566 done
6567
6568 fi
6569 fi
6570 LEX=$ac_cv_prog_LEX
6571 if test -n "$LEX"; then
6572   echo "$as_me:$LINENO: result: $LEX" >&5
6573 echo "${ECHO_T}$LEX" >&6
6574 else
6575   echo "$as_me:$LINENO: result: no" >&5
6576 echo "${ECHO_T}no" >&6
6577 fi
6578
6579   test -n "$LEX" && break
6580 done
6581 test -n "$LEX" || LEX="$MISSING flex"
6582
6583 case " $build_configdirs " in
6584   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6585   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6586 esac
6587
6588 for ac_prog in flex
6589 do
6590   # Extract the first word of "$ac_prog", so it can be a program name with args.
6591 set dummy $ac_prog; ac_word=$2
6592 echo "$as_me:$LINENO: checking for $ac_word" >&5
6593 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6594 if test "${ac_cv_prog_FLEX+set}" = set; then
6595   echo $ECHO_N "(cached) $ECHO_C" >&6
6596 else
6597   if test -n "$FLEX"; then
6598   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6599 else
6600 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6601 for as_dir in $PATH
6602 do
6603   IFS=$as_save_IFS
6604   test -z "$as_dir" && as_dir=.
6605   for ac_exec_ext in '' $ac_executable_extensions; do
6606   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6607     ac_cv_prog_FLEX="$ac_prog"
6608     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6609     break 2
6610   fi
6611 done
6612 done
6613
6614 fi
6615 fi
6616 FLEX=$ac_cv_prog_FLEX
6617 if test -n "$FLEX"; then
6618   echo "$as_me:$LINENO: result: $FLEX" >&5
6619 echo "${ECHO_T}$FLEX" >&6
6620 else
6621   echo "$as_me:$LINENO: result: no" >&5
6622 echo "${ECHO_T}no" >&6
6623 fi
6624
6625   test -n "$FLEX" && break
6626 done
6627 test -n "$FLEX" || FLEX="$MISSING flex"
6628
6629 case " $build_configdirs " in
6630   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6631 esac
6632
6633 for ac_prog in makeinfo
6634 do
6635   # Extract the first word of "$ac_prog", so it can be a program name with args.
6636 set dummy $ac_prog; ac_word=$2
6637 echo "$as_me:$LINENO: checking for $ac_word" >&5
6638 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6639 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6640   echo $ECHO_N "(cached) $ECHO_C" >&6
6641 else
6642   if test -n "$MAKEINFO"; then
6643   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6644 else
6645 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6646 for as_dir in $PATH
6647 do
6648   IFS=$as_save_IFS
6649   test -z "$as_dir" && as_dir=.
6650   for ac_exec_ext in '' $ac_executable_extensions; do
6651   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6652     ac_cv_prog_MAKEINFO="$ac_prog"
6653     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6654     break 2
6655   fi
6656 done
6657 done
6658
6659 fi
6660 fi
6661 MAKEINFO=$ac_cv_prog_MAKEINFO
6662 if test -n "$MAKEINFO"; then
6663   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6664 echo "${ECHO_T}$MAKEINFO" >&6
6665 else
6666   echo "$as_me:$LINENO: result: no" >&5
6667 echo "${ECHO_T}no" >&6
6668 fi
6669
6670   test -n "$MAKEINFO" && break
6671 done
6672 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6673
6674 case " $build_configdirs " in
6675   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6676   *)
6677
6678     # For an installed makeinfo, we require it to be from texinfo 4.7 or
6679     # higher, else we use the "missing" dummy.
6680     if ${MAKEINFO} --version \
6681        | egrep 'texinfo[^0-9]*(4\.([7-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6682       :
6683     else
6684       MAKEINFO="$MISSING makeinfo"
6685     fi
6686     ;;
6687
6688 esac
6689
6690 # FIXME: expect and dejagnu may become build tools?
6691
6692 for ac_prog in expect
6693 do
6694   # Extract the first word of "$ac_prog", so it can be a program name with args.
6695 set dummy $ac_prog; ac_word=$2
6696 echo "$as_me:$LINENO: checking for $ac_word" >&5
6697 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6698 if test "${ac_cv_prog_EXPECT+set}" = set; then
6699   echo $ECHO_N "(cached) $ECHO_C" >&6
6700 else
6701   if test -n "$EXPECT"; then
6702   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6703 else
6704 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6705 for as_dir in $PATH
6706 do
6707   IFS=$as_save_IFS
6708   test -z "$as_dir" && as_dir=.
6709   for ac_exec_ext in '' $ac_executable_extensions; do
6710   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6711     ac_cv_prog_EXPECT="$ac_prog"
6712     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6713     break 2
6714   fi
6715 done
6716 done
6717
6718 fi
6719 fi
6720 EXPECT=$ac_cv_prog_EXPECT
6721 if test -n "$EXPECT"; then
6722   echo "$as_me:$LINENO: result: $EXPECT" >&5
6723 echo "${ECHO_T}$EXPECT" >&6
6724 else
6725   echo "$as_me:$LINENO: result: no" >&5
6726 echo "${ECHO_T}no" >&6
6727 fi
6728
6729   test -n "$EXPECT" && break
6730 done
6731 test -n "$EXPECT" || EXPECT="expect"
6732
6733 case " $configdirs " in
6734   *" expect "*)
6735     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6736     ;;
6737 esac
6738
6739 for ac_prog in runtest
6740 do
6741   # Extract the first word of "$ac_prog", so it can be a program name with args.
6742 set dummy $ac_prog; ac_word=$2
6743 echo "$as_me:$LINENO: checking for $ac_word" >&5
6744 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6745 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6746   echo $ECHO_N "(cached) $ECHO_C" >&6
6747 else
6748   if test -n "$RUNTEST"; then
6749   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6750 else
6751 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6752 for as_dir in $PATH
6753 do
6754   IFS=$as_save_IFS
6755   test -z "$as_dir" && as_dir=.
6756   for ac_exec_ext in '' $ac_executable_extensions; do
6757   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6758     ac_cv_prog_RUNTEST="$ac_prog"
6759     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6760     break 2
6761   fi
6762 done
6763 done
6764
6765 fi
6766 fi
6767 RUNTEST=$ac_cv_prog_RUNTEST
6768 if test -n "$RUNTEST"; then
6769   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6770 echo "${ECHO_T}$RUNTEST" >&6
6771 else
6772   echo "$as_me:$LINENO: result: no" >&5
6773 echo "${ECHO_T}no" >&6
6774 fi
6775
6776   test -n "$RUNTEST" && break
6777 done
6778 test -n "$RUNTEST" || RUNTEST="runtest"
6779
6780 case " $configdirs " in
6781   *" dejagnu "*)
6782     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6783     ;;
6784 esac
6785
6786
6787 # Host tools.
6788 ncn_tool_prefix=
6789 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6790 ncn_target_tool_prefix=
6791 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6792
6793
6794
6795 if test -n "$AR"; then
6796   ac_cv_prog_AR=$AR
6797 elif test -n "$ac_cv_prog_AR"; then
6798   AR=$ac_cv_prog_AR
6799 fi
6800
6801 if test -n "$ac_cv_prog_AR"; then
6802   for ncn_progname in ar; do
6803     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6804 set dummy ${ncn_progname}; ac_word=$2
6805 echo "$as_me:$LINENO: checking for $ac_word" >&5
6806 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6807 if test "${ac_cv_prog_AR+set}" = set; then
6808   echo $ECHO_N "(cached) $ECHO_C" >&6
6809 else
6810   if test -n "$AR"; then
6811   ac_cv_prog_AR="$AR" # Let the user override the test.
6812 else
6813 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6814 for as_dir in $PATH
6815 do
6816   IFS=$as_save_IFS
6817   test -z "$as_dir" && as_dir=.
6818   for ac_exec_ext in '' $ac_executable_extensions; do
6819   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6820     ac_cv_prog_AR="${ncn_progname}"
6821     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6822     break 2
6823   fi
6824 done
6825 done
6826
6827 fi
6828 fi
6829 AR=$ac_cv_prog_AR
6830 if test -n "$AR"; then
6831   echo "$as_me:$LINENO: result: $AR" >&5
6832 echo "${ECHO_T}$AR" >&6
6833 else
6834   echo "$as_me:$LINENO: result: no" >&5
6835 echo "${ECHO_T}no" >&6
6836 fi
6837
6838   done
6839 fi
6840
6841 for ncn_progname in ar; do
6842   if test -n "$ncn_tool_prefix"; then
6843     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6844 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6845 echo "$as_me:$LINENO: checking for $ac_word" >&5
6846 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6847 if test "${ac_cv_prog_AR+set}" = set; then
6848   echo $ECHO_N "(cached) $ECHO_C" >&6
6849 else
6850   if test -n "$AR"; then
6851   ac_cv_prog_AR="$AR" # Let the user override the test.
6852 else
6853 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6854 for as_dir in $PATH
6855 do
6856   IFS=$as_save_IFS
6857   test -z "$as_dir" && as_dir=.
6858   for ac_exec_ext in '' $ac_executable_extensions; do
6859   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6860     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6861     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6862     break 2
6863   fi
6864 done
6865 done
6866
6867 fi
6868 fi
6869 AR=$ac_cv_prog_AR
6870 if test -n "$AR"; then
6871   echo "$as_me:$LINENO: result: $AR" >&5
6872 echo "${ECHO_T}$AR" >&6
6873 else
6874   echo "$as_me:$LINENO: result: no" >&5
6875 echo "${ECHO_T}no" >&6
6876 fi
6877
6878   fi
6879   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6880     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6881 set dummy ${ncn_progname}; ac_word=$2
6882 echo "$as_me:$LINENO: checking for $ac_word" >&5
6883 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6884 if test "${ac_cv_prog_AR+set}" = set; then
6885   echo $ECHO_N "(cached) $ECHO_C" >&6
6886 else
6887   if test -n "$AR"; then
6888   ac_cv_prog_AR="$AR" # Let the user override the test.
6889 else
6890 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6891 for as_dir in $PATH
6892 do
6893   IFS=$as_save_IFS
6894   test -z "$as_dir" && as_dir=.
6895   for ac_exec_ext in '' $ac_executable_extensions; do
6896   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6897     ac_cv_prog_AR="${ncn_progname}"
6898     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6899     break 2
6900   fi
6901 done
6902 done
6903
6904 fi
6905 fi
6906 AR=$ac_cv_prog_AR
6907 if test -n "$AR"; then
6908   echo "$as_me:$LINENO: result: $AR" >&5
6909 echo "${ECHO_T}$AR" >&6
6910 else
6911   echo "$as_me:$LINENO: result: no" >&5
6912 echo "${ECHO_T}no" >&6
6913 fi
6914
6915   fi
6916   test -n "$ac_cv_prog_AR" && break
6917 done
6918
6919 if test -z "$ac_cv_prog_AR" ; then
6920   set dummy ar
6921   if test $build = $host ; then
6922     AR="$2"
6923   else
6924     AR="${ncn_tool_prefix}$2"
6925   fi
6926 fi
6927
6928
6929
6930 if test -n "$AS"; then
6931   ac_cv_prog_AS=$AS
6932 elif test -n "$ac_cv_prog_AS"; then
6933   AS=$ac_cv_prog_AS
6934 fi
6935
6936 if test -n "$ac_cv_prog_AS"; then
6937   for ncn_progname in as; do
6938     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6939 set dummy ${ncn_progname}; ac_word=$2
6940 echo "$as_me:$LINENO: checking for $ac_word" >&5
6941 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6942 if test "${ac_cv_prog_AS+set}" = set; then
6943   echo $ECHO_N "(cached) $ECHO_C" >&6
6944 else
6945   if test -n "$AS"; then
6946   ac_cv_prog_AS="$AS" # Let the user override the test.
6947 else
6948 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6949 for as_dir in $PATH
6950 do
6951   IFS=$as_save_IFS
6952   test -z "$as_dir" && as_dir=.
6953   for ac_exec_ext in '' $ac_executable_extensions; do
6954   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6955     ac_cv_prog_AS="${ncn_progname}"
6956     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6957     break 2
6958   fi
6959 done
6960 done
6961
6962 fi
6963 fi
6964 AS=$ac_cv_prog_AS
6965 if test -n "$AS"; then
6966   echo "$as_me:$LINENO: result: $AS" >&5
6967 echo "${ECHO_T}$AS" >&6
6968 else
6969   echo "$as_me:$LINENO: result: no" >&5
6970 echo "${ECHO_T}no" >&6
6971 fi
6972
6973   done
6974 fi
6975
6976 for ncn_progname in as; do
6977   if test -n "$ncn_tool_prefix"; then
6978     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6979 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6980 echo "$as_me:$LINENO: checking for $ac_word" >&5
6981 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6982 if test "${ac_cv_prog_AS+set}" = set; then
6983   echo $ECHO_N "(cached) $ECHO_C" >&6
6984 else
6985   if test -n "$AS"; then
6986   ac_cv_prog_AS="$AS" # Let the user override the test.
6987 else
6988 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6989 for as_dir in $PATH
6990 do
6991   IFS=$as_save_IFS
6992   test -z "$as_dir" && as_dir=.
6993   for ac_exec_ext in '' $ac_executable_extensions; do
6994   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6995     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6996     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6997     break 2
6998   fi
6999 done
7000 done
7001
7002 fi
7003 fi
7004 AS=$ac_cv_prog_AS
7005 if test -n "$AS"; then
7006   echo "$as_me:$LINENO: result: $AS" >&5
7007 echo "${ECHO_T}$AS" >&6
7008 else
7009   echo "$as_me:$LINENO: result: no" >&5
7010 echo "${ECHO_T}no" >&6
7011 fi
7012
7013   fi
7014   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
7015     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7016 set dummy ${ncn_progname}; ac_word=$2
7017 echo "$as_me:$LINENO: checking for $ac_word" >&5
7018 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7019 if test "${ac_cv_prog_AS+set}" = set; then
7020   echo $ECHO_N "(cached) $ECHO_C" >&6
7021 else
7022   if test -n "$AS"; then
7023   ac_cv_prog_AS="$AS" # Let the user override the test.
7024 else
7025 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7026 for as_dir in $PATH
7027 do
7028   IFS=$as_save_IFS
7029   test -z "$as_dir" && as_dir=.
7030   for ac_exec_ext in '' $ac_executable_extensions; do
7031   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7032     ac_cv_prog_AS="${ncn_progname}"
7033     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7034     break 2
7035   fi
7036 done
7037 done
7038
7039 fi
7040 fi
7041 AS=$ac_cv_prog_AS
7042 if test -n "$AS"; then
7043   echo "$as_me:$LINENO: result: $AS" >&5
7044 echo "${ECHO_T}$AS" >&6
7045 else
7046   echo "$as_me:$LINENO: result: no" >&5
7047 echo "${ECHO_T}no" >&6
7048 fi
7049
7050   fi
7051   test -n "$ac_cv_prog_AS" && break
7052 done
7053
7054 if test -z "$ac_cv_prog_AS" ; then
7055   set dummy as
7056   if test $build = $host ; then
7057     AS="$2"
7058   else
7059     AS="${ncn_tool_prefix}$2"
7060   fi
7061 fi
7062
7063
7064
7065 if test -n "$DLLTOOL"; then
7066   ac_cv_prog_DLLTOOL=$DLLTOOL
7067 elif test -n "$ac_cv_prog_DLLTOOL"; then
7068   DLLTOOL=$ac_cv_prog_DLLTOOL
7069 fi
7070
7071 if test -n "$ac_cv_prog_DLLTOOL"; then
7072   for ncn_progname in dlltool; do
7073     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7074 set dummy ${ncn_progname}; ac_word=$2
7075 echo "$as_me:$LINENO: checking for $ac_word" >&5
7076 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7077 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7078   echo $ECHO_N "(cached) $ECHO_C" >&6
7079 else
7080   if test -n "$DLLTOOL"; then
7081   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7082 else
7083 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7084 for as_dir in $PATH
7085 do
7086   IFS=$as_save_IFS
7087   test -z "$as_dir" && as_dir=.
7088   for ac_exec_ext in '' $ac_executable_extensions; do
7089   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7090     ac_cv_prog_DLLTOOL="${ncn_progname}"
7091     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7092     break 2
7093   fi
7094 done
7095 done
7096
7097 fi
7098 fi
7099 DLLTOOL=$ac_cv_prog_DLLTOOL
7100 if test -n "$DLLTOOL"; then
7101   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7102 echo "${ECHO_T}$DLLTOOL" >&6
7103 else
7104   echo "$as_me:$LINENO: result: no" >&5
7105 echo "${ECHO_T}no" >&6
7106 fi
7107
7108   done
7109 fi
7110
7111 for ncn_progname in dlltool; do
7112   if test -n "$ncn_tool_prefix"; then
7113     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7114 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7115 echo "$as_me:$LINENO: checking for $ac_word" >&5
7116 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7117 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7118   echo $ECHO_N "(cached) $ECHO_C" >&6
7119 else
7120   if test -n "$DLLTOOL"; then
7121   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7122 else
7123 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7124 for as_dir in $PATH
7125 do
7126   IFS=$as_save_IFS
7127   test -z "$as_dir" && as_dir=.
7128   for ac_exec_ext in '' $ac_executable_extensions; do
7129   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7130     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7131     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7132     break 2
7133   fi
7134 done
7135 done
7136
7137 fi
7138 fi
7139 DLLTOOL=$ac_cv_prog_DLLTOOL
7140 if test -n "$DLLTOOL"; then
7141   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7142 echo "${ECHO_T}$DLLTOOL" >&6
7143 else
7144   echo "$as_me:$LINENO: result: no" >&5
7145 echo "${ECHO_T}no" >&6
7146 fi
7147
7148   fi
7149   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7150     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7151 set dummy ${ncn_progname}; ac_word=$2
7152 echo "$as_me:$LINENO: checking for $ac_word" >&5
7153 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7154 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7155   echo $ECHO_N "(cached) $ECHO_C" >&6
7156 else
7157   if test -n "$DLLTOOL"; then
7158   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7159 else
7160 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7161 for as_dir in $PATH
7162 do
7163   IFS=$as_save_IFS
7164   test -z "$as_dir" && as_dir=.
7165   for ac_exec_ext in '' $ac_executable_extensions; do
7166   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7167     ac_cv_prog_DLLTOOL="${ncn_progname}"
7168     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7169     break 2
7170   fi
7171 done
7172 done
7173
7174 fi
7175 fi
7176 DLLTOOL=$ac_cv_prog_DLLTOOL
7177 if test -n "$DLLTOOL"; then
7178   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7179 echo "${ECHO_T}$DLLTOOL" >&6
7180 else
7181   echo "$as_me:$LINENO: result: no" >&5
7182 echo "${ECHO_T}no" >&6
7183 fi
7184
7185   fi
7186   test -n "$ac_cv_prog_DLLTOOL" && break
7187 done
7188
7189 if test -z "$ac_cv_prog_DLLTOOL" ; then
7190   set dummy dlltool
7191   if test $build = $host ; then
7192     DLLTOOL="$2"
7193   else
7194     DLLTOOL="${ncn_tool_prefix}$2"
7195   fi
7196 fi
7197
7198
7199
7200 if test -n "$LD"; then
7201   ac_cv_prog_LD=$LD
7202 elif test -n "$ac_cv_prog_LD"; then
7203   LD=$ac_cv_prog_LD
7204 fi
7205
7206 if test -n "$ac_cv_prog_LD"; then
7207   for ncn_progname in ld; do
7208     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7209 set dummy ${ncn_progname}; ac_word=$2
7210 echo "$as_me:$LINENO: checking for $ac_word" >&5
7211 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7212 if test "${ac_cv_prog_LD+set}" = set; then
7213   echo $ECHO_N "(cached) $ECHO_C" >&6
7214 else
7215   if test -n "$LD"; then
7216   ac_cv_prog_LD="$LD" # Let the user override the test.
7217 else
7218 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7219 for as_dir in $PATH
7220 do
7221   IFS=$as_save_IFS
7222   test -z "$as_dir" && as_dir=.
7223   for ac_exec_ext in '' $ac_executable_extensions; do
7224   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7225     ac_cv_prog_LD="${ncn_progname}"
7226     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7227     break 2
7228   fi
7229 done
7230 done
7231
7232 fi
7233 fi
7234 LD=$ac_cv_prog_LD
7235 if test -n "$LD"; then
7236   echo "$as_me:$LINENO: result: $LD" >&5
7237 echo "${ECHO_T}$LD" >&6
7238 else
7239   echo "$as_me:$LINENO: result: no" >&5
7240 echo "${ECHO_T}no" >&6
7241 fi
7242
7243   done
7244 fi
7245
7246 for ncn_progname in ld; do
7247   if test -n "$ncn_tool_prefix"; then
7248     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7249 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7250 echo "$as_me:$LINENO: checking for $ac_word" >&5
7251 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7252 if test "${ac_cv_prog_LD+set}" = set; then
7253   echo $ECHO_N "(cached) $ECHO_C" >&6
7254 else
7255   if test -n "$LD"; then
7256   ac_cv_prog_LD="$LD" # Let the user override the test.
7257 else
7258 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7259 for as_dir in $PATH
7260 do
7261   IFS=$as_save_IFS
7262   test -z "$as_dir" && as_dir=.
7263   for ac_exec_ext in '' $ac_executable_extensions; do
7264   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7265     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7266     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7267     break 2
7268   fi
7269 done
7270 done
7271
7272 fi
7273 fi
7274 LD=$ac_cv_prog_LD
7275 if test -n "$LD"; then
7276   echo "$as_me:$LINENO: result: $LD" >&5
7277 echo "${ECHO_T}$LD" >&6
7278 else
7279   echo "$as_me:$LINENO: result: no" >&5
7280 echo "${ECHO_T}no" >&6
7281 fi
7282
7283   fi
7284   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7285     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7286 set dummy ${ncn_progname}; ac_word=$2
7287 echo "$as_me:$LINENO: checking for $ac_word" >&5
7288 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7289 if test "${ac_cv_prog_LD+set}" = set; then
7290   echo $ECHO_N "(cached) $ECHO_C" >&6
7291 else
7292   if test -n "$LD"; then
7293   ac_cv_prog_LD="$LD" # Let the user override the test.
7294 else
7295 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7296 for as_dir in $PATH
7297 do
7298   IFS=$as_save_IFS
7299   test -z "$as_dir" && as_dir=.
7300   for ac_exec_ext in '' $ac_executable_extensions; do
7301   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7302     ac_cv_prog_LD="${ncn_progname}"
7303     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7304     break 2
7305   fi
7306 done
7307 done
7308
7309 fi
7310 fi
7311 LD=$ac_cv_prog_LD
7312 if test -n "$LD"; then
7313   echo "$as_me:$LINENO: result: $LD" >&5
7314 echo "${ECHO_T}$LD" >&6
7315 else
7316   echo "$as_me:$LINENO: result: no" >&5
7317 echo "${ECHO_T}no" >&6
7318 fi
7319
7320   fi
7321   test -n "$ac_cv_prog_LD" && break
7322 done
7323
7324 if test -z "$ac_cv_prog_LD" ; then
7325   set dummy ld
7326   if test $build = $host ; then
7327     LD="$2"
7328   else
7329     LD="${ncn_tool_prefix}$2"
7330   fi
7331 fi
7332
7333
7334
7335 if test -n "$LIPO"; then
7336   ac_cv_prog_LIPO=$LIPO
7337 elif test -n "$ac_cv_prog_LIPO"; then
7338   LIPO=$ac_cv_prog_LIPO
7339 fi
7340
7341 if test -n "$ac_cv_prog_LIPO"; then
7342   for ncn_progname in lipo; do
7343     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7344 set dummy ${ncn_progname}; ac_word=$2
7345 echo "$as_me:$LINENO: checking for $ac_word" >&5
7346 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7347 if test "${ac_cv_prog_LIPO+set}" = set; then
7348   echo $ECHO_N "(cached) $ECHO_C" >&6
7349 else
7350   if test -n "$LIPO"; then
7351   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7352 else
7353 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7354 for as_dir in $PATH
7355 do
7356   IFS=$as_save_IFS
7357   test -z "$as_dir" && as_dir=.
7358   for ac_exec_ext in '' $ac_executable_extensions; do
7359   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7360     ac_cv_prog_LIPO="${ncn_progname}"
7361     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7362     break 2
7363   fi
7364 done
7365 done
7366
7367 fi
7368 fi
7369 LIPO=$ac_cv_prog_LIPO
7370 if test -n "$LIPO"; then
7371   echo "$as_me:$LINENO: result: $LIPO" >&5
7372 echo "${ECHO_T}$LIPO" >&6
7373 else
7374   echo "$as_me:$LINENO: result: no" >&5
7375 echo "${ECHO_T}no" >&6
7376 fi
7377
7378   done
7379 fi
7380
7381 for ncn_progname in lipo; do
7382   if test -n "$ncn_tool_prefix"; then
7383     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7384 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7385 echo "$as_me:$LINENO: checking for $ac_word" >&5
7386 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7387 if test "${ac_cv_prog_LIPO+set}" = set; then
7388   echo $ECHO_N "(cached) $ECHO_C" >&6
7389 else
7390   if test -n "$LIPO"; then
7391   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7392 else
7393 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7394 for as_dir in $PATH
7395 do
7396   IFS=$as_save_IFS
7397   test -z "$as_dir" && as_dir=.
7398   for ac_exec_ext in '' $ac_executable_extensions; do
7399   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7400     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7401     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7402     break 2
7403   fi
7404 done
7405 done
7406
7407 fi
7408 fi
7409 LIPO=$ac_cv_prog_LIPO
7410 if test -n "$LIPO"; then
7411   echo "$as_me:$LINENO: result: $LIPO" >&5
7412 echo "${ECHO_T}$LIPO" >&6
7413 else
7414   echo "$as_me:$LINENO: result: no" >&5
7415 echo "${ECHO_T}no" >&6
7416 fi
7417
7418   fi
7419   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7420     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7421 set dummy ${ncn_progname}; ac_word=$2
7422 echo "$as_me:$LINENO: checking for $ac_word" >&5
7423 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7424 if test "${ac_cv_prog_LIPO+set}" = set; then
7425   echo $ECHO_N "(cached) $ECHO_C" >&6
7426 else
7427   if test -n "$LIPO"; then
7428   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7429 else
7430 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7431 for as_dir in $PATH
7432 do
7433   IFS=$as_save_IFS
7434   test -z "$as_dir" && as_dir=.
7435   for ac_exec_ext in '' $ac_executable_extensions; do
7436   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7437     ac_cv_prog_LIPO="${ncn_progname}"
7438     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7439     break 2
7440   fi
7441 done
7442 done
7443
7444 fi
7445 fi
7446 LIPO=$ac_cv_prog_LIPO
7447 if test -n "$LIPO"; then
7448   echo "$as_me:$LINENO: result: $LIPO" >&5
7449 echo "${ECHO_T}$LIPO" >&6
7450 else
7451   echo "$as_me:$LINENO: result: no" >&5
7452 echo "${ECHO_T}no" >&6
7453 fi
7454
7455   fi
7456   test -n "$ac_cv_prog_LIPO" && break
7457 done
7458
7459 if test -z "$ac_cv_prog_LIPO" ; then
7460   set dummy lipo
7461   if test $build = $host ; then
7462     LIPO="$2"
7463   else
7464     LIPO="${ncn_tool_prefix}$2"
7465   fi
7466 fi
7467
7468
7469
7470 if test -n "$NM"; then
7471   ac_cv_prog_NM=$NM
7472 elif test -n "$ac_cv_prog_NM"; then
7473   NM=$ac_cv_prog_NM
7474 fi
7475
7476 if test -n "$ac_cv_prog_NM"; then
7477   for ncn_progname in nm; do
7478     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7479 set dummy ${ncn_progname}; ac_word=$2
7480 echo "$as_me:$LINENO: checking for $ac_word" >&5
7481 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7482 if test "${ac_cv_prog_NM+set}" = set; then
7483   echo $ECHO_N "(cached) $ECHO_C" >&6
7484 else
7485   if test -n "$NM"; then
7486   ac_cv_prog_NM="$NM" # Let the user override the test.
7487 else
7488 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7489 for as_dir in $PATH
7490 do
7491   IFS=$as_save_IFS
7492   test -z "$as_dir" && as_dir=.
7493   for ac_exec_ext in '' $ac_executable_extensions; do
7494   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7495     ac_cv_prog_NM="${ncn_progname}"
7496     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7497     break 2
7498   fi
7499 done
7500 done
7501
7502 fi
7503 fi
7504 NM=$ac_cv_prog_NM
7505 if test -n "$NM"; then
7506   echo "$as_me:$LINENO: result: $NM" >&5
7507 echo "${ECHO_T}$NM" >&6
7508 else
7509   echo "$as_me:$LINENO: result: no" >&5
7510 echo "${ECHO_T}no" >&6
7511 fi
7512
7513   done
7514 fi
7515
7516 for ncn_progname in nm; do
7517   if test -n "$ncn_tool_prefix"; then
7518     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7519 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7520 echo "$as_me:$LINENO: checking for $ac_word" >&5
7521 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7522 if test "${ac_cv_prog_NM+set}" = set; then
7523   echo $ECHO_N "(cached) $ECHO_C" >&6
7524 else
7525   if test -n "$NM"; then
7526   ac_cv_prog_NM="$NM" # Let the user override the test.
7527 else
7528 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7529 for as_dir in $PATH
7530 do
7531   IFS=$as_save_IFS
7532   test -z "$as_dir" && as_dir=.
7533   for ac_exec_ext in '' $ac_executable_extensions; do
7534   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7535     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7536     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7537     break 2
7538   fi
7539 done
7540 done
7541
7542 fi
7543 fi
7544 NM=$ac_cv_prog_NM
7545 if test -n "$NM"; then
7546   echo "$as_me:$LINENO: result: $NM" >&5
7547 echo "${ECHO_T}$NM" >&6
7548 else
7549   echo "$as_me:$LINENO: result: no" >&5
7550 echo "${ECHO_T}no" >&6
7551 fi
7552
7553   fi
7554   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7555     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7556 set dummy ${ncn_progname}; ac_word=$2
7557 echo "$as_me:$LINENO: checking for $ac_word" >&5
7558 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7559 if test "${ac_cv_prog_NM+set}" = set; then
7560   echo $ECHO_N "(cached) $ECHO_C" >&6
7561 else
7562   if test -n "$NM"; then
7563   ac_cv_prog_NM="$NM" # Let the user override the test.
7564 else
7565 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7566 for as_dir in $PATH
7567 do
7568   IFS=$as_save_IFS
7569   test -z "$as_dir" && as_dir=.
7570   for ac_exec_ext in '' $ac_executable_extensions; do
7571   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7572     ac_cv_prog_NM="${ncn_progname}"
7573     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7574     break 2
7575   fi
7576 done
7577 done
7578
7579 fi
7580 fi
7581 NM=$ac_cv_prog_NM
7582 if test -n "$NM"; then
7583   echo "$as_me:$LINENO: result: $NM" >&5
7584 echo "${ECHO_T}$NM" >&6
7585 else
7586   echo "$as_me:$LINENO: result: no" >&5
7587 echo "${ECHO_T}no" >&6
7588 fi
7589
7590   fi
7591   test -n "$ac_cv_prog_NM" && break
7592 done
7593
7594 if test -z "$ac_cv_prog_NM" ; then
7595   set dummy nm
7596   if test $build = $host ; then
7597     NM="$2"
7598   else
7599     NM="${ncn_tool_prefix}$2"
7600   fi
7601 fi
7602
7603
7604
7605 if test -n "$RANLIB"; then
7606   ac_cv_prog_RANLIB=$RANLIB
7607 elif test -n "$ac_cv_prog_RANLIB"; then
7608   RANLIB=$ac_cv_prog_RANLIB
7609 fi
7610
7611 if test -n "$ac_cv_prog_RANLIB"; then
7612   for ncn_progname in ranlib; do
7613     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7614 set dummy ${ncn_progname}; ac_word=$2
7615 echo "$as_me:$LINENO: checking for $ac_word" >&5
7616 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7617 if test "${ac_cv_prog_RANLIB+set}" = set; then
7618   echo $ECHO_N "(cached) $ECHO_C" >&6
7619 else
7620   if test -n "$RANLIB"; then
7621   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7622 else
7623 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7624 for as_dir in $PATH
7625 do
7626   IFS=$as_save_IFS
7627   test -z "$as_dir" && as_dir=.
7628   for ac_exec_ext in '' $ac_executable_extensions; do
7629   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7630     ac_cv_prog_RANLIB="${ncn_progname}"
7631     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7632     break 2
7633   fi
7634 done
7635 done
7636
7637 fi
7638 fi
7639 RANLIB=$ac_cv_prog_RANLIB
7640 if test -n "$RANLIB"; then
7641   echo "$as_me:$LINENO: result: $RANLIB" >&5
7642 echo "${ECHO_T}$RANLIB" >&6
7643 else
7644   echo "$as_me:$LINENO: result: no" >&5
7645 echo "${ECHO_T}no" >&6
7646 fi
7647
7648   done
7649 fi
7650
7651 for ncn_progname in ranlib; do
7652   if test -n "$ncn_tool_prefix"; then
7653     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7654 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7655 echo "$as_me:$LINENO: checking for $ac_word" >&5
7656 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7657 if test "${ac_cv_prog_RANLIB+set}" = set; then
7658   echo $ECHO_N "(cached) $ECHO_C" >&6
7659 else
7660   if test -n "$RANLIB"; then
7661   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7662 else
7663 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7664 for as_dir in $PATH
7665 do
7666   IFS=$as_save_IFS
7667   test -z "$as_dir" && as_dir=.
7668   for ac_exec_ext in '' $ac_executable_extensions; do
7669   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7670     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7671     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7672     break 2
7673   fi
7674 done
7675 done
7676
7677 fi
7678 fi
7679 RANLIB=$ac_cv_prog_RANLIB
7680 if test -n "$RANLIB"; then
7681   echo "$as_me:$LINENO: result: $RANLIB" >&5
7682 echo "${ECHO_T}$RANLIB" >&6
7683 else
7684   echo "$as_me:$LINENO: result: no" >&5
7685 echo "${ECHO_T}no" >&6
7686 fi
7687
7688   fi
7689   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7690     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7691 set dummy ${ncn_progname}; ac_word=$2
7692 echo "$as_me:$LINENO: checking for $ac_word" >&5
7693 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7694 if test "${ac_cv_prog_RANLIB+set}" = set; then
7695   echo $ECHO_N "(cached) $ECHO_C" >&6
7696 else
7697   if test -n "$RANLIB"; then
7698   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7699 else
7700 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7701 for as_dir in $PATH
7702 do
7703   IFS=$as_save_IFS
7704   test -z "$as_dir" && as_dir=.
7705   for ac_exec_ext in '' $ac_executable_extensions; do
7706   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7707     ac_cv_prog_RANLIB="${ncn_progname}"
7708     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7709     break 2
7710   fi
7711 done
7712 done
7713
7714 fi
7715 fi
7716 RANLIB=$ac_cv_prog_RANLIB
7717 if test -n "$RANLIB"; then
7718   echo "$as_me:$LINENO: result: $RANLIB" >&5
7719 echo "${ECHO_T}$RANLIB" >&6
7720 else
7721   echo "$as_me:$LINENO: result: no" >&5
7722 echo "${ECHO_T}no" >&6
7723 fi
7724
7725   fi
7726   test -n "$ac_cv_prog_RANLIB" && break
7727 done
7728
7729 if test -z "$ac_cv_prog_RANLIB" ; then
7730   RANLIB=":"
7731 fi
7732
7733
7734
7735 if test -n "$STRIP"; then
7736   ac_cv_prog_STRIP=$STRIP
7737 elif test -n "$ac_cv_prog_STRIP"; then
7738   STRIP=$ac_cv_prog_STRIP
7739 fi
7740
7741 if test -n "$ac_cv_prog_STRIP"; then
7742   for ncn_progname in strip; do
7743     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7744 set dummy ${ncn_progname}; ac_word=$2
7745 echo "$as_me:$LINENO: checking for $ac_word" >&5
7746 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7747 if test "${ac_cv_prog_STRIP+set}" = set; then
7748   echo $ECHO_N "(cached) $ECHO_C" >&6
7749 else
7750   if test -n "$STRIP"; then
7751   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7752 else
7753 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7754 for as_dir in $PATH
7755 do
7756   IFS=$as_save_IFS
7757   test -z "$as_dir" && as_dir=.
7758   for ac_exec_ext in '' $ac_executable_extensions; do
7759   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7760     ac_cv_prog_STRIP="${ncn_progname}"
7761     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7762     break 2
7763   fi
7764 done
7765 done
7766
7767 fi
7768 fi
7769 STRIP=$ac_cv_prog_STRIP
7770 if test -n "$STRIP"; then
7771   echo "$as_me:$LINENO: result: $STRIP" >&5
7772 echo "${ECHO_T}$STRIP" >&6
7773 else
7774   echo "$as_me:$LINENO: result: no" >&5
7775 echo "${ECHO_T}no" >&6
7776 fi
7777
7778   done
7779 fi
7780
7781 for ncn_progname in strip; do
7782   if test -n "$ncn_tool_prefix"; then
7783     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7784 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7785 echo "$as_me:$LINENO: checking for $ac_word" >&5
7786 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7787 if test "${ac_cv_prog_STRIP+set}" = set; then
7788   echo $ECHO_N "(cached) $ECHO_C" >&6
7789 else
7790   if test -n "$STRIP"; then
7791   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7792 else
7793 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7794 for as_dir in $PATH
7795 do
7796   IFS=$as_save_IFS
7797   test -z "$as_dir" && as_dir=.
7798   for ac_exec_ext in '' $ac_executable_extensions; do
7799   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7800     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7801     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7802     break 2
7803   fi
7804 done
7805 done
7806
7807 fi
7808 fi
7809 STRIP=$ac_cv_prog_STRIP
7810 if test -n "$STRIP"; then
7811   echo "$as_me:$LINENO: result: $STRIP" >&5
7812 echo "${ECHO_T}$STRIP" >&6
7813 else
7814   echo "$as_me:$LINENO: result: no" >&5
7815 echo "${ECHO_T}no" >&6
7816 fi
7817
7818   fi
7819   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7820     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7821 set dummy ${ncn_progname}; ac_word=$2
7822 echo "$as_me:$LINENO: checking for $ac_word" >&5
7823 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7824 if test "${ac_cv_prog_STRIP+set}" = set; then
7825   echo $ECHO_N "(cached) $ECHO_C" >&6
7826 else
7827   if test -n "$STRIP"; then
7828   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7829 else
7830 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7831 for as_dir in $PATH
7832 do
7833   IFS=$as_save_IFS
7834   test -z "$as_dir" && as_dir=.
7835   for ac_exec_ext in '' $ac_executable_extensions; do
7836   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7837     ac_cv_prog_STRIP="${ncn_progname}"
7838     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7839     break 2
7840   fi
7841 done
7842 done
7843
7844 fi
7845 fi
7846 STRIP=$ac_cv_prog_STRIP
7847 if test -n "$STRIP"; then
7848   echo "$as_me:$LINENO: result: $STRIP" >&5
7849 echo "${ECHO_T}$STRIP" >&6
7850 else
7851   echo "$as_me:$LINENO: result: no" >&5
7852 echo "${ECHO_T}no" >&6
7853 fi
7854
7855   fi
7856   test -n "$ac_cv_prog_STRIP" && break
7857 done
7858
7859 if test -z "$ac_cv_prog_STRIP" ; then
7860   STRIP=":"
7861 fi
7862
7863
7864
7865 if test -n "$WINDRES"; then
7866   ac_cv_prog_WINDRES=$WINDRES
7867 elif test -n "$ac_cv_prog_WINDRES"; then
7868   WINDRES=$ac_cv_prog_WINDRES
7869 fi
7870
7871 if test -n "$ac_cv_prog_WINDRES"; then
7872   for ncn_progname in windres; do
7873     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7874 set dummy ${ncn_progname}; ac_word=$2
7875 echo "$as_me:$LINENO: checking for $ac_word" >&5
7876 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7877 if test "${ac_cv_prog_WINDRES+set}" = set; then
7878   echo $ECHO_N "(cached) $ECHO_C" >&6
7879 else
7880   if test -n "$WINDRES"; then
7881   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7882 else
7883 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7884 for as_dir in $PATH
7885 do
7886   IFS=$as_save_IFS
7887   test -z "$as_dir" && as_dir=.
7888   for ac_exec_ext in '' $ac_executable_extensions; do
7889   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7890     ac_cv_prog_WINDRES="${ncn_progname}"
7891     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7892     break 2
7893   fi
7894 done
7895 done
7896
7897 fi
7898 fi
7899 WINDRES=$ac_cv_prog_WINDRES
7900 if test -n "$WINDRES"; then
7901   echo "$as_me:$LINENO: result: $WINDRES" >&5
7902 echo "${ECHO_T}$WINDRES" >&6
7903 else
7904   echo "$as_me:$LINENO: result: no" >&5
7905 echo "${ECHO_T}no" >&6
7906 fi
7907
7908   done
7909 fi
7910
7911 for ncn_progname in windres; do
7912   if test -n "$ncn_tool_prefix"; then
7913     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7914 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7915 echo "$as_me:$LINENO: checking for $ac_word" >&5
7916 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7917 if test "${ac_cv_prog_WINDRES+set}" = set; then
7918   echo $ECHO_N "(cached) $ECHO_C" >&6
7919 else
7920   if test -n "$WINDRES"; then
7921   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7922 else
7923 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7924 for as_dir in $PATH
7925 do
7926   IFS=$as_save_IFS
7927   test -z "$as_dir" && as_dir=.
7928   for ac_exec_ext in '' $ac_executable_extensions; do
7929   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7930     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7931     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7932     break 2
7933   fi
7934 done
7935 done
7936
7937 fi
7938 fi
7939 WINDRES=$ac_cv_prog_WINDRES
7940 if test -n "$WINDRES"; then
7941   echo "$as_me:$LINENO: result: $WINDRES" >&5
7942 echo "${ECHO_T}$WINDRES" >&6
7943 else
7944   echo "$as_me:$LINENO: result: no" >&5
7945 echo "${ECHO_T}no" >&6
7946 fi
7947
7948   fi
7949   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7950     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7951 set dummy ${ncn_progname}; ac_word=$2
7952 echo "$as_me:$LINENO: checking for $ac_word" >&5
7953 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7954 if test "${ac_cv_prog_WINDRES+set}" = set; then
7955   echo $ECHO_N "(cached) $ECHO_C" >&6
7956 else
7957   if test -n "$WINDRES"; then
7958   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7959 else
7960 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7961 for as_dir in $PATH
7962 do
7963   IFS=$as_save_IFS
7964   test -z "$as_dir" && as_dir=.
7965   for ac_exec_ext in '' $ac_executable_extensions; do
7966   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7967     ac_cv_prog_WINDRES="${ncn_progname}"
7968     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7969     break 2
7970   fi
7971 done
7972 done
7973
7974 fi
7975 fi
7976 WINDRES=$ac_cv_prog_WINDRES
7977 if test -n "$WINDRES"; then
7978   echo "$as_me:$LINENO: result: $WINDRES" >&5
7979 echo "${ECHO_T}$WINDRES" >&6
7980 else
7981   echo "$as_me:$LINENO: result: no" >&5
7982 echo "${ECHO_T}no" >&6
7983 fi
7984
7985   fi
7986   test -n "$ac_cv_prog_WINDRES" && break
7987 done
7988
7989 if test -z "$ac_cv_prog_WINDRES" ; then
7990   set dummy windres
7991   if test $build = $host ; then
7992     WINDRES="$2"
7993   else
7994     WINDRES="${ncn_tool_prefix}$2"
7995   fi
7996 fi
7997
7998
7999
8000 if test -n "$WINDMC"; then
8001   ac_cv_prog_WINDMC=$WINDMC
8002 elif test -n "$ac_cv_prog_WINDMC"; then
8003   WINDMC=$ac_cv_prog_WINDMC
8004 fi
8005
8006 if test -n "$ac_cv_prog_WINDMC"; then
8007   for ncn_progname in windmc; do
8008     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8009 set dummy ${ncn_progname}; ac_word=$2
8010 echo "$as_me:$LINENO: checking for $ac_word" >&5
8011 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8012 if test "${ac_cv_prog_WINDMC+set}" = set; then
8013   echo $ECHO_N "(cached) $ECHO_C" >&6
8014 else
8015   if test -n "$WINDMC"; then
8016   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8017 else
8018 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8019 for as_dir in $PATH
8020 do
8021   IFS=$as_save_IFS
8022   test -z "$as_dir" && as_dir=.
8023   for ac_exec_ext in '' $ac_executable_extensions; do
8024   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8025     ac_cv_prog_WINDMC="${ncn_progname}"
8026     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8027     break 2
8028   fi
8029 done
8030 done
8031
8032 fi
8033 fi
8034 WINDMC=$ac_cv_prog_WINDMC
8035 if test -n "$WINDMC"; then
8036   echo "$as_me:$LINENO: result: $WINDMC" >&5
8037 echo "${ECHO_T}$WINDMC" >&6
8038 else
8039   echo "$as_me:$LINENO: result: no" >&5
8040 echo "${ECHO_T}no" >&6
8041 fi
8042
8043   done
8044 fi
8045
8046 for ncn_progname in windmc; do
8047   if test -n "$ncn_tool_prefix"; then
8048     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8049 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8050 echo "$as_me:$LINENO: checking for $ac_word" >&5
8051 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8052 if test "${ac_cv_prog_WINDMC+set}" = set; then
8053   echo $ECHO_N "(cached) $ECHO_C" >&6
8054 else
8055   if test -n "$WINDMC"; then
8056   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8057 else
8058 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8059 for as_dir in $PATH
8060 do
8061   IFS=$as_save_IFS
8062   test -z "$as_dir" && as_dir=.
8063   for ac_exec_ext in '' $ac_executable_extensions; do
8064   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8065     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8066     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8067     break 2
8068   fi
8069 done
8070 done
8071
8072 fi
8073 fi
8074 WINDMC=$ac_cv_prog_WINDMC
8075 if test -n "$WINDMC"; then
8076   echo "$as_me:$LINENO: result: $WINDMC" >&5
8077 echo "${ECHO_T}$WINDMC" >&6
8078 else
8079   echo "$as_me:$LINENO: result: no" >&5
8080 echo "${ECHO_T}no" >&6
8081 fi
8082
8083   fi
8084   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8085     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8086 set dummy ${ncn_progname}; ac_word=$2
8087 echo "$as_me:$LINENO: checking for $ac_word" >&5
8088 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8089 if test "${ac_cv_prog_WINDMC+set}" = set; then
8090   echo $ECHO_N "(cached) $ECHO_C" >&6
8091 else
8092   if test -n "$WINDMC"; then
8093   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8094 else
8095 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8096 for as_dir in $PATH
8097 do
8098   IFS=$as_save_IFS
8099   test -z "$as_dir" && as_dir=.
8100   for ac_exec_ext in '' $ac_executable_extensions; do
8101   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8102     ac_cv_prog_WINDMC="${ncn_progname}"
8103     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8104     break 2
8105   fi
8106 done
8107 done
8108
8109 fi
8110 fi
8111 WINDMC=$ac_cv_prog_WINDMC
8112 if test -n "$WINDMC"; then
8113   echo "$as_me:$LINENO: result: $WINDMC" >&5
8114 echo "${ECHO_T}$WINDMC" >&6
8115 else
8116   echo "$as_me:$LINENO: result: no" >&5
8117 echo "${ECHO_T}no" >&6
8118 fi
8119
8120   fi
8121   test -n "$ac_cv_prog_WINDMC" && break
8122 done
8123
8124 if test -z "$ac_cv_prog_WINDMC" ; then
8125   set dummy windmc
8126   if test $build = $host ; then
8127     WINDMC="$2"
8128   else
8129     WINDMC="${ncn_tool_prefix}$2"
8130   fi
8131 fi
8132
8133
8134
8135 if test -n "$OBJCOPY"; then
8136   ac_cv_prog_OBJCOPY=$OBJCOPY
8137 elif test -n "$ac_cv_prog_OBJCOPY"; then
8138   OBJCOPY=$ac_cv_prog_OBJCOPY
8139 fi
8140
8141 if test -n "$ac_cv_prog_OBJCOPY"; then
8142   for ncn_progname in objcopy; do
8143     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8144 set dummy ${ncn_progname}; ac_word=$2
8145 echo "$as_me:$LINENO: checking for $ac_word" >&5
8146 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8147 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8148   echo $ECHO_N "(cached) $ECHO_C" >&6
8149 else
8150   if test -n "$OBJCOPY"; then
8151   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8152 else
8153 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8154 for as_dir in $PATH
8155 do
8156   IFS=$as_save_IFS
8157   test -z "$as_dir" && as_dir=.
8158   for ac_exec_ext in '' $ac_executable_extensions; do
8159   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8160     ac_cv_prog_OBJCOPY="${ncn_progname}"
8161     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8162     break 2
8163   fi
8164 done
8165 done
8166
8167 fi
8168 fi
8169 OBJCOPY=$ac_cv_prog_OBJCOPY
8170 if test -n "$OBJCOPY"; then
8171   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8172 echo "${ECHO_T}$OBJCOPY" >&6
8173 else
8174   echo "$as_me:$LINENO: result: no" >&5
8175 echo "${ECHO_T}no" >&6
8176 fi
8177
8178   done
8179 fi
8180
8181 for ncn_progname in objcopy; do
8182   if test -n "$ncn_tool_prefix"; then
8183     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8184 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8185 echo "$as_me:$LINENO: checking for $ac_word" >&5
8186 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8187 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8188   echo $ECHO_N "(cached) $ECHO_C" >&6
8189 else
8190   if test -n "$OBJCOPY"; then
8191   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8192 else
8193 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8194 for as_dir in $PATH
8195 do
8196   IFS=$as_save_IFS
8197   test -z "$as_dir" && as_dir=.
8198   for ac_exec_ext in '' $ac_executable_extensions; do
8199   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8200     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8201     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8202     break 2
8203   fi
8204 done
8205 done
8206
8207 fi
8208 fi
8209 OBJCOPY=$ac_cv_prog_OBJCOPY
8210 if test -n "$OBJCOPY"; then
8211   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8212 echo "${ECHO_T}$OBJCOPY" >&6
8213 else
8214   echo "$as_me:$LINENO: result: no" >&5
8215 echo "${ECHO_T}no" >&6
8216 fi
8217
8218   fi
8219   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8220     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8221 set dummy ${ncn_progname}; ac_word=$2
8222 echo "$as_me:$LINENO: checking for $ac_word" >&5
8223 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8224 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8225   echo $ECHO_N "(cached) $ECHO_C" >&6
8226 else
8227   if test -n "$OBJCOPY"; then
8228   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8229 else
8230 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8231 for as_dir in $PATH
8232 do
8233   IFS=$as_save_IFS
8234   test -z "$as_dir" && as_dir=.
8235   for ac_exec_ext in '' $ac_executable_extensions; do
8236   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8237     ac_cv_prog_OBJCOPY="${ncn_progname}"
8238     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8239     break 2
8240   fi
8241 done
8242 done
8243
8244 fi
8245 fi
8246 OBJCOPY=$ac_cv_prog_OBJCOPY
8247 if test -n "$OBJCOPY"; then
8248   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8249 echo "${ECHO_T}$OBJCOPY" >&6
8250 else
8251   echo "$as_me:$LINENO: result: no" >&5
8252 echo "${ECHO_T}no" >&6
8253 fi
8254
8255   fi
8256   test -n "$ac_cv_prog_OBJCOPY" && break
8257 done
8258
8259 if test -z "$ac_cv_prog_OBJCOPY" ; then
8260   set dummy objcopy
8261   if test $build = $host ; then
8262     OBJCOPY="$2"
8263   else
8264     OBJCOPY="${ncn_tool_prefix}$2"
8265   fi
8266 fi
8267
8268
8269
8270 if test -n "$OBJDUMP"; then
8271   ac_cv_prog_OBJDUMP=$OBJDUMP
8272 elif test -n "$ac_cv_prog_OBJDUMP"; then
8273   OBJDUMP=$ac_cv_prog_OBJDUMP
8274 fi
8275
8276 if test -n "$ac_cv_prog_OBJDUMP"; then
8277   for ncn_progname in objdump; do
8278     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8279 set dummy ${ncn_progname}; ac_word=$2
8280 echo "$as_me:$LINENO: checking for $ac_word" >&5
8281 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8282 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8283   echo $ECHO_N "(cached) $ECHO_C" >&6
8284 else
8285   if test -n "$OBJDUMP"; then
8286   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8287 else
8288 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8289 for as_dir in $PATH
8290 do
8291   IFS=$as_save_IFS
8292   test -z "$as_dir" && as_dir=.
8293   for ac_exec_ext in '' $ac_executable_extensions; do
8294   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8295     ac_cv_prog_OBJDUMP="${ncn_progname}"
8296     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8297     break 2
8298   fi
8299 done
8300 done
8301
8302 fi
8303 fi
8304 OBJDUMP=$ac_cv_prog_OBJDUMP
8305 if test -n "$OBJDUMP"; then
8306   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8307 echo "${ECHO_T}$OBJDUMP" >&6
8308 else
8309   echo "$as_me:$LINENO: result: no" >&5
8310 echo "${ECHO_T}no" >&6
8311 fi
8312
8313   done
8314 fi
8315
8316 for ncn_progname in objdump; do
8317   if test -n "$ncn_tool_prefix"; then
8318     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8319 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8320 echo "$as_me:$LINENO: checking for $ac_word" >&5
8321 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8322 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8323   echo $ECHO_N "(cached) $ECHO_C" >&6
8324 else
8325   if test -n "$OBJDUMP"; then
8326   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8327 else
8328 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8329 for as_dir in $PATH
8330 do
8331   IFS=$as_save_IFS
8332   test -z "$as_dir" && as_dir=.
8333   for ac_exec_ext in '' $ac_executable_extensions; do
8334   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8335     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8336     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8337     break 2
8338   fi
8339 done
8340 done
8341
8342 fi
8343 fi
8344 OBJDUMP=$ac_cv_prog_OBJDUMP
8345 if test -n "$OBJDUMP"; then
8346   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8347 echo "${ECHO_T}$OBJDUMP" >&6
8348 else
8349   echo "$as_me:$LINENO: result: no" >&5
8350 echo "${ECHO_T}no" >&6
8351 fi
8352
8353   fi
8354   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8355     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8356 set dummy ${ncn_progname}; ac_word=$2
8357 echo "$as_me:$LINENO: checking for $ac_word" >&5
8358 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8359 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8360   echo $ECHO_N "(cached) $ECHO_C" >&6
8361 else
8362   if test -n "$OBJDUMP"; then
8363   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8364 else
8365 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8366 for as_dir in $PATH
8367 do
8368   IFS=$as_save_IFS
8369   test -z "$as_dir" && as_dir=.
8370   for ac_exec_ext in '' $ac_executable_extensions; do
8371   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8372     ac_cv_prog_OBJDUMP="${ncn_progname}"
8373     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8374     break 2
8375   fi
8376 done
8377 done
8378
8379 fi
8380 fi
8381 OBJDUMP=$ac_cv_prog_OBJDUMP
8382 if test -n "$OBJDUMP"; then
8383   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8384 echo "${ECHO_T}$OBJDUMP" >&6
8385 else
8386   echo "$as_me:$LINENO: result: no" >&5
8387 echo "${ECHO_T}no" >&6
8388 fi
8389
8390   fi
8391   test -n "$ac_cv_prog_OBJDUMP" && break
8392 done
8393
8394 if test -z "$ac_cv_prog_OBJDUMP" ; then
8395   set dummy objdump
8396   if test $build = $host ; then
8397     OBJDUMP="$2"
8398   else
8399     OBJDUMP="${ncn_tool_prefix}$2"
8400   fi
8401 fi
8402
8403
8404
8405
8406
8407
8408 # Target tools.
8409
8410 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8411 if test "${with_build_time_tools+set}" = set; then
8412   withval="$with_build_time_tools"
8413   case x"$withval" in
8414      x/*) ;;
8415      *)
8416        with_build_time_tools=
8417        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8418 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8419        ;;
8420    esac
8421 else
8422   with_build_time_tools=
8423 fi;
8424
8425
8426
8427 if test -n "$CC_FOR_TARGET"; then
8428   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8429 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8430   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8431 fi
8432
8433 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8434   for ncn_progname in cc gcc; do
8435     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8436 set dummy ${ncn_progname}; ac_word=$2
8437 echo "$as_me:$LINENO: checking for $ac_word" >&5
8438 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8439 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8440   echo $ECHO_N "(cached) $ECHO_C" >&6
8441 else
8442   if test -n "$CC_FOR_TARGET"; then
8443   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8444 else
8445 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8446 for as_dir in $PATH
8447 do
8448   IFS=$as_save_IFS
8449   test -z "$as_dir" && as_dir=.
8450   for ac_exec_ext in '' $ac_executable_extensions; do
8451   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8452     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8453     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8454     break 2
8455   fi
8456 done
8457 done
8458
8459 fi
8460 fi
8461 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8462 if test -n "$CC_FOR_TARGET"; then
8463   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8464 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8465 else
8466   echo "$as_me:$LINENO: result: no" >&5
8467 echo "${ECHO_T}no" >&6
8468 fi
8469
8470   done
8471 fi
8472
8473 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8474   for ncn_progname in cc gcc; do
8475     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8476 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8477     if test -x $with_build_time_tools/${ncn_progname}; then
8478       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8479       echo "$as_me:$LINENO: result: yes" >&5
8480 echo "${ECHO_T}yes" >&6
8481       break
8482     else
8483       echo "$as_me:$LINENO: result: no" >&5
8484 echo "${ECHO_T}no" >&6
8485     fi
8486   done
8487 fi
8488
8489 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8490   for ncn_progname in cc gcc; do
8491     if test -n "$ncn_target_tool_prefix"; then
8492       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8493 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8494 echo "$as_me:$LINENO: checking for $ac_word" >&5
8495 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8496 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8497   echo $ECHO_N "(cached) $ECHO_C" >&6
8498 else
8499   if test -n "$CC_FOR_TARGET"; then
8500   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8501 else
8502 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8503 for as_dir in $PATH
8504 do
8505   IFS=$as_save_IFS
8506   test -z "$as_dir" && as_dir=.
8507   for ac_exec_ext in '' $ac_executable_extensions; do
8508   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8509     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8510     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8511     break 2
8512   fi
8513 done
8514 done
8515
8516 fi
8517 fi
8518 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8519 if test -n "$CC_FOR_TARGET"; then
8520   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8521 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8522 else
8523   echo "$as_me:$LINENO: result: no" >&5
8524 echo "${ECHO_T}no" >&6
8525 fi
8526
8527     fi
8528     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8529       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8530 set dummy ${ncn_progname}; ac_word=$2
8531 echo "$as_me:$LINENO: checking for $ac_word" >&5
8532 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8533 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8534   echo $ECHO_N "(cached) $ECHO_C" >&6
8535 else
8536   if test -n "$CC_FOR_TARGET"; then
8537   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8538 else
8539 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8540 for as_dir in $PATH
8541 do
8542   IFS=$as_save_IFS
8543   test -z "$as_dir" && as_dir=.
8544   for ac_exec_ext in '' $ac_executable_extensions; do
8545   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8546     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8547     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8548     break 2
8549   fi
8550 done
8551 done
8552
8553 fi
8554 fi
8555 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8556 if test -n "$CC_FOR_TARGET"; then
8557   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8558 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8559 else
8560   echo "$as_me:$LINENO: result: no" >&5
8561 echo "${ECHO_T}no" >&6
8562 fi
8563
8564     fi
8565     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8566   done
8567 fi
8568
8569 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8570   set dummy cc gcc
8571   if test $build = $target ; then
8572     CC_FOR_TARGET="$2"
8573   else
8574     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8575   fi
8576 else
8577   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8578 fi
8579
8580
8581
8582 if test -n "$CXX_FOR_TARGET"; then
8583   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8584 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8585   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8586 fi
8587
8588 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8589   for ncn_progname in c++ g++ cxx gxx; do
8590     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8591 set dummy ${ncn_progname}; ac_word=$2
8592 echo "$as_me:$LINENO: checking for $ac_word" >&5
8593 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8594 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8595   echo $ECHO_N "(cached) $ECHO_C" >&6
8596 else
8597   if test -n "$CXX_FOR_TARGET"; then
8598   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8599 else
8600 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8601 for as_dir in $PATH
8602 do
8603   IFS=$as_save_IFS
8604   test -z "$as_dir" && as_dir=.
8605   for ac_exec_ext in '' $ac_executable_extensions; do
8606   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8607     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8608     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8609     break 2
8610   fi
8611 done
8612 done
8613
8614 fi
8615 fi
8616 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8617 if test -n "$CXX_FOR_TARGET"; then
8618   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8619 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8620 else
8621   echo "$as_me:$LINENO: result: no" >&5
8622 echo "${ECHO_T}no" >&6
8623 fi
8624
8625   done
8626 fi
8627
8628 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8629   for ncn_progname in c++ g++ cxx gxx; do
8630     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8631 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8632     if test -x $with_build_time_tools/${ncn_progname}; then
8633       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8634       echo "$as_me:$LINENO: result: yes" >&5
8635 echo "${ECHO_T}yes" >&6
8636       break
8637     else
8638       echo "$as_me:$LINENO: result: no" >&5
8639 echo "${ECHO_T}no" >&6
8640     fi
8641   done
8642 fi
8643
8644 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8645   for ncn_progname in c++ g++ cxx gxx; do
8646     if test -n "$ncn_target_tool_prefix"; then
8647       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8648 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8649 echo "$as_me:$LINENO: checking for $ac_word" >&5
8650 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8651 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8652   echo $ECHO_N "(cached) $ECHO_C" >&6
8653 else
8654   if test -n "$CXX_FOR_TARGET"; then
8655   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8656 else
8657 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8658 for as_dir in $PATH
8659 do
8660   IFS=$as_save_IFS
8661   test -z "$as_dir" && as_dir=.
8662   for ac_exec_ext in '' $ac_executable_extensions; do
8663   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8664     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8665     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8666     break 2
8667   fi
8668 done
8669 done
8670
8671 fi
8672 fi
8673 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8674 if test -n "$CXX_FOR_TARGET"; then
8675   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8676 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8677 else
8678   echo "$as_me:$LINENO: result: no" >&5
8679 echo "${ECHO_T}no" >&6
8680 fi
8681
8682     fi
8683     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8684       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8685 set dummy ${ncn_progname}; ac_word=$2
8686 echo "$as_me:$LINENO: checking for $ac_word" >&5
8687 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8688 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8689   echo $ECHO_N "(cached) $ECHO_C" >&6
8690 else
8691   if test -n "$CXX_FOR_TARGET"; then
8692   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8693 else
8694 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8695 for as_dir in $PATH
8696 do
8697   IFS=$as_save_IFS
8698   test -z "$as_dir" && as_dir=.
8699   for ac_exec_ext in '' $ac_executable_extensions; do
8700   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8701     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8702     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8703     break 2
8704   fi
8705 done
8706 done
8707
8708 fi
8709 fi
8710 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8711 if test -n "$CXX_FOR_TARGET"; then
8712   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8713 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8714 else
8715   echo "$as_me:$LINENO: result: no" >&5
8716 echo "${ECHO_T}no" >&6
8717 fi
8718
8719     fi
8720     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8721   done
8722 fi
8723
8724 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8725   set dummy c++ g++ cxx gxx
8726   if test $build = $target ; then
8727     CXX_FOR_TARGET="$2"
8728   else
8729     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8730   fi
8731 else
8732   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8733 fi
8734
8735
8736
8737 if test -n "$GCC_FOR_TARGET"; then
8738   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8739 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8740   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8741 fi
8742
8743 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8744   for ncn_progname in gcc; do
8745     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8746 set dummy ${ncn_progname}; ac_word=$2
8747 echo "$as_me:$LINENO: checking for $ac_word" >&5
8748 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8749 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8750   echo $ECHO_N "(cached) $ECHO_C" >&6
8751 else
8752   if test -n "$GCC_FOR_TARGET"; then
8753   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8754 else
8755 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8756 for as_dir in $PATH
8757 do
8758   IFS=$as_save_IFS
8759   test -z "$as_dir" && as_dir=.
8760   for ac_exec_ext in '' $ac_executable_extensions; do
8761   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8762     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8763     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8764     break 2
8765   fi
8766 done
8767 done
8768
8769 fi
8770 fi
8771 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8772 if test -n "$GCC_FOR_TARGET"; then
8773   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8774 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8775 else
8776   echo "$as_me:$LINENO: result: no" >&5
8777 echo "${ECHO_T}no" >&6
8778 fi
8779
8780   done
8781 fi
8782
8783 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8784   for ncn_progname in gcc; do
8785     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8786 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8787     if test -x $with_build_time_tools/${ncn_progname}; then
8788       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8789       echo "$as_me:$LINENO: result: yes" >&5
8790 echo "${ECHO_T}yes" >&6
8791       break
8792     else
8793       echo "$as_me:$LINENO: result: no" >&5
8794 echo "${ECHO_T}no" >&6
8795     fi
8796   done
8797 fi
8798
8799 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8800   for ncn_progname in gcc; do
8801     if test -n "$ncn_target_tool_prefix"; then
8802       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8803 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8804 echo "$as_me:$LINENO: checking for $ac_word" >&5
8805 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8806 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8807   echo $ECHO_N "(cached) $ECHO_C" >&6
8808 else
8809   if test -n "$GCC_FOR_TARGET"; then
8810   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8811 else
8812 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8813 for as_dir in $PATH
8814 do
8815   IFS=$as_save_IFS
8816   test -z "$as_dir" && as_dir=.
8817   for ac_exec_ext in '' $ac_executable_extensions; do
8818   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8819     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8820     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8821     break 2
8822   fi
8823 done
8824 done
8825
8826 fi
8827 fi
8828 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8829 if test -n "$GCC_FOR_TARGET"; then
8830   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8831 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8832 else
8833   echo "$as_me:$LINENO: result: no" >&5
8834 echo "${ECHO_T}no" >&6
8835 fi
8836
8837     fi
8838     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8839       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8840 set dummy ${ncn_progname}; ac_word=$2
8841 echo "$as_me:$LINENO: checking for $ac_word" >&5
8842 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8843 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8844   echo $ECHO_N "(cached) $ECHO_C" >&6
8845 else
8846   if test -n "$GCC_FOR_TARGET"; then
8847   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8848 else
8849 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8850 for as_dir in $PATH
8851 do
8852   IFS=$as_save_IFS
8853   test -z "$as_dir" && as_dir=.
8854   for ac_exec_ext in '' $ac_executable_extensions; do
8855   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8856     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8857     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8858     break 2
8859   fi
8860 done
8861 done
8862
8863 fi
8864 fi
8865 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8866 if test -n "$GCC_FOR_TARGET"; then
8867   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8868 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8869 else
8870   echo "$as_me:$LINENO: result: no" >&5
8871 echo "${ECHO_T}no" >&6
8872 fi
8873
8874     fi
8875     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8876   done
8877 fi
8878
8879 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8880   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8881 else
8882   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8883 fi
8884
8885
8886
8887 if test -n "$GCJ_FOR_TARGET"; then
8888   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8889 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8890   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8891 fi
8892
8893 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8894   for ncn_progname in gcj; do
8895     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8896 set dummy ${ncn_progname}; ac_word=$2
8897 echo "$as_me:$LINENO: checking for $ac_word" >&5
8898 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8899 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8900   echo $ECHO_N "(cached) $ECHO_C" >&6
8901 else
8902   if test -n "$GCJ_FOR_TARGET"; then
8903   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8904 else
8905 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8906 for as_dir in $PATH
8907 do
8908   IFS=$as_save_IFS
8909   test -z "$as_dir" && as_dir=.
8910   for ac_exec_ext in '' $ac_executable_extensions; do
8911   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8912     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8913     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8914     break 2
8915   fi
8916 done
8917 done
8918
8919 fi
8920 fi
8921 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8922 if test -n "$GCJ_FOR_TARGET"; then
8923   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8924 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8925 else
8926   echo "$as_me:$LINENO: result: no" >&5
8927 echo "${ECHO_T}no" >&6
8928 fi
8929
8930   done
8931 fi
8932
8933 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8934   for ncn_progname in gcj; do
8935     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8936 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8937     if test -x $with_build_time_tools/${ncn_progname}; then
8938       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8939       echo "$as_me:$LINENO: result: yes" >&5
8940 echo "${ECHO_T}yes" >&6
8941       break
8942     else
8943       echo "$as_me:$LINENO: result: no" >&5
8944 echo "${ECHO_T}no" >&6
8945     fi
8946   done
8947 fi
8948
8949 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8950   for ncn_progname in gcj; do
8951     if test -n "$ncn_target_tool_prefix"; then
8952       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8953 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8954 echo "$as_me:$LINENO: checking for $ac_word" >&5
8955 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8956 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8957   echo $ECHO_N "(cached) $ECHO_C" >&6
8958 else
8959   if test -n "$GCJ_FOR_TARGET"; then
8960   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8961 else
8962 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8963 for as_dir in $PATH
8964 do
8965   IFS=$as_save_IFS
8966   test -z "$as_dir" && as_dir=.
8967   for ac_exec_ext in '' $ac_executable_extensions; do
8968   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8969     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8970     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8971     break 2
8972   fi
8973 done
8974 done
8975
8976 fi
8977 fi
8978 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8979 if test -n "$GCJ_FOR_TARGET"; then
8980   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8981 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8982 else
8983   echo "$as_me:$LINENO: result: no" >&5
8984 echo "${ECHO_T}no" >&6
8985 fi
8986
8987     fi
8988     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8989       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8990 set dummy ${ncn_progname}; ac_word=$2
8991 echo "$as_me:$LINENO: checking for $ac_word" >&5
8992 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8993 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8994   echo $ECHO_N "(cached) $ECHO_C" >&6
8995 else
8996   if test -n "$GCJ_FOR_TARGET"; then
8997   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8998 else
8999 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9000 for as_dir in $PATH
9001 do
9002   IFS=$as_save_IFS
9003   test -z "$as_dir" && as_dir=.
9004   for ac_exec_ext in '' $ac_executable_extensions; do
9005   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9006     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9007     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9008     break 2
9009   fi
9010 done
9011 done
9012
9013 fi
9014 fi
9015 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9016 if test -n "$GCJ_FOR_TARGET"; then
9017   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9018 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9019 else
9020   echo "$as_me:$LINENO: result: no" >&5
9021 echo "${ECHO_T}no" >&6
9022 fi
9023
9024     fi
9025     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
9026   done
9027 fi
9028
9029 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9030   set dummy gcj
9031   if test $build = $target ; then
9032     GCJ_FOR_TARGET="$2"
9033   else
9034     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9035   fi
9036 else
9037   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9038 fi
9039
9040
9041
9042 if test -n "$GFORTRAN_FOR_TARGET"; then
9043   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9044 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9045   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9046 fi
9047
9048 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9049   for ncn_progname in gfortran; do
9050     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9051 set dummy ${ncn_progname}; ac_word=$2
9052 echo "$as_me:$LINENO: checking for $ac_word" >&5
9053 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9054 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9055   echo $ECHO_N "(cached) $ECHO_C" >&6
9056 else
9057   if test -n "$GFORTRAN_FOR_TARGET"; then
9058   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9059 else
9060 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9061 for as_dir in $PATH
9062 do
9063   IFS=$as_save_IFS
9064   test -z "$as_dir" && as_dir=.
9065   for ac_exec_ext in '' $ac_executable_extensions; do
9066   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9067     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9068     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9069     break 2
9070   fi
9071 done
9072 done
9073
9074 fi
9075 fi
9076 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9077 if test -n "$GFORTRAN_FOR_TARGET"; then
9078   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9079 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9080 else
9081   echo "$as_me:$LINENO: result: no" >&5
9082 echo "${ECHO_T}no" >&6
9083 fi
9084
9085   done
9086 fi
9087
9088 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9089   for ncn_progname in gfortran; do
9090     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9091 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9092     if test -x $with_build_time_tools/${ncn_progname}; then
9093       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9094       echo "$as_me:$LINENO: result: yes" >&5
9095 echo "${ECHO_T}yes" >&6
9096       break
9097     else
9098       echo "$as_me:$LINENO: result: no" >&5
9099 echo "${ECHO_T}no" >&6
9100     fi
9101   done
9102 fi
9103
9104 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9105   for ncn_progname in gfortran; do
9106     if test -n "$ncn_target_tool_prefix"; then
9107       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9108 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9109 echo "$as_me:$LINENO: checking for $ac_word" >&5
9110 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9111 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9112   echo $ECHO_N "(cached) $ECHO_C" >&6
9113 else
9114   if test -n "$GFORTRAN_FOR_TARGET"; then
9115   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9116 else
9117 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9118 for as_dir in $PATH
9119 do
9120   IFS=$as_save_IFS
9121   test -z "$as_dir" && as_dir=.
9122   for ac_exec_ext in '' $ac_executable_extensions; do
9123   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9124     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9125     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9126     break 2
9127   fi
9128 done
9129 done
9130
9131 fi
9132 fi
9133 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9134 if test -n "$GFORTRAN_FOR_TARGET"; then
9135   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9136 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9137 else
9138   echo "$as_me:$LINENO: result: no" >&5
9139 echo "${ECHO_T}no" >&6
9140 fi
9141
9142     fi
9143     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9144       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9145 set dummy ${ncn_progname}; ac_word=$2
9146 echo "$as_me:$LINENO: checking for $ac_word" >&5
9147 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9148 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9149   echo $ECHO_N "(cached) $ECHO_C" >&6
9150 else
9151   if test -n "$GFORTRAN_FOR_TARGET"; then
9152   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9153 else
9154 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9155 for as_dir in $PATH
9156 do
9157   IFS=$as_save_IFS
9158   test -z "$as_dir" && as_dir=.
9159   for ac_exec_ext in '' $ac_executable_extensions; do
9160   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9161     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9162     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9163     break 2
9164   fi
9165 done
9166 done
9167
9168 fi
9169 fi
9170 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9171 if test -n "$GFORTRAN_FOR_TARGET"; then
9172   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9173 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9174 else
9175   echo "$as_me:$LINENO: result: no" >&5
9176 echo "${ECHO_T}no" >&6
9177 fi
9178
9179     fi
9180     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9181   done
9182 fi
9183
9184 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9185   set dummy gfortran
9186   if test $build = $target ; then
9187     GFORTRAN_FOR_TARGET="$2"
9188   else
9189     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9190   fi
9191 else
9192   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9193 fi
9194
9195
9196
9197 cat > conftest.c << \EOF
9198 #ifdef __GNUC__
9199   gcc_yay;
9200 #endif
9201 EOF
9202 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9203   have_gcc_for_target=yes
9204 else
9205   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9206   have_gcc_for_target=no
9207 fi
9208 rm conftest.c
9209
9210
9211
9212
9213 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9214   if test -n "$with_build_time_tools"; then
9215     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9216 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9217     if test -x $with_build_time_tools/ar; then
9218       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9219       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9220       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9221 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9222     else
9223       echo "$as_me:$LINENO: result: no" >&5
9224 echo "${ECHO_T}no" >&6
9225     fi
9226   elif test $build != $host && test $have_gcc_for_target = yes; then
9227     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9228     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9229     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9230   fi
9231 fi
9232 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9233   # Extract the first word of "ar", so it can be a program name with args.
9234 set dummy ar; ac_word=$2
9235 echo "$as_me:$LINENO: checking for $ac_word" >&5
9236 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9237 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9238   echo $ECHO_N "(cached) $ECHO_C" >&6
9239 else
9240   case $AR_FOR_TARGET in
9241   [\\/]* | ?:[\\/]*)
9242   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9243   ;;
9244   *)
9245   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9246 for as_dir in $gcc_cv_tool_dirs
9247 do
9248   IFS=$as_save_IFS
9249   test -z "$as_dir" && as_dir=.
9250   for ac_exec_ext in '' $ac_executable_extensions; do
9251   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9252     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9253     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9254     break 2
9255   fi
9256 done
9257 done
9258
9259   ;;
9260 esac
9261 fi
9262 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9263
9264 if test -n "$AR_FOR_TARGET"; then
9265   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9266 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9267 else
9268   echo "$as_me:$LINENO: result: no" >&5
9269 echo "${ECHO_T}no" >&6
9270 fi
9271
9272 fi
9273 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9274
9275
9276 if test -n "$AR_FOR_TARGET"; then
9277   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9278 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9279   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9280 fi
9281
9282 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9283   for ncn_progname in ar; do
9284     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9285 set dummy ${ncn_progname}; ac_word=$2
9286 echo "$as_me:$LINENO: checking for $ac_word" >&5
9287 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9288 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9289   echo $ECHO_N "(cached) $ECHO_C" >&6
9290 else
9291   if test -n "$AR_FOR_TARGET"; then
9292   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9293 else
9294 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9295 for as_dir in $PATH
9296 do
9297   IFS=$as_save_IFS
9298   test -z "$as_dir" && as_dir=.
9299   for ac_exec_ext in '' $ac_executable_extensions; do
9300   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9301     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9302     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9303     break 2
9304   fi
9305 done
9306 done
9307
9308 fi
9309 fi
9310 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9311 if test -n "$AR_FOR_TARGET"; then
9312   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9313 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9314 else
9315   echo "$as_me:$LINENO: result: no" >&5
9316 echo "${ECHO_T}no" >&6
9317 fi
9318
9319   done
9320 fi
9321
9322 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9323   for ncn_progname in ar; do
9324     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9325 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9326     if test -x $with_build_time_tools/${ncn_progname}; then
9327       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9328       echo "$as_me:$LINENO: result: yes" >&5
9329 echo "${ECHO_T}yes" >&6
9330       break
9331     else
9332       echo "$as_me:$LINENO: result: no" >&5
9333 echo "${ECHO_T}no" >&6
9334     fi
9335   done
9336 fi
9337
9338 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9339   for ncn_progname in ar; do
9340     if test -n "$ncn_target_tool_prefix"; then
9341       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9342 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9343 echo "$as_me:$LINENO: checking for $ac_word" >&5
9344 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9345 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9346   echo $ECHO_N "(cached) $ECHO_C" >&6
9347 else
9348   if test -n "$AR_FOR_TARGET"; then
9349   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9350 else
9351 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9352 for as_dir in $PATH
9353 do
9354   IFS=$as_save_IFS
9355   test -z "$as_dir" && as_dir=.
9356   for ac_exec_ext in '' $ac_executable_extensions; do
9357   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9358     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9359     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9360     break 2
9361   fi
9362 done
9363 done
9364
9365 fi
9366 fi
9367 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9368 if test -n "$AR_FOR_TARGET"; then
9369   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9370 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9371 else
9372   echo "$as_me:$LINENO: result: no" >&5
9373 echo "${ECHO_T}no" >&6
9374 fi
9375
9376     fi
9377     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9378       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9379 set dummy ${ncn_progname}; ac_word=$2
9380 echo "$as_me:$LINENO: checking for $ac_word" >&5
9381 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9382 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9383   echo $ECHO_N "(cached) $ECHO_C" >&6
9384 else
9385   if test -n "$AR_FOR_TARGET"; then
9386   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9387 else
9388 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9389 for as_dir in $PATH
9390 do
9391   IFS=$as_save_IFS
9392   test -z "$as_dir" && as_dir=.
9393   for ac_exec_ext in '' $ac_executable_extensions; do
9394   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9395     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9396     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9397     break 2
9398   fi
9399 done
9400 done
9401
9402 fi
9403 fi
9404 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9405 if test -n "$AR_FOR_TARGET"; then
9406   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9407 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9408 else
9409   echo "$as_me:$LINENO: result: no" >&5
9410 echo "${ECHO_T}no" >&6
9411 fi
9412
9413     fi
9414     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9415   done
9416 fi
9417
9418 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9419   set dummy ar
9420   if test $build = $target ; then
9421     AR_FOR_TARGET="$2"
9422   else
9423     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9424   fi
9425 else
9426   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9427 fi
9428
9429 else
9430   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9431 fi
9432
9433
9434
9435
9436 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9437   if test -n "$with_build_time_tools"; then
9438     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9439 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9440     if test -x $with_build_time_tools/as; then
9441       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9442       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9443       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9444 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9445     else
9446       echo "$as_me:$LINENO: result: no" >&5
9447 echo "${ECHO_T}no" >&6
9448     fi
9449   elif test $build != $host && test $have_gcc_for_target = yes; then
9450     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9451     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9452     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9453   fi
9454 fi
9455 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9456   # Extract the first word of "as", so it can be a program name with args.
9457 set dummy as; ac_word=$2
9458 echo "$as_me:$LINENO: checking for $ac_word" >&5
9459 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9460 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9461   echo $ECHO_N "(cached) $ECHO_C" >&6
9462 else
9463   case $AS_FOR_TARGET in
9464   [\\/]* | ?:[\\/]*)
9465   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9466   ;;
9467   *)
9468   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9469 for as_dir in $gcc_cv_tool_dirs
9470 do
9471   IFS=$as_save_IFS
9472   test -z "$as_dir" && as_dir=.
9473   for ac_exec_ext in '' $ac_executable_extensions; do
9474   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9475     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9476     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9477     break 2
9478   fi
9479 done
9480 done
9481
9482   ;;
9483 esac
9484 fi
9485 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9486
9487 if test -n "$AS_FOR_TARGET"; then
9488   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9489 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9490 else
9491   echo "$as_me:$LINENO: result: no" >&5
9492 echo "${ECHO_T}no" >&6
9493 fi
9494
9495 fi
9496 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9497
9498
9499 if test -n "$AS_FOR_TARGET"; then
9500   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9501 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9502   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9503 fi
9504
9505 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9506   for ncn_progname in as; do
9507     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9508 set dummy ${ncn_progname}; ac_word=$2
9509 echo "$as_me:$LINENO: checking for $ac_word" >&5
9510 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9511 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9512   echo $ECHO_N "(cached) $ECHO_C" >&6
9513 else
9514   if test -n "$AS_FOR_TARGET"; then
9515   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9516 else
9517 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9518 for as_dir in $PATH
9519 do
9520   IFS=$as_save_IFS
9521   test -z "$as_dir" && as_dir=.
9522   for ac_exec_ext in '' $ac_executable_extensions; do
9523   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9524     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9525     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9526     break 2
9527   fi
9528 done
9529 done
9530
9531 fi
9532 fi
9533 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9534 if test -n "$AS_FOR_TARGET"; then
9535   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9536 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9537 else
9538   echo "$as_me:$LINENO: result: no" >&5
9539 echo "${ECHO_T}no" >&6
9540 fi
9541
9542   done
9543 fi
9544
9545 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9546   for ncn_progname in as; do
9547     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9548 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9549     if test -x $with_build_time_tools/${ncn_progname}; then
9550       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9551       echo "$as_me:$LINENO: result: yes" >&5
9552 echo "${ECHO_T}yes" >&6
9553       break
9554     else
9555       echo "$as_me:$LINENO: result: no" >&5
9556 echo "${ECHO_T}no" >&6
9557     fi
9558   done
9559 fi
9560
9561 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9562   for ncn_progname in as; do
9563     if test -n "$ncn_target_tool_prefix"; then
9564       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9565 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9566 echo "$as_me:$LINENO: checking for $ac_word" >&5
9567 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9568 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9569   echo $ECHO_N "(cached) $ECHO_C" >&6
9570 else
9571   if test -n "$AS_FOR_TARGET"; then
9572   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9573 else
9574 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9575 for as_dir in $PATH
9576 do
9577   IFS=$as_save_IFS
9578   test -z "$as_dir" && as_dir=.
9579   for ac_exec_ext in '' $ac_executable_extensions; do
9580   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9581     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9582     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9583     break 2
9584   fi
9585 done
9586 done
9587
9588 fi
9589 fi
9590 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9591 if test -n "$AS_FOR_TARGET"; then
9592   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9593 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9594 else
9595   echo "$as_me:$LINENO: result: no" >&5
9596 echo "${ECHO_T}no" >&6
9597 fi
9598
9599     fi
9600     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9601       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9602 set dummy ${ncn_progname}; ac_word=$2
9603 echo "$as_me:$LINENO: checking for $ac_word" >&5
9604 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9605 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9606   echo $ECHO_N "(cached) $ECHO_C" >&6
9607 else
9608   if test -n "$AS_FOR_TARGET"; then
9609   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9610 else
9611 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9612 for as_dir in $PATH
9613 do
9614   IFS=$as_save_IFS
9615   test -z "$as_dir" && as_dir=.
9616   for ac_exec_ext in '' $ac_executable_extensions; do
9617   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9618     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9619     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9620     break 2
9621   fi
9622 done
9623 done
9624
9625 fi
9626 fi
9627 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9628 if test -n "$AS_FOR_TARGET"; then
9629   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9630 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9631 else
9632   echo "$as_me:$LINENO: result: no" >&5
9633 echo "${ECHO_T}no" >&6
9634 fi
9635
9636     fi
9637     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9638   done
9639 fi
9640
9641 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9642   set dummy as
9643   if test $build = $target ; then
9644     AS_FOR_TARGET="$2"
9645   else
9646     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9647   fi
9648 else
9649   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9650 fi
9651
9652 else
9653   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9654 fi
9655
9656
9657
9658
9659 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9660   if test -n "$with_build_time_tools"; then
9661     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9662 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9663     if test -x $with_build_time_tools/dlltool; then
9664       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9665       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9666       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9667 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9668     else
9669       echo "$as_me:$LINENO: result: no" >&5
9670 echo "${ECHO_T}no" >&6
9671     fi
9672   elif test $build != $host && test $have_gcc_for_target = yes; then
9673     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9674     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9675     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9676   fi
9677 fi
9678 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9679   # Extract the first word of "dlltool", so it can be a program name with args.
9680 set dummy dlltool; ac_word=$2
9681 echo "$as_me:$LINENO: checking for $ac_word" >&5
9682 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9683 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9684   echo $ECHO_N "(cached) $ECHO_C" >&6
9685 else
9686   case $DLLTOOL_FOR_TARGET in
9687   [\\/]* | ?:[\\/]*)
9688   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9689   ;;
9690   *)
9691   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9692 for as_dir in $gcc_cv_tool_dirs
9693 do
9694   IFS=$as_save_IFS
9695   test -z "$as_dir" && as_dir=.
9696   for ac_exec_ext in '' $ac_executable_extensions; do
9697   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9698     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9699     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9700     break 2
9701   fi
9702 done
9703 done
9704
9705   ;;
9706 esac
9707 fi
9708 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9709
9710 if test -n "$DLLTOOL_FOR_TARGET"; then
9711   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9712 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9713 else
9714   echo "$as_me:$LINENO: result: no" >&5
9715 echo "${ECHO_T}no" >&6
9716 fi
9717
9718 fi
9719 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9720
9721
9722 if test -n "$DLLTOOL_FOR_TARGET"; then
9723   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9724 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9725   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9726 fi
9727
9728 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9729   for ncn_progname in dlltool; do
9730     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9731 set dummy ${ncn_progname}; ac_word=$2
9732 echo "$as_me:$LINENO: checking for $ac_word" >&5
9733 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9734 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9735   echo $ECHO_N "(cached) $ECHO_C" >&6
9736 else
9737   if test -n "$DLLTOOL_FOR_TARGET"; then
9738   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9739 else
9740 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9741 for as_dir in $PATH
9742 do
9743   IFS=$as_save_IFS
9744   test -z "$as_dir" && as_dir=.
9745   for ac_exec_ext in '' $ac_executable_extensions; do
9746   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9747     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9748     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9749     break 2
9750   fi
9751 done
9752 done
9753
9754 fi
9755 fi
9756 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9757 if test -n "$DLLTOOL_FOR_TARGET"; then
9758   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9759 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9760 else
9761   echo "$as_me:$LINENO: result: no" >&5
9762 echo "${ECHO_T}no" >&6
9763 fi
9764
9765   done
9766 fi
9767
9768 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9769   for ncn_progname in dlltool; do
9770     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9771 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9772     if test -x $with_build_time_tools/${ncn_progname}; then
9773       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9774       echo "$as_me:$LINENO: result: yes" >&5
9775 echo "${ECHO_T}yes" >&6
9776       break
9777     else
9778       echo "$as_me:$LINENO: result: no" >&5
9779 echo "${ECHO_T}no" >&6
9780     fi
9781   done
9782 fi
9783
9784 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9785   for ncn_progname in dlltool; do
9786     if test -n "$ncn_target_tool_prefix"; then
9787       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9788 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9789 echo "$as_me:$LINENO: checking for $ac_word" >&5
9790 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9791 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9792   echo $ECHO_N "(cached) $ECHO_C" >&6
9793 else
9794   if test -n "$DLLTOOL_FOR_TARGET"; then
9795   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9796 else
9797 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9798 for as_dir in $PATH
9799 do
9800   IFS=$as_save_IFS
9801   test -z "$as_dir" && as_dir=.
9802   for ac_exec_ext in '' $ac_executable_extensions; do
9803   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9804     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9805     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9806     break 2
9807   fi
9808 done
9809 done
9810
9811 fi
9812 fi
9813 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9814 if test -n "$DLLTOOL_FOR_TARGET"; then
9815   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9816 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9817 else
9818   echo "$as_me:$LINENO: result: no" >&5
9819 echo "${ECHO_T}no" >&6
9820 fi
9821
9822     fi
9823     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9824       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9825 set dummy ${ncn_progname}; ac_word=$2
9826 echo "$as_me:$LINENO: checking for $ac_word" >&5
9827 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9828 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9829   echo $ECHO_N "(cached) $ECHO_C" >&6
9830 else
9831   if test -n "$DLLTOOL_FOR_TARGET"; then
9832   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9833 else
9834 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9835 for as_dir in $PATH
9836 do
9837   IFS=$as_save_IFS
9838   test -z "$as_dir" && as_dir=.
9839   for ac_exec_ext in '' $ac_executable_extensions; do
9840   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9841     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9842     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9843     break 2
9844   fi
9845 done
9846 done
9847
9848 fi
9849 fi
9850 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9851 if test -n "$DLLTOOL_FOR_TARGET"; then
9852   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9853 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9854 else
9855   echo "$as_me:$LINENO: result: no" >&5
9856 echo "${ECHO_T}no" >&6
9857 fi
9858
9859     fi
9860     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9861   done
9862 fi
9863
9864 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9865   set dummy dlltool
9866   if test $build = $target ; then
9867     DLLTOOL_FOR_TARGET="$2"
9868   else
9869     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9870   fi
9871 else
9872   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9873 fi
9874
9875 else
9876   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9877 fi
9878
9879
9880
9881
9882 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9883   if test -n "$with_build_time_tools"; then
9884     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9885 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9886     if test -x $with_build_time_tools/ld; then
9887       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9888       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9889       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9890 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9891     else
9892       echo "$as_me:$LINENO: result: no" >&5
9893 echo "${ECHO_T}no" >&6
9894     fi
9895   elif test $build != $host && test $have_gcc_for_target = yes; then
9896     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9897     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9898     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9899   fi
9900 fi
9901 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9902   # Extract the first word of "ld", so it can be a program name with args.
9903 set dummy ld; ac_word=$2
9904 echo "$as_me:$LINENO: checking for $ac_word" >&5
9905 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9906 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9907   echo $ECHO_N "(cached) $ECHO_C" >&6
9908 else
9909   case $LD_FOR_TARGET in
9910   [\\/]* | ?:[\\/]*)
9911   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9912   ;;
9913   *)
9914   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9915 for as_dir in $gcc_cv_tool_dirs
9916 do
9917   IFS=$as_save_IFS
9918   test -z "$as_dir" && as_dir=.
9919   for ac_exec_ext in '' $ac_executable_extensions; do
9920   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9921     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9922     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9923     break 2
9924   fi
9925 done
9926 done
9927
9928   ;;
9929 esac
9930 fi
9931 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9932
9933 if test -n "$LD_FOR_TARGET"; then
9934   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9935 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9936 else
9937   echo "$as_me:$LINENO: result: no" >&5
9938 echo "${ECHO_T}no" >&6
9939 fi
9940
9941 fi
9942 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9943
9944
9945 if test -n "$LD_FOR_TARGET"; then
9946   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9947 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9948   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9949 fi
9950
9951 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9952   for ncn_progname in ld; do
9953     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9954 set dummy ${ncn_progname}; ac_word=$2
9955 echo "$as_me:$LINENO: checking for $ac_word" >&5
9956 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9957 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9958   echo $ECHO_N "(cached) $ECHO_C" >&6
9959 else
9960   if test -n "$LD_FOR_TARGET"; then
9961   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9962 else
9963 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9964 for as_dir in $PATH
9965 do
9966   IFS=$as_save_IFS
9967   test -z "$as_dir" && as_dir=.
9968   for ac_exec_ext in '' $ac_executable_extensions; do
9969   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9970     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9971     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9972     break 2
9973   fi
9974 done
9975 done
9976
9977 fi
9978 fi
9979 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9980 if test -n "$LD_FOR_TARGET"; then
9981   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9982 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9983 else
9984   echo "$as_me:$LINENO: result: no" >&5
9985 echo "${ECHO_T}no" >&6
9986 fi
9987
9988   done
9989 fi
9990
9991 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9992   for ncn_progname in ld; do
9993     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9994 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9995     if test -x $with_build_time_tools/${ncn_progname}; then
9996       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9997       echo "$as_me:$LINENO: result: yes" >&5
9998 echo "${ECHO_T}yes" >&6
9999       break
10000     else
10001       echo "$as_me:$LINENO: result: no" >&5
10002 echo "${ECHO_T}no" >&6
10003     fi
10004   done
10005 fi
10006
10007 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
10008   for ncn_progname in ld; do
10009     if test -n "$ncn_target_tool_prefix"; then
10010       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10011 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10012 echo "$as_me:$LINENO: checking for $ac_word" >&5
10013 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10014 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10015   echo $ECHO_N "(cached) $ECHO_C" >&6
10016 else
10017   if test -n "$LD_FOR_TARGET"; then
10018   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10019 else
10020 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10021 for as_dir in $PATH
10022 do
10023   IFS=$as_save_IFS
10024   test -z "$as_dir" && as_dir=.
10025   for ac_exec_ext in '' $ac_executable_extensions; do
10026   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10027     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10028     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10029     break 2
10030   fi
10031 done
10032 done
10033
10034 fi
10035 fi
10036 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10037 if test -n "$LD_FOR_TARGET"; then
10038   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10039 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10040 else
10041   echo "$as_me:$LINENO: result: no" >&5
10042 echo "${ECHO_T}no" >&6
10043 fi
10044
10045     fi
10046     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10047       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10048 set dummy ${ncn_progname}; ac_word=$2
10049 echo "$as_me:$LINENO: checking for $ac_word" >&5
10050 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10051 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10052   echo $ECHO_N "(cached) $ECHO_C" >&6
10053 else
10054   if test -n "$LD_FOR_TARGET"; then
10055   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10056 else
10057 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10058 for as_dir in $PATH
10059 do
10060   IFS=$as_save_IFS
10061   test -z "$as_dir" && as_dir=.
10062   for ac_exec_ext in '' $ac_executable_extensions; do
10063   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10064     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10065     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10066     break 2
10067   fi
10068 done
10069 done
10070
10071 fi
10072 fi
10073 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10074 if test -n "$LD_FOR_TARGET"; then
10075   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10076 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10077 else
10078   echo "$as_me:$LINENO: result: no" >&5
10079 echo "${ECHO_T}no" >&6
10080 fi
10081
10082     fi
10083     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10084   done
10085 fi
10086
10087 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10088   set dummy ld
10089   if test $build = $target ; then
10090     LD_FOR_TARGET="$2"
10091   else
10092     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10093   fi
10094 else
10095   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10096 fi
10097
10098 else
10099   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10100 fi
10101
10102
10103
10104
10105 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10106   if test -n "$with_build_time_tools"; then
10107     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10108 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10109     if test -x $with_build_time_tools/lipo; then
10110       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10111       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10112       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10113 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10114     else
10115       echo "$as_me:$LINENO: result: no" >&5
10116 echo "${ECHO_T}no" >&6
10117     fi
10118   elif test $build != $host && test $have_gcc_for_target = yes; then
10119     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10120     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10121     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10122   fi
10123 fi
10124 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10125   # Extract the first word of "lipo", so it can be a program name with args.
10126 set dummy lipo; ac_word=$2
10127 echo "$as_me:$LINENO: checking for $ac_word" >&5
10128 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10129 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10130   echo $ECHO_N "(cached) $ECHO_C" >&6
10131 else
10132   case $LIPO_FOR_TARGET in
10133   [\\/]* | ?:[\\/]*)
10134   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10135   ;;
10136   *)
10137   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10138 for as_dir in $gcc_cv_tool_dirs
10139 do
10140   IFS=$as_save_IFS
10141   test -z "$as_dir" && as_dir=.
10142   for ac_exec_ext in '' $ac_executable_extensions; do
10143   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10144     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10145     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10146     break 2
10147   fi
10148 done
10149 done
10150
10151   ;;
10152 esac
10153 fi
10154 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10155
10156 if test -n "$LIPO_FOR_TARGET"; then
10157   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10158 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10159 else
10160   echo "$as_me:$LINENO: result: no" >&5
10161 echo "${ECHO_T}no" >&6
10162 fi
10163
10164 fi
10165 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10166
10167
10168 if test -n "$LIPO_FOR_TARGET"; then
10169   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10170 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10171   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10172 fi
10173
10174 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10175   for ncn_progname in lipo; do
10176     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10177 set dummy ${ncn_progname}; ac_word=$2
10178 echo "$as_me:$LINENO: checking for $ac_word" >&5
10179 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10180 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10181   echo $ECHO_N "(cached) $ECHO_C" >&6
10182 else
10183   if test -n "$LIPO_FOR_TARGET"; then
10184   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10185 else
10186 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10187 for as_dir in $PATH
10188 do
10189   IFS=$as_save_IFS
10190   test -z "$as_dir" && as_dir=.
10191   for ac_exec_ext in '' $ac_executable_extensions; do
10192   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10193     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10194     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10195     break 2
10196   fi
10197 done
10198 done
10199
10200 fi
10201 fi
10202 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10203 if test -n "$LIPO_FOR_TARGET"; then
10204   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10205 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10206 else
10207   echo "$as_me:$LINENO: result: no" >&5
10208 echo "${ECHO_T}no" >&6
10209 fi
10210
10211   done
10212 fi
10213
10214 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10215   for ncn_progname in lipo; do
10216     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10217 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10218     if test -x $with_build_time_tools/${ncn_progname}; then
10219       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10220       echo "$as_me:$LINENO: result: yes" >&5
10221 echo "${ECHO_T}yes" >&6
10222       break
10223     else
10224       echo "$as_me:$LINENO: result: no" >&5
10225 echo "${ECHO_T}no" >&6
10226     fi
10227   done
10228 fi
10229
10230 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10231   for ncn_progname in lipo; do
10232     if test -n "$ncn_target_tool_prefix"; then
10233       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10234 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10235 echo "$as_me:$LINENO: checking for $ac_word" >&5
10236 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10237 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10238   echo $ECHO_N "(cached) $ECHO_C" >&6
10239 else
10240   if test -n "$LIPO_FOR_TARGET"; then
10241   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10242 else
10243 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10244 for as_dir in $PATH
10245 do
10246   IFS=$as_save_IFS
10247   test -z "$as_dir" && as_dir=.
10248   for ac_exec_ext in '' $ac_executable_extensions; do
10249   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10250     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10251     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10252     break 2
10253   fi
10254 done
10255 done
10256
10257 fi
10258 fi
10259 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10260 if test -n "$LIPO_FOR_TARGET"; then
10261   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10262 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10263 else
10264   echo "$as_me:$LINENO: result: no" >&5
10265 echo "${ECHO_T}no" >&6
10266 fi
10267
10268     fi
10269     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10270       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10271 set dummy ${ncn_progname}; ac_word=$2
10272 echo "$as_me:$LINENO: checking for $ac_word" >&5
10273 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10274 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10275   echo $ECHO_N "(cached) $ECHO_C" >&6
10276 else
10277   if test -n "$LIPO_FOR_TARGET"; then
10278   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10279 else
10280 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10281 for as_dir in $PATH
10282 do
10283   IFS=$as_save_IFS
10284   test -z "$as_dir" && as_dir=.
10285   for ac_exec_ext in '' $ac_executable_extensions; do
10286   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10287     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10288     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10289     break 2
10290   fi
10291 done
10292 done
10293
10294 fi
10295 fi
10296 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10297 if test -n "$LIPO_FOR_TARGET"; then
10298   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10299 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10300 else
10301   echo "$as_me:$LINENO: result: no" >&5
10302 echo "${ECHO_T}no" >&6
10303 fi
10304
10305     fi
10306     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10307   done
10308 fi
10309
10310 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10311   set dummy lipo
10312   if test $build = $target ; then
10313     LIPO_FOR_TARGET="$2"
10314   else
10315     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10316   fi
10317 else
10318   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10319 fi
10320
10321 else
10322   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10323 fi
10324
10325
10326
10327
10328 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10329   if test -n "$with_build_time_tools"; then
10330     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10331 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10332     if test -x $with_build_time_tools/nm; then
10333       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10334       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10335       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10336 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10337     else
10338       echo "$as_me:$LINENO: result: no" >&5
10339 echo "${ECHO_T}no" >&6
10340     fi
10341   elif test $build != $host && test $have_gcc_for_target = yes; then
10342     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10343     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10344     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10345   fi
10346 fi
10347 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10348   # Extract the first word of "nm", so it can be a program name with args.
10349 set dummy nm; ac_word=$2
10350 echo "$as_me:$LINENO: checking for $ac_word" >&5
10351 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10352 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10353   echo $ECHO_N "(cached) $ECHO_C" >&6
10354 else
10355   case $NM_FOR_TARGET in
10356   [\\/]* | ?:[\\/]*)
10357   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10358   ;;
10359   *)
10360   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10361 for as_dir in $gcc_cv_tool_dirs
10362 do
10363   IFS=$as_save_IFS
10364   test -z "$as_dir" && as_dir=.
10365   for ac_exec_ext in '' $ac_executable_extensions; do
10366   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10367     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10368     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10369     break 2
10370   fi
10371 done
10372 done
10373
10374   ;;
10375 esac
10376 fi
10377 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10378
10379 if test -n "$NM_FOR_TARGET"; then
10380   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10381 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10382 else
10383   echo "$as_me:$LINENO: result: no" >&5
10384 echo "${ECHO_T}no" >&6
10385 fi
10386
10387 fi
10388 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10389
10390
10391 if test -n "$NM_FOR_TARGET"; then
10392   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10393 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10394   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10395 fi
10396
10397 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10398   for ncn_progname in nm; do
10399     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10400 set dummy ${ncn_progname}; ac_word=$2
10401 echo "$as_me:$LINENO: checking for $ac_word" >&5
10402 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10403 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10404   echo $ECHO_N "(cached) $ECHO_C" >&6
10405 else
10406   if test -n "$NM_FOR_TARGET"; then
10407   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10408 else
10409 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10410 for as_dir in $PATH
10411 do
10412   IFS=$as_save_IFS
10413   test -z "$as_dir" && as_dir=.
10414   for ac_exec_ext in '' $ac_executable_extensions; do
10415   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10416     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10417     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10418     break 2
10419   fi
10420 done
10421 done
10422
10423 fi
10424 fi
10425 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10426 if test -n "$NM_FOR_TARGET"; then
10427   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10428 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10429 else
10430   echo "$as_me:$LINENO: result: no" >&5
10431 echo "${ECHO_T}no" >&6
10432 fi
10433
10434   done
10435 fi
10436
10437 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10438   for ncn_progname in nm; do
10439     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10440 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10441     if test -x $with_build_time_tools/${ncn_progname}; then
10442       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10443       echo "$as_me:$LINENO: result: yes" >&5
10444 echo "${ECHO_T}yes" >&6
10445       break
10446     else
10447       echo "$as_me:$LINENO: result: no" >&5
10448 echo "${ECHO_T}no" >&6
10449     fi
10450   done
10451 fi
10452
10453 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10454   for ncn_progname in nm; do
10455     if test -n "$ncn_target_tool_prefix"; then
10456       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10457 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10458 echo "$as_me:$LINENO: checking for $ac_word" >&5
10459 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10460 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10461   echo $ECHO_N "(cached) $ECHO_C" >&6
10462 else
10463   if test -n "$NM_FOR_TARGET"; then
10464   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10465 else
10466 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10467 for as_dir in $PATH
10468 do
10469   IFS=$as_save_IFS
10470   test -z "$as_dir" && as_dir=.
10471   for ac_exec_ext in '' $ac_executable_extensions; do
10472   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10473     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10474     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10475     break 2
10476   fi
10477 done
10478 done
10479
10480 fi
10481 fi
10482 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10483 if test -n "$NM_FOR_TARGET"; then
10484   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10485 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10486 else
10487   echo "$as_me:$LINENO: result: no" >&5
10488 echo "${ECHO_T}no" >&6
10489 fi
10490
10491     fi
10492     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10493       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10494 set dummy ${ncn_progname}; ac_word=$2
10495 echo "$as_me:$LINENO: checking for $ac_word" >&5
10496 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10497 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10498   echo $ECHO_N "(cached) $ECHO_C" >&6
10499 else
10500   if test -n "$NM_FOR_TARGET"; then
10501   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10502 else
10503 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10504 for as_dir in $PATH
10505 do
10506   IFS=$as_save_IFS
10507   test -z "$as_dir" && as_dir=.
10508   for ac_exec_ext in '' $ac_executable_extensions; do
10509   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10510     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10511     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10512     break 2
10513   fi
10514 done
10515 done
10516
10517 fi
10518 fi
10519 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10520 if test -n "$NM_FOR_TARGET"; then
10521   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10522 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10523 else
10524   echo "$as_me:$LINENO: result: no" >&5
10525 echo "${ECHO_T}no" >&6
10526 fi
10527
10528     fi
10529     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10530   done
10531 fi
10532
10533 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10534   set dummy nm
10535   if test $build = $target ; then
10536     NM_FOR_TARGET="$2"
10537   else
10538     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10539   fi
10540 else
10541   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10542 fi
10543
10544 else
10545   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10546 fi
10547
10548
10549
10550
10551 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10552   if test -n "$with_build_time_tools"; then
10553     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10554 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10555     if test -x $with_build_time_tools/objdump; then
10556       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10557       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10558       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10559 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10560     else
10561       echo "$as_me:$LINENO: result: no" >&5
10562 echo "${ECHO_T}no" >&6
10563     fi
10564   elif test $build != $host && test $have_gcc_for_target = yes; then
10565     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10566     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10567     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10568   fi
10569 fi
10570 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10571   # Extract the first word of "objdump", so it can be a program name with args.
10572 set dummy objdump; ac_word=$2
10573 echo "$as_me:$LINENO: checking for $ac_word" >&5
10574 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10575 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10576   echo $ECHO_N "(cached) $ECHO_C" >&6
10577 else
10578   case $OBJDUMP_FOR_TARGET in
10579   [\\/]* | ?:[\\/]*)
10580   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10581   ;;
10582   *)
10583   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10584 for as_dir in $gcc_cv_tool_dirs
10585 do
10586   IFS=$as_save_IFS
10587   test -z "$as_dir" && as_dir=.
10588   for ac_exec_ext in '' $ac_executable_extensions; do
10589   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10590     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10591     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10592     break 2
10593   fi
10594 done
10595 done
10596
10597   ;;
10598 esac
10599 fi
10600 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10601
10602 if test -n "$OBJDUMP_FOR_TARGET"; then
10603   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10604 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10605 else
10606   echo "$as_me:$LINENO: result: no" >&5
10607 echo "${ECHO_T}no" >&6
10608 fi
10609
10610 fi
10611 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10612
10613
10614 if test -n "$OBJDUMP_FOR_TARGET"; then
10615   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10616 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10617   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10618 fi
10619
10620 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10621   for ncn_progname in objdump; do
10622     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10623 set dummy ${ncn_progname}; ac_word=$2
10624 echo "$as_me:$LINENO: checking for $ac_word" >&5
10625 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10626 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10627   echo $ECHO_N "(cached) $ECHO_C" >&6
10628 else
10629   if test -n "$OBJDUMP_FOR_TARGET"; then
10630   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10631 else
10632 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10633 for as_dir in $PATH
10634 do
10635   IFS=$as_save_IFS
10636   test -z "$as_dir" && as_dir=.
10637   for ac_exec_ext in '' $ac_executable_extensions; do
10638   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10639     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10640     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10641     break 2
10642   fi
10643 done
10644 done
10645
10646 fi
10647 fi
10648 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10649 if test -n "$OBJDUMP_FOR_TARGET"; then
10650   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10651 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10652 else
10653   echo "$as_me:$LINENO: result: no" >&5
10654 echo "${ECHO_T}no" >&6
10655 fi
10656
10657   done
10658 fi
10659
10660 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10661   for ncn_progname in objdump; do
10662     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10663 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10664     if test -x $with_build_time_tools/${ncn_progname}; then
10665       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10666       echo "$as_me:$LINENO: result: yes" >&5
10667 echo "${ECHO_T}yes" >&6
10668       break
10669     else
10670       echo "$as_me:$LINENO: result: no" >&5
10671 echo "${ECHO_T}no" >&6
10672     fi
10673   done
10674 fi
10675
10676 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10677   for ncn_progname in objdump; do
10678     if test -n "$ncn_target_tool_prefix"; then
10679       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10680 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10681 echo "$as_me:$LINENO: checking for $ac_word" >&5
10682 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10683 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10684   echo $ECHO_N "(cached) $ECHO_C" >&6
10685 else
10686   if test -n "$OBJDUMP_FOR_TARGET"; then
10687   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10688 else
10689 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10690 for as_dir in $PATH
10691 do
10692   IFS=$as_save_IFS
10693   test -z "$as_dir" && as_dir=.
10694   for ac_exec_ext in '' $ac_executable_extensions; do
10695   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10696     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10697     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10698     break 2
10699   fi
10700 done
10701 done
10702
10703 fi
10704 fi
10705 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10706 if test -n "$OBJDUMP_FOR_TARGET"; then
10707   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10708 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10709 else
10710   echo "$as_me:$LINENO: result: no" >&5
10711 echo "${ECHO_T}no" >&6
10712 fi
10713
10714     fi
10715     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10716       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10717 set dummy ${ncn_progname}; ac_word=$2
10718 echo "$as_me:$LINENO: checking for $ac_word" >&5
10719 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10720 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10721   echo $ECHO_N "(cached) $ECHO_C" >&6
10722 else
10723   if test -n "$OBJDUMP_FOR_TARGET"; then
10724   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10725 else
10726 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10727 for as_dir in $PATH
10728 do
10729   IFS=$as_save_IFS
10730   test -z "$as_dir" && as_dir=.
10731   for ac_exec_ext in '' $ac_executable_extensions; do
10732   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10733     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10734     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10735     break 2
10736   fi
10737 done
10738 done
10739
10740 fi
10741 fi
10742 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10743 if test -n "$OBJDUMP_FOR_TARGET"; then
10744   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10745 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10746 else
10747   echo "$as_me:$LINENO: result: no" >&5
10748 echo "${ECHO_T}no" >&6
10749 fi
10750
10751     fi
10752     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10753   done
10754 fi
10755
10756 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10757   set dummy objdump
10758   if test $build = $target ; then
10759     OBJDUMP_FOR_TARGET="$2"
10760   else
10761     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10762   fi
10763 else
10764   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10765 fi
10766
10767 else
10768   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10769 fi
10770
10771
10772
10773
10774 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10775   if test -n "$with_build_time_tools"; then
10776     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10777 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10778     if test -x $with_build_time_tools/ranlib; then
10779       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10780       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10781       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10782 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10783     else
10784       echo "$as_me:$LINENO: result: no" >&5
10785 echo "${ECHO_T}no" >&6
10786     fi
10787   elif test $build != $host && test $have_gcc_for_target = yes; then
10788     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10789     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10790     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10791   fi
10792 fi
10793 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10794   # Extract the first word of "ranlib", so it can be a program name with args.
10795 set dummy ranlib; ac_word=$2
10796 echo "$as_me:$LINENO: checking for $ac_word" >&5
10797 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10798 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10799   echo $ECHO_N "(cached) $ECHO_C" >&6
10800 else
10801   case $RANLIB_FOR_TARGET in
10802   [\\/]* | ?:[\\/]*)
10803   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10804   ;;
10805   *)
10806   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10807 for as_dir in $gcc_cv_tool_dirs
10808 do
10809   IFS=$as_save_IFS
10810   test -z "$as_dir" && as_dir=.
10811   for ac_exec_ext in '' $ac_executable_extensions; do
10812   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10813     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10814     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10815     break 2
10816   fi
10817 done
10818 done
10819
10820   ;;
10821 esac
10822 fi
10823 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10824
10825 if test -n "$RANLIB_FOR_TARGET"; then
10826   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10827 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10828 else
10829   echo "$as_me:$LINENO: result: no" >&5
10830 echo "${ECHO_T}no" >&6
10831 fi
10832
10833 fi
10834 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10835
10836
10837 if test -n "$RANLIB_FOR_TARGET"; then
10838   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10839 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10840   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10841 fi
10842
10843 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10844   for ncn_progname in ranlib; do
10845     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10846 set dummy ${ncn_progname}; ac_word=$2
10847 echo "$as_me:$LINENO: checking for $ac_word" >&5
10848 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10849 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10850   echo $ECHO_N "(cached) $ECHO_C" >&6
10851 else
10852   if test -n "$RANLIB_FOR_TARGET"; then
10853   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10854 else
10855 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10856 for as_dir in $PATH
10857 do
10858   IFS=$as_save_IFS
10859   test -z "$as_dir" && as_dir=.
10860   for ac_exec_ext in '' $ac_executable_extensions; do
10861   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10862     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10863     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10864     break 2
10865   fi
10866 done
10867 done
10868
10869 fi
10870 fi
10871 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10872 if test -n "$RANLIB_FOR_TARGET"; then
10873   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10874 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10875 else
10876   echo "$as_me:$LINENO: result: no" >&5
10877 echo "${ECHO_T}no" >&6
10878 fi
10879
10880   done
10881 fi
10882
10883 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10884   for ncn_progname in ranlib; do
10885     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10886 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10887     if test -x $with_build_time_tools/${ncn_progname}; then
10888       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10889       echo "$as_me:$LINENO: result: yes" >&5
10890 echo "${ECHO_T}yes" >&6
10891       break
10892     else
10893       echo "$as_me:$LINENO: result: no" >&5
10894 echo "${ECHO_T}no" >&6
10895     fi
10896   done
10897 fi
10898
10899 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10900   for ncn_progname in ranlib; do
10901     if test -n "$ncn_target_tool_prefix"; then
10902       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10903 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10904 echo "$as_me:$LINENO: checking for $ac_word" >&5
10905 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10906 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10907   echo $ECHO_N "(cached) $ECHO_C" >&6
10908 else
10909   if test -n "$RANLIB_FOR_TARGET"; then
10910   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10911 else
10912 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10913 for as_dir in $PATH
10914 do
10915   IFS=$as_save_IFS
10916   test -z "$as_dir" && as_dir=.
10917   for ac_exec_ext in '' $ac_executable_extensions; do
10918   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10919     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10920     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10921     break 2
10922   fi
10923 done
10924 done
10925
10926 fi
10927 fi
10928 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10929 if test -n "$RANLIB_FOR_TARGET"; then
10930   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10931 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10932 else
10933   echo "$as_me:$LINENO: result: no" >&5
10934 echo "${ECHO_T}no" >&6
10935 fi
10936
10937     fi
10938     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10939       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10940 set dummy ${ncn_progname}; ac_word=$2
10941 echo "$as_me:$LINENO: checking for $ac_word" >&5
10942 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10943 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10944   echo $ECHO_N "(cached) $ECHO_C" >&6
10945 else
10946   if test -n "$RANLIB_FOR_TARGET"; then
10947   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10948 else
10949 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10950 for as_dir in $PATH
10951 do
10952   IFS=$as_save_IFS
10953   test -z "$as_dir" && as_dir=.
10954   for ac_exec_ext in '' $ac_executable_extensions; do
10955   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10956     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10957     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10958     break 2
10959   fi
10960 done
10961 done
10962
10963 fi
10964 fi
10965 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10966 if test -n "$RANLIB_FOR_TARGET"; then
10967   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10968 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10969 else
10970   echo "$as_me:$LINENO: result: no" >&5
10971 echo "${ECHO_T}no" >&6
10972 fi
10973
10974     fi
10975     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10976   done
10977 fi
10978
10979 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10980   set dummy ranlib
10981   if test $build = $target ; then
10982     RANLIB_FOR_TARGET="$2"
10983   else
10984     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10985   fi
10986 else
10987   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10988 fi
10989
10990 else
10991   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10992 fi
10993
10994
10995
10996
10997 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10998   if test -n "$with_build_time_tools"; then
10999     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
11000 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
11001     if test -x $with_build_time_tools/strip; then
11002       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
11003       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11004       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
11005 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
11006     else
11007       echo "$as_me:$LINENO: result: no" >&5
11008 echo "${ECHO_T}no" >&6
11009     fi
11010   elif test $build != $host && test $have_gcc_for_target = yes; then
11011     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
11012     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
11013     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11014   fi
11015 fi
11016 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11017   # Extract the first word of "strip", so it can be a program name with args.
11018 set dummy strip; ac_word=$2
11019 echo "$as_me:$LINENO: checking for $ac_word" >&5
11020 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11021 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
11022   echo $ECHO_N "(cached) $ECHO_C" >&6
11023 else
11024   case $STRIP_FOR_TARGET in
11025   [\\/]* | ?:[\\/]*)
11026   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
11027   ;;
11028   *)
11029   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11030 for as_dir in $gcc_cv_tool_dirs
11031 do
11032   IFS=$as_save_IFS
11033   test -z "$as_dir" && as_dir=.
11034   for ac_exec_ext in '' $ac_executable_extensions; do
11035   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11036     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11037     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11038     break 2
11039   fi
11040 done
11041 done
11042
11043   ;;
11044 esac
11045 fi
11046 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11047
11048 if test -n "$STRIP_FOR_TARGET"; then
11049   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11050 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11051 else
11052   echo "$as_me:$LINENO: result: no" >&5
11053 echo "${ECHO_T}no" >&6
11054 fi
11055
11056 fi
11057 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11058
11059
11060 if test -n "$STRIP_FOR_TARGET"; then
11061   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11062 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11063   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11064 fi
11065
11066 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11067   for ncn_progname in strip; do
11068     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11069 set dummy ${ncn_progname}; ac_word=$2
11070 echo "$as_me:$LINENO: checking for $ac_word" >&5
11071 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11072 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11073   echo $ECHO_N "(cached) $ECHO_C" >&6
11074 else
11075   if test -n "$STRIP_FOR_TARGET"; then
11076   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11077 else
11078 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11079 for as_dir in $PATH
11080 do
11081   IFS=$as_save_IFS
11082   test -z "$as_dir" && as_dir=.
11083   for ac_exec_ext in '' $ac_executable_extensions; do
11084   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11085     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11086     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11087     break 2
11088   fi
11089 done
11090 done
11091
11092 fi
11093 fi
11094 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11095 if test -n "$STRIP_FOR_TARGET"; then
11096   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11097 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11098 else
11099   echo "$as_me:$LINENO: result: no" >&5
11100 echo "${ECHO_T}no" >&6
11101 fi
11102
11103   done
11104 fi
11105
11106 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11107   for ncn_progname in strip; do
11108     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11109 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11110     if test -x $with_build_time_tools/${ncn_progname}; then
11111       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11112       echo "$as_me:$LINENO: result: yes" >&5
11113 echo "${ECHO_T}yes" >&6
11114       break
11115     else
11116       echo "$as_me:$LINENO: result: no" >&5
11117 echo "${ECHO_T}no" >&6
11118     fi
11119   done
11120 fi
11121
11122 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11123   for ncn_progname in strip; do
11124     if test -n "$ncn_target_tool_prefix"; then
11125       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11126 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11127 echo "$as_me:$LINENO: checking for $ac_word" >&5
11128 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11129 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11130   echo $ECHO_N "(cached) $ECHO_C" >&6
11131 else
11132   if test -n "$STRIP_FOR_TARGET"; then
11133   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11134 else
11135 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11136 for as_dir in $PATH
11137 do
11138   IFS=$as_save_IFS
11139   test -z "$as_dir" && as_dir=.
11140   for ac_exec_ext in '' $ac_executable_extensions; do
11141   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11142     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11143     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11144     break 2
11145   fi
11146 done
11147 done
11148
11149 fi
11150 fi
11151 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11152 if test -n "$STRIP_FOR_TARGET"; then
11153   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11154 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11155 else
11156   echo "$as_me:$LINENO: result: no" >&5
11157 echo "${ECHO_T}no" >&6
11158 fi
11159
11160     fi
11161     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11162       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11163 set dummy ${ncn_progname}; ac_word=$2
11164 echo "$as_me:$LINENO: checking for $ac_word" >&5
11165 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11166 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11167   echo $ECHO_N "(cached) $ECHO_C" >&6
11168 else
11169   if test -n "$STRIP_FOR_TARGET"; then
11170   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11171 else
11172 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11173 for as_dir in $PATH
11174 do
11175   IFS=$as_save_IFS
11176   test -z "$as_dir" && as_dir=.
11177   for ac_exec_ext in '' $ac_executable_extensions; do
11178   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11179     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11180     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11181     break 2
11182   fi
11183 done
11184 done
11185
11186 fi
11187 fi
11188 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11189 if test -n "$STRIP_FOR_TARGET"; then
11190   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11191 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11192 else
11193   echo "$as_me:$LINENO: result: no" >&5
11194 echo "${ECHO_T}no" >&6
11195 fi
11196
11197     fi
11198     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11199   done
11200 fi
11201
11202 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11203   set dummy strip
11204   if test $build = $target ; then
11205     STRIP_FOR_TARGET="$2"
11206   else
11207     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11208   fi
11209 else
11210   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11211 fi
11212
11213 else
11214   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11215 fi
11216
11217
11218
11219
11220 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11221   if test -n "$with_build_time_tools"; then
11222     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11223 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11224     if test -x $with_build_time_tools/windres; then
11225       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11226       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11227       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11228 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11229     else
11230       echo "$as_me:$LINENO: result: no" >&5
11231 echo "${ECHO_T}no" >&6
11232     fi
11233   elif test $build != $host && test $have_gcc_for_target = yes; then
11234     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11235     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11236     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11237   fi
11238 fi
11239 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11240   # Extract the first word of "windres", so it can be a program name with args.
11241 set dummy windres; ac_word=$2
11242 echo "$as_me:$LINENO: checking for $ac_word" >&5
11243 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11244 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11245   echo $ECHO_N "(cached) $ECHO_C" >&6
11246 else
11247   case $WINDRES_FOR_TARGET in
11248   [\\/]* | ?:[\\/]*)
11249   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11250   ;;
11251   *)
11252   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11253 for as_dir in $gcc_cv_tool_dirs
11254 do
11255   IFS=$as_save_IFS
11256   test -z "$as_dir" && as_dir=.
11257   for ac_exec_ext in '' $ac_executable_extensions; do
11258   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11259     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11260     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11261     break 2
11262   fi
11263 done
11264 done
11265
11266   ;;
11267 esac
11268 fi
11269 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11270
11271 if test -n "$WINDRES_FOR_TARGET"; then
11272   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11273 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11274 else
11275   echo "$as_me:$LINENO: result: no" >&5
11276 echo "${ECHO_T}no" >&6
11277 fi
11278
11279 fi
11280 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11281
11282
11283 if test -n "$WINDRES_FOR_TARGET"; then
11284   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11285 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11286   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11287 fi
11288
11289 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11290   for ncn_progname in windres; do
11291     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11292 set dummy ${ncn_progname}; ac_word=$2
11293 echo "$as_me:$LINENO: checking for $ac_word" >&5
11294 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11295 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11296   echo $ECHO_N "(cached) $ECHO_C" >&6
11297 else
11298   if test -n "$WINDRES_FOR_TARGET"; then
11299   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11300 else
11301 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11302 for as_dir in $PATH
11303 do
11304   IFS=$as_save_IFS
11305   test -z "$as_dir" && as_dir=.
11306   for ac_exec_ext in '' $ac_executable_extensions; do
11307   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11308     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11309     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11310     break 2
11311   fi
11312 done
11313 done
11314
11315 fi
11316 fi
11317 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11318 if test -n "$WINDRES_FOR_TARGET"; then
11319   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11320 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11321 else
11322   echo "$as_me:$LINENO: result: no" >&5
11323 echo "${ECHO_T}no" >&6
11324 fi
11325
11326   done
11327 fi
11328
11329 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11330   for ncn_progname in windres; do
11331     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11332 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11333     if test -x $with_build_time_tools/${ncn_progname}; then
11334       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11335       echo "$as_me:$LINENO: result: yes" >&5
11336 echo "${ECHO_T}yes" >&6
11337       break
11338     else
11339       echo "$as_me:$LINENO: result: no" >&5
11340 echo "${ECHO_T}no" >&6
11341     fi
11342   done
11343 fi
11344
11345 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11346   for ncn_progname in windres; do
11347     if test -n "$ncn_target_tool_prefix"; then
11348       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11349 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11350 echo "$as_me:$LINENO: checking for $ac_word" >&5
11351 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11352 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11353   echo $ECHO_N "(cached) $ECHO_C" >&6
11354 else
11355   if test -n "$WINDRES_FOR_TARGET"; then
11356   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11357 else
11358 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11359 for as_dir in $PATH
11360 do
11361   IFS=$as_save_IFS
11362   test -z "$as_dir" && as_dir=.
11363   for ac_exec_ext in '' $ac_executable_extensions; do
11364   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11365     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11366     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11367     break 2
11368   fi
11369 done
11370 done
11371
11372 fi
11373 fi
11374 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11375 if test -n "$WINDRES_FOR_TARGET"; then
11376   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11377 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11378 else
11379   echo "$as_me:$LINENO: result: no" >&5
11380 echo "${ECHO_T}no" >&6
11381 fi
11382
11383     fi
11384     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11385       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11386 set dummy ${ncn_progname}; ac_word=$2
11387 echo "$as_me:$LINENO: checking for $ac_word" >&5
11388 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11389 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11390   echo $ECHO_N "(cached) $ECHO_C" >&6
11391 else
11392   if test -n "$WINDRES_FOR_TARGET"; then
11393   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11394 else
11395 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11396 for as_dir in $PATH
11397 do
11398   IFS=$as_save_IFS
11399   test -z "$as_dir" && as_dir=.
11400   for ac_exec_ext in '' $ac_executable_extensions; do
11401   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11402     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11403     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11404     break 2
11405   fi
11406 done
11407 done
11408
11409 fi
11410 fi
11411 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11412 if test -n "$WINDRES_FOR_TARGET"; then
11413   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11414 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11415 else
11416   echo "$as_me:$LINENO: result: no" >&5
11417 echo "${ECHO_T}no" >&6
11418 fi
11419
11420     fi
11421     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11422   done
11423 fi
11424
11425 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11426   set dummy windres
11427   if test $build = $target ; then
11428     WINDRES_FOR_TARGET="$2"
11429   else
11430     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11431   fi
11432 else
11433   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11434 fi
11435
11436 else
11437   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11438 fi
11439
11440
11441
11442
11443 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11444   if test -n "$with_build_time_tools"; then
11445     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11446 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11447     if test -x $with_build_time_tools/windmc; then
11448       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11449       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11450       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11451 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11452     else
11453       echo "$as_me:$LINENO: result: no" >&5
11454 echo "${ECHO_T}no" >&6
11455     fi
11456   elif test $build != $host && test $have_gcc_for_target = yes; then
11457     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11458     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11459     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11460   fi
11461 fi
11462 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11463   # Extract the first word of "windmc", so it can be a program name with args.
11464 set dummy windmc; ac_word=$2
11465 echo "$as_me:$LINENO: checking for $ac_word" >&5
11466 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11467 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11468   echo $ECHO_N "(cached) $ECHO_C" >&6
11469 else
11470   case $WINDMC_FOR_TARGET in
11471   [\\/]* | ?:[\\/]*)
11472   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11473   ;;
11474   *)
11475   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11476 for as_dir in $gcc_cv_tool_dirs
11477 do
11478   IFS=$as_save_IFS
11479   test -z "$as_dir" && as_dir=.
11480   for ac_exec_ext in '' $ac_executable_extensions; do
11481   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11482     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11483     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11484     break 2
11485   fi
11486 done
11487 done
11488
11489   ;;
11490 esac
11491 fi
11492 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11493
11494 if test -n "$WINDMC_FOR_TARGET"; then
11495   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11496 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11497 else
11498   echo "$as_me:$LINENO: result: no" >&5
11499 echo "${ECHO_T}no" >&6
11500 fi
11501
11502 fi
11503 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11504
11505
11506 if test -n "$WINDMC_FOR_TARGET"; then
11507   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11508 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11509   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11510 fi
11511
11512 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11513   for ncn_progname in windmc; do
11514     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11515 set dummy ${ncn_progname}; ac_word=$2
11516 echo "$as_me:$LINENO: checking for $ac_word" >&5
11517 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11518 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11519   echo $ECHO_N "(cached) $ECHO_C" >&6
11520 else
11521   if test -n "$WINDMC_FOR_TARGET"; then
11522   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11523 else
11524 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11525 for as_dir in $PATH
11526 do
11527   IFS=$as_save_IFS
11528   test -z "$as_dir" && as_dir=.
11529   for ac_exec_ext in '' $ac_executable_extensions; do
11530   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11531     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11532     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11533     break 2
11534   fi
11535 done
11536 done
11537
11538 fi
11539 fi
11540 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11541 if test -n "$WINDMC_FOR_TARGET"; then
11542   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11543 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11544 else
11545   echo "$as_me:$LINENO: result: no" >&5
11546 echo "${ECHO_T}no" >&6
11547 fi
11548
11549   done
11550 fi
11551
11552 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11553   for ncn_progname in windmc; do
11554     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11555 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11556     if test -x $with_build_time_tools/${ncn_progname}; then
11557       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11558       echo "$as_me:$LINENO: result: yes" >&5
11559 echo "${ECHO_T}yes" >&6
11560       break
11561     else
11562       echo "$as_me:$LINENO: result: no" >&5
11563 echo "${ECHO_T}no" >&6
11564     fi
11565   done
11566 fi
11567
11568 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11569   for ncn_progname in windmc; do
11570     if test -n "$ncn_target_tool_prefix"; then
11571       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11572 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11573 echo "$as_me:$LINENO: checking for $ac_word" >&5
11574 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11575 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11576   echo $ECHO_N "(cached) $ECHO_C" >&6
11577 else
11578   if test -n "$WINDMC_FOR_TARGET"; then
11579   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11580 else
11581 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11582 for as_dir in $PATH
11583 do
11584   IFS=$as_save_IFS
11585   test -z "$as_dir" && as_dir=.
11586   for ac_exec_ext in '' $ac_executable_extensions; do
11587   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11588     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11589     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11590     break 2
11591   fi
11592 done
11593 done
11594
11595 fi
11596 fi
11597 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11598 if test -n "$WINDMC_FOR_TARGET"; then
11599   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11600 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11601 else
11602   echo "$as_me:$LINENO: result: no" >&5
11603 echo "${ECHO_T}no" >&6
11604 fi
11605
11606     fi
11607     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11608       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11609 set dummy ${ncn_progname}; ac_word=$2
11610 echo "$as_me:$LINENO: checking for $ac_word" >&5
11611 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11612 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11613   echo $ECHO_N "(cached) $ECHO_C" >&6
11614 else
11615   if test -n "$WINDMC_FOR_TARGET"; then
11616   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11617 else
11618 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11619 for as_dir in $PATH
11620 do
11621   IFS=$as_save_IFS
11622   test -z "$as_dir" && as_dir=.
11623   for ac_exec_ext in '' $ac_executable_extensions; do
11624   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11625     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11626     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11627     break 2
11628   fi
11629 done
11630 done
11631
11632 fi
11633 fi
11634 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11635 if test -n "$WINDMC_FOR_TARGET"; then
11636   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11637 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11638 else
11639   echo "$as_me:$LINENO: result: no" >&5
11640 echo "${ECHO_T}no" >&6
11641 fi
11642
11643     fi
11644     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11645   done
11646 fi
11647
11648 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11649   set dummy windmc
11650   if test $build = $target ; then
11651     WINDMC_FOR_TARGET="$2"
11652   else
11653     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11654   fi
11655 else
11656   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11657 fi
11658
11659 else
11660   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11661 fi
11662
11663
11664 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11665
11666 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11667 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11668 if test "x${build}" != "x${host}" ; then
11669   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11670     # We already found the complete path
11671     ac_dir=`dirname $AR_FOR_TARGET`
11672     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11673 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11674   else
11675     # Canadian cross, just use what we found
11676     echo "$as_me:$LINENO: result: pre-installed" >&5
11677 echo "${ECHO_T}pre-installed" >&6
11678   fi
11679 else
11680   ok=yes
11681   case " ${configdirs} " in
11682     *" binutils "*) ;;
11683     *) ok=no ;;
11684   esac
11685
11686   if test $ok = yes; then
11687     # An in-tree tool is available and we can use it
11688     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11689     echo "$as_me:$LINENO: result: just compiled" >&5
11690 echo "${ECHO_T}just compiled" >&6
11691   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11692     # We already found the complete path
11693     ac_dir=`dirname $AR_FOR_TARGET`
11694     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11695 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11696   elif test "x$target" = "x$host"; then
11697     # We can use an host tool
11698     AR_FOR_TARGET='$(AR)'
11699     echo "$as_me:$LINENO: result: host tool" >&5
11700 echo "${ECHO_T}host tool" >&6
11701   else
11702     # We need a cross tool
11703     echo "$as_me:$LINENO: result: pre-installed" >&5
11704 echo "${ECHO_T}pre-installed" >&6
11705   fi
11706 fi
11707
11708 echo "$as_me:$LINENO: checking where to find the target as" >&5
11709 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11710 if test "x${build}" != "x${host}" ; then
11711   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11712     # We already found the complete path
11713     ac_dir=`dirname $AS_FOR_TARGET`
11714     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11715 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11716   else
11717     # Canadian cross, just use what we found
11718     echo "$as_me:$LINENO: result: pre-installed" >&5
11719 echo "${ECHO_T}pre-installed" >&6
11720   fi
11721 else
11722   ok=yes
11723   case " ${configdirs} " in
11724     *" gas "*) ;;
11725     *) ok=no ;;
11726   esac
11727
11728   if test $ok = yes; then
11729     # An in-tree tool is available and we can use it
11730     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11731     echo "$as_me:$LINENO: result: just compiled" >&5
11732 echo "${ECHO_T}just compiled" >&6
11733   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11734     # We already found the complete path
11735     ac_dir=`dirname $AS_FOR_TARGET`
11736     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11737 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11738   elif test "x$target" = "x$host"; then
11739     # We can use an host tool
11740     AS_FOR_TARGET='$(AS)'
11741     echo "$as_me:$LINENO: result: host tool" >&5
11742 echo "${ECHO_T}host tool" >&6
11743   else
11744     # We need a cross tool
11745     echo "$as_me:$LINENO: result: pre-installed" >&5
11746 echo "${ECHO_T}pre-installed" >&6
11747   fi
11748 fi
11749
11750 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11751 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11752 if test "x${build}" != "x${host}" ; then
11753   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11754     # We already found the complete path
11755     ac_dir=`dirname $CC_FOR_TARGET`
11756     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11757 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11758   else
11759     # Canadian cross, just use what we found
11760     echo "$as_me:$LINENO: result: pre-installed" >&5
11761 echo "${ECHO_T}pre-installed" >&6
11762   fi
11763 else
11764   ok=yes
11765   case " ${configdirs} " in
11766     *" gcc "*) ;;
11767     *) ok=no ;;
11768   esac
11769
11770   if test $ok = yes; then
11771     # An in-tree tool is available and we can use it
11772     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11773     echo "$as_me:$LINENO: result: just compiled" >&5
11774 echo "${ECHO_T}just compiled" >&6
11775   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11776     # We already found the complete path
11777     ac_dir=`dirname $CC_FOR_TARGET`
11778     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11779 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11780   elif test "x$target" = "x$host"; then
11781     # We can use an host tool
11782     CC_FOR_TARGET='$(CC)'
11783     echo "$as_me:$LINENO: result: host tool" >&5
11784 echo "${ECHO_T}host tool" >&6
11785   else
11786     # We need a cross tool
11787     echo "$as_me:$LINENO: result: pre-installed" >&5
11788 echo "${ECHO_T}pre-installed" >&6
11789   fi
11790 fi
11791
11792 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11793 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11794 if test "x${build}" != "x${host}" ; then
11795   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11796     # We already found the complete path
11797     ac_dir=`dirname $CXX_FOR_TARGET`
11798     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11799 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11800   else
11801     # Canadian cross, just use what we found
11802     echo "$as_me:$LINENO: result: pre-installed" >&5
11803 echo "${ECHO_T}pre-installed" >&6
11804   fi
11805 else
11806   ok=yes
11807   case " ${configdirs} " in
11808     *" gcc "*) ;;
11809     *) ok=no ;;
11810   esac
11811   case ,${enable_languages}, in
11812     *,c++,*) ;;
11813     *) ok=no ;;
11814   esac
11815   if test $ok = yes; then
11816     # An in-tree tool is available and we can use it
11817     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'
11818     echo "$as_me:$LINENO: result: just compiled" >&5
11819 echo "${ECHO_T}just compiled" >&6
11820   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11821     # We already found the complete path
11822     ac_dir=`dirname $CXX_FOR_TARGET`
11823     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11824 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11825   elif test "x$target" = "x$host"; then
11826     # We can use an host tool
11827     CXX_FOR_TARGET='$(CXX)'
11828     echo "$as_me:$LINENO: result: host tool" >&5
11829 echo "${ECHO_T}host tool" >&6
11830   else
11831     # We need a cross tool
11832     echo "$as_me:$LINENO: result: pre-installed" >&5
11833 echo "${ECHO_T}pre-installed" >&6
11834   fi
11835 fi
11836
11837 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11838 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11839 if test "x${build}" != "x${host}" ; then
11840   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11841     # We already found the complete path
11842     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11843     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11844 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11845   else
11846     # Canadian cross, just use what we found
11847     echo "$as_me:$LINENO: result: pre-installed" >&5
11848 echo "${ECHO_T}pre-installed" >&6
11849   fi
11850 else
11851   ok=yes
11852   case " ${configdirs} " in
11853     *" gcc "*) ;;
11854     *) ok=no ;;
11855   esac
11856   case ,${enable_languages}, in
11857     *,c++,*) ;;
11858     *) ok=no ;;
11859   esac
11860   if test $ok = yes; then
11861     # An in-tree tool is available and we can use it
11862     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'
11863     echo "$as_me:$LINENO: result: just compiled" >&5
11864 echo "${ECHO_T}just compiled" >&6
11865   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11866     # We already found the complete path
11867     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11868     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11869 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11870   elif test "x$target" = "x$host"; then
11871     # We can use an host tool
11872     RAW_CXX_FOR_TARGET='$(CXX)'
11873     echo "$as_me:$LINENO: result: host tool" >&5
11874 echo "${ECHO_T}host tool" >&6
11875   else
11876     # We need a cross tool
11877     echo "$as_me:$LINENO: result: pre-installed" >&5
11878 echo "${ECHO_T}pre-installed" >&6
11879   fi
11880 fi
11881
11882 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11883 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11884 if test "x${build}" != "x${host}" ; then
11885   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11886     # We already found the complete path
11887     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11888     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11889 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11890   else
11891     # Canadian cross, just use what we found
11892     echo "$as_me:$LINENO: result: pre-installed" >&5
11893 echo "${ECHO_T}pre-installed" >&6
11894   fi
11895 else
11896   ok=yes
11897   case " ${configdirs} " in
11898     *" binutils "*) ;;
11899     *) ok=no ;;
11900   esac
11901
11902   if test $ok = yes; then
11903     # An in-tree tool is available and we can use it
11904     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11905     echo "$as_me:$LINENO: result: just compiled" >&5
11906 echo "${ECHO_T}just compiled" >&6
11907   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11908     # We already found the complete path
11909     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11910     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11911 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11912   elif test "x$target" = "x$host"; then
11913     # We can use an host tool
11914     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11915     echo "$as_me:$LINENO: result: host tool" >&5
11916 echo "${ECHO_T}host tool" >&6
11917   else
11918     # We need a cross tool
11919     echo "$as_me:$LINENO: result: pre-installed" >&5
11920 echo "${ECHO_T}pre-installed" >&6
11921   fi
11922 fi
11923
11924 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11925 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11926 if test "x${build}" != "x${host}" ; then
11927   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11928     # We already found the complete path
11929     ac_dir=`dirname $GCC_FOR_TARGET`
11930     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11931 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11932   else
11933     # Canadian cross, just use what we found
11934     echo "$as_me:$LINENO: result: pre-installed" >&5
11935 echo "${ECHO_T}pre-installed" >&6
11936   fi
11937 else
11938   ok=yes
11939   case " ${configdirs} " in
11940     *" gcc "*) ;;
11941     *) ok=no ;;
11942   esac
11943
11944   if test $ok = yes; then
11945     # An in-tree tool is available and we can use it
11946     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11947     echo "$as_me:$LINENO: result: just compiled" >&5
11948 echo "${ECHO_T}just compiled" >&6
11949   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11950     # We already found the complete path
11951     ac_dir=`dirname $GCC_FOR_TARGET`
11952     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11953 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11954   elif test "x$target" = "x$host"; then
11955     # We can use an host tool
11956     GCC_FOR_TARGET='$()'
11957     echo "$as_me:$LINENO: result: host tool" >&5
11958 echo "${ECHO_T}host tool" >&6
11959   else
11960     # We need a cross tool
11961     echo "$as_me:$LINENO: result: pre-installed" >&5
11962 echo "${ECHO_T}pre-installed" >&6
11963   fi
11964 fi
11965
11966 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11967 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11968 if test "x${build}" != "x${host}" ; then
11969   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11970     # We already found the complete path
11971     ac_dir=`dirname $GCJ_FOR_TARGET`
11972     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11973 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11974   else
11975     # Canadian cross, just use what we found
11976     echo "$as_me:$LINENO: result: pre-installed" >&5
11977 echo "${ECHO_T}pre-installed" >&6
11978   fi
11979 else
11980   ok=yes
11981   case " ${configdirs} " in
11982     *" gcc "*) ;;
11983     *) ok=no ;;
11984   esac
11985   case ,${enable_languages}, in
11986     *,java,*) ;;
11987     *) ok=no ;;
11988   esac
11989   if test $ok = yes; then
11990     # An in-tree tool is available and we can use it
11991     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11992     echo "$as_me:$LINENO: result: just compiled" >&5
11993 echo "${ECHO_T}just compiled" >&6
11994   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11995     # We already found the complete path
11996     ac_dir=`dirname $GCJ_FOR_TARGET`
11997     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11998 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11999   elif test "x$target" = "x$host"; then
12000     # We can use an host tool
12001     GCJ_FOR_TARGET='$(GCJ)'
12002     echo "$as_me:$LINENO: result: host tool" >&5
12003 echo "${ECHO_T}host tool" >&6
12004   else
12005     # We need a cross tool
12006     echo "$as_me:$LINENO: result: pre-installed" >&5
12007 echo "${ECHO_T}pre-installed" >&6
12008   fi
12009 fi
12010
12011 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
12012 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
12013 if test "x${build}" != "x${host}" ; then
12014   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12015     # We already found the complete path
12016     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12017     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12018 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12019   else
12020     # Canadian cross, just use what we found
12021     echo "$as_me:$LINENO: result: pre-installed" >&5
12022 echo "${ECHO_T}pre-installed" >&6
12023   fi
12024 else
12025   ok=yes
12026   case " ${configdirs} " in
12027     *" gcc "*) ;;
12028     *) ok=no ;;
12029   esac
12030   case ,${enable_languages}, in
12031     *,fortran,*) ;;
12032     *) ok=no ;;
12033   esac
12034   if test $ok = yes; then
12035     # An in-tree tool is available and we can use it
12036     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12037     echo "$as_me:$LINENO: result: just compiled" >&5
12038 echo "${ECHO_T}just compiled" >&6
12039   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12040     # We already found the complete path
12041     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12042     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12043 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12044   elif test "x$target" = "x$host"; then
12045     # We can use an host tool
12046     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12047     echo "$as_me:$LINENO: result: host tool" >&5
12048 echo "${ECHO_T}host tool" >&6
12049   else
12050     # We need a cross tool
12051     echo "$as_me:$LINENO: result: pre-installed" >&5
12052 echo "${ECHO_T}pre-installed" >&6
12053   fi
12054 fi
12055
12056 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12057 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12058 if test "x${build}" != "x${host}" ; then
12059   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12060     # We already found the complete path
12061     ac_dir=`dirname $LD_FOR_TARGET`
12062     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12063 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12064   else
12065     # Canadian cross, just use what we found
12066     echo "$as_me:$LINENO: result: pre-installed" >&5
12067 echo "${ECHO_T}pre-installed" >&6
12068   fi
12069 else
12070   ok=yes
12071   case " ${configdirs} " in
12072     *" ld "*) ;;
12073     *) ok=no ;;
12074   esac
12075
12076   if test $ok = yes; then
12077     # An in-tree tool is available and we can use it
12078     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12079     echo "$as_me:$LINENO: result: just compiled" >&5
12080 echo "${ECHO_T}just compiled" >&6
12081   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12082     # We already found the complete path
12083     ac_dir=`dirname $LD_FOR_TARGET`
12084     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12085 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12086   elif test "x$target" = "x$host"; then
12087     # We can use an host tool
12088     LD_FOR_TARGET='$(LD)'
12089     echo "$as_me:$LINENO: result: host tool" >&5
12090 echo "${ECHO_T}host tool" >&6
12091   else
12092     # We need a cross tool
12093     echo "$as_me:$LINENO: result: pre-installed" >&5
12094 echo "${ECHO_T}pre-installed" >&6
12095   fi
12096 fi
12097
12098 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12099 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12100 if test "x${build}" != "x${host}" ; then
12101   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12102     # We already found the complete path
12103     ac_dir=`dirname $LIPO_FOR_TARGET`
12104     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12105 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12106   else
12107     # Canadian cross, just use what we found
12108     echo "$as_me:$LINENO: result: pre-installed" >&5
12109 echo "${ECHO_T}pre-installed" >&6
12110   fi
12111 else
12112   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12113     # We already found the complete path
12114     ac_dir=`dirname $LIPO_FOR_TARGET`
12115     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12116 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12117   elif test "x$target" = "x$host"; then
12118     # We can use an host tool
12119     LIPO_FOR_TARGET='$(LIPO)'
12120     echo "$as_me:$LINENO: result: host tool" >&5
12121 echo "${ECHO_T}host tool" >&6
12122   else
12123     # We need a cross tool
12124     echo "$as_me:$LINENO: result: pre-installed" >&5
12125 echo "${ECHO_T}pre-installed" >&6
12126   fi
12127 fi
12128
12129 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12130 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12131 if test "x${build}" != "x${host}" ; then
12132   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12133     # We already found the complete path
12134     ac_dir=`dirname $NM_FOR_TARGET`
12135     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12136 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12137   else
12138     # Canadian cross, just use what we found
12139     echo "$as_me:$LINENO: result: pre-installed" >&5
12140 echo "${ECHO_T}pre-installed" >&6
12141   fi
12142 else
12143   ok=yes
12144   case " ${configdirs} " in
12145     *" binutils "*) ;;
12146     *) ok=no ;;
12147   esac
12148
12149   if test $ok = yes; then
12150     # An in-tree tool is available and we can use it
12151     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12152     echo "$as_me:$LINENO: result: just compiled" >&5
12153 echo "${ECHO_T}just compiled" >&6
12154   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12155     # We already found the complete path
12156     ac_dir=`dirname $NM_FOR_TARGET`
12157     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12158 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12159   elif test "x$target" = "x$host"; then
12160     # We can use an host tool
12161     NM_FOR_TARGET='$(NM)'
12162     echo "$as_me:$LINENO: result: host tool" >&5
12163 echo "${ECHO_T}host tool" >&6
12164   else
12165     # We need a cross tool
12166     echo "$as_me:$LINENO: result: pre-installed" >&5
12167 echo "${ECHO_T}pre-installed" >&6
12168   fi
12169 fi
12170
12171 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12172 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12173 if test "x${build}" != "x${host}" ; then
12174   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12175     # We already found the complete path
12176     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12177     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12178 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12179   else
12180     # Canadian cross, just use what we found
12181     echo "$as_me:$LINENO: result: pre-installed" >&5
12182 echo "${ECHO_T}pre-installed" >&6
12183   fi
12184 else
12185   ok=yes
12186   case " ${configdirs} " in
12187     *" binutils "*) ;;
12188     *) ok=no ;;
12189   esac
12190
12191   if test $ok = yes; then
12192     # An in-tree tool is available and we can use it
12193     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12194     echo "$as_me:$LINENO: result: just compiled" >&5
12195 echo "${ECHO_T}just compiled" >&6
12196   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12197     # We already found the complete path
12198     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12199     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12200 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12201   elif test "x$target" = "x$host"; then
12202     # We can use an host tool
12203     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12204     echo "$as_me:$LINENO: result: host tool" >&5
12205 echo "${ECHO_T}host tool" >&6
12206   else
12207     # We need a cross tool
12208     echo "$as_me:$LINENO: result: pre-installed" >&5
12209 echo "${ECHO_T}pre-installed" >&6
12210   fi
12211 fi
12212
12213 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12214 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12215 if test "x${build}" != "x${host}" ; then
12216   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12217     # We already found the complete path
12218     ac_dir=`dirname $RANLIB_FOR_TARGET`
12219     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12220 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12221   else
12222     # Canadian cross, just use what we found
12223     echo "$as_me:$LINENO: result: pre-installed" >&5
12224 echo "${ECHO_T}pre-installed" >&6
12225   fi
12226 else
12227   ok=yes
12228   case " ${configdirs} " in
12229     *" binutils "*) ;;
12230     *) ok=no ;;
12231   esac
12232
12233   if test $ok = yes; then
12234     # An in-tree tool is available and we can use it
12235     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12236     echo "$as_me:$LINENO: result: just compiled" >&5
12237 echo "${ECHO_T}just compiled" >&6
12238   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12239     # We already found the complete path
12240     ac_dir=`dirname $RANLIB_FOR_TARGET`
12241     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12242 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12243   elif test "x$target" = "x$host"; then
12244     # We can use an host tool
12245     RANLIB_FOR_TARGET='$(RANLIB)'
12246     echo "$as_me:$LINENO: result: host tool" >&5
12247 echo "${ECHO_T}host tool" >&6
12248   else
12249     # We need a cross tool
12250     echo "$as_me:$LINENO: result: pre-installed" >&5
12251 echo "${ECHO_T}pre-installed" >&6
12252   fi
12253 fi
12254
12255 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12256 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12257 if test "x${build}" != "x${host}" ; then
12258   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12259     # We already found the complete path
12260     ac_dir=`dirname $STRIP_FOR_TARGET`
12261     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12262 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12263   else
12264     # Canadian cross, just use what we found
12265     echo "$as_me:$LINENO: result: pre-installed" >&5
12266 echo "${ECHO_T}pre-installed" >&6
12267   fi
12268 else
12269   ok=yes
12270   case " ${configdirs} " in
12271     *" binutils "*) ;;
12272     *) ok=no ;;
12273   esac
12274
12275   if test $ok = yes; then
12276     # An in-tree tool is available and we can use it
12277     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12278     echo "$as_me:$LINENO: result: just compiled" >&5
12279 echo "${ECHO_T}just compiled" >&6
12280   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12281     # We already found the complete path
12282     ac_dir=`dirname $STRIP_FOR_TARGET`
12283     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12284 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12285   elif test "x$target" = "x$host"; then
12286     # We can use an host tool
12287     STRIP_FOR_TARGET='$(STRIP)'
12288     echo "$as_me:$LINENO: result: host tool" >&5
12289 echo "${ECHO_T}host tool" >&6
12290   else
12291     # We need a cross tool
12292     echo "$as_me:$LINENO: result: pre-installed" >&5
12293 echo "${ECHO_T}pre-installed" >&6
12294   fi
12295 fi
12296
12297 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12298 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12299 if test "x${build}" != "x${host}" ; then
12300   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12301     # We already found the complete path
12302     ac_dir=`dirname $WINDRES_FOR_TARGET`
12303     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12304 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12305   else
12306     # Canadian cross, just use what we found
12307     echo "$as_me:$LINENO: result: pre-installed" >&5
12308 echo "${ECHO_T}pre-installed" >&6
12309   fi
12310 else
12311   ok=yes
12312   case " ${configdirs} " in
12313     *" binutils "*) ;;
12314     *) ok=no ;;
12315   esac
12316
12317   if test $ok = yes; then
12318     # An in-tree tool is available and we can use it
12319     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12320     echo "$as_me:$LINENO: result: just compiled" >&5
12321 echo "${ECHO_T}just compiled" >&6
12322   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12323     # We already found the complete path
12324     ac_dir=`dirname $WINDRES_FOR_TARGET`
12325     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12326 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12327   elif test "x$target" = "x$host"; then
12328     # We can use an host tool
12329     WINDRES_FOR_TARGET='$(WINDRES)'
12330     echo "$as_me:$LINENO: result: host tool" >&5
12331 echo "${ECHO_T}host tool" >&6
12332   else
12333     # We need a cross tool
12334     echo "$as_me:$LINENO: result: pre-installed" >&5
12335 echo "${ECHO_T}pre-installed" >&6
12336   fi
12337 fi
12338
12339 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12340 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12341 if test "x${build}" != "x${host}" ; then
12342   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12343     # We already found the complete path
12344     ac_dir=`dirname $WINDMC_FOR_TARGET`
12345     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12346 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12347   else
12348     # Canadian cross, just use what we found
12349     echo "$as_me:$LINENO: result: pre-installed" >&5
12350 echo "${ECHO_T}pre-installed" >&6
12351   fi
12352 else
12353   ok=yes
12354   case " ${configdirs} " in
12355     *" binutils "*) ;;
12356     *) ok=no ;;
12357   esac
12358
12359   if test $ok = yes; then
12360     # An in-tree tool is available and we can use it
12361     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12362     echo "$as_me:$LINENO: result: just compiled" >&5
12363 echo "${ECHO_T}just compiled" >&6
12364   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12365     # We already found the complete path
12366     ac_dir=`dirname $WINDMC_FOR_TARGET`
12367     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12368 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12369   elif test "x$target" = "x$host"; then
12370     # We can use an host tool
12371     WINDMC_FOR_TARGET='$(WINDMC)'
12372     echo "$as_me:$LINENO: result: host tool" >&5
12373 echo "${ECHO_T}host tool" >&6
12374   else
12375     # We need a cross tool
12376     echo "$as_me:$LINENO: result: pre-installed" >&5
12377 echo "${ECHO_T}pre-installed" >&6
12378   fi
12379 fi
12380
12381
12382
12383
12384
12385 # Certain tools may need extra flags.
12386 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12387 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12388 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12389
12390 # When building target libraries, except in a Canadian cross, we use
12391 # the same toolchain as the compiler we just built.
12392 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12393 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12394 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12395 if test $host = $build; then
12396   case " $configdirs " in
12397     *" gcc "*)
12398       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12399       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12400       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12401       ;;
12402   esac
12403 fi
12404
12405
12406
12407
12408
12409 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12410 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12411 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12412 if test "${enable_maintainer_mode+set}" = set; then
12413   enableval="$enable_maintainer_mode"
12414   USE_MAINTAINER_MODE=$enableval
12415 else
12416   USE_MAINTAINER_MODE=no
12417 fi;
12418 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12419 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12420
12421
12422 if test "$USE_MAINTAINER_MODE" = yes; then
12423   MAINTAINER_MODE_TRUE=
12424   MAINTAINER_MODE_FALSE='#'
12425 else
12426   MAINTAINER_MODE_TRUE='#'
12427   MAINTAINER_MODE_FALSE=
12428 fi
12429 MAINT=$MAINTAINER_MODE_TRUE
12430
12431 # ---------------------
12432 # GCC bootstrap support
12433 # ---------------------
12434
12435 # Stage specific cflags for build.
12436 stage1_cflags="-g"
12437 case $build in
12438   vax-*-*)
12439     case ${GCC} in
12440       yes) stage1_cflags="-g -Wa,-J" ;;
12441       *) stage1_cflags="-g -J" ;;
12442     esac ;;
12443 esac
12444
12445 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12446 if test "$GCC" = yes; then
12447   saved_CFLAGS="$CFLAGS"
12448
12449   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12450   CFLAGS="$CFLAGS -fkeep-inline-functions"
12451   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12452 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12453   cat >conftest.$ac_ext <<_ACEOF
12454 /* confdefs.h.  */
12455 _ACEOF
12456 cat confdefs.h >>conftest.$ac_ext
12457 cat >>conftest.$ac_ext <<_ACEOF
12458 /* end confdefs.h.  */
12459
12460 #if (__GNUC__ < 3) \
12461     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12462                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12463 #error http://gcc.gnu.org/PR29382
12464 #endif
12465
12466 int
12467 main ()
12468 {
12469
12470   ;
12471   return 0;
12472 }
12473 _ACEOF
12474 rm -f conftest.$ac_objext
12475 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12476   (eval $ac_compile) 2>conftest.er1
12477   ac_status=$?
12478   grep -v '^ *+' conftest.er1 >conftest.err
12479   rm -f conftest.er1
12480   cat conftest.err >&5
12481   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12482   (exit $ac_status); } &&
12483          { ac_try='test -z "$ac_c_werror_flag"
12484                          || test ! -s conftest.err'
12485   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12486   (eval $ac_try) 2>&5
12487   ac_status=$?
12488   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12489   (exit $ac_status); }; } &&
12490          { ac_try='test -s conftest.$ac_objext'
12491   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12492   (eval $ac_try) 2>&5
12493   ac_status=$?
12494   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12495   (exit $ac_status); }; }; then
12496   echo "$as_me:$LINENO: result: yes" >&5
12497 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12498 else
12499   echo "$as_me: failed program was:" >&5
12500 sed 's/^/| /' conftest.$ac_ext >&5
12501
12502 echo "$as_me:$LINENO: result: no" >&5
12503 echo "${ECHO_T}no" >&6
12504 fi
12505 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12506
12507   CFLAGS="$saved_CFLAGS"
12508 fi
12509
12510
12511
12512 # Enable --enable-checking in stage1 of the compiler.
12513 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12514 if test "${enable_stage1_checking+set}" = set; then
12515   enableval="$enable_stage1_checking"
12516   stage1_checking=--enable-checking=${enable_stage1_checking}
12517 else
12518   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12519   stage1_checking=--enable-checking=yes,types
12520 else
12521   stage1_checking=--enable-checking=$enable_checking,types
12522 fi
12523 fi;
12524
12525
12526 # Enable -Werror in bootstrap stage2 and later.
12527 # Check whether --enable-werror or --disable-werror was given.
12528 if test "${enable_werror+set}" = set; then
12529   enableval="$enable_werror"
12530
12531 else
12532   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12533   enable_werror=yes
12534 else
12535   enable_werror=no
12536 fi
12537 fi;
12538 case ${enable_werror} in
12539   yes) stage2_werror_flag="--enable-werror-always" ;;
12540   *) stage2_werror_flag="" ;;
12541 esac
12542
12543
12544 # Flags needed to enable html installing and building
12545
12546 # Check whether --with-datarootdir or --without-datarootdir was given.
12547 if test "${with_datarootdir+set}" = set; then
12548   withval="$with_datarootdir"
12549   datarootdir="\${prefix}/${withval}"
12550 else
12551   datarootdir="\${prefix}/share"
12552 fi;
12553
12554
12555 # Check whether --with-docdir or --without-docdir was given.
12556 if test "${with_docdir+set}" = set; then
12557   withval="$with_docdir"
12558   docdir="\${prefix}/${withval}"
12559 else
12560   docdir="\${datarootdir}/doc"
12561 fi;
12562
12563
12564 # Check whether --with-pdfdir or --without-pdfdir was given.
12565 if test "${with_pdfdir+set}" = set; then
12566   withval="$with_pdfdir"
12567   pdfdir="\${prefix}/${withval}"
12568 else
12569   pdfdir="\${docdir}"
12570 fi;
12571
12572
12573 # Check whether --with-htmldir or --without-htmldir was given.
12574 if test "${with_htmldir+set}" = set; then
12575   withval="$with_htmldir"
12576   htmldir="\${prefix}/${withval}"
12577 else
12578   htmldir="\${docdir}"
12579 fi;
12580
12581
12582
12583
12584
12585
12586           ac_config_files="$ac_config_files Makefile"
12587 cat >confcache <<\_ACEOF
12588 # This file is a shell script that caches the results of configure
12589 # tests run on this system so they can be shared between configure
12590 # scripts and configure runs, see configure's option --config-cache.
12591 # It is not useful on other systems.  If it contains results you don't
12592 # want to keep, you may remove or edit it.
12593 #
12594 # config.status only pays attention to the cache file if you give it
12595 # the --recheck option to rerun configure.
12596 #
12597 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12598 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12599 # following values.
12600
12601 _ACEOF
12602
12603 # The following way of writing the cache mishandles newlines in values,
12604 # but we know of no workaround that is simple, portable, and efficient.
12605 # So, don't put newlines in cache variables' values.
12606 # Ultrix sh set writes to stderr and can't be redirected directly,
12607 # and sets the high bit in the cache file unless we assign to the vars.
12608 {
12609   (set) 2>&1 |
12610     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12611     *ac_space=\ *)
12612       # `set' does not quote correctly, so add quotes (double-quote
12613       # substitution turns \\\\ into \\, and sed turns \\ into \).
12614       sed -n \
12615         "s/'/'\\\\''/g;
12616           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12617       ;;
12618     *)
12619       # `set' quotes correctly as required by POSIX, so do not add quotes.
12620       sed -n \
12621         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12622       ;;
12623     esac;
12624 } |
12625   sed '
12626      t clear
12627      : clear
12628      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12629      t end
12630      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12631      : end' >>confcache
12632 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12633   if test -w $cache_file; then
12634     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12635     cat confcache >$cache_file
12636   else
12637     echo "not updating unwritable cache $cache_file"
12638   fi
12639 fi
12640 rm -f confcache
12641
12642 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12643 # Let make expand exec_prefix.
12644 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12645
12646 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12647 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12648 # trailing colons and then remove the whole line if VPATH becomes empty
12649 # (actually we leave an empty line to preserve line numbers).
12650 if test "x$srcdir" = x.; then
12651   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12652 s/:*\$(srcdir):*/:/;
12653 s/:*\${srcdir}:*/:/;
12654 s/:*@srcdir@:*/:/;
12655 s/^\([^=]*=[     ]*\):*/\1/;
12656 s/:*$//;
12657 s/^[^=]*=[       ]*$//;
12658 }'
12659 fi
12660
12661 # Transform confdefs.h into DEFS.
12662 # Protect against shell expansion while executing Makefile rules.
12663 # Protect against Makefile macro expansion.
12664 #
12665 # If the first sed substitution is executed (which looks for macros that
12666 # take arguments), then we branch to the quote section.  Otherwise,
12667 # look for a macro that doesn't take arguments.
12668 cat >confdef2opt.sed <<\_ACEOF
12669 t clear
12670 : clear
12671 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12672 t quote
12673 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12674 t quote
12675 d
12676 : quote
12677 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12678 s,\[,\\&,g
12679 s,\],\\&,g
12680 s,\$,$$,g
12681 p
12682 _ACEOF
12683 # We use echo to avoid assuming a particular line-breaking character.
12684 # The extra dot is to prevent the shell from consuming trailing
12685 # line-breaks from the sub-command output.  A line-break within
12686 # single-quotes doesn't work because, if this script is created in a
12687 # platform that uses two characters for line-breaks (e.g., DOS), tr
12688 # would break.
12689 ac_LF_and_DOT=`echo; echo .`
12690 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12691 rm -f confdef2opt.sed
12692
12693
12694 ac_libobjs=
12695 ac_ltlibobjs=
12696 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12697   # 1. Remove the extension, and $U if already installed.
12698   ac_i=`echo "$ac_i" |
12699          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12700   # 2. Add them.
12701   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12702   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12703 done
12704 LIBOBJS=$ac_libobjs
12705
12706 LTLIBOBJS=$ac_ltlibobjs
12707
12708
12709
12710 : ${CONFIG_STATUS=./config.status}
12711 ac_clean_files_save=$ac_clean_files
12712 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12713 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12714 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12715 cat >$CONFIG_STATUS <<_ACEOF
12716 #! $SHELL
12717 # Generated by $as_me.
12718 # Run this file to recreate the current configuration.
12719 # Compiler output produced by configure, useful for debugging
12720 # configure, is in config.log if it exists.
12721
12722 debug=false
12723 ac_cs_recheck=false
12724 ac_cs_silent=false
12725 SHELL=\${CONFIG_SHELL-$SHELL}
12726 _ACEOF
12727
12728 cat >>$CONFIG_STATUS <<\_ACEOF
12729 ## --------------------- ##
12730 ## M4sh Initialization.  ##
12731 ## --------------------- ##
12732
12733 # Be Bourne compatible
12734 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12735   emulate sh
12736   NULLCMD=:
12737   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12738   # is contrary to our usage.  Disable this feature.
12739   alias -g '${1+"$@"}'='"$@"'
12740 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12741   set -o posix
12742 fi
12743 DUALCASE=1; export DUALCASE # for MKS sh
12744
12745 # Support unset when possible.
12746 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12747   as_unset=unset
12748 else
12749   as_unset=false
12750 fi
12751
12752
12753 # Work around bugs in pre-3.0 UWIN ksh.
12754 $as_unset ENV MAIL MAILPATH
12755 PS1='$ '
12756 PS2='> '
12757 PS4='+ '
12758
12759 # NLS nuisances.
12760 for as_var in \
12761   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12762   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12763   LC_TELEPHONE LC_TIME
12764 do
12765   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12766     eval $as_var=C; export $as_var
12767   else
12768     $as_unset $as_var
12769   fi
12770 done
12771
12772 # Required to use basename.
12773 if expr a : '\(a\)' >/dev/null 2>&1; then
12774   as_expr=expr
12775 else
12776   as_expr=false
12777 fi
12778
12779 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12780   as_basename=basename
12781 else
12782   as_basename=false
12783 fi
12784
12785
12786 # Name of the executable.
12787 as_me=`$as_basename "$0" ||
12788 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12789          X"$0" : 'X\(//\)$' \| \
12790          X"$0" : 'X\(/\)$' \| \
12791          .     : '\(.\)' 2>/dev/null ||
12792 echo X/"$0" |
12793     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12794           /^X\/\(\/\/\)$/{ s//\1/; q; }
12795           /^X\/\(\/\).*/{ s//\1/; q; }
12796           s/.*/./; q'`
12797
12798
12799 # PATH needs CR, and LINENO needs CR and PATH.
12800 # Avoid depending upon Character Ranges.
12801 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12802 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12803 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12804 as_cr_digits='0123456789'
12805 as_cr_alnum=$as_cr_Letters$as_cr_digits
12806
12807 # The user is always right.
12808 if test "${PATH_SEPARATOR+set}" != set; then
12809   echo "#! /bin/sh" >conf$$.sh
12810   echo  "exit 0"   >>conf$$.sh
12811   chmod +x conf$$.sh
12812   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12813     PATH_SEPARATOR=';'
12814   else
12815     PATH_SEPARATOR=:
12816   fi
12817   rm -f conf$$.sh
12818 fi
12819
12820
12821   as_lineno_1=$LINENO
12822   as_lineno_2=$LINENO
12823   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12824   test "x$as_lineno_1" != "x$as_lineno_2" &&
12825   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12826   # Find who we are.  Look in the path if we contain no path at all
12827   # relative or not.
12828   case $0 in
12829     *[\\/]* ) as_myself=$0 ;;
12830     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12831 for as_dir in $PATH
12832 do
12833   IFS=$as_save_IFS
12834   test -z "$as_dir" && as_dir=.
12835   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12836 done
12837
12838        ;;
12839   esac
12840   # We did not find ourselves, most probably we were run as `sh COMMAND'
12841   # in which case we are not to be found in the path.
12842   if test "x$as_myself" = x; then
12843     as_myself=$0
12844   fi
12845   if test ! -f "$as_myself"; then
12846     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12847 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12848    { (exit 1); exit 1; }; }
12849   fi
12850   case $CONFIG_SHELL in
12851   '')
12852     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12853 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12854 do
12855   IFS=$as_save_IFS
12856   test -z "$as_dir" && as_dir=.
12857   for as_base in sh bash ksh sh5; do
12858          case $as_dir in
12859          /*)
12860            if ("$as_dir/$as_base" -c '
12861   as_lineno_1=$LINENO
12862   as_lineno_2=$LINENO
12863   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12864   test "x$as_lineno_1" != "x$as_lineno_2" &&
12865   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12866              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12867              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12868              CONFIG_SHELL=$as_dir/$as_base
12869              export CONFIG_SHELL
12870              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12871            fi;;
12872          esac
12873        done
12874 done
12875 ;;
12876   esac
12877
12878   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12879   # uniformly replaced by the line number.  The first 'sed' inserts a
12880   # line-number line before each line; the second 'sed' does the real
12881   # work.  The second script uses 'N' to pair each line-number line
12882   # with the numbered line, and appends trailing '-' during
12883   # substitution so that $LINENO is not a special case at line end.
12884   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12885   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12886   sed '=' <$as_myself |
12887     sed '
12888       N
12889       s,$,-,
12890       : loop
12891       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12892       t loop
12893       s,-$,,
12894       s,^['$as_cr_digits']*\n,,
12895     ' >$as_me.lineno &&
12896   chmod +x $as_me.lineno ||
12897     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12898 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12899    { (exit 1); exit 1; }; }
12900
12901   # Don't try to exec as it changes $[0], causing all sort of problems
12902   # (the dirname of $[0] is not the place where we might find the
12903   # original and so on.  Autoconf is especially sensible to this).
12904   . ./$as_me.lineno
12905   # Exit status is that of the last command.
12906   exit
12907 }
12908
12909
12910 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12911   *c*,-n*) ECHO_N= ECHO_C='
12912 ' ECHO_T='      ' ;;
12913   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12914   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12915 esac
12916
12917 if expr a : '\(a\)' >/dev/null 2>&1; then
12918   as_expr=expr
12919 else
12920   as_expr=false
12921 fi
12922
12923 rm -f conf$$ conf$$.exe conf$$.file
12924 echo >conf$$.file
12925 if ln -s conf$$.file conf$$ 2>/dev/null; then
12926   # We could just check for DJGPP; but this test a) works b) is more generic
12927   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12928   if test -f conf$$.exe; then
12929     # Don't use ln at all; we don't have any links
12930     as_ln_s='cp -p'
12931   else
12932     as_ln_s='ln -s'
12933   fi
12934 elif ln conf$$.file conf$$ 2>/dev/null; then
12935   as_ln_s=ln
12936 else
12937   as_ln_s='cp -p'
12938 fi
12939 rm -f conf$$ conf$$.exe conf$$.file
12940
12941 if mkdir -p . 2>/dev/null; then
12942   as_mkdir_p=:
12943 else
12944   test -d ./-p && rmdir ./-p
12945   as_mkdir_p=false
12946 fi
12947
12948 as_executable_p="test -f"
12949
12950 # Sed expression to map a string onto a valid CPP name.
12951 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12952
12953 # Sed expression to map a string onto a valid variable name.
12954 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12955
12956
12957 # IFS
12958 # We need space, tab and new line, in precisely that order.
12959 as_nl='
12960 '
12961 IFS="   $as_nl"
12962
12963 # CDPATH.
12964 $as_unset CDPATH
12965
12966 exec 6>&1
12967
12968 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12969 # report actual input values of CONFIG_FILES etc. instead of their
12970 # values after options handling.  Logging --version etc. is OK.
12971 exec 5>>config.log
12972 {
12973   echo
12974   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12975 ## Running $as_me. ##
12976 _ASBOX
12977 } >&5
12978 cat >&5 <<_CSEOF
12979
12980 This file was extended by $as_me, which was
12981 generated by GNU Autoconf 2.59.  Invocation command line was
12982
12983   CONFIG_FILES    = $CONFIG_FILES
12984   CONFIG_HEADERS  = $CONFIG_HEADERS
12985   CONFIG_LINKS    = $CONFIG_LINKS
12986   CONFIG_COMMANDS = $CONFIG_COMMANDS
12987   $ $0 $@
12988
12989 _CSEOF
12990 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12991 echo >&5
12992 _ACEOF
12993
12994 # Files that config.status was made for.
12995 if test -n "$ac_config_files"; then
12996   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12997 fi
12998
12999 if test -n "$ac_config_headers"; then
13000   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
13001 fi
13002
13003 if test -n "$ac_config_links"; then
13004   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
13005 fi
13006
13007 if test -n "$ac_config_commands"; then
13008   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
13009 fi
13010
13011 cat >>$CONFIG_STATUS <<\_ACEOF
13012
13013 ac_cs_usage="\
13014 \`$as_me' instantiates files from templates according to the
13015 current configuration.
13016
13017 Usage: $0 [OPTIONS] [FILE]...
13018
13019   -h, --help       print this help, then exit
13020   -V, --version    print version number, then exit
13021   -q, --quiet      do not print progress messages
13022   -d, --debug      don't remove temporary files
13023       --recheck    update $as_me by reconfiguring in the same conditions
13024   --file=FILE[:TEMPLATE]
13025                    instantiate the configuration file FILE
13026
13027 Configuration files:
13028 $config_files
13029
13030 Report bugs to <bug-autoconf@gnu.org>."
13031 _ACEOF
13032
13033 cat >>$CONFIG_STATUS <<_ACEOF
13034 ac_cs_version="\\
13035 config.status
13036 configured by $0, generated by GNU Autoconf 2.59,
13037   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13038
13039 Copyright (C) 2003 Free Software Foundation, Inc.
13040 This config.status script is free software; the Free Software Foundation
13041 gives unlimited permission to copy, distribute and modify it."
13042 srcdir=$srcdir
13043 INSTALL="$INSTALL"
13044 _ACEOF
13045
13046 cat >>$CONFIG_STATUS <<\_ACEOF
13047 # If no file are specified by the user, then we need to provide default
13048 # value.  By we need to know if files were specified by the user.
13049 ac_need_defaults=:
13050 while test $# != 0
13051 do
13052   case $1 in
13053   --*=*)
13054     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13055     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13056     ac_shift=:
13057     ;;
13058   -*)
13059     ac_option=$1
13060     ac_optarg=$2
13061     ac_shift=shift
13062     ;;
13063   *) # This is not an option, so the user has probably given explicit
13064      # arguments.
13065      ac_option=$1
13066      ac_need_defaults=false;;
13067   esac
13068
13069   case $ac_option in
13070   # Handling of the options.
13071 _ACEOF
13072 cat >>$CONFIG_STATUS <<\_ACEOF
13073   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13074     ac_cs_recheck=: ;;
13075   --version | --vers* | -V )
13076     echo "$ac_cs_version"; exit 0 ;;
13077   --he | --h)
13078     # Conflict between --help and --header
13079     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13080 Try \`$0 --help' for more information." >&5
13081 echo "$as_me: error: ambiguous option: $1
13082 Try \`$0 --help' for more information." >&2;}
13083    { (exit 1); exit 1; }; };;
13084   --help | --hel | -h )
13085     echo "$ac_cs_usage"; exit 0 ;;
13086   --debug | --d* | -d )
13087     debug=: ;;
13088   --file | --fil | --fi | --f )
13089     $ac_shift
13090     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13091     ac_need_defaults=false;;
13092   --header | --heade | --head | --hea )
13093     $ac_shift
13094     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13095     ac_need_defaults=false;;
13096   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13097   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13098     ac_cs_silent=: ;;
13099
13100   # This is an error.
13101   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13102 Try \`$0 --help' for more information." >&5
13103 echo "$as_me: error: unrecognized option: $1
13104 Try \`$0 --help' for more information." >&2;}
13105    { (exit 1); exit 1; }; } ;;
13106
13107   *) ac_config_targets="$ac_config_targets $1" ;;
13108
13109   esac
13110   shift
13111 done
13112
13113 ac_configure_extra_args=
13114
13115 if $ac_cs_silent; then
13116   exec 6>/dev/null
13117   ac_configure_extra_args="$ac_configure_extra_args --silent"
13118 fi
13119
13120 _ACEOF
13121 cat >>$CONFIG_STATUS <<_ACEOF
13122 if \$ac_cs_recheck; then
13123   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13124   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13125 fi
13126
13127 _ACEOF
13128
13129
13130
13131
13132
13133 cat >>$CONFIG_STATUS <<\_ACEOF
13134 for ac_config_target in $ac_config_targets
13135 do
13136   case "$ac_config_target" in
13137   # Handling of arguments.
13138   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13139   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13140 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13141    { (exit 1); exit 1; }; };;
13142   esac
13143 done
13144
13145 # If the user did not use the arguments to specify the items to instantiate,
13146 # then the envvar interface is used.  Set only those that are not.
13147 # We use the long form for the default assignment because of an extremely
13148 # bizarre bug on SunOS 4.1.3.
13149 if $ac_need_defaults; then
13150   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13151 fi
13152
13153 # Have a temporary directory for convenience.  Make it in the build tree
13154 # simply because there is no reason to put it here, and in addition,
13155 # creating and moving files from /tmp can sometimes cause problems.
13156 # Create a temporary directory, and hook for its removal unless debugging.
13157 $debug ||
13158 {
13159   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13160   trap '{ (exit 1); exit 1; }' 1 2 13 15
13161 }
13162
13163 # Create a (secure) tmp directory for tmp files.
13164
13165 {
13166   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13167   test -n "$tmp" && test -d "$tmp"
13168 }  ||
13169 {
13170   tmp=./confstat$$-$RANDOM
13171   (umask 077 && mkdir $tmp)
13172 } ||
13173 {
13174    echo "$me: cannot create a temporary directory in ." >&2
13175    { (exit 1); exit 1; }
13176 }
13177
13178 _ACEOF
13179
13180 cat >>$CONFIG_STATUS <<_ACEOF
13181
13182 #
13183 # CONFIG_FILES section.
13184 #
13185
13186 # No need to generate the scripts if there are no CONFIG_FILES.
13187 # This happens for instance when ./config.status config.h
13188 if test -n "\$CONFIG_FILES"; then
13189   # Protect against being on the right side of a sed subst in config.status.
13190   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13191    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13192 s,@SHELL@,$SHELL,;t t
13193 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13194 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13195 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13196 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13197 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13198 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13199 s,@exec_prefix@,$exec_prefix,;t t
13200 s,@prefix@,$prefix,;t t
13201 s,@program_transform_name@,$program_transform_name,;t t
13202 s,@bindir@,$bindir,;t t
13203 s,@sbindir@,$sbindir,;t t
13204 s,@libexecdir@,$libexecdir,;t t
13205 s,@datadir@,$datadir,;t t
13206 s,@sysconfdir@,$sysconfdir,;t t
13207 s,@sharedstatedir@,$sharedstatedir,;t t
13208 s,@localstatedir@,$localstatedir,;t t
13209 s,@libdir@,$libdir,;t t
13210 s,@includedir@,$includedir,;t t
13211 s,@oldincludedir@,$oldincludedir,;t t
13212 s,@infodir@,$infodir,;t t
13213 s,@mandir@,$mandir,;t t
13214 s,@build_alias@,$build_alias,;t t
13215 s,@host_alias@,$host_alias,;t t
13216 s,@target_alias@,$target_alias,;t t
13217 s,@DEFS@,$DEFS,;t t
13218 s,@ECHO_C@,$ECHO_C,;t t
13219 s,@ECHO_N@,$ECHO_N,;t t
13220 s,@ECHO_T@,$ECHO_T,;t t
13221 s,@LIBS@,$LIBS,;t t
13222 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13223 s,@build@,$build,;t t
13224 s,@build_cpu@,$build_cpu,;t t
13225 s,@build_vendor@,$build_vendor,;t t
13226 s,@build_os@,$build_os,;t t
13227 s,@build_noncanonical@,$build_noncanonical,;t t
13228 s,@host_noncanonical@,$host_noncanonical,;t t
13229 s,@target_noncanonical@,$target_noncanonical,;t t
13230 s,@host@,$host,;t t
13231 s,@host_cpu@,$host_cpu,;t t
13232 s,@host_vendor@,$host_vendor,;t t
13233 s,@host_os@,$host_os,;t t
13234 s,@target@,$target,;t t
13235 s,@target_cpu@,$target_cpu,;t t
13236 s,@target_vendor@,$target_vendor,;t t
13237 s,@target_os@,$target_os,;t t
13238 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13239 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13240 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13241 s,@LN@,$LN,;t t
13242 s,@LN_S@,$LN_S,;t t
13243 s,@build_libsubdir@,$build_libsubdir,;t t
13244 s,@build_subdir@,$build_subdir,;t t
13245 s,@host_subdir@,$host_subdir,;t t
13246 s,@target_subdir@,$target_subdir,;t t
13247 s,@CC@,$CC,;t t
13248 s,@CFLAGS@,$CFLAGS,;t t
13249 s,@LDFLAGS@,$LDFLAGS,;t t
13250 s,@CPPFLAGS@,$CPPFLAGS,;t t
13251 s,@ac_ct_CC@,$ac_ct_CC,;t t
13252 s,@EXEEXT@,$EXEEXT,;t t
13253 s,@OBJEXT@,$OBJEXT,;t t
13254 s,@CXX@,$CXX,;t t
13255 s,@CXXFLAGS@,$CXXFLAGS,;t t
13256 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13257 s,@GNATBIND@,$GNATBIND,;t t
13258 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13259 s,@GNATMAKE@,$GNATMAKE,;t t
13260 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13261 s,@do_compare@,$do_compare,;t t
13262 s,@gmplibs@,$gmplibs,;t t
13263 s,@gmpinc@,$gmpinc,;t t
13264 s,@extra_mpfr_configure_flags@,$extra_mpfr_configure_flags,;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