configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S TOPLEVEL_CONFIGURE_ARGUMENTS build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET RPATH_ENVVAR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs 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
 278 # Initialize some variables set by options.
 279 ac_init_help=
 280 ac_init_version=false
 281 # The variables have the same names as the options, with
 282 # dashes changed to underlines.
 283 cache_file=/dev/null
 284 exec_prefix=NONE
 285 no_create=
 286 no_recursion=
 287 prefix=NONE
 288 program_prefix=NONE
 289 program_suffix=NONE
 290 program_transform_name=s,x,x,
 291 silent=
 292 site=
 293 srcdir=
 294 verbose=
 295 x_includes=NONE
 296 x_libraries=NONE
 297
 298 # Installation directory options.
 299 # These are left unexpanded so users can "make install exec_prefix=/foo"
 300 # and all the variables that are supposed to be based on exec_prefix
 301 # by default will actually change.
 302 # Use braces instead of parens because sh, perl, etc. also accept them.
 303 bindir='${exec_prefix}/bin'
 304 sbindir='${exec_prefix}/sbin'
 305 libexecdir='${exec_prefix}/libexec'
 306 datadir='${prefix}/share'
 307 sysconfdir='${prefix}/etc'
 308 sharedstatedir='${prefix}/com'
 309 localstatedir='${prefix}/var'
 310 libdir='${exec_prefix}/lib'
 311 includedir='${prefix}/include'
 312 oldincludedir='/usr/include'
 313 infodir='${prefix}/info'
 314 mandir='${prefix}/man'
 315
 316 ac_prev=
 317 for ac_option
 318 do
 319   # If the previous option needs an argument, assign it.
 320   if test -n "$ac_prev"; then
 321     eval "$ac_prev=\$ac_option"
 322     ac_prev=
 323     continue
 324   fi
 325
 326   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 327
 328   # Accept the important Cygnus configure options, so we can diagnose typos.
 329
 330   case $ac_option in
 331
 332   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 333     ac_prev=bindir ;;
 334   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 335     bindir=$ac_optarg ;;
 336
 337   -build | --build | --buil | --bui | --bu)
 338     ac_prev=build_alias ;;
 339   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 340     build_alias=$ac_optarg ;;
 341
 342   -cache-file | --cache-file | --cache-fil | --cache-fi \
 343   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 344     ac_prev=cache_file ;;
 345   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 346   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 347     cache_file=$ac_optarg ;;
 348
 349   --config-cache | -C)
 350     cache_file=config.cache ;;
 351
 352   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 353     ac_prev=datadir ;;
 354   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 355   | --da=*)
 356     datadir=$ac_optarg ;;
 357
 358   -disable-* | --disable-*)
 359     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 360     # Reject names that are not valid shell variable names.
 361     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 362       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 363    { (exit 1); exit 1; }; }
 364     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 365     eval "enable_$ac_feature=no" ;;
 366
 367   -enable-* | --enable-*)
 368     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 369     # Reject names that are not valid shell variable names.
 370     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 371       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 372    { (exit 1); exit 1; }; }
 373     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 374     case $ac_option in
 375       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 376       *) ac_optarg=yes ;;
 377     esac
 378     eval "enable_$ac_feature='$ac_optarg'" ;;
 379
 380   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 381   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 382   | --exec | --exe | --ex)
 383     ac_prev=exec_prefix ;;
 384   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 385   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 386   | --exec=* | --exe=* | --ex=*)
 387     exec_prefix=$ac_optarg ;;
 388
 389   -gas | --gas | --ga | --g)
 390     # Obsolete; use --with-gas.
 391     with_gas=yes ;;
 392
 393   -help | --help | --hel | --he | -h)
 394     ac_init_help=long ;;
 395   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 396     ac_init_help=recursive ;;
 397   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 398     ac_init_help=short ;;
 399
 400   -host | --host | --hos | --ho)
 401     ac_prev=host_alias ;;
 402   -host=* | --host=* | --hos=* | --ho=*)
 403     host_alias=$ac_optarg ;;
 404
 405   -includedir | --includedir | --includedi | --included | --include \
 406   | --includ | --inclu | --incl | --inc)
 407     ac_prev=includedir ;;
 408   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 409   | --includ=* | --inclu=* | --incl=* | --inc=*)
 410     includedir=$ac_optarg ;;
 411
 412   -infodir | --infodir | --infodi | --infod | --info | --inf)
 413     ac_prev=infodir ;;
 414   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 415     infodir=$ac_optarg ;;
 416
 417   -libdir | --libdir | --libdi | --libd)
 418     ac_prev=libdir ;;
 419   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 420     libdir=$ac_optarg ;;
 421
 422   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 423   | --libexe | --libex | --libe)
 424     ac_prev=libexecdir ;;
 425   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 426   | --libexe=* | --libex=* | --libe=*)
 427     libexecdir=$ac_optarg ;;
 428
 429   -localstatedir | --localstatedir | --localstatedi | --localstated \
 430   | --localstate | --localstat | --localsta | --localst \
 431   | --locals | --local | --loca | --loc | --lo)
 432     ac_prev=localstatedir ;;
 433   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 434   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 435   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 436     localstatedir=$ac_optarg ;;
 437
 438   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 439     ac_prev=mandir ;;
 440   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 441     mandir=$ac_optarg ;;
 442
 443   -nfp | --nfp | --nf)
 444     # Obsolete; use --without-fp.
 445     with_fp=no ;;
 446
 447   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 448   | --no-cr | --no-c | -n)
 449     no_create=yes ;;
 450
 451   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 452   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 453     no_recursion=yes ;;
 454
 455   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 456   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 457   | --oldin | --oldi | --old | --ol | --o)
 458     ac_prev=oldincludedir ;;
 459   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 460   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 461   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 462     oldincludedir=$ac_optarg ;;
 463
 464   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 465     ac_prev=prefix ;;
 466   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 467     prefix=$ac_optarg ;;
 468
 469   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 470   | --program-pre | --program-pr | --program-p)
 471     ac_prev=program_prefix ;;
 472   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 473   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 474     program_prefix=$ac_optarg ;;
 475
 476   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 477   | --program-suf | --program-su | --program-s)
 478     ac_prev=program_suffix ;;
 479   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 480   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 481     program_suffix=$ac_optarg ;;
 482
 483   -program-transform-name | --program-transform-name \
 484   | --program-transform-nam | --program-transform-na \
 485   | --program-transform-n | --program-transform- \
 486   | --program-transform | --program-transfor \
 487   | --program-transfo | --program-transf \
 488   | --program-trans | --program-tran \
 489   | --progr-tra | --program-tr | --program-t)
 490     ac_prev=program_transform_name ;;
 491   -program-transform-name=* | --program-transform-name=* \
 492   | --program-transform-nam=* | --program-transform-na=* \
 493   | --program-transform-n=* | --program-transform-=* \
 494   | --program-transform=* | --program-transfor=* \
 495   | --program-transfo=* | --program-transf=* \
 496   | --program-trans=* | --program-tran=* \
 497   | --progr-tra=* | --program-tr=* | --program-t=*)
 498     program_transform_name=$ac_optarg ;;
 499
 500   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 501   | -silent | --silent | --silen | --sile | --sil)
 502     silent=yes ;;
 503
 504   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 505     ac_prev=sbindir ;;
 506   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 507   | --sbi=* | --sb=*)
 508     sbindir=$ac_optarg ;;
 509
 510   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 511   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 512   | --sharedst | --shareds | --shared | --share | --shar \
 513   | --sha | --sh)
 514     ac_prev=sharedstatedir ;;
 515   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 516   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 517   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 518   | --sha=* | --sh=*)
 519     sharedstatedir=$ac_optarg ;;
 520
 521   -site | --site | --sit)
 522     ac_prev=site ;;
 523   -site=* | --site=* | --sit=*)
 524     site=$ac_optarg ;;
 525
 526   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 527     ac_prev=srcdir ;;
 528   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 529     srcdir=$ac_optarg ;;
 530
 531   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 532   | --syscon | --sysco | --sysc | --sys | --sy)
 533     ac_prev=sysconfdir ;;
 534   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 535   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 536     sysconfdir=$ac_optarg ;;
 537
 538   -target | --target | --targe | --targ | --tar | --ta | --t)
 539     ac_prev=target_alias ;;
 540   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 541     target_alias=$ac_optarg ;;
 542
 543   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 544     verbose=yes ;;
 545
 546   -version | --version | --versio | --versi | --vers | -V)
 547     ac_init_version=: ;;
 548
 549   -with-* | --with-*)
 550     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 551     # Reject names that are not valid shell variable names.
 552     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 553       { echo "$as_me: error: invalid package name: $ac_package" >&2
 554    { (exit 1); exit 1; }; }
 555     ac_package=`echo $ac_package| sed 's/-/_/g'`
 556     case $ac_option in
 557       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 558       *) ac_optarg=yes ;;
 559     esac
 560     eval "with_$ac_package='$ac_optarg'" ;;
 561
 562   -without-* | --without-*)
 563     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 564     # Reject names that are not valid shell variable names.
 565     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 566       { echo "$as_me: error: invalid package name: $ac_package" >&2
 567    { (exit 1); exit 1; }; }
 568     ac_package=`echo $ac_package | sed 's/-/_/g'`
 569     eval "with_$ac_package=no" ;;
 570
 571   --x)
 572     # Obsolete; use --with-x.
 573     with_x=yes ;;
 574
 575   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 576   | --x-incl | --x-inc | --x-in | --x-i)
 577     ac_prev=x_includes ;;
 578   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 579   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 580     x_includes=$ac_optarg ;;
 581
 582   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 583   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 584     ac_prev=x_libraries ;;
 585   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 586   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 587     x_libraries=$ac_optarg ;;
 588
 589   -*) { echo "$as_me: error: unrecognized option: $ac_option
 590 Try \`$0 --help' for more information." >&2
 591    { (exit 1); exit 1; }; }
 592     ;;
 593
 594   *=*)
 595     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 596     # Reject names that are not valid shell variable names.
 597     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 598       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 599    { (exit 1); exit 1; }; }
 600     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 601     eval "$ac_envvar='$ac_optarg'"
 602     export $ac_envvar ;;
 603
 604   *)
 605     # FIXME: should be removed in autoconf 3.0.
 606     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 607     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 608       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 609     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 610     ;;
 611
 612   esac
 613 done
 614
 615 if test -n "$ac_prev"; then
 616   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 617   { echo "$as_me: error: missing argument to $ac_option" >&2
 618    { (exit 1); exit 1; }; }
 619 fi
 620
 621 # Be sure to have absolute paths.
 622 for ac_var in exec_prefix prefix
 623 do
 624   eval ac_val=$`echo $ac_var`
 625   case $ac_val in
 626     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 627     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 628    { (exit 1); exit 1; }; };;
 629   esac
 630 done
 631
 632 # Be sure to have absolute paths.
 633 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 634               localstatedir libdir includedir oldincludedir infodir mandir
 635 do
 636   eval ac_val=$`echo $ac_var`
 637   case $ac_val in
 638     [\\/$]* | ?:[\\/]* ) ;;
 639     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 640    { (exit 1); exit 1; }; };;
 641   esac
 642 done
 643
 644 # There might be people who depend on the old broken behavior: `$host'
 645 # used to hold the argument of --host etc.
 646 # FIXME: To remove some day.
 647 build=$build_alias
 648 host=$host_alias
 649 target=$target_alias
 650
 651 # FIXME: To remove some day.
 652 if test "x$host_alias" != x; then
 653   if test "x$build_alias" = x; then
 654     cross_compiling=maybe
 655     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 656     If a cross compiler is detected then cross compile mode will be used." >&2
 657   elif test "x$build_alias" != "x$host_alias"; then
 658     cross_compiling=yes
 659   fi
 660 fi
 661
 662 ac_tool_prefix=
 663 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 664
 665 test "$silent" = yes && exec 6>/dev/null
 666
 667
 668 # Find the source files, if location was not specified.
 669 if test -z "$srcdir"; then
 670   ac_srcdir_defaulted=yes
 671   # Try the directory containing this script, then its parent.
 672   ac_confdir=`(dirname "$0") 2>/dev/null ||
 673 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 674          X"$0" : 'X\(//\)[^/]' \| \
 675          X"$0" : 'X\(//\)$' \| \
 676          X"$0" : 'X\(/\)' \| \
 677          .     : '\(.\)' 2>/dev/null ||
 678 echo X"$0" |
 679     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 680           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 681           /^X\(\/\/\)$/{ s//\1/; q; }
 682           /^X\(\/\).*/{ s//\1/; q; }
 683           s/.*/./; q'`
 684   srcdir=$ac_confdir
 685   if test ! -r $srcdir/$ac_unique_file; then
 686     srcdir=..
 687   fi
 688 else
 689   ac_srcdir_defaulted=no
 690 fi
 691 if test ! -r $srcdir/$ac_unique_file; then
 692   if test "$ac_srcdir_defaulted" = yes; then
 693     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 694    { (exit 1); exit 1; }; }
 695   else
 696     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 697    { (exit 1); exit 1; }; }
 698   fi
 699 fi
 700 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 701   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 702    { (exit 1); exit 1; }; }
 703 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 704 ac_env_build_alias_set=${build_alias+set}
 705 ac_env_build_alias_value=$build_alias
 706 ac_cv_env_build_alias_set=${build_alias+set}
 707 ac_cv_env_build_alias_value=$build_alias
 708 ac_env_host_alias_set=${host_alias+set}
 709 ac_env_host_alias_value=$host_alias
 710 ac_cv_env_host_alias_set=${host_alias+set}
 711 ac_cv_env_host_alias_value=$host_alias
 712 ac_env_target_alias_set=${target_alias+set}
 713 ac_env_target_alias_value=$target_alias
 714 ac_cv_env_target_alias_set=${target_alias+set}
 715 ac_cv_env_target_alias_value=$target_alias
 716 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 717
 718 ac_env_CC_set=${CC+set}
 719 ac_env_CC_value=$CC
 720 ac_cv_env_CC_set=${CC+set}
 721 ac_cv_env_CC_value=$CC
 722 ac_env_CFLAGS_set=${CFLAGS+set}
 723 ac_env_CFLAGS_value=$CFLAGS
 724 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 725 ac_cv_env_CFLAGS_value=$CFLAGS
 726 ac_env_LDFLAGS_set=${LDFLAGS+set}
 727 ac_env_LDFLAGS_value=$LDFLAGS
 728 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 729 ac_cv_env_LDFLAGS_value=$LDFLAGS
 730 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 731 ac_env_CPPFLAGS_value=$CPPFLAGS
 732 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 733 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 734 ac_env_CXX_set=${CXX+set}
 735 ac_env_CXX_value=$CXX
 736 ac_cv_env_CXX_set=${CXX+set}
 737 ac_cv_env_CXX_value=$CXX
 738 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 739 ac_env_CXXFLAGS_value=$CXXFLAGS
 740 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 741 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 742 ac_env_AR_set=${AR+set}
 743 ac_env_AR_value=$AR
 744 ac_cv_env_AR_set=${AR+set}
 745 ac_cv_env_AR_value=$AR
 746 ac_env_AS_set=${AS+set}
 747 ac_env_AS_value=$AS
 748 ac_cv_env_AS_set=${AS+set}
 749 ac_cv_env_AS_value=$AS
 750 ac_env_DLLTOOL_set=${DLLTOOL+set}
 751 ac_env_DLLTOOL_value=$DLLTOOL
 752 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 753 ac_cv_env_DLLTOOL_value=$DLLTOOL
 754 ac_env_LD_set=${LD+set}
 755 ac_env_LD_value=$LD
 756 ac_cv_env_LD_set=${LD+set}
 757 ac_cv_env_LD_value=$LD
 758 ac_env_LIPO_set=${LIPO+set}
 759 ac_env_LIPO_value=$LIPO
 760 ac_cv_env_LIPO_set=${LIPO+set}
 761 ac_cv_env_LIPO_value=$LIPO
 762 ac_env_NM_set=${NM+set}
 763 ac_env_NM_value=$NM
 764 ac_cv_env_NM_set=${NM+set}
 765 ac_cv_env_NM_value=$NM
 766 ac_env_RANLIB_set=${RANLIB+set}
 767 ac_env_RANLIB_value=$RANLIB
 768 ac_cv_env_RANLIB_set=${RANLIB+set}
 769 ac_cv_env_RANLIB_value=$RANLIB
 770 ac_env_STRIP_set=${STRIP+set}
 771 ac_env_STRIP_value=$STRIP
 772 ac_cv_env_STRIP_set=${STRIP+set}
 773 ac_cv_env_STRIP_value=$STRIP
 774 ac_env_WINDRES_set=${WINDRES+set}
 775 ac_env_WINDRES_value=$WINDRES
 776 ac_cv_env_WINDRES_set=${WINDRES+set}
 777 ac_cv_env_WINDRES_value=$WINDRES
 778 ac_env_WINDMC_set=${WINDMC+set}
 779 ac_env_WINDMC_value=$WINDMC
 780 ac_cv_env_WINDMC_set=${WINDMC+set}
 781 ac_cv_env_WINDMC_value=$WINDMC
 782 ac_env_OBJCOPY_set=${OBJCOPY+set}
 783 ac_env_OBJCOPY_value=$OBJCOPY
 784 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 785 ac_cv_env_OBJCOPY_value=$OBJCOPY
 786 ac_env_OBJDUMP_set=${OBJDUMP+set}
 787 ac_env_OBJDUMP_value=$OBJDUMP
 788 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 789 ac_cv_env_OBJDUMP_value=$OBJDUMP
 790 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 791 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 792 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 793 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 794 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 795 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 796 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 797 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 798 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 799 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 800 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 801 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 802 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 803 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 804 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 805 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 806 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 807 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 808 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 809 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 810 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 811 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 812 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 813 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 814 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 815 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 816 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 817 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 818 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 819 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 820 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 821 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 822 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 823 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 824 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 825 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 826 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 827 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 828 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 829 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 830 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 831 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 832 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 833 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 834 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 835 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 836 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 837 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 838 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 839 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 840 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 841 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 842 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 843 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 844 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 845 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 846 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 847 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 848 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 849 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 850 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 851 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 852 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 853 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 854
 855 #
 856 # Report the --help message.
 857 #
 858 if test "$ac_init_help" = "long"; then
 859   # Omit some internal or obsolete options to make the list less imposing.
 860   # This message is too long to be a string in the A/UX 3.1 sh.
 861   cat <<_ACEOF
 862 \`configure' configures this package to adapt to many kinds of systems.
 863
 864 Usage: $0 [OPTION]... [VAR=VALUE]...
 865
 866 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 867 VAR=VALUE.  See below for descriptions of some of the useful variables.
 868
 869 Defaults for the options are specified in brackets.
 870
 871 Configuration:
 872   -h, --help              display this help and exit
 873       --help=short        display options specific to this package
 874       --help=recursive    display the short help of all the included packages
 875   -V, --version           display version information and exit
 876   -q, --quiet, --silent   do not print \`checking...' messages
 877       --cache-file=FILE   cache test results in FILE [disabled]
 878   -C, --config-cache      alias for \`--cache-file=config.cache'
 879   -n, --no-create         do not create output files
 880       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 881
 882 _ACEOF
 883
 884   cat <<_ACEOF
 885 Installation directories:
 886   --prefix=PREFIX         install architecture-independent files in PREFIX
 887                           [$ac_default_prefix]
 888   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 889                           [PREFIX]
 890
 891 By default, \`make install' will install all the files in
 892 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 893 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 894 for instance \`--prefix=\$HOME'.
 895
 896 For better control, use the options below.
 897
 898 Fine tuning of the installation directories:
 899   --bindir=DIR           user executables [EPREFIX/bin]
 900   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 901   --libexecdir=DIR       program executables [EPREFIX/libexec]
 902   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 903   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 904   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 905   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 906   --libdir=DIR           object code libraries [EPREFIX/lib]
 907   --includedir=DIR       C header files [PREFIX/include]
 908   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 909   --infodir=DIR          info documentation [PREFIX/info]
 910   --mandir=DIR           man documentation [PREFIX/man]
 911 _ACEOF
 912
 913   cat <<\_ACEOF
 914
 915 Program names:
 916   --program-prefix=PREFIX            prepend PREFIX to installed program names
 917   --program-suffix=SUFFIX            append SUFFIX to installed program names
 918   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 919
 920 System types:
 921   --build=BUILD     configure for building on BUILD [guessed]
 922   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 923   --target=TARGET   configure for building compilers for TARGET [HOST]
 924 _ACEOF
 925 fi
 926
 927 if test -n "$ac_init_help"; then
 928
 929   cat <<\_ACEOF
 930
 931 Optional Features:
 932   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 933   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 934   --enable-libada         build libada directory
 935   --enable-libssp         build libssp directory
 936   --enable-stage1-languages[=all]   choose additional languages to build during
 937                           stage1.  Mostly useful for compiler development.
 938   --enable-objc-gc        enable use of Boehm's garbage collector with the
 939                           GNU Objective-C runtime
 940   --enable-bootstrap      enable bootstrapping [yes if native build]
 941   --enable-serial-[{host,target,build}-]configure
 942                           force sequential configuration of
 943                           sub-packages for the host, target or build
 944                           machine, or all sub-packages
 945   --enable-maintainer-mode enable make rules and dependencies not useful
 946                           (and sometimes confusing) to the casual installer
 947   --enable-stage1-checking[=all]   choose additional checking for stage1
 948                           of the compiler
 949   --enable-werror         enable -Werror in bootstrap stage2 and later
 950
 951 Optional Packages:
 952   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 953   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 954   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 955   --with-mpfr-dir=PATH    this option has been REMOVED
 956   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 957                           Equivalent to --with-mpfr-include=PATH/include
 958                           plus --with-mpfr-lib=PATH/lib
 959   --with-mpfr-include=PATH
 960                           specify directory for installed MPFR include files
 961   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 962   --with-gmp-dir=PATH     this option has been REMOVED
 963   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 964                           Equivalent to --with-gmp-include=PATH/include
 965                           plus --with-gmp-lib=PATH/lib
 966   --with-gmp-include=PATH specify directory for installed GMP include files
 967   --with-gmp-lib=PATH     specify directory for the installed GMP library
 968   --with-build-sysroot=SYSROOT
 969                           use sysroot as the system root during the build
 970   --with-debug-prefix-map='A=B C=D ...'
 971                              map A to B, C to D ... in debug information
 972   --with-build-time-tools=PATH
 973                           use given path to find target tools during the build
 974   --with-datarootdir      use datarootdir as the data root directory.
 975   --with-docdir           install documentation in this directory.
 976   --with-pdfdir           install pdf in this directory.
 977   --with-htmldir          install html in this directory.
 978
 979 Some influential environment variables:
 980   CC          C compiler command
 981   CFLAGS      C compiler flags
 982   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 983               nonstandard directory <lib dir>
 984   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 985               headers in a nonstandard directory <include dir>
 986   CXX         C++ compiler command
 987   CXXFLAGS    C++ compiler flags
 988   AR          AR for the host
 989   AS          AS for the host
 990   DLLTOOL     DLLTOOL for the host
 991   LD          LD for the host
 992   LIPO        LIPO for the host
 993   NM          NM for the host
 994   RANLIB      RANLIB for the host
 995   STRIP       STRIP for the host
 996   WINDRES     WINDRES for the host
 997   WINDMC      WINDMC for the host
 998   OBJCOPY     OBJCOPY for the host
 999   OBJDUMP     OBJDUMP for the host
1000   CC_FOR_TARGET
1001               CC for the target
1002   CXX_FOR_TARGET
1003               CXX for the target
1004   GCC_FOR_TARGET
1005               GCC for the target
1006   GCJ_FOR_TARGET
1007               GCJ for the target
1008   GFORTRAN_FOR_TARGET
1009               GFORTRAN for the target
1010   AR_FOR_TARGET
1011               AR for the target
1012   AS_FOR_TARGET
1013               AS for the target
1014   DLLTOOL_FOR_TARGET
1015               DLLTOOL for the target
1016   LD_FOR_TARGET
1017               LD for the target
1018   LIPO_FOR_TARGET
1019               LIPO for the target
1020   NM_FOR_TARGET
1021               NM for the target
1022   OBJDUMP_FOR_TARGET
1023               OBJDUMP for the target
1024   RANLIB_FOR_TARGET
1025               RANLIB for the target
1026   STRIP_FOR_TARGET
1027               STRIP for the target
1028   WINDRES_FOR_TARGET
1029               WINDRES for the target
1030   WINDMC_FOR_TARGET
1031               WINDMC for the target
1032
1033 Use these variables to override the choices made by `configure' or to help
1034 it to find libraries and programs with nonstandard names/locations.
1035
1036 _ACEOF
1037 fi
1038
1039 if test "$ac_init_help" = "recursive"; then
1040   # If there are subdirs, report their specific --help.
1041   ac_popdir=`pwd`
1042   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1043     test -d $ac_dir || continue
1044     ac_builddir=.
1045
1046 if test "$ac_dir" != .; then
1047   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1048   # A "../" for each directory in $ac_dir_suffix.
1049   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1050 else
1051   ac_dir_suffix= ac_top_builddir=
1052 fi
1053
1054 case $srcdir in
1055   .)  # No --srcdir option.  We are building in place.
1056     ac_srcdir=.
1057     if test -z "$ac_top_builddir"; then
1058        ac_top_srcdir=.
1059     else
1060        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1061     fi ;;
1062   [\\/]* | ?:[\\/]* )  # Absolute path.
1063     ac_srcdir=$srcdir$ac_dir_suffix;
1064     ac_top_srcdir=$srcdir ;;
1065   *) # Relative path.
1066     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1067     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1068 esac
1069
1070 # Do not use `cd foo && pwd` to compute absolute paths, because
1071 # the directories may not exist.
1072 case `pwd` in
1073 .) ac_abs_builddir="$ac_dir";;
1074 *)
1075   case "$ac_dir" in
1076   .) ac_abs_builddir=`pwd`;;
1077   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1078   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1079   esac;;
1080 esac
1081 case $ac_abs_builddir in
1082 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1083 *)
1084   case ${ac_top_builddir}. in
1085   .) ac_abs_top_builddir=$ac_abs_builddir;;
1086   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1087   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1088   esac;;
1089 esac
1090 case $ac_abs_builddir in
1091 .) ac_abs_srcdir=$ac_srcdir;;
1092 *)
1093   case $ac_srcdir in
1094   .) ac_abs_srcdir=$ac_abs_builddir;;
1095   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1096   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1097   esac;;
1098 esac
1099 case $ac_abs_builddir in
1100 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1101 *)
1102   case $ac_top_srcdir in
1103   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1104   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1105   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1106   esac;;
1107 esac
1108
1109     cd $ac_dir
1110     # Check for guested configure; otherwise get Cygnus style configure.
1111     if test -f $ac_srcdir/configure.gnu; then
1112       echo
1113       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1114     elif test -f $ac_srcdir/configure; then
1115       echo
1116       $SHELL $ac_srcdir/configure  --help=recursive
1117     elif test -f $ac_srcdir/configure.ac ||
1118            test -f $ac_srcdir/configure.in; then
1119       echo
1120       $ac_configure --help
1121     else
1122       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1123     fi
1124     cd $ac_popdir
1125   done
1126 fi
1127
1128 test -n "$ac_init_help" && exit 0
1129 if $ac_init_version; then
1130   cat <<\_ACEOF
1131
1132 Copyright (C) 2003 Free Software Foundation, Inc.
1133 This configure script is free software; the Free Software Foundation
1134 gives unlimited permission to copy, distribute and modify it.
1135 _ACEOF
1136   exit 0
1137 fi
1138 exec 5>config.log
1139 cat >&5 <<_ACEOF
1140 This file contains any messages produced by compilers while
1141 running configure, to aid debugging if configure makes a mistake.
1142
1143 It was created by $as_me, which was
1144 generated by GNU Autoconf 2.59.  Invocation command line was
1145
1146   $ $0 $@
1147
1148 _ACEOF
1149 {
1150 cat <<_ASUNAME
1151 ## --------- ##
1152 ## Platform. ##
1153 ## --------- ##
1154
1155 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1156 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1157 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1158 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1159 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1160
1161 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1162 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1163
1164 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1165 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1166 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1167 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1168 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1169 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1170 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1171
1172 _ASUNAME
1173
1174 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1175 for as_dir in $PATH
1176 do
1177   IFS=$as_save_IFS
1178   test -z "$as_dir" && as_dir=.
1179   echo "PATH: $as_dir"
1180 done
1181
1182 } >&5
1183
1184 cat >&5 <<_ACEOF
1185
1186
1187 ## ----------- ##
1188 ## Core tests. ##
1189 ## ----------- ##
1190
1191 _ACEOF
1192
1193
1194 # Keep a trace of the command line.
1195 # Strip out --no-create and --no-recursion so they do not pile up.
1196 # Strip out --silent because we don't want to record it for future runs.
1197 # Also quote any args containing shell meta-characters.
1198 # Make two passes to allow for proper duplicate-argument suppression.
1199 ac_configure_args=
1200 ac_configure_args0=
1201 ac_configure_args1=
1202 ac_sep=
1203 ac_must_keep_next=false
1204 for ac_pass in 1 2
1205 do
1206   for ac_arg
1207   do
1208     case $ac_arg in
1209     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1210     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1211     | -silent | --silent | --silen | --sile | --sil)
1212       continue ;;
1213     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1214       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1215     esac
1216     case $ac_pass in
1217     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1218     2)
1219       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1220       if test $ac_must_keep_next = true; then
1221         ac_must_keep_next=false # Got value, back to normal.
1222       else
1223         case $ac_arg in
1224           *=* | --config-cache | -C | -disable-* | --disable-* \
1225           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1226           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1227           | -with-* | --with-* | -without-* | --without-* | --x)
1228             case "$ac_configure_args0 " in
1229               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1230             esac
1231             ;;
1232           -* ) ac_must_keep_next=true ;;
1233         esac
1234       fi
1235       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1236       # Get rid of the leading space.
1237       ac_sep=" "
1238       ;;
1239     esac
1240   done
1241 done
1242 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1243 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1244
1245 # When interrupted or exit'd, cleanup temporary files, and complete
1246 # config.log.  We remove comments because anyway the quotes in there
1247 # would cause problems or look ugly.
1248 # WARNING: Be sure not to use single quotes in there, as some shells,
1249 # such as our DU 5.0 friend, will then `close' the trap.
1250 trap 'exit_status=$?
1251   # Save into config.log some information that might help in debugging.
1252   {
1253     echo
1254
1255     cat <<\_ASBOX
1256 ## ---------------- ##
1257 ## Cache variables. ##
1258 ## ---------------- ##
1259 _ASBOX
1260     echo
1261     # The following way of writing the cache mishandles newlines in values,
1262 {
1263   (set) 2>&1 |
1264     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1265     *ac_space=\ *)
1266       sed -n \
1267         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1268           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1269       ;;
1270     *)
1271       sed -n \
1272         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1273       ;;
1274     esac;
1275 }
1276     echo
1277
1278     cat <<\_ASBOX
1279 ## ----------------- ##
1280 ## Output variables. ##
1281 ## ----------------- ##
1282 _ASBOX
1283     echo
1284     for ac_var in $ac_subst_vars
1285     do
1286       eval ac_val=$`echo $ac_var`
1287       echo "$ac_var='"'"'$ac_val'"'"'"
1288     done | sort
1289     echo
1290
1291     if test -n "$ac_subst_files"; then
1292       cat <<\_ASBOX
1293 ## ------------- ##
1294 ## Output files. ##
1295 ## ------------- ##
1296 _ASBOX
1297       echo
1298       for ac_var in $ac_subst_files
1299       do
1300         eval ac_val=$`echo $ac_var`
1301         echo "$ac_var='"'"'$ac_val'"'"'"
1302       done | sort
1303       echo
1304     fi
1305
1306     if test -s confdefs.h; then
1307       cat <<\_ASBOX
1308 ## ----------- ##
1309 ## confdefs.h. ##
1310 ## ----------- ##
1311 _ASBOX
1312       echo
1313       sed "/^$/d" confdefs.h | sort
1314       echo
1315     fi
1316     test "$ac_signal" != 0 &&
1317       echo "$as_me: caught signal $ac_signal"
1318     echo "$as_me: exit $exit_status"
1319   } >&5
1320   rm -f core *.core &&
1321   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1322     exit $exit_status
1323      ' 0
1324 for ac_signal in 1 2 13 15; do
1325   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1326 done
1327 ac_signal=0
1328
1329 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1330 rm -rf conftest* confdefs.h
1331 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1332 echo >confdefs.h
1333
1334 # Predefined preprocessor variables.
1335
1336 cat >>confdefs.h <<_ACEOF
1337 #define PACKAGE_NAME "$PACKAGE_NAME"
1338 _ACEOF
1339
1340
1341 cat >>confdefs.h <<_ACEOF
1342 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1343 _ACEOF
1344
1345
1346 cat >>confdefs.h <<_ACEOF
1347 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1348 _ACEOF
1349
1350
1351 cat >>confdefs.h <<_ACEOF
1352 #define PACKAGE_STRING "$PACKAGE_STRING"
1353 _ACEOF
1354
1355
1356 cat >>confdefs.h <<_ACEOF
1357 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1358 _ACEOF
1359
1360
1361 # Let the site file select an alternate cache file if it wants to.
1362 # Prefer explicitly selected file to automatically selected ones.
1363 if test -z "$CONFIG_SITE"; then
1364   if test "x$prefix" != xNONE; then
1365     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1366   else
1367     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1368   fi
1369 fi
1370 for ac_site_file in $CONFIG_SITE; do
1371   if test -r "$ac_site_file"; then
1372     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1373 echo "$as_me: loading site script $ac_site_file" >&6;}
1374     sed 's/^/| /' "$ac_site_file" >&5
1375     . "$ac_site_file"
1376   fi
1377 done
1378
1379 if test -r "$cache_file"; then
1380   # Some versions of bash will fail to source /dev/null (special
1381   # files actually), so we avoid doing that.
1382   if test -f "$cache_file"; then
1383     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1384 echo "$as_me: loading cache $cache_file" >&6;}
1385     case $cache_file in
1386       [\\/]* | ?:[\\/]* ) . $cache_file;;
1387       *)                      . ./$cache_file;;
1388     esac
1389   fi
1390 else
1391   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1392 echo "$as_me: creating cache $cache_file" >&6;}
1393   >$cache_file
1394 fi
1395
1396 # Check that the precious variables saved in the cache have kept the same
1397 # value.
1398 ac_cache_corrupted=false
1399 for ac_var in `(set) 2>&1 |
1400                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1401   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1402   eval ac_new_set=\$ac_env_${ac_var}_set
1403   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1404   eval ac_new_val="\$ac_env_${ac_var}_value"
1405   case $ac_old_set,$ac_new_set in
1406     set,)
1407       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1408 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1409       ac_cache_corrupted=: ;;
1410     ,set)
1411       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1412 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1413       ac_cache_corrupted=: ;;
1414     ,);;
1415     *)
1416       if test "x$ac_old_val" != "x$ac_new_val"; then
1417         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1418 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1419         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1420 echo "$as_me:   former value:  $ac_old_val" >&2;}
1421         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1422 echo "$as_me:   current value: $ac_new_val" >&2;}
1423         ac_cache_corrupted=:
1424       fi;;
1425   esac
1426   # Pass precious variables to config.status.
1427   if test "$ac_new_set" = set; then
1428     case $ac_new_val in
1429     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1430       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1431     *) ac_arg=$ac_var=$ac_new_val ;;
1432     esac
1433     case " $ac_configure_args " in
1434       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1435       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1436     esac
1437   fi
1438 done
1439 if $ac_cache_corrupted; then
1440   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1441 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1442   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1443 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1444    { (exit 1); exit 1; }; }
1445 fi
1446
1447 ac_ext=c
1448 ac_cpp='$CPP $CPPFLAGS'
1449 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1450 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1451 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473 # Find the build, host, and target systems.
1474 ac_aux_dir=
1475 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1476   if test -f $ac_dir/install-sh; then
1477     ac_aux_dir=$ac_dir
1478     ac_install_sh="$ac_aux_dir/install-sh -c"
1479     break
1480   elif test -f $ac_dir/install.sh; then
1481     ac_aux_dir=$ac_dir
1482     ac_install_sh="$ac_aux_dir/install.sh -c"
1483     break
1484   elif test -f $ac_dir/shtool; then
1485     ac_aux_dir=$ac_dir
1486     ac_install_sh="$ac_aux_dir/shtool install -c"
1487     break
1488   fi
1489 done
1490 if test -z "$ac_aux_dir"; then
1491   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1492 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1493    { (exit 1); exit 1; }; }
1494 fi
1495 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1496 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1497 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1498
1499 # Make sure we can run config.sub.
1500 $ac_config_sub sun4 >/dev/null 2>&1 ||
1501   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1502 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1503    { (exit 1); exit 1; }; }
1504
1505 echo "$as_me:$LINENO: checking build system type" >&5
1506 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1507 if test "${ac_cv_build+set}" = set; then
1508   echo $ECHO_N "(cached) $ECHO_C" >&6
1509 else
1510   ac_cv_build_alias=$build_alias
1511 test -z "$ac_cv_build_alias" &&
1512   ac_cv_build_alias=`$ac_config_guess`
1513 test -z "$ac_cv_build_alias" &&
1514   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1515 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1516    { (exit 1); exit 1; }; }
1517 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1518   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1519 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1520    { (exit 1); exit 1; }; }
1521
1522 fi
1523 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1524 echo "${ECHO_T}$ac_cv_build" >&6
1525 build=$ac_cv_build
1526 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1527 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1528 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1529
1530
1531  case ${build_alias} in
1532   "") build_noncanonical=${build} ;;
1533   *) build_noncanonical=${build_alias} ;;
1534 esac
1535
1536
1537
1538  case ${host_alias} in
1539   "") host_noncanonical=${build_noncanonical} ;;
1540   *) host_noncanonical=${host_alias} ;;
1541 esac
1542
1543
1544
1545  case ${target_alias} in
1546   "") target_noncanonical=${host_noncanonical} ;;
1547   *) target_noncanonical=${target_alias} ;;
1548 esac
1549
1550
1551
1552
1553 test "$host_noncanonical" = "$target_noncanonical" &&
1554   test "$program_prefix$program_suffix$program_transform_name" = \
1555     NONENONEs,x,x, &&
1556   program_transform_name=s,y,y,
1557
1558 echo "$as_me:$LINENO: checking host system type" >&5
1559 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1560 if test "${ac_cv_host+set}" = set; then
1561   echo $ECHO_N "(cached) $ECHO_C" >&6
1562 else
1563   ac_cv_host_alias=$host_alias
1564 test -z "$ac_cv_host_alias" &&
1565   ac_cv_host_alias=$ac_cv_build_alias
1566 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1567   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1568 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1569    { (exit 1); exit 1; }; }
1570
1571 fi
1572 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1573 echo "${ECHO_T}$ac_cv_host" >&6
1574 host=$ac_cv_host
1575 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1576 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1577 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1578
1579
1580 echo "$as_me:$LINENO: checking target system type" >&5
1581 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1582 if test "${ac_cv_target+set}" = set; then
1583   echo $ECHO_N "(cached) $ECHO_C" >&6
1584 else
1585   ac_cv_target_alias=$target_alias
1586 test "x$ac_cv_target_alias" = "x" &&
1587   ac_cv_target_alias=$ac_cv_host_alias
1588 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1589   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1590 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1591    { (exit 1); exit 1; }; }
1592
1593 fi
1594 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1595 echo "${ECHO_T}$ac_cv_target" >&6
1596 target=$ac_cv_target
1597 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1598 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1599 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1600
1601
1602 # The aliases save the names the user supplied, while $host etc.
1603 # will get canonicalized.
1604 test -n "$target_alias" &&
1605   test "$program_prefix$program_suffix$program_transform_name" = \
1606     NONENONEs,x,x, &&
1607   program_prefix=${target_alias}-
1608 test "$program_prefix" != NONE &&
1609   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1610 # Use a double $ so make ignores it.
1611 test "$program_suffix" != NONE &&
1612   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1613 # Double any \ or $.  echo might interpret backslashes.
1614 # By default was `s,x,x', remove it if useless.
1615 cat <<\_ACEOF >conftest.sed
1616 s/[\\$]/&&/g;s/;s,x,x,$//
1617 _ACEOF
1618 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1619 rm conftest.sed
1620
1621
1622
1623 # Get 'install' or 'install-sh' and its variants.
1624 # Find a good install program.  We prefer a C program (faster),
1625 # so one script is as good as another.  But avoid the broken or
1626 # incompatible versions:
1627 # SysV /etc/install, /usr/sbin/install
1628 # SunOS /usr/etc/install
1629 # IRIX /sbin/install
1630 # AIX /bin/install
1631 # AmigaOS /C/install, which installs bootblocks on floppy discs
1632 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1633 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1634 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1635 # OS/2's system install, which has a completely different semantic
1636 # ./install, which can be erroneously created by make from ./install.sh.
1637 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1638 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1639 if test -z "$INSTALL"; then
1640 if test "${ac_cv_path_install+set}" = set; then
1641   echo $ECHO_N "(cached) $ECHO_C" >&6
1642 else
1643   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1644 for as_dir in $PATH
1645 do
1646   IFS=$as_save_IFS
1647   test -z "$as_dir" && as_dir=.
1648   # Account for people who put trailing slashes in PATH elements.
1649 case $as_dir/ in
1650   ./ | .// | /cC/* | \
1651   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1652   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1653   /usr/ucb/* ) ;;
1654   *)
1655     # OSF1 and SCO ODT 3.0 have their own names for install.
1656     # Don't use installbsd from OSF since it installs stuff as root
1657     # by default.
1658     for ac_prog in ginstall scoinst install; do
1659       for ac_exec_ext in '' $ac_executable_extensions; do
1660         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1661           if test $ac_prog = install &&
1662             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1663             # AIX install.  It has an incompatible calling convention.
1664             :
1665           elif test $ac_prog = install &&
1666             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1667             # program-specific install script used by HP pwplus--don't use.
1668             :
1669           else
1670             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1671             break 3
1672           fi
1673         fi
1674       done
1675     done
1676     ;;
1677 esac
1678 done
1679
1680
1681 fi
1682   if test "${ac_cv_path_install+set}" = set; then
1683     INSTALL=$ac_cv_path_install
1684   else
1685     # As a last resort, use the slow shell script.  We don't cache a
1686     # path for INSTALL within a source directory, because that will
1687     # break other packages using the cache if that directory is
1688     # removed, or if the path is relative.
1689     INSTALL=$ac_install_sh
1690   fi
1691 fi
1692 echo "$as_me:$LINENO: result: $INSTALL" >&5
1693 echo "${ECHO_T}$INSTALL" >&6
1694
1695 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1696 # It thinks the first close brace ends the variable substitution.
1697 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1698
1699 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1700
1701 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1702
1703 echo "$as_me:$LINENO: checking whether ln works" >&5
1704 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1705 if test "${acx_cv_prog_LN+set}" = set; then
1706   echo $ECHO_N "(cached) $ECHO_C" >&6
1707 else
1708   rm -f conftestdata_t
1709 echo >conftestdata_f
1710 if ln conftestdata_f conftestdata_t 2>/dev/null
1711 then
1712   acx_cv_prog_LN=ln
1713 else
1714   acx_cv_prog_LN=no
1715 fi
1716 rm -f conftestdata_f conftestdata_t
1717
1718 fi
1719 if test $acx_cv_prog_LN = no; then
1720   LN="cp"
1721   echo "$as_me:$LINENO: result: no, using $LN" >&5
1722 echo "${ECHO_T}no, using $LN" >&6
1723 else
1724   LN="$acx_cv_prog_LN"
1725   echo "$as_me:$LINENO: result: yes" >&5
1726 echo "${ECHO_T}yes" >&6
1727 fi
1728
1729 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1730 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1731 LN_S=$as_ln_s
1732 if test "$LN_S" = "ln -s"; then
1733   echo "$as_me:$LINENO: result: yes" >&5
1734 echo "${ECHO_T}yes" >&6
1735 else
1736   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1737 echo "${ECHO_T}no, using $LN_S" >&6
1738 fi
1739
1740
1741 ### we might need to use some other shell than /bin/sh for running subshells
1742 ### If we are on Windows, search for the shell.  This will permit people
1743 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1744 ### without also having to set CONFIG_SHELL.  This code will work when
1745 ### using bash, which sets OSTYPE.
1746 case "${OSTYPE}" in
1747 *win32*)
1748   if test x${CONFIG_SHELL} = x ; then
1749     if test ! -f /bin/sh ; then
1750       if test x${SHELL} != x && test -f ${SHELL} ; then
1751         CONFIG_SHELL=${SHELL}
1752         export CONFIG_SHELL
1753       else
1754         for prog in sh sh.exe bash bash.exe; do
1755           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1756           for dir in $PATH; do
1757             test -z "$dir" && dir=.
1758             if test -f $dir/$prog; then
1759               CONFIG_SHELL=$dir/$prog
1760               export CONFIG_SHELL
1761               break
1762             fi
1763           done
1764           IFS="$save_ifs"
1765           test -n "${CONFIG_SHELL}" && break
1766         done
1767       fi
1768     fi
1769   fi
1770   ;;
1771 esac
1772
1773 config_shell=${CONFIG_SHELL-/bin/sh}
1774
1775 progname=$0
1776 # if PWD already has a value, it is probably wrong.
1777 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1778
1779 # Export original configure arguments for use by sub-configures.
1780 # Quote arguments with shell meta charatcers.
1781 TOPLEVEL_CONFIGURE_ARGUMENTS=
1782 set -- "$progname" "$@"
1783 for ac_arg
1784 do
1785   case "$ac_arg" in
1786   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1787     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1788     # if the argument is of the form -foo=baz, quote the baz part only
1789     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1790   *) ;;
1791   esac
1792   # Add the quoted argument to the list.
1793   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1794 done
1795 if test "$silent" = yes; then
1796   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1797 fi
1798 # Remove the initial space we just introduced and, as these will be
1799 # expanded by make, quote '$'.
1800 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1801
1802
1803 moveifchange=${srcdir}/move-if-change
1804
1805 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1806
1807 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1808 # a relative path.
1809 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1810   INSTALL="${srcpwd}/install-sh -c"
1811 fi
1812
1813 # Set srcdir to "." if that's what it is.
1814 # This is important for multilib support.
1815 pwd=`${PWDCMD-pwd}`
1816 if test "${pwd}" = "${srcpwd}" ; then
1817   srcdir=.
1818 fi
1819
1820 topsrcdir=$srcpwd
1821
1822 extra_host_args=
1823
1824 ### To add a new directory to the tree, first choose whether it is a target
1825 ### or a host dependent tool.  Then put it into the appropriate list
1826 ### (library or tools, host or target), doing a dependency sort.
1827
1828 # Subdirs will be configured in the order listed in build_configdirs,
1829 # configdirs, or target_configdirs; see the serialization section below.
1830
1831 # Dependency sorting is only needed when *configuration* must be done in
1832 # a particular order.  In all cases a dependency should be specified in
1833 # the Makefile, whether or not it's implicitly specified here.
1834
1835 # Double entries in build_configdirs, configdirs, or target_configdirs may
1836 # cause circular dependencies and break everything horribly.
1837
1838 # these library is used by various programs built for the build
1839 # environment
1840 #
1841 build_libs="build-libiberty"
1842
1843 # these tools are built for the build environment
1844 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1845
1846 # these libraries are used by various programs built for the host environment
1847 #
1848 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1849
1850 # these tools are built for the host environment
1851 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1852 # know that we are building the simulator.
1853 # binutils, gas and ld appear in that order because it makes sense to run
1854 # "make check" in that particular order.
1855 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"
1856
1857 # libgcj represents the runtime libraries only used by gcj.
1858 libgcj="target-libffi \
1859         target-zlib \
1860         target-qthreads \
1861         target-libjava"
1862
1863 # these libraries are built for the target environment, and are built after
1864 # the host libraries and the host tools (which may be a cross compiler)
1865 #
1866 target_libraries="target-libgcc \
1867                 target-libiberty \
1868                 target-libgloss \
1869                 target-newlib \
1870                 target-libgomp \
1871                 target-libstdc++-v3 \
1872                 target-libmudflap \
1873                 target-libssp \
1874                 target-libgfortran \
1875                 target-boehm-gc \
1876                 ${libgcj} \
1877                 target-libobjc \
1878                 target-libada"
1879
1880 # these tools are built using the target libraries, and are intended to
1881 # run only in the target environment
1882 #
1883 # note: any program that *uses* libraries that are in the "target_libraries"
1884 # list belongs in this list.  those programs are also very likely
1885 # candidates for the "native_only" list which follows
1886 #
1887 target_tools="target-examples target-groff target-gperf target-rda"
1888
1889 ################################################################################
1890
1891 ## All tools belong in one of the four categories, and are assigned above
1892 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1893 ## is important because configure will choke if they ever get through.
1894 ## ${configdirs} is directories we build using the host tools.
1895 ## ${target_configdirs} is directories we build using the target tools.
1896 configdirs=`echo ${host_libs} ${host_tools}`
1897 target_configdirs=`echo ${target_libraries} ${target_tools}`
1898 build_configdirs=`echo ${build_libs} ${build_tools}`
1899
1900
1901
1902 ################################################################################
1903
1904 srcname="gnu development package"
1905
1906 # This gets set non-empty for some net releases of packages.
1907 appdirs=""
1908
1909 # Define is_cross_compiler to save on calls to 'test'.
1910 is_cross_compiler=
1911 if test x"${host}" = x"${target}" ; then
1912   is_cross_compiler=no
1913 else
1914   is_cross_compiler=yes
1915 fi
1916
1917 # Find the build and target subdir names.
1918
1919 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1920 # have matching libraries, they should use host libraries: Makefile.tpl
1921 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1922 # However, they still use the build modules, because the corresponding
1923 # host modules (e.g. bison) are only built for the host when bootstrap
1924 # finishes. So:
1925 # - build_subdir is where we find build modules, and never changes.
1926 # - build_libsubdir is where we find build libraries, and can be overridden.
1927
1928 # Prefix 'build-' so this never conflicts with target_subdir.
1929 build_subdir="build-${build_noncanonical}"
1930
1931 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1932 if test "${with_build_libsubdir+set}" = set; then
1933   withval="$with_build_libsubdir"
1934   build_libsubdir="$withval"
1935 else
1936   build_libsubdir="$build_subdir"
1937 fi;
1938 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1939 if ( test $srcdir = . && test -d gcc ) \
1940    || test -d $srcdir/../host-${host_noncanonical}; then
1941   host_subdir="host-${host_noncanonical}"
1942 else
1943   host_subdir=.
1944 fi
1945 # No prefix.
1946 target_subdir=${target_noncanonical}
1947
1948
1949 # Skipdirs are removed silently.
1950 skipdirs=
1951 # Noconfigdirs are removed loudly.
1952 noconfigdirs=""
1953
1954 use_gnu_ld=
1955 # Make sure we don't let GNU ld be added if we didn't want it.
1956 if test x$with_gnu_ld = xno ; then
1957   use_gnu_ld=no
1958   noconfigdirs="$noconfigdirs ld"
1959 fi
1960
1961 use_gnu_as=
1962 # Make sure we don't let GNU as be added if we didn't want it.
1963 if test x$with_gnu_as = xno ; then
1964   use_gnu_as=no
1965   noconfigdirs="$noconfigdirs gas"
1966 fi
1967
1968 # some tools are so dependent upon X11 that if we're not building with X,
1969 # it's not even worth trying to configure, much less build, that tool.
1970
1971 case ${with_x} in
1972   yes | "") ;; # the default value for this tree is that X11 is available
1973   no)
1974     skipdirs="${skipdirs} tk itcl libgui"
1975     # We won't be able to build gdbtk without X.
1976     enable_gdbtk=no
1977     ;;
1978   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
1979 esac
1980
1981 # Some tools are only suitable for building in a "native" situation.
1982 # Remove these if host!=target.
1983 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"
1984
1985 # Similarly, some are only suitable for cross toolchains.
1986 # Remove these if host=target.
1987 cross_only="target-libgloss target-newlib target-opcodes"
1988
1989 case $is_cross_compiler in
1990   no) skipdirs="${skipdirs} ${cross_only}" ;;
1991   yes) skipdirs="${skipdirs} ${native_only}" ;;
1992 esac
1993
1994 # If both --with-headers and --with-libs are specified, default to
1995 # --without-newlib.
1996 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
1997    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
1998   if test x"${with_newlib}" = x ; then
1999     with_newlib=no
2000   fi
2001 fi
2002
2003 # Recognize --with-newlib/--without-newlib.
2004 case ${with_newlib} in
2005   no) skipdirs="${skipdirs} target-newlib" ;;
2006   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2007 esac
2008
2009 # Configure extra directories which are host specific
2010
2011 case "${host}" in
2012   *-cygwin*)
2013     configdirs="$configdirs libtermcap" ;;
2014 esac
2015
2016 # A target can indicate whether a language isn't supported for some reason.
2017 # Only spaces may be used in this macro; not newlines or tabs.
2018 unsupported_languages=
2019
2020 # Remove more programs from consideration, based on the host or
2021 # target this usually means that a port of the program doesn't
2022 # exist yet.
2023
2024 case "${host}" in
2025   hppa*64*-*-*)
2026     noconfigdirs="$noconfigdirs byacc"
2027     ;;
2028   i[3456789]86-*-vsta)
2029     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2030     ;;
2031   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2032     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2033     ;;
2034   x86_64-*-mingw*)
2035     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2036     ;;
2037   i[3456789]86-*-mingw32*)
2038     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2039     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2040     ;;
2041   i[3456789]86-*-beos*)
2042     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2043     ;;
2044   *-*-cygwin*)
2045     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2046     ;;
2047   *-*-netbsd*)
2048     noconfigdirs="$noconfigdirs rcs"
2049     ;;
2050   ppc*-*-pe)
2051     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2052     ;;
2053   powerpc-*-beos*)
2054     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2055     ;;
2056 esac
2057
2058
2059 # Check whether --enable-libada or --disable-libada was given.
2060 if test "${enable_libada+set}" = set; then
2061   enableval="$enable_libada"
2062   ENABLE_LIBADA=$enableval
2063 else
2064   ENABLE_LIBADA=yes
2065 fi;
2066 if test "${ENABLE_LIBADA}" != "yes" ; then
2067   noconfigdirs="$noconfigdirs gnattools"
2068 fi
2069
2070 # Check whether --enable-libssp or --disable-libssp was given.
2071 if test "${enable_libssp+set}" = set; then
2072   enableval="$enable_libssp"
2073   ENABLE_LIBSSP=$enableval
2074 else
2075   ENABLE_LIBSSP=yes
2076 fi;
2077
2078 # Save it here so that, even in case of --enable-libgcj, if the Java
2079 # front-end isn't enabled, we still get libgcj disabled.
2080 libgcj_saved=$libgcj
2081 case $enable_libgcj in
2082 yes)
2083   # If we reset it here, it won't get added to noconfigdirs in the
2084   # target-specific build rules, so it will be forcibly enabled
2085   # (unless the Java language itself isn't enabled).
2086   libgcj=
2087   ;;
2088 no)
2089   # Make sure we get it printed in the list of not supported target libs.
2090   noconfigdirs="$noconfigdirs ${libgcj}"
2091   ;;
2092 esac
2093
2094
2095 # Disable libmudflap on some systems.
2096 if test x$enable_libmudflap = x ; then
2097     case "${target}" in
2098     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2099         # Enable libmudflap by default in GNU and friends.
2100         ;;
2101     *-*-freebsd*)
2102         # Enable libmudflap by default in FreeBSD.
2103         ;;
2104     *)
2105         # Disable it by default everywhere else.
2106         noconfigdirs="$noconfigdirs target-libmudflap"
2107         ;;
2108     esac
2109 fi
2110
2111 # Disable libgomp on non POSIX hosted systems.
2112 if test x$enable_libgomp = x ; then
2113     # Enable libgomp by default on hosted POSIX systems.
2114     case "${target}" in
2115     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2116         ;;
2117     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2118         ;;
2119     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2120         ;;
2121     *-*-darwin* | *-*-aix*)
2122         ;;
2123     *)
2124         noconfigdirs="$noconfigdirs target-libgomp"
2125         ;;
2126     esac
2127 fi
2128
2129 # Default libgloss CPU subdirectory.
2130 libgloss_dir="$target_cpu"
2131
2132 case "${target}" in
2133   *-*-chorusos)
2134     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2135     ;;
2136   powerpc-*-darwin* | i[3456789]86-*-darwin* | x86_64-*-darwin9*)
2137     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2138     noconfigdirs="$noconfigdirs sim target-rda"
2139     ;;
2140   *-*-darwin*)
2141     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2142     noconfigdirs="$noconfigdirs sim target-rda"
2143     noconfigdirs="$noconfigdirs ${libgcj}"
2144     ;;
2145   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2146     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2147     ;;
2148   *-*-freebsd*)
2149     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2150     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2151         && test -f /usr/local/include/gmp.h; then
2152       with_gmp=/usr/local
2153     fi
2154
2155     # Skip some stuff that's unsupported on some FreeBSD configurations.
2156     case "${target}" in
2157       i*86-*-*) ;;
2158       alpha*-*-*) ;;
2159       *)
2160         noconfigdirs="$noconfigdirs ${libgcj}"
2161         ;;
2162     esac
2163     ;;
2164   *-*-kaos*)
2165     # Remove unsupported stuff on all kaOS configurations.
2166     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2167     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2168     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2169     noconfigdirs="$noconfigdirs target-libgloss"
2170     ;;
2171   *-*-netbsd*)
2172     # Skip some stuff on all NetBSD configurations.
2173     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2174
2175     # Skip some stuff that's unsupported on some NetBSD configurations.
2176     case "${target}" in
2177       i*86-*-netbsdelf*) ;;
2178       arm*-*-netbsdelf*) ;;
2179       *)
2180         noconfigdirs="$noconfigdirs ${libgcj}"
2181         ;;
2182     esac
2183     ;;
2184   *-*-netware*)
2185     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2186     ;;
2187   *-*-rtems*)
2188     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2189     ;;
2190     # The tpf target doesn't support gdb yet.
2191   *-*-tpf*)
2192     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2193     ;;
2194   *-*-uclinux*)
2195     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2196     ;;
2197   *-*-vxworks*)
2198     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2199     ;;
2200   alpha*-dec-osf*)
2201     # ld works, but does not support shared libraries.
2202     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2203     # gas doesn't generate exception information.
2204     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2205     ;;
2206   alpha*-*-*vms*)
2207     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2208     ;;
2209   alpha*-*-linux*)
2210     # newlib is not 64 bit ready
2211     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2212     ;;
2213   alpha*-*-*)
2214     # newlib is not 64 bit ready
2215     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2216     ;;
2217   am33_2.0-*-linux*)
2218     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2219     ;;
2220   sh-*-linux*)
2221     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2222     ;;
2223   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2224     noconfigdirs="$noconfigdirs ${libgcj}"
2225     noconfigdirs="$noconfigdirs target-examples"
2226     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2227     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2228     noconfigdirs="$noconfigdirs expect dejagnu"
2229     # the C++ libraries don't build on top of CE's C libraries
2230     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2231     noconfigdirs="$noconfigdirs target-newlib"
2232     case "${host}" in
2233       *-*-cygwin*) ;; # keep gdb and readline
2234       *) noconfigdirs="$noconfigdirs gdb readline"
2235          ;;
2236     esac
2237     libgloss_dir=wince
2238     ;;
2239   arc-*-*)
2240     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2241     ;;
2242   arm-semi-aof )
2243     ;;
2244   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2245     noconfigdirs="$noconfigdirs ${libgcj}"
2246     libgloss_dir=arm
2247     ;;
2248   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2249     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2250     libgloss_dir=arm
2251     ;;
2252   arm*-*-linux-gnueabi)
2253     noconfigdirs="$noconfigdirs target-qthreads"
2254     noconfigdirs="$noconfigdirs target-libobjc"
2255     case ${with_newlib} in
2256       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2257     esac
2258     libgloss_dir=arm
2259     ;;
2260   arm*-*-symbianelf*)
2261     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2262     libgloss_dir=arm
2263     ;;
2264   arm-*-pe*)
2265     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2266     ;;
2267   thumb-*-coff)
2268     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2269     ;;
2270   thumb-*-elf)
2271     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2272     ;;
2273   thumb-*-pe)
2274     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2275     ;;
2276   arm-*-riscix*)
2277     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2278     ;;
2279   avr-*-*)
2280     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2281     ;;
2282   bfin-*-*)
2283     noconfigdirs="$noconfigdirs gdb"
2284     if test x${is_cross_compiler} != xno ; then
2285       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2286     fi
2287     ;;
2288   c4x-*-* | tic4x-*-*)
2289     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2290     ;;
2291   c54x*-*-* | tic54x-*-*)
2292     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2293     ;;
2294   cris-*-* | crisv32-*-*)
2295     unsupported_languages="$unsupported_languages java"
2296     case "${target}" in
2297       *-*-aout)
2298         unsupported_languages="$unsupported_languages fortran"
2299         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2300       *-*-elf)
2301         unsupported_languages="$unsupported_languages fortran"
2302         noconfigdirs="$noconfigdirs target-boehm-gc";;
2303       *-*-linux*)
2304         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2305       *)
2306         unsupported_languages="$unsupported_languages fortran"
2307         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2308     esac
2309     libgloss_dir=cris
2310     ;;
2311   crx-*-*)
2312     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2313     ;;
2314   d10v-*-*)
2315     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2316     ;;
2317   d30v-*-*)
2318     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2319     ;;
2320   ep9312-*-elf | ep9312-*-coff)
2321     libgloss_dir=arm
2322     ;;
2323   fr30-*-elf*)
2324     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2325     ;;
2326   frv-*-*)
2327     noconfigdirs="$noconfigdirs ${libgcj}"
2328     ;;
2329   h8300*-*-*)
2330     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2331     ;;
2332   h8500-*-*)
2333     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2334     ;;
2335   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2336     ;;
2337   hppa*64*-*-linux* | parisc*64*-*-linux*)
2338     # In this case, it's because the hppa64-linux target is for
2339     # the kernel only at this point and has no libc, and thus no
2340     # headers, crt*.o, etc., all of which are needed by these.
2341     noconfigdirs="$noconfigdirs target-zlib"
2342     ;;
2343   parisc*-*-linux* | hppa*-*-linux*)
2344     ;;
2345   hppa*-*-*elf* | \
2346   hppa*-*-lites* | \
2347   hppa*-*-openbsd* | \
2348   hppa*64*-*-*)
2349     noconfigdirs="$noconfigdirs ${libgcj}"
2350     ;;
2351   hppa*-hp-hpux11*)
2352     noconfigdirs="$noconfigdirs ld shellutils"
2353     ;;
2354   hppa*-*-pro*)
2355     libgloss_dir=pa
2356     ;;
2357   hppa*-*-*)
2358     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2359     # build on HP-UX 10.20.
2360     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2361     ;;
2362   i960-*-*)
2363     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2364     ;;
2365   ia64*-*-elf*)
2366     # No gdb support yet.
2367     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2368     ;;
2369   ia64*-**-hpux*)
2370     # No gdb or ld support yet.
2371     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2372     ;;
2373   i370-*-opened*)
2374     ;;
2375   i[3456789]86-*-coff | i[3456789]86-*-elf)
2376     noconfigdirs="$noconfigdirs ${libgcj}"
2377     libgloss_dir=i386
2378     ;;
2379   i[3456789]86-*-linux*)
2380     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2381     # not build java stuff by default.
2382     case "${target}" in
2383       *-*-*libc1*)
2384         noconfigdirs="$noconfigdirs ${libgcj}";;
2385     esac
2386
2387     # This section makes it possible to build newlib natively on linux.
2388     # If we are using a cross compiler then don't configure newlib.
2389     if test x${is_cross_compiler} != xno ; then
2390       noconfigdirs="$noconfigdirs target-newlib"
2391     fi
2392     noconfigdirs="$noconfigdirs target-libgloss"
2393     # If we are not using a cross compiler, do configure newlib.
2394     # Note however, that newlib will only be configured in this situation
2395     # if the --with-newlib option has been given, because otherwise
2396     # 'target-newlib' will appear in skipdirs.
2397     ;;
2398   i[3456789]86-*-mingw32*)
2399     target_configdirs="$target_configdirs target-winsup"
2400     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2401     ;;
2402   x86_64-*-mingw*)
2403     target_configdirs="$target_configdirs target-winsup"
2404     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2405     ;;
2406   *-*-cygwin*)
2407     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2408     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2409     # always build newlib if winsup directory is present.
2410     if test -d "$srcdir/winsup/cygwin"; then
2411       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2412     elif test -d "$srcdir/newlib"; then
2413       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2414     fi
2415     ;;
2416   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2417   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2418     ;;
2419   i[3456789]86-*-pe)
2420     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2421     ;;
2422   i[3456789]86-*-sco3.2v5*)
2423     # The linker does not yet know about weak symbols in COFF,
2424     # and is not configured to handle mixed ELF and COFF.
2425     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2426     ;;
2427   i[3456789]86-*-sco*)
2428     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2429     ;;
2430   i[3456789]86-*-solaris2*)
2431     noconfigdirs="$noconfigdirs target-libgloss"
2432     ;;
2433   i[3456789]86-*-sysv4*)
2434     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2435     ;;
2436   i[3456789]86-*-beos*)
2437     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2438     ;;
2439   i[3456789]86-*-rdos*)
2440     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2441     ;;
2442   m32r-*-*)
2443     noconfigdirs="$noconfigdirs ${libgcj}"
2444     ;;
2445   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2446     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2447     libgloss_dir=m68hc11
2448     ;;
2449   m68k-*-elf*)
2450     noconfigdirs="$noconfigdirs ${libgcj}"
2451     ;;
2452   m68k-*-coff*)
2453     noconfigdirs="$noconfigdirs ${libgcj}"
2454     ;;
2455   m68*-*-* | fido-*-*)
2456     libgloss_dir=m68k
2457     ;;
2458   mcore-*-pe*)
2459   # The EPOC C++ environment does not support exceptions or rtti,
2460   # and so building libstdc++-v3 tends not to always work.
2461     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2462     ;;
2463   mmix-*-*)
2464     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2465     unsupported_languages="$unsupported_languages fortran java"
2466     ;;
2467   mn10200-*-*)
2468     noconfigdirs="$noconfigdirs ${libgcj}"
2469     ;;
2470   mn10300-*-*)
2471     noconfigdirs="$noconfigdirs ${libgcj}"
2472     ;;
2473   mt-*-*)
2474     noconfigdirs="$noconfigdirs sim"
2475     ;;
2476   powerpc-*-aix*)
2477     # copied from rs6000-*-* entry
2478     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2479     ;;
2480   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2481     target_configdirs="$target_configdirs target-winsup"
2482     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2483     # always build newlib.
2484     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2485     ;;
2486     # This is temporary until we can link against shared libraries
2487   powerpcle-*-solaris*)
2488     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2489     libgloss_dir=rs6000
2490     ;;
2491   powerpc-*-beos*)
2492     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2493     ;;
2494   powerpc-*-eabi)
2495     noconfigdirs="$noconfigdirs ${libgcj}"
2496     libgloss_dir=rs6000
2497     ;;
2498   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2499     libgloss_dir=rs6000
2500     ;;
2501   rs6000-*-lynxos*)
2502     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2503     ;;
2504   rs6000-*-aix*)
2505     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2506     ;;
2507   rs6000-*-*)
2508     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2509     ;;
2510   m68k-apollo-*)
2511     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2512     ;;
2513   mips*-sde-elf*)
2514     skipdirs="$skipdirs target-libiberty"
2515     noconfigdirs="$noconfigdirs ${libgcj}"
2516     if test x$with_newlib = xyes; then
2517       noconfigdirs="$noconfigdirs gprof"
2518     fi
2519     libgloss_dir=mips
2520     ;;
2521   mips*-*-irix5*)
2522     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2523     ;;
2524   mips*-*-irix6*)
2525     # Linking libjava exceeds command-line length limits on at least
2526     # IRIX 6.2, but not on IRIX 6.5.
2527     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2528     # <oldham@codesourcery.com>
2529     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2530     ;;
2531   mips*-*-bsd*)
2532     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2533     ;;
2534   mips*-*-linux*)
2535     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2536     ;;
2537   mips*-*-*)
2538     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2539     libgloss_dir=mips
2540     ;;
2541   romp-*-*)
2542     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2543     ;;
2544   sh-*-* | sh64-*-*)
2545     case "${host}" in
2546       i[3456789]86-*-vsta) ;; # don't add gprof back in
2547       i[3456789]86-*-go32*) ;; # don't add gprof back in
2548       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2549       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2550     esac
2551     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2552     ;;
2553   sparclet-*-aout* | sparc86x-*-*)
2554     libgloss_dir=sparc
2555     ;;
2556   sparc-*-elf*)
2557     noconfigdirs="$noconfigdirs ${libgcj}"
2558     ;;
2559   sparc64-*-elf*)
2560     noconfigdirs="$noconfigdirs ${libgcj}"
2561     libgloss_dir=sparc
2562     ;;
2563   sparclite-*-*)
2564     noconfigdirs="$noconfigdirs ${libgcj}"
2565     libgloss_dir=sparc
2566     ;;
2567   sparc-*-sunos4*)
2568     noconfigdirs="$noconfigdirs ${libgcj}"
2569     if test x${is_cross_compiler} != xno ; then
2570            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2571     else
2572            use_gnu_ld=no
2573     fi
2574     ;;
2575   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2576     noconfigdirs="$noconfigdirs ${libgcj}"
2577     ;;
2578   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2579     ;;
2580   spu-*-*)
2581     skipdirs="target-libssp"
2582     ;;
2583   v810-*-*)
2584     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2585     ;;
2586   v850-*-*)
2587     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2588     ;;
2589   v850e-*-*)
2590     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2591     ;;
2592   v850ea-*-*)
2593     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2594     ;;
2595   vax-*-vms)
2596     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2597     ;;
2598   vax-*-*)
2599     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2600     ;;
2601   xtensa-*-*)
2602     noconfigdirs="$noconfigdirs ${libgcj}"
2603     ;;
2604   ip2k-*-*)
2605     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2606     ;;
2607   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2608     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2609     ;;
2610   *-*-lynxos*)
2611     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2612     ;;
2613   *-*-*)
2614     noconfigdirs="$noconfigdirs ${libgcj}"
2615     ;;
2616 esac
2617
2618 # If we aren't building newlib, then don't build libgloss, since libgloss
2619 # depends upon some newlib header files.
2620 case "${noconfigdirs}" in
2621   *target-libgloss*) ;;
2622   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2623 esac
2624
2625 # Work in distributions that contain no compiler tools, like Autoconf.
2626 tentative_cc=""
2627 host_makefile_frag=/dev/null
2628 if test -d ${srcdir}/config ; then
2629 case "${host}" in
2630   m68k-hp-hpux*)
2631     # Avoid "too much defining" errors from HPUX compiler.
2632     tentative_cc="cc -Wp,-H256000"
2633     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2634     # If it's HP/UX ar, this should be harmless.
2635     RANLIB="ar ts"
2636     ;;
2637   m68k-apollo-sysv*)
2638     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2639     ;;
2640   m68k-apollo-bsd*)
2641     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2642     # chokes on bfd, the compiler won't let you assign integers to enums, and
2643     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2644     # the apollo compiler" (the preferred version of GCC could be called cc,
2645     # or whatever), but I'm not sure leaving CC as cc is any better...
2646     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2647     # Used to have BISON=yacc.
2648     tentative_cc=gcc
2649     ;;
2650   m88k-dg-dgux*)
2651     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2652     ;;
2653   m88k-harris-cxux*)
2654     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2655     tentative_cc="cc -Xa"
2656     host_makefile_frag="config/mh-cxux"
2657     ;;
2658   m88k-motorola-sysv*)
2659     ;;
2660   mips*-dec-ultrix*)
2661     tentative_cc="cc -Wf,-XNg1000"
2662     host_makefile_frag="config/mh-decstation"
2663     ;;
2664   mips*-nec-sysv4*)
2665     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2666     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2667     host_makefile_frag="config/mh-necv4"
2668     ;;
2669   mips*-sgi-irix4*)
2670     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2671     # environment.  Also bump switch table size so that cp-parse will
2672     # compile.  Bump string length limit so linker builds.
2673     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2674     ;;
2675   mips*-*-sysv4*)
2676     host_makefile_frag="config/mh-sysv4"
2677     ;;
2678   mips*-*-sysv*)
2679     # This is for a MIPS running RISC/os 4.52C.
2680
2681     # This is needed for GDB, but needs to be in the top-level make because
2682     # if a library is compiled with the bsd headers and gets linked with the
2683     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2684     # a different size).
2685     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2686     # known except to select the sysv environment.  Could we use /proc instead?
2687     # These "sysv environments" and "bsd environments" often end up being a pain.
2688     #
2689     # This is not part of CFLAGS because perhaps not all C compilers have this
2690     # option.
2691     tentative_cc="cc -systype sysv"
2692     ;;
2693   i370-ibm-opened*)
2694     tentative_cc="c89"
2695     ;;
2696   i[3456789]86-*-sysv5*)
2697     host_makefile_frag="config/mh-sysv5"
2698     ;;
2699   i[3456789]86-*-dgux*)
2700     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2701     host_makefile_frag="config/mh-dgux386"
2702     ;;
2703   i[3456789]86-ncr-sysv4.3*)
2704     # The MetaWare compiler will generate a copyright message unless you
2705     # turn it off by adding the -Hnocopyr flag.
2706     tentative_cc="cc -Hnocopyr"
2707     ;;
2708   i[3456789]86-ncr-sysv4*)
2709     # for an NCR 3000 (i486/SVR4) system.
2710     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2711     # This compiler not only emits obnoxious copyright messages every time
2712     # you run it, but it chokes and dies on a whole bunch of GNU source
2713     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2714     tentative_cc="/usr/ccs/ATT/cc"
2715     host_makefile_frag="config/mh-ncr3000"
2716     ;;
2717   i[3456789]86-*-sco3.2v5*)
2718     ;;
2719   i[3456789]86-*-sco*)
2720     # The native C compiler botches some simple uses of const.  Unfortunately,
2721     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2722     tentative_cc="cc -Dconst="
2723     host_makefile_frag="config/mh-sco"
2724     ;;
2725   i[3456789]86-*-udk*)
2726     host_makefile_frag="config/mh-sysv5"
2727     ;;
2728   i[3456789]86-*-solaris2*)
2729     host_makefile_frag="config/mh-sysv4"
2730     ;;
2731   i[3456789]86-*-msdosdjgpp*)
2732     host_makefile_frag="config/mh-djgpp"
2733     ;;
2734   *-cygwin*)
2735     host_makefile_frag="config/mh-cygwin"
2736     ;;
2737   *-mingw32*)
2738     host_makefile_frag="config/mh-mingw"
2739     ;;
2740   *-mingw64*)
2741     host_makefile_frag="config/mh-mingw"
2742     ;;
2743   *-interix*)
2744     host_makefile_frag="config/mh-interix"
2745     ;;
2746   vax-*-ultrix2*)
2747     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2748     tentative_cc=gcc
2749     ;;
2750   *-*-solaris2*)
2751     host_makefile_frag="config/mh-solaris"
2752     ;;
2753   m68k-sun-sunos*)
2754     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2755     # without overflowing the jump tables (-J says to use a 32 bit table)
2756     tentative_cc="cc -J"
2757     ;;
2758   *-hp-hpux*)
2759     tentative_cc="cc -Wp,-H256000"
2760     ;;
2761   *-*-hiux*)
2762     tentative_cc="cc -Wp,-H256000"
2763     ;;
2764   rs6000-*-lynxos*)
2765     # /bin/cc is less than useful for our purposes.  Always use GCC
2766     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2767     host_makefile_frag="config/mh-lynxrs6k"
2768     ;;
2769   powerpc-*-darwin*)
2770     host_makefile_frag="config/mh-ppc-darwin"
2771     ;;
2772   powerpc-*-aix*)
2773     host_makefile_frag="config/mh-ppc-aix"
2774     ;;
2775   rs6000-*-aix*)
2776     host_makefile_frag="config/mh-ppc-aix"
2777     ;;
2778   *-*-lynxos*)
2779     # /bin/cc is less than useful for our purposes.  Always use GCC
2780     tentative_cc="/bin/gcc"
2781     ;;
2782   *-*-sysv4*)
2783     host_makefile_frag="config/mh-sysv4"
2784     ;;
2785   # This is placed last to prevent interfering with the cases above.
2786   i[3456789]86-*-*)
2787     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2788     host_makefile_frag="config/mh-x86omitfp"
2789     ;;
2790 esac
2791 fi
2792
2793 # If we aren't going to be using gcc, see if we can extract a definition
2794 # of CC from the fragment.
2795 # Actually, use the 'pre-extracted' version above.
2796 if test -z "${CC}" && test "${build}" = "${host}" ; then
2797   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2798   found=
2799   for dir in $PATH; do
2800     test -z "$dir" && dir=.
2801     if test -f $dir/gcc; then
2802       found=yes
2803       break
2804     fi
2805   done
2806   IFS="$save_ifs"
2807   if test -z "${found}" && test -n "${tentative_cc}" ; then
2808     CC=$tentative_cc
2809   fi
2810 fi
2811
2812 if test "${build}" != "${host}" ; then
2813   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2814   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2815   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2816   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2817   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2818   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2819   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2820   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2821   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2822   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2823   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2824   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2825 else
2826   AR_FOR_BUILD="\$(AR)"
2827   AS_FOR_BUILD="\$(AS)"
2828   CC_FOR_BUILD="\$(CC)"
2829   CXX_FOR_BUILD="\$(CXX)"
2830   GCJ_FOR_BUILD="\$(GCJ)"
2831   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2832   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2833   LD_FOR_BUILD="\$(LD)"
2834   NM_FOR_BUILD="\$(NM)"
2835   RANLIB_FOR_BUILD="\$(RANLIB)"
2836   WINDRES_FOR_BUILD="\$(WINDRES)"
2837   WINDMC_FOR_BUILD="\$(WINDMC)"
2838 fi
2839
2840 ac_ext=c
2841 ac_cpp='$CPP $CPPFLAGS'
2842 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2843 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2844 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2845 if test -n "$ac_tool_prefix"; then
2846   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2847 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2848 echo "$as_me:$LINENO: checking for $ac_word" >&5
2849 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2850 if test "${ac_cv_prog_CC+set}" = set; then
2851   echo $ECHO_N "(cached) $ECHO_C" >&6
2852 else
2853   if test -n "$CC"; then
2854   ac_cv_prog_CC="$CC" # Let the user override the test.
2855 else
2856 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2857 for as_dir in $PATH
2858 do
2859   IFS=$as_save_IFS
2860   test -z "$as_dir" && as_dir=.
2861   for ac_exec_ext in '' $ac_executable_extensions; do
2862   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2863     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2864     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2865     break 2
2866   fi
2867 done
2868 done
2869
2870 fi
2871 fi
2872 CC=$ac_cv_prog_CC
2873 if test -n "$CC"; then
2874   echo "$as_me:$LINENO: result: $CC" >&5
2875 echo "${ECHO_T}$CC" >&6
2876 else
2877   echo "$as_me:$LINENO: result: no" >&5
2878 echo "${ECHO_T}no" >&6
2879 fi
2880
2881 fi
2882 if test -z "$ac_cv_prog_CC"; then
2883   ac_ct_CC=$CC
2884   # Extract the first word of "gcc", so it can be a program name with args.
2885 set dummy gcc; ac_word=$2
2886 echo "$as_me:$LINENO: checking for $ac_word" >&5
2887 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2888 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2889   echo $ECHO_N "(cached) $ECHO_C" >&6
2890 else
2891   if test -n "$ac_ct_CC"; then
2892   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2893 else
2894 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2895 for as_dir in $PATH
2896 do
2897   IFS=$as_save_IFS
2898   test -z "$as_dir" && as_dir=.
2899   for ac_exec_ext in '' $ac_executable_extensions; do
2900   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2901     ac_cv_prog_ac_ct_CC="gcc"
2902     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2903     break 2
2904   fi
2905 done
2906 done
2907
2908 fi
2909 fi
2910 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2911 if test -n "$ac_ct_CC"; then
2912   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2913 echo "${ECHO_T}$ac_ct_CC" >&6
2914 else
2915   echo "$as_me:$LINENO: result: no" >&5
2916 echo "${ECHO_T}no" >&6
2917 fi
2918
2919   CC=$ac_ct_CC
2920 else
2921   CC="$ac_cv_prog_CC"
2922 fi
2923
2924 if test -z "$CC"; then
2925   if test -n "$ac_tool_prefix"; then
2926   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2927 set dummy ${ac_tool_prefix}cc; ac_word=$2
2928 echo "$as_me:$LINENO: checking for $ac_word" >&5
2929 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2930 if test "${ac_cv_prog_CC+set}" = set; then
2931   echo $ECHO_N "(cached) $ECHO_C" >&6
2932 else
2933   if test -n "$CC"; then
2934   ac_cv_prog_CC="$CC" # Let the user override the test.
2935 else
2936 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2937 for as_dir in $PATH
2938 do
2939   IFS=$as_save_IFS
2940   test -z "$as_dir" && as_dir=.
2941   for ac_exec_ext in '' $ac_executable_extensions; do
2942   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2943     ac_cv_prog_CC="${ac_tool_prefix}cc"
2944     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2945     break 2
2946   fi
2947 done
2948 done
2949
2950 fi
2951 fi
2952 CC=$ac_cv_prog_CC
2953 if test -n "$CC"; then
2954   echo "$as_me:$LINENO: result: $CC" >&5
2955 echo "${ECHO_T}$CC" >&6
2956 else
2957   echo "$as_me:$LINENO: result: no" >&5
2958 echo "${ECHO_T}no" >&6
2959 fi
2960
2961 fi
2962 if test -z "$ac_cv_prog_CC"; then
2963   ac_ct_CC=$CC
2964   # Extract the first word of "cc", so it can be a program name with args.
2965 set dummy cc; ac_word=$2
2966 echo "$as_me:$LINENO: checking for $ac_word" >&5
2967 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2968 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2969   echo $ECHO_N "(cached) $ECHO_C" >&6
2970 else
2971   if test -n "$ac_ct_CC"; then
2972   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2973 else
2974 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2975 for as_dir in $PATH
2976 do
2977   IFS=$as_save_IFS
2978   test -z "$as_dir" && as_dir=.
2979   for ac_exec_ext in '' $ac_executable_extensions; do
2980   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2981     ac_cv_prog_ac_ct_CC="cc"
2982     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2983     break 2
2984   fi
2985 done
2986 done
2987
2988 fi
2989 fi
2990 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2991 if test -n "$ac_ct_CC"; then
2992   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2993 echo "${ECHO_T}$ac_ct_CC" >&6
2994 else
2995   echo "$as_me:$LINENO: result: no" >&5
2996 echo "${ECHO_T}no" >&6
2997 fi
2998
2999   CC=$ac_ct_CC
3000 else
3001   CC="$ac_cv_prog_CC"
3002 fi
3003
3004 fi
3005 if test -z "$CC"; then
3006   # Extract the first word of "cc", so it can be a program name with args.
3007 set dummy cc; ac_word=$2
3008 echo "$as_me:$LINENO: checking for $ac_word" >&5
3009 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3010 if test "${ac_cv_prog_CC+set}" = set; then
3011   echo $ECHO_N "(cached) $ECHO_C" >&6
3012 else
3013   if test -n "$CC"; then
3014   ac_cv_prog_CC="$CC" # Let the user override the test.
3015 else
3016   ac_prog_rejected=no
3017 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3018 for as_dir in $PATH
3019 do
3020   IFS=$as_save_IFS
3021   test -z "$as_dir" && as_dir=.
3022   for ac_exec_ext in '' $ac_executable_extensions; do
3023   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3024     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3025        ac_prog_rejected=yes
3026        continue
3027      fi
3028     ac_cv_prog_CC="cc"
3029     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3030     break 2
3031   fi
3032 done
3033 done
3034
3035 if test $ac_prog_rejected = yes; then
3036   # We found a bogon in the path, so make sure we never use it.
3037   set dummy $ac_cv_prog_CC
3038   shift
3039   if test $# != 0; then
3040     # We chose a different compiler from the bogus one.
3041     # However, it has the same basename, so the bogon will be chosen
3042     # first if we set CC to just the basename; use the full file name.
3043     shift
3044     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3045   fi
3046 fi
3047 fi
3048 fi
3049 CC=$ac_cv_prog_CC
3050 if test -n "$CC"; then
3051   echo "$as_me:$LINENO: result: $CC" >&5
3052 echo "${ECHO_T}$CC" >&6
3053 else
3054   echo "$as_me:$LINENO: result: no" >&5
3055 echo "${ECHO_T}no" >&6
3056 fi
3057
3058 fi
3059 if test -z "$CC"; then
3060   if test -n "$ac_tool_prefix"; then
3061   for ac_prog in cl
3062   do
3063     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3064 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3065 echo "$as_me:$LINENO: checking for $ac_word" >&5
3066 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3067 if test "${ac_cv_prog_CC+set}" = set; then
3068   echo $ECHO_N "(cached) $ECHO_C" >&6
3069 else
3070   if test -n "$CC"; then
3071   ac_cv_prog_CC="$CC" # Let the user override the test.
3072 else
3073 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3074 for as_dir in $PATH
3075 do
3076   IFS=$as_save_IFS
3077   test -z "$as_dir" && as_dir=.
3078   for ac_exec_ext in '' $ac_executable_extensions; do
3079   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3080     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3081     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3082     break 2
3083   fi
3084 done
3085 done
3086
3087 fi
3088 fi
3089 CC=$ac_cv_prog_CC
3090 if test -n "$CC"; then
3091   echo "$as_me:$LINENO: result: $CC" >&5
3092 echo "${ECHO_T}$CC" >&6
3093 else
3094   echo "$as_me:$LINENO: result: no" >&5
3095 echo "${ECHO_T}no" >&6
3096 fi
3097
3098     test -n "$CC" && break
3099   done
3100 fi
3101 if test -z "$CC"; then
3102   ac_ct_CC=$CC
3103   for ac_prog in cl
3104 do
3105   # Extract the first word of "$ac_prog", so it can be a program name with args.
3106 set dummy $ac_prog; ac_word=$2
3107 echo "$as_me:$LINENO: checking for $ac_word" >&5
3108 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3109 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3110   echo $ECHO_N "(cached) $ECHO_C" >&6
3111 else
3112   if test -n "$ac_ct_CC"; then
3113   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3114 else
3115 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3116 for as_dir in $PATH
3117 do
3118   IFS=$as_save_IFS
3119   test -z "$as_dir" && as_dir=.
3120   for ac_exec_ext in '' $ac_executable_extensions; do
3121   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3122     ac_cv_prog_ac_ct_CC="$ac_prog"
3123     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3124     break 2
3125   fi
3126 done
3127 done
3128
3129 fi
3130 fi
3131 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3132 if test -n "$ac_ct_CC"; then
3133   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3134 echo "${ECHO_T}$ac_ct_CC" >&6
3135 else
3136   echo "$as_me:$LINENO: result: no" >&5
3137 echo "${ECHO_T}no" >&6
3138 fi
3139
3140   test -n "$ac_ct_CC" && break
3141 done
3142
3143   CC=$ac_ct_CC
3144 fi
3145
3146 fi
3147
3148
3149 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3150 See \`config.log' for more details." >&5
3151 echo "$as_me: error: no acceptable C compiler found in \$PATH
3152 See \`config.log' for more details." >&2;}
3153    { (exit 1); exit 1; }; }
3154
3155 # Provide some information about the compiler.
3156 echo "$as_me:$LINENO:" \
3157      "checking for C compiler version" >&5
3158 ac_compiler=`set X $ac_compile; echo $2`
3159 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3160   (eval $ac_compiler --version </dev/null >&5) 2>&5
3161   ac_status=$?
3162   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3163   (exit $ac_status); }
3164 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3165   (eval $ac_compiler -v </dev/null >&5) 2>&5
3166   ac_status=$?
3167   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3168   (exit $ac_status); }
3169 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3170   (eval $ac_compiler -V </dev/null >&5) 2>&5
3171   ac_status=$?
3172   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3173   (exit $ac_status); }
3174
3175 cat >conftest.$ac_ext <<_ACEOF
3176 /* confdefs.h.  */
3177 _ACEOF
3178 cat confdefs.h >>conftest.$ac_ext
3179 cat >>conftest.$ac_ext <<_ACEOF
3180 /* end confdefs.h.  */
3181
3182 int
3183 main ()
3184 {
3185
3186   ;
3187   return 0;
3188 }
3189 _ACEOF
3190 ac_clean_files_save=$ac_clean_files
3191 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3192 # Try to create an executable without -o first, disregard a.out.
3193 # It will help us diagnose broken compilers, and finding out an intuition
3194 # of exeext.
3195 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3196 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3197 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3198 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3199   (eval $ac_link_default) 2>&5
3200   ac_status=$?
3201   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3202   (exit $ac_status); }; then
3203   # Find the output, starting from the most likely.  This scheme is
3204 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3205 # resort.
3206
3207 # Be careful to initialize this variable, since it used to be cached.
3208 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3209 ac_cv_exeext=
3210 # b.out is created by i960 compilers.
3211 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3212 do
3213   test -f "$ac_file" || continue
3214   case $ac_file in
3215     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3216         ;;
3217     conftest.$ac_ext )
3218         # This is the source file.
3219         ;;
3220     [ab].out )
3221         # We found the default executable, but exeext='' is most
3222         # certainly right.
3223         break;;
3224     *.* )
3225         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3226         # FIXME: I believe we export ac_cv_exeext for Libtool,
3227         # but it would be cool to find out if it's true.  Does anybody
3228         # maintain Libtool? --akim.
3229         export ac_cv_exeext
3230         break;;
3231     * )
3232         break;;
3233   esac
3234 done
3235 else
3236   echo "$as_me: failed program was:" >&5
3237 sed 's/^/| /' conftest.$ac_ext >&5
3238
3239 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3240 See \`config.log' for more details." >&5
3241 echo "$as_me: error: C compiler cannot create executables
3242 See \`config.log' for more details." >&2;}
3243    { (exit 77); exit 77; }; }
3244 fi
3245
3246 ac_exeext=$ac_cv_exeext
3247 echo "$as_me:$LINENO: result: $ac_file" >&5
3248 echo "${ECHO_T}$ac_file" >&6
3249
3250 # Check the compiler produces executables we can run.  If not, either
3251 # the compiler is broken, or we cross compile.
3252 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3253 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3254 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3255 # If not cross compiling, check that we can run a simple program.
3256 if test "$cross_compiling" != yes; then
3257   if { ac_try='./$ac_file'
3258   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3259   (eval $ac_try) 2>&5
3260   ac_status=$?
3261   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3262   (exit $ac_status); }; }; then
3263     cross_compiling=no
3264   else
3265     if test "$cross_compiling" = maybe; then
3266         cross_compiling=yes
3267     else
3268         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3269 If you meant to cross compile, use \`--host'.
3270 See \`config.log' for more details." >&5
3271 echo "$as_me: error: cannot run C compiled programs.
3272 If you meant to cross compile, use \`--host'.
3273 See \`config.log' for more details." >&2;}
3274    { (exit 1); exit 1; }; }
3275     fi
3276   fi
3277 fi
3278 echo "$as_me:$LINENO: result: yes" >&5
3279 echo "${ECHO_T}yes" >&6
3280
3281 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3282 ac_clean_files=$ac_clean_files_save
3283 # Check the compiler produces executables we can run.  If not, either
3284 # the compiler is broken, or we cross compile.
3285 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3286 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3287 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3288 echo "${ECHO_T}$cross_compiling" >&6
3289
3290 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3291 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3292 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3293   (eval $ac_link) 2>&5
3294   ac_status=$?
3295   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3296   (exit $ac_status); }; then
3297   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3298 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3299 # work properly (i.e., refer to `conftest.exe'), while it won't with
3300 # `rm'.
3301 for ac_file in conftest.exe conftest conftest.*; do
3302   test -f "$ac_file" || continue
3303   case $ac_file in
3304     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3305     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3306           export ac_cv_exeext
3307           break;;
3308     * ) break;;
3309   esac
3310 done
3311 else
3312   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3313 See \`config.log' for more details." >&5
3314 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3315 See \`config.log' for more details." >&2;}
3316    { (exit 1); exit 1; }; }
3317 fi
3318
3319 rm -f conftest$ac_cv_exeext
3320 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3321 echo "${ECHO_T}$ac_cv_exeext" >&6
3322
3323 rm -f conftest.$ac_ext
3324 EXEEXT=$ac_cv_exeext
3325 ac_exeext=$EXEEXT
3326 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3327 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3328 if test "${ac_cv_objext+set}" = set; then
3329   echo $ECHO_N "(cached) $ECHO_C" >&6
3330 else
3331   cat >conftest.$ac_ext <<_ACEOF
3332 /* confdefs.h.  */
3333 _ACEOF
3334 cat confdefs.h >>conftest.$ac_ext
3335 cat >>conftest.$ac_ext <<_ACEOF
3336 /* end confdefs.h.  */
3337
3338 int
3339 main ()
3340 {
3341
3342   ;
3343   return 0;
3344 }
3345 _ACEOF
3346 rm -f conftest.o conftest.obj
3347 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3348   (eval $ac_compile) 2>&5
3349   ac_status=$?
3350   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3351   (exit $ac_status); }; then
3352   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3353   case $ac_file in
3354     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3355     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3356        break;;
3357   esac
3358 done
3359 else
3360   echo "$as_me: failed program was:" >&5
3361 sed 's/^/| /' conftest.$ac_ext >&5
3362
3363 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3364 See \`config.log' for more details." >&5
3365 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3366 See \`config.log' for more details." >&2;}
3367    { (exit 1); exit 1; }; }
3368 fi
3369
3370 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3371 fi
3372 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3373 echo "${ECHO_T}$ac_cv_objext" >&6
3374 OBJEXT=$ac_cv_objext
3375 ac_objext=$OBJEXT
3376 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3377 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3378 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3379   echo $ECHO_N "(cached) $ECHO_C" >&6
3380 else
3381   cat >conftest.$ac_ext <<_ACEOF
3382 /* confdefs.h.  */
3383 _ACEOF
3384 cat confdefs.h >>conftest.$ac_ext
3385 cat >>conftest.$ac_ext <<_ACEOF
3386 /* end confdefs.h.  */
3387
3388 int
3389 main ()
3390 {
3391 #ifndef __GNUC__
3392        choke me
3393 #endif
3394
3395   ;
3396   return 0;
3397 }
3398 _ACEOF
3399 rm -f conftest.$ac_objext
3400 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3401   (eval $ac_compile) 2>conftest.er1
3402   ac_status=$?
3403   grep -v '^ *+' conftest.er1 >conftest.err
3404   rm -f conftest.er1
3405   cat conftest.err >&5
3406   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3407   (exit $ac_status); } &&
3408          { ac_try='test -z "$ac_c_werror_flag"
3409                          || test ! -s conftest.err'
3410   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3411   (eval $ac_try) 2>&5
3412   ac_status=$?
3413   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3414   (exit $ac_status); }; } &&
3415          { ac_try='test -s conftest.$ac_objext'
3416   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3417   (eval $ac_try) 2>&5
3418   ac_status=$?
3419   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3420   (exit $ac_status); }; }; then
3421   ac_compiler_gnu=yes
3422 else
3423   echo "$as_me: failed program was:" >&5
3424 sed 's/^/| /' conftest.$ac_ext >&5
3425
3426 ac_compiler_gnu=no
3427 fi
3428 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3429 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3430
3431 fi
3432 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3433 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3434 GCC=`test $ac_compiler_gnu = yes && echo yes`
3435 ac_test_CFLAGS=${CFLAGS+set}
3436 ac_save_CFLAGS=$CFLAGS
3437 CFLAGS="-g"
3438 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3439 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3440 if test "${ac_cv_prog_cc_g+set}" = set; then
3441   echo $ECHO_N "(cached) $ECHO_C" >&6
3442 else
3443   cat >conftest.$ac_ext <<_ACEOF
3444 /* confdefs.h.  */
3445 _ACEOF
3446 cat confdefs.h >>conftest.$ac_ext
3447 cat >>conftest.$ac_ext <<_ACEOF
3448 /* end confdefs.h.  */
3449
3450 int
3451 main ()
3452 {
3453
3454   ;
3455   return 0;
3456 }
3457 _ACEOF
3458 rm -f conftest.$ac_objext
3459 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3460   (eval $ac_compile) 2>conftest.er1
3461   ac_status=$?
3462   grep -v '^ *+' conftest.er1 >conftest.err
3463   rm -f conftest.er1
3464   cat conftest.err >&5
3465   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3466   (exit $ac_status); } &&
3467          { ac_try='test -z "$ac_c_werror_flag"
3468                          || test ! -s conftest.err'
3469   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3470   (eval $ac_try) 2>&5
3471   ac_status=$?
3472   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3473   (exit $ac_status); }; } &&
3474          { ac_try='test -s conftest.$ac_objext'
3475   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3476   (eval $ac_try) 2>&5
3477   ac_status=$?
3478   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3479   (exit $ac_status); }; }; then
3480   ac_cv_prog_cc_g=yes
3481 else
3482   echo "$as_me: failed program was:" >&5
3483 sed 's/^/| /' conftest.$ac_ext >&5
3484
3485 ac_cv_prog_cc_g=no
3486 fi
3487 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3488 fi
3489 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3490 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3491 if test "$ac_test_CFLAGS" = set; then
3492   CFLAGS=$ac_save_CFLAGS
3493 elif test $ac_cv_prog_cc_g = yes; then
3494   if test "$GCC" = yes; then
3495     CFLAGS="-g -O2"
3496   else
3497     CFLAGS="-g"
3498   fi
3499 else
3500   if test "$GCC" = yes; then
3501     CFLAGS="-O2"
3502   else
3503     CFLAGS=
3504   fi
3505 fi
3506 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3507 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3508 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3509   echo $ECHO_N "(cached) $ECHO_C" >&6
3510 else
3511   ac_cv_prog_cc_stdc=no
3512 ac_save_CC=$CC
3513 cat >conftest.$ac_ext <<_ACEOF
3514 /* confdefs.h.  */
3515 _ACEOF
3516 cat confdefs.h >>conftest.$ac_ext
3517 cat >>conftest.$ac_ext <<_ACEOF
3518 /* end confdefs.h.  */
3519 #include <stdarg.h>
3520 #include <stdio.h>
3521 #include <sys/types.h>
3522 #include <sys/stat.h>
3523 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3524 struct buf { int x; };
3525 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3526 static char *e (p, i)
3527      char **p;
3528      int i;
3529 {
3530   return p[i];
3531 }
3532 static char *f (char * (*g) (char **, int), char **p, ...)
3533 {
3534   char *s;
3535   va_list v;
3536   va_start (v,p);
3537   s = g (p, va_arg (v,int));
3538   va_end (v);
3539   return s;
3540 }
3541
3542 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3543    function prototypes and stuff, but not '\xHH' hex character constants.
3544    These don't provoke an error unfortunately, instead are silently treated
3545    as 'x'.  The following induces an error, until -std1 is added to get
3546    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3547    array size at least.  It's necessary to write '\x00'==0 to get something
3548    that's true only with -std1.  */
3549 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3550
3551 int test (int i, double x);
3552 struct s1 {int (*f) (int a);};
3553 struct s2 {int (*f) (double a);};
3554 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3555 int argc;
3556 char **argv;
3557 int
3558 main ()
3559 {
3560 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3561   ;
3562   return 0;
3563 }
3564 _ACEOF
3565 # Don't try gcc -ansi; that turns off useful extensions and
3566 # breaks some systems' header files.
3567 # AIX                   -qlanglvl=ansi
3568 # Ultrix and OSF/1      -std1
3569 # HP-UX 10.20 and later -Ae
3570 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3571 # SVR4                  -Xc -D__EXTENSIONS__
3572 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3573 do
3574   CC="$ac_save_CC $ac_arg"
3575   rm -f conftest.$ac_objext
3576 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3577   (eval $ac_compile) 2>conftest.er1
3578   ac_status=$?
3579   grep -v '^ *+' conftest.er1 >conftest.err
3580   rm -f conftest.er1
3581   cat conftest.err >&5
3582   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3583   (exit $ac_status); } &&
3584          { ac_try='test -z "$ac_c_werror_flag"
3585                          || test ! -s conftest.err'
3586   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3587   (eval $ac_try) 2>&5
3588   ac_status=$?
3589   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3590   (exit $ac_status); }; } &&
3591          { ac_try='test -s conftest.$ac_objext'
3592   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3593   (eval $ac_try) 2>&5
3594   ac_status=$?
3595   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3596   (exit $ac_status); }; }; then
3597   ac_cv_prog_cc_stdc=$ac_arg
3598 break
3599 else
3600   echo "$as_me: failed program was:" >&5
3601 sed 's/^/| /' conftest.$ac_ext >&5
3602
3603 fi
3604 rm -f conftest.err conftest.$ac_objext
3605 done
3606 rm -f conftest.$ac_ext conftest.$ac_objext
3607 CC=$ac_save_CC
3608
3609 fi
3610
3611 case "x$ac_cv_prog_cc_stdc" in
3612   x|xno)
3613     echo "$as_me:$LINENO: result: none needed" >&5
3614 echo "${ECHO_T}none needed" >&6 ;;
3615   *)
3616     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3617 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3618     CC="$CC $ac_cv_prog_cc_stdc" ;;
3619 esac
3620
3621 # Some people use a C++ compiler to compile C.  Since we use `exit',
3622 # in C++ we need to declare it.  In case someone uses the same compiler
3623 # for both compiling C and C++ we need to have the C++ compiler decide
3624 # the declaration of exit, since it's the most demanding environment.
3625 cat >conftest.$ac_ext <<_ACEOF
3626 #ifndef __cplusplus
3627   choke me
3628 #endif
3629 _ACEOF
3630 rm -f conftest.$ac_objext
3631 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3632   (eval $ac_compile) 2>conftest.er1
3633   ac_status=$?
3634   grep -v '^ *+' conftest.er1 >conftest.err
3635   rm -f conftest.er1
3636   cat conftest.err >&5
3637   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3638   (exit $ac_status); } &&
3639          { ac_try='test -z "$ac_c_werror_flag"
3640                          || test ! -s conftest.err'
3641   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3642   (eval $ac_try) 2>&5
3643   ac_status=$?
3644   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3645   (exit $ac_status); }; } &&
3646          { ac_try='test -s conftest.$ac_objext'
3647   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3648   (eval $ac_try) 2>&5
3649   ac_status=$?
3650   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3651   (exit $ac_status); }; }; then
3652   for ac_declaration in \
3653    '' \
3654    'extern "C" void std::exit (int) throw (); using std::exit;' \
3655    'extern "C" void std::exit (int); using std::exit;' \
3656    'extern "C" void exit (int) throw ();' \
3657    'extern "C" void exit (int);' \
3658    'void exit (int);'
3659 do
3660   cat >conftest.$ac_ext <<_ACEOF
3661 /* confdefs.h.  */
3662 _ACEOF
3663 cat confdefs.h >>conftest.$ac_ext
3664 cat >>conftest.$ac_ext <<_ACEOF
3665 /* end confdefs.h.  */
3666 $ac_declaration
3667 #include <stdlib.h>
3668 int
3669 main ()
3670 {
3671 exit (42);
3672   ;
3673   return 0;
3674 }
3675 _ACEOF
3676 rm -f conftest.$ac_objext
3677 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3678   (eval $ac_compile) 2>conftest.er1
3679   ac_status=$?
3680   grep -v '^ *+' conftest.er1 >conftest.err
3681   rm -f conftest.er1
3682   cat conftest.err >&5
3683   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3684   (exit $ac_status); } &&
3685          { ac_try='test -z "$ac_c_werror_flag"
3686                          || test ! -s conftest.err'
3687   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3688   (eval $ac_try) 2>&5
3689   ac_status=$?
3690   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3691   (exit $ac_status); }; } &&
3692          { ac_try='test -s conftest.$ac_objext'
3693   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3694   (eval $ac_try) 2>&5
3695   ac_status=$?
3696   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3697   (exit $ac_status); }; }; then
3698   :
3699 else
3700   echo "$as_me: failed program was:" >&5
3701 sed 's/^/| /' conftest.$ac_ext >&5
3702
3703 continue
3704 fi
3705 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3706   cat >conftest.$ac_ext <<_ACEOF
3707 /* confdefs.h.  */
3708 _ACEOF
3709 cat confdefs.h >>conftest.$ac_ext
3710 cat >>conftest.$ac_ext <<_ACEOF
3711 /* end confdefs.h.  */
3712 $ac_declaration
3713 int
3714 main ()
3715 {
3716 exit (42);
3717   ;
3718   return 0;
3719 }
3720 _ACEOF
3721 rm -f conftest.$ac_objext
3722 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3723   (eval $ac_compile) 2>conftest.er1
3724   ac_status=$?
3725   grep -v '^ *+' conftest.er1 >conftest.err
3726   rm -f conftest.er1
3727   cat conftest.err >&5
3728   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3729   (exit $ac_status); } &&
3730          { ac_try='test -z "$ac_c_werror_flag"
3731                          || test ! -s conftest.err'
3732   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3733   (eval $ac_try) 2>&5
3734   ac_status=$?
3735   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3736   (exit $ac_status); }; } &&
3737          { ac_try='test -s conftest.$ac_objext'
3738   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3739   (eval $ac_try) 2>&5
3740   ac_status=$?
3741   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3742   (exit $ac_status); }; }; then
3743   break
3744 else
3745   echo "$as_me: failed program was:" >&5
3746 sed 's/^/| /' conftest.$ac_ext >&5
3747
3748 fi
3749 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3750 done
3751 rm -f conftest*
3752 if test -n "$ac_declaration"; then
3753   echo '#ifdef __cplusplus' >>confdefs.h
3754   echo $ac_declaration      >>confdefs.h
3755   echo '#endif'             >>confdefs.h
3756 fi
3757
3758 else
3759   echo "$as_me: failed program was:" >&5
3760 sed 's/^/| /' conftest.$ac_ext >&5
3761
3762 fi
3763 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3764 ac_ext=c
3765 ac_cpp='$CPP $CPPFLAGS'
3766 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3767 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3768 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3769
3770 ac_ext=cc
3771 ac_cpp='$CXXCPP $CPPFLAGS'
3772 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3773 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3774 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3775 if test -n "$ac_tool_prefix"; then
3776   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3777   do
3778     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3779 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3780 echo "$as_me:$LINENO: checking for $ac_word" >&5
3781 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3782 if test "${ac_cv_prog_CXX+set}" = set; then
3783   echo $ECHO_N "(cached) $ECHO_C" >&6
3784 else
3785   if test -n "$CXX"; then
3786   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3787 else
3788 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3789 for as_dir in $PATH
3790 do
3791   IFS=$as_save_IFS
3792   test -z "$as_dir" && as_dir=.
3793   for ac_exec_ext in '' $ac_executable_extensions; do
3794   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3795     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3796     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3797     break 2
3798   fi
3799 done
3800 done
3801
3802 fi
3803 fi
3804 CXX=$ac_cv_prog_CXX
3805 if test -n "$CXX"; then
3806   echo "$as_me:$LINENO: result: $CXX" >&5
3807 echo "${ECHO_T}$CXX" >&6
3808 else
3809   echo "$as_me:$LINENO: result: no" >&5
3810 echo "${ECHO_T}no" >&6
3811 fi
3812
3813     test -n "$CXX" && break
3814   done
3815 fi
3816 if test -z "$CXX"; then
3817   ac_ct_CXX=$CXX
3818   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3819 do
3820   # Extract the first word of "$ac_prog", so it can be a program name with args.
3821 set dummy $ac_prog; ac_word=$2
3822 echo "$as_me:$LINENO: checking for $ac_word" >&5
3823 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3824 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3825   echo $ECHO_N "(cached) $ECHO_C" >&6
3826 else
3827   if test -n "$ac_ct_CXX"; then
3828   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3829 else
3830 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3831 for as_dir in $PATH
3832 do
3833   IFS=$as_save_IFS
3834   test -z "$as_dir" && as_dir=.
3835   for ac_exec_ext in '' $ac_executable_extensions; do
3836   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3837     ac_cv_prog_ac_ct_CXX="$ac_prog"
3838     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3839     break 2
3840   fi
3841 done
3842 done
3843
3844 fi
3845 fi
3846 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3847 if test -n "$ac_ct_CXX"; then
3848   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3849 echo "${ECHO_T}$ac_ct_CXX" >&6
3850 else
3851   echo "$as_me:$LINENO: result: no" >&5
3852 echo "${ECHO_T}no" >&6
3853 fi
3854
3855   test -n "$ac_ct_CXX" && break
3856 done
3857 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3858
3859   CXX=$ac_ct_CXX
3860 fi
3861
3862
3863 # Provide some information about the compiler.
3864 echo "$as_me:$LINENO:" \
3865      "checking for C++ compiler version" >&5
3866 ac_compiler=`set X $ac_compile; echo $2`
3867 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3868   (eval $ac_compiler --version </dev/null >&5) 2>&5
3869   ac_status=$?
3870   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3871   (exit $ac_status); }
3872 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3873   (eval $ac_compiler -v </dev/null >&5) 2>&5
3874   ac_status=$?
3875   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3876   (exit $ac_status); }
3877 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3878   (eval $ac_compiler -V </dev/null >&5) 2>&5
3879   ac_status=$?
3880   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3881   (exit $ac_status); }
3882
3883 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3884 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3885 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3886   echo $ECHO_N "(cached) $ECHO_C" >&6
3887 else
3888   cat >conftest.$ac_ext <<_ACEOF
3889 /* confdefs.h.  */
3890 _ACEOF
3891 cat confdefs.h >>conftest.$ac_ext
3892 cat >>conftest.$ac_ext <<_ACEOF
3893 /* end confdefs.h.  */
3894
3895 int
3896 main ()
3897 {
3898 #ifndef __GNUC__
3899        choke me
3900 #endif
3901
3902   ;
3903   return 0;
3904 }
3905 _ACEOF
3906 rm -f conftest.$ac_objext
3907 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3908   (eval $ac_compile) 2>conftest.er1
3909   ac_status=$?
3910   grep -v '^ *+' conftest.er1 >conftest.err
3911   rm -f conftest.er1
3912   cat conftest.err >&5
3913   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3914   (exit $ac_status); } &&
3915          { ac_try='test -z "$ac_cxx_werror_flag"
3916                          || test ! -s conftest.err'
3917   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3918   (eval $ac_try) 2>&5
3919   ac_status=$?
3920   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3921   (exit $ac_status); }; } &&
3922          { ac_try='test -s conftest.$ac_objext'
3923   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3924   (eval $ac_try) 2>&5
3925   ac_status=$?
3926   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3927   (exit $ac_status); }; }; then
3928   ac_compiler_gnu=yes
3929 else
3930   echo "$as_me: failed program was:" >&5
3931 sed 's/^/| /' conftest.$ac_ext >&5
3932
3933 ac_compiler_gnu=no
3934 fi
3935 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3936 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3937
3938 fi
3939 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3940 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
3941 GXX=`test $ac_compiler_gnu = yes && echo yes`
3942 ac_test_CXXFLAGS=${CXXFLAGS+set}
3943 ac_save_CXXFLAGS=$CXXFLAGS
3944 CXXFLAGS="-g"
3945 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3946 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
3947 if test "${ac_cv_prog_cxx_g+set}" = set; then
3948   echo $ECHO_N "(cached) $ECHO_C" >&6
3949 else
3950   cat >conftest.$ac_ext <<_ACEOF
3951 /* confdefs.h.  */
3952 _ACEOF
3953 cat confdefs.h >>conftest.$ac_ext
3954 cat >>conftest.$ac_ext <<_ACEOF
3955 /* end confdefs.h.  */
3956
3957 int
3958 main ()
3959 {
3960
3961   ;
3962   return 0;
3963 }
3964 _ACEOF
3965 rm -f conftest.$ac_objext
3966 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3967   (eval $ac_compile) 2>conftest.er1
3968   ac_status=$?
3969   grep -v '^ *+' conftest.er1 >conftest.err
3970   rm -f conftest.er1
3971   cat conftest.err >&5
3972   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3973   (exit $ac_status); } &&
3974          { ac_try='test -z "$ac_cxx_werror_flag"
3975                          || test ! -s conftest.err'
3976   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3977   (eval $ac_try) 2>&5
3978   ac_status=$?
3979   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3980   (exit $ac_status); }; } &&
3981          { ac_try='test -s conftest.$ac_objext'
3982   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3983   (eval $ac_try) 2>&5
3984   ac_status=$?
3985   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3986   (exit $ac_status); }; }; then
3987   ac_cv_prog_cxx_g=yes
3988 else
3989   echo "$as_me: failed program was:" >&5
3990 sed 's/^/| /' conftest.$ac_ext >&5
3991
3992 ac_cv_prog_cxx_g=no
3993 fi
3994 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3995 fi
3996 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3997 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
3998 if test "$ac_test_CXXFLAGS" = set; then
3999   CXXFLAGS=$ac_save_CXXFLAGS
4000 elif test $ac_cv_prog_cxx_g = yes; then
4001   if test "$GXX" = yes; then
4002     CXXFLAGS="-g -O2"
4003   else
4004     CXXFLAGS="-g"
4005   fi
4006 else
4007   if test "$GXX" = yes; then
4008     CXXFLAGS="-O2"
4009   else
4010     CXXFLAGS=
4011   fi
4012 fi
4013 for ac_declaration in \
4014    '' \
4015    'extern "C" void std::exit (int) throw (); using std::exit;' \
4016    'extern "C" void std::exit (int); using std::exit;' \
4017    'extern "C" void exit (int) throw ();' \
4018    'extern "C" void exit (int);' \
4019    'void exit (int);'
4020 do
4021   cat >conftest.$ac_ext <<_ACEOF
4022 /* confdefs.h.  */
4023 _ACEOF
4024 cat confdefs.h >>conftest.$ac_ext
4025 cat >>conftest.$ac_ext <<_ACEOF
4026 /* end confdefs.h.  */
4027 $ac_declaration
4028 #include <stdlib.h>
4029 int
4030 main ()
4031 {
4032 exit (42);
4033   ;
4034   return 0;
4035 }
4036 _ACEOF
4037 rm -f conftest.$ac_objext
4038 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4039   (eval $ac_compile) 2>conftest.er1
4040   ac_status=$?
4041   grep -v '^ *+' conftest.er1 >conftest.err
4042   rm -f conftest.er1
4043   cat conftest.err >&5
4044   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4045   (exit $ac_status); } &&
4046          { ac_try='test -z "$ac_cxx_werror_flag"
4047                          || test ! -s conftest.err'
4048   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4049   (eval $ac_try) 2>&5
4050   ac_status=$?
4051   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4052   (exit $ac_status); }; } &&
4053          { ac_try='test -s conftest.$ac_objext'
4054   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4055   (eval $ac_try) 2>&5
4056   ac_status=$?
4057   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4058   (exit $ac_status); }; }; then
4059   :
4060 else
4061   echo "$as_me: failed program was:" >&5
4062 sed 's/^/| /' conftest.$ac_ext >&5
4063
4064 continue
4065 fi
4066 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4067   cat >conftest.$ac_ext <<_ACEOF
4068 /* confdefs.h.  */
4069 _ACEOF
4070 cat confdefs.h >>conftest.$ac_ext
4071 cat >>conftest.$ac_ext <<_ACEOF
4072 /* end confdefs.h.  */
4073 $ac_declaration
4074 int
4075 main ()
4076 {
4077 exit (42);
4078   ;
4079   return 0;
4080 }
4081 _ACEOF
4082 rm -f conftest.$ac_objext
4083 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4084   (eval $ac_compile) 2>conftest.er1
4085   ac_status=$?
4086   grep -v '^ *+' conftest.er1 >conftest.err
4087   rm -f conftest.er1
4088   cat conftest.err >&5
4089   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4090   (exit $ac_status); } &&
4091          { ac_try='test -z "$ac_cxx_werror_flag"
4092                          || test ! -s conftest.err'
4093   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4094   (eval $ac_try) 2>&5
4095   ac_status=$?
4096   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4097   (exit $ac_status); }; } &&
4098          { ac_try='test -s conftest.$ac_objext'
4099   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4100   (eval $ac_try) 2>&5
4101   ac_status=$?
4102   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4103   (exit $ac_status); }; }; then
4104   break
4105 else
4106   echo "$as_me: failed program was:" >&5
4107 sed 's/^/| /' conftest.$ac_ext >&5
4108
4109 fi
4110 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4111 done
4112 rm -f conftest*
4113 if test -n "$ac_declaration"; then
4114   echo '#ifdef __cplusplus' >>confdefs.h
4115   echo $ac_declaration      >>confdefs.h
4116   echo '#endif'             >>confdefs.h
4117 fi
4118
4119 ac_ext=c
4120 ac_cpp='$CPP $CPPFLAGS'
4121 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4122 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4123 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4124
4125
4126 # We must set the default linker to the linker used by gcc for the correct
4127 # operation of libtool.  If LD is not defined and we are using gcc, try to
4128 # set the LD default to the ld used by gcc.
4129 if test -z "$LD"; then
4130   if test "$GCC" = yes; then
4131     case $build in
4132     *-*-mingw*)
4133       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4134     *)
4135       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4136     esac
4137     case $gcc_prog_ld in
4138     # Accept absolute paths.
4139     [\\/]* | [A-Za-z]:[\\/]*)
4140       LD="$gcc_prog_ld" ;;
4141     esac
4142   fi
4143 fi
4144
4145
4146
4147
4148 if test -n "$ac_tool_prefix"; then
4149   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4150 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4151 echo "$as_me:$LINENO: checking for $ac_word" >&5
4152 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4153 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4154   echo $ECHO_N "(cached) $ECHO_C" >&6
4155 else
4156   if test -n "$GNATBIND"; then
4157   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4158 else
4159 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4160 for as_dir in $PATH
4161 do
4162   IFS=$as_save_IFS
4163   test -z "$as_dir" && as_dir=.
4164   for ac_exec_ext in '' $ac_executable_extensions; do
4165   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4166     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4167     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4168     break 2
4169   fi
4170 done
4171 done
4172
4173 fi
4174 fi
4175 GNATBIND=$ac_cv_prog_GNATBIND
4176 if test -n "$GNATBIND"; then
4177   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4178 echo "${ECHO_T}$GNATBIND" >&6
4179 else
4180   echo "$as_me:$LINENO: result: no" >&5
4181 echo "${ECHO_T}no" >&6
4182 fi
4183
4184 fi
4185 if test -z "$ac_cv_prog_GNATBIND"; then
4186   ac_ct_GNATBIND=$GNATBIND
4187   # Extract the first word of "gnatbind", so it can be a program name with args.
4188 set dummy gnatbind; ac_word=$2
4189 echo "$as_me:$LINENO: checking for $ac_word" >&5
4190 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4191 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4192   echo $ECHO_N "(cached) $ECHO_C" >&6
4193 else
4194   if test -n "$ac_ct_GNATBIND"; then
4195   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4196 else
4197 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4198 for as_dir in $PATH
4199 do
4200   IFS=$as_save_IFS
4201   test -z "$as_dir" && as_dir=.
4202   for ac_exec_ext in '' $ac_executable_extensions; do
4203   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4204     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4205     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4206     break 2
4207   fi
4208 done
4209 done
4210
4211   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4212 fi
4213 fi
4214 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4215 if test -n "$ac_ct_GNATBIND"; then
4216   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4217 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4218 else
4219   echo "$as_me:$LINENO: result: no" >&5
4220 echo "${ECHO_T}no" >&6
4221 fi
4222
4223   GNATBIND=$ac_ct_GNATBIND
4224 else
4225   GNATBIND="$ac_cv_prog_GNATBIND"
4226 fi
4227
4228 if test -n "$ac_tool_prefix"; then
4229   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4230 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4231 echo "$as_me:$LINENO: checking for $ac_word" >&5
4232 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4233 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4234   echo $ECHO_N "(cached) $ECHO_C" >&6
4235 else
4236   if test -n "$GNATMAKE"; then
4237   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4238 else
4239 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4240 for as_dir in $PATH
4241 do
4242   IFS=$as_save_IFS
4243   test -z "$as_dir" && as_dir=.
4244   for ac_exec_ext in '' $ac_executable_extensions; do
4245   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4246     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4247     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4248     break 2
4249   fi
4250 done
4251 done
4252
4253 fi
4254 fi
4255 GNATMAKE=$ac_cv_prog_GNATMAKE
4256 if test -n "$GNATMAKE"; then
4257   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4258 echo "${ECHO_T}$GNATMAKE" >&6
4259 else
4260   echo "$as_me:$LINENO: result: no" >&5
4261 echo "${ECHO_T}no" >&6
4262 fi
4263
4264 fi
4265 if test -z "$ac_cv_prog_GNATMAKE"; then
4266   ac_ct_GNATMAKE=$GNATMAKE
4267   # Extract the first word of "gnatmake", so it can be a program name with args.
4268 set dummy gnatmake; ac_word=$2
4269 echo "$as_me:$LINENO: checking for $ac_word" >&5
4270 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4271 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4272   echo $ECHO_N "(cached) $ECHO_C" >&6
4273 else
4274   if test -n "$ac_ct_GNATMAKE"; then
4275   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4276 else
4277 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4278 for as_dir in $PATH
4279 do
4280   IFS=$as_save_IFS
4281   test -z "$as_dir" && as_dir=.
4282   for ac_exec_ext in '' $ac_executable_extensions; do
4283   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4284     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4285     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4286     break 2
4287   fi
4288 done
4289 done
4290
4291   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4292 fi
4293 fi
4294 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4295 if test -n "$ac_ct_GNATMAKE"; then
4296   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4297 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4298 else
4299   echo "$as_me:$LINENO: result: no" >&5
4300 echo "${ECHO_T}no" >&6
4301 fi
4302
4303   GNATMAKE=$ac_ct_GNATMAKE
4304 else
4305   GNATMAKE="$ac_cv_prog_GNATMAKE"
4306 fi
4307
4308 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4309 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4310 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4311   echo $ECHO_N "(cached) $ECHO_C" >&6
4312 else
4313   cat >conftest.adb <<EOF
4314 procedure conftest is begin null; end conftest;
4315 EOF
4316 acx_cv_cc_gcc_supports_ada=no
4317 # There is a bug in old released versions of GCC which causes the
4318 # driver to exit successfully when the appropriate language module
4319 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4320 # Therefore we must check for the error message as well as an
4321 # unsuccessful exit.
4322 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4323 # given a .adb file, but produce no object file.  So we must check
4324 # if an object file was really produced to guard against this.
4325 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4326 if test x"$errors" = x && test -f conftest.$ac_objext; then
4327   acx_cv_cc_gcc_supports_ada=yes
4328 fi
4329 rm -f conftest.*
4330 fi
4331 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4332 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4333
4334 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4335   have_gnat=yes
4336 else
4337   have_gnat=no
4338 fi
4339
4340 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4341 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4342 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4343   echo $ECHO_N "(cached) $ECHO_C" >&6
4344 else
4345    echo abfoo >t1
4346   echo cdfoo >t2
4347   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4348   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4349     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4350       :
4351     else
4352       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4353     fi
4354   fi
4355   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4356     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4357       :
4358     else
4359       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4360     fi
4361   fi
4362   rm t1 t2
4363
4364 fi
4365 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4366 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4367 do_compare="$gcc_cv_prog_cmp_skip"
4368
4369
4370
4371 # Check for GMP and MPFR
4372 gmplibs="-lmpfr -lgmp"
4373 gmpinc=
4374 have_gmp=no
4375
4376 # Specify a location for mpfr
4377 # check for this first so it ends up on the link line before gmp.
4378
4379 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4380 if test "${with_mpfr_dir+set}" = set; then
4381   withval="$with_mpfr_dir"
4382   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4383 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4384 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4385 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4386    { (exit 1); exit 1; }; }
4387 fi;
4388
4389
4390 # Check whether --with-mpfr or --without-mpfr was given.
4391 if test "${with_mpfr+set}" = set; then
4392   withval="$with_mpfr"
4393
4394 fi;
4395
4396 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4397 if test "${with_mpfr_include+set}" = set; then
4398   withval="$with_mpfr_include"
4399
4400 fi;
4401
4402 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4403 if test "${with_mpfr_lib+set}" = set; then
4404   withval="$with_mpfr_lib"
4405
4406 fi;
4407
4408 if test "x$with_mpfr" != x; then
4409   gmplibs="-L$with_mpfr/lib $gmplibs"
4410   gmpinc="-I$with_mpfr/include"
4411 fi
4412 if test "x$with_mpfr_include" != x; then
4413   gmpinc="-I$with_mpfr_include"
4414 fi
4415 if test "x$with_mpfr_lib" != x; then
4416   gmplibs="-L$with_mpfr_lib $gmplibs"
4417 fi
4418 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4419   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4420   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4421   # Do not test the mpfr version.  Assume that it is sufficient, since
4422   # it is in the source tree, and the library has not been built yet
4423   # but it would be included on the link line in the version check below
4424   # hence making the test fail.
4425   have_gmp=yes
4426 fi
4427
4428 # Specify a location for gmp
4429
4430 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4431 if test "${with_gmp_dir+set}" = set; then
4432   withval="$with_gmp_dir"
4433   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4434 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4435 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4436 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4437    { (exit 1); exit 1; }; }
4438 fi;
4439
4440
4441 # Check whether --with-gmp or --without-gmp was given.
4442 if test "${with_gmp+set}" = set; then
4443   withval="$with_gmp"
4444
4445 fi;
4446
4447 # Check whether --with-gmp_include or --without-gmp_include was given.
4448 if test "${with_gmp_include+set}" = set; then
4449   withval="$with_gmp_include"
4450
4451 fi;
4452
4453 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4454 if test "${with_gmp_lib+set}" = set; then
4455   withval="$with_gmp_lib"
4456
4457 fi;
4458
4459
4460 if test "x$with_gmp" != x; then
4461   gmplibs="-L$with_gmp/lib $gmplibs"
4462   gmpinc="-I$with_gmp/include $gmpinc"
4463 fi
4464 if test "x$with_gmp_include" != x; then
4465   gmpinc="-I$with_gmp_include $gmpinc"
4466 fi
4467 if test "x$with_gmp_lib" != x; then
4468   gmplibs="-L$with_gmp_lib $gmplibs"
4469 fi
4470 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4471   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4472   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4473   # Do not test the gmp version.  Assume that it is sufficient, since
4474   # it is in the source tree, and the library has not been built yet
4475   # but it would be included on the link line in the version check below
4476   # hence making the test fail.
4477   have_gmp=yes
4478 fi
4479
4480 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4481   have_gmp=yes
4482   saved_CFLAGS="$CFLAGS"
4483   CFLAGS="$CFLAGS $gmpinc"
4484   # Check GMP actually works
4485   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4486 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4487
4488 cat >conftest.$ac_ext <<_ACEOF
4489 /* confdefs.h.  */
4490 _ACEOF
4491 cat confdefs.h >>conftest.$ac_ext
4492 cat >>conftest.$ac_ext <<_ACEOF
4493 /* end confdefs.h.  */
4494 #include "gmp.h"
4495 int
4496 main ()
4497 {
4498
4499   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4500   choke me
4501   #endif
4502
4503   ;
4504   return 0;
4505 }
4506 _ACEOF
4507 rm -f conftest.$ac_objext
4508 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4509   (eval $ac_compile) 2>conftest.er1
4510   ac_status=$?
4511   grep -v '^ *+' conftest.er1 >conftest.err
4512   rm -f conftest.er1
4513   cat conftest.err >&5
4514   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4515   (exit $ac_status); } &&
4516          { ac_try='test -z "$ac_c_werror_flag"
4517                          || test ! -s conftest.err'
4518   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4519   (eval $ac_try) 2>&5
4520   ac_status=$?
4521   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4522   (exit $ac_status); }; } &&
4523          { ac_try='test -s conftest.$ac_objext'
4524   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4525   (eval $ac_try) 2>&5
4526   ac_status=$?
4527   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4528   (exit $ac_status); }; }; then
4529   echo "$as_me:$LINENO: result: yes" >&5
4530 echo "${ECHO_T}yes" >&6
4531 else
4532   echo "$as_me: failed program was:" >&5
4533 sed 's/^/| /' conftest.$ac_ext >&5
4534
4535 echo "$as_me:$LINENO: result: no" >&5
4536 echo "${ECHO_T}no" >&6; have_gmp=no
4537 fi
4538 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4539
4540   if test x"$have_gmp" = xyes; then
4541     saved_LIBS="$LIBS"
4542     LIBS="$LIBS $gmplibs"
4543         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4544 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4545     cat >conftest.$ac_ext <<_ACEOF
4546 /* confdefs.h.  */
4547 _ACEOF
4548 cat confdefs.h >>conftest.$ac_ext
4549 cat >>conftest.$ac_ext <<_ACEOF
4550 /* end confdefs.h.  */
4551 #include <gmp.h>
4552     #include <mpfr.h>
4553 int
4554 main ()
4555 {
4556
4557     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4558     choke me
4559     #endif
4560     mpfr_t n;
4561     mpfr_t x;
4562     int t;
4563     mpfr_init (n);
4564     mpfr_init (x);
4565     mpfr_atan2 (n, n, x, GMP_RNDN);
4566     mpfr_erfc (n, x, GMP_RNDN);
4567     mpfr_subnormalize (x, t, GMP_RNDN);
4568
4569   ;
4570   return 0;
4571 }
4572 _ACEOF
4573 rm -f conftest.$ac_objext conftest$ac_exeext
4574 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4575   (eval $ac_link) 2>conftest.er1
4576   ac_status=$?
4577   grep -v '^ *+' conftest.er1 >conftest.err
4578   rm -f conftest.er1
4579   cat conftest.err >&5
4580   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4581   (exit $ac_status); } &&
4582          { ac_try='test -z "$ac_c_werror_flag"
4583                          || test ! -s conftest.err'
4584   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4585   (eval $ac_try) 2>&5
4586   ac_status=$?
4587   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4588   (exit $ac_status); }; } &&
4589          { ac_try='test -s conftest$ac_exeext'
4590   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4591   (eval $ac_try) 2>&5
4592   ac_status=$?
4593   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4594   (exit $ac_status); }; }; then
4595   cat >conftest.$ac_ext <<_ACEOF
4596 /* confdefs.h.  */
4597 _ACEOF
4598 cat confdefs.h >>conftest.$ac_ext
4599 cat >>conftest.$ac_ext <<_ACEOF
4600 /* end confdefs.h.  */
4601 #include <gmp.h>
4602     #include <mpfr.h>
4603 int
4604 main ()
4605 {
4606
4607     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4608     choke me
4609     #endif
4610     mpfr_t n; mpfr_init(n);
4611
4612   ;
4613   return 0;
4614 }
4615 _ACEOF
4616 rm -f conftest.$ac_objext conftest$ac_exeext
4617 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4618   (eval $ac_link) 2>conftest.er1
4619   ac_status=$?
4620   grep -v '^ *+' conftest.er1 >conftest.err
4621   rm -f conftest.er1
4622   cat conftest.err >&5
4623   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4624   (exit $ac_status); } &&
4625          { ac_try='test -z "$ac_c_werror_flag"
4626                          || test ! -s conftest.err'
4627   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4628   (eval $ac_try) 2>&5
4629   ac_status=$?
4630   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4631   (exit $ac_status); }; } &&
4632          { ac_try='test -s conftest$ac_exeext'
4633   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4634   (eval $ac_try) 2>&5
4635   ac_status=$?
4636   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4637   (exit $ac_status); }; }; then
4638   echo "$as_me:$LINENO: result: yes" >&5
4639 echo "${ECHO_T}yes" >&6
4640 else
4641   echo "$as_me: failed program was:" >&5
4642 sed 's/^/| /' conftest.$ac_ext >&5
4643
4644 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4645 echo "${ECHO_T}buggy but acceptable" >&6
4646 fi
4647 rm -f conftest.err conftest.$ac_objext \
4648       conftest$ac_exeext conftest.$ac_ext
4649 else
4650   echo "$as_me: failed program was:" >&5
4651 sed 's/^/| /' conftest.$ac_ext >&5
4652
4653 echo "$as_me:$LINENO: result: no" >&5
4654 echo "${ECHO_T}no" >&6; have_gmp=no
4655 fi
4656 rm -f conftest.err conftest.$ac_objext \
4657       conftest$ac_exeext conftest.$ac_ext
4658       LIBS="$saved_LIBS"
4659   fi
4660   CFLAGS="$saved_CFLAGS"
4661
4662   if test x$have_gmp != xyes; then
4663     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4664 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4665 Copies of these libraries' source code can be found at their respective
4666 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4667 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4668 If you obtained GMP and/or MPFR from a vendor distribution package, make
4669 sure that you have installed both the libraries and the header files.
4670 They may be located in separate packages." >&5
4671 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4672 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4673 Copies of these libraries' source code can be found at their respective
4674 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4675 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4676 If you obtained GMP and/or MPFR from a vendor distribution package, make
4677 sure that you have installed both the libraries and the header files.
4678 They may be located in separate packages." >&2;}
4679    { (exit 1); exit 1; }; }
4680   fi
4681 fi
4682
4683 # Flags needed for both GMP and/or MPFR
4684
4685
4686
4687 # By default, C is the only stage 1 language.
4688 stage1_languages=,c,
4689
4690 # Figure out what language subdirectories are present.
4691 # Look if the user specified --enable-languages="..."; if not, use
4692 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4693 # go away some day.
4694 # NB:  embedded tabs in this IF block -- do not untabify
4695 if test -d ${srcdir}/gcc; then
4696   if test x"${enable_languages+set}" != xset; then
4697     if test x"${LANGUAGES+set}" = xset; then
4698       enable_languages="${LANGUAGES}"
4699         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4700     else
4701       enable_languages=all
4702     fi
4703   else
4704     if test x"${enable_languages}" = x ||
4705        test x"${enable_languages}" = xyes;
4706        then
4707       echo configure.in: --enable-languages needs at least one language argument 1>&2
4708       exit 1
4709     fi
4710   fi
4711   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4712
4713   # 'f95' is the old name for the 'fortran' language. We issue a warning
4714   # and make the substitution.
4715   case ,${enable_languages}, in
4716     *,f95,*)
4717       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4718       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4719       ;;
4720   esac
4721
4722   # First scan to see if an enabled language requires some other language.
4723   # We assume that a given config-lang.in will list all the language
4724   # front ends it requires, even if some are required indirectly.
4725   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4726     case ${lang_frag} in
4727       ..) ;;
4728       # The odd quoting in the next line works around
4729       # an apparent bug in bash 1.12 on linux.
4730       ${srcdir}/gcc/[*]/config-lang.in) ;;
4731       *)
4732         # From the config-lang.in, get $language, $lang_requires
4733         language=
4734         lang_requires=
4735         . ${lang_frag}
4736         for other in ${lang_requires} ; do
4737           case ,${enable_languages}, in
4738             *,$other,*) ;;
4739             *,all,*) ;;
4740             *,$language,*)
4741               echo " \`$other' language required by \`$language'; enabling" 1>&2
4742               enable_languages="${enable_languages},${other}"
4743               ;;
4744           esac
4745         done
4746         ;;
4747     esac
4748   done
4749
4750   new_enable_languages=,c,
4751   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4752   potential_languages=,c,
4753
4754   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4755     case ${lang_frag} in
4756       ..) ;;
4757       # The odd quoting in the next line works around
4758       # an apparent bug in bash 1.12 on linux.
4759       ${srcdir}/gcc/[*]/config-lang.in) ;;
4760       *)
4761         # From the config-lang.in, get $language, $target_libs,
4762         # $lang_dirs, $boot_language, and $build_by_default
4763         language=
4764         target_libs=
4765         lang_dirs=
4766         subdir_requires=
4767         boot_language=no
4768         build_by_default=yes
4769         . ${lang_frag}
4770         if test x${language} = x; then
4771           echo "${lang_frag} doesn't set \$language." 1>&2
4772           exit 1
4773         fi
4774
4775         case ,${enable_languages}, in
4776           *,${language},*)
4777             # Language was explicitly selected; include it.
4778             add_this_lang=yes
4779             ;;
4780           *,all,*)
4781             # 'all' was selected, select it if it is a default language
4782             add_this_lang=${build_by_default}
4783             ;;
4784           *)
4785             add_this_lang=no
4786             ;;
4787         esac
4788
4789         # Disable languages that need other directories if these aren't available.
4790         for i in $subdir_requires; do
4791           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4792           case ,${enable_languages}, in
4793             *,${language},*)
4794               # Specifically requested language; tell them.
4795               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4796 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4797    { (exit 1); exit 1; }; }
4798               ;;
4799             *)
4800               # Silently disable.
4801               add_this_lang=unsupported
4802               ;;
4803           esac
4804         done
4805
4806         # Disable Ada if no preexisting GNAT is available.
4807         case ,${enable_languages},:${language}:${have_gnat} in
4808           *,${language},*:ada:no)
4809             # Specifically requested language; tell them.
4810             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4811 echo "$as_me: error: GNAT is required to build $language" >&2;}
4812    { (exit 1); exit 1; }; }
4813             ;;
4814           *:ada:no)
4815             # Silently disable.
4816             add_this_lang=unsupported
4817             ;;
4818         esac
4819
4820         # Disable a language that is unsupported by the target.
4821         case " $unsupported_languages " in
4822           *" $language "*)
4823             add_this_lang=unsupported
4824             ;;
4825         esac
4826
4827         case $add_this_lang in
4828           unsupported)
4829             # Remove language-dependent dirs.
4830             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4831             ;;
4832           no)
4833             # Remove language-dependent dirs; still show language as supported.
4834             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4835             potential_languages="${potential_languages}${language},"
4836             ;;
4837           yes)
4838             new_enable_languages="${new_enable_languages}${language},"
4839             potential_languages="${potential_languages}${language},"
4840             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4841             case ${boot_language} in
4842               yes)
4843                 # Add to (comma-separated) list of stage 1 languages.
4844                 stage1_languages="${stage1_languages}${language},"
4845                 ;;
4846             esac
4847             ;;
4848         esac
4849         ;;
4850     esac
4851   done
4852
4853   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4854 if test "${enable_stage1_languages+set}" = set; then
4855   enableval="$enable_stage1_languages"
4856   case ,${enable_stage1_languages}, in
4857     ,no,|,,)
4858       # Set it to something that will have no effect in the loop below
4859       enable_stage1_languages=c ;;
4860     ,yes,)
4861       enable_stage1_languages=`echo $new_enable_languages | \
4862         sed -e "s/^,//" -e "s/,$//" ` ;;
4863     *,all,*)
4864       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4865         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4866   esac
4867
4868   # Add "good" languages from enable_stage1_languages to stage1_languages,
4869   # while "bad" languages go in missing_languages.  Leave no duplicates.
4870   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4871     case $potential_languages in
4872       *,$i,*)
4873         case $stage1_languages in
4874           *,$i,*) ;;
4875           *) stage1_languages="$stage1_languages$i," ;;
4876         esac ;;
4877       *)
4878         case $missing_languages in
4879           *,$i,*) ;;
4880           *) missing_languages="$missing_languages$i," ;;
4881         esac ;;
4882      esac
4883   done
4884 fi;
4885
4886   # Remove leading/trailing commas that were added for simplicity
4887   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4888   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4889   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4890   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4891
4892   if test "x$missing_languages" != x; then
4893     { { echo "$as_me:$LINENO: error:
4894 The following requested languages could not be built: ${missing_languages}
4895 Supported languages are: ${potential_languages}" >&5
4896 echo "$as_me: error:
4897 The following requested languages could not be built: ${missing_languages}
4898 Supported languages are: ${potential_languages}" >&2;}
4899    { (exit 1); exit 1; }; }
4900   fi
4901   if test "x$new_enable_languages" != "x$enable_languages"; then
4902     echo The following languages will be built: ${new_enable_languages}
4903     enable_languages="$new_enable_languages"
4904   fi
4905
4906
4907   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4908 fi
4909
4910 # Handle --disable-<component> generically.
4911 for dir in $configdirs $build_configdirs $target_configdirs ; do
4912   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4913   varname=`echo $dirname | sed -e s/+/_/g`
4914   if eval test x\${enable_${varname}} "=" xno ; then
4915     noconfigdirs="$noconfigdirs $dir"
4916   fi
4917 done
4918
4919 # Check for Boehm's garbage collector
4920 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4921 if test "${enable_objc_gc+set}" = set; then
4922   enableval="$enable_objc_gc"
4923   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4924   *,objc,*:*:yes:*target-boehm-gc*)
4925     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4926 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4927    { (exit 1); exit 1; }; }
4928     ;;
4929 esac
4930 fi;
4931
4932 # Make sure we only build Boehm's garbage collector if required.
4933 case ,${enable_languages},:${enable_objc_gc} in
4934   *,objc,*:yes)
4935     # Keep target-boehm-gc if requested for Objective-C.
4936     ;;
4937   *)
4938     # Otherwise remove target-boehm-gc depending on target-libjava.
4939     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
4940       noconfigdirs="$noconfigdirs target-boehm-gc"
4941     fi
4942     ;;
4943 esac
4944
4945 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
4946 # $build_configdirs and $target_configdirs.
4947 # If we have the source for $noconfigdirs entries, add them to $notsupp.
4948
4949 notsupp=""
4950 for dir in . $skipdirs $noconfigdirs ; do
4951   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
4952   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4953     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
4954     if test -r $srcdir/$dirname/configure ; then
4955       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4956         true
4957       else
4958         notsupp="$notsupp $dir"
4959       fi
4960     fi
4961   fi
4962   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4963     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
4964     if test -r $srcdir/$dirname/configure ; then
4965       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4966         true
4967       else
4968         notsupp="$notsupp $dir"
4969       fi
4970     fi
4971   fi
4972   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4973     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
4974     if test -r $srcdir/$dirname/configure ; then
4975       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4976         true
4977       else
4978         notsupp="$notsupp $dir"
4979       fi
4980     fi
4981   fi
4982 done
4983
4984 # Sometimes the tools are distributed with libiberty but with no other
4985 # libraries.  In that case, we don't want to build target-libiberty.
4986 # Don't let libgcc imply libiberty either.
4987 if test -n "${target_configdirs}" ; then
4988   libgcc=
4989   others=
4990   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
4991     if test "$i" = "libgcc"; then
4992       libgcc=target-libgcc
4993     elif test "$i" != "libiberty" ; then
4994       if test -r $srcdir/$i/configure ; then
4995         others=yes;
4996         break;
4997       fi
4998     fi
4999   done
5000   if test -z "${others}" ; then
5001     target_configdirs=$libgcc
5002   fi
5003 fi
5004
5005 # Quietly strip out all directories which aren't configurable in this tree.
5006 # This relies on all configurable subdirectories being autoconfiscated, which
5007 # is now the case.
5008 build_configdirs_all="$build_configdirs"
5009 build_configdirs=
5010 for i in ${build_configdirs_all} ; do
5011   j=`echo $i | sed -e s/build-//g`
5012   if test -f ${srcdir}/$j/configure ; then
5013     build_configdirs="${build_configdirs} $i"
5014   fi
5015 done
5016
5017 configdirs_all="$configdirs"
5018 configdirs=
5019 for i in ${configdirs_all} ; do
5020   if test -f ${srcdir}/$i/configure ; then
5021     configdirs="${configdirs} $i"
5022   fi
5023 done
5024
5025 target_configdirs_all="$target_configdirs"
5026 target_configdirs=
5027 for i in ${target_configdirs_all} ; do
5028   j=`echo $i | sed -e s/target-//g`
5029   if test -f ${srcdir}/$j/configure ; then
5030     target_configdirs="${target_configdirs} $i"
5031   fi
5032 done
5033
5034 # Produce a warning message for the subdirs we can't configure.
5035 # This isn't especially interesting in the Cygnus tree, but in the individual
5036 # FSF releases, it's important to let people know when their machine isn't
5037 # supported by the one or two programs in a package.
5038
5039 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5040   # If $appdirs is non-empty, at least one of those directories must still
5041   # be configured, or we error out.  (E.g., if the gas release supports a
5042   # specified target in some subdirs but not the gas subdir, we shouldn't
5043   # pretend that all is well.)
5044   if test -n "$appdirs" ; then
5045     for dir in $appdirs ; do
5046       if test -r $dir/Makefile.in ; then
5047         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5048           appdirs=""
5049           break
5050         fi
5051         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5052           appdirs=""
5053           break
5054         fi
5055       fi
5056     done
5057     if test -n "$appdirs" ; then
5058       echo "*** This configuration is not supported by this package." 1>&2
5059       exit 1
5060     fi
5061   fi
5062   # Okay, some application will build, or we don't care to check.  Still
5063   # notify of subdirs not getting built.
5064   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5065   echo "    ${notsupp}" 1>&2
5066   echo "    (Any other directories should still work fine.)" 1>&2
5067 fi
5068
5069 case "$host" in
5070   *msdosdjgpp*)
5071     enable_gdbtk=no ;;
5072 esac
5073
5074 # To find our prefix, in gcc_cv_tool_prefix.
5075
5076 # The user is always right.
5077 if test "${PATH_SEPARATOR+set}" != set; then
5078   echo "#! /bin/sh" >conf$$.sh
5079   echo  "exit 0"   >>conf$$.sh
5080   chmod +x conf$$.sh
5081   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5082     PATH_SEPARATOR=';'
5083   else
5084     PATH_SEPARATOR=:
5085   fi
5086   rm -f conf$$.sh
5087 fi
5088
5089
5090
5091 if test "x$exec_prefix" = xNONE; then
5092         if test "x$prefix" = xNONE; then
5093                 gcc_cv_tool_prefix=$ac_default_prefix
5094         else
5095                 gcc_cv_tool_prefix=$prefix
5096         fi
5097 else
5098         gcc_cv_tool_prefix=$exec_prefix
5099 fi
5100
5101 # If there is no compiler in the tree, use the PATH only.  In any
5102 # case, if there is no compiler in the tree nobody should use
5103 # AS_FOR_TARGET and LD_FOR_TARGET.
5104 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5105     gcc_version=`cat $srcdir/gcc/BASE-VER`
5106     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5107     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5108     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5109     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5110     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5111     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5112 else
5113     gcc_cv_tool_dirs=
5114 fi
5115
5116 if test x$build = x$target && test -n "$md_exec_prefix"; then
5117         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5118 fi
5119
5120
5121
5122 copy_dirs=
5123
5124
5125 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5126 if test "${with_build_sysroot+set}" = set; then
5127   withval="$with_build_sysroot"
5128   if test x"$withval" != x ; then
5129      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5130    fi
5131 else
5132   SYSROOT_CFLAGS_FOR_TARGET=
5133 fi;
5134
5135
5136
5137 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5138 if test "${with_debug_prefix_map+set}" = set; then
5139   withval="$with_debug_prefix_map"
5140   if test x"$withval" != x; then
5141      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5142      for debug_map in $withval; do
5143        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5144      done
5145    fi
5146 else
5147   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5148 fi;
5149
5150
5151 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5152 # the named directory are copied to $(tooldir)/sys-include.
5153 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5154   if test x${is_cross_compiler} = xno ; then
5155     echo 1>&2 '***' --with-headers is only supported when cross compiling
5156     exit 1
5157   fi
5158   if test x"${with_headers}" != xyes ; then
5159     x=${gcc_cv_tool_prefix}
5160     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5161   fi
5162 fi
5163
5164 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5165 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5166 # are permitted.
5167 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5168   if test x${is_cross_compiler} = xno ; then
5169     echo 1>&2 '***' --with-libs is only supported when cross compiling
5170     exit 1
5171   fi
5172   if test x"${with_libs}" != xyes ; then
5173     # Copy the libraries in reverse order, so that files in the first named
5174     # library override files in subsequent libraries.
5175     x=${gcc_cv_tool_prefix}
5176     for l in ${with_libs}; do
5177       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5178     done
5179   fi
5180 fi
5181
5182 # Set with_gnu_as and with_gnu_ld as appropriate.
5183 #
5184 # This is done by determining whether or not the appropriate directory
5185 # is available, and by checking whether or not specific configurations
5186 # have requested that this magic not happen.
5187 #
5188 # The command line options always override the explicit settings in
5189 # configure.in, and the settings in configure.in override this magic.
5190 #
5191 # If the default for a toolchain is to use GNU as and ld, and you don't
5192 # want to do that, then you should use the --without-gnu-as and
5193 # --without-gnu-ld options for the configure script.
5194
5195 if test x${use_gnu_as} = x &&
5196    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5197   with_gnu_as=yes
5198   extra_host_args="$extra_host_args --with-gnu-as"
5199 fi
5200
5201 if test x${use_gnu_ld} = x &&
5202    echo " ${configdirs} " | grep " ld " > /dev/null 2>&1 ; then
5203   with_gnu_ld=yes
5204   extra_host_args="$extra_host_args --with-gnu-ld"
5205 fi
5206
5207 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5208 # can detect this case.
5209
5210 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5211   with_newlib=yes
5212   extra_host_args="$extra_host_args --with-newlib"
5213 fi
5214
5215 # Handle ${copy_dirs}
5216 set fnord ${copy_dirs}
5217 shift
5218 while test $# != 0 ; do
5219   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5220     :
5221   else
5222     echo Copying $1 to $2
5223
5224     # Use the install script to create the directory and all required
5225     # parent directories.
5226     if test -d $2 ; then
5227       :
5228     else
5229       echo >config.temp
5230       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5231     fi
5232
5233     # Copy the directory, assuming we have tar.
5234     # FIXME: Should we use B in the second tar?  Not all systems support it.
5235     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5236
5237     # It is the responsibility of the user to correctly adjust all
5238     # symlinks.  If somebody can figure out how to handle them correctly
5239     # here, feel free to add the code.
5240
5241     echo $1 > $2/COPIED
5242   fi
5243   shift; shift
5244 done
5245
5246 # Determine a target-dependent exec_prefix that the installed
5247 # gcc will search in.  Keep this list sorted by triplet, with
5248 # the *-*-osname triplets last.
5249 md_exec_prefix=
5250 case "${target}" in
5251   alpha*-*-*vms*)
5252     md_exec_prefix=/gnu/lib/gcc-lib
5253     ;;
5254   i[34567]86-pc-msdosdjgpp*)
5255     md_exec_prefix=/dev/env/DJDIR/bin
5256     ;;
5257   i[34567]86-*-sco3.2v5*)
5258     if test $with_gnu_as = yes; then
5259       md_exec_prefix=/usr/gnu/bin
5260     else
5261       md_exec_prefix=/usr/ccs/bin/elf
5262     fi
5263     ;;
5264
5265   mn10300-*-* | \
5266   powerpc-*-chorusos* | \
5267   powerpc*-*-eabi* | \
5268   powerpc*-*-sysv* | \
5269   powerpc*-*-kaos* | \
5270   s390x-ibm-tpf*)
5271     md_exec_prefix=/usr/ccs/bin
5272     ;;
5273   sparc64-*-elf*)
5274     ;;
5275   v850*-*-*)
5276     md_exec_prefix=/usr/ccs/bin
5277     ;;
5278   xtensa-*-elf*)
5279     ;;
5280
5281   *-*-beos* | \
5282   *-*-elf* | \
5283   *-*-hpux* | \
5284   *-*-netware* | \
5285   *-*-nto-qnx* | \
5286   *-*-rtems* | \
5287   *-*-solaris2* | \
5288   *-*-sysv[45]* | \
5289   *-*-vxworks* | \
5290   *-wrs-windiss)
5291     md_exec_prefix=/usr/ccs/bin
5292     ;;
5293 esac
5294
5295 extra_arflags_for_target=
5296 extra_nmflags_for_target=
5297 extra_ranlibflags_for_target=
5298 target_makefile_frag=/dev/null
5299 case "${target}" in
5300   mep*-*-*)
5301     target_makefile_frag="config/mt-mep"
5302     ;;
5303   spu-*-*)
5304     target_makefile_frag="config/mt-spu"
5305     ;;
5306   mips*-sde-elf*)
5307     target_makefile_frag="config/mt-sde"
5308     ;;
5309   mipsisa*-*-elfoabi*)
5310     target_makefile_frag="config/mt-mips-elfoabi"
5311     ;;
5312   *-*-netware*)
5313     target_makefile_frag="config/mt-netware"
5314     ;;
5315   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5316     target_makefile_frag="config/mt-gnu"
5317     ;;
5318   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5319     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5320     # commands to handle both 32-bit and 64-bit objects.  These flags are
5321     # harmless if we're using GNU nm or ar.
5322     extra_arflags_for_target=" -X32_64"
5323     extra_nmflags_for_target=" -B -X32_64"
5324     ;;
5325   *-*-darwin*)
5326     # ranlib from Darwin requires the -c flag to look at common symbols.
5327     extra_ranlibflags_for_target=" -c"
5328     ;;
5329   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5330     target_makefile_frag="config/mt-wince"
5331     ;;
5332 esac
5333
5334 alphaieee_frag=/dev/null
5335 case $target in
5336   alpha*-*-*)
5337     # This just makes sure to use the -mieee option to build target libs.
5338     # This should probably be set individually by each library.
5339     alphaieee_frag="config/mt-alphaieee"
5340     ;;
5341 esac
5342
5343 # If --enable-target-optspace always use -Os instead of -O2 to build
5344 # the target libraries, similarly if it is not specified, use -Os
5345 # on selected platforms.
5346 ospace_frag=/dev/null
5347 case "${enable_target_optspace}:${target}" in
5348   yes:*)
5349     ospace_frag="config/mt-ospace"
5350     ;;
5351   :d30v-*)
5352     ospace_frag="config/mt-d30v"
5353     ;;
5354   :m32r-* | :d10v-* | :fr30-*)
5355     ospace_frag="config/mt-ospace"
5356     ;;
5357   no:* | :*)
5358     ;;
5359   *)
5360     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5361     ;;
5362 esac
5363
5364 # Default to using --with-stabs for certain targets.
5365 if test x${with_stabs} = x ; then
5366   case "${target}" in
5367   mips*-*-irix[56]*)
5368     ;;
5369   mips*-*-* | alpha*-*-osf*)
5370     with_stabs=yes;
5371     extra_host_args="${extra_host_args} --with-stabs"
5372     ;;
5373   esac
5374 fi
5375
5376 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5377 # them automatically.
5378 case "${host}" in
5379   hppa*64*-*-hpux11*)
5380     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5381     ;;
5382 esac
5383
5384 # Some systems (e.g., one of the i386-aix systems the gas testers are
5385 # using) don't handle "\$" correctly, so don't use it here.
5386 tooldir='${exec_prefix}'/${target_noncanonical}
5387 build_tooldir=${tooldir}
5388
5389 # Create a .gdbinit file which runs the one in srcdir
5390 # and tells GDB to look there for source files.
5391
5392 if test -r ${srcdir}/.gdbinit ; then
5393   case ${srcdir} in
5394     .) ;;
5395     *) cat > ./.gdbinit <<EOF
5396 # ${NO_EDIT}
5397 dir ${srcdir}
5398 dir .
5399 source ${srcdir}/.gdbinit
5400 EOF
5401     ;;
5402   esac
5403 fi
5404
5405 # Make sure that the compiler is able to generate an executable.  If it
5406 # can't, we are probably in trouble.  We don't care whether we can run the
5407 # executable--we might be using a cross compiler--we only care whether it
5408 # can be created.  At this point the main configure script has set CC.
5409 we_are_ok=no
5410 echo "int main () { return 0; }" > conftest.c
5411 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5412 if test $? = 0 ; then
5413   if test -s conftest || test -s conftest.exe ; then
5414     we_are_ok=yes
5415   fi
5416 fi
5417 case $we_are_ok in
5418   no)
5419     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5420     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5421     rm -f conftest*
5422     exit 1
5423     ;;
5424 esac
5425 rm -f conftest*
5426
5427 # The Solaris /usr/ucb/cc compiler does not appear to work.
5428 case "${host}" in
5429   sparc-sun-solaris2*)
5430       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5431       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5432           could_use=
5433           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5434           if test -d /opt/cygnus/bin ; then
5435               if test "$could_use" = "" ; then
5436                   could_use="/opt/cygnus/bin"
5437               else
5438                   could_use="$could_use or /opt/cygnus/bin"
5439               fi
5440           fi
5441         if test "$could_use" = "" ; then
5442             echo "Warning: compilation may fail because you're using"
5443             echo "/usr/ucb/cc.  You should change your PATH or CC "
5444             echo "variable and rerun configure."
5445         else
5446             echo "Warning: compilation may fail because you're using"
5447             echo "/usr/ucb/cc, when you should use the C compiler from"
5448             echo "$could_use.  You should change your"
5449             echo "PATH or CC variable and rerun configure."
5450         fi
5451       fi
5452   ;;
5453 esac
5454
5455 case "${host}" in
5456   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5457   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5458   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5459 esac
5460
5461 # Record target_configdirs and the configure arguments for target and
5462 # build configuration in Makefile.
5463 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5464 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5465
5466 # Determine whether gdb needs tk/tcl or not.
5467 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5468 # and in that case we want gdb to be built without tk.  Ugh!
5469 # In fact I believe gdb is the *only* package directly dependent on tk,
5470 # so we should be able to put the 'maybe's in unconditionally and
5471 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5472 # 100% sure that that's safe though.
5473
5474 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5475 case "$enable_gdbtk" in
5476   no)
5477     GDB_TK="" ;;
5478   yes)
5479     GDB_TK="${gdb_tk}" ;;
5480   *)
5481     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5482     # distro.  Eventually someone will fix this and move Insight, nee
5483     # gdbtk to a separate directory.
5484     if test -d ${srcdir}/gdb/gdbtk ; then
5485       GDB_TK="${gdb_tk}"
5486     else
5487       GDB_TK=""
5488     fi
5489     ;;
5490 esac
5491 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5492 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5493
5494 # Strip out unwanted targets.
5495
5496 # While at that, we remove Makefiles if we were started for recursive
5497 # configuration, so that the top-level Makefile reconfigures them,
5498 # like we used to do when configure itself was recursive.
5499
5500 # Loop over modules.  $extrasub must be used with care, limiting as
5501 # much as possible the usage of range addresses.  That's because autoconf
5502 # splits the sed script to overcome limits in the number of commands,
5503 # and relying on carefully-timed sed passes may turn out to be very hard
5504 # to maintain later.  In this particular case, you just have to be careful
5505 # not to nest @if/@endif pairs, because configure will not warn you at all.
5506
5507 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5508 if test "${enable_bootstrap+set}" = set; then
5509   enableval="$enable_bootstrap"
5510
5511 else
5512   enable_bootstrap=default
5513 fi;
5514
5515 # Issue errors and warnings for invalid/strange bootstrap combinations.
5516 case "$configdirs" in
5517   *gcc*) have_compiler=yes ;;
5518   *) have_compiler=no ;;
5519 esac
5520
5521 case "$have_compiler:$host:$target:$enable_bootstrap" in
5522   *:*:*:no) ;;
5523
5524   # Default behavior.  Enable bootstrap if we have a compiler
5525   # and we are in a native configuration.
5526   yes:$build:$build:default)
5527     enable_bootstrap=yes ;;
5528
5529   *:*:*:default)
5530     enable_bootstrap=no ;;
5531
5532   # We have a compiler and we are in a native configuration, bootstrap is ok
5533   yes:$build:$build:yes)
5534     ;;
5535
5536   # Other configurations, but we have a compiler.  Assume the user knows
5537   # what he's doing.
5538   yes:*:*:yes)
5539     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5540 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5541     ;;
5542
5543   # No compiler: if they passed --enable-bootstrap explicitly, fail
5544   no:*:*:yes)
5545     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5546 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5547    { (exit 1); exit 1; }; } ;;
5548
5549   # Fail if wrong command line
5550   *)
5551     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5552 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5553    { (exit 1); exit 1; }; }
5554     ;;
5555 esac
5556
5557 # Adjust the toplevel makefile according to whether bootstrap was selected.
5558 case "$enable_bootstrap" in
5559   yes)
5560     bootstrap_suffix=bootstrap ;;
5561   no)
5562     bootstrap_suffix=no-bootstrap ;;
5563 esac
5564
5565 for module in ${build_configdirs} ; do
5566   if test -z "${no_recursion}" \
5567      && test -f ${build_subdir}/${module}/Makefile; then
5568     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5569     rm -f ${build_subdir}/${module}/Makefile
5570   fi
5571   extrasub="$extrasub
5572 /^@if build-$module\$/d
5573 /^@endif build-$module\$/d
5574 /^@if build-$module-$bootstrap_suffix\$/d
5575 /^@endif build-$module-$bootstrap_suffix\$/d"
5576 done
5577 for module in ${configdirs} ; do
5578   if test -z "${no_recursion}"; then
5579     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5580       if test -f ${file}; then
5581         echo 1>&2 "*** removing ${file} to force reconfigure"
5582         rm -f ${file}
5583       fi
5584     done
5585   fi
5586   extrasub="$extrasub
5587 /^@if $module\$/d
5588 /^@endif $module\$/d
5589 /^@if $module-$bootstrap_suffix\$/d
5590 /^@endif $module-$bootstrap_suffix\$/d"
5591 done
5592 for module in ${target_configdirs} ; do
5593   if test -z "${no_recursion}" \
5594      && test -f ${target_subdir}/${module}/Makefile; then
5595     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5596     rm -f ${target_subdir}/${module}/Makefile
5597   fi
5598   extrasub="$extrasub
5599 /^@if target-$module\$/d
5600 /^@endif target-$module\$/d
5601 /^@if target-$module-$bootstrap_suffix\$/d
5602 /^@endif target-$module-$bootstrap_suffix\$/d"
5603 done
5604
5605 extrasub="$extrasub
5606 /^@if /,/^@endif /d"
5607
5608 # Create the serialization dependencies.  This uses a temporary file.
5609
5610 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5611 if test "${enable_serial_configure+set}" = set; then
5612   enableval="$enable_serial_configure"
5613
5614 fi;
5615
5616 case ${enable_serial_configure} in
5617   yes)
5618     enable_serial_build_configure=yes
5619     enable_serial_host_configure=yes
5620     enable_serial_target_configure=yes
5621     ;;
5622 esac
5623
5624 # These force 'configure's to be done one at a time, to avoid problems
5625 # with contention over a shared config.cache.
5626 rm -f serdep.tmp
5627 echo '# serdep.tmp' > serdep.tmp
5628 olditem=
5629 test "x${enable_serial_build_configure}" = xyes &&
5630 for item in ${build_configdirs} ; do
5631   case ${olditem} in
5632     "") ;;
5633     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5634   esac
5635   olditem=${item}
5636 done
5637 olditem=
5638 test "x${enable_serial_host_configure}" = xyes &&
5639 for item in ${configdirs} ; do
5640   case ${olditem} in
5641     "") ;;
5642     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5643   esac
5644   olditem=${item}
5645 done
5646 olditem=
5647 test "x${enable_serial_target_configure}" = xyes &&
5648 for item in ${target_configdirs} ; do
5649   case ${olditem} in
5650     "") ;;
5651     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5652   esac
5653   olditem=${item}
5654 done
5655 serialization_dependencies=serdep.tmp
5656
5657
5658 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5659 # target, nonopt, and variable assignments.  These are the ones we
5660 # might not want to pass down to subconfigures.  Also strip
5661 # program-prefix, program-suffix, and program-transform-name, so that
5662 # we can pass down a consistent program-transform-name.
5663 baseargs=
5664 keep_next=no
5665 skip_next=no
5666 eval "set -- $ac_configure_args"
5667 for ac_arg
5668 do
5669   if test X"$skip_next" = X"yes"; then
5670     skip_next=no
5671     continue
5672   fi
5673   if test X"$keep_next" = X"yes"; then
5674     case $ac_arg in
5675       *\'*)
5676         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5677     esac
5678     baseargs="$baseargs '$ac_arg'"
5679     keep_next=no
5680     continue
5681   fi
5682
5683   # Handle separated arguments.  Based on the logic generated by
5684   # autoconf 2.59.
5685   case $ac_arg in
5686     *=* | --config-cache | -C | -disable-* | --disable-* \
5687       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5688       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5689       | -with-* | --with-* | -without-* | --without-* | --x)
5690       separate_arg=no
5691       ;;
5692     -*)
5693       separate_arg=yes
5694       ;;
5695     *)
5696       separate_arg=no
5697       ;;
5698   esac
5699
5700   case "$ac_arg" in
5701     --no*)
5702       continue
5703       ;;
5704     --c* | \
5705     --sr* | \
5706     --ho* | \
5707     --bu* | \
5708     --t* | \
5709     --program-* | \
5710     -cache_file* | \
5711     -srcdir* | \
5712     -host* | \
5713     -build* | \
5714     -target* | \
5715     -program-prefix* | \
5716     -program-suffix* | \
5717     -program-transform-name* )
5718       skip_next=$separate_arg
5719       continue
5720       ;;
5721     -*)
5722       # An option.  Add it.
5723       case $ac_arg in
5724         *\'*)
5725           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5726       esac
5727       baseargs="$baseargs '$ac_arg'"
5728       keep_next=$separate_arg
5729       ;;
5730     *)
5731       # Either a variable assignment, or a nonopt (triplet).  Don't
5732       # pass it down; let the Makefile handle this.
5733       continue
5734       ;;
5735   esac
5736 done
5737 # Remove the initial space we just introduced and, as these will be
5738 # expanded by make, quote '$'.
5739 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5740
5741 # Add in --program-transform-name, after --program-prefix and
5742 # --program-suffix have been applied to it.  Autoconf has already
5743 # doubled dollar signs and backslashes in program_transform_name; we want
5744 # the backslashes un-doubled, and then the entire thing wrapped in single
5745 # quotes, because this will be expanded first by make and then by the shell.
5746 # Also, because we want to override the logic in subdir configure scripts to
5747 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5748 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5749 ${program_transform_name}
5750 EOF_SED
5751 gcc_transform_name=`cat conftestsed.out`
5752 rm -f conftestsed.out
5753 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5754 if test "$silent" = yes; then
5755   baseargs="$baseargs --silent"
5756 fi
5757
5758 # For the build-side libraries, we just need to pretend we're native,
5759 # and not use the same cache file.  Multilibs are neither needed nor
5760 # desired.
5761 build_configargs="--cache-file=../config.cache ${baseargs}"
5762
5763 # For host modules, accept cache file option, or specification as blank.
5764 case "${cache_file}" in
5765 "") # empty
5766   cache_file_option="" ;;
5767 /* | [A-Za-z]:[\\/]* ) # absolute path
5768   cache_file_option="--cache-file=${cache_file}" ;;
5769 *) # relative path
5770   cache_file_option="--cache-file=../${cache_file}" ;;
5771 esac
5772
5773 # Host dirs don't like to share a cache file either, horribly enough.
5774 # This seems to be due to autoconf 2.5x stupidity.
5775 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5776
5777 target_configargs=${baseargs}
5778
5779 # Passing a --with-cross-host argument lets the target libraries know
5780 # whether they are being built with a cross-compiler or being built
5781 # native.  However, it would be better to use other mechanisms to make the
5782 # sorts of decisions they want to make on this basis.  Please consider
5783 # this option to be deprecated.  FIXME.
5784 if test x${is_cross_compiler} = xyes ; then
5785   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5786 fi
5787
5788 # Default to --enable-multilib.
5789 if test x${enable_multilib} = x ; then
5790   target_configargs="--enable-multilib ${target_configargs}"
5791 fi
5792
5793 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5794 # changed from the earlier setting of with_newlib.
5795 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5796   target_configargs="--with-newlib ${target_configargs}"
5797 fi
5798
5799 # Different target subdirs use different values of certain variables
5800 # (notably CXX).  Worse, multilibs use *lots* of different values.
5801 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5802 # it doesn't automatically accept command-line overrides of them.
5803 # This means it's not safe for target subdirs to share a cache file,
5804 # which is disgusting, but there you have it.  Hopefully this can be
5805 # fixed in future.  It's still worthwhile to use a cache file for each
5806 # directory.  I think.
5807
5808 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5809 # We need to pass --target, as newer autoconf's requires consistency
5810 # for target_alias and gcc doesn't manage it consistently.
5811 target_configargs="--cache-file=./config.cache ${target_configargs}"
5812
5813 FLAGS_FOR_TARGET=
5814 case " $target_configdirs " in
5815  *" newlib "*)
5816   case " $target_configargs " in
5817   *" --with-newlib "*)
5818    case "$target" in
5819    *-cygwin*)
5820      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' ;;
5821    esac
5822
5823    # If we're not building GCC, don't discard standard headers.
5824    if test -d ${srcdir}/gcc; then
5825      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5826
5827      if test "${build}" != "${host}"; then
5828        # On Canadian crosses, CC_FOR_TARGET will have already been set
5829        # by `configure', so we won't have an opportunity to add -Bgcc/
5830        # to it.  This is right: we don't want to search that directory
5831        # for binaries, but we want the header files in there, so add
5832        # them explicitly.
5833        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5834
5835        # Someone might think of using the pre-installed headers on
5836        # Canadian crosses, in case the installed compiler is not fully
5837        # compatible with the compiler being built.  In this case, it
5838        # would be better to flag an error than risking having
5839        # incompatible object files being constructed.  We can't
5840        # guarantee that an error will be flagged, but let's hope the
5841        # compiler will do it, when presented with incompatible header
5842        # files.
5843      fi
5844    fi
5845
5846    case "${target}-${is_cross_compiler}" in
5847    i[3456789]86-*-linux*-no)
5848       # Here host == target, so we don't need to build gcc,
5849       # so we don't want to discard standard headers.
5850       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5851       ;;
5852    *)
5853       # If we're building newlib, use its generic headers last, but search
5854       # for any libc-related directories first (so make it the last -B
5855       # switch).
5856       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5857
5858       # If we're building libgloss, find the startup file, simulator library
5859       # and linker script.
5860       case " $target_configdirs " in
5861         *" libgloss "*)
5862         # Look for startup file, simulator library and maybe linker script.
5863         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
5864         # Look for libnosys.a in case the target needs it.
5865         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5866         # Most targets have the linker script in the source directory.
5867         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
5868         ;;
5869       esac
5870       ;;
5871    esac
5872    ;;
5873   esac
5874   ;;
5875 esac
5876 case "$target" in
5877 *-mingw*)
5878   # Can't be handled as Cygwin above since Mingw does not use newlib.
5879   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' ;;
5880 esac
5881
5882 # Allow the user to override the flags for
5883 # our build compiler if desired.
5884 if test x"${build}" = x"${host}" ; then
5885   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5886   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
5887   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
5888 fi
5889
5890 # On Canadian crosses, we'll be searching the right directories for
5891 # the previously-installed cross compiler, so don't bother to add
5892 # flags for directories within the install tree of the compiler
5893 # being built; programs in there won't even run.
5894 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5895   # Search for pre-installed headers if nothing else fits.
5896   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5897 fi
5898
5899 if test "x${use_gnu_ld}" = x &&
5900    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5901   # Arrange for us to find uninstalled linker scripts.
5902   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5903 fi
5904
5905 # Search for other target-specific linker scripts and such.
5906 case "${target}" in
5907   mep*)
5908     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5909     ;;
5910 esac
5911
5912 # Makefile fragments.
5913 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5914 do
5915   eval fragval=\$$frag
5916   if test $fragval != /dev/null; then
5917     eval $frag=${srcdir}/$fragval
5918   fi
5919 done
5920
5921
5922
5923
5924
5925 # Miscellanea: directories, flags, etc.
5926
5927
5928
5929
5930
5931
5932
5933 # Build module lists & subconfigure args.
5934
5935
5936
5937 # Host module lists & subconfigure args.
5938
5939
5940
5941 # Target module lists & subconfigure args.
5942
5943
5944
5945 # Build tools.
5946
5947
5948
5949
5950
5951
5952
5953
5954
5955
5956
5957
5958
5959
5960
5961
5962
5963 # Generate default definitions for YACC, M4, LEX and other programs that run
5964 # on the build machine.  These are used if the Makefile can't locate these
5965 # programs in objdir.
5966 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
5967
5968 for ac_prog in 'bison -y' byacc yacc
5969 do
5970   # Extract the first word of "$ac_prog", so it can be a program name with args.
5971 set dummy $ac_prog; ac_word=$2
5972 echo "$as_me:$LINENO: checking for $ac_word" >&5
5973 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5974 if test "${ac_cv_prog_YACC+set}" = set; then
5975   echo $ECHO_N "(cached) $ECHO_C" >&6
5976 else
5977   if test -n "$YACC"; then
5978   ac_cv_prog_YACC="$YACC" # Let the user override the test.
5979 else
5980 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5981 for as_dir in $PATH
5982 do
5983   IFS=$as_save_IFS
5984   test -z "$as_dir" && as_dir=.
5985   for ac_exec_ext in '' $ac_executable_extensions; do
5986   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5987     ac_cv_prog_YACC="$ac_prog"
5988     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5989     break 2
5990   fi
5991 done
5992 done
5993
5994 fi
5995 fi
5996 YACC=$ac_cv_prog_YACC
5997 if test -n "$YACC"; then
5998   echo "$as_me:$LINENO: result: $YACC" >&5
5999 echo "${ECHO_T}$YACC" >&6
6000 else
6001   echo "$as_me:$LINENO: result: no" >&5
6002 echo "${ECHO_T}no" >&6
6003 fi
6004
6005   test -n "$YACC" && break
6006 done
6007 test -n "$YACC" || YACC="$MISSING bison -y"
6008
6009 case " $build_configdirs " in
6010   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6011   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6012 esac
6013
6014 for ac_prog in bison
6015 do
6016   # Extract the first word of "$ac_prog", so it can be a program name with args.
6017 set dummy $ac_prog; ac_word=$2
6018 echo "$as_me:$LINENO: checking for $ac_word" >&5
6019 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6020 if test "${ac_cv_prog_BISON+set}" = set; then
6021   echo $ECHO_N "(cached) $ECHO_C" >&6
6022 else
6023   if test -n "$BISON"; then
6024   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6025 else
6026 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6027 for as_dir in $PATH
6028 do
6029   IFS=$as_save_IFS
6030   test -z "$as_dir" && as_dir=.
6031   for ac_exec_ext in '' $ac_executable_extensions; do
6032   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6033     ac_cv_prog_BISON="$ac_prog"
6034     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6035     break 2
6036   fi
6037 done
6038 done
6039
6040 fi
6041 fi
6042 BISON=$ac_cv_prog_BISON
6043 if test -n "$BISON"; then
6044   echo "$as_me:$LINENO: result: $BISON" >&5
6045 echo "${ECHO_T}$BISON" >&6
6046 else
6047   echo "$as_me:$LINENO: result: no" >&5
6048 echo "${ECHO_T}no" >&6
6049 fi
6050
6051   test -n "$BISON" && break
6052 done
6053 test -n "$BISON" || BISON="$MISSING bison"
6054
6055 case " $build_configdirs " in
6056   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6057 esac
6058
6059 for ac_prog in gm4 gnum4 m4
6060 do
6061   # Extract the first word of "$ac_prog", so it can be a program name with args.
6062 set dummy $ac_prog; ac_word=$2
6063 echo "$as_me:$LINENO: checking for $ac_word" >&5
6064 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6065 if test "${ac_cv_prog_M4+set}" = set; then
6066   echo $ECHO_N "(cached) $ECHO_C" >&6
6067 else
6068   if test -n "$M4"; then
6069   ac_cv_prog_M4="$M4" # Let the user override the test.
6070 else
6071 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6072 for as_dir in $PATH
6073 do
6074   IFS=$as_save_IFS
6075   test -z "$as_dir" && as_dir=.
6076   for ac_exec_ext in '' $ac_executable_extensions; do
6077   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6078     ac_cv_prog_M4="$ac_prog"
6079     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6080     break 2
6081   fi
6082 done
6083 done
6084
6085 fi
6086 fi
6087 M4=$ac_cv_prog_M4
6088 if test -n "$M4"; then
6089   echo "$as_me:$LINENO: result: $M4" >&5
6090 echo "${ECHO_T}$M4" >&6
6091 else
6092   echo "$as_me:$LINENO: result: no" >&5
6093 echo "${ECHO_T}no" >&6
6094 fi
6095
6096   test -n "$M4" && break
6097 done
6098 test -n "$M4" || M4="$MISSING m4"
6099
6100 case " $build_configdirs " in
6101   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6102 esac
6103
6104 for ac_prog in flex lex
6105 do
6106   # Extract the first word of "$ac_prog", so it can be a program name with args.
6107 set dummy $ac_prog; ac_word=$2
6108 echo "$as_me:$LINENO: checking for $ac_word" >&5
6109 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6110 if test "${ac_cv_prog_LEX+set}" = set; then
6111   echo $ECHO_N "(cached) $ECHO_C" >&6
6112 else
6113   if test -n "$LEX"; then
6114   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6115 else
6116 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6117 for as_dir in $PATH
6118 do
6119   IFS=$as_save_IFS
6120   test -z "$as_dir" && as_dir=.
6121   for ac_exec_ext in '' $ac_executable_extensions; do
6122   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6123     ac_cv_prog_LEX="$ac_prog"
6124     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6125     break 2
6126   fi
6127 done
6128 done
6129
6130 fi
6131 fi
6132 LEX=$ac_cv_prog_LEX
6133 if test -n "$LEX"; then
6134   echo "$as_me:$LINENO: result: $LEX" >&5
6135 echo "${ECHO_T}$LEX" >&6
6136 else
6137   echo "$as_me:$LINENO: result: no" >&5
6138 echo "${ECHO_T}no" >&6
6139 fi
6140
6141   test -n "$LEX" && break
6142 done
6143 test -n "$LEX" || LEX="$MISSING flex"
6144
6145 case " $build_configdirs " in
6146   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6147   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6148 esac
6149
6150 for ac_prog in flex
6151 do
6152   # Extract the first word of "$ac_prog", so it can be a program name with args.
6153 set dummy $ac_prog; ac_word=$2
6154 echo "$as_me:$LINENO: checking for $ac_word" >&5
6155 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6156 if test "${ac_cv_prog_FLEX+set}" = set; then
6157   echo $ECHO_N "(cached) $ECHO_C" >&6
6158 else
6159   if test -n "$FLEX"; then
6160   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6161 else
6162 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6163 for as_dir in $PATH
6164 do
6165   IFS=$as_save_IFS
6166   test -z "$as_dir" && as_dir=.
6167   for ac_exec_ext in '' $ac_executable_extensions; do
6168   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6169     ac_cv_prog_FLEX="$ac_prog"
6170     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6171     break 2
6172   fi
6173 done
6174 done
6175
6176 fi
6177 fi
6178 FLEX=$ac_cv_prog_FLEX
6179 if test -n "$FLEX"; then
6180   echo "$as_me:$LINENO: result: $FLEX" >&5
6181 echo "${ECHO_T}$FLEX" >&6
6182 else
6183   echo "$as_me:$LINENO: result: no" >&5
6184 echo "${ECHO_T}no" >&6
6185 fi
6186
6187   test -n "$FLEX" && break
6188 done
6189 test -n "$FLEX" || FLEX="$MISSING flex"
6190
6191 case " $build_configdirs " in
6192   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6193 esac
6194
6195 for ac_prog in makeinfo
6196 do
6197   # Extract the first word of "$ac_prog", so it can be a program name with args.
6198 set dummy $ac_prog; ac_word=$2
6199 echo "$as_me:$LINENO: checking for $ac_word" >&5
6200 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6201 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6202   echo $ECHO_N "(cached) $ECHO_C" >&6
6203 else
6204   if test -n "$MAKEINFO"; then
6205   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6206 else
6207 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6208 for as_dir in $PATH
6209 do
6210   IFS=$as_save_IFS
6211   test -z "$as_dir" && as_dir=.
6212   for ac_exec_ext in '' $ac_executable_extensions; do
6213   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6214     ac_cv_prog_MAKEINFO="$ac_prog"
6215     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6216     break 2
6217   fi
6218 done
6219 done
6220
6221 fi
6222 fi
6223 MAKEINFO=$ac_cv_prog_MAKEINFO
6224 if test -n "$MAKEINFO"; then
6225   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6226 echo "${ECHO_T}$MAKEINFO" >&6
6227 else
6228   echo "$as_me:$LINENO: result: no" >&5
6229 echo "${ECHO_T}no" >&6
6230 fi
6231
6232   test -n "$MAKEINFO" && break
6233 done
6234 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6235
6236 case " $build_configdirs " in
6237   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6238   *)
6239
6240     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6241     # higher, else we use the "missing" dummy.
6242     if ${MAKEINFO} --version \
6243        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6244       :
6245     else
6246       MAKEINFO="$MISSING makeinfo"
6247     fi
6248     ;;
6249
6250 esac
6251
6252 # FIXME: expect and dejagnu may become build tools?
6253
6254 for ac_prog in expect
6255 do
6256   # Extract the first word of "$ac_prog", so it can be a program name with args.
6257 set dummy $ac_prog; ac_word=$2
6258 echo "$as_me:$LINENO: checking for $ac_word" >&5
6259 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6260 if test "${ac_cv_prog_EXPECT+set}" = set; then
6261   echo $ECHO_N "(cached) $ECHO_C" >&6
6262 else
6263   if test -n "$EXPECT"; then
6264   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6265 else
6266 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6267 for as_dir in $PATH
6268 do
6269   IFS=$as_save_IFS
6270   test -z "$as_dir" && as_dir=.
6271   for ac_exec_ext in '' $ac_executable_extensions; do
6272   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6273     ac_cv_prog_EXPECT="$ac_prog"
6274     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6275     break 2
6276   fi
6277 done
6278 done
6279
6280 fi
6281 fi
6282 EXPECT=$ac_cv_prog_EXPECT
6283 if test -n "$EXPECT"; then
6284   echo "$as_me:$LINENO: result: $EXPECT" >&5
6285 echo "${ECHO_T}$EXPECT" >&6
6286 else
6287   echo "$as_me:$LINENO: result: no" >&5
6288 echo "${ECHO_T}no" >&6
6289 fi
6290
6291   test -n "$EXPECT" && break
6292 done
6293 test -n "$EXPECT" || EXPECT="expect"
6294
6295 case " $configdirs " in
6296   *" expect "*)
6297     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6298     ;;
6299 esac
6300
6301 for ac_prog in runtest
6302 do
6303   # Extract the first word of "$ac_prog", so it can be a program name with args.
6304 set dummy $ac_prog; ac_word=$2
6305 echo "$as_me:$LINENO: checking for $ac_word" >&5
6306 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6307 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6308   echo $ECHO_N "(cached) $ECHO_C" >&6
6309 else
6310   if test -n "$RUNTEST"; then
6311   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6312 else
6313 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6314 for as_dir in $PATH
6315 do
6316   IFS=$as_save_IFS
6317   test -z "$as_dir" && as_dir=.
6318   for ac_exec_ext in '' $ac_executable_extensions; do
6319   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6320     ac_cv_prog_RUNTEST="$ac_prog"
6321     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6322     break 2
6323   fi
6324 done
6325 done
6326
6327 fi
6328 fi
6329 RUNTEST=$ac_cv_prog_RUNTEST
6330 if test -n "$RUNTEST"; then
6331   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6332 echo "${ECHO_T}$RUNTEST" >&6
6333 else
6334   echo "$as_me:$LINENO: result: no" >&5
6335 echo "${ECHO_T}no" >&6
6336 fi
6337
6338   test -n "$RUNTEST" && break
6339 done
6340 test -n "$RUNTEST" || RUNTEST="runtest"
6341
6342 case " $configdirs " in
6343   *" dejagnu "*)
6344     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6345     ;;
6346 esac
6347
6348
6349 # Host tools.
6350 ncn_tool_prefix=
6351 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6352 ncn_target_tool_prefix=
6353 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6354
6355
6356
6357 if test -n "$AR"; then
6358   ac_cv_prog_AR=$AR
6359 elif test -n "$ac_cv_prog_AR"; then
6360   AR=$ac_cv_prog_AR
6361 fi
6362
6363 if test -n "$ac_cv_prog_AR"; then
6364   for ncn_progname in ar; do
6365     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6366 set dummy ${ncn_progname}; ac_word=$2
6367 echo "$as_me:$LINENO: checking for $ac_word" >&5
6368 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6369 if test "${ac_cv_prog_AR+set}" = set; then
6370   echo $ECHO_N "(cached) $ECHO_C" >&6
6371 else
6372   if test -n "$AR"; then
6373   ac_cv_prog_AR="$AR" # Let the user override the test.
6374 else
6375 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6376 for as_dir in $PATH
6377 do
6378   IFS=$as_save_IFS
6379   test -z "$as_dir" && as_dir=.
6380   for ac_exec_ext in '' $ac_executable_extensions; do
6381   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6382     ac_cv_prog_AR="${ncn_progname}"
6383     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6384     break 2
6385   fi
6386 done
6387 done
6388
6389 fi
6390 fi
6391 AR=$ac_cv_prog_AR
6392 if test -n "$AR"; then
6393   echo "$as_me:$LINENO: result: $AR" >&5
6394 echo "${ECHO_T}$AR" >&6
6395 else
6396   echo "$as_me:$LINENO: result: no" >&5
6397 echo "${ECHO_T}no" >&6
6398 fi
6399
6400   done
6401 fi
6402
6403 for ncn_progname in ar; do
6404   if test -n "$ncn_tool_prefix"; then
6405     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6406 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6407 echo "$as_me:$LINENO: checking for $ac_word" >&5
6408 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6409 if test "${ac_cv_prog_AR+set}" = set; then
6410   echo $ECHO_N "(cached) $ECHO_C" >&6
6411 else
6412   if test -n "$AR"; then
6413   ac_cv_prog_AR="$AR" # Let the user override the test.
6414 else
6415 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6416 for as_dir in $PATH
6417 do
6418   IFS=$as_save_IFS
6419   test -z "$as_dir" && as_dir=.
6420   for ac_exec_ext in '' $ac_executable_extensions; do
6421   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6422     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6423     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6424     break 2
6425   fi
6426 done
6427 done
6428
6429 fi
6430 fi
6431 AR=$ac_cv_prog_AR
6432 if test -n "$AR"; then
6433   echo "$as_me:$LINENO: result: $AR" >&5
6434 echo "${ECHO_T}$AR" >&6
6435 else
6436   echo "$as_me:$LINENO: result: no" >&5
6437 echo "${ECHO_T}no" >&6
6438 fi
6439
6440   fi
6441   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6442     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6443 set dummy ${ncn_progname}; ac_word=$2
6444 echo "$as_me:$LINENO: checking for $ac_word" >&5
6445 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6446 if test "${ac_cv_prog_AR+set}" = set; then
6447   echo $ECHO_N "(cached) $ECHO_C" >&6
6448 else
6449   if test -n "$AR"; then
6450   ac_cv_prog_AR="$AR" # Let the user override the test.
6451 else
6452 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6453 for as_dir in $PATH
6454 do
6455   IFS=$as_save_IFS
6456   test -z "$as_dir" && as_dir=.
6457   for ac_exec_ext in '' $ac_executable_extensions; do
6458   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6459     ac_cv_prog_AR="${ncn_progname}"
6460     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6461     break 2
6462   fi
6463 done
6464 done
6465
6466 fi
6467 fi
6468 AR=$ac_cv_prog_AR
6469 if test -n "$AR"; then
6470   echo "$as_me:$LINENO: result: $AR" >&5
6471 echo "${ECHO_T}$AR" >&6
6472 else
6473   echo "$as_me:$LINENO: result: no" >&5
6474 echo "${ECHO_T}no" >&6
6475 fi
6476
6477   fi
6478   test -n "$ac_cv_prog_AR" && break
6479 done
6480
6481 if test -z "$ac_cv_prog_AR" ; then
6482   set dummy ar
6483   if test $build = $host ; then
6484     AR="$2"
6485   else
6486     AR="${ncn_tool_prefix}$2"
6487   fi
6488 fi
6489
6490
6491
6492 if test -n "$AS"; then
6493   ac_cv_prog_AS=$AS
6494 elif test -n "$ac_cv_prog_AS"; then
6495   AS=$ac_cv_prog_AS
6496 fi
6497
6498 if test -n "$ac_cv_prog_AS"; then
6499   for ncn_progname in as; do
6500     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6501 set dummy ${ncn_progname}; ac_word=$2
6502 echo "$as_me:$LINENO: checking for $ac_word" >&5
6503 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6504 if test "${ac_cv_prog_AS+set}" = set; then
6505   echo $ECHO_N "(cached) $ECHO_C" >&6
6506 else
6507   if test -n "$AS"; then
6508   ac_cv_prog_AS="$AS" # Let the user override the test.
6509 else
6510 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6511 for as_dir in $PATH
6512 do
6513   IFS=$as_save_IFS
6514   test -z "$as_dir" && as_dir=.
6515   for ac_exec_ext in '' $ac_executable_extensions; do
6516   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6517     ac_cv_prog_AS="${ncn_progname}"
6518     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6519     break 2
6520   fi
6521 done
6522 done
6523
6524 fi
6525 fi
6526 AS=$ac_cv_prog_AS
6527 if test -n "$AS"; then
6528   echo "$as_me:$LINENO: result: $AS" >&5
6529 echo "${ECHO_T}$AS" >&6
6530 else
6531   echo "$as_me:$LINENO: result: no" >&5
6532 echo "${ECHO_T}no" >&6
6533 fi
6534
6535   done
6536 fi
6537
6538 for ncn_progname in as; do
6539   if test -n "$ncn_tool_prefix"; then
6540     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6541 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6542 echo "$as_me:$LINENO: checking for $ac_word" >&5
6543 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6544 if test "${ac_cv_prog_AS+set}" = set; then
6545   echo $ECHO_N "(cached) $ECHO_C" >&6
6546 else
6547   if test -n "$AS"; then
6548   ac_cv_prog_AS="$AS" # Let the user override the test.
6549 else
6550 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6551 for as_dir in $PATH
6552 do
6553   IFS=$as_save_IFS
6554   test -z "$as_dir" && as_dir=.
6555   for ac_exec_ext in '' $ac_executable_extensions; do
6556   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6557     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6558     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6559     break 2
6560   fi
6561 done
6562 done
6563
6564 fi
6565 fi
6566 AS=$ac_cv_prog_AS
6567 if test -n "$AS"; then
6568   echo "$as_me:$LINENO: result: $AS" >&5
6569 echo "${ECHO_T}$AS" >&6
6570 else
6571   echo "$as_me:$LINENO: result: no" >&5
6572 echo "${ECHO_T}no" >&6
6573 fi
6574
6575   fi
6576   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6577     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6578 set dummy ${ncn_progname}; ac_word=$2
6579 echo "$as_me:$LINENO: checking for $ac_word" >&5
6580 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6581 if test "${ac_cv_prog_AS+set}" = set; then
6582   echo $ECHO_N "(cached) $ECHO_C" >&6
6583 else
6584   if test -n "$AS"; then
6585   ac_cv_prog_AS="$AS" # Let the user override the test.
6586 else
6587 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6588 for as_dir in $PATH
6589 do
6590   IFS=$as_save_IFS
6591   test -z "$as_dir" && as_dir=.
6592   for ac_exec_ext in '' $ac_executable_extensions; do
6593   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6594     ac_cv_prog_AS="${ncn_progname}"
6595     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6596     break 2
6597   fi
6598 done
6599 done
6600
6601 fi
6602 fi
6603 AS=$ac_cv_prog_AS
6604 if test -n "$AS"; then
6605   echo "$as_me:$LINENO: result: $AS" >&5
6606 echo "${ECHO_T}$AS" >&6
6607 else
6608   echo "$as_me:$LINENO: result: no" >&5
6609 echo "${ECHO_T}no" >&6
6610 fi
6611
6612   fi
6613   test -n "$ac_cv_prog_AS" && break
6614 done
6615
6616 if test -z "$ac_cv_prog_AS" ; then
6617   set dummy as
6618   if test $build = $host ; then
6619     AS="$2"
6620   else
6621     AS="${ncn_tool_prefix}$2"
6622   fi
6623 fi
6624
6625
6626
6627 if test -n "$DLLTOOL"; then
6628   ac_cv_prog_DLLTOOL=$DLLTOOL
6629 elif test -n "$ac_cv_prog_DLLTOOL"; then
6630   DLLTOOL=$ac_cv_prog_DLLTOOL
6631 fi
6632
6633 if test -n "$ac_cv_prog_DLLTOOL"; then
6634   for ncn_progname in dlltool; do
6635     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6636 set dummy ${ncn_progname}; 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_DLLTOOL+set}" = set; then
6640   echo $ECHO_N "(cached) $ECHO_C" >&6
6641 else
6642   if test -n "$DLLTOOL"; then
6643   ac_cv_prog_DLLTOOL="$DLLTOOL" # 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_DLLTOOL="${ncn_progname}"
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 DLLTOOL=$ac_cv_prog_DLLTOOL
6662 if test -n "$DLLTOOL"; then
6663   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6664 echo "${ECHO_T}$DLLTOOL" >&6
6665 else
6666   echo "$as_me:$LINENO: result: no" >&5
6667 echo "${ECHO_T}no" >&6
6668 fi
6669
6670   done
6671 fi
6672
6673 for ncn_progname in dlltool; do
6674   if test -n "$ncn_tool_prefix"; then
6675     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6676 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6677 echo "$as_me:$LINENO: checking for $ac_word" >&5
6678 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6679 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6680   echo $ECHO_N "(cached) $ECHO_C" >&6
6681 else
6682   if test -n "$DLLTOOL"; then
6683   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6684 else
6685 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6686 for as_dir in $PATH
6687 do
6688   IFS=$as_save_IFS
6689   test -z "$as_dir" && as_dir=.
6690   for ac_exec_ext in '' $ac_executable_extensions; do
6691   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6692     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6693     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6694     break 2
6695   fi
6696 done
6697 done
6698
6699 fi
6700 fi
6701 DLLTOOL=$ac_cv_prog_DLLTOOL
6702 if test -n "$DLLTOOL"; then
6703   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6704 echo "${ECHO_T}$DLLTOOL" >&6
6705 else
6706   echo "$as_me:$LINENO: result: no" >&5
6707 echo "${ECHO_T}no" >&6
6708 fi
6709
6710   fi
6711   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6712     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6713 set dummy ${ncn_progname}; ac_word=$2
6714 echo "$as_me:$LINENO: checking for $ac_word" >&5
6715 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6716 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6717   echo $ECHO_N "(cached) $ECHO_C" >&6
6718 else
6719   if test -n "$DLLTOOL"; then
6720   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6721 else
6722 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6723 for as_dir in $PATH
6724 do
6725   IFS=$as_save_IFS
6726   test -z "$as_dir" && as_dir=.
6727   for ac_exec_ext in '' $ac_executable_extensions; do
6728   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6729     ac_cv_prog_DLLTOOL="${ncn_progname}"
6730     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6731     break 2
6732   fi
6733 done
6734 done
6735
6736 fi
6737 fi
6738 DLLTOOL=$ac_cv_prog_DLLTOOL
6739 if test -n "$DLLTOOL"; then
6740   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6741 echo "${ECHO_T}$DLLTOOL" >&6
6742 else
6743   echo "$as_me:$LINENO: result: no" >&5
6744 echo "${ECHO_T}no" >&6
6745 fi
6746
6747   fi
6748   test -n "$ac_cv_prog_DLLTOOL" && break
6749 done
6750
6751 if test -z "$ac_cv_prog_DLLTOOL" ; then
6752   set dummy dlltool
6753   if test $build = $host ; then
6754     DLLTOOL="$2"
6755   else
6756     DLLTOOL="${ncn_tool_prefix}$2"
6757   fi
6758 fi
6759
6760
6761
6762 if test -n "$LD"; then
6763   ac_cv_prog_LD=$LD
6764 elif test -n "$ac_cv_prog_LD"; then
6765   LD=$ac_cv_prog_LD
6766 fi
6767
6768 if test -n "$ac_cv_prog_LD"; then
6769   for ncn_progname in ld; do
6770     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6771 set dummy ${ncn_progname}; ac_word=$2
6772 echo "$as_me:$LINENO: checking for $ac_word" >&5
6773 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6774 if test "${ac_cv_prog_LD+set}" = set; then
6775   echo $ECHO_N "(cached) $ECHO_C" >&6
6776 else
6777   if test -n "$LD"; then
6778   ac_cv_prog_LD="$LD" # Let the user override the test.
6779 else
6780 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6781 for as_dir in $PATH
6782 do
6783   IFS=$as_save_IFS
6784   test -z "$as_dir" && as_dir=.
6785   for ac_exec_ext in '' $ac_executable_extensions; do
6786   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6787     ac_cv_prog_LD="${ncn_progname}"
6788     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6789     break 2
6790   fi
6791 done
6792 done
6793
6794 fi
6795 fi
6796 LD=$ac_cv_prog_LD
6797 if test -n "$LD"; then
6798   echo "$as_me:$LINENO: result: $LD" >&5
6799 echo "${ECHO_T}$LD" >&6
6800 else
6801   echo "$as_me:$LINENO: result: no" >&5
6802 echo "${ECHO_T}no" >&6
6803 fi
6804
6805   done
6806 fi
6807
6808 for ncn_progname in ld; do
6809   if test -n "$ncn_tool_prefix"; then
6810     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6811 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6812 echo "$as_me:$LINENO: checking for $ac_word" >&5
6813 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6814 if test "${ac_cv_prog_LD+set}" = set; then
6815   echo $ECHO_N "(cached) $ECHO_C" >&6
6816 else
6817   if test -n "$LD"; then
6818   ac_cv_prog_LD="$LD" # Let the user override the test.
6819 else
6820 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6821 for as_dir in $PATH
6822 do
6823   IFS=$as_save_IFS
6824   test -z "$as_dir" && as_dir=.
6825   for ac_exec_ext in '' $ac_executable_extensions; do
6826   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6827     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6828     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6829     break 2
6830   fi
6831 done
6832 done
6833
6834 fi
6835 fi
6836 LD=$ac_cv_prog_LD
6837 if test -n "$LD"; then
6838   echo "$as_me:$LINENO: result: $LD" >&5
6839 echo "${ECHO_T}$LD" >&6
6840 else
6841   echo "$as_me:$LINENO: result: no" >&5
6842 echo "${ECHO_T}no" >&6
6843 fi
6844
6845   fi
6846   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6847     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6848 set dummy ${ncn_progname}; ac_word=$2
6849 echo "$as_me:$LINENO: checking for $ac_word" >&5
6850 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6851 if test "${ac_cv_prog_LD+set}" = set; then
6852   echo $ECHO_N "(cached) $ECHO_C" >&6
6853 else
6854   if test -n "$LD"; then
6855   ac_cv_prog_LD="$LD" # Let the user override the test.
6856 else
6857 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6858 for as_dir in $PATH
6859 do
6860   IFS=$as_save_IFS
6861   test -z "$as_dir" && as_dir=.
6862   for ac_exec_ext in '' $ac_executable_extensions; do
6863   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6864     ac_cv_prog_LD="${ncn_progname}"
6865     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6866     break 2
6867   fi
6868 done
6869 done
6870
6871 fi
6872 fi
6873 LD=$ac_cv_prog_LD
6874 if test -n "$LD"; then
6875   echo "$as_me:$LINENO: result: $LD" >&5
6876 echo "${ECHO_T}$LD" >&6
6877 else
6878   echo "$as_me:$LINENO: result: no" >&5
6879 echo "${ECHO_T}no" >&6
6880 fi
6881
6882   fi
6883   test -n "$ac_cv_prog_LD" && break
6884 done
6885
6886 if test -z "$ac_cv_prog_LD" ; then
6887   set dummy ld
6888   if test $build = $host ; then
6889     LD="$2"
6890   else
6891     LD="${ncn_tool_prefix}$2"
6892   fi
6893 fi
6894
6895
6896
6897 if test -n "$LIPO"; then
6898   ac_cv_prog_LIPO=$LIPO
6899 elif test -n "$ac_cv_prog_LIPO"; then
6900   LIPO=$ac_cv_prog_LIPO
6901 fi
6902
6903 if test -n "$ac_cv_prog_LIPO"; then
6904   for ncn_progname in lipo; do
6905     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6906 set dummy ${ncn_progname}; ac_word=$2
6907 echo "$as_me:$LINENO: checking for $ac_word" >&5
6908 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6909 if test "${ac_cv_prog_LIPO+set}" = set; then
6910   echo $ECHO_N "(cached) $ECHO_C" >&6
6911 else
6912   if test -n "$LIPO"; then
6913   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6914 else
6915 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6916 for as_dir in $PATH
6917 do
6918   IFS=$as_save_IFS
6919   test -z "$as_dir" && as_dir=.
6920   for ac_exec_ext in '' $ac_executable_extensions; do
6921   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6922     ac_cv_prog_LIPO="${ncn_progname}"
6923     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6924     break 2
6925   fi
6926 done
6927 done
6928
6929 fi
6930 fi
6931 LIPO=$ac_cv_prog_LIPO
6932 if test -n "$LIPO"; then
6933   echo "$as_me:$LINENO: result: $LIPO" >&5
6934 echo "${ECHO_T}$LIPO" >&6
6935 else
6936   echo "$as_me:$LINENO: result: no" >&5
6937 echo "${ECHO_T}no" >&6
6938 fi
6939
6940   done
6941 fi
6942
6943 for ncn_progname in lipo; do
6944   if test -n "$ncn_tool_prefix"; then
6945     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6946 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6947 echo "$as_me:$LINENO: checking for $ac_word" >&5
6948 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6949 if test "${ac_cv_prog_LIPO+set}" = set; then
6950   echo $ECHO_N "(cached) $ECHO_C" >&6
6951 else
6952   if test -n "$LIPO"; then
6953   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6954 else
6955 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6956 for as_dir in $PATH
6957 do
6958   IFS=$as_save_IFS
6959   test -z "$as_dir" && as_dir=.
6960   for ac_exec_ext in '' $ac_executable_extensions; do
6961   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6962     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
6963     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6964     break 2
6965   fi
6966 done
6967 done
6968
6969 fi
6970 fi
6971 LIPO=$ac_cv_prog_LIPO
6972 if test -n "$LIPO"; then
6973   echo "$as_me:$LINENO: result: $LIPO" >&5
6974 echo "${ECHO_T}$LIPO" >&6
6975 else
6976   echo "$as_me:$LINENO: result: no" >&5
6977 echo "${ECHO_T}no" >&6
6978 fi
6979
6980   fi
6981   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
6982     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6983 set dummy ${ncn_progname}; ac_word=$2
6984 echo "$as_me:$LINENO: checking for $ac_word" >&5
6985 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6986 if test "${ac_cv_prog_LIPO+set}" = set; then
6987   echo $ECHO_N "(cached) $ECHO_C" >&6
6988 else
6989   if test -n "$LIPO"; then
6990   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6991 else
6992 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6993 for as_dir in $PATH
6994 do
6995   IFS=$as_save_IFS
6996   test -z "$as_dir" && as_dir=.
6997   for ac_exec_ext in '' $ac_executable_extensions; do
6998   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6999     ac_cv_prog_LIPO="${ncn_progname}"
7000     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7001     break 2
7002   fi
7003 done
7004 done
7005
7006 fi
7007 fi
7008 LIPO=$ac_cv_prog_LIPO
7009 if test -n "$LIPO"; then
7010   echo "$as_me:$LINENO: result: $LIPO" >&5
7011 echo "${ECHO_T}$LIPO" >&6
7012 else
7013   echo "$as_me:$LINENO: result: no" >&5
7014 echo "${ECHO_T}no" >&6
7015 fi
7016
7017   fi
7018   test -n "$ac_cv_prog_LIPO" && break
7019 done
7020
7021 if test -z "$ac_cv_prog_LIPO" ; then
7022   set dummy lipo
7023   if test $build = $host ; then
7024     LIPO="$2"
7025   else
7026     LIPO="${ncn_tool_prefix}$2"
7027   fi
7028 fi
7029
7030
7031
7032 if test -n "$NM"; then
7033   ac_cv_prog_NM=$NM
7034 elif test -n "$ac_cv_prog_NM"; then
7035   NM=$ac_cv_prog_NM
7036 fi
7037
7038 if test -n "$ac_cv_prog_NM"; then
7039   for ncn_progname in nm; do
7040     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7041 set dummy ${ncn_progname}; ac_word=$2
7042 echo "$as_me:$LINENO: checking for $ac_word" >&5
7043 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7044 if test "${ac_cv_prog_NM+set}" = set; then
7045   echo $ECHO_N "(cached) $ECHO_C" >&6
7046 else
7047   if test -n "$NM"; then
7048   ac_cv_prog_NM="$NM" # Let the user override the test.
7049 else
7050 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7051 for as_dir in $PATH
7052 do
7053   IFS=$as_save_IFS
7054   test -z "$as_dir" && as_dir=.
7055   for ac_exec_ext in '' $ac_executable_extensions; do
7056   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7057     ac_cv_prog_NM="${ncn_progname}"
7058     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7059     break 2
7060   fi
7061 done
7062 done
7063
7064 fi
7065 fi
7066 NM=$ac_cv_prog_NM
7067 if test -n "$NM"; then
7068   echo "$as_me:$LINENO: result: $NM" >&5
7069 echo "${ECHO_T}$NM" >&6
7070 else
7071   echo "$as_me:$LINENO: result: no" >&5
7072 echo "${ECHO_T}no" >&6
7073 fi
7074
7075   done
7076 fi
7077
7078 for ncn_progname in nm; do
7079   if test -n "$ncn_tool_prefix"; then
7080     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7081 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7082 echo "$as_me:$LINENO: checking for $ac_word" >&5
7083 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7084 if test "${ac_cv_prog_NM+set}" = set; then
7085   echo $ECHO_N "(cached) $ECHO_C" >&6
7086 else
7087   if test -n "$NM"; then
7088   ac_cv_prog_NM="$NM" # Let the user override the test.
7089 else
7090 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7091 for as_dir in $PATH
7092 do
7093   IFS=$as_save_IFS
7094   test -z "$as_dir" && as_dir=.
7095   for ac_exec_ext in '' $ac_executable_extensions; do
7096   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7097     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7098     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7099     break 2
7100   fi
7101 done
7102 done
7103
7104 fi
7105 fi
7106 NM=$ac_cv_prog_NM
7107 if test -n "$NM"; then
7108   echo "$as_me:$LINENO: result: $NM" >&5
7109 echo "${ECHO_T}$NM" >&6
7110 else
7111   echo "$as_me:$LINENO: result: no" >&5
7112 echo "${ECHO_T}no" >&6
7113 fi
7114
7115   fi
7116   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7117     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7118 set dummy ${ncn_progname}; ac_word=$2
7119 echo "$as_me:$LINENO: checking for $ac_word" >&5
7120 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7121 if test "${ac_cv_prog_NM+set}" = set; then
7122   echo $ECHO_N "(cached) $ECHO_C" >&6
7123 else
7124   if test -n "$NM"; then
7125   ac_cv_prog_NM="$NM" # Let the user override the test.
7126 else
7127 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7128 for as_dir in $PATH
7129 do
7130   IFS=$as_save_IFS
7131   test -z "$as_dir" && as_dir=.
7132   for ac_exec_ext in '' $ac_executable_extensions; do
7133   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7134     ac_cv_prog_NM="${ncn_progname}"
7135     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7136     break 2
7137   fi
7138 done
7139 done
7140
7141 fi
7142 fi
7143 NM=$ac_cv_prog_NM
7144 if test -n "$NM"; then
7145   echo "$as_me:$LINENO: result: $NM" >&5
7146 echo "${ECHO_T}$NM" >&6
7147 else
7148   echo "$as_me:$LINENO: result: no" >&5
7149 echo "${ECHO_T}no" >&6
7150 fi
7151
7152   fi
7153   test -n "$ac_cv_prog_NM" && break
7154 done
7155
7156 if test -z "$ac_cv_prog_NM" ; then
7157   set dummy nm
7158   if test $build = $host ; then
7159     NM="$2"
7160   else
7161     NM="${ncn_tool_prefix}$2"
7162   fi
7163 fi
7164
7165
7166
7167 if test -n "$RANLIB"; then
7168   ac_cv_prog_RANLIB=$RANLIB
7169 elif test -n "$ac_cv_prog_RANLIB"; then
7170   RANLIB=$ac_cv_prog_RANLIB
7171 fi
7172
7173 if test -n "$ac_cv_prog_RANLIB"; then
7174   for ncn_progname in ranlib; do
7175     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7176 set dummy ${ncn_progname}; ac_word=$2
7177 echo "$as_me:$LINENO: checking for $ac_word" >&5
7178 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7179 if test "${ac_cv_prog_RANLIB+set}" = set; then
7180   echo $ECHO_N "(cached) $ECHO_C" >&6
7181 else
7182   if test -n "$RANLIB"; then
7183   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7184 else
7185 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7186 for as_dir in $PATH
7187 do
7188   IFS=$as_save_IFS
7189   test -z "$as_dir" && as_dir=.
7190   for ac_exec_ext in '' $ac_executable_extensions; do
7191   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7192     ac_cv_prog_RANLIB="${ncn_progname}"
7193     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7194     break 2
7195   fi
7196 done
7197 done
7198
7199 fi
7200 fi
7201 RANLIB=$ac_cv_prog_RANLIB
7202 if test -n "$RANLIB"; then
7203   echo "$as_me:$LINENO: result: $RANLIB" >&5
7204 echo "${ECHO_T}$RANLIB" >&6
7205 else
7206   echo "$as_me:$LINENO: result: no" >&5
7207 echo "${ECHO_T}no" >&6
7208 fi
7209
7210   done
7211 fi
7212
7213 for ncn_progname in ranlib; do
7214   if test -n "$ncn_tool_prefix"; then
7215     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7216 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7217 echo "$as_me:$LINENO: checking for $ac_word" >&5
7218 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7219 if test "${ac_cv_prog_RANLIB+set}" = set; then
7220   echo $ECHO_N "(cached) $ECHO_C" >&6
7221 else
7222   if test -n "$RANLIB"; then
7223   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7224 else
7225 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7226 for as_dir in $PATH
7227 do
7228   IFS=$as_save_IFS
7229   test -z "$as_dir" && as_dir=.
7230   for ac_exec_ext in '' $ac_executable_extensions; do
7231   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7232     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7233     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7234     break 2
7235   fi
7236 done
7237 done
7238
7239 fi
7240 fi
7241 RANLIB=$ac_cv_prog_RANLIB
7242 if test -n "$RANLIB"; then
7243   echo "$as_me:$LINENO: result: $RANLIB" >&5
7244 echo "${ECHO_T}$RANLIB" >&6
7245 else
7246   echo "$as_me:$LINENO: result: no" >&5
7247 echo "${ECHO_T}no" >&6
7248 fi
7249
7250   fi
7251   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7252     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7253 set dummy ${ncn_progname}; ac_word=$2
7254 echo "$as_me:$LINENO: checking for $ac_word" >&5
7255 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7256 if test "${ac_cv_prog_RANLIB+set}" = set; then
7257   echo $ECHO_N "(cached) $ECHO_C" >&6
7258 else
7259   if test -n "$RANLIB"; then
7260   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7261 else
7262 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7263 for as_dir in $PATH
7264 do
7265   IFS=$as_save_IFS
7266   test -z "$as_dir" && as_dir=.
7267   for ac_exec_ext in '' $ac_executable_extensions; do
7268   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7269     ac_cv_prog_RANLIB="${ncn_progname}"
7270     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7271     break 2
7272   fi
7273 done
7274 done
7275
7276 fi
7277 fi
7278 RANLIB=$ac_cv_prog_RANLIB
7279 if test -n "$RANLIB"; then
7280   echo "$as_me:$LINENO: result: $RANLIB" >&5
7281 echo "${ECHO_T}$RANLIB" >&6
7282 else
7283   echo "$as_me:$LINENO: result: no" >&5
7284 echo "${ECHO_T}no" >&6
7285 fi
7286
7287   fi
7288   test -n "$ac_cv_prog_RANLIB" && break
7289 done
7290
7291 if test -z "$ac_cv_prog_RANLIB" ; then
7292   RANLIB=":"
7293 fi
7294
7295
7296
7297 if test -n "$STRIP"; then
7298   ac_cv_prog_STRIP=$STRIP
7299 elif test -n "$ac_cv_prog_STRIP"; then
7300   STRIP=$ac_cv_prog_STRIP
7301 fi
7302
7303 if test -n "$ac_cv_prog_STRIP"; then
7304   for ncn_progname in strip; do
7305     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7306 set dummy ${ncn_progname}; ac_word=$2
7307 echo "$as_me:$LINENO: checking for $ac_word" >&5
7308 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7309 if test "${ac_cv_prog_STRIP+set}" = set; then
7310   echo $ECHO_N "(cached) $ECHO_C" >&6
7311 else
7312   if test -n "$STRIP"; then
7313   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7314 else
7315 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7316 for as_dir in $PATH
7317 do
7318   IFS=$as_save_IFS
7319   test -z "$as_dir" && as_dir=.
7320   for ac_exec_ext in '' $ac_executable_extensions; do
7321   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7322     ac_cv_prog_STRIP="${ncn_progname}"
7323     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7324     break 2
7325   fi
7326 done
7327 done
7328
7329 fi
7330 fi
7331 STRIP=$ac_cv_prog_STRIP
7332 if test -n "$STRIP"; then
7333   echo "$as_me:$LINENO: result: $STRIP" >&5
7334 echo "${ECHO_T}$STRIP" >&6
7335 else
7336   echo "$as_me:$LINENO: result: no" >&5
7337 echo "${ECHO_T}no" >&6
7338 fi
7339
7340   done
7341 fi
7342
7343 for ncn_progname in strip; do
7344   if test -n "$ncn_tool_prefix"; then
7345     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7346 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7347 echo "$as_me:$LINENO: checking for $ac_word" >&5
7348 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7349 if test "${ac_cv_prog_STRIP+set}" = set; then
7350   echo $ECHO_N "(cached) $ECHO_C" >&6
7351 else
7352   if test -n "$STRIP"; then
7353   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7354 else
7355 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7356 for as_dir in $PATH
7357 do
7358   IFS=$as_save_IFS
7359   test -z "$as_dir" && as_dir=.
7360   for ac_exec_ext in '' $ac_executable_extensions; do
7361   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7362     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7363     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7364     break 2
7365   fi
7366 done
7367 done
7368
7369 fi
7370 fi
7371 STRIP=$ac_cv_prog_STRIP
7372 if test -n "$STRIP"; then
7373   echo "$as_me:$LINENO: result: $STRIP" >&5
7374 echo "${ECHO_T}$STRIP" >&6
7375 else
7376   echo "$as_me:$LINENO: result: no" >&5
7377 echo "${ECHO_T}no" >&6
7378 fi
7379
7380   fi
7381   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7382     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7383 set dummy ${ncn_progname}; ac_word=$2
7384 echo "$as_me:$LINENO: checking for $ac_word" >&5
7385 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7386 if test "${ac_cv_prog_STRIP+set}" = set; then
7387   echo $ECHO_N "(cached) $ECHO_C" >&6
7388 else
7389   if test -n "$STRIP"; then
7390   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7391 else
7392 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7393 for as_dir in $PATH
7394 do
7395   IFS=$as_save_IFS
7396   test -z "$as_dir" && as_dir=.
7397   for ac_exec_ext in '' $ac_executable_extensions; do
7398   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7399     ac_cv_prog_STRIP="${ncn_progname}"
7400     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7401     break 2
7402   fi
7403 done
7404 done
7405
7406 fi
7407 fi
7408 STRIP=$ac_cv_prog_STRIP
7409 if test -n "$STRIP"; then
7410   echo "$as_me:$LINENO: result: $STRIP" >&5
7411 echo "${ECHO_T}$STRIP" >&6
7412 else
7413   echo "$as_me:$LINENO: result: no" >&5
7414 echo "${ECHO_T}no" >&6
7415 fi
7416
7417   fi
7418   test -n "$ac_cv_prog_STRIP" && break
7419 done
7420
7421 if test -z "$ac_cv_prog_STRIP" ; then
7422   STRIP=":"
7423 fi
7424
7425
7426
7427 if test -n "$WINDRES"; then
7428   ac_cv_prog_WINDRES=$WINDRES
7429 elif test -n "$ac_cv_prog_WINDRES"; then
7430   WINDRES=$ac_cv_prog_WINDRES
7431 fi
7432
7433 if test -n "$ac_cv_prog_WINDRES"; then
7434   for ncn_progname in windres; do
7435     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7436 set dummy ${ncn_progname}; ac_word=$2
7437 echo "$as_me:$LINENO: checking for $ac_word" >&5
7438 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7439 if test "${ac_cv_prog_WINDRES+set}" = set; then
7440   echo $ECHO_N "(cached) $ECHO_C" >&6
7441 else
7442   if test -n "$WINDRES"; then
7443   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7444 else
7445 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7446 for as_dir in $PATH
7447 do
7448   IFS=$as_save_IFS
7449   test -z "$as_dir" && as_dir=.
7450   for ac_exec_ext in '' $ac_executable_extensions; do
7451   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7452     ac_cv_prog_WINDRES="${ncn_progname}"
7453     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7454     break 2
7455   fi
7456 done
7457 done
7458
7459 fi
7460 fi
7461 WINDRES=$ac_cv_prog_WINDRES
7462 if test -n "$WINDRES"; then
7463   echo "$as_me:$LINENO: result: $WINDRES" >&5
7464 echo "${ECHO_T}$WINDRES" >&6
7465 else
7466   echo "$as_me:$LINENO: result: no" >&5
7467 echo "${ECHO_T}no" >&6
7468 fi
7469
7470   done
7471 fi
7472
7473 for ncn_progname in windres; do
7474   if test -n "$ncn_tool_prefix"; then
7475     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7476 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7477 echo "$as_me:$LINENO: checking for $ac_word" >&5
7478 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7479 if test "${ac_cv_prog_WINDRES+set}" = set; then
7480   echo $ECHO_N "(cached) $ECHO_C" >&6
7481 else
7482   if test -n "$WINDRES"; then
7483   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7484 else
7485 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7486 for as_dir in $PATH
7487 do
7488   IFS=$as_save_IFS
7489   test -z "$as_dir" && as_dir=.
7490   for ac_exec_ext in '' $ac_executable_extensions; do
7491   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7492     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7493     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7494     break 2
7495   fi
7496 done
7497 done
7498
7499 fi
7500 fi
7501 WINDRES=$ac_cv_prog_WINDRES
7502 if test -n "$WINDRES"; then
7503   echo "$as_me:$LINENO: result: $WINDRES" >&5
7504 echo "${ECHO_T}$WINDRES" >&6
7505 else
7506   echo "$as_me:$LINENO: result: no" >&5
7507 echo "${ECHO_T}no" >&6
7508 fi
7509
7510   fi
7511   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7512     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7513 set dummy ${ncn_progname}; ac_word=$2
7514 echo "$as_me:$LINENO: checking for $ac_word" >&5
7515 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7516 if test "${ac_cv_prog_WINDRES+set}" = set; then
7517   echo $ECHO_N "(cached) $ECHO_C" >&6
7518 else
7519   if test -n "$WINDRES"; then
7520   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7521 else
7522 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7523 for as_dir in $PATH
7524 do
7525   IFS=$as_save_IFS
7526   test -z "$as_dir" && as_dir=.
7527   for ac_exec_ext in '' $ac_executable_extensions; do
7528   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7529     ac_cv_prog_WINDRES="${ncn_progname}"
7530     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7531     break 2
7532   fi
7533 done
7534 done
7535
7536 fi
7537 fi
7538 WINDRES=$ac_cv_prog_WINDRES
7539 if test -n "$WINDRES"; then
7540   echo "$as_me:$LINENO: result: $WINDRES" >&5
7541 echo "${ECHO_T}$WINDRES" >&6
7542 else
7543   echo "$as_me:$LINENO: result: no" >&5
7544 echo "${ECHO_T}no" >&6
7545 fi
7546
7547   fi
7548   test -n "$ac_cv_prog_WINDRES" && break
7549 done
7550
7551 if test -z "$ac_cv_prog_WINDRES" ; then
7552   set dummy windres
7553   if test $build = $host ; then
7554     WINDRES="$2"
7555   else
7556     WINDRES="${ncn_tool_prefix}$2"
7557   fi
7558 fi
7559
7560
7561
7562 if test -n "$WINDMC"; then
7563   ac_cv_prog_WINDMC=$WINDMC
7564 elif test -n "$ac_cv_prog_WINDMC"; then
7565   WINDMC=$ac_cv_prog_WINDMC
7566 fi
7567
7568 if test -n "$ac_cv_prog_WINDMC"; then
7569   for ncn_progname in windmc; do
7570     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7571 set dummy ${ncn_progname}; ac_word=$2
7572 echo "$as_me:$LINENO: checking for $ac_word" >&5
7573 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7574 if test "${ac_cv_prog_WINDMC+set}" = set; then
7575   echo $ECHO_N "(cached) $ECHO_C" >&6
7576 else
7577   if test -n "$WINDMC"; then
7578   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7579 else
7580 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7581 for as_dir in $PATH
7582 do
7583   IFS=$as_save_IFS
7584   test -z "$as_dir" && as_dir=.
7585   for ac_exec_ext in '' $ac_executable_extensions; do
7586   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7587     ac_cv_prog_WINDMC="${ncn_progname}"
7588     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7589     break 2
7590   fi
7591 done
7592 done
7593
7594 fi
7595 fi
7596 WINDMC=$ac_cv_prog_WINDMC
7597 if test -n "$WINDMC"; then
7598   echo "$as_me:$LINENO: result: $WINDMC" >&5
7599 echo "${ECHO_T}$WINDMC" >&6
7600 else
7601   echo "$as_me:$LINENO: result: no" >&5
7602 echo "${ECHO_T}no" >&6
7603 fi
7604
7605   done
7606 fi
7607
7608 for ncn_progname in windmc; do
7609   if test -n "$ncn_tool_prefix"; then
7610     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7611 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7612 echo "$as_me:$LINENO: checking for $ac_word" >&5
7613 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7614 if test "${ac_cv_prog_WINDMC+set}" = set; then
7615   echo $ECHO_N "(cached) $ECHO_C" >&6
7616 else
7617   if test -n "$WINDMC"; then
7618   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7619 else
7620 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7621 for as_dir in $PATH
7622 do
7623   IFS=$as_save_IFS
7624   test -z "$as_dir" && as_dir=.
7625   for ac_exec_ext in '' $ac_executable_extensions; do
7626   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7627     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7628     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7629     break 2
7630   fi
7631 done
7632 done
7633
7634 fi
7635 fi
7636 WINDMC=$ac_cv_prog_WINDMC
7637 if test -n "$WINDMC"; then
7638   echo "$as_me:$LINENO: result: $WINDMC" >&5
7639 echo "${ECHO_T}$WINDMC" >&6
7640 else
7641   echo "$as_me:$LINENO: result: no" >&5
7642 echo "${ECHO_T}no" >&6
7643 fi
7644
7645   fi
7646   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7647     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7648 set dummy ${ncn_progname}; ac_word=$2
7649 echo "$as_me:$LINENO: checking for $ac_word" >&5
7650 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7651 if test "${ac_cv_prog_WINDMC+set}" = set; then
7652   echo $ECHO_N "(cached) $ECHO_C" >&6
7653 else
7654   if test -n "$WINDMC"; then
7655   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7656 else
7657 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7658 for as_dir in $PATH
7659 do
7660   IFS=$as_save_IFS
7661   test -z "$as_dir" && as_dir=.
7662   for ac_exec_ext in '' $ac_executable_extensions; do
7663   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7664     ac_cv_prog_WINDMC="${ncn_progname}"
7665     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7666     break 2
7667   fi
7668 done
7669 done
7670
7671 fi
7672 fi
7673 WINDMC=$ac_cv_prog_WINDMC
7674 if test -n "$WINDMC"; then
7675   echo "$as_me:$LINENO: result: $WINDMC" >&5
7676 echo "${ECHO_T}$WINDMC" >&6
7677 else
7678   echo "$as_me:$LINENO: result: no" >&5
7679 echo "${ECHO_T}no" >&6
7680 fi
7681
7682   fi
7683   test -n "$ac_cv_prog_WINDMC" && break
7684 done
7685
7686 if test -z "$ac_cv_prog_WINDMC" ; then
7687   set dummy windmc
7688   if test $build = $host ; then
7689     WINDMC="$2"
7690   else
7691     WINDMC="${ncn_tool_prefix}$2"
7692   fi
7693 fi
7694
7695
7696
7697 if test -n "$OBJCOPY"; then
7698   ac_cv_prog_OBJCOPY=$OBJCOPY
7699 elif test -n "$ac_cv_prog_OBJCOPY"; then
7700   OBJCOPY=$ac_cv_prog_OBJCOPY
7701 fi
7702
7703 if test -n "$ac_cv_prog_OBJCOPY"; then
7704   for ncn_progname in objcopy; do
7705     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7706 set dummy ${ncn_progname}; ac_word=$2
7707 echo "$as_me:$LINENO: checking for $ac_word" >&5
7708 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7709 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7710   echo $ECHO_N "(cached) $ECHO_C" >&6
7711 else
7712   if test -n "$OBJCOPY"; then
7713   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7714 else
7715 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7716 for as_dir in $PATH
7717 do
7718   IFS=$as_save_IFS
7719   test -z "$as_dir" && as_dir=.
7720   for ac_exec_ext in '' $ac_executable_extensions; do
7721   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7722     ac_cv_prog_OBJCOPY="${ncn_progname}"
7723     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7724     break 2
7725   fi
7726 done
7727 done
7728
7729 fi
7730 fi
7731 OBJCOPY=$ac_cv_prog_OBJCOPY
7732 if test -n "$OBJCOPY"; then
7733   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7734 echo "${ECHO_T}$OBJCOPY" >&6
7735 else
7736   echo "$as_me:$LINENO: result: no" >&5
7737 echo "${ECHO_T}no" >&6
7738 fi
7739
7740   done
7741 fi
7742
7743 for ncn_progname in objcopy; do
7744   if test -n "$ncn_tool_prefix"; then
7745     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7746 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7747 echo "$as_me:$LINENO: checking for $ac_word" >&5
7748 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7749 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7750   echo $ECHO_N "(cached) $ECHO_C" >&6
7751 else
7752   if test -n "$OBJCOPY"; then
7753   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7754 else
7755 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7756 for as_dir in $PATH
7757 do
7758   IFS=$as_save_IFS
7759   test -z "$as_dir" && as_dir=.
7760   for ac_exec_ext in '' $ac_executable_extensions; do
7761   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7762     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7763     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7764     break 2
7765   fi
7766 done
7767 done
7768
7769 fi
7770 fi
7771 OBJCOPY=$ac_cv_prog_OBJCOPY
7772 if test -n "$OBJCOPY"; then
7773   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7774 echo "${ECHO_T}$OBJCOPY" >&6
7775 else
7776   echo "$as_me:$LINENO: result: no" >&5
7777 echo "${ECHO_T}no" >&6
7778 fi
7779
7780   fi
7781   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7782     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7783 set dummy ${ncn_progname}; ac_word=$2
7784 echo "$as_me:$LINENO: checking for $ac_word" >&5
7785 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7786 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7787   echo $ECHO_N "(cached) $ECHO_C" >&6
7788 else
7789   if test -n "$OBJCOPY"; then
7790   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7791 else
7792 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7793 for as_dir in $PATH
7794 do
7795   IFS=$as_save_IFS
7796   test -z "$as_dir" && as_dir=.
7797   for ac_exec_ext in '' $ac_executable_extensions; do
7798   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7799     ac_cv_prog_OBJCOPY="${ncn_progname}"
7800     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7801     break 2
7802   fi
7803 done
7804 done
7805
7806 fi
7807 fi
7808 OBJCOPY=$ac_cv_prog_OBJCOPY
7809 if test -n "$OBJCOPY"; then
7810   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7811 echo "${ECHO_T}$OBJCOPY" >&6
7812 else
7813   echo "$as_me:$LINENO: result: no" >&5
7814 echo "${ECHO_T}no" >&6
7815 fi
7816
7817   fi
7818   test -n "$ac_cv_prog_OBJCOPY" && break
7819 done
7820
7821 if test -z "$ac_cv_prog_OBJCOPY" ; then
7822   set dummy objcopy
7823   if test $build = $host ; then
7824     OBJCOPY="$2"
7825   else
7826     OBJCOPY="${ncn_tool_prefix}$2"
7827   fi
7828 fi
7829
7830
7831
7832 if test -n "$OBJDUMP"; then
7833   ac_cv_prog_OBJDUMP=$OBJDUMP
7834 elif test -n "$ac_cv_prog_OBJDUMP"; then
7835   OBJDUMP=$ac_cv_prog_OBJDUMP
7836 fi
7837
7838 if test -n "$ac_cv_prog_OBJDUMP"; then
7839   for ncn_progname in objdump; do
7840     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7841 set dummy ${ncn_progname}; ac_word=$2
7842 echo "$as_me:$LINENO: checking for $ac_word" >&5
7843 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7844 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7845   echo $ECHO_N "(cached) $ECHO_C" >&6
7846 else
7847   if test -n "$OBJDUMP"; then
7848   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7849 else
7850 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7851 for as_dir in $PATH
7852 do
7853   IFS=$as_save_IFS
7854   test -z "$as_dir" && as_dir=.
7855   for ac_exec_ext in '' $ac_executable_extensions; do
7856   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7857     ac_cv_prog_OBJDUMP="${ncn_progname}"
7858     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7859     break 2
7860   fi
7861 done
7862 done
7863
7864 fi
7865 fi
7866 OBJDUMP=$ac_cv_prog_OBJDUMP
7867 if test -n "$OBJDUMP"; then
7868   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7869 echo "${ECHO_T}$OBJDUMP" >&6
7870 else
7871   echo "$as_me:$LINENO: result: no" >&5
7872 echo "${ECHO_T}no" >&6
7873 fi
7874
7875   done
7876 fi
7877
7878 for ncn_progname in objdump; do
7879   if test -n "$ncn_tool_prefix"; then
7880     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7881 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7882 echo "$as_me:$LINENO: checking for $ac_word" >&5
7883 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7884 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7885   echo $ECHO_N "(cached) $ECHO_C" >&6
7886 else
7887   if test -n "$OBJDUMP"; then
7888   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7889 else
7890 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7891 for as_dir in $PATH
7892 do
7893   IFS=$as_save_IFS
7894   test -z "$as_dir" && as_dir=.
7895   for ac_exec_ext in '' $ac_executable_extensions; do
7896   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7897     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7898     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7899     break 2
7900   fi
7901 done
7902 done
7903
7904 fi
7905 fi
7906 OBJDUMP=$ac_cv_prog_OBJDUMP
7907 if test -n "$OBJDUMP"; then
7908   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7909 echo "${ECHO_T}$OBJDUMP" >&6
7910 else
7911   echo "$as_me:$LINENO: result: no" >&5
7912 echo "${ECHO_T}no" >&6
7913 fi
7914
7915   fi
7916   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7917     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7918 set dummy ${ncn_progname}; ac_word=$2
7919 echo "$as_me:$LINENO: checking for $ac_word" >&5
7920 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7921 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7922   echo $ECHO_N "(cached) $ECHO_C" >&6
7923 else
7924   if test -n "$OBJDUMP"; then
7925   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7926 else
7927 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7928 for as_dir in $PATH
7929 do
7930   IFS=$as_save_IFS
7931   test -z "$as_dir" && as_dir=.
7932   for ac_exec_ext in '' $ac_executable_extensions; do
7933   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7934     ac_cv_prog_OBJDUMP="${ncn_progname}"
7935     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7936     break 2
7937   fi
7938 done
7939 done
7940
7941 fi
7942 fi
7943 OBJDUMP=$ac_cv_prog_OBJDUMP
7944 if test -n "$OBJDUMP"; then
7945   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7946 echo "${ECHO_T}$OBJDUMP" >&6
7947 else
7948   echo "$as_me:$LINENO: result: no" >&5
7949 echo "${ECHO_T}no" >&6
7950 fi
7951
7952   fi
7953   test -n "$ac_cv_prog_OBJDUMP" && break
7954 done
7955
7956 if test -z "$ac_cv_prog_OBJDUMP" ; then
7957   set dummy objdump
7958   if test $build = $host ; then
7959     OBJDUMP="$2"
7960   else
7961     OBJDUMP="${ncn_tool_prefix}$2"
7962   fi
7963 fi
7964
7965
7966
7967
7968
7969
7970 # Target tools.
7971
7972 # Check whether --with-build-time-tools or --without-build-time-tools was given.
7973 if test "${with_build_time_tools+set}" = set; then
7974   withval="$with_build_time_tools"
7975   case x"$withval" in
7976      x/*) ;;
7977      *)
7978        with_build_time_tools=
7979        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
7980 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
7981        ;;
7982    esac
7983 else
7984   with_build_time_tools=
7985 fi;
7986
7987
7988
7989 if test -n "$CC_FOR_TARGET"; then
7990   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
7991 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7992   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7993 fi
7994
7995 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7996   for ncn_progname in cc gcc; do
7997     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7998 set dummy ${ncn_progname}; ac_word=$2
7999 echo "$as_me:$LINENO: checking for $ac_word" >&5
8000 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8001 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8002   echo $ECHO_N "(cached) $ECHO_C" >&6
8003 else
8004   if test -n "$CC_FOR_TARGET"; then
8005   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8006 else
8007 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8008 for as_dir in $PATH
8009 do
8010   IFS=$as_save_IFS
8011   test -z "$as_dir" && as_dir=.
8012   for ac_exec_ext in '' $ac_executable_extensions; do
8013   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8014     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8015     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8016     break 2
8017   fi
8018 done
8019 done
8020
8021 fi
8022 fi
8023 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8024 if test -n "$CC_FOR_TARGET"; then
8025   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8026 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8027 else
8028   echo "$as_me:$LINENO: result: no" >&5
8029 echo "${ECHO_T}no" >&6
8030 fi
8031
8032   done
8033 fi
8034
8035 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8036   for ncn_progname in cc gcc; do
8037     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8038 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8039     if test -x $with_build_time_tools/${ncn_progname}; then
8040       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8041       echo "$as_me:$LINENO: result: yes" >&5
8042 echo "${ECHO_T}yes" >&6
8043       break
8044     else
8045       echo "$as_me:$LINENO: result: no" >&5
8046 echo "${ECHO_T}no" >&6
8047     fi
8048   done
8049 fi
8050
8051 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8052   for ncn_progname in cc gcc; do
8053     if test -n "$ncn_target_tool_prefix"; then
8054       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8055 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8056 echo "$as_me:$LINENO: checking for $ac_word" >&5
8057 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8058 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8059   echo $ECHO_N "(cached) $ECHO_C" >&6
8060 else
8061   if test -n "$CC_FOR_TARGET"; then
8062   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8063 else
8064 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8065 for as_dir in $PATH
8066 do
8067   IFS=$as_save_IFS
8068   test -z "$as_dir" && as_dir=.
8069   for ac_exec_ext in '' $ac_executable_extensions; do
8070   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8071     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8072     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8073     break 2
8074   fi
8075 done
8076 done
8077
8078 fi
8079 fi
8080 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8081 if test -n "$CC_FOR_TARGET"; then
8082   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8083 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8084 else
8085   echo "$as_me:$LINENO: result: no" >&5
8086 echo "${ECHO_T}no" >&6
8087 fi
8088
8089     fi
8090     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8091       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8092 set dummy ${ncn_progname}; ac_word=$2
8093 echo "$as_me:$LINENO: checking for $ac_word" >&5
8094 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8095 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8096   echo $ECHO_N "(cached) $ECHO_C" >&6
8097 else
8098   if test -n "$CC_FOR_TARGET"; then
8099   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8100 else
8101 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8102 for as_dir in $PATH
8103 do
8104   IFS=$as_save_IFS
8105   test -z "$as_dir" && as_dir=.
8106   for ac_exec_ext in '' $ac_executable_extensions; do
8107   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8108     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8109     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8110     break 2
8111   fi
8112 done
8113 done
8114
8115 fi
8116 fi
8117 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8118 if test -n "$CC_FOR_TARGET"; then
8119   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8120 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8121 else
8122   echo "$as_me:$LINENO: result: no" >&5
8123 echo "${ECHO_T}no" >&6
8124 fi
8125
8126     fi
8127     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8128   done
8129 fi
8130
8131 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8132   set dummy cc gcc
8133   if test $build = $target ; then
8134     CC_FOR_TARGET="$2"
8135   else
8136     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8137   fi
8138 else
8139   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8140 fi
8141
8142
8143
8144 if test -n "$CXX_FOR_TARGET"; then
8145   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8146 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8147   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8148 fi
8149
8150 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8151   for ncn_progname in c++ g++ cxx gxx; do
8152     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8153 set dummy ${ncn_progname}; ac_word=$2
8154 echo "$as_me:$LINENO: checking for $ac_word" >&5
8155 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8156 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8157   echo $ECHO_N "(cached) $ECHO_C" >&6
8158 else
8159   if test -n "$CXX_FOR_TARGET"; then
8160   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8161 else
8162 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8163 for as_dir in $PATH
8164 do
8165   IFS=$as_save_IFS
8166   test -z "$as_dir" && as_dir=.
8167   for ac_exec_ext in '' $ac_executable_extensions; do
8168   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8169     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8170     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8171     break 2
8172   fi
8173 done
8174 done
8175
8176 fi
8177 fi
8178 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8179 if test -n "$CXX_FOR_TARGET"; then
8180   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8181 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8182 else
8183   echo "$as_me:$LINENO: result: no" >&5
8184 echo "${ECHO_T}no" >&6
8185 fi
8186
8187   done
8188 fi
8189
8190 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8191   for ncn_progname in c++ g++ cxx gxx; do
8192     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8193 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8194     if test -x $with_build_time_tools/${ncn_progname}; then
8195       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8196       echo "$as_me:$LINENO: result: yes" >&5
8197 echo "${ECHO_T}yes" >&6
8198       break
8199     else
8200       echo "$as_me:$LINENO: result: no" >&5
8201 echo "${ECHO_T}no" >&6
8202     fi
8203   done
8204 fi
8205
8206 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8207   for ncn_progname in c++ g++ cxx gxx; do
8208     if test -n "$ncn_target_tool_prefix"; then
8209       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8210 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8211 echo "$as_me:$LINENO: checking for $ac_word" >&5
8212 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8213 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8214   echo $ECHO_N "(cached) $ECHO_C" >&6
8215 else
8216   if test -n "$CXX_FOR_TARGET"; then
8217   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8218 else
8219 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8220 for as_dir in $PATH
8221 do
8222   IFS=$as_save_IFS
8223   test -z "$as_dir" && as_dir=.
8224   for ac_exec_ext in '' $ac_executable_extensions; do
8225   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8226     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8227     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8228     break 2
8229   fi
8230 done
8231 done
8232
8233 fi
8234 fi
8235 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8236 if test -n "$CXX_FOR_TARGET"; then
8237   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8238 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8239 else
8240   echo "$as_me:$LINENO: result: no" >&5
8241 echo "${ECHO_T}no" >&6
8242 fi
8243
8244     fi
8245     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8246       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8247 set dummy ${ncn_progname}; ac_word=$2
8248 echo "$as_me:$LINENO: checking for $ac_word" >&5
8249 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8250 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8251   echo $ECHO_N "(cached) $ECHO_C" >&6
8252 else
8253   if test -n "$CXX_FOR_TARGET"; then
8254   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8255 else
8256 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8257 for as_dir in $PATH
8258 do
8259   IFS=$as_save_IFS
8260   test -z "$as_dir" && as_dir=.
8261   for ac_exec_ext in '' $ac_executable_extensions; do
8262   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8263     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8264     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8265     break 2
8266   fi
8267 done
8268 done
8269
8270 fi
8271 fi
8272 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8273 if test -n "$CXX_FOR_TARGET"; then
8274   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8275 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8276 else
8277   echo "$as_me:$LINENO: result: no" >&5
8278 echo "${ECHO_T}no" >&6
8279 fi
8280
8281     fi
8282     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8283   done
8284 fi
8285
8286 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8287   set dummy c++ g++ cxx gxx
8288   if test $build = $target ; then
8289     CXX_FOR_TARGET="$2"
8290   else
8291     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8292   fi
8293 else
8294   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8295 fi
8296
8297
8298
8299 if test -n "$GCC_FOR_TARGET"; then
8300   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8301 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8302   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8303 fi
8304
8305 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8306   for ncn_progname in gcc; do
8307     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8308 set dummy ${ncn_progname}; ac_word=$2
8309 echo "$as_me:$LINENO: checking for $ac_word" >&5
8310 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8311 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8312   echo $ECHO_N "(cached) $ECHO_C" >&6
8313 else
8314   if test -n "$GCC_FOR_TARGET"; then
8315   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8316 else
8317 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8318 for as_dir in $PATH
8319 do
8320   IFS=$as_save_IFS
8321   test -z "$as_dir" && as_dir=.
8322   for ac_exec_ext in '' $ac_executable_extensions; do
8323   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8324     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8325     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8326     break 2
8327   fi
8328 done
8329 done
8330
8331 fi
8332 fi
8333 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8334 if test -n "$GCC_FOR_TARGET"; then
8335   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8336 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8337 else
8338   echo "$as_me:$LINENO: result: no" >&5
8339 echo "${ECHO_T}no" >&6
8340 fi
8341
8342   done
8343 fi
8344
8345 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8346   for ncn_progname in gcc; do
8347     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8348 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8349     if test -x $with_build_time_tools/${ncn_progname}; then
8350       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8351       echo "$as_me:$LINENO: result: yes" >&5
8352 echo "${ECHO_T}yes" >&6
8353       break
8354     else
8355       echo "$as_me:$LINENO: result: no" >&5
8356 echo "${ECHO_T}no" >&6
8357     fi
8358   done
8359 fi
8360
8361 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8362   for ncn_progname in gcc; do
8363     if test -n "$ncn_target_tool_prefix"; then
8364       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8365 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8366 echo "$as_me:$LINENO: checking for $ac_word" >&5
8367 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8368 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8369   echo $ECHO_N "(cached) $ECHO_C" >&6
8370 else
8371   if test -n "$GCC_FOR_TARGET"; then
8372   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8373 else
8374 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8375 for as_dir in $PATH
8376 do
8377   IFS=$as_save_IFS
8378   test -z "$as_dir" && as_dir=.
8379   for ac_exec_ext in '' $ac_executable_extensions; do
8380   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8381     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8382     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8383     break 2
8384   fi
8385 done
8386 done
8387
8388 fi
8389 fi
8390 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8391 if test -n "$GCC_FOR_TARGET"; then
8392   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8393 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8394 else
8395   echo "$as_me:$LINENO: result: no" >&5
8396 echo "${ECHO_T}no" >&6
8397 fi
8398
8399     fi
8400     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8401       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8402 set dummy ${ncn_progname}; ac_word=$2
8403 echo "$as_me:$LINENO: checking for $ac_word" >&5
8404 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8405 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8406   echo $ECHO_N "(cached) $ECHO_C" >&6
8407 else
8408   if test -n "$GCC_FOR_TARGET"; then
8409   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8410 else
8411 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8412 for as_dir in $PATH
8413 do
8414   IFS=$as_save_IFS
8415   test -z "$as_dir" && as_dir=.
8416   for ac_exec_ext in '' $ac_executable_extensions; do
8417   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8418     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8419     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8420     break 2
8421   fi
8422 done
8423 done
8424
8425 fi
8426 fi
8427 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8428 if test -n "$GCC_FOR_TARGET"; then
8429   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8430 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8431 else
8432   echo "$as_me:$LINENO: result: no" >&5
8433 echo "${ECHO_T}no" >&6
8434 fi
8435
8436     fi
8437     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8438   done
8439 fi
8440
8441 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8442   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8443 else
8444   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8445 fi
8446
8447
8448
8449 if test -n "$GCJ_FOR_TARGET"; then
8450   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8451 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8452   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8453 fi
8454
8455 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8456   for ncn_progname in gcj; do
8457     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8458 set dummy ${ncn_progname}; ac_word=$2
8459 echo "$as_me:$LINENO: checking for $ac_word" >&5
8460 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8461 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8462   echo $ECHO_N "(cached) $ECHO_C" >&6
8463 else
8464   if test -n "$GCJ_FOR_TARGET"; then
8465   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8466 else
8467 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8468 for as_dir in $PATH
8469 do
8470   IFS=$as_save_IFS
8471   test -z "$as_dir" && as_dir=.
8472   for ac_exec_ext in '' $ac_executable_extensions; do
8473   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8474     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8475     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8476     break 2
8477   fi
8478 done
8479 done
8480
8481 fi
8482 fi
8483 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8484 if test -n "$GCJ_FOR_TARGET"; then
8485   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8486 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8487 else
8488   echo "$as_me:$LINENO: result: no" >&5
8489 echo "${ECHO_T}no" >&6
8490 fi
8491
8492   done
8493 fi
8494
8495 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8496   for ncn_progname in gcj; do
8497     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8498 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8499     if test -x $with_build_time_tools/${ncn_progname}; then
8500       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8501       echo "$as_me:$LINENO: result: yes" >&5
8502 echo "${ECHO_T}yes" >&6
8503       break
8504     else
8505       echo "$as_me:$LINENO: result: no" >&5
8506 echo "${ECHO_T}no" >&6
8507     fi
8508   done
8509 fi
8510
8511 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8512   for ncn_progname in gcj; do
8513     if test -n "$ncn_target_tool_prefix"; then
8514       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8515 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8516 echo "$as_me:$LINENO: checking for $ac_word" >&5
8517 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8518 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8519   echo $ECHO_N "(cached) $ECHO_C" >&6
8520 else
8521   if test -n "$GCJ_FOR_TARGET"; then
8522   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8523 else
8524 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8525 for as_dir in $PATH
8526 do
8527   IFS=$as_save_IFS
8528   test -z "$as_dir" && as_dir=.
8529   for ac_exec_ext in '' $ac_executable_extensions; do
8530   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8531     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8532     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8533     break 2
8534   fi
8535 done
8536 done
8537
8538 fi
8539 fi
8540 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8541 if test -n "$GCJ_FOR_TARGET"; then
8542   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8543 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8544 else
8545   echo "$as_me:$LINENO: result: no" >&5
8546 echo "${ECHO_T}no" >&6
8547 fi
8548
8549     fi
8550     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8551       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8552 set dummy ${ncn_progname}; ac_word=$2
8553 echo "$as_me:$LINENO: checking for $ac_word" >&5
8554 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8555 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8556   echo $ECHO_N "(cached) $ECHO_C" >&6
8557 else
8558   if test -n "$GCJ_FOR_TARGET"; then
8559   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8560 else
8561 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8562 for as_dir in $PATH
8563 do
8564   IFS=$as_save_IFS
8565   test -z "$as_dir" && as_dir=.
8566   for ac_exec_ext in '' $ac_executable_extensions; do
8567   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8568     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8569     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8570     break 2
8571   fi
8572 done
8573 done
8574
8575 fi
8576 fi
8577 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8578 if test -n "$GCJ_FOR_TARGET"; then
8579   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8580 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8581 else
8582   echo "$as_me:$LINENO: result: no" >&5
8583 echo "${ECHO_T}no" >&6
8584 fi
8585
8586     fi
8587     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8588   done
8589 fi
8590
8591 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8592   set dummy gcj
8593   if test $build = $target ; then
8594     GCJ_FOR_TARGET="$2"
8595   else
8596     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8597   fi
8598 else
8599   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8600 fi
8601
8602
8603
8604 if test -n "$GFORTRAN_FOR_TARGET"; then
8605   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8606 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8607   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8608 fi
8609
8610 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8611   for ncn_progname in gfortran; do
8612     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8613 set dummy ${ncn_progname}; ac_word=$2
8614 echo "$as_me:$LINENO: checking for $ac_word" >&5
8615 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8616 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8617   echo $ECHO_N "(cached) $ECHO_C" >&6
8618 else
8619   if test -n "$GFORTRAN_FOR_TARGET"; then
8620   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8621 else
8622 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8623 for as_dir in $PATH
8624 do
8625   IFS=$as_save_IFS
8626   test -z "$as_dir" && as_dir=.
8627   for ac_exec_ext in '' $ac_executable_extensions; do
8628   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8629     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8630     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8631     break 2
8632   fi
8633 done
8634 done
8635
8636 fi
8637 fi
8638 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8639 if test -n "$GFORTRAN_FOR_TARGET"; then
8640   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8641 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8642 else
8643   echo "$as_me:$LINENO: result: no" >&5
8644 echo "${ECHO_T}no" >&6
8645 fi
8646
8647   done
8648 fi
8649
8650 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8651   for ncn_progname in gfortran; do
8652     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8653 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8654     if test -x $with_build_time_tools/${ncn_progname}; then
8655       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8656       echo "$as_me:$LINENO: result: yes" >&5
8657 echo "${ECHO_T}yes" >&6
8658       break
8659     else
8660       echo "$as_me:$LINENO: result: no" >&5
8661 echo "${ECHO_T}no" >&6
8662     fi
8663   done
8664 fi
8665
8666 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8667   for ncn_progname in gfortran; do
8668     if test -n "$ncn_target_tool_prefix"; then
8669       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8670 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8671 echo "$as_me:$LINENO: checking for $ac_word" >&5
8672 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8673 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8674   echo $ECHO_N "(cached) $ECHO_C" >&6
8675 else
8676   if test -n "$GFORTRAN_FOR_TARGET"; then
8677   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8678 else
8679 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8680 for as_dir in $PATH
8681 do
8682   IFS=$as_save_IFS
8683   test -z "$as_dir" && as_dir=.
8684   for ac_exec_ext in '' $ac_executable_extensions; do
8685   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8686     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8687     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8688     break 2
8689   fi
8690 done
8691 done
8692
8693 fi
8694 fi
8695 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8696 if test -n "$GFORTRAN_FOR_TARGET"; then
8697   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8698 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8699 else
8700   echo "$as_me:$LINENO: result: no" >&5
8701 echo "${ECHO_T}no" >&6
8702 fi
8703
8704     fi
8705     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8706       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8707 set dummy ${ncn_progname}; ac_word=$2
8708 echo "$as_me:$LINENO: checking for $ac_word" >&5
8709 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8710 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8711   echo $ECHO_N "(cached) $ECHO_C" >&6
8712 else
8713   if test -n "$GFORTRAN_FOR_TARGET"; then
8714   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8715 else
8716 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8717 for as_dir in $PATH
8718 do
8719   IFS=$as_save_IFS
8720   test -z "$as_dir" && as_dir=.
8721   for ac_exec_ext in '' $ac_executable_extensions; do
8722   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8723     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8724     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8725     break 2
8726   fi
8727 done
8728 done
8729
8730 fi
8731 fi
8732 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8733 if test -n "$GFORTRAN_FOR_TARGET"; then
8734   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8735 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8736 else
8737   echo "$as_me:$LINENO: result: no" >&5
8738 echo "${ECHO_T}no" >&6
8739 fi
8740
8741     fi
8742     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8743   done
8744 fi
8745
8746 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8747   set dummy gfortran
8748   if test $build = $target ; then
8749     GFORTRAN_FOR_TARGET="$2"
8750   else
8751     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8752   fi
8753 else
8754   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8755 fi
8756
8757
8758
8759 cat > conftest.c << \EOF
8760 #ifdef __GNUC__
8761   gcc_yay;
8762 #endif
8763 EOF
8764 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8765   have_gcc_for_target=yes
8766 else
8767   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8768   have_gcc_for_target=no
8769 fi
8770 rm conftest.c
8771
8772
8773
8774
8775 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8776   if test -n "$with_build_time_tools"; then
8777     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8778 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8779     if test -x $with_build_time_tools/ar; then
8780       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8781       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8782       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8783 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8784     else
8785       echo "$as_me:$LINENO: result: no" >&5
8786 echo "${ECHO_T}no" >&6
8787     fi
8788   elif test $build != $host && test $have_gcc_for_target = yes; then
8789     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8790     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8791     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8792   fi
8793 fi
8794 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8795   # Extract the first word of "ar", so it can be a program name with args.
8796 set dummy ar; ac_word=$2
8797 echo "$as_me:$LINENO: checking for $ac_word" >&5
8798 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8799 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8800   echo $ECHO_N "(cached) $ECHO_C" >&6
8801 else
8802   case $AR_FOR_TARGET in
8803   [\\/]* | ?:[\\/]*)
8804   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8805   ;;
8806   *)
8807   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8808 for as_dir in $gcc_cv_tool_dirs
8809 do
8810   IFS=$as_save_IFS
8811   test -z "$as_dir" && as_dir=.
8812   for ac_exec_ext in '' $ac_executable_extensions; do
8813   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8814     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8815     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8816     break 2
8817   fi
8818 done
8819 done
8820
8821   ;;
8822 esac
8823 fi
8824 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8825
8826 if test -n "$AR_FOR_TARGET"; then
8827   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8828 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8829 else
8830   echo "$as_me:$LINENO: result: no" >&5
8831 echo "${ECHO_T}no" >&6
8832 fi
8833
8834 fi
8835 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8836
8837
8838 if test -n "$AR_FOR_TARGET"; then
8839   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8840 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8841   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8842 fi
8843
8844 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8845   for ncn_progname in ar; do
8846     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8847 set dummy ${ncn_progname}; ac_word=$2
8848 echo "$as_me:$LINENO: checking for $ac_word" >&5
8849 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8850 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8851   echo $ECHO_N "(cached) $ECHO_C" >&6
8852 else
8853   if test -n "$AR_FOR_TARGET"; then
8854   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8855 else
8856 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8857 for as_dir in $PATH
8858 do
8859   IFS=$as_save_IFS
8860   test -z "$as_dir" && as_dir=.
8861   for ac_exec_ext in '' $ac_executable_extensions; do
8862   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8863     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8864     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8865     break 2
8866   fi
8867 done
8868 done
8869
8870 fi
8871 fi
8872 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8873 if test -n "$AR_FOR_TARGET"; then
8874   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8875 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8876 else
8877   echo "$as_me:$LINENO: result: no" >&5
8878 echo "${ECHO_T}no" >&6
8879 fi
8880
8881   done
8882 fi
8883
8884 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8885   for ncn_progname in ar; do
8886     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8887 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8888     if test -x $with_build_time_tools/${ncn_progname}; then
8889       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8890       echo "$as_me:$LINENO: result: yes" >&5
8891 echo "${ECHO_T}yes" >&6
8892       break
8893     else
8894       echo "$as_me:$LINENO: result: no" >&5
8895 echo "${ECHO_T}no" >&6
8896     fi
8897   done
8898 fi
8899
8900 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8901   for ncn_progname in ar; do
8902     if test -n "$ncn_target_tool_prefix"; then
8903       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8904 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8905 echo "$as_me:$LINENO: checking for $ac_word" >&5
8906 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8907 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8908   echo $ECHO_N "(cached) $ECHO_C" >&6
8909 else
8910   if test -n "$AR_FOR_TARGET"; then
8911   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8912 else
8913 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8914 for as_dir in $PATH
8915 do
8916   IFS=$as_save_IFS
8917   test -z "$as_dir" && as_dir=.
8918   for ac_exec_ext in '' $ac_executable_extensions; do
8919   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8920     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8921     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8922     break 2
8923   fi
8924 done
8925 done
8926
8927 fi
8928 fi
8929 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8930 if test -n "$AR_FOR_TARGET"; then
8931   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8932 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8933 else
8934   echo "$as_me:$LINENO: result: no" >&5
8935 echo "${ECHO_T}no" >&6
8936 fi
8937
8938     fi
8939     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
8940       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8941 set dummy ${ncn_progname}; ac_word=$2
8942 echo "$as_me:$LINENO: checking for $ac_word" >&5
8943 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8944 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8945   echo $ECHO_N "(cached) $ECHO_C" >&6
8946 else
8947   if test -n "$AR_FOR_TARGET"; then
8948   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8949 else
8950 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8951 for as_dir in $PATH
8952 do
8953   IFS=$as_save_IFS
8954   test -z "$as_dir" && as_dir=.
8955   for ac_exec_ext in '' $ac_executable_extensions; do
8956   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8957     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8958     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8959     break 2
8960   fi
8961 done
8962 done
8963
8964 fi
8965 fi
8966 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8967 if test -n "$AR_FOR_TARGET"; then
8968   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8969 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8970 else
8971   echo "$as_me:$LINENO: result: no" >&5
8972 echo "${ECHO_T}no" >&6
8973 fi
8974
8975     fi
8976     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
8977   done
8978 fi
8979
8980 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
8981   set dummy ar
8982   if test $build = $target ; then
8983     AR_FOR_TARGET="$2"
8984   else
8985     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
8986   fi
8987 else
8988   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
8989 fi
8990
8991 else
8992   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8993 fi
8994
8995
8996
8997
8998 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8999   if test -n "$with_build_time_tools"; then
9000     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9001 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9002     if test -x $with_build_time_tools/as; then
9003       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9004       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9005       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9006 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9007     else
9008       echo "$as_me:$LINENO: result: no" >&5
9009 echo "${ECHO_T}no" >&6
9010     fi
9011   elif test $build != $host && test $have_gcc_for_target = yes; then
9012     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9013     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9014     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9015   fi
9016 fi
9017 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9018   # Extract the first word of "as", so it can be a program name with args.
9019 set dummy as; ac_word=$2
9020 echo "$as_me:$LINENO: checking for $ac_word" >&5
9021 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9022 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9023   echo $ECHO_N "(cached) $ECHO_C" >&6
9024 else
9025   case $AS_FOR_TARGET in
9026   [\\/]* | ?:[\\/]*)
9027   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9028   ;;
9029   *)
9030   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9031 for as_dir in $gcc_cv_tool_dirs
9032 do
9033   IFS=$as_save_IFS
9034   test -z "$as_dir" && as_dir=.
9035   for ac_exec_ext in '' $ac_executable_extensions; do
9036   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9037     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9038     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9039     break 2
9040   fi
9041 done
9042 done
9043
9044   ;;
9045 esac
9046 fi
9047 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9048
9049 if test -n "$AS_FOR_TARGET"; then
9050   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9051 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9052 else
9053   echo "$as_me:$LINENO: result: no" >&5
9054 echo "${ECHO_T}no" >&6
9055 fi
9056
9057 fi
9058 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9059
9060
9061 if test -n "$AS_FOR_TARGET"; then
9062   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9063 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9064   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9065 fi
9066
9067 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9068   for ncn_progname in as; do
9069     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9070 set dummy ${ncn_progname}; ac_word=$2
9071 echo "$as_me:$LINENO: checking for $ac_word" >&5
9072 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9073 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9074   echo $ECHO_N "(cached) $ECHO_C" >&6
9075 else
9076   if test -n "$AS_FOR_TARGET"; then
9077   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9078 else
9079 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9080 for as_dir in $PATH
9081 do
9082   IFS=$as_save_IFS
9083   test -z "$as_dir" && as_dir=.
9084   for ac_exec_ext in '' $ac_executable_extensions; do
9085   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9086     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9087     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9088     break 2
9089   fi
9090 done
9091 done
9092
9093 fi
9094 fi
9095 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9096 if test -n "$AS_FOR_TARGET"; then
9097   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9098 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9099 else
9100   echo "$as_me:$LINENO: result: no" >&5
9101 echo "${ECHO_T}no" >&6
9102 fi
9103
9104   done
9105 fi
9106
9107 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9108   for ncn_progname in as; do
9109     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9110 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9111     if test -x $with_build_time_tools/${ncn_progname}; then
9112       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9113       echo "$as_me:$LINENO: result: yes" >&5
9114 echo "${ECHO_T}yes" >&6
9115       break
9116     else
9117       echo "$as_me:$LINENO: result: no" >&5
9118 echo "${ECHO_T}no" >&6
9119     fi
9120   done
9121 fi
9122
9123 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9124   for ncn_progname in as; do
9125     if test -n "$ncn_target_tool_prefix"; then
9126       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9127 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9128 echo "$as_me:$LINENO: checking for $ac_word" >&5
9129 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9130 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9131   echo $ECHO_N "(cached) $ECHO_C" >&6
9132 else
9133   if test -n "$AS_FOR_TARGET"; then
9134   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9135 else
9136 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9137 for as_dir in $PATH
9138 do
9139   IFS=$as_save_IFS
9140   test -z "$as_dir" && as_dir=.
9141   for ac_exec_ext in '' $ac_executable_extensions; do
9142   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9143     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9144     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9145     break 2
9146   fi
9147 done
9148 done
9149
9150 fi
9151 fi
9152 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9153 if test -n "$AS_FOR_TARGET"; then
9154   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9155 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9156 else
9157   echo "$as_me:$LINENO: result: no" >&5
9158 echo "${ECHO_T}no" >&6
9159 fi
9160
9161     fi
9162     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9163       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9164 set dummy ${ncn_progname}; ac_word=$2
9165 echo "$as_me:$LINENO: checking for $ac_word" >&5
9166 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9167 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9168   echo $ECHO_N "(cached) $ECHO_C" >&6
9169 else
9170   if test -n "$AS_FOR_TARGET"; then
9171   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9172 else
9173 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9174 for as_dir in $PATH
9175 do
9176   IFS=$as_save_IFS
9177   test -z "$as_dir" && as_dir=.
9178   for ac_exec_ext in '' $ac_executable_extensions; do
9179   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9180     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9181     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9182     break 2
9183   fi
9184 done
9185 done
9186
9187 fi
9188 fi
9189 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9190 if test -n "$AS_FOR_TARGET"; then
9191   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9192 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9193 else
9194   echo "$as_me:$LINENO: result: no" >&5
9195 echo "${ECHO_T}no" >&6
9196 fi
9197
9198     fi
9199     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9200   done
9201 fi
9202
9203 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9204   set dummy as
9205   if test $build = $target ; then
9206     AS_FOR_TARGET="$2"
9207   else
9208     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9209   fi
9210 else
9211   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9212 fi
9213
9214 else
9215   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9216 fi
9217
9218
9219
9220
9221 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9222   if test -n "$with_build_time_tools"; then
9223     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9224 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9225     if test -x $with_build_time_tools/dlltool; then
9226       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9227       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9228       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9229 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9230     else
9231       echo "$as_me:$LINENO: result: no" >&5
9232 echo "${ECHO_T}no" >&6
9233     fi
9234   elif test $build != $host && test $have_gcc_for_target = yes; then
9235     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9236     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9237     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9238   fi
9239 fi
9240 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9241   # Extract the first word of "dlltool", so it can be a program name with args.
9242 set dummy dlltool; ac_word=$2
9243 echo "$as_me:$LINENO: checking for $ac_word" >&5
9244 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9245 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9246   echo $ECHO_N "(cached) $ECHO_C" >&6
9247 else
9248   case $DLLTOOL_FOR_TARGET in
9249   [\\/]* | ?:[\\/]*)
9250   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9251   ;;
9252   *)
9253   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9254 for as_dir in $gcc_cv_tool_dirs
9255 do
9256   IFS=$as_save_IFS
9257   test -z "$as_dir" && as_dir=.
9258   for ac_exec_ext in '' $ac_executable_extensions; do
9259   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9260     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9261     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9262     break 2
9263   fi
9264 done
9265 done
9266
9267   ;;
9268 esac
9269 fi
9270 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9271
9272 if test -n "$DLLTOOL_FOR_TARGET"; then
9273   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9274 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9275 else
9276   echo "$as_me:$LINENO: result: no" >&5
9277 echo "${ECHO_T}no" >&6
9278 fi
9279
9280 fi
9281 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9282
9283
9284 if test -n "$DLLTOOL_FOR_TARGET"; then
9285   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9286 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9287   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9288 fi
9289
9290 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9291   for ncn_progname in dlltool; do
9292     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9293 set dummy ${ncn_progname}; ac_word=$2
9294 echo "$as_me:$LINENO: checking for $ac_word" >&5
9295 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9296 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9297   echo $ECHO_N "(cached) $ECHO_C" >&6
9298 else
9299   if test -n "$DLLTOOL_FOR_TARGET"; then
9300   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9301 else
9302 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9303 for as_dir in $PATH
9304 do
9305   IFS=$as_save_IFS
9306   test -z "$as_dir" && as_dir=.
9307   for ac_exec_ext in '' $ac_executable_extensions; do
9308   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9309     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9310     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9311     break 2
9312   fi
9313 done
9314 done
9315
9316 fi
9317 fi
9318 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9319 if test -n "$DLLTOOL_FOR_TARGET"; then
9320   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9321 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9322 else
9323   echo "$as_me:$LINENO: result: no" >&5
9324 echo "${ECHO_T}no" >&6
9325 fi
9326
9327   done
9328 fi
9329
9330 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9331   for ncn_progname in dlltool; do
9332     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9333 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9334     if test -x $with_build_time_tools/${ncn_progname}; then
9335       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9336       echo "$as_me:$LINENO: result: yes" >&5
9337 echo "${ECHO_T}yes" >&6
9338       break
9339     else
9340       echo "$as_me:$LINENO: result: no" >&5
9341 echo "${ECHO_T}no" >&6
9342     fi
9343   done
9344 fi
9345
9346 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9347   for ncn_progname in dlltool; do
9348     if test -n "$ncn_target_tool_prefix"; then
9349       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9350 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9351 echo "$as_me:$LINENO: checking for $ac_word" >&5
9352 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9353 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9354   echo $ECHO_N "(cached) $ECHO_C" >&6
9355 else
9356   if test -n "$DLLTOOL_FOR_TARGET"; then
9357   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9358 else
9359 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9360 for as_dir in $PATH
9361 do
9362   IFS=$as_save_IFS
9363   test -z "$as_dir" && as_dir=.
9364   for ac_exec_ext in '' $ac_executable_extensions; do
9365   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9366     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9367     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9368     break 2
9369   fi
9370 done
9371 done
9372
9373 fi
9374 fi
9375 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9376 if test -n "$DLLTOOL_FOR_TARGET"; then
9377   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9378 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9379 else
9380   echo "$as_me:$LINENO: result: no" >&5
9381 echo "${ECHO_T}no" >&6
9382 fi
9383
9384     fi
9385     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9386       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9387 set dummy ${ncn_progname}; ac_word=$2
9388 echo "$as_me:$LINENO: checking for $ac_word" >&5
9389 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9390 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9391   echo $ECHO_N "(cached) $ECHO_C" >&6
9392 else
9393   if test -n "$DLLTOOL_FOR_TARGET"; then
9394   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9395 else
9396 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9397 for as_dir in $PATH
9398 do
9399   IFS=$as_save_IFS
9400   test -z "$as_dir" && as_dir=.
9401   for ac_exec_ext in '' $ac_executable_extensions; do
9402   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9403     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9404     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9405     break 2
9406   fi
9407 done
9408 done
9409
9410 fi
9411 fi
9412 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9413 if test -n "$DLLTOOL_FOR_TARGET"; then
9414   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9415 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9416 else
9417   echo "$as_me:$LINENO: result: no" >&5
9418 echo "${ECHO_T}no" >&6
9419 fi
9420
9421     fi
9422     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9423   done
9424 fi
9425
9426 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9427   set dummy dlltool
9428   if test $build = $target ; then
9429     DLLTOOL_FOR_TARGET="$2"
9430   else
9431     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9432   fi
9433 else
9434   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9435 fi
9436
9437 else
9438   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9439 fi
9440
9441
9442
9443
9444 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9445   if test -n "$with_build_time_tools"; then
9446     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9447 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9448     if test -x $with_build_time_tools/ld; then
9449       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9450       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9451       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9452 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9453     else
9454       echo "$as_me:$LINENO: result: no" >&5
9455 echo "${ECHO_T}no" >&6
9456     fi
9457   elif test $build != $host && test $have_gcc_for_target = yes; then
9458     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9459     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9460     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9461   fi
9462 fi
9463 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9464   # Extract the first word of "ld", so it can be a program name with args.
9465 set dummy ld; ac_word=$2
9466 echo "$as_me:$LINENO: checking for $ac_word" >&5
9467 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9468 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9469   echo $ECHO_N "(cached) $ECHO_C" >&6
9470 else
9471   case $LD_FOR_TARGET in
9472   [\\/]* | ?:[\\/]*)
9473   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9474   ;;
9475   *)
9476   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9477 for as_dir in $gcc_cv_tool_dirs
9478 do
9479   IFS=$as_save_IFS
9480   test -z "$as_dir" && as_dir=.
9481   for ac_exec_ext in '' $ac_executable_extensions; do
9482   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9483     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9484     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9485     break 2
9486   fi
9487 done
9488 done
9489
9490   ;;
9491 esac
9492 fi
9493 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9494
9495 if test -n "$LD_FOR_TARGET"; then
9496   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9497 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9498 else
9499   echo "$as_me:$LINENO: result: no" >&5
9500 echo "${ECHO_T}no" >&6
9501 fi
9502
9503 fi
9504 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9505
9506
9507 if test -n "$LD_FOR_TARGET"; then
9508   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9509 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9510   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9511 fi
9512
9513 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9514   for ncn_progname in ld; do
9515     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9516 set dummy ${ncn_progname}; ac_word=$2
9517 echo "$as_me:$LINENO: checking for $ac_word" >&5
9518 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9519 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9520   echo $ECHO_N "(cached) $ECHO_C" >&6
9521 else
9522   if test -n "$LD_FOR_TARGET"; then
9523   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9524 else
9525 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9526 for as_dir in $PATH
9527 do
9528   IFS=$as_save_IFS
9529   test -z "$as_dir" && as_dir=.
9530   for ac_exec_ext in '' $ac_executable_extensions; do
9531   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9532     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9533     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9534     break 2
9535   fi
9536 done
9537 done
9538
9539 fi
9540 fi
9541 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9542 if test -n "$LD_FOR_TARGET"; then
9543   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9544 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9545 else
9546   echo "$as_me:$LINENO: result: no" >&5
9547 echo "${ECHO_T}no" >&6
9548 fi
9549
9550   done
9551 fi
9552
9553 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9554   for ncn_progname in ld; do
9555     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9556 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9557     if test -x $with_build_time_tools/${ncn_progname}; then
9558       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9559       echo "$as_me:$LINENO: result: yes" >&5
9560 echo "${ECHO_T}yes" >&6
9561       break
9562     else
9563       echo "$as_me:$LINENO: result: no" >&5
9564 echo "${ECHO_T}no" >&6
9565     fi
9566   done
9567 fi
9568
9569 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9570   for ncn_progname in ld; do
9571     if test -n "$ncn_target_tool_prefix"; then
9572       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9573 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9574 echo "$as_me:$LINENO: checking for $ac_word" >&5
9575 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9576 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9577   echo $ECHO_N "(cached) $ECHO_C" >&6
9578 else
9579   if test -n "$LD_FOR_TARGET"; then
9580   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9581 else
9582 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9583 for as_dir in $PATH
9584 do
9585   IFS=$as_save_IFS
9586   test -z "$as_dir" && as_dir=.
9587   for ac_exec_ext in '' $ac_executable_extensions; do
9588   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9589     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9590     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9591     break 2
9592   fi
9593 done
9594 done
9595
9596 fi
9597 fi
9598 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9599 if test -n "$LD_FOR_TARGET"; then
9600   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9601 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9602 else
9603   echo "$as_me:$LINENO: result: no" >&5
9604 echo "${ECHO_T}no" >&6
9605 fi
9606
9607     fi
9608     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9609       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9610 set dummy ${ncn_progname}; ac_word=$2
9611 echo "$as_me:$LINENO: checking for $ac_word" >&5
9612 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9613 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9614   echo $ECHO_N "(cached) $ECHO_C" >&6
9615 else
9616   if test -n "$LD_FOR_TARGET"; then
9617   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9618 else
9619 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9620 for as_dir in $PATH
9621 do
9622   IFS=$as_save_IFS
9623   test -z "$as_dir" && as_dir=.
9624   for ac_exec_ext in '' $ac_executable_extensions; do
9625   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9626     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9627     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9628     break 2
9629   fi
9630 done
9631 done
9632
9633 fi
9634 fi
9635 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9636 if test -n "$LD_FOR_TARGET"; then
9637   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9638 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9639 else
9640   echo "$as_me:$LINENO: result: no" >&5
9641 echo "${ECHO_T}no" >&6
9642 fi
9643
9644     fi
9645     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9646   done
9647 fi
9648
9649 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9650   set dummy ld
9651   if test $build = $target ; then
9652     LD_FOR_TARGET="$2"
9653   else
9654     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9655   fi
9656 else
9657   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9658 fi
9659
9660 else
9661   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9662 fi
9663
9664
9665
9666
9667 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9668   if test -n "$with_build_time_tools"; then
9669     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9670 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9671     if test -x $with_build_time_tools/lipo; then
9672       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9673       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9674       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9675 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9676     else
9677       echo "$as_me:$LINENO: result: no" >&5
9678 echo "${ECHO_T}no" >&6
9679     fi
9680   elif test $build != $host && test $have_gcc_for_target = yes; then
9681     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9682     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9683     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9684   fi
9685 fi
9686 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9687   # Extract the first word of "lipo", so it can be a program name with args.
9688 set dummy lipo; ac_word=$2
9689 echo "$as_me:$LINENO: checking for $ac_word" >&5
9690 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9691 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9692   echo $ECHO_N "(cached) $ECHO_C" >&6
9693 else
9694   case $LIPO_FOR_TARGET in
9695   [\\/]* | ?:[\\/]*)
9696   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9697   ;;
9698   *)
9699   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9700 for as_dir in $gcc_cv_tool_dirs
9701 do
9702   IFS=$as_save_IFS
9703   test -z "$as_dir" && as_dir=.
9704   for ac_exec_ext in '' $ac_executable_extensions; do
9705   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9706     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9707     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9708     break 2
9709   fi
9710 done
9711 done
9712
9713   ;;
9714 esac
9715 fi
9716 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9717
9718 if test -n "$LIPO_FOR_TARGET"; then
9719   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9720 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9721 else
9722   echo "$as_me:$LINENO: result: no" >&5
9723 echo "${ECHO_T}no" >&6
9724 fi
9725
9726 fi
9727 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9728
9729
9730 if test -n "$LIPO_FOR_TARGET"; then
9731   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9732 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9733   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9734 fi
9735
9736 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9737   for ncn_progname in lipo; do
9738     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9739 set dummy ${ncn_progname}; ac_word=$2
9740 echo "$as_me:$LINENO: checking for $ac_word" >&5
9741 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9742 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9743   echo $ECHO_N "(cached) $ECHO_C" >&6
9744 else
9745   if test -n "$LIPO_FOR_TARGET"; then
9746   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9747 else
9748 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9749 for as_dir in $PATH
9750 do
9751   IFS=$as_save_IFS
9752   test -z "$as_dir" && as_dir=.
9753   for ac_exec_ext in '' $ac_executable_extensions; do
9754   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9755     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9756     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9757     break 2
9758   fi
9759 done
9760 done
9761
9762 fi
9763 fi
9764 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9765 if test -n "$LIPO_FOR_TARGET"; then
9766   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9767 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9768 else
9769   echo "$as_me:$LINENO: result: no" >&5
9770 echo "${ECHO_T}no" >&6
9771 fi
9772
9773   done
9774 fi
9775
9776 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9777   for ncn_progname in lipo; do
9778     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9779 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9780     if test -x $with_build_time_tools/${ncn_progname}; then
9781       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9782       echo "$as_me:$LINENO: result: yes" >&5
9783 echo "${ECHO_T}yes" >&6
9784       break
9785     else
9786       echo "$as_me:$LINENO: result: no" >&5
9787 echo "${ECHO_T}no" >&6
9788     fi
9789   done
9790 fi
9791
9792 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9793   for ncn_progname in lipo; do
9794     if test -n "$ncn_target_tool_prefix"; then
9795       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9796 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9797 echo "$as_me:$LINENO: checking for $ac_word" >&5
9798 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9799 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9800   echo $ECHO_N "(cached) $ECHO_C" >&6
9801 else
9802   if test -n "$LIPO_FOR_TARGET"; then
9803   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9804 else
9805 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9806 for as_dir in $PATH
9807 do
9808   IFS=$as_save_IFS
9809   test -z "$as_dir" && as_dir=.
9810   for ac_exec_ext in '' $ac_executable_extensions; do
9811   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9812     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9813     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9814     break 2
9815   fi
9816 done
9817 done
9818
9819 fi
9820 fi
9821 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9822 if test -n "$LIPO_FOR_TARGET"; then
9823   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9824 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9825 else
9826   echo "$as_me:$LINENO: result: no" >&5
9827 echo "${ECHO_T}no" >&6
9828 fi
9829
9830     fi
9831     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9832       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9833 set dummy ${ncn_progname}; ac_word=$2
9834 echo "$as_me:$LINENO: checking for $ac_word" >&5
9835 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9836 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9837   echo $ECHO_N "(cached) $ECHO_C" >&6
9838 else
9839   if test -n "$LIPO_FOR_TARGET"; then
9840   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9841 else
9842 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9843 for as_dir in $PATH
9844 do
9845   IFS=$as_save_IFS
9846   test -z "$as_dir" && as_dir=.
9847   for ac_exec_ext in '' $ac_executable_extensions; do
9848   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9849     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9850     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9851     break 2
9852   fi
9853 done
9854 done
9855
9856 fi
9857 fi
9858 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9859 if test -n "$LIPO_FOR_TARGET"; then
9860   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9861 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9862 else
9863   echo "$as_me:$LINENO: result: no" >&5
9864 echo "${ECHO_T}no" >&6
9865 fi
9866
9867     fi
9868     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9869   done
9870 fi
9871
9872 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9873   set dummy lipo
9874   if test $build = $target ; then
9875     LIPO_FOR_TARGET="$2"
9876   else
9877     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9878   fi
9879 else
9880   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9881 fi
9882
9883 else
9884   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9885 fi
9886
9887
9888
9889
9890 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9891   if test -n "$with_build_time_tools"; then
9892     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9893 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9894     if test -x $with_build_time_tools/nm; then
9895       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9896       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9897       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9898 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9899     else
9900       echo "$as_me:$LINENO: result: no" >&5
9901 echo "${ECHO_T}no" >&6
9902     fi
9903   elif test $build != $host && test $have_gcc_for_target = yes; then
9904     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9905     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
9906     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9907   fi
9908 fi
9909 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9910   # Extract the first word of "nm", so it can be a program name with args.
9911 set dummy nm; ac_word=$2
9912 echo "$as_me:$LINENO: checking for $ac_word" >&5
9913 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9914 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9915   echo $ECHO_N "(cached) $ECHO_C" >&6
9916 else
9917   case $NM_FOR_TARGET in
9918   [\\/]* | ?:[\\/]*)
9919   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9920   ;;
9921   *)
9922   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9923 for as_dir in $gcc_cv_tool_dirs
9924 do
9925   IFS=$as_save_IFS
9926   test -z "$as_dir" && as_dir=.
9927   for ac_exec_ext in '' $ac_executable_extensions; do
9928   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9929     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9930     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9931     break 2
9932   fi
9933 done
9934 done
9935
9936   ;;
9937 esac
9938 fi
9939 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9940
9941 if test -n "$NM_FOR_TARGET"; then
9942   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9943 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9944 else
9945   echo "$as_me:$LINENO: result: no" >&5
9946 echo "${ECHO_T}no" >&6
9947 fi
9948
9949 fi
9950 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9951
9952
9953 if test -n "$NM_FOR_TARGET"; then
9954   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
9955 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9956   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9957 fi
9958
9959 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9960   for ncn_progname in nm; do
9961     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9962 set dummy ${ncn_progname}; ac_word=$2
9963 echo "$as_me:$LINENO: checking for $ac_word" >&5
9964 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9965 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9966   echo $ECHO_N "(cached) $ECHO_C" >&6
9967 else
9968   if test -n "$NM_FOR_TARGET"; then
9969   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9970 else
9971 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9972 for as_dir in $PATH
9973 do
9974   IFS=$as_save_IFS
9975   test -z "$as_dir" && as_dir=.
9976   for ac_exec_ext in '' $ac_executable_extensions; do
9977   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9978     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9979     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9980     break 2
9981   fi
9982 done
9983 done
9984
9985 fi
9986 fi
9987 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9988 if test -n "$NM_FOR_TARGET"; then
9989   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9990 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9991 else
9992   echo "$as_me:$LINENO: result: no" >&5
9993 echo "${ECHO_T}no" >&6
9994 fi
9995
9996   done
9997 fi
9998
9999 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10000   for ncn_progname in nm; do
10001     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10002 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10003     if test -x $with_build_time_tools/${ncn_progname}; then
10004       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10005       echo "$as_me:$LINENO: result: yes" >&5
10006 echo "${ECHO_T}yes" >&6
10007       break
10008     else
10009       echo "$as_me:$LINENO: result: no" >&5
10010 echo "${ECHO_T}no" >&6
10011     fi
10012   done
10013 fi
10014
10015 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10016   for ncn_progname in nm; do
10017     if test -n "$ncn_target_tool_prefix"; then
10018       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10019 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10020 echo "$as_me:$LINENO: checking for $ac_word" >&5
10021 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10022 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10023   echo $ECHO_N "(cached) $ECHO_C" >&6
10024 else
10025   if test -n "$NM_FOR_TARGET"; then
10026   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10027 else
10028 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10029 for as_dir in $PATH
10030 do
10031   IFS=$as_save_IFS
10032   test -z "$as_dir" && as_dir=.
10033   for ac_exec_ext in '' $ac_executable_extensions; do
10034   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10035     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10036     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10037     break 2
10038   fi
10039 done
10040 done
10041
10042 fi
10043 fi
10044 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10045 if test -n "$NM_FOR_TARGET"; then
10046   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10047 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10048 else
10049   echo "$as_me:$LINENO: result: no" >&5
10050 echo "${ECHO_T}no" >&6
10051 fi
10052
10053     fi
10054     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10055       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10056 set dummy ${ncn_progname}; ac_word=$2
10057 echo "$as_me:$LINENO: checking for $ac_word" >&5
10058 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10059 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10060   echo $ECHO_N "(cached) $ECHO_C" >&6
10061 else
10062   if test -n "$NM_FOR_TARGET"; then
10063   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10064 else
10065 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10066 for as_dir in $PATH
10067 do
10068   IFS=$as_save_IFS
10069   test -z "$as_dir" && as_dir=.
10070   for ac_exec_ext in '' $ac_executable_extensions; do
10071   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10072     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10073     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10074     break 2
10075   fi
10076 done
10077 done
10078
10079 fi
10080 fi
10081 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10082 if test -n "$NM_FOR_TARGET"; then
10083   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10084 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10085 else
10086   echo "$as_me:$LINENO: result: no" >&5
10087 echo "${ECHO_T}no" >&6
10088 fi
10089
10090     fi
10091     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10092   done
10093 fi
10094
10095 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10096   set dummy nm
10097   if test $build = $target ; then
10098     NM_FOR_TARGET="$2"
10099   else
10100     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10101   fi
10102 else
10103   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10104 fi
10105
10106 else
10107   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10108 fi
10109
10110
10111
10112
10113 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10114   if test -n "$with_build_time_tools"; then
10115     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10116 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10117     if test -x $with_build_time_tools/objdump; then
10118       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10119       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10120       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10121 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10122     else
10123       echo "$as_me:$LINENO: result: no" >&5
10124 echo "${ECHO_T}no" >&6
10125     fi
10126   elif test $build != $host && test $have_gcc_for_target = yes; then
10127     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10128     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10129     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10130   fi
10131 fi
10132 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10133   # Extract the first word of "objdump", so it can be a program name with args.
10134 set dummy objdump; ac_word=$2
10135 echo "$as_me:$LINENO: checking for $ac_word" >&5
10136 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10137 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10138   echo $ECHO_N "(cached) $ECHO_C" >&6
10139 else
10140   case $OBJDUMP_FOR_TARGET in
10141   [\\/]* | ?:[\\/]*)
10142   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10143   ;;
10144   *)
10145   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10146 for as_dir in $gcc_cv_tool_dirs
10147 do
10148   IFS=$as_save_IFS
10149   test -z "$as_dir" && as_dir=.
10150   for ac_exec_ext in '' $ac_executable_extensions; do
10151   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10152     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10153     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10154     break 2
10155   fi
10156 done
10157 done
10158
10159   ;;
10160 esac
10161 fi
10162 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10163
10164 if test -n "$OBJDUMP_FOR_TARGET"; then
10165   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10166 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10167 else
10168   echo "$as_me:$LINENO: result: no" >&5
10169 echo "${ECHO_T}no" >&6
10170 fi
10171
10172 fi
10173 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10174
10175
10176 if test -n "$OBJDUMP_FOR_TARGET"; then
10177   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10178 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10179   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10180 fi
10181
10182 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10183   for ncn_progname in objdump; do
10184     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10185 set dummy ${ncn_progname}; ac_word=$2
10186 echo "$as_me:$LINENO: checking for $ac_word" >&5
10187 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10188 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10189   echo $ECHO_N "(cached) $ECHO_C" >&6
10190 else
10191   if test -n "$OBJDUMP_FOR_TARGET"; then
10192   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10193 else
10194 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10195 for as_dir in $PATH
10196 do
10197   IFS=$as_save_IFS
10198   test -z "$as_dir" && as_dir=.
10199   for ac_exec_ext in '' $ac_executable_extensions; do
10200   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10201     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10202     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10203     break 2
10204   fi
10205 done
10206 done
10207
10208 fi
10209 fi
10210 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10211 if test -n "$OBJDUMP_FOR_TARGET"; then
10212   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10213 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10214 else
10215   echo "$as_me:$LINENO: result: no" >&5
10216 echo "${ECHO_T}no" >&6
10217 fi
10218
10219   done
10220 fi
10221
10222 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10223   for ncn_progname in objdump; do
10224     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10225 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10226     if test -x $with_build_time_tools/${ncn_progname}; then
10227       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10228       echo "$as_me:$LINENO: result: yes" >&5
10229 echo "${ECHO_T}yes" >&6
10230       break
10231     else
10232       echo "$as_me:$LINENO: result: no" >&5
10233 echo "${ECHO_T}no" >&6
10234     fi
10235   done
10236 fi
10237
10238 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10239   for ncn_progname in objdump; do
10240     if test -n "$ncn_target_tool_prefix"; then
10241       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10242 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10243 echo "$as_me:$LINENO: checking for $ac_word" >&5
10244 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10245 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10246   echo $ECHO_N "(cached) $ECHO_C" >&6
10247 else
10248   if test -n "$OBJDUMP_FOR_TARGET"; then
10249   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10250 else
10251 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10252 for as_dir in $PATH
10253 do
10254   IFS=$as_save_IFS
10255   test -z "$as_dir" && as_dir=.
10256   for ac_exec_ext in '' $ac_executable_extensions; do
10257   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10258     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10259     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10260     break 2
10261   fi
10262 done
10263 done
10264
10265 fi
10266 fi
10267 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10268 if test -n "$OBJDUMP_FOR_TARGET"; then
10269   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10270 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10271 else
10272   echo "$as_me:$LINENO: result: no" >&5
10273 echo "${ECHO_T}no" >&6
10274 fi
10275
10276     fi
10277     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10278       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10279 set dummy ${ncn_progname}; ac_word=$2
10280 echo "$as_me:$LINENO: checking for $ac_word" >&5
10281 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10282 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10283   echo $ECHO_N "(cached) $ECHO_C" >&6
10284 else
10285   if test -n "$OBJDUMP_FOR_TARGET"; then
10286   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10287 else
10288 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10289 for as_dir in $PATH
10290 do
10291   IFS=$as_save_IFS
10292   test -z "$as_dir" && as_dir=.
10293   for ac_exec_ext in '' $ac_executable_extensions; do
10294   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10295     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10296     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10297     break 2
10298   fi
10299 done
10300 done
10301
10302 fi
10303 fi
10304 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10305 if test -n "$OBJDUMP_FOR_TARGET"; then
10306   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10307 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10308 else
10309   echo "$as_me:$LINENO: result: no" >&5
10310 echo "${ECHO_T}no" >&6
10311 fi
10312
10313     fi
10314     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10315   done
10316 fi
10317
10318 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10319   set dummy objdump
10320   if test $build = $target ; then
10321     OBJDUMP_FOR_TARGET="$2"
10322   else
10323     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10324   fi
10325 else
10326   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10327 fi
10328
10329 else
10330   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10331 fi
10332
10333
10334
10335
10336 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10337   if test -n "$with_build_time_tools"; then
10338     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10339 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10340     if test -x $with_build_time_tools/ranlib; then
10341       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10342       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10343       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10344 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10345     else
10346       echo "$as_me:$LINENO: result: no" >&5
10347 echo "${ECHO_T}no" >&6
10348     fi
10349   elif test $build != $host && test $have_gcc_for_target = yes; then
10350     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10351     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10352     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10353   fi
10354 fi
10355 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10356   # Extract the first word of "ranlib", so it can be a program name with args.
10357 set dummy ranlib; ac_word=$2
10358 echo "$as_me:$LINENO: checking for $ac_word" >&5
10359 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10360 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10361   echo $ECHO_N "(cached) $ECHO_C" >&6
10362 else
10363   case $RANLIB_FOR_TARGET in
10364   [\\/]* | ?:[\\/]*)
10365   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10366   ;;
10367   *)
10368   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10369 for as_dir in $gcc_cv_tool_dirs
10370 do
10371   IFS=$as_save_IFS
10372   test -z "$as_dir" && as_dir=.
10373   for ac_exec_ext in '' $ac_executable_extensions; do
10374   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10375     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10376     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10377     break 2
10378   fi
10379 done
10380 done
10381
10382   ;;
10383 esac
10384 fi
10385 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10386
10387 if test -n "$RANLIB_FOR_TARGET"; then
10388   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10389 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10390 else
10391   echo "$as_me:$LINENO: result: no" >&5
10392 echo "${ECHO_T}no" >&6
10393 fi
10394
10395 fi
10396 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10397
10398
10399 if test -n "$RANLIB_FOR_TARGET"; then
10400   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10401 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10402   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10403 fi
10404
10405 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10406   for ncn_progname in ranlib; do
10407     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10408 set dummy ${ncn_progname}; ac_word=$2
10409 echo "$as_me:$LINENO: checking for $ac_word" >&5
10410 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10411 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10412   echo $ECHO_N "(cached) $ECHO_C" >&6
10413 else
10414   if test -n "$RANLIB_FOR_TARGET"; then
10415   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10416 else
10417 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10418 for as_dir in $PATH
10419 do
10420   IFS=$as_save_IFS
10421   test -z "$as_dir" && as_dir=.
10422   for ac_exec_ext in '' $ac_executable_extensions; do
10423   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10424     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10425     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10426     break 2
10427   fi
10428 done
10429 done
10430
10431 fi
10432 fi
10433 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10434 if test -n "$RANLIB_FOR_TARGET"; then
10435   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10436 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10437 else
10438   echo "$as_me:$LINENO: result: no" >&5
10439 echo "${ECHO_T}no" >&6
10440 fi
10441
10442   done
10443 fi
10444
10445 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10446   for ncn_progname in ranlib; do
10447     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10448 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10449     if test -x $with_build_time_tools/${ncn_progname}; then
10450       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10451       echo "$as_me:$LINENO: result: yes" >&5
10452 echo "${ECHO_T}yes" >&6
10453       break
10454     else
10455       echo "$as_me:$LINENO: result: no" >&5
10456 echo "${ECHO_T}no" >&6
10457     fi
10458   done
10459 fi
10460
10461 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10462   for ncn_progname in ranlib; do
10463     if test -n "$ncn_target_tool_prefix"; then
10464       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10465 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10466 echo "$as_me:$LINENO: checking for $ac_word" >&5
10467 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10468 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10469   echo $ECHO_N "(cached) $ECHO_C" >&6
10470 else
10471   if test -n "$RANLIB_FOR_TARGET"; then
10472   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10473 else
10474 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10475 for as_dir in $PATH
10476 do
10477   IFS=$as_save_IFS
10478   test -z "$as_dir" && as_dir=.
10479   for ac_exec_ext in '' $ac_executable_extensions; do
10480   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10481     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10482     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10483     break 2
10484   fi
10485 done
10486 done
10487
10488 fi
10489 fi
10490 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10491 if test -n "$RANLIB_FOR_TARGET"; then
10492   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10493 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10494 else
10495   echo "$as_me:$LINENO: result: no" >&5
10496 echo "${ECHO_T}no" >&6
10497 fi
10498
10499     fi
10500     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10501       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10502 set dummy ${ncn_progname}; ac_word=$2
10503 echo "$as_me:$LINENO: checking for $ac_word" >&5
10504 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10505 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10506   echo $ECHO_N "(cached) $ECHO_C" >&6
10507 else
10508   if test -n "$RANLIB_FOR_TARGET"; then
10509   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10510 else
10511 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10512 for as_dir in $PATH
10513 do
10514   IFS=$as_save_IFS
10515   test -z "$as_dir" && as_dir=.
10516   for ac_exec_ext in '' $ac_executable_extensions; do
10517   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10518     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10519     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10520     break 2
10521   fi
10522 done
10523 done
10524
10525 fi
10526 fi
10527 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10528 if test -n "$RANLIB_FOR_TARGET"; then
10529   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10530 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10531 else
10532   echo "$as_me:$LINENO: result: no" >&5
10533 echo "${ECHO_T}no" >&6
10534 fi
10535
10536     fi
10537     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10538   done
10539 fi
10540
10541 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10542   set dummy ranlib
10543   if test $build = $target ; then
10544     RANLIB_FOR_TARGET="$2"
10545   else
10546     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10547   fi
10548 else
10549   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10550 fi
10551
10552 else
10553   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10554 fi
10555
10556
10557
10558
10559 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10560   if test -n "$with_build_time_tools"; then
10561     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10562 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10563     if test -x $with_build_time_tools/strip; then
10564       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10565       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10566       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10567 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10568     else
10569       echo "$as_me:$LINENO: result: no" >&5
10570 echo "${ECHO_T}no" >&6
10571     fi
10572   elif test $build != $host && test $have_gcc_for_target = yes; then
10573     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10574     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10575     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10576   fi
10577 fi
10578 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10579   # Extract the first word of "strip", so it can be a program name with args.
10580 set dummy strip; ac_word=$2
10581 echo "$as_me:$LINENO: checking for $ac_word" >&5
10582 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10583 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10584   echo $ECHO_N "(cached) $ECHO_C" >&6
10585 else
10586   case $STRIP_FOR_TARGET in
10587   [\\/]* | ?:[\\/]*)
10588   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10589   ;;
10590   *)
10591   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10592 for as_dir in $gcc_cv_tool_dirs
10593 do
10594   IFS=$as_save_IFS
10595   test -z "$as_dir" && as_dir=.
10596   for ac_exec_ext in '' $ac_executable_extensions; do
10597   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10598     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10599     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10600     break 2
10601   fi
10602 done
10603 done
10604
10605   ;;
10606 esac
10607 fi
10608 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10609
10610 if test -n "$STRIP_FOR_TARGET"; then
10611   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10612 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10613 else
10614   echo "$as_me:$LINENO: result: no" >&5
10615 echo "${ECHO_T}no" >&6
10616 fi
10617
10618 fi
10619 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10620
10621
10622 if test -n "$STRIP_FOR_TARGET"; then
10623   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10624 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10625   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10626 fi
10627
10628 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10629   for ncn_progname in strip; do
10630     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10631 set dummy ${ncn_progname}; ac_word=$2
10632 echo "$as_me:$LINENO: checking for $ac_word" >&5
10633 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10634 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10635   echo $ECHO_N "(cached) $ECHO_C" >&6
10636 else
10637   if test -n "$STRIP_FOR_TARGET"; then
10638   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10639 else
10640 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10641 for as_dir in $PATH
10642 do
10643   IFS=$as_save_IFS
10644   test -z "$as_dir" && as_dir=.
10645   for ac_exec_ext in '' $ac_executable_extensions; do
10646   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10647     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10648     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10649     break 2
10650   fi
10651 done
10652 done
10653
10654 fi
10655 fi
10656 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10657 if test -n "$STRIP_FOR_TARGET"; then
10658   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10659 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10660 else
10661   echo "$as_me:$LINENO: result: no" >&5
10662 echo "${ECHO_T}no" >&6
10663 fi
10664
10665   done
10666 fi
10667
10668 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10669   for ncn_progname in strip; do
10670     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10671 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10672     if test -x $with_build_time_tools/${ncn_progname}; then
10673       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10674       echo "$as_me:$LINENO: result: yes" >&5
10675 echo "${ECHO_T}yes" >&6
10676       break
10677     else
10678       echo "$as_me:$LINENO: result: no" >&5
10679 echo "${ECHO_T}no" >&6
10680     fi
10681   done
10682 fi
10683
10684 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10685   for ncn_progname in strip; do
10686     if test -n "$ncn_target_tool_prefix"; then
10687       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10688 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10689 echo "$as_me:$LINENO: checking for $ac_word" >&5
10690 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10691 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10692   echo $ECHO_N "(cached) $ECHO_C" >&6
10693 else
10694   if test -n "$STRIP_FOR_TARGET"; then
10695   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10696 else
10697 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10698 for as_dir in $PATH
10699 do
10700   IFS=$as_save_IFS
10701   test -z "$as_dir" && as_dir=.
10702   for ac_exec_ext in '' $ac_executable_extensions; do
10703   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10704     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10705     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10706     break 2
10707   fi
10708 done
10709 done
10710
10711 fi
10712 fi
10713 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10714 if test -n "$STRIP_FOR_TARGET"; then
10715   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10716 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10717 else
10718   echo "$as_me:$LINENO: result: no" >&5
10719 echo "${ECHO_T}no" >&6
10720 fi
10721
10722     fi
10723     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10724       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10725 set dummy ${ncn_progname}; ac_word=$2
10726 echo "$as_me:$LINENO: checking for $ac_word" >&5
10727 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10728 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10729   echo $ECHO_N "(cached) $ECHO_C" >&6
10730 else
10731   if test -n "$STRIP_FOR_TARGET"; then
10732   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10733 else
10734 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10735 for as_dir in $PATH
10736 do
10737   IFS=$as_save_IFS
10738   test -z "$as_dir" && as_dir=.
10739   for ac_exec_ext in '' $ac_executable_extensions; do
10740   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10741     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10742     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10743     break 2
10744   fi
10745 done
10746 done
10747
10748 fi
10749 fi
10750 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10751 if test -n "$STRIP_FOR_TARGET"; then
10752   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10753 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10754 else
10755   echo "$as_me:$LINENO: result: no" >&5
10756 echo "${ECHO_T}no" >&6
10757 fi
10758
10759     fi
10760     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10761   done
10762 fi
10763
10764 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10765   set dummy strip
10766   if test $build = $target ; then
10767     STRIP_FOR_TARGET="$2"
10768   else
10769     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10770   fi
10771 else
10772   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10773 fi
10774
10775 else
10776   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10777 fi
10778
10779
10780
10781
10782 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10783   if test -n "$with_build_time_tools"; then
10784     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10785 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10786     if test -x $with_build_time_tools/windres; then
10787       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10788       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10789       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10790 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10791     else
10792       echo "$as_me:$LINENO: result: no" >&5
10793 echo "${ECHO_T}no" >&6
10794     fi
10795   elif test $build != $host && test $have_gcc_for_target = yes; then
10796     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10797     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10798     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10799   fi
10800 fi
10801 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10802   # Extract the first word of "windres", so it can be a program name with args.
10803 set dummy windres; ac_word=$2
10804 echo "$as_me:$LINENO: checking for $ac_word" >&5
10805 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10806 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10807   echo $ECHO_N "(cached) $ECHO_C" >&6
10808 else
10809   case $WINDRES_FOR_TARGET in
10810   [\\/]* | ?:[\\/]*)
10811   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10812   ;;
10813   *)
10814   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10815 for as_dir in $gcc_cv_tool_dirs
10816 do
10817   IFS=$as_save_IFS
10818   test -z "$as_dir" && as_dir=.
10819   for ac_exec_ext in '' $ac_executable_extensions; do
10820   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10821     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10822     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10823     break 2
10824   fi
10825 done
10826 done
10827
10828   ;;
10829 esac
10830 fi
10831 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10832
10833 if test -n "$WINDRES_FOR_TARGET"; then
10834   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10835 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10836 else
10837   echo "$as_me:$LINENO: result: no" >&5
10838 echo "${ECHO_T}no" >&6
10839 fi
10840
10841 fi
10842 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10843
10844
10845 if test -n "$WINDRES_FOR_TARGET"; then
10846   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10847 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10848   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10849 fi
10850
10851 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10852   for ncn_progname in windres; do
10853     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10854 set dummy ${ncn_progname}; ac_word=$2
10855 echo "$as_me:$LINENO: checking for $ac_word" >&5
10856 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10857 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10858   echo $ECHO_N "(cached) $ECHO_C" >&6
10859 else
10860   if test -n "$WINDRES_FOR_TARGET"; then
10861   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10862 else
10863 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10864 for as_dir in $PATH
10865 do
10866   IFS=$as_save_IFS
10867   test -z "$as_dir" && as_dir=.
10868   for ac_exec_ext in '' $ac_executable_extensions; do
10869   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10870     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10871     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10872     break 2
10873   fi
10874 done
10875 done
10876
10877 fi
10878 fi
10879 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10880 if test -n "$WINDRES_FOR_TARGET"; then
10881   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10882 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10883 else
10884   echo "$as_me:$LINENO: result: no" >&5
10885 echo "${ECHO_T}no" >&6
10886 fi
10887
10888   done
10889 fi
10890
10891 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10892   for ncn_progname in windres; do
10893     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10894 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10895     if test -x $with_build_time_tools/${ncn_progname}; then
10896       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10897       echo "$as_me:$LINENO: result: yes" >&5
10898 echo "${ECHO_T}yes" >&6
10899       break
10900     else
10901       echo "$as_me:$LINENO: result: no" >&5
10902 echo "${ECHO_T}no" >&6
10903     fi
10904   done
10905 fi
10906
10907 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10908   for ncn_progname in windres; do
10909     if test -n "$ncn_target_tool_prefix"; then
10910       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10911 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10912 echo "$as_me:$LINENO: checking for $ac_word" >&5
10913 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10914 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10915   echo $ECHO_N "(cached) $ECHO_C" >&6
10916 else
10917   if test -n "$WINDRES_FOR_TARGET"; then
10918   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10919 else
10920 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10921 for as_dir in $PATH
10922 do
10923   IFS=$as_save_IFS
10924   test -z "$as_dir" && as_dir=.
10925   for ac_exec_ext in '' $ac_executable_extensions; do
10926   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10927     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10928     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10929     break 2
10930   fi
10931 done
10932 done
10933
10934 fi
10935 fi
10936 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10937 if test -n "$WINDRES_FOR_TARGET"; then
10938   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10939 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10940 else
10941   echo "$as_me:$LINENO: result: no" >&5
10942 echo "${ECHO_T}no" >&6
10943 fi
10944
10945     fi
10946     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
10947       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10948 set dummy ${ncn_progname}; ac_word=$2
10949 echo "$as_me:$LINENO: checking for $ac_word" >&5
10950 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10951 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10952   echo $ECHO_N "(cached) $ECHO_C" >&6
10953 else
10954   if test -n "$WINDRES_FOR_TARGET"; then
10955   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10956 else
10957 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10958 for as_dir in $PATH
10959 do
10960   IFS=$as_save_IFS
10961   test -z "$as_dir" && as_dir=.
10962   for ac_exec_ext in '' $ac_executable_extensions; do
10963   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10964     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10965     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10966     break 2
10967   fi
10968 done
10969 done
10970
10971 fi
10972 fi
10973 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10974 if test -n "$WINDRES_FOR_TARGET"; then
10975   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10976 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10977 else
10978   echo "$as_me:$LINENO: result: no" >&5
10979 echo "${ECHO_T}no" >&6
10980 fi
10981
10982     fi
10983     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
10984   done
10985 fi
10986
10987 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
10988   set dummy windres
10989   if test $build = $target ; then
10990     WINDRES_FOR_TARGET="$2"
10991   else
10992     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
10993   fi
10994 else
10995   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
10996 fi
10997
10998 else
10999   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11000 fi
11001
11002
11003
11004
11005 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11006   if test -n "$with_build_time_tools"; then
11007     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11008 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11009     if test -x $with_build_time_tools/windmc; then
11010       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11011       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11012       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11013 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11014     else
11015       echo "$as_me:$LINENO: result: no" >&5
11016 echo "${ECHO_T}no" >&6
11017     fi
11018   elif test $build != $host && test $have_gcc_for_target = yes; then
11019     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11020     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11021     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11022   fi
11023 fi
11024 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11025   # Extract the first word of "windmc", so it can be a program name with args.
11026 set dummy windmc; ac_word=$2
11027 echo "$as_me:$LINENO: checking for $ac_word" >&5
11028 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11029 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11030   echo $ECHO_N "(cached) $ECHO_C" >&6
11031 else
11032   case $WINDMC_FOR_TARGET in
11033   [\\/]* | ?:[\\/]*)
11034   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11035   ;;
11036   *)
11037   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11038 for as_dir in $gcc_cv_tool_dirs
11039 do
11040   IFS=$as_save_IFS
11041   test -z "$as_dir" && as_dir=.
11042   for ac_exec_ext in '' $ac_executable_extensions; do
11043   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11044     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11045     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11046     break 2
11047   fi
11048 done
11049 done
11050
11051   ;;
11052 esac
11053 fi
11054 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11055
11056 if test -n "$WINDMC_FOR_TARGET"; then
11057   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11058 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11059 else
11060   echo "$as_me:$LINENO: result: no" >&5
11061 echo "${ECHO_T}no" >&6
11062 fi
11063
11064 fi
11065 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11066
11067
11068 if test -n "$WINDMC_FOR_TARGET"; then
11069   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11070 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11071   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11072 fi
11073
11074 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11075   for ncn_progname in windmc; do
11076     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11077 set dummy ${ncn_progname}; ac_word=$2
11078 echo "$as_me:$LINENO: checking for $ac_word" >&5
11079 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11080 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11081   echo $ECHO_N "(cached) $ECHO_C" >&6
11082 else
11083   if test -n "$WINDMC_FOR_TARGET"; then
11084   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11085 else
11086 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11087 for as_dir in $PATH
11088 do
11089   IFS=$as_save_IFS
11090   test -z "$as_dir" && as_dir=.
11091   for ac_exec_ext in '' $ac_executable_extensions; do
11092   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11093     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11094     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11095     break 2
11096   fi
11097 done
11098 done
11099
11100 fi
11101 fi
11102 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11103 if test -n "$WINDMC_FOR_TARGET"; then
11104   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11105 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11106 else
11107   echo "$as_me:$LINENO: result: no" >&5
11108 echo "${ECHO_T}no" >&6
11109 fi
11110
11111   done
11112 fi
11113
11114 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11115   for ncn_progname in windmc; do
11116     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11117 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11118     if test -x $with_build_time_tools/${ncn_progname}; then
11119       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11120       echo "$as_me:$LINENO: result: yes" >&5
11121 echo "${ECHO_T}yes" >&6
11122       break
11123     else
11124       echo "$as_me:$LINENO: result: no" >&5
11125 echo "${ECHO_T}no" >&6
11126     fi
11127   done
11128 fi
11129
11130 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11131   for ncn_progname in windmc; do
11132     if test -n "$ncn_target_tool_prefix"; then
11133       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11134 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11135 echo "$as_me:$LINENO: checking for $ac_word" >&5
11136 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11137 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11138   echo $ECHO_N "(cached) $ECHO_C" >&6
11139 else
11140   if test -n "$WINDMC_FOR_TARGET"; then
11141   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11142 else
11143 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11144 for as_dir in $PATH
11145 do
11146   IFS=$as_save_IFS
11147   test -z "$as_dir" && as_dir=.
11148   for ac_exec_ext in '' $ac_executable_extensions; do
11149   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11150     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11151     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11152     break 2
11153   fi
11154 done
11155 done
11156
11157 fi
11158 fi
11159 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11160 if test -n "$WINDMC_FOR_TARGET"; then
11161   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11162 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11163 else
11164   echo "$as_me:$LINENO: result: no" >&5
11165 echo "${ECHO_T}no" >&6
11166 fi
11167
11168     fi
11169     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11170       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11171 set dummy ${ncn_progname}; ac_word=$2
11172 echo "$as_me:$LINENO: checking for $ac_word" >&5
11173 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11174 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11175   echo $ECHO_N "(cached) $ECHO_C" >&6
11176 else
11177   if test -n "$WINDMC_FOR_TARGET"; then
11178   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11179 else
11180 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11181 for as_dir in $PATH
11182 do
11183   IFS=$as_save_IFS
11184   test -z "$as_dir" && as_dir=.
11185   for ac_exec_ext in '' $ac_executable_extensions; do
11186   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11187     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11188     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11189     break 2
11190   fi
11191 done
11192 done
11193
11194 fi
11195 fi
11196 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11197 if test -n "$WINDMC_FOR_TARGET"; then
11198   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11199 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11200 else
11201   echo "$as_me:$LINENO: result: no" >&5
11202 echo "${ECHO_T}no" >&6
11203 fi
11204
11205     fi
11206     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11207   done
11208 fi
11209
11210 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11211   set dummy windmc
11212   if test $build = $target ; then
11213     WINDMC_FOR_TARGET="$2"
11214   else
11215     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11216   fi
11217 else
11218   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11219 fi
11220
11221 else
11222   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11223 fi
11224
11225
11226 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11227
11228 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11229 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11230 if test "x${build}" != "x${host}" ; then
11231   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11232     # We already found the complete path
11233     ac_dir=`dirname $AR_FOR_TARGET`
11234     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11235 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11236   else
11237     # Canadian cross, just use what we found
11238     echo "$as_me:$LINENO: result: pre-installed" >&5
11239 echo "${ECHO_T}pre-installed" >&6
11240   fi
11241 else
11242   ok=yes
11243   case " ${configdirs} " in
11244     *" binutils "*) ;;
11245     *) ok=no ;;
11246   esac
11247
11248   if test $ok = yes; then
11249     # An in-tree tool is available and we can use it
11250     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11251     echo "$as_me:$LINENO: result: just compiled" >&5
11252 echo "${ECHO_T}just compiled" >&6
11253   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11254     # We already found the complete path
11255     ac_dir=`dirname $AR_FOR_TARGET`
11256     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11257 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11258   elif test "x$target" = "x$host"; then
11259     # We can use an host tool
11260     AR_FOR_TARGET='$(AR)'
11261     echo "$as_me:$LINENO: result: host tool" >&5
11262 echo "${ECHO_T}host tool" >&6
11263   else
11264     # We need a cross tool
11265     echo "$as_me:$LINENO: result: pre-installed" >&5
11266 echo "${ECHO_T}pre-installed" >&6
11267   fi
11268 fi
11269
11270 echo "$as_me:$LINENO: checking where to find the target as" >&5
11271 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11272 if test "x${build}" != "x${host}" ; then
11273   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11274     # We already found the complete path
11275     ac_dir=`dirname $AS_FOR_TARGET`
11276     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11277 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11278   else
11279     # Canadian cross, just use what we found
11280     echo "$as_me:$LINENO: result: pre-installed" >&5
11281 echo "${ECHO_T}pre-installed" >&6
11282   fi
11283 else
11284   ok=yes
11285   case " ${configdirs} " in
11286     *" gas "*) ;;
11287     *) ok=no ;;
11288   esac
11289
11290   if test $ok = yes; then
11291     # An in-tree tool is available and we can use it
11292     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11293     echo "$as_me:$LINENO: result: just compiled" >&5
11294 echo "${ECHO_T}just compiled" >&6
11295   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11296     # We already found the complete path
11297     ac_dir=`dirname $AS_FOR_TARGET`
11298     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11299 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11300   elif test "x$target" = "x$host"; then
11301     # We can use an host tool
11302     AS_FOR_TARGET='$(AS)'
11303     echo "$as_me:$LINENO: result: host tool" >&5
11304 echo "${ECHO_T}host tool" >&6
11305   else
11306     # We need a cross tool
11307     echo "$as_me:$LINENO: result: pre-installed" >&5
11308 echo "${ECHO_T}pre-installed" >&6
11309   fi
11310 fi
11311
11312 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11313 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11314 if test "x${build}" != "x${host}" ; then
11315   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11316     # We already found the complete path
11317     ac_dir=`dirname $CC_FOR_TARGET`
11318     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11319 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11320   else
11321     # Canadian cross, just use what we found
11322     echo "$as_me:$LINENO: result: pre-installed" >&5
11323 echo "${ECHO_T}pre-installed" >&6
11324   fi
11325 else
11326   ok=yes
11327   case " ${configdirs} " in
11328     *" gcc "*) ;;
11329     *) ok=no ;;
11330   esac
11331
11332   if test $ok = yes; then
11333     # An in-tree tool is available and we can use it
11334     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11335     echo "$as_me:$LINENO: result: just compiled" >&5
11336 echo "${ECHO_T}just compiled" >&6
11337   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11338     # We already found the complete path
11339     ac_dir=`dirname $CC_FOR_TARGET`
11340     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11341 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11342   elif test "x$target" = "x$host"; then
11343     # We can use an host tool
11344     CC_FOR_TARGET='$(CC)'
11345     echo "$as_me:$LINENO: result: host tool" >&5
11346 echo "${ECHO_T}host tool" >&6
11347   else
11348     # We need a cross tool
11349     echo "$as_me:$LINENO: result: pre-installed" >&5
11350 echo "${ECHO_T}pre-installed" >&6
11351   fi
11352 fi
11353
11354 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11355 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11356 if test "x${build}" != "x${host}" ; then
11357   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11358     # We already found the complete path
11359     ac_dir=`dirname $CXX_FOR_TARGET`
11360     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11361 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11362   else
11363     # Canadian cross, just use what we found
11364     echo "$as_me:$LINENO: result: pre-installed" >&5
11365 echo "${ECHO_T}pre-installed" >&6
11366   fi
11367 else
11368   ok=yes
11369   case " ${configdirs} " in
11370     *" gcc "*) ;;
11371     *) ok=no ;;
11372   esac
11373   case ,${enable_languages}, in
11374     *,c++,*) ;;
11375     *) ok=no ;;
11376   esac
11377   if test $ok = yes; then
11378     # An in-tree tool is available and we can use it
11379     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'
11380     echo "$as_me:$LINENO: result: just compiled" >&5
11381 echo "${ECHO_T}just compiled" >&6
11382   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11383     # We already found the complete path
11384     ac_dir=`dirname $CXX_FOR_TARGET`
11385     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11386 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11387   elif test "x$target" = "x$host"; then
11388     # We can use an host tool
11389     CXX_FOR_TARGET='$(CXX)'
11390     echo "$as_me:$LINENO: result: host tool" >&5
11391 echo "${ECHO_T}host tool" >&6
11392   else
11393     # We need a cross tool
11394     echo "$as_me:$LINENO: result: pre-installed" >&5
11395 echo "${ECHO_T}pre-installed" >&6
11396   fi
11397 fi
11398
11399 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11400 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11401 if test "x${build}" != "x${host}" ; then
11402   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11403     # We already found the complete path
11404     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11405     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11406 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11407   else
11408     # Canadian cross, just use what we found
11409     echo "$as_me:$LINENO: result: pre-installed" >&5
11410 echo "${ECHO_T}pre-installed" >&6
11411   fi
11412 else
11413   ok=yes
11414   case " ${configdirs} " in
11415     *" gcc "*) ;;
11416     *) ok=no ;;
11417   esac
11418   case ,${enable_languages}, in
11419     *,c++,*) ;;
11420     *) ok=no ;;
11421   esac
11422   if test $ok = yes; then
11423     # An in-tree tool is available and we can use it
11424     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'
11425     echo "$as_me:$LINENO: result: just compiled" >&5
11426 echo "${ECHO_T}just compiled" >&6
11427   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11428     # We already found the complete path
11429     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11430     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11431 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11432   elif test "x$target" = "x$host"; then
11433     # We can use an host tool
11434     RAW_CXX_FOR_TARGET='$(CXX)'
11435     echo "$as_me:$LINENO: result: host tool" >&5
11436 echo "${ECHO_T}host tool" >&6
11437   else
11438     # We need a cross tool
11439     echo "$as_me:$LINENO: result: pre-installed" >&5
11440 echo "${ECHO_T}pre-installed" >&6
11441   fi
11442 fi
11443
11444 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11445 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11446 if test "x${build}" != "x${host}" ; then
11447   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11448     # We already found the complete path
11449     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11450     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11451 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11452   else
11453     # Canadian cross, just use what we found
11454     echo "$as_me:$LINENO: result: pre-installed" >&5
11455 echo "${ECHO_T}pre-installed" >&6
11456   fi
11457 else
11458   ok=yes
11459   case " ${configdirs} " in
11460     *" binutils "*) ;;
11461     *) ok=no ;;
11462   esac
11463
11464   if test $ok = yes; then
11465     # An in-tree tool is available and we can use it
11466     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11467     echo "$as_me:$LINENO: result: just compiled" >&5
11468 echo "${ECHO_T}just compiled" >&6
11469   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11470     # We already found the complete path
11471     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11472     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11473 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11474   elif test "x$target" = "x$host"; then
11475     # We can use an host tool
11476     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11477     echo "$as_me:$LINENO: result: host tool" >&5
11478 echo "${ECHO_T}host tool" >&6
11479   else
11480     # We need a cross tool
11481     echo "$as_me:$LINENO: result: pre-installed" >&5
11482 echo "${ECHO_T}pre-installed" >&6
11483   fi
11484 fi
11485
11486 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11487 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11488 if test "x${build}" != "x${host}" ; then
11489   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11490     # We already found the complete path
11491     ac_dir=`dirname $GCC_FOR_TARGET`
11492     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11493 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11494   else
11495     # Canadian cross, just use what we found
11496     echo "$as_me:$LINENO: result: pre-installed" >&5
11497 echo "${ECHO_T}pre-installed" >&6
11498   fi
11499 else
11500   ok=yes
11501   case " ${configdirs} " in
11502     *" gcc "*) ;;
11503     *) ok=no ;;
11504   esac
11505
11506   if test $ok = yes; then
11507     # An in-tree tool is available and we can use it
11508     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11509     echo "$as_me:$LINENO: result: just compiled" >&5
11510 echo "${ECHO_T}just compiled" >&6
11511   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11512     # We already found the complete path
11513     ac_dir=`dirname $GCC_FOR_TARGET`
11514     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11515 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11516   elif test "x$target" = "x$host"; then
11517     # We can use an host tool
11518     GCC_FOR_TARGET='$()'
11519     echo "$as_me:$LINENO: result: host tool" >&5
11520 echo "${ECHO_T}host tool" >&6
11521   else
11522     # We need a cross tool
11523     echo "$as_me:$LINENO: result: pre-installed" >&5
11524 echo "${ECHO_T}pre-installed" >&6
11525   fi
11526 fi
11527
11528 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11529 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11530 if test "x${build}" != "x${host}" ; then
11531   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11532     # We already found the complete path
11533     ac_dir=`dirname $GCJ_FOR_TARGET`
11534     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11535 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11536   else
11537     # Canadian cross, just use what we found
11538     echo "$as_me:$LINENO: result: pre-installed" >&5
11539 echo "${ECHO_T}pre-installed" >&6
11540   fi
11541 else
11542   ok=yes
11543   case " ${configdirs} " in
11544     *" gcc "*) ;;
11545     *) ok=no ;;
11546   esac
11547   case ,${enable_languages}, in
11548     *,java,*) ;;
11549     *) ok=no ;;
11550   esac
11551   if test $ok = yes; then
11552     # An in-tree tool is available and we can use it
11553     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11554     echo "$as_me:$LINENO: result: just compiled" >&5
11555 echo "${ECHO_T}just compiled" >&6
11556   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11557     # We already found the complete path
11558     ac_dir=`dirname $GCJ_FOR_TARGET`
11559     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11560 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11561   elif test "x$target" = "x$host"; then
11562     # We can use an host tool
11563     GCJ_FOR_TARGET='$(GCJ)'
11564     echo "$as_me:$LINENO: result: host tool" >&5
11565 echo "${ECHO_T}host tool" >&6
11566   else
11567     # We need a cross tool
11568     echo "$as_me:$LINENO: result: pre-installed" >&5
11569 echo "${ECHO_T}pre-installed" >&6
11570   fi
11571 fi
11572
11573 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11574 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11575 if test "x${build}" != "x${host}" ; then
11576   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11577     # We already found the complete path
11578     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11579     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11580 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11581   else
11582     # Canadian cross, just use what we found
11583     echo "$as_me:$LINENO: result: pre-installed" >&5
11584 echo "${ECHO_T}pre-installed" >&6
11585   fi
11586 else
11587   ok=yes
11588   case " ${configdirs} " in
11589     *" gcc "*) ;;
11590     *) ok=no ;;
11591   esac
11592   case ,${enable_languages}, in
11593     *,fortran,*) ;;
11594     *) ok=no ;;
11595   esac
11596   if test $ok = yes; then
11597     # An in-tree tool is available and we can use it
11598     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11599     echo "$as_me:$LINENO: result: just compiled" >&5
11600 echo "${ECHO_T}just compiled" >&6
11601   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11602     # We already found the complete path
11603     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11604     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11605 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11606   elif test "x$target" = "x$host"; then
11607     # We can use an host tool
11608     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11609     echo "$as_me:$LINENO: result: host tool" >&5
11610 echo "${ECHO_T}host tool" >&6
11611   else
11612     # We need a cross tool
11613     echo "$as_me:$LINENO: result: pre-installed" >&5
11614 echo "${ECHO_T}pre-installed" >&6
11615   fi
11616 fi
11617
11618 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11619 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11620 if test "x${build}" != "x${host}" ; then
11621   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11622     # We already found the complete path
11623     ac_dir=`dirname $LD_FOR_TARGET`
11624     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11625 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11626   else
11627     # Canadian cross, just use what we found
11628     echo "$as_me:$LINENO: result: pre-installed" >&5
11629 echo "${ECHO_T}pre-installed" >&6
11630   fi
11631 else
11632   ok=yes
11633   case " ${configdirs} " in
11634     *" ld "*) ;;
11635     *) ok=no ;;
11636   esac
11637
11638   if test $ok = yes; then
11639     # An in-tree tool is available and we can use it
11640     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11641     echo "$as_me:$LINENO: result: just compiled" >&5
11642 echo "${ECHO_T}just compiled" >&6
11643   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11644     # We already found the complete path
11645     ac_dir=`dirname $LD_FOR_TARGET`
11646     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11647 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11648   elif test "x$target" = "x$host"; then
11649     # We can use an host tool
11650     LD_FOR_TARGET='$(LD)'
11651     echo "$as_me:$LINENO: result: host tool" >&5
11652 echo "${ECHO_T}host tool" >&6
11653   else
11654     # We need a cross tool
11655     echo "$as_me:$LINENO: result: pre-installed" >&5
11656 echo "${ECHO_T}pre-installed" >&6
11657   fi
11658 fi
11659
11660 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11661 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11662 if test "x${build}" != "x${host}" ; then
11663   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11664     # We already found the complete path
11665     ac_dir=`dirname $LIPO_FOR_TARGET`
11666     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11667 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11668   else
11669     # Canadian cross, just use what we found
11670     echo "$as_me:$LINENO: result: pre-installed" >&5
11671 echo "${ECHO_T}pre-installed" >&6
11672   fi
11673 else
11674   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11675     # We already found the complete path
11676     ac_dir=`dirname $LIPO_FOR_TARGET`
11677     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11678 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11679   elif test "x$target" = "x$host"; then
11680     # We can use an host tool
11681     LIPO_FOR_TARGET='$(LIPO)'
11682     echo "$as_me:$LINENO: result: host tool" >&5
11683 echo "${ECHO_T}host tool" >&6
11684   else
11685     # We need a cross tool
11686     echo "$as_me:$LINENO: result: pre-installed" >&5
11687 echo "${ECHO_T}pre-installed" >&6
11688   fi
11689 fi
11690
11691 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11692 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11693 if test "x${build}" != "x${host}" ; then
11694   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11695     # We already found the complete path
11696     ac_dir=`dirname $NM_FOR_TARGET`
11697     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11698 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11699   else
11700     # Canadian cross, just use what we found
11701     echo "$as_me:$LINENO: result: pre-installed" >&5
11702 echo "${ECHO_T}pre-installed" >&6
11703   fi
11704 else
11705   ok=yes
11706   case " ${configdirs} " in
11707     *" binutils "*) ;;
11708     *) ok=no ;;
11709   esac
11710
11711   if test $ok = yes; then
11712     # An in-tree tool is available and we can use it
11713     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11714     echo "$as_me:$LINENO: result: just compiled" >&5
11715 echo "${ECHO_T}just compiled" >&6
11716   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11717     # We already found the complete path
11718     ac_dir=`dirname $NM_FOR_TARGET`
11719     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11720 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11721   elif test "x$target" = "x$host"; then
11722     # We can use an host tool
11723     NM_FOR_TARGET='$(NM)'
11724     echo "$as_me:$LINENO: result: host tool" >&5
11725 echo "${ECHO_T}host tool" >&6
11726   else
11727     # We need a cross tool
11728     echo "$as_me:$LINENO: result: pre-installed" >&5
11729 echo "${ECHO_T}pre-installed" >&6
11730   fi
11731 fi
11732
11733 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11734 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11735 if test "x${build}" != "x${host}" ; then
11736   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11737     # We already found the complete path
11738     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11739     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11740 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11741   else
11742     # Canadian cross, just use what we found
11743     echo "$as_me:$LINENO: result: pre-installed" >&5
11744 echo "${ECHO_T}pre-installed" >&6
11745   fi
11746 else
11747   ok=yes
11748   case " ${configdirs} " in
11749     *" binutils "*) ;;
11750     *) ok=no ;;
11751   esac
11752
11753   if test $ok = yes; then
11754     # An in-tree tool is available and we can use it
11755     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11756     echo "$as_me:$LINENO: result: just compiled" >&5
11757 echo "${ECHO_T}just compiled" >&6
11758   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11759     # We already found the complete path
11760     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11761     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11762 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11763   elif test "x$target" = "x$host"; then
11764     # We can use an host tool
11765     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11766     echo "$as_me:$LINENO: result: host tool" >&5
11767 echo "${ECHO_T}host tool" >&6
11768   else
11769     # We need a cross tool
11770     echo "$as_me:$LINENO: result: pre-installed" >&5
11771 echo "${ECHO_T}pre-installed" >&6
11772   fi
11773 fi
11774
11775 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11776 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11777 if test "x${build}" != "x${host}" ; then
11778   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11779     # We already found the complete path
11780     ac_dir=`dirname $RANLIB_FOR_TARGET`
11781     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11782 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11783   else
11784     # Canadian cross, just use what we found
11785     echo "$as_me:$LINENO: result: pre-installed" >&5
11786 echo "${ECHO_T}pre-installed" >&6
11787   fi
11788 else
11789   ok=yes
11790   case " ${configdirs} " in
11791     *" binutils "*) ;;
11792     *) ok=no ;;
11793   esac
11794
11795   if test $ok = yes; then
11796     # An in-tree tool is available and we can use it
11797     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11798     echo "$as_me:$LINENO: result: just compiled" >&5
11799 echo "${ECHO_T}just compiled" >&6
11800   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11801     # We already found the complete path
11802     ac_dir=`dirname $RANLIB_FOR_TARGET`
11803     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11804 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11805   elif test "x$target" = "x$host"; then
11806     # We can use an host tool
11807     RANLIB_FOR_TARGET='$(RANLIB)'
11808     echo "$as_me:$LINENO: result: host tool" >&5
11809 echo "${ECHO_T}host tool" >&6
11810   else
11811     # We need a cross tool
11812     echo "$as_me:$LINENO: result: pre-installed" >&5
11813 echo "${ECHO_T}pre-installed" >&6
11814   fi
11815 fi
11816
11817 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11818 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11819 if test "x${build}" != "x${host}" ; then
11820   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11821     # We already found the complete path
11822     ac_dir=`dirname $STRIP_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   else
11826     # Canadian cross, just use what we found
11827     echo "$as_me:$LINENO: result: pre-installed" >&5
11828 echo "${ECHO_T}pre-installed" >&6
11829   fi
11830 else
11831   ok=yes
11832   case " ${configdirs} " in
11833     *" binutils "*) ;;
11834     *) ok=no ;;
11835   esac
11836
11837   if test $ok = yes; then
11838     # An in-tree tool is available and we can use it
11839     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11840     echo "$as_me:$LINENO: result: just compiled" >&5
11841 echo "${ECHO_T}just compiled" >&6
11842   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11843     # We already found the complete path
11844     ac_dir=`dirname $STRIP_FOR_TARGET`
11845     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11846 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11847   elif test "x$target" = "x$host"; then
11848     # We can use an host tool
11849     STRIP_FOR_TARGET='$(STRIP)'
11850     echo "$as_me:$LINENO: result: host tool" >&5
11851 echo "${ECHO_T}host tool" >&6
11852   else
11853     # We need a cross tool
11854     echo "$as_me:$LINENO: result: pre-installed" >&5
11855 echo "${ECHO_T}pre-installed" >&6
11856   fi
11857 fi
11858
11859 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11860 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11861 if test "x${build}" != "x${host}" ; then
11862   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11863     # We already found the complete path
11864     ac_dir=`dirname $WINDRES_FOR_TARGET`
11865     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11866 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11867   else
11868     # Canadian cross, just use what we found
11869     echo "$as_me:$LINENO: result: pre-installed" >&5
11870 echo "${ECHO_T}pre-installed" >&6
11871   fi
11872 else
11873   ok=yes
11874   case " ${configdirs} " in
11875     *" binutils "*) ;;
11876     *) ok=no ;;
11877   esac
11878
11879   if test $ok = yes; then
11880     # An in-tree tool is available and we can use it
11881     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11882     echo "$as_me:$LINENO: result: just compiled" >&5
11883 echo "${ECHO_T}just compiled" >&6
11884   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11885     # We already found the complete path
11886     ac_dir=`dirname $WINDRES_FOR_TARGET`
11887     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11888 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11889   elif test "x$target" = "x$host"; then
11890     # We can use an host tool
11891     WINDRES_FOR_TARGET='$(WINDRES)'
11892     echo "$as_me:$LINENO: result: host tool" >&5
11893 echo "${ECHO_T}host tool" >&6
11894   else
11895     # We need a cross tool
11896     echo "$as_me:$LINENO: result: pre-installed" >&5
11897 echo "${ECHO_T}pre-installed" >&6
11898   fi
11899 fi
11900
11901 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
11902 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
11903 if test "x${build}" != "x${host}" ; then
11904   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11905     # We already found the complete path
11906     ac_dir=`dirname $WINDMC_FOR_TARGET`
11907     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11908 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11909   else
11910     # Canadian cross, just use what we found
11911     echo "$as_me:$LINENO: result: pre-installed" >&5
11912 echo "${ECHO_T}pre-installed" >&6
11913   fi
11914 else
11915   ok=yes
11916   case " ${configdirs} " in
11917     *" binutils "*) ;;
11918     *) ok=no ;;
11919   esac
11920
11921   if test $ok = yes; then
11922     # An in-tree tool is available and we can use it
11923     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
11924     echo "$as_me:$LINENO: result: just compiled" >&5
11925 echo "${ECHO_T}just compiled" >&6
11926   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11927     # We already found the complete path
11928     ac_dir=`dirname $WINDMC_FOR_TARGET`
11929     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11930 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11931   elif test "x$target" = "x$host"; then
11932     # We can use an host tool
11933     WINDMC_FOR_TARGET='$(WINDMC)'
11934     echo "$as_me:$LINENO: result: host tool" >&5
11935 echo "${ECHO_T}host tool" >&6
11936   else
11937     # We need a cross tool
11938     echo "$as_me:$LINENO: result: pre-installed" >&5
11939 echo "${ECHO_T}pre-installed" >&6
11940   fi
11941 fi
11942
11943
11944
11945
11946
11947 # Certain tools may need extra flags.
11948 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
11949 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
11950 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
11951
11952 # When building target libraries, except in a Canadian cross, we use
11953 # the same toolchain as the compiler we just built.
11954 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
11955 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
11956 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
11957 if test $host = $build; then
11958   case " $configdirs " in
11959     *" gcc "*)
11960       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
11961       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
11962       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
11963       ;;
11964   esac
11965 fi
11966
11967
11968
11969
11970
11971 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
11972 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
11973 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
11974 if test "${enable_maintainer_mode+set}" = set; then
11975   enableval="$enable_maintainer_mode"
11976   USE_MAINTAINER_MODE=$enableval
11977 else
11978   USE_MAINTAINER_MODE=no
11979 fi;
11980 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
11981 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
11982
11983
11984 if test "$USE_MAINTAINER_MODE" = yes; then
11985   MAINTAINER_MODE_TRUE=
11986   MAINTAINER_MODE_FALSE='#'
11987 else
11988   MAINTAINER_MODE_TRUE='#'
11989   MAINTAINER_MODE_FALSE=
11990 fi
11991 MAINT=$MAINTAINER_MODE_TRUE
11992
11993 # ---------------------
11994 # GCC bootstrap support
11995 # ---------------------
11996
11997 # Stage specific cflags for build.
11998 stage1_cflags="-g"
11999 case $build in
12000   vax-*-*)
12001     case ${GCC} in
12002       yes) stage1_cflags="-g -Wa,-J" ;;
12003       *) stage1_cflags="-g -J" ;;
12004     esac ;;
12005 esac
12006
12007 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12008 if test "$GCC" = yes; then
12009   saved_CFLAGS="$CFLAGS"
12010
12011   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12012   CFLAGS="$CFLAGS -fkeep-inline-functions"
12013   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12014 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12015   cat >conftest.$ac_ext <<_ACEOF
12016 /* confdefs.h.  */
12017 _ACEOF
12018 cat confdefs.h >>conftest.$ac_ext
12019 cat >>conftest.$ac_ext <<_ACEOF
12020 /* end confdefs.h.  */
12021
12022 #if (__GNUC__ < 3) \
12023     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12024                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12025 #error http://gcc.gnu.org/PR29382
12026 #endif
12027
12028 int
12029 main ()
12030 {
12031
12032   ;
12033   return 0;
12034 }
12035 _ACEOF
12036 rm -f conftest.$ac_objext
12037 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12038   (eval $ac_compile) 2>conftest.er1
12039   ac_status=$?
12040   grep -v '^ *+' conftest.er1 >conftest.err
12041   rm -f conftest.er1
12042   cat conftest.err >&5
12043   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12044   (exit $ac_status); } &&
12045          { ac_try='test -z "$ac_c_werror_flag"
12046                          || test ! -s conftest.err'
12047   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12048   (eval $ac_try) 2>&5
12049   ac_status=$?
12050   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12051   (exit $ac_status); }; } &&
12052          { ac_try='test -s conftest.$ac_objext'
12053   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12054   (eval $ac_try) 2>&5
12055   ac_status=$?
12056   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12057   (exit $ac_status); }; }; then
12058   echo "$as_me:$LINENO: result: yes" >&5
12059 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12060 else
12061   echo "$as_me: failed program was:" >&5
12062 sed 's/^/| /' conftest.$ac_ext >&5
12063
12064 echo "$as_me:$LINENO: result: no" >&5
12065 echo "${ECHO_T}no" >&6
12066 fi
12067 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12068
12069   CFLAGS="$saved_CFLAGS"
12070 fi
12071
12072
12073
12074 # Enable --enable-checking in stage1 of the compiler.
12075 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12076 if test "${enable_stage1_checking+set}" = set; then
12077   enableval="$enable_stage1_checking"
12078   stage1_checking=--enable-checking=${enable_stage1_checking}
12079 else
12080   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12081   stage1_checking=--enable-checking=yes,types
12082 else
12083   stage1_checking=--enable-checking=$enable_checking,types
12084 fi
12085 fi;
12086
12087
12088 # Enable -Werror in bootstrap stage2 and later.
12089 # Check whether --enable-werror or --disable-werror was given.
12090 if test "${enable_werror+set}" = set; then
12091   enableval="$enable_werror"
12092
12093 else
12094   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12095   enable_werror=yes
12096 else
12097   enable_werror=no
12098 fi
12099 fi;
12100 case ${enable_werror} in
12101   yes) stage2_werror_flag="--enable-werror-always" ;;
12102   *) stage2_werror_flag="" ;;
12103 esac
12104
12105
12106 # Flags needed to enable html installing and building
12107
12108 # Check whether --with-datarootdir or --without-datarootdir was given.
12109 if test "${with_datarootdir+set}" = set; then
12110   withval="$with_datarootdir"
12111   datarootdir="\${prefix}/${withval}"
12112 else
12113   datarootdir="\${prefix}/share"
12114 fi;
12115
12116
12117 # Check whether --with-docdir or --without-docdir was given.
12118 if test "${with_docdir+set}" = set; then
12119   withval="$with_docdir"
12120   docdir="\${prefix}/${withval}"
12121 else
12122   docdir="\${datarootdir}/doc"
12123 fi;
12124
12125
12126 # Check whether --with-pdfdir or --without-pdfdir was given.
12127 if test "${with_pdfdir+set}" = set; then
12128   withval="$with_pdfdir"
12129   pdfdir="\${prefix}/${withval}"
12130 else
12131   pdfdir="\${docdir}"
12132 fi;
12133
12134
12135 # Check whether --with-htmldir or --without-htmldir was given.
12136 if test "${with_htmldir+set}" = set; then
12137   withval="$with_htmldir"
12138   htmldir="\${prefix}/${withval}"
12139 else
12140   htmldir="\${docdir}"
12141 fi;
12142
12143
12144
12145
12146
12147
12148           ac_config_files="$ac_config_files Makefile"
12149 cat >confcache <<\_ACEOF
12150 # This file is a shell script that caches the results of configure
12151 # tests run on this system so they can be shared between configure
12152 # scripts and configure runs, see configure's option --config-cache.
12153 # It is not useful on other systems.  If it contains results you don't
12154 # want to keep, you may remove or edit it.
12155 #
12156 # config.status only pays attention to the cache file if you give it
12157 # the --recheck option to rerun configure.
12158 #
12159 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12160 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12161 # following values.
12162
12163 _ACEOF
12164
12165 # The following way of writing the cache mishandles newlines in values,
12166 # but we know of no workaround that is simple, portable, and efficient.
12167 # So, don't put newlines in cache variables' values.
12168 # Ultrix sh set writes to stderr and can't be redirected directly,
12169 # and sets the high bit in the cache file unless we assign to the vars.
12170 {
12171   (set) 2>&1 |
12172     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12173     *ac_space=\ *)
12174       # `set' does not quote correctly, so add quotes (double-quote
12175       # substitution turns \\\\ into \\, and sed turns \\ into \).
12176       sed -n \
12177         "s/'/'\\\\''/g;
12178           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12179       ;;
12180     *)
12181       # `set' quotes correctly as required by POSIX, so do not add quotes.
12182       sed -n \
12183         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12184       ;;
12185     esac;
12186 } |
12187   sed '
12188      t clear
12189      : clear
12190      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12191      t end
12192      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12193      : end' >>confcache
12194 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12195   if test -w $cache_file; then
12196     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12197     cat confcache >$cache_file
12198   else
12199     echo "not updating unwritable cache $cache_file"
12200   fi
12201 fi
12202 rm -f confcache
12203
12204 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12205 # Let make expand exec_prefix.
12206 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12207
12208 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12209 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12210 # trailing colons and then remove the whole line if VPATH becomes empty
12211 # (actually we leave an empty line to preserve line numbers).
12212 if test "x$srcdir" = x.; then
12213   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12214 s/:*\$(srcdir):*/:/;
12215 s/:*\${srcdir}:*/:/;
12216 s/:*@srcdir@:*/:/;
12217 s/^\([^=]*=[     ]*\):*/\1/;
12218 s/:*$//;
12219 s/^[^=]*=[       ]*$//;
12220 }'
12221 fi
12222
12223 # Transform confdefs.h into DEFS.
12224 # Protect against shell expansion while executing Makefile rules.
12225 # Protect against Makefile macro expansion.
12226 #
12227 # If the first sed substitution is executed (which looks for macros that
12228 # take arguments), then we branch to the quote section.  Otherwise,
12229 # look for a macro that doesn't take arguments.
12230 cat >confdef2opt.sed <<\_ACEOF
12231 t clear
12232 : clear
12233 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12234 t quote
12235 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12236 t quote
12237 d
12238 : quote
12239 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12240 s,\[,\\&,g
12241 s,\],\\&,g
12242 s,\$,$$,g
12243 p
12244 _ACEOF
12245 # We use echo to avoid assuming a particular line-breaking character.
12246 # The extra dot is to prevent the shell from consuming trailing
12247 # line-breaks from the sub-command output.  A line-break within
12248 # single-quotes doesn't work because, if this script is created in a
12249 # platform that uses two characters for line-breaks (e.g., DOS), tr
12250 # would break.
12251 ac_LF_and_DOT=`echo; echo .`
12252 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12253 rm -f confdef2opt.sed
12254
12255
12256 ac_libobjs=
12257 ac_ltlibobjs=
12258 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12259   # 1. Remove the extension, and $U if already installed.
12260   ac_i=`echo "$ac_i" |
12261          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12262   # 2. Add them.
12263   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12264   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12265 done
12266 LIBOBJS=$ac_libobjs
12267
12268 LTLIBOBJS=$ac_ltlibobjs
12269
12270
12271
12272 : ${CONFIG_STATUS=./config.status}
12273 ac_clean_files_save=$ac_clean_files
12274 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12275 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12276 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12277 cat >$CONFIG_STATUS <<_ACEOF
12278 #! $SHELL
12279 # Generated by $as_me.
12280 # Run this file to recreate the current configuration.
12281 # Compiler output produced by configure, useful for debugging
12282 # configure, is in config.log if it exists.
12283
12284 debug=false
12285 ac_cs_recheck=false
12286 ac_cs_silent=false
12287 SHELL=\${CONFIG_SHELL-$SHELL}
12288 _ACEOF
12289
12290 cat >>$CONFIG_STATUS <<\_ACEOF
12291 ## --------------------- ##
12292 ## M4sh Initialization.  ##
12293 ## --------------------- ##
12294
12295 # Be Bourne compatible
12296 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12297   emulate sh
12298   NULLCMD=:
12299   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12300   # is contrary to our usage.  Disable this feature.
12301   alias -g '${1+"$@"}'='"$@"'
12302 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12303   set -o posix
12304 fi
12305 DUALCASE=1; export DUALCASE # for MKS sh
12306
12307 # Support unset when possible.
12308 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12309   as_unset=unset
12310 else
12311   as_unset=false
12312 fi
12313
12314
12315 # Work around bugs in pre-3.0 UWIN ksh.
12316 $as_unset ENV MAIL MAILPATH
12317 PS1='$ '
12318 PS2='> '
12319 PS4='+ '
12320
12321 # NLS nuisances.
12322 for as_var in \
12323   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12324   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12325   LC_TELEPHONE LC_TIME
12326 do
12327   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12328     eval $as_var=C; export $as_var
12329   else
12330     $as_unset $as_var
12331   fi
12332 done
12333
12334 # Required to use basename.
12335 if expr a : '\(a\)' >/dev/null 2>&1; then
12336   as_expr=expr
12337 else
12338   as_expr=false
12339 fi
12340
12341 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12342   as_basename=basename
12343 else
12344   as_basename=false
12345 fi
12346
12347
12348 # Name of the executable.
12349 as_me=`$as_basename "$0" ||
12350 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12351          X"$0" : 'X\(//\)$' \| \
12352          X"$0" : 'X\(/\)$' \| \
12353          .     : '\(.\)' 2>/dev/null ||
12354 echo X/"$0" |
12355     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12356           /^X\/\(\/\/\)$/{ s//\1/; q; }
12357           /^X\/\(\/\).*/{ s//\1/; q; }
12358           s/.*/./; q'`
12359
12360
12361 # PATH needs CR, and LINENO needs CR and PATH.
12362 # Avoid depending upon Character Ranges.
12363 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12364 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12365 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12366 as_cr_digits='0123456789'
12367 as_cr_alnum=$as_cr_Letters$as_cr_digits
12368
12369 # The user is always right.
12370 if test "${PATH_SEPARATOR+set}" != set; then
12371   echo "#! /bin/sh" >conf$$.sh
12372   echo  "exit 0"   >>conf$$.sh
12373   chmod +x conf$$.sh
12374   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12375     PATH_SEPARATOR=';'
12376   else
12377     PATH_SEPARATOR=:
12378   fi
12379   rm -f conf$$.sh
12380 fi
12381
12382
12383   as_lineno_1=$LINENO
12384   as_lineno_2=$LINENO
12385   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12386   test "x$as_lineno_1" != "x$as_lineno_2" &&
12387   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12388   # Find who we are.  Look in the path if we contain no path at all
12389   # relative or not.
12390   case $0 in
12391     *[\\/]* ) as_myself=$0 ;;
12392     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12393 for as_dir in $PATH
12394 do
12395   IFS=$as_save_IFS
12396   test -z "$as_dir" && as_dir=.
12397   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12398 done
12399
12400        ;;
12401   esac
12402   # We did not find ourselves, most probably we were run as `sh COMMAND'
12403   # in which case we are not to be found in the path.
12404   if test "x$as_myself" = x; then
12405     as_myself=$0
12406   fi
12407   if test ! -f "$as_myself"; then
12408     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12409 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12410    { (exit 1); exit 1; }; }
12411   fi
12412   case $CONFIG_SHELL in
12413   '')
12414     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12415 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12416 do
12417   IFS=$as_save_IFS
12418   test -z "$as_dir" && as_dir=.
12419   for as_base in sh bash ksh sh5; do
12420          case $as_dir in
12421          /*)
12422            if ("$as_dir/$as_base" -c '
12423   as_lineno_1=$LINENO
12424   as_lineno_2=$LINENO
12425   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12426   test "x$as_lineno_1" != "x$as_lineno_2" &&
12427   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12428              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12429              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12430              CONFIG_SHELL=$as_dir/$as_base
12431              export CONFIG_SHELL
12432              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12433            fi;;
12434          esac
12435        done
12436 done
12437 ;;
12438   esac
12439
12440   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12441   # uniformly replaced by the line number.  The first 'sed' inserts a
12442   # line-number line before each line; the second 'sed' does the real
12443   # work.  The second script uses 'N' to pair each line-number line
12444   # with the numbered line, and appends trailing '-' during
12445   # substitution so that $LINENO is not a special case at line end.
12446   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12447   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12448   sed '=' <$as_myself |
12449     sed '
12450       N
12451       s,$,-,
12452       : loop
12453       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12454       t loop
12455       s,-$,,
12456       s,^['$as_cr_digits']*\n,,
12457     ' >$as_me.lineno &&
12458   chmod +x $as_me.lineno ||
12459     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12460 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12461    { (exit 1); exit 1; }; }
12462
12463   # Don't try to exec as it changes $[0], causing all sort of problems
12464   # (the dirname of $[0] is not the place where we might find the
12465   # original and so on.  Autoconf is especially sensible to this).
12466   . ./$as_me.lineno
12467   # Exit status is that of the last command.
12468   exit
12469 }
12470
12471
12472 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12473   *c*,-n*) ECHO_N= ECHO_C='
12474 ' ECHO_T='      ' ;;
12475   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12476   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12477 esac
12478
12479 if expr a : '\(a\)' >/dev/null 2>&1; then
12480   as_expr=expr
12481 else
12482   as_expr=false
12483 fi
12484
12485 rm -f conf$$ conf$$.exe conf$$.file
12486 echo >conf$$.file
12487 if ln -s conf$$.file conf$$ 2>/dev/null; then
12488   # We could just check for DJGPP; but this test a) works b) is more generic
12489   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12490   if test -f conf$$.exe; then
12491     # Don't use ln at all; we don't have any links
12492     as_ln_s='cp -p'
12493   else
12494     as_ln_s='ln -s'
12495   fi
12496 elif ln conf$$.file conf$$ 2>/dev/null; then
12497   as_ln_s=ln
12498 else
12499   as_ln_s='cp -p'
12500 fi
12501 rm -f conf$$ conf$$.exe conf$$.file
12502
12503 if mkdir -p . 2>/dev/null; then
12504   as_mkdir_p=:
12505 else
12506   test -d ./-p && rmdir ./-p
12507   as_mkdir_p=false
12508 fi
12509
12510 as_executable_p="test -f"
12511
12512 # Sed expression to map a string onto a valid CPP name.
12513 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12514
12515 # Sed expression to map a string onto a valid variable name.
12516 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12517
12518
12519 # IFS
12520 # We need space, tab and new line, in precisely that order.
12521 as_nl='
12522 '
12523 IFS="   $as_nl"
12524
12525 # CDPATH.
12526 $as_unset CDPATH
12527
12528 exec 6>&1
12529
12530 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12531 # report actual input values of CONFIG_FILES etc. instead of their
12532 # values after options handling.  Logging --version etc. is OK.
12533 exec 5>>config.log
12534 {
12535   echo
12536   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12537 ## Running $as_me. ##
12538 _ASBOX
12539 } >&5
12540 cat >&5 <<_CSEOF
12541
12542 This file was extended by $as_me, which was
12543 generated by GNU Autoconf 2.59.  Invocation command line was
12544
12545   CONFIG_FILES    = $CONFIG_FILES
12546   CONFIG_HEADERS  = $CONFIG_HEADERS
12547   CONFIG_LINKS    = $CONFIG_LINKS
12548   CONFIG_COMMANDS = $CONFIG_COMMANDS
12549   $ $0 $@
12550
12551 _CSEOF
12552 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12553 echo >&5
12554 _ACEOF
12555
12556 # Files that config.status was made for.
12557 if test -n "$ac_config_files"; then
12558   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12559 fi
12560
12561 if test -n "$ac_config_headers"; then
12562   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12563 fi
12564
12565 if test -n "$ac_config_links"; then
12566   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12567 fi
12568
12569 if test -n "$ac_config_commands"; then
12570   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12571 fi
12572
12573 cat >>$CONFIG_STATUS <<\_ACEOF
12574
12575 ac_cs_usage="\
12576 \`$as_me' instantiates files from templates according to the
12577 current configuration.
12578
12579 Usage: $0 [OPTIONS] [FILE]...
12580
12581   -h, --help       print this help, then exit
12582   -V, --version    print version number, then exit
12583   -q, --quiet      do not print progress messages
12584   -d, --debug      don't remove temporary files
12585       --recheck    update $as_me by reconfiguring in the same conditions
12586   --file=FILE[:TEMPLATE]
12587                    instantiate the configuration file FILE
12588
12589 Configuration files:
12590 $config_files
12591
12592 Report bugs to <bug-autoconf@gnu.org>."
12593 _ACEOF
12594
12595 cat >>$CONFIG_STATUS <<_ACEOF
12596 ac_cs_version="\\
12597 config.status
12598 configured by $0, generated by GNU Autoconf 2.59,
12599   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12600
12601 Copyright (C) 2003 Free Software Foundation, Inc.
12602 This config.status script is free software; the Free Software Foundation
12603 gives unlimited permission to copy, distribute and modify it."
12604 srcdir=$srcdir
12605 INSTALL="$INSTALL"
12606 _ACEOF
12607
12608 cat >>$CONFIG_STATUS <<\_ACEOF
12609 # If no file are specified by the user, then we need to provide default
12610 # value.  By we need to know if files were specified by the user.
12611 ac_need_defaults=:
12612 while test $# != 0
12613 do
12614   case $1 in
12615   --*=*)
12616     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12617     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12618     ac_shift=:
12619     ;;
12620   -*)
12621     ac_option=$1
12622     ac_optarg=$2
12623     ac_shift=shift
12624     ;;
12625   *) # This is not an option, so the user has probably given explicit
12626      # arguments.
12627      ac_option=$1
12628      ac_need_defaults=false;;
12629   esac
12630
12631   case $ac_option in
12632   # Handling of the options.
12633 _ACEOF
12634 cat >>$CONFIG_STATUS <<\_ACEOF
12635   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12636     ac_cs_recheck=: ;;
12637   --version | --vers* | -V )
12638     echo "$ac_cs_version"; exit 0 ;;
12639   --he | --h)
12640     # Conflict between --help and --header
12641     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12642 Try \`$0 --help' for more information." >&5
12643 echo "$as_me: error: ambiguous option: $1
12644 Try \`$0 --help' for more information." >&2;}
12645    { (exit 1); exit 1; }; };;
12646   --help | --hel | -h )
12647     echo "$ac_cs_usage"; exit 0 ;;
12648   --debug | --d* | -d )
12649     debug=: ;;
12650   --file | --fil | --fi | --f )
12651     $ac_shift
12652     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12653     ac_need_defaults=false;;
12654   --header | --heade | --head | --hea )
12655     $ac_shift
12656     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12657     ac_need_defaults=false;;
12658   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12659   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12660     ac_cs_silent=: ;;
12661
12662   # This is an error.
12663   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12664 Try \`$0 --help' for more information." >&5
12665 echo "$as_me: error: unrecognized option: $1
12666 Try \`$0 --help' for more information." >&2;}
12667    { (exit 1); exit 1; }; } ;;
12668
12669   *) ac_config_targets="$ac_config_targets $1" ;;
12670
12671   esac
12672   shift
12673 done
12674
12675 ac_configure_extra_args=
12676
12677 if $ac_cs_silent; then
12678   exec 6>/dev/null
12679   ac_configure_extra_args="$ac_configure_extra_args --silent"
12680 fi
12681
12682 _ACEOF
12683 cat >>$CONFIG_STATUS <<_ACEOF
12684 if \$ac_cs_recheck; then
12685   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12686   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12687 fi
12688
12689 _ACEOF
12690
12691
12692
12693
12694
12695 cat >>$CONFIG_STATUS <<\_ACEOF
12696 for ac_config_target in $ac_config_targets
12697 do
12698   case "$ac_config_target" in
12699   # Handling of arguments.
12700   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12701   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12702 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12703    { (exit 1); exit 1; }; };;
12704   esac
12705 done
12706
12707 # If the user did not use the arguments to specify the items to instantiate,
12708 # then the envvar interface is used.  Set only those that are not.
12709 # We use the long form for the default assignment because of an extremely
12710 # bizarre bug on SunOS 4.1.3.
12711 if $ac_need_defaults; then
12712   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12713 fi
12714
12715 # Have a temporary directory for convenience.  Make it in the build tree
12716 # simply because there is no reason to put it here, and in addition,
12717 # creating and moving files from /tmp can sometimes cause problems.
12718 # Create a temporary directory, and hook for its removal unless debugging.
12719 $debug ||
12720 {
12721   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12722   trap '{ (exit 1); exit 1; }' 1 2 13 15
12723 }
12724
12725 # Create a (secure) tmp directory for tmp files.
12726
12727 {
12728   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12729   test -n "$tmp" && test -d "$tmp"
12730 }  ||
12731 {
12732   tmp=./confstat$$-$RANDOM
12733   (umask 077 && mkdir $tmp)
12734 } ||
12735 {
12736    echo "$me: cannot create a temporary directory in ." >&2
12737    { (exit 1); exit 1; }
12738 }
12739
12740 _ACEOF
12741
12742 cat >>$CONFIG_STATUS <<_ACEOF
12743
12744 #
12745 # CONFIG_FILES section.
12746 #
12747
12748 # No need to generate the scripts if there are no CONFIG_FILES.
12749 # This happens for instance when ./config.status config.h
12750 if test -n "\$CONFIG_FILES"; then
12751   # Protect against being on the right side of a sed subst in config.status.
12752   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12753    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12754 s,@SHELL@,$SHELL,;t t
12755 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12756 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12757 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12758 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12759 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12760 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12761 s,@exec_prefix@,$exec_prefix,;t t
12762 s,@prefix@,$prefix,;t t
12763 s,@program_transform_name@,$program_transform_name,;t t
12764 s,@bindir@,$bindir,;t t
12765 s,@sbindir@,$sbindir,;t t
12766 s,@libexecdir@,$libexecdir,;t t
12767 s,@datadir@,$datadir,;t t
12768 s,@sysconfdir@,$sysconfdir,;t t
12769 s,@sharedstatedir@,$sharedstatedir,;t t
12770 s,@localstatedir@,$localstatedir,;t t
12771 s,@libdir@,$libdir,;t t
12772 s,@includedir@,$includedir,;t t
12773 s,@oldincludedir@,$oldincludedir,;t t
12774 s,@infodir@,$infodir,;t t
12775 s,@mandir@,$mandir,;t t
12776 s,@build_alias@,$build_alias,;t t
12777 s,@host_alias@,$host_alias,;t t
12778 s,@target_alias@,$target_alias,;t t
12779 s,@DEFS@,$DEFS,;t t
12780 s,@ECHO_C@,$ECHO_C,;t t
12781 s,@ECHO_N@,$ECHO_N,;t t
12782 s,@ECHO_T@,$ECHO_T,;t t
12783 s,@LIBS@,$LIBS,;t t
12784 s,@build@,$build,;t t
12785 s,@build_cpu@,$build_cpu,;t t
12786 s,@build_vendor@,$build_vendor,;t t
12787 s,@build_os@,$build_os,;t t
12788 s,@build_noncanonical@,$build_noncanonical,;t t
12789 s,@host_noncanonical@,$host_noncanonical,;t t
12790 s,@target_noncanonical@,$target_noncanonical,;t t
12791 s,@host@,$host,;t t
12792 s,@host_cpu@,$host_cpu,;t t
12793 s,@host_vendor@,$host_vendor,;t t
12794 s,@host_os@,$host_os,;t t
12795 s,@target@,$target,;t t
12796 s,@target_cpu@,$target_cpu,;t t
12797 s,@target_vendor@,$target_vendor,;t t
12798 s,@target_os@,$target_os,;t t
12799 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12800 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12801 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12802 s,@LN@,$LN,;t t
12803 s,@LN_S@,$LN_S,;t t
12804 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12805 s,@build_libsubdir@,$build_libsubdir,;t t
12806 s,@build_subdir@,$build_subdir,;t t
12807 s,@host_subdir@,$host_subdir,;t t
12808 s,@target_subdir@,$target_subdir,;t t
12809 s,@CC@,$CC,;t t
12810 s,@CFLAGS@,$CFLAGS,;t t
12811 s,@LDFLAGS@,$LDFLAGS,;t t
12812 s,@CPPFLAGS@,$CPPFLAGS,;t t
12813 s,@ac_ct_CC@,$ac_ct_CC,;t t
12814 s,@EXEEXT@,$EXEEXT,;t t
12815 s,@OBJEXT@,$OBJEXT,;t t
12816 s,@CXX@,$CXX,;t t
12817 s,@CXXFLAGS@,$CXXFLAGS,;t t
12818 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12819 s,@GNATBIND@,$GNATBIND,;t t
12820 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12821 s,@GNATMAKE@,$GNATMAKE,;t t
12822 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12823 s,@do_compare@,$do_compare,;t t
12824 s,@gmplibs@,$gmplibs,;t t
12825 s,@gmpinc@,$gmpinc,;t t
12826 s,@stage1_languages@,$stage1_languages,;t t
12827 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12828 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12829 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12830 s,@tooldir@,$tooldir,;t t
12831 s,@build_tooldir@,$build_tooldir,;t t
12832 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12833 s,@GDB_TK@,$GDB_TK,;t t
12834 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12835 s,@build_configargs@,$build_configargs,;t t
12836 s,@build_configdirs@,$build_configdirs,;t t
12837 s,@host_configargs@,$host_configargs,;t t
12838 s,@configdirs@,$configdirs,;t t
12839 s,@target_configargs@,$target_configargs,;t t
12840 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
12841 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
12842 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12843 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12844 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
12845 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
12846 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
12847 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
12848 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
12849 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
12850 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
12851 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
12852 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
12853 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
12854 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
12855 s,@config_shell@,$config_shell,;t t
12856 s,@YACC@,$YACC,;t t
12857 s,@BISON@,$BISON,;t t
12858 s,@M4@,$M4,;t t
12859 s,@LEX@,$LEX,;t t
12860 s,@FLEX@,$FLEX,;t t
12861 s,@MAKEINFO@,$MAKEINFO,;t t
12862 s,@EXPECT@,$EXPECT,;t t
12863 s,@RUNTEST@,$RUNTEST,;t t
12864 s,@AR@,$AR,;t t
12865 s,@AS@,$AS,;t t
12866 s,@DLLTOOL@,$DLLTOOL,;t t
12867 s,@LD@,$LD,;t t
12868 s,@LIPO@,$LIPO,;t t
12869 s,@NM@,$NM,;t t
12870 s,@RANLIB@,$RANLIB,;t t
12871 s,@STRIP@,$STRIP,;t t
12872 s,@WINDRES@,$WINDRES,;t t
12873 s,@WINDMC@,$WINDMC,;t t
12874 s,@OBJCOPY@,$OBJCOPY,;t t
12875 s,@OBJDUMP@,$OBJDUMP,;t t
12876 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12877 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12878 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12879 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12880 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12881 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12882 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12883 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12884 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12885 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12886 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12887 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12888 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12889 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12890 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12891 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
12892 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12893 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12894 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12895 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12896 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12897 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12898 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12899 s,@MAINT@,$MAINT,;t t
12900 s,@stage1_cflags@,$stage1_cflags,;t t
12901 s,@stage1_checking@,$stage1_checking,;t t
12902 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12903 s,@datarootdir@,$datarootdir,;t t
12904 s,@docdir@,$docdir,;t t
12905 s,@pdfdir@,$pdfdir,;t t
12906 s,@htmldir@,$htmldir,;t t
12907 s,@LIBOBJS@,$LIBOBJS,;t t
12908 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12909 /@serialization_dependencies@/r $serialization_dependencies
12910 s,@serialization_dependencies@,,;t t
12911 /@host_makefile_frag@/r $host_makefile_frag
12912 s,@host_makefile_frag@,,;t t
12913 /@target_makefile_frag@/r $target_makefile_frag
12914 s,@target_makefile_frag@,,;t t
12915 /@alphaieee_frag@/r $alphaieee_frag
12916 s,@alphaieee_frag@,,;t t
12917 /@ospace_frag@/r $ospace_frag
12918 s,@ospace_frag@,,;t t
12919 CEOF
12920
12921 _ACEOF
12922
12923   cat >>$CONFIG_STATUS <<\_ACEOF
12924   # Split the substitutions into bite-sized pieces for seds with
12925   # small command number limits, like on Digital OSF/1 and HP-UX.
12926   ac_max_sed_lines=48
12927   ac_sed_frag=1 # Number of current file.
12928   ac_beg=1 # First line for current file.
12929   ac_end=$ac_max_sed_lines # Line after last line for current file.
12930   ac_more_lines=:
12931   ac_sed_cmds=
12932   while $ac_more_lines; do
12933     if test $ac_beg -gt 1; then
12934       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12935     else
12936       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12937     fi
12938     if test ! -s $tmp/subs.frag; then
12939       ac_more_lines=false
12940     else
12941       # The purpose of the label and of the branching condition is to
12942       # speed up the sed processing (if there are no `@' at all, there
12943       # is no need to browse any of the substitutions).
12944       # These are the two extra sed commands mentioned above.
12945       (echo ':t
12946   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
12947       if test -z "$ac_sed_cmds"; then
12948         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
12949       else
12950         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
12951       fi
12952       ac_sed_frag=`expr $ac_sed_frag + 1`
12953       ac_beg=$ac_end
12954       ac_end=`expr $ac_end + $ac_max_sed_lines`
12955     fi
12956   done
12957   if test -z "$ac_sed_cmds"; then
12958     ac_sed_cmds=cat
12959   fi
12960 fi # test -n "$CONFIG_FILES"
12961
12962 _ACEOF
12963 cat >>$CONFIG_STATUS <<\_ACEOF
12964 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
12965   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
12966   case $ac_file in
12967   - | *:- | *:-:* ) # input from stdin
12968         cat >$tmp/stdin
12969         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12970         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12971   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12972         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12973   * )   ac_file_in=$ac_file.in ;;
12974   esac
12975
12976   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
12977   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
12978 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12979          X"$ac_file" : 'X\(//\)[^/]' \| \
12980          X"$ac_file" : 'X\(//\)$' \| \
12981          X"$ac_file" : 'X\(/\)' \| \
12982          .     : '\(.\)' 2>/dev/null ||
12983 echo X"$ac_file" |
12984     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12985           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12986           /^X\(\/\/\)$/{ s//\1/; q; }
12987           /^X\(\/\).*/{ s//\1/; q; }
12988           s/.*/./; q'`
12989   { if $as_mkdir_p; then
12990     mkdir -p "$ac_dir"
12991   else
12992     as_dir="$ac_dir"
12993     as_dirs=
12994     while test ! -d "$as_dir"; do
12995       as_dirs="$as_dir $as_dirs"
12996       as_dir=`(dirname "$as_dir") 2>/dev/null ||
12997 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12998          X"$as_dir" : 'X\(//\)[^/]' \| \
12999          X"$as_dir" : 'X\(//\)$' \| \
13000          X"$as_dir" : 'X\(/\)' \| \
13001          .     : '\(.\)' 2>/dev/null ||
13002 echo X"$as_dir" |
13003     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13004           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13005           /^X\(\/\/\)$/{ s//\1/; q; }
13006           /^X\(\/\).*/{ s//\1/; q; }
13007           s/.*/./; q'`
13008     done
13009     test ! -n "$as_dirs" || mkdir $as_dirs
13010   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13011 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13012    { (exit 1); exit 1; }; }; }
13013
13014   ac_builddir=.
13015
13016 if test "$ac_dir" != .; then
13017   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13018   # A "../" for each directory in $ac_dir_suffix.
13019   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13020 else
13021   ac_dir_suffix= ac_top_builddir=
13022 fi
13023
13024 case $srcdir in
13025   .)  # No --srcdir option.  We are building in place.
13026     ac_srcdir=.
13027     if test -z "$ac_top_builddir"; then
13028        ac_top_srcdir=.
13029     else
13030        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13031     fi ;;
13032   [\\/]* | ?:[\\/]* )  # Absolute path.
13033     ac_srcdir=$srcdir$ac_dir_suffix;
13034     ac_top_srcdir=$srcdir ;;
13035   *) # Relative path.
13036     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13037     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13038 esac
13039
13040 # Do not use `cd foo && pwd` to compute absolute paths, because
13041 # the directories may not exist.
13042 case `pwd` in
13043 .) ac_abs_builddir="$ac_dir";;
13044 *)
13045   case "$ac_dir" in
13046   .) ac_abs_builddir=`pwd`;;
13047   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13048   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13049   esac;;
13050 esac
13051 case $ac_abs_builddir in
13052 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13053 *)
13054   case ${ac_top_builddir}. in
13055   .) ac_abs_top_builddir=$ac_abs_builddir;;
13056   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13057   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13058   esac;;
13059 esac
13060 case $ac_abs_builddir in
13061 .) ac_abs_srcdir=$ac_srcdir;;
13062 *)
13063   case $ac_srcdir in
13064   .) ac_abs_srcdir=$ac_abs_builddir;;
13065   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13066   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13067   esac;;
13068 esac
13069 case $ac_abs_builddir in
13070 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13071 *)
13072   case $ac_top_srcdir in
13073   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13074   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13075   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13076   esac;;
13077 esac
13078
13079
13080   case $INSTALL in
13081   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13082   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13083   esac
13084
13085   if test x"$ac_file" != x-; then
13086     { echo "$as_me:$LINENO: creating $ac_file" >&5
13087 echo "$as_me: creating $ac_file" >&6;}
13088     rm -f "$ac_file"
13089   fi
13090   # Let's still pretend it is `configure' which instantiates (i.e., don't
13091   # use $as_me), people would be surprised to read:
13092   #    /* config.h.  Generated by config.status.  */
13093   if test x"$ac_file" = x-; then
13094     configure_input=
13095   else
13096     configure_input="$ac_file.  "
13097   fi
13098   configure_input=$configure_input"Generated from `echo $ac_file_in |
13099                                      sed 's,.*/,,'` by configure."
13100
13101   # First look for the input files in the build tree, otherwise in the
13102   # src tree.
13103   ac_file_inputs=`IFS=:
13104     for f in $ac_file_in; do
13105       case $f in
13106       -) echo $tmp/stdin ;;
13107       [\\/$]*)
13108          # Absolute (can't be DOS-style, as IFS=:)
13109          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13110 echo "$as_me: error: cannot find input file: $f" >&2;}
13111    { (exit 1); exit 1; }; }
13112          echo "$f";;
13113       *) # Relative
13114          if test -f "$f"; then
13115            # Build tree
13116            echo "$f"
13117          elif test -f "$srcdir/$f"; then
13118            # Source tree
13119            echo "$srcdir/$f"
13120          else
13121            # /dev/null tree
13122            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13123 echo "$as_me: error: cannot find input file: $f" >&2;}
13124    { (exit 1); exit 1; }; }
13125          fi;;
13126       esac
13127     done` || { (exit 1); exit 1; }
13128 _ACEOF
13129 cat >>$CONFIG_STATUS <<_ACEOF
13130   sed "$ac_vpsub
13131 $extrasub
13132 _ACEOF
13133 cat >>$CONFIG_STATUS <<\_ACEOF
13134 :t
13135 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13136 s,@configure_input@,$configure_input,;t t
13137 s,@srcdir@,$ac_srcdir,;t t
13138 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13139 s,@top_srcdir@,$ac_top_srcdir,;t t
13140 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13141 s,@builddir@,$ac_builddir,;t t
13142 s,@abs_builddir@,$ac_abs_builddir,;t t
13143 s,@top_builddir@,$ac_top_builddir,;t t
13144 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13145 s,@INSTALL@,$ac_INSTALL,;t t
13146 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13147   rm -f $tmp/stdin
13148   if test x"$ac_file" != x-; then
13149     mv $tmp/out $ac_file
13150   else
13151     cat $tmp/out
13152     rm -f $tmp/out
13153   fi
13154
13155 done
13156 _ACEOF
13157
13158 cat >>$CONFIG_STATUS <<\_ACEOF
13159
13160 { (exit 0); exit 0; }
13161 _ACEOF
13162 chmod +x $CONFIG_STATUS
13163 ac_clean_files=$ac_clean_files_save
13164
13165
13166 # configure is writing to config.log, and then calls config.status.
13167 # config.status does its own redirection, appending to config.log.
13168 # Unfortunately, on DOS this fails, as config.log is still kept open
13169 # by configure, so config.status won't be able to write to it; its
13170 # output is simply discarded.  So we exec the FD to /dev/null,
13171 # effectively closing config.log, so it can be properly (re)opened and
13172 # appended to by config.status.  When coming back to configure, we
13173 # need to make the FD available again.
13174 if test "$no_create" != yes; then
13175   ac_cs_success=:
13176   ac_config_status_args=
13177   test "$silent" = yes &&
13178     ac_config_status_args="$ac_config_status_args --quiet"
13179   exec 5>/dev/null
13180   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13181   exec 5>>config.log
13182   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13183   # would make configure fail if this is the last instruction.
13184   $ac_cs_success || { (exit 1); exit 1; }
13185 fi
13186