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         noconfigdirs="$noconfigdirs target-boehm-gc";;
2302       *-*-linux*)
2303         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2304       *)
2305         unsupported_languages="$unsupported_languages fortran"
2306         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2307     esac
2308     libgloss_dir=cris
2309     ;;
2310   crx-*-*)
2311     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2312     ;;
2313   d10v-*-*)
2314     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2315     ;;
2316   d30v-*-*)
2317     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2318     ;;
2319   ep9312-*-elf | ep9312-*-coff)
2320     libgloss_dir=arm
2321     ;;
2322   fr30-*-elf*)
2323     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2324     ;;
2325   frv-*-*)
2326     noconfigdirs="$noconfigdirs ${libgcj}"
2327     ;;
2328   h8300*-*-*)
2329     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2330     ;;
2331   h8500-*-*)
2332     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2333     ;;
2334   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2335     ;;
2336   hppa*64*-*-linux* | parisc*64*-*-linux*)
2337     # In this case, it's because the hppa64-linux target is for
2338     # the kernel only at this point and has no libc, and thus no
2339     # headers, crt*.o, etc., all of which are needed by these.
2340     noconfigdirs="$noconfigdirs target-zlib"
2341     ;;
2342   parisc*-*-linux* | hppa*-*-linux*)
2343     ;;
2344   hppa*-*-*elf* | \
2345   hppa*-*-lites* | \
2346   hppa*-*-openbsd* | \
2347   hppa*64*-*-*)
2348     noconfigdirs="$noconfigdirs ${libgcj}"
2349     ;;
2350   hppa*-hp-hpux11*)
2351     noconfigdirs="$noconfigdirs ld shellutils"
2352     ;;
2353   hppa*-*-pro*)
2354     libgloss_dir=pa
2355     ;;
2356   hppa*-*-*)
2357     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2358     # build on HP-UX 10.20.
2359     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2360     ;;
2361   i960-*-*)
2362     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2363     ;;
2364   ia64*-*-elf*)
2365     # No gdb support yet.
2366     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2367     ;;
2368   ia64*-**-hpux*)
2369     # No gdb or ld support yet.
2370     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2371     ;;
2372   i370-*-opened*)
2373     ;;
2374   i[3456789]86-*-coff | i[3456789]86-*-elf)
2375     noconfigdirs="$noconfigdirs ${libgcj}"
2376     libgloss_dir=i386
2377     ;;
2378   i[3456789]86-*-linux*)
2379     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2380     # not build java stuff by default.
2381     case "${target}" in
2382       *-*-*libc1*)
2383         noconfigdirs="$noconfigdirs ${libgcj}";;
2384     esac
2385
2386     # This section makes it possible to build newlib natively on linux.
2387     # If we are using a cross compiler then don't configure newlib.
2388     if test x${is_cross_compiler} != xno ; then
2389       noconfigdirs="$noconfigdirs target-newlib"
2390     fi
2391     noconfigdirs="$noconfigdirs target-libgloss"
2392     # If we are not using a cross compiler, do configure newlib.
2393     # Note however, that newlib will only be configured in this situation
2394     # if the --with-newlib option has been given, because otherwise
2395     # 'target-newlib' will appear in skipdirs.
2396     ;;
2397   i[3456789]86-*-mingw32*)
2398     target_configdirs="$target_configdirs target-winsup"
2399     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2400     ;;
2401   x86_64-*-mingw*)
2402     target_configdirs="$target_configdirs target-winsup"
2403     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2404     ;;
2405   *-*-cygwin*)
2406     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2407     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2408     # always build newlib if winsup directory is present.
2409     if test -d "$srcdir/winsup/cygwin"; then
2410       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2411     elif test -d "$srcdir/newlib"; then
2412       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2413     fi
2414     ;;
2415   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2416   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2417     ;;
2418   i[3456789]86-*-pe)
2419     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2420     ;;
2421   i[3456789]86-*-sco3.2v5*)
2422     # The linker does not yet know about weak symbols in COFF,
2423     # and is not configured to handle mixed ELF and COFF.
2424     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2425     ;;
2426   i[3456789]86-*-sco*)
2427     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2428     ;;
2429   i[3456789]86-*-solaris2*)
2430     noconfigdirs="$noconfigdirs target-libgloss"
2431     ;;
2432   i[3456789]86-*-sysv4*)
2433     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2434     ;;
2435   i[3456789]86-*-beos*)
2436     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2437     ;;
2438   i[3456789]86-*-rdos*)
2439     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2440     ;;
2441   m32r-*-*)
2442     noconfigdirs="$noconfigdirs ${libgcj}"
2443     ;;
2444   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2445     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2446     libgloss_dir=m68hc11
2447     ;;
2448   m68k-*-elf*)
2449     noconfigdirs="$noconfigdirs ${libgcj}"
2450     ;;
2451   m68k-*-coff*)
2452     noconfigdirs="$noconfigdirs ${libgcj}"
2453     ;;
2454   m68*-*-* | fido-*-*)
2455     libgloss_dir=m68k
2456     ;;
2457   mcore-*-pe*)
2458   # The EPOC C++ environment does not support exceptions or rtti,
2459   # and so building libstdc++-v3 tends not to always work.
2460     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2461     ;;
2462   mmix-*-*)
2463     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2464     unsupported_languages="$unsupported_languages fortran java"
2465     ;;
2466   mn10200-*-*)
2467     noconfigdirs="$noconfigdirs ${libgcj}"
2468     ;;
2469   mn10300-*-*)
2470     noconfigdirs="$noconfigdirs ${libgcj}"
2471     ;;
2472   mt-*-*)
2473     noconfigdirs="$noconfigdirs sim"
2474     ;;
2475   powerpc-*-aix*)
2476     # copied from rs6000-*-* entry
2477     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2478     ;;
2479   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2480     target_configdirs="$target_configdirs target-winsup"
2481     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2482     # always build newlib.
2483     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2484     ;;
2485     # This is temporary until we can link against shared libraries
2486   powerpcle-*-solaris*)
2487     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2488     libgloss_dir=rs6000
2489     ;;
2490   powerpc-*-beos*)
2491     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2492     ;;
2493   powerpc-*-eabi)
2494     noconfigdirs="$noconfigdirs ${libgcj}"
2495     libgloss_dir=rs6000
2496     ;;
2497   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2498     libgloss_dir=rs6000
2499     ;;
2500   rs6000-*-lynxos*)
2501     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2502     ;;
2503   rs6000-*-aix*)
2504     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2505     ;;
2506   rs6000-*-*)
2507     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2508     ;;
2509   m68k-apollo-*)
2510     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2511     ;;
2512   mips*-sde-elf*)
2513     skipdirs="$skipdirs target-libiberty"
2514     noconfigdirs="$noconfigdirs ${libgcj}"
2515     if test x$with_newlib = xyes; then
2516       noconfigdirs="$noconfigdirs gprof"
2517     fi
2518     libgloss_dir=mips
2519     ;;
2520   mips*-*-irix5*)
2521     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2522     ;;
2523   mips*-*-irix6*)
2524     # Linking libjava exceeds command-line length limits on at least
2525     # IRIX 6.2, but not on IRIX 6.5.
2526     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2527     # <oldham@codesourcery.com>
2528     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2529     ;;
2530   mips*-*-bsd*)
2531     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2532     ;;
2533   mips*-*-linux*)
2534     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2535     ;;
2536   mips*-*-*)
2537     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2538     libgloss_dir=mips
2539     ;;
2540   romp-*-*)
2541     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2542     ;;
2543   sh-*-* | sh64-*-*)
2544     case "${host}" in
2545       i[3456789]86-*-vsta) ;; # don't add gprof back in
2546       i[3456789]86-*-go32*) ;; # don't add gprof back in
2547       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2548       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2549     esac
2550     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2551     ;;
2552   sparclet-*-aout* | sparc86x-*-*)
2553     libgloss_dir=sparc
2554     ;;
2555   sparc-*-elf*)
2556     noconfigdirs="$noconfigdirs ${libgcj}"
2557     ;;
2558   sparc64-*-elf*)
2559     noconfigdirs="$noconfigdirs ${libgcj}"
2560     libgloss_dir=sparc
2561     ;;
2562   sparclite-*-*)
2563     noconfigdirs="$noconfigdirs ${libgcj}"
2564     libgloss_dir=sparc
2565     ;;
2566   sparc-*-sunos4*)
2567     noconfigdirs="$noconfigdirs ${libgcj}"
2568     if test x${is_cross_compiler} != xno ; then
2569            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2570     else
2571            use_gnu_ld=no
2572     fi
2573     ;;
2574   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2575     noconfigdirs="$noconfigdirs ${libgcj}"
2576     ;;
2577   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2578     ;;
2579   spu-*-*)
2580     skipdirs="target-libssp"
2581     ;;
2582   v810-*-*)
2583     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2584     ;;
2585   v850-*-*)
2586     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2587     ;;
2588   v850e-*-*)
2589     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2590     ;;
2591   v850ea-*-*)
2592     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2593     ;;
2594   vax-*-vms)
2595     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2596     ;;
2597   vax-*-*)
2598     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2599     ;;
2600   xtensa*-*-*)
2601     noconfigdirs="$noconfigdirs ${libgcj}"
2602     ;;
2603   ip2k-*-*)
2604     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2605     ;;
2606   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2607     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2608     ;;
2609   *-*-lynxos*)
2610     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2611     ;;
2612   *-*-*)
2613     noconfigdirs="$noconfigdirs ${libgcj}"
2614     ;;
2615 esac
2616
2617 # If we aren't building newlib, then don't build libgloss, since libgloss
2618 # depends upon some newlib header files.
2619 case "${noconfigdirs}" in
2620   *target-libgloss*) ;;
2621   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2622 esac
2623
2624 # Work in distributions that contain no compiler tools, like Autoconf.
2625 tentative_cc=""
2626 host_makefile_frag=/dev/null
2627 if test -d ${srcdir}/config ; then
2628 case "${host}" in
2629   m68k-hp-hpux*)
2630     # Avoid "too much defining" errors from HPUX compiler.
2631     tentative_cc="cc -Wp,-H256000"
2632     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2633     # If it's HP/UX ar, this should be harmless.
2634     RANLIB="ar ts"
2635     ;;
2636   m68k-apollo-sysv*)
2637     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2638     ;;
2639   m68k-apollo-bsd*)
2640     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2641     # chokes on bfd, the compiler won't let you assign integers to enums, and
2642     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2643     # the apollo compiler" (the preferred version of GCC could be called cc,
2644     # or whatever), but I'm not sure leaving CC as cc is any better...
2645     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2646     # Used to have BISON=yacc.
2647     tentative_cc=gcc
2648     ;;
2649   m88k-dg-dgux*)
2650     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2651     ;;
2652   m88k-harris-cxux*)
2653     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2654     tentative_cc="cc -Xa"
2655     host_makefile_frag="config/mh-cxux"
2656     ;;
2657   m88k-motorola-sysv*)
2658     ;;
2659   mips*-dec-ultrix*)
2660     tentative_cc="cc -Wf,-XNg1000"
2661     host_makefile_frag="config/mh-decstation"
2662     ;;
2663   mips*-nec-sysv4*)
2664     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2665     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2666     host_makefile_frag="config/mh-necv4"
2667     ;;
2668   mips*-sgi-irix4*)
2669     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2670     # environment.  Also bump switch table size so that cp-parse will
2671     # compile.  Bump string length limit so linker builds.
2672     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2673     ;;
2674   mips*-*-sysv4*)
2675     host_makefile_frag="config/mh-sysv4"
2676     ;;
2677   mips*-*-sysv*)
2678     # This is for a MIPS running RISC/os 4.52C.
2679
2680     # This is needed for GDB, but needs to be in the top-level make because
2681     # if a library is compiled with the bsd headers and gets linked with the
2682     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2683     # a different size).
2684     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2685     # known except to select the sysv environment.  Could we use /proc instead?
2686     # These "sysv environments" and "bsd environments" often end up being a pain.
2687     #
2688     # This is not part of CFLAGS because perhaps not all C compilers have this
2689     # option.
2690     tentative_cc="cc -systype sysv"
2691     ;;
2692   i370-ibm-opened*)
2693     tentative_cc="c89"
2694     ;;
2695   i[3456789]86-*-sysv5*)
2696     host_makefile_frag="config/mh-sysv5"
2697     ;;
2698   i[3456789]86-*-dgux*)
2699     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2700     host_makefile_frag="config/mh-dgux386"
2701     ;;
2702   i[3456789]86-ncr-sysv4.3*)
2703     # The MetaWare compiler will generate a copyright message unless you
2704     # turn it off by adding the -Hnocopyr flag.
2705     tentative_cc="cc -Hnocopyr"
2706     ;;
2707   i[3456789]86-ncr-sysv4*)
2708     # for an NCR 3000 (i486/SVR4) system.
2709     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2710     # This compiler not only emits obnoxious copyright messages every time
2711     # you run it, but it chokes and dies on a whole bunch of GNU source
2712     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2713     tentative_cc="/usr/ccs/ATT/cc"
2714     host_makefile_frag="config/mh-ncr3000"
2715     ;;
2716   i[3456789]86-*-sco3.2v5*)
2717     ;;
2718   i[3456789]86-*-sco*)
2719     # The native C compiler botches some simple uses of const.  Unfortunately,
2720     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2721     tentative_cc="cc -Dconst="
2722     host_makefile_frag="config/mh-sco"
2723     ;;
2724   i[3456789]86-*-udk*)
2725     host_makefile_frag="config/mh-sysv5"
2726     ;;
2727   i[3456789]86-*-solaris2*)
2728     host_makefile_frag="config/mh-sysv4"
2729     ;;
2730   i[3456789]86-*-msdosdjgpp*)
2731     host_makefile_frag="config/mh-djgpp"
2732     ;;
2733   *-cygwin*)
2734     host_makefile_frag="config/mh-cygwin"
2735     ;;
2736   *-mingw32*)
2737     host_makefile_frag="config/mh-mingw"
2738     ;;
2739   *-mingw64*)
2740     host_makefile_frag="config/mh-mingw"
2741     ;;
2742   *-interix*)
2743     host_makefile_frag="config/mh-interix"
2744     ;;
2745   vax-*-ultrix2*)
2746     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2747     tentative_cc=gcc
2748     ;;
2749   *-*-solaris2*)
2750     host_makefile_frag="config/mh-solaris"
2751     ;;
2752   m68k-sun-sunos*)
2753     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2754     # without overflowing the jump tables (-J says to use a 32 bit table)
2755     tentative_cc="cc -J"
2756     ;;
2757   *-hp-hpux*)
2758     tentative_cc="cc -Wp,-H256000"
2759     ;;
2760   *-*-hiux*)
2761     tentative_cc="cc -Wp,-H256000"
2762     ;;
2763   rs6000-*-lynxos*)
2764     # /bin/cc is less than useful for our purposes.  Always use GCC
2765     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2766     host_makefile_frag="config/mh-lynxrs6k"
2767     ;;
2768   powerpc-*-darwin*)
2769     host_makefile_frag="config/mh-ppc-darwin"
2770     ;;
2771   powerpc-*-aix*)
2772     host_makefile_frag="config/mh-ppc-aix"
2773     ;;
2774   rs6000-*-aix*)
2775     host_makefile_frag="config/mh-ppc-aix"
2776     ;;
2777   *-*-lynxos*)
2778     # /bin/cc is less than useful for our purposes.  Always use GCC
2779     tentative_cc="/bin/gcc"
2780     ;;
2781   *-*-sysv4*)
2782     host_makefile_frag="config/mh-sysv4"
2783     ;;
2784   # This is placed last to prevent interfering with the cases above.
2785   i[3456789]86-*-*)
2786     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2787     host_makefile_frag="config/mh-x86omitfp"
2788     ;;
2789 esac
2790 fi
2791
2792 # If we aren't going to be using gcc, see if we can extract a definition
2793 # of CC from the fragment.
2794 # Actually, use the 'pre-extracted' version above.
2795 if test -z "${CC}" && test "${build}" = "${host}" ; then
2796   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2797   found=
2798   for dir in $PATH; do
2799     test -z "$dir" && dir=.
2800     if test -f $dir/gcc; then
2801       found=yes
2802       break
2803     fi
2804   done
2805   IFS="$save_ifs"
2806   if test -z "${found}" && test -n "${tentative_cc}" ; then
2807     CC=$tentative_cc
2808   fi
2809 fi
2810
2811 if test "${build}" != "${host}" ; then
2812   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2813   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2814   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2815   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2816   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2817   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2818   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2819   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2820   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2821   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2822   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2823   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2824 else
2825   AR_FOR_BUILD="\$(AR)"
2826   AS_FOR_BUILD="\$(AS)"
2827   CC_FOR_BUILD="\$(CC)"
2828   CXX_FOR_BUILD="\$(CXX)"
2829   GCJ_FOR_BUILD="\$(GCJ)"
2830   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2831   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2832   LD_FOR_BUILD="\$(LD)"
2833   NM_FOR_BUILD="\$(NM)"
2834   RANLIB_FOR_BUILD="\$(RANLIB)"
2835   WINDRES_FOR_BUILD="\$(WINDRES)"
2836   WINDMC_FOR_BUILD="\$(WINDMC)"
2837 fi
2838
2839 ac_ext=c
2840 ac_cpp='$CPP $CPPFLAGS'
2841 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2842 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2843 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2844 if test -n "$ac_tool_prefix"; then
2845   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2846 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2847 echo "$as_me:$LINENO: checking for $ac_word" >&5
2848 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2849 if test "${ac_cv_prog_CC+set}" = set; then
2850   echo $ECHO_N "(cached) $ECHO_C" >&6
2851 else
2852   if test -n "$CC"; then
2853   ac_cv_prog_CC="$CC" # Let the user override the test.
2854 else
2855 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2856 for as_dir in $PATH
2857 do
2858   IFS=$as_save_IFS
2859   test -z "$as_dir" && as_dir=.
2860   for ac_exec_ext in '' $ac_executable_extensions; do
2861   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2862     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2863     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2864     break 2
2865   fi
2866 done
2867 done
2868
2869 fi
2870 fi
2871 CC=$ac_cv_prog_CC
2872 if test -n "$CC"; then
2873   echo "$as_me:$LINENO: result: $CC" >&5
2874 echo "${ECHO_T}$CC" >&6
2875 else
2876   echo "$as_me:$LINENO: result: no" >&5
2877 echo "${ECHO_T}no" >&6
2878 fi
2879
2880 fi
2881 if test -z "$ac_cv_prog_CC"; then
2882   ac_ct_CC=$CC
2883   # Extract the first word of "gcc", so it can be a program name with args.
2884 set dummy gcc; ac_word=$2
2885 echo "$as_me:$LINENO: checking for $ac_word" >&5
2886 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2887 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2888   echo $ECHO_N "(cached) $ECHO_C" >&6
2889 else
2890   if test -n "$ac_ct_CC"; then
2891   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2892 else
2893 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2894 for as_dir in $PATH
2895 do
2896   IFS=$as_save_IFS
2897   test -z "$as_dir" && as_dir=.
2898   for ac_exec_ext in '' $ac_executable_extensions; do
2899   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2900     ac_cv_prog_ac_ct_CC="gcc"
2901     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2902     break 2
2903   fi
2904 done
2905 done
2906
2907 fi
2908 fi
2909 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2910 if test -n "$ac_ct_CC"; then
2911   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2912 echo "${ECHO_T}$ac_ct_CC" >&6
2913 else
2914   echo "$as_me:$LINENO: result: no" >&5
2915 echo "${ECHO_T}no" >&6
2916 fi
2917
2918   CC=$ac_ct_CC
2919 else
2920   CC="$ac_cv_prog_CC"
2921 fi
2922
2923 if test -z "$CC"; then
2924   if test -n "$ac_tool_prefix"; then
2925   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2926 set dummy ${ac_tool_prefix}cc; ac_word=$2
2927 echo "$as_me:$LINENO: checking for $ac_word" >&5
2928 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2929 if test "${ac_cv_prog_CC+set}" = set; then
2930   echo $ECHO_N "(cached) $ECHO_C" >&6
2931 else
2932   if test -n "$CC"; then
2933   ac_cv_prog_CC="$CC" # Let the user override the test.
2934 else
2935 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2936 for as_dir in $PATH
2937 do
2938   IFS=$as_save_IFS
2939   test -z "$as_dir" && as_dir=.
2940   for ac_exec_ext in '' $ac_executable_extensions; do
2941   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2942     ac_cv_prog_CC="${ac_tool_prefix}cc"
2943     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2944     break 2
2945   fi
2946 done
2947 done
2948
2949 fi
2950 fi
2951 CC=$ac_cv_prog_CC
2952 if test -n "$CC"; then
2953   echo "$as_me:$LINENO: result: $CC" >&5
2954 echo "${ECHO_T}$CC" >&6
2955 else
2956   echo "$as_me:$LINENO: result: no" >&5
2957 echo "${ECHO_T}no" >&6
2958 fi
2959
2960 fi
2961 if test -z "$ac_cv_prog_CC"; then
2962   ac_ct_CC=$CC
2963   # Extract the first word of "cc", so it can be a program name with args.
2964 set dummy cc; ac_word=$2
2965 echo "$as_me:$LINENO: checking for $ac_word" >&5
2966 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2967 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2968   echo $ECHO_N "(cached) $ECHO_C" >&6
2969 else
2970   if test -n "$ac_ct_CC"; then
2971   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2972 else
2973 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2974 for as_dir in $PATH
2975 do
2976   IFS=$as_save_IFS
2977   test -z "$as_dir" && as_dir=.
2978   for ac_exec_ext in '' $ac_executable_extensions; do
2979   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2980     ac_cv_prog_ac_ct_CC="cc"
2981     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2982     break 2
2983   fi
2984 done
2985 done
2986
2987 fi
2988 fi
2989 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2990 if test -n "$ac_ct_CC"; then
2991   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2992 echo "${ECHO_T}$ac_ct_CC" >&6
2993 else
2994   echo "$as_me:$LINENO: result: no" >&5
2995 echo "${ECHO_T}no" >&6
2996 fi
2997
2998   CC=$ac_ct_CC
2999 else
3000   CC="$ac_cv_prog_CC"
3001 fi
3002
3003 fi
3004 if test -z "$CC"; then
3005   # Extract the first word of "cc", so it can be a program name with args.
3006 set dummy cc; ac_word=$2
3007 echo "$as_me:$LINENO: checking for $ac_word" >&5
3008 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3009 if test "${ac_cv_prog_CC+set}" = set; then
3010   echo $ECHO_N "(cached) $ECHO_C" >&6
3011 else
3012   if test -n "$CC"; then
3013   ac_cv_prog_CC="$CC" # Let the user override the test.
3014 else
3015   ac_prog_rejected=no
3016 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3017 for as_dir in $PATH
3018 do
3019   IFS=$as_save_IFS
3020   test -z "$as_dir" && as_dir=.
3021   for ac_exec_ext in '' $ac_executable_extensions; do
3022   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3023     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3024        ac_prog_rejected=yes
3025        continue
3026      fi
3027     ac_cv_prog_CC="cc"
3028     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3029     break 2
3030   fi
3031 done
3032 done
3033
3034 if test $ac_prog_rejected = yes; then
3035   # We found a bogon in the path, so make sure we never use it.
3036   set dummy $ac_cv_prog_CC
3037   shift
3038   if test $# != 0; then
3039     # We chose a different compiler from the bogus one.
3040     # However, it has the same basename, so the bogon will be chosen
3041     # first if we set CC to just the basename; use the full file name.
3042     shift
3043     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3044   fi
3045 fi
3046 fi
3047 fi
3048 CC=$ac_cv_prog_CC
3049 if test -n "$CC"; then
3050   echo "$as_me:$LINENO: result: $CC" >&5
3051 echo "${ECHO_T}$CC" >&6
3052 else
3053   echo "$as_me:$LINENO: result: no" >&5
3054 echo "${ECHO_T}no" >&6
3055 fi
3056
3057 fi
3058 if test -z "$CC"; then
3059   if test -n "$ac_tool_prefix"; then
3060   for ac_prog in cl
3061   do
3062     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3063 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3064 echo "$as_me:$LINENO: checking for $ac_word" >&5
3065 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3066 if test "${ac_cv_prog_CC+set}" = set; then
3067   echo $ECHO_N "(cached) $ECHO_C" >&6
3068 else
3069   if test -n "$CC"; then
3070   ac_cv_prog_CC="$CC" # Let the user override the test.
3071 else
3072 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3073 for as_dir in $PATH
3074 do
3075   IFS=$as_save_IFS
3076   test -z "$as_dir" && as_dir=.
3077   for ac_exec_ext in '' $ac_executable_extensions; do
3078   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3079     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3080     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3081     break 2
3082   fi
3083 done
3084 done
3085
3086 fi
3087 fi
3088 CC=$ac_cv_prog_CC
3089 if test -n "$CC"; then
3090   echo "$as_me:$LINENO: result: $CC" >&5
3091 echo "${ECHO_T}$CC" >&6
3092 else
3093   echo "$as_me:$LINENO: result: no" >&5
3094 echo "${ECHO_T}no" >&6
3095 fi
3096
3097     test -n "$CC" && break
3098   done
3099 fi
3100 if test -z "$CC"; then
3101   ac_ct_CC=$CC
3102   for ac_prog in cl
3103 do
3104   # Extract the first word of "$ac_prog", so it can be a program name with args.
3105 set dummy $ac_prog; ac_word=$2
3106 echo "$as_me:$LINENO: checking for $ac_word" >&5
3107 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3108 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3109   echo $ECHO_N "(cached) $ECHO_C" >&6
3110 else
3111   if test -n "$ac_ct_CC"; then
3112   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3113 else
3114 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3115 for as_dir in $PATH
3116 do
3117   IFS=$as_save_IFS
3118   test -z "$as_dir" && as_dir=.
3119   for ac_exec_ext in '' $ac_executable_extensions; do
3120   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3121     ac_cv_prog_ac_ct_CC="$ac_prog"
3122     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3123     break 2
3124   fi
3125 done
3126 done
3127
3128 fi
3129 fi
3130 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3131 if test -n "$ac_ct_CC"; then
3132   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3133 echo "${ECHO_T}$ac_ct_CC" >&6
3134 else
3135   echo "$as_me:$LINENO: result: no" >&5
3136 echo "${ECHO_T}no" >&6
3137 fi
3138
3139   test -n "$ac_ct_CC" && break
3140 done
3141
3142   CC=$ac_ct_CC
3143 fi
3144
3145 fi
3146
3147
3148 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3149 See \`config.log' for more details." >&5
3150 echo "$as_me: error: no acceptable C compiler found in \$PATH
3151 See \`config.log' for more details." >&2;}
3152    { (exit 1); exit 1; }; }
3153
3154 # Provide some information about the compiler.
3155 echo "$as_me:$LINENO:" \
3156      "checking for C compiler version" >&5
3157 ac_compiler=`set X $ac_compile; echo $2`
3158 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3159   (eval $ac_compiler --version </dev/null >&5) 2>&5
3160   ac_status=$?
3161   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3162   (exit $ac_status); }
3163 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3164   (eval $ac_compiler -v </dev/null >&5) 2>&5
3165   ac_status=$?
3166   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3167   (exit $ac_status); }
3168 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3169   (eval $ac_compiler -V </dev/null >&5) 2>&5
3170   ac_status=$?
3171   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3172   (exit $ac_status); }
3173
3174 cat >conftest.$ac_ext <<_ACEOF
3175 /* confdefs.h.  */
3176 _ACEOF
3177 cat confdefs.h >>conftest.$ac_ext
3178 cat >>conftest.$ac_ext <<_ACEOF
3179 /* end confdefs.h.  */
3180
3181 int
3182 main ()
3183 {
3184
3185   ;
3186   return 0;
3187 }
3188 _ACEOF
3189 ac_clean_files_save=$ac_clean_files
3190 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3191 # Try to create an executable without -o first, disregard a.out.
3192 # It will help us diagnose broken compilers, and finding out an intuition
3193 # of exeext.
3194 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3195 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3196 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3197 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3198   (eval $ac_link_default) 2>&5
3199   ac_status=$?
3200   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3201   (exit $ac_status); }; then
3202   # Find the output, starting from the most likely.  This scheme is
3203 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3204 # resort.
3205
3206 # Be careful to initialize this variable, since it used to be cached.
3207 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3208 ac_cv_exeext=
3209 # b.out is created by i960 compilers.
3210 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3211 do
3212   test -f "$ac_file" || continue
3213   case $ac_file in
3214     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3215         ;;
3216     conftest.$ac_ext )
3217         # This is the source file.
3218         ;;
3219     [ab].out )
3220         # We found the default executable, but exeext='' is most
3221         # certainly right.
3222         break;;
3223     *.* )
3224         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3225         # FIXME: I believe we export ac_cv_exeext for Libtool,
3226         # but it would be cool to find out if it's true.  Does anybody
3227         # maintain Libtool? --akim.
3228         export ac_cv_exeext
3229         break;;
3230     * )
3231         break;;
3232   esac
3233 done
3234 else
3235   echo "$as_me: failed program was:" >&5
3236 sed 's/^/| /' conftest.$ac_ext >&5
3237
3238 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3239 See \`config.log' for more details." >&5
3240 echo "$as_me: error: C compiler cannot create executables
3241 See \`config.log' for more details." >&2;}
3242    { (exit 77); exit 77; }; }
3243 fi
3244
3245 ac_exeext=$ac_cv_exeext
3246 echo "$as_me:$LINENO: result: $ac_file" >&5
3247 echo "${ECHO_T}$ac_file" >&6
3248
3249 # Check the compiler produces executables we can run.  If not, either
3250 # the compiler is broken, or we cross compile.
3251 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3252 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3253 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3254 # If not cross compiling, check that we can run a simple program.
3255 if test "$cross_compiling" != yes; then
3256   if { ac_try='./$ac_file'
3257   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3258   (eval $ac_try) 2>&5
3259   ac_status=$?
3260   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3261   (exit $ac_status); }; }; then
3262     cross_compiling=no
3263   else
3264     if test "$cross_compiling" = maybe; then
3265         cross_compiling=yes
3266     else
3267         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3268 If you meant to cross compile, use \`--host'.
3269 See \`config.log' for more details." >&5
3270 echo "$as_me: error: cannot run C compiled programs.
3271 If you meant to cross compile, use \`--host'.
3272 See \`config.log' for more details." >&2;}
3273    { (exit 1); exit 1; }; }
3274     fi
3275   fi
3276 fi
3277 echo "$as_me:$LINENO: result: yes" >&5
3278 echo "${ECHO_T}yes" >&6
3279
3280 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3281 ac_clean_files=$ac_clean_files_save
3282 # Check the compiler produces executables we can run.  If not, either
3283 # the compiler is broken, or we cross compile.
3284 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3285 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3286 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3287 echo "${ECHO_T}$cross_compiling" >&6
3288
3289 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3290 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3291 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3292   (eval $ac_link) 2>&5
3293   ac_status=$?
3294   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3295   (exit $ac_status); }; then
3296   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3297 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3298 # work properly (i.e., refer to `conftest.exe'), while it won't with
3299 # `rm'.
3300 for ac_file in conftest.exe conftest conftest.*; do
3301   test -f "$ac_file" || continue
3302   case $ac_file in
3303     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3304     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3305           export ac_cv_exeext
3306           break;;
3307     * ) break;;
3308   esac
3309 done
3310 else
3311   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3312 See \`config.log' for more details." >&5
3313 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3314 See \`config.log' for more details." >&2;}
3315    { (exit 1); exit 1; }; }
3316 fi
3317
3318 rm -f conftest$ac_cv_exeext
3319 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3320 echo "${ECHO_T}$ac_cv_exeext" >&6
3321
3322 rm -f conftest.$ac_ext
3323 EXEEXT=$ac_cv_exeext
3324 ac_exeext=$EXEEXT
3325 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3326 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3327 if test "${ac_cv_objext+set}" = set; then
3328   echo $ECHO_N "(cached) $ECHO_C" >&6
3329 else
3330   cat >conftest.$ac_ext <<_ACEOF
3331 /* confdefs.h.  */
3332 _ACEOF
3333 cat confdefs.h >>conftest.$ac_ext
3334 cat >>conftest.$ac_ext <<_ACEOF
3335 /* end confdefs.h.  */
3336
3337 int
3338 main ()
3339 {
3340
3341   ;
3342   return 0;
3343 }
3344 _ACEOF
3345 rm -f conftest.o conftest.obj
3346 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3347   (eval $ac_compile) 2>&5
3348   ac_status=$?
3349   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3350   (exit $ac_status); }; then
3351   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3352   case $ac_file in
3353     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3354     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3355        break;;
3356   esac
3357 done
3358 else
3359   echo "$as_me: failed program was:" >&5
3360 sed 's/^/| /' conftest.$ac_ext >&5
3361
3362 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3363 See \`config.log' for more details." >&5
3364 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3365 See \`config.log' for more details." >&2;}
3366    { (exit 1); exit 1; }; }
3367 fi
3368
3369 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3370 fi
3371 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3372 echo "${ECHO_T}$ac_cv_objext" >&6
3373 OBJEXT=$ac_cv_objext
3374 ac_objext=$OBJEXT
3375 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3376 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3377 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3378   echo $ECHO_N "(cached) $ECHO_C" >&6
3379 else
3380   cat >conftest.$ac_ext <<_ACEOF
3381 /* confdefs.h.  */
3382 _ACEOF
3383 cat confdefs.h >>conftest.$ac_ext
3384 cat >>conftest.$ac_ext <<_ACEOF
3385 /* end confdefs.h.  */
3386
3387 int
3388 main ()
3389 {
3390 #ifndef __GNUC__
3391        choke me
3392 #endif
3393
3394   ;
3395   return 0;
3396 }
3397 _ACEOF
3398 rm -f conftest.$ac_objext
3399 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3400   (eval $ac_compile) 2>conftest.er1
3401   ac_status=$?
3402   grep -v '^ *+' conftest.er1 >conftest.err
3403   rm -f conftest.er1
3404   cat conftest.err >&5
3405   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3406   (exit $ac_status); } &&
3407          { ac_try='test -z "$ac_c_werror_flag"
3408                          || test ! -s conftest.err'
3409   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3410   (eval $ac_try) 2>&5
3411   ac_status=$?
3412   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3413   (exit $ac_status); }; } &&
3414          { ac_try='test -s conftest.$ac_objext'
3415   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3416   (eval $ac_try) 2>&5
3417   ac_status=$?
3418   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3419   (exit $ac_status); }; }; then
3420   ac_compiler_gnu=yes
3421 else
3422   echo "$as_me: failed program was:" >&5
3423 sed 's/^/| /' conftest.$ac_ext >&5
3424
3425 ac_compiler_gnu=no
3426 fi
3427 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3428 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3429
3430 fi
3431 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3432 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3433 GCC=`test $ac_compiler_gnu = yes && echo yes`
3434 ac_test_CFLAGS=${CFLAGS+set}
3435 ac_save_CFLAGS=$CFLAGS
3436 CFLAGS="-g"
3437 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3438 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3439 if test "${ac_cv_prog_cc_g+set}" = set; then
3440   echo $ECHO_N "(cached) $ECHO_C" >&6
3441 else
3442   cat >conftest.$ac_ext <<_ACEOF
3443 /* confdefs.h.  */
3444 _ACEOF
3445 cat confdefs.h >>conftest.$ac_ext
3446 cat >>conftest.$ac_ext <<_ACEOF
3447 /* end confdefs.h.  */
3448
3449 int
3450 main ()
3451 {
3452
3453   ;
3454   return 0;
3455 }
3456 _ACEOF
3457 rm -f conftest.$ac_objext
3458 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3459   (eval $ac_compile) 2>conftest.er1
3460   ac_status=$?
3461   grep -v '^ *+' conftest.er1 >conftest.err
3462   rm -f conftest.er1
3463   cat conftest.err >&5
3464   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3465   (exit $ac_status); } &&
3466          { ac_try='test -z "$ac_c_werror_flag"
3467                          || test ! -s conftest.err'
3468   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3469   (eval $ac_try) 2>&5
3470   ac_status=$?
3471   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3472   (exit $ac_status); }; } &&
3473          { ac_try='test -s conftest.$ac_objext'
3474   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3475   (eval $ac_try) 2>&5
3476   ac_status=$?
3477   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3478   (exit $ac_status); }; }; then
3479   ac_cv_prog_cc_g=yes
3480 else
3481   echo "$as_me: failed program was:" >&5
3482 sed 's/^/| /' conftest.$ac_ext >&5
3483
3484 ac_cv_prog_cc_g=no
3485 fi
3486 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3487 fi
3488 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3489 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3490 if test "$ac_test_CFLAGS" = set; then
3491   CFLAGS=$ac_save_CFLAGS
3492 elif test $ac_cv_prog_cc_g = yes; then
3493   if test "$GCC" = yes; then
3494     CFLAGS="-g -O2"
3495   else
3496     CFLAGS="-g"
3497   fi
3498 else
3499   if test "$GCC" = yes; then
3500     CFLAGS="-O2"
3501   else
3502     CFLAGS=
3503   fi
3504 fi
3505 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3506 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3507 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3508   echo $ECHO_N "(cached) $ECHO_C" >&6
3509 else
3510   ac_cv_prog_cc_stdc=no
3511 ac_save_CC=$CC
3512 cat >conftest.$ac_ext <<_ACEOF
3513 /* confdefs.h.  */
3514 _ACEOF
3515 cat confdefs.h >>conftest.$ac_ext
3516 cat >>conftest.$ac_ext <<_ACEOF
3517 /* end confdefs.h.  */
3518 #include <stdarg.h>
3519 #include <stdio.h>
3520 #include <sys/types.h>
3521 #include <sys/stat.h>
3522 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3523 struct buf { int x; };
3524 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3525 static char *e (p, i)
3526      char **p;
3527      int i;
3528 {
3529   return p[i];
3530 }
3531 static char *f (char * (*g) (char **, int), char **p, ...)
3532 {
3533   char *s;
3534   va_list v;
3535   va_start (v,p);
3536   s = g (p, va_arg (v,int));
3537   va_end (v);
3538   return s;
3539 }
3540
3541 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3542    function prototypes and stuff, but not '\xHH' hex character constants.
3543    These don't provoke an error unfortunately, instead are silently treated
3544    as 'x'.  The following induces an error, until -std1 is added to get
3545    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3546    array size at least.  It's necessary to write '\x00'==0 to get something
3547    that's true only with -std1.  */
3548 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3549
3550 int test (int i, double x);
3551 struct s1 {int (*f) (int a);};
3552 struct s2 {int (*f) (double a);};
3553 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3554 int argc;
3555 char **argv;
3556 int
3557 main ()
3558 {
3559 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3560   ;
3561   return 0;
3562 }
3563 _ACEOF
3564 # Don't try gcc -ansi; that turns off useful extensions and
3565 # breaks some systems' header files.
3566 # AIX                   -qlanglvl=ansi
3567 # Ultrix and OSF/1      -std1
3568 # HP-UX 10.20 and later -Ae
3569 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3570 # SVR4                  -Xc -D__EXTENSIONS__
3571 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3572 do
3573   CC="$ac_save_CC $ac_arg"
3574   rm -f conftest.$ac_objext
3575 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3576   (eval $ac_compile) 2>conftest.er1
3577   ac_status=$?
3578   grep -v '^ *+' conftest.er1 >conftest.err
3579   rm -f conftest.er1
3580   cat conftest.err >&5
3581   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3582   (exit $ac_status); } &&
3583          { ac_try='test -z "$ac_c_werror_flag"
3584                          || test ! -s conftest.err'
3585   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3586   (eval $ac_try) 2>&5
3587   ac_status=$?
3588   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3589   (exit $ac_status); }; } &&
3590          { ac_try='test -s conftest.$ac_objext'
3591   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3592   (eval $ac_try) 2>&5
3593   ac_status=$?
3594   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3595   (exit $ac_status); }; }; then
3596   ac_cv_prog_cc_stdc=$ac_arg
3597 break
3598 else
3599   echo "$as_me: failed program was:" >&5
3600 sed 's/^/| /' conftest.$ac_ext >&5
3601
3602 fi
3603 rm -f conftest.err conftest.$ac_objext
3604 done
3605 rm -f conftest.$ac_ext conftest.$ac_objext
3606 CC=$ac_save_CC
3607
3608 fi
3609
3610 case "x$ac_cv_prog_cc_stdc" in
3611   x|xno)
3612     echo "$as_me:$LINENO: result: none needed" >&5
3613 echo "${ECHO_T}none needed" >&6 ;;
3614   *)
3615     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3616 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3617     CC="$CC $ac_cv_prog_cc_stdc" ;;
3618 esac
3619
3620 # Some people use a C++ compiler to compile C.  Since we use `exit',
3621 # in C++ we need to declare it.  In case someone uses the same compiler
3622 # for both compiling C and C++ we need to have the C++ compiler decide
3623 # the declaration of exit, since it's the most demanding environment.
3624 cat >conftest.$ac_ext <<_ACEOF
3625 #ifndef __cplusplus
3626   choke me
3627 #endif
3628 _ACEOF
3629 rm -f conftest.$ac_objext
3630 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3631   (eval $ac_compile) 2>conftest.er1
3632   ac_status=$?
3633   grep -v '^ *+' conftest.er1 >conftest.err
3634   rm -f conftest.er1
3635   cat conftest.err >&5
3636   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3637   (exit $ac_status); } &&
3638          { ac_try='test -z "$ac_c_werror_flag"
3639                          || test ! -s conftest.err'
3640   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3641   (eval $ac_try) 2>&5
3642   ac_status=$?
3643   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3644   (exit $ac_status); }; } &&
3645          { ac_try='test -s conftest.$ac_objext'
3646   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3647   (eval $ac_try) 2>&5
3648   ac_status=$?
3649   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3650   (exit $ac_status); }; }; then
3651   for ac_declaration in \
3652    '' \
3653    'extern "C" void std::exit (int) throw (); using std::exit;' \
3654    'extern "C" void std::exit (int); using std::exit;' \
3655    'extern "C" void exit (int) throw ();' \
3656    'extern "C" void exit (int);' \
3657    'void exit (int);'
3658 do
3659   cat >conftest.$ac_ext <<_ACEOF
3660 /* confdefs.h.  */
3661 _ACEOF
3662 cat confdefs.h >>conftest.$ac_ext
3663 cat >>conftest.$ac_ext <<_ACEOF
3664 /* end confdefs.h.  */
3665 $ac_declaration
3666 #include <stdlib.h>
3667 int
3668 main ()
3669 {
3670 exit (42);
3671   ;
3672   return 0;
3673 }
3674 _ACEOF
3675 rm -f conftest.$ac_objext
3676 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3677   (eval $ac_compile) 2>conftest.er1
3678   ac_status=$?
3679   grep -v '^ *+' conftest.er1 >conftest.err
3680   rm -f conftest.er1
3681   cat conftest.err >&5
3682   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3683   (exit $ac_status); } &&
3684          { ac_try='test -z "$ac_c_werror_flag"
3685                          || test ! -s conftest.err'
3686   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3687   (eval $ac_try) 2>&5
3688   ac_status=$?
3689   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3690   (exit $ac_status); }; } &&
3691          { ac_try='test -s conftest.$ac_objext'
3692   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3693   (eval $ac_try) 2>&5
3694   ac_status=$?
3695   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3696   (exit $ac_status); }; }; then
3697   :
3698 else
3699   echo "$as_me: failed program was:" >&5
3700 sed 's/^/| /' conftest.$ac_ext >&5
3701
3702 continue
3703 fi
3704 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3705   cat >conftest.$ac_ext <<_ACEOF
3706 /* confdefs.h.  */
3707 _ACEOF
3708 cat confdefs.h >>conftest.$ac_ext
3709 cat >>conftest.$ac_ext <<_ACEOF
3710 /* end confdefs.h.  */
3711 $ac_declaration
3712 int
3713 main ()
3714 {
3715 exit (42);
3716   ;
3717   return 0;
3718 }
3719 _ACEOF
3720 rm -f conftest.$ac_objext
3721 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3722   (eval $ac_compile) 2>conftest.er1
3723   ac_status=$?
3724   grep -v '^ *+' conftest.er1 >conftest.err
3725   rm -f conftest.er1
3726   cat conftest.err >&5
3727   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3728   (exit $ac_status); } &&
3729          { ac_try='test -z "$ac_c_werror_flag"
3730                          || test ! -s conftest.err'
3731   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3732   (eval $ac_try) 2>&5
3733   ac_status=$?
3734   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3735   (exit $ac_status); }; } &&
3736          { ac_try='test -s conftest.$ac_objext'
3737   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3738   (eval $ac_try) 2>&5
3739   ac_status=$?
3740   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3741   (exit $ac_status); }; }; then
3742   break
3743 else
3744   echo "$as_me: failed program was:" >&5
3745 sed 's/^/| /' conftest.$ac_ext >&5
3746
3747 fi
3748 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3749 done
3750 rm -f conftest*
3751 if test -n "$ac_declaration"; then
3752   echo '#ifdef __cplusplus' >>confdefs.h
3753   echo $ac_declaration      >>confdefs.h
3754   echo '#endif'             >>confdefs.h
3755 fi
3756
3757 else
3758   echo "$as_me: failed program was:" >&5
3759 sed 's/^/| /' conftest.$ac_ext >&5
3760
3761 fi
3762 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3763 ac_ext=c
3764 ac_cpp='$CPP $CPPFLAGS'
3765 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3766 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3767 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3768
3769 ac_ext=cc
3770 ac_cpp='$CXXCPP $CPPFLAGS'
3771 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3772 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3773 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3774 if test -n "$ac_tool_prefix"; then
3775   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3776   do
3777     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3778 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3779 echo "$as_me:$LINENO: checking for $ac_word" >&5
3780 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3781 if test "${ac_cv_prog_CXX+set}" = set; then
3782   echo $ECHO_N "(cached) $ECHO_C" >&6
3783 else
3784   if test -n "$CXX"; then
3785   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3786 else
3787 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3788 for as_dir in $PATH
3789 do
3790   IFS=$as_save_IFS
3791   test -z "$as_dir" && as_dir=.
3792   for ac_exec_ext in '' $ac_executable_extensions; do
3793   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3794     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3795     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3796     break 2
3797   fi
3798 done
3799 done
3800
3801 fi
3802 fi
3803 CXX=$ac_cv_prog_CXX
3804 if test -n "$CXX"; then
3805   echo "$as_me:$LINENO: result: $CXX" >&5
3806 echo "${ECHO_T}$CXX" >&6
3807 else
3808   echo "$as_me:$LINENO: result: no" >&5
3809 echo "${ECHO_T}no" >&6
3810 fi
3811
3812     test -n "$CXX" && break
3813   done
3814 fi
3815 if test -z "$CXX"; then
3816   ac_ct_CXX=$CXX
3817   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3818 do
3819   # Extract the first word of "$ac_prog", so it can be a program name with args.
3820 set dummy $ac_prog; ac_word=$2
3821 echo "$as_me:$LINENO: checking for $ac_word" >&5
3822 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3823 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3824   echo $ECHO_N "(cached) $ECHO_C" >&6
3825 else
3826   if test -n "$ac_ct_CXX"; then
3827   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3828 else
3829 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3830 for as_dir in $PATH
3831 do
3832   IFS=$as_save_IFS
3833   test -z "$as_dir" && as_dir=.
3834   for ac_exec_ext in '' $ac_executable_extensions; do
3835   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3836     ac_cv_prog_ac_ct_CXX="$ac_prog"
3837     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3838     break 2
3839   fi
3840 done
3841 done
3842
3843 fi
3844 fi
3845 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3846 if test -n "$ac_ct_CXX"; then
3847   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3848 echo "${ECHO_T}$ac_ct_CXX" >&6
3849 else
3850   echo "$as_me:$LINENO: result: no" >&5
3851 echo "${ECHO_T}no" >&6
3852 fi
3853
3854   test -n "$ac_ct_CXX" && break
3855 done
3856 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3857
3858   CXX=$ac_ct_CXX
3859 fi
3860
3861
3862 # Provide some information about the compiler.
3863 echo "$as_me:$LINENO:" \
3864      "checking for C++ compiler version" >&5
3865 ac_compiler=`set X $ac_compile; echo $2`
3866 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3867   (eval $ac_compiler --version </dev/null >&5) 2>&5
3868   ac_status=$?
3869   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3870   (exit $ac_status); }
3871 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3872   (eval $ac_compiler -v </dev/null >&5) 2>&5
3873   ac_status=$?
3874   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3875   (exit $ac_status); }
3876 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3877   (eval $ac_compiler -V </dev/null >&5) 2>&5
3878   ac_status=$?
3879   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3880   (exit $ac_status); }
3881
3882 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3883 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3884 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3885   echo $ECHO_N "(cached) $ECHO_C" >&6
3886 else
3887   cat >conftest.$ac_ext <<_ACEOF
3888 /* confdefs.h.  */
3889 _ACEOF
3890 cat confdefs.h >>conftest.$ac_ext
3891 cat >>conftest.$ac_ext <<_ACEOF
3892 /* end confdefs.h.  */
3893
3894 int
3895 main ()
3896 {
3897 #ifndef __GNUC__
3898        choke me
3899 #endif
3900
3901   ;
3902   return 0;
3903 }
3904 _ACEOF
3905 rm -f conftest.$ac_objext
3906 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3907   (eval $ac_compile) 2>conftest.er1
3908   ac_status=$?
3909   grep -v '^ *+' conftest.er1 >conftest.err
3910   rm -f conftest.er1
3911   cat conftest.err >&5
3912   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3913   (exit $ac_status); } &&
3914          { ac_try='test -z "$ac_cxx_werror_flag"
3915                          || test ! -s conftest.err'
3916   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3917   (eval $ac_try) 2>&5
3918   ac_status=$?
3919   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3920   (exit $ac_status); }; } &&
3921          { ac_try='test -s conftest.$ac_objext'
3922   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3923   (eval $ac_try) 2>&5
3924   ac_status=$?
3925   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3926   (exit $ac_status); }; }; then
3927   ac_compiler_gnu=yes
3928 else
3929   echo "$as_me: failed program was:" >&5
3930 sed 's/^/| /' conftest.$ac_ext >&5
3931
3932 ac_compiler_gnu=no
3933 fi
3934 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3935 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3936
3937 fi
3938 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3939 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
3940 GXX=`test $ac_compiler_gnu = yes && echo yes`
3941 ac_test_CXXFLAGS=${CXXFLAGS+set}
3942 ac_save_CXXFLAGS=$CXXFLAGS
3943 CXXFLAGS="-g"
3944 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3945 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
3946 if test "${ac_cv_prog_cxx_g+set}" = set; then
3947   echo $ECHO_N "(cached) $ECHO_C" >&6
3948 else
3949   cat >conftest.$ac_ext <<_ACEOF
3950 /* confdefs.h.  */
3951 _ACEOF
3952 cat confdefs.h >>conftest.$ac_ext
3953 cat >>conftest.$ac_ext <<_ACEOF
3954 /* end confdefs.h.  */
3955
3956 int
3957 main ()
3958 {
3959
3960   ;
3961   return 0;
3962 }
3963 _ACEOF
3964 rm -f conftest.$ac_objext
3965 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3966   (eval $ac_compile) 2>conftest.er1
3967   ac_status=$?
3968   grep -v '^ *+' conftest.er1 >conftest.err
3969   rm -f conftest.er1
3970   cat conftest.err >&5
3971   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3972   (exit $ac_status); } &&
3973          { ac_try='test -z "$ac_cxx_werror_flag"
3974                          || test ! -s conftest.err'
3975   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3976   (eval $ac_try) 2>&5
3977   ac_status=$?
3978   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3979   (exit $ac_status); }; } &&
3980          { ac_try='test -s conftest.$ac_objext'
3981   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3982   (eval $ac_try) 2>&5
3983   ac_status=$?
3984   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3985   (exit $ac_status); }; }; then
3986   ac_cv_prog_cxx_g=yes
3987 else
3988   echo "$as_me: failed program was:" >&5
3989 sed 's/^/| /' conftest.$ac_ext >&5
3990
3991 ac_cv_prog_cxx_g=no
3992 fi
3993 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3994 fi
3995 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3996 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
3997 if test "$ac_test_CXXFLAGS" = set; then
3998   CXXFLAGS=$ac_save_CXXFLAGS
3999 elif test $ac_cv_prog_cxx_g = yes; then
4000   if test "$GXX" = yes; then
4001     CXXFLAGS="-g -O2"
4002   else
4003     CXXFLAGS="-g"
4004   fi
4005 else
4006   if test "$GXX" = yes; then
4007     CXXFLAGS="-O2"
4008   else
4009     CXXFLAGS=
4010   fi
4011 fi
4012 for ac_declaration in \
4013    '' \
4014    'extern "C" void std::exit (int) throw (); using std::exit;' \
4015    'extern "C" void std::exit (int); using std::exit;' \
4016    'extern "C" void exit (int) throw ();' \
4017    'extern "C" void exit (int);' \
4018    'void exit (int);'
4019 do
4020   cat >conftest.$ac_ext <<_ACEOF
4021 /* confdefs.h.  */
4022 _ACEOF
4023 cat confdefs.h >>conftest.$ac_ext
4024 cat >>conftest.$ac_ext <<_ACEOF
4025 /* end confdefs.h.  */
4026 $ac_declaration
4027 #include <stdlib.h>
4028 int
4029 main ()
4030 {
4031 exit (42);
4032   ;
4033   return 0;
4034 }
4035 _ACEOF
4036 rm -f conftest.$ac_objext
4037 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4038   (eval $ac_compile) 2>conftest.er1
4039   ac_status=$?
4040   grep -v '^ *+' conftest.er1 >conftest.err
4041   rm -f conftest.er1
4042   cat conftest.err >&5
4043   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4044   (exit $ac_status); } &&
4045          { ac_try='test -z "$ac_cxx_werror_flag"
4046                          || test ! -s conftest.err'
4047   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4048   (eval $ac_try) 2>&5
4049   ac_status=$?
4050   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4051   (exit $ac_status); }; } &&
4052          { ac_try='test -s conftest.$ac_objext'
4053   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4054   (eval $ac_try) 2>&5
4055   ac_status=$?
4056   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4057   (exit $ac_status); }; }; then
4058   :
4059 else
4060   echo "$as_me: failed program was:" >&5
4061 sed 's/^/| /' conftest.$ac_ext >&5
4062
4063 continue
4064 fi
4065 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4066   cat >conftest.$ac_ext <<_ACEOF
4067 /* confdefs.h.  */
4068 _ACEOF
4069 cat confdefs.h >>conftest.$ac_ext
4070 cat >>conftest.$ac_ext <<_ACEOF
4071 /* end confdefs.h.  */
4072 $ac_declaration
4073 int
4074 main ()
4075 {
4076 exit (42);
4077   ;
4078   return 0;
4079 }
4080 _ACEOF
4081 rm -f conftest.$ac_objext
4082 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4083   (eval $ac_compile) 2>conftest.er1
4084   ac_status=$?
4085   grep -v '^ *+' conftest.er1 >conftest.err
4086   rm -f conftest.er1
4087   cat conftest.err >&5
4088   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4089   (exit $ac_status); } &&
4090          { ac_try='test -z "$ac_cxx_werror_flag"
4091                          || test ! -s conftest.err'
4092   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4093   (eval $ac_try) 2>&5
4094   ac_status=$?
4095   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4096   (exit $ac_status); }; } &&
4097          { ac_try='test -s conftest.$ac_objext'
4098   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4099   (eval $ac_try) 2>&5
4100   ac_status=$?
4101   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4102   (exit $ac_status); }; }; then
4103   break
4104 else
4105   echo "$as_me: failed program was:" >&5
4106 sed 's/^/| /' conftest.$ac_ext >&5
4107
4108 fi
4109 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4110 done
4111 rm -f conftest*
4112 if test -n "$ac_declaration"; then
4113   echo '#ifdef __cplusplus' >>confdefs.h
4114   echo $ac_declaration      >>confdefs.h
4115   echo '#endif'             >>confdefs.h
4116 fi
4117
4118 ac_ext=c
4119 ac_cpp='$CPP $CPPFLAGS'
4120 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4121 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4122 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4123
4124
4125 # We must set the default linker to the linker used by gcc for the correct
4126 # operation of libtool.  If LD is not defined and we are using gcc, try to
4127 # set the LD default to the ld used by gcc.
4128 if test -z "$LD"; then
4129   if test "$GCC" = yes; then
4130     case $build in
4131     *-*-mingw*)
4132       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4133     *)
4134       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4135     esac
4136     case $gcc_prog_ld in
4137     # Accept absolute paths.
4138     [\\/]* | [A-Za-z]:[\\/]*)
4139       LD="$gcc_prog_ld" ;;
4140     esac
4141   fi
4142 fi
4143
4144
4145
4146
4147 if test -n "$ac_tool_prefix"; then
4148   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4149 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4150 echo "$as_me:$LINENO: checking for $ac_word" >&5
4151 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4152 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4153   echo $ECHO_N "(cached) $ECHO_C" >&6
4154 else
4155   if test -n "$GNATBIND"; then
4156   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4157 else
4158 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4159 for as_dir in $PATH
4160 do
4161   IFS=$as_save_IFS
4162   test -z "$as_dir" && as_dir=.
4163   for ac_exec_ext in '' $ac_executable_extensions; do
4164   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4165     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4166     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4167     break 2
4168   fi
4169 done
4170 done
4171
4172 fi
4173 fi
4174 GNATBIND=$ac_cv_prog_GNATBIND
4175 if test -n "$GNATBIND"; then
4176   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4177 echo "${ECHO_T}$GNATBIND" >&6
4178 else
4179   echo "$as_me:$LINENO: result: no" >&5
4180 echo "${ECHO_T}no" >&6
4181 fi
4182
4183 fi
4184 if test -z "$ac_cv_prog_GNATBIND"; then
4185   ac_ct_GNATBIND=$GNATBIND
4186   # Extract the first word of "gnatbind", so it can be a program name with args.
4187 set dummy gnatbind; ac_word=$2
4188 echo "$as_me:$LINENO: checking for $ac_word" >&5
4189 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4190 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4191   echo $ECHO_N "(cached) $ECHO_C" >&6
4192 else
4193   if test -n "$ac_ct_GNATBIND"; then
4194   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4195 else
4196 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4197 for as_dir in $PATH
4198 do
4199   IFS=$as_save_IFS
4200   test -z "$as_dir" && as_dir=.
4201   for ac_exec_ext in '' $ac_executable_extensions; do
4202   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4203     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4204     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4205     break 2
4206   fi
4207 done
4208 done
4209
4210   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4211 fi
4212 fi
4213 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4214 if test -n "$ac_ct_GNATBIND"; then
4215   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4216 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4217 else
4218   echo "$as_me:$LINENO: result: no" >&5
4219 echo "${ECHO_T}no" >&6
4220 fi
4221
4222   GNATBIND=$ac_ct_GNATBIND
4223 else
4224   GNATBIND="$ac_cv_prog_GNATBIND"
4225 fi
4226
4227 if test -n "$ac_tool_prefix"; then
4228   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4229 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4230 echo "$as_me:$LINENO: checking for $ac_word" >&5
4231 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4232 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4233   echo $ECHO_N "(cached) $ECHO_C" >&6
4234 else
4235   if test -n "$GNATMAKE"; then
4236   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4237 else
4238 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4239 for as_dir in $PATH
4240 do
4241   IFS=$as_save_IFS
4242   test -z "$as_dir" && as_dir=.
4243   for ac_exec_ext in '' $ac_executable_extensions; do
4244   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4245     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4246     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4247     break 2
4248   fi
4249 done
4250 done
4251
4252 fi
4253 fi
4254 GNATMAKE=$ac_cv_prog_GNATMAKE
4255 if test -n "$GNATMAKE"; then
4256   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4257 echo "${ECHO_T}$GNATMAKE" >&6
4258 else
4259   echo "$as_me:$LINENO: result: no" >&5
4260 echo "${ECHO_T}no" >&6
4261 fi
4262
4263 fi
4264 if test -z "$ac_cv_prog_GNATMAKE"; then
4265   ac_ct_GNATMAKE=$GNATMAKE
4266   # Extract the first word of "gnatmake", so it can be a program name with args.
4267 set dummy gnatmake; ac_word=$2
4268 echo "$as_me:$LINENO: checking for $ac_word" >&5
4269 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4270 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4271   echo $ECHO_N "(cached) $ECHO_C" >&6
4272 else
4273   if test -n "$ac_ct_GNATMAKE"; then
4274   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4275 else
4276 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4277 for as_dir in $PATH
4278 do
4279   IFS=$as_save_IFS
4280   test -z "$as_dir" && as_dir=.
4281   for ac_exec_ext in '' $ac_executable_extensions; do
4282   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4283     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4284     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4285     break 2
4286   fi
4287 done
4288 done
4289
4290   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4291 fi
4292 fi
4293 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4294 if test -n "$ac_ct_GNATMAKE"; then
4295   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4296 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4297 else
4298   echo "$as_me:$LINENO: result: no" >&5
4299 echo "${ECHO_T}no" >&6
4300 fi
4301
4302   GNATMAKE=$ac_ct_GNATMAKE
4303 else
4304   GNATMAKE="$ac_cv_prog_GNATMAKE"
4305 fi
4306
4307 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4308 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4309 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4310   echo $ECHO_N "(cached) $ECHO_C" >&6
4311 else
4312   cat >conftest.adb <<EOF
4313 procedure conftest is begin null; end conftest;
4314 EOF
4315 acx_cv_cc_gcc_supports_ada=no
4316 # There is a bug in old released versions of GCC which causes the
4317 # driver to exit successfully when the appropriate language module
4318 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4319 # Therefore we must check for the error message as well as an
4320 # unsuccessful exit.
4321 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4322 # given a .adb file, but produce no object file.  So we must check
4323 # if an object file was really produced to guard against this.
4324 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4325 if test x"$errors" = x && test -f conftest.$ac_objext; then
4326   acx_cv_cc_gcc_supports_ada=yes
4327 fi
4328 rm -f conftest.*
4329 fi
4330 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4331 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4332
4333 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4334   have_gnat=yes
4335 else
4336   have_gnat=no
4337 fi
4338
4339 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4340 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4341 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4342   echo $ECHO_N "(cached) $ECHO_C" >&6
4343 else
4344    echo abfoo >t1
4345   echo cdfoo >t2
4346   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4347   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4348     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4349       :
4350     else
4351       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4352     fi
4353   fi
4354   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4355     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4356       :
4357     else
4358       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4359     fi
4360   fi
4361   rm t1 t2
4362
4363 fi
4364 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4365 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4366 do_compare="$gcc_cv_prog_cmp_skip"
4367
4368
4369
4370 # Check for GMP and MPFR
4371 gmplibs="-lmpfr -lgmp"
4372 gmpinc=
4373 have_gmp=no
4374
4375 # Specify a location for mpfr
4376 # check for this first so it ends up on the link line before gmp.
4377
4378 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4379 if test "${with_mpfr_dir+set}" = set; then
4380   withval="$with_mpfr_dir"
4381   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4382 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4383 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4384 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4385    { (exit 1); exit 1; }; }
4386 fi;
4387
4388
4389 # Check whether --with-mpfr or --without-mpfr was given.
4390 if test "${with_mpfr+set}" = set; then
4391   withval="$with_mpfr"
4392
4393 fi;
4394
4395 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4396 if test "${with_mpfr_include+set}" = set; then
4397   withval="$with_mpfr_include"
4398
4399 fi;
4400
4401 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4402 if test "${with_mpfr_lib+set}" = set; then
4403   withval="$with_mpfr_lib"
4404
4405 fi;
4406
4407 if test "x$with_mpfr" != x; then
4408   gmplibs="-L$with_mpfr/lib $gmplibs"
4409   gmpinc="-I$with_mpfr/include"
4410 fi
4411 if test "x$with_mpfr_include" != x; then
4412   gmpinc="-I$with_mpfr_include"
4413 fi
4414 if test "x$with_mpfr_lib" != x; then
4415   gmplibs="-L$with_mpfr_lib $gmplibs"
4416 fi
4417 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4418   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4419   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4420   # Do not test the mpfr version.  Assume that it is sufficient, since
4421   # it is in the source tree, and the library has not been built yet
4422   # but it would be included on the link line in the version check below
4423   # hence making the test fail.
4424   have_gmp=yes
4425 fi
4426
4427 # Specify a location for gmp
4428
4429 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4430 if test "${with_gmp_dir+set}" = set; then
4431   withval="$with_gmp_dir"
4432   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4433 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4434 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4435 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4436    { (exit 1); exit 1; }; }
4437 fi;
4438
4439
4440 # Check whether --with-gmp or --without-gmp was given.
4441 if test "${with_gmp+set}" = set; then
4442   withval="$with_gmp"
4443
4444 fi;
4445
4446 # Check whether --with-gmp_include or --without-gmp_include was given.
4447 if test "${with_gmp_include+set}" = set; then
4448   withval="$with_gmp_include"
4449
4450 fi;
4451
4452 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4453 if test "${with_gmp_lib+set}" = set; then
4454   withval="$with_gmp_lib"
4455
4456 fi;
4457
4458
4459 if test "x$with_gmp" != x; then
4460   gmplibs="-L$with_gmp/lib $gmplibs"
4461   gmpinc="-I$with_gmp/include $gmpinc"
4462 fi
4463 if test "x$with_gmp_include" != x; then
4464   gmpinc="-I$with_gmp_include $gmpinc"
4465 fi
4466 if test "x$with_gmp_lib" != x; then
4467   gmplibs="-L$with_gmp_lib $gmplibs"
4468 fi
4469 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4470   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4471   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4472   # Do not test the gmp version.  Assume that it is sufficient, since
4473   # it is in the source tree, and the library has not been built yet
4474   # but it would be included on the link line in the version check below
4475   # hence making the test fail.
4476   have_gmp=yes
4477 fi
4478
4479 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4480   have_gmp=yes
4481   saved_CFLAGS="$CFLAGS"
4482   CFLAGS="$CFLAGS $gmpinc"
4483   # Check GMP actually works
4484   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4485 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4486
4487 cat >conftest.$ac_ext <<_ACEOF
4488 /* confdefs.h.  */
4489 _ACEOF
4490 cat confdefs.h >>conftest.$ac_ext
4491 cat >>conftest.$ac_ext <<_ACEOF
4492 /* end confdefs.h.  */
4493 #include "gmp.h"
4494 int
4495 main ()
4496 {
4497
4498   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4499   choke me
4500   #endif
4501
4502   ;
4503   return 0;
4504 }
4505 _ACEOF
4506 rm -f conftest.$ac_objext
4507 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4508   (eval $ac_compile) 2>conftest.er1
4509   ac_status=$?
4510   grep -v '^ *+' conftest.er1 >conftest.err
4511   rm -f conftest.er1
4512   cat conftest.err >&5
4513   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4514   (exit $ac_status); } &&
4515          { ac_try='test -z "$ac_c_werror_flag"
4516                          || test ! -s conftest.err'
4517   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4518   (eval $ac_try) 2>&5
4519   ac_status=$?
4520   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4521   (exit $ac_status); }; } &&
4522          { ac_try='test -s conftest.$ac_objext'
4523   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4524   (eval $ac_try) 2>&5
4525   ac_status=$?
4526   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4527   (exit $ac_status); }; }; then
4528   echo "$as_me:$LINENO: result: yes" >&5
4529 echo "${ECHO_T}yes" >&6
4530 else
4531   echo "$as_me: failed program was:" >&5
4532 sed 's/^/| /' conftest.$ac_ext >&5
4533
4534 echo "$as_me:$LINENO: result: no" >&5
4535 echo "${ECHO_T}no" >&6; have_gmp=no
4536 fi
4537 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4538
4539   if test x"$have_gmp" = xyes; then
4540     saved_LIBS="$LIBS"
4541     LIBS="$LIBS $gmplibs"
4542         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4543 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4544     cat >conftest.$ac_ext <<_ACEOF
4545 /* confdefs.h.  */
4546 _ACEOF
4547 cat confdefs.h >>conftest.$ac_ext
4548 cat >>conftest.$ac_ext <<_ACEOF
4549 /* end confdefs.h.  */
4550 #include <gmp.h>
4551     #include <mpfr.h>
4552 int
4553 main ()
4554 {
4555
4556     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4557     choke me
4558     #endif
4559     mpfr_t n;
4560     mpfr_t x;
4561     int t;
4562     mpfr_init (n);
4563     mpfr_init (x);
4564     mpfr_atan2 (n, n, x, GMP_RNDN);
4565     mpfr_erfc (n, x, GMP_RNDN);
4566     mpfr_subnormalize (x, t, GMP_RNDN);
4567
4568   ;
4569   return 0;
4570 }
4571 _ACEOF
4572 rm -f conftest.$ac_objext conftest$ac_exeext
4573 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4574   (eval $ac_link) 2>conftest.er1
4575   ac_status=$?
4576   grep -v '^ *+' conftest.er1 >conftest.err
4577   rm -f conftest.er1
4578   cat conftest.err >&5
4579   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4580   (exit $ac_status); } &&
4581          { ac_try='test -z "$ac_c_werror_flag"
4582                          || test ! -s conftest.err'
4583   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4584   (eval $ac_try) 2>&5
4585   ac_status=$?
4586   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4587   (exit $ac_status); }; } &&
4588          { ac_try='test -s conftest$ac_exeext'
4589   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4590   (eval $ac_try) 2>&5
4591   ac_status=$?
4592   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4593   (exit $ac_status); }; }; then
4594   cat >conftest.$ac_ext <<_ACEOF
4595 /* confdefs.h.  */
4596 _ACEOF
4597 cat confdefs.h >>conftest.$ac_ext
4598 cat >>conftest.$ac_ext <<_ACEOF
4599 /* end confdefs.h.  */
4600 #include <gmp.h>
4601     #include <mpfr.h>
4602 int
4603 main ()
4604 {
4605
4606     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4607     choke me
4608     #endif
4609     mpfr_t n; mpfr_init(n);
4610
4611   ;
4612   return 0;
4613 }
4614 _ACEOF
4615 rm -f conftest.$ac_objext conftest$ac_exeext
4616 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4617   (eval $ac_link) 2>conftest.er1
4618   ac_status=$?
4619   grep -v '^ *+' conftest.er1 >conftest.err
4620   rm -f conftest.er1
4621   cat conftest.err >&5
4622   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4623   (exit $ac_status); } &&
4624          { ac_try='test -z "$ac_c_werror_flag"
4625                          || test ! -s conftest.err'
4626   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4627   (eval $ac_try) 2>&5
4628   ac_status=$?
4629   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4630   (exit $ac_status); }; } &&
4631          { ac_try='test -s conftest$ac_exeext'
4632   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4633   (eval $ac_try) 2>&5
4634   ac_status=$?
4635   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4636   (exit $ac_status); }; }; then
4637   echo "$as_me:$LINENO: result: yes" >&5
4638 echo "${ECHO_T}yes" >&6
4639 else
4640   echo "$as_me: failed program was:" >&5
4641 sed 's/^/| /' conftest.$ac_ext >&5
4642
4643 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4644 echo "${ECHO_T}buggy but acceptable" >&6
4645 fi
4646 rm -f conftest.err conftest.$ac_objext \
4647       conftest$ac_exeext conftest.$ac_ext
4648 else
4649   echo "$as_me: failed program was:" >&5
4650 sed 's/^/| /' conftest.$ac_ext >&5
4651
4652 echo "$as_me:$LINENO: result: no" >&5
4653 echo "${ECHO_T}no" >&6; have_gmp=no
4654 fi
4655 rm -f conftest.err conftest.$ac_objext \
4656       conftest$ac_exeext conftest.$ac_ext
4657       LIBS="$saved_LIBS"
4658   fi
4659   CFLAGS="$saved_CFLAGS"
4660
4661   if test x$have_gmp != xyes; then
4662     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4663 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4664 Copies of these libraries' source code can be found at their respective
4665 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4666 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4667 If you obtained GMP and/or MPFR from a vendor distribution package, make
4668 sure that you have installed both the libraries and the header files.
4669 They may be located in separate packages." >&5
4670 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4671 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4672 Copies of these libraries' source code can be found at their respective
4673 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4674 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4675 If you obtained GMP and/or MPFR from a vendor distribution package, make
4676 sure that you have installed both the libraries and the header files.
4677 They may be located in separate packages." >&2;}
4678    { (exit 1); exit 1; }; }
4679   fi
4680 fi
4681
4682 # Flags needed for both GMP and/or MPFR
4683
4684
4685
4686 # By default, C is the only stage 1 language.
4687 stage1_languages=,c,
4688
4689 # Figure out what language subdirectories are present.
4690 # Look if the user specified --enable-languages="..."; if not, use
4691 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4692 # go away some day.
4693 # NB:  embedded tabs in this IF block -- do not untabify
4694 if test -d ${srcdir}/gcc; then
4695   if test x"${enable_languages+set}" != xset; then
4696     if test x"${LANGUAGES+set}" = xset; then
4697       enable_languages="${LANGUAGES}"
4698         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4699     else
4700       enable_languages=all
4701     fi
4702   else
4703     if test x"${enable_languages}" = x ||
4704        test x"${enable_languages}" = xyes;
4705        then
4706       echo configure.in: --enable-languages needs at least one language argument 1>&2
4707       exit 1
4708     fi
4709   fi
4710   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4711
4712   # 'f95' is the old name for the 'fortran' language. We issue a warning
4713   # and make the substitution.
4714   case ,${enable_languages}, in
4715     *,f95,*)
4716       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4717       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4718       ;;
4719   esac
4720
4721   # First scan to see if an enabled language requires some other language.
4722   # We assume that a given config-lang.in will list all the language
4723   # front ends it requires, even if some are required indirectly.
4724   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4725     case ${lang_frag} in
4726       ..) ;;
4727       # The odd quoting in the next line works around
4728       # an apparent bug in bash 1.12 on linux.
4729       ${srcdir}/gcc/[*]/config-lang.in) ;;
4730       *)
4731         # From the config-lang.in, get $language, $lang_requires
4732         language=
4733         lang_requires=
4734         . ${lang_frag}
4735         for other in ${lang_requires} ; do
4736           case ,${enable_languages}, in
4737             *,$other,*) ;;
4738             *,all,*) ;;
4739             *,$language,*)
4740               echo " \`$other' language required by \`$language'; enabling" 1>&2
4741               enable_languages="${enable_languages},${other}"
4742               ;;
4743           esac
4744         done
4745         ;;
4746     esac
4747   done
4748
4749   new_enable_languages=,c,
4750   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4751   potential_languages=,c,
4752
4753   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4754     case ${lang_frag} in
4755       ..) ;;
4756       # The odd quoting in the next line works around
4757       # an apparent bug in bash 1.12 on linux.
4758       ${srcdir}/gcc/[*]/config-lang.in) ;;
4759       *)
4760         # From the config-lang.in, get $language, $target_libs,
4761         # $lang_dirs, $boot_language, and $build_by_default
4762         language=
4763         target_libs=
4764         lang_dirs=
4765         subdir_requires=
4766         boot_language=no
4767         build_by_default=yes
4768         . ${lang_frag}
4769         if test x${language} = x; then
4770           echo "${lang_frag} doesn't set \$language." 1>&2
4771           exit 1
4772         fi
4773
4774         case ,${enable_languages}, in
4775           *,${language},*)
4776             # Language was explicitly selected; include it.
4777             add_this_lang=yes
4778             ;;
4779           *,all,*)
4780             # 'all' was selected, select it if it is a default language
4781             add_this_lang=${build_by_default}
4782             ;;
4783           *)
4784             add_this_lang=no
4785             ;;
4786         esac
4787
4788         # Disable languages that need other directories if these aren't available.
4789         for i in $subdir_requires; do
4790           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4791           case ,${enable_languages}, in
4792             *,${language},*)
4793               # Specifically requested language; tell them.
4794               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4795 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4796    { (exit 1); exit 1; }; }
4797               ;;
4798             *)
4799               # Silently disable.
4800               add_this_lang=unsupported
4801               ;;
4802           esac
4803         done
4804
4805         # Disable Ada if no preexisting GNAT is available.
4806         case ,${enable_languages},:${language}:${have_gnat} in
4807           *,${language},*:ada:no)
4808             # Specifically requested language; tell them.
4809             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4810 echo "$as_me: error: GNAT is required to build $language" >&2;}
4811    { (exit 1); exit 1; }; }
4812             ;;
4813           *:ada:no)
4814             # Silently disable.
4815             add_this_lang=unsupported
4816             ;;
4817         esac
4818
4819         # Disable a language that is unsupported by the target.
4820         case " $unsupported_languages " in
4821           *" $language "*)
4822             add_this_lang=unsupported
4823             ;;
4824         esac
4825
4826         case $add_this_lang in
4827           unsupported)
4828             # Remove language-dependent dirs.
4829             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4830             ;;
4831           no)
4832             # Remove language-dependent dirs; still show language as supported.
4833             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4834             potential_languages="${potential_languages}${language},"
4835             ;;
4836           yes)
4837             new_enable_languages="${new_enable_languages}${language},"
4838             potential_languages="${potential_languages}${language},"
4839             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4840             case ${boot_language} in
4841               yes)
4842                 # Add to (comma-separated) list of stage 1 languages.
4843                 stage1_languages="${stage1_languages}${language},"
4844                 ;;
4845             esac
4846             ;;
4847         esac
4848         ;;
4849     esac
4850   done
4851
4852   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4853 if test "${enable_stage1_languages+set}" = set; then
4854   enableval="$enable_stage1_languages"
4855   case ,${enable_stage1_languages}, in
4856     ,no,|,,)
4857       # Set it to something that will have no effect in the loop below
4858       enable_stage1_languages=c ;;
4859     ,yes,)
4860       enable_stage1_languages=`echo $new_enable_languages | \
4861         sed -e "s/^,//" -e "s/,$//" ` ;;
4862     *,all,*)
4863       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4864         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4865   esac
4866
4867   # Add "good" languages from enable_stage1_languages to stage1_languages,
4868   # while "bad" languages go in missing_languages.  Leave no duplicates.
4869   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4870     case $potential_languages in
4871       *,$i,*)
4872         case $stage1_languages in
4873           *,$i,*) ;;
4874           *) stage1_languages="$stage1_languages$i," ;;
4875         esac ;;
4876       *)
4877         case $missing_languages in
4878           *,$i,*) ;;
4879           *) missing_languages="$missing_languages$i," ;;
4880         esac ;;
4881      esac
4882   done
4883 fi;
4884
4885   # Remove leading/trailing commas that were added for simplicity
4886   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4887   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4888   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4889   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4890
4891   if test "x$missing_languages" != x; then
4892     { { echo "$as_me:$LINENO: error:
4893 The following requested languages could not be built: ${missing_languages}
4894 Supported languages are: ${potential_languages}" >&5
4895 echo "$as_me: error:
4896 The following requested languages could not be built: ${missing_languages}
4897 Supported languages are: ${potential_languages}" >&2;}
4898    { (exit 1); exit 1; }; }
4899   fi
4900   if test "x$new_enable_languages" != "x$enable_languages"; then
4901     echo The following languages will be built: ${new_enable_languages}
4902     enable_languages="$new_enable_languages"
4903   fi
4904
4905
4906   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4907 fi
4908
4909 # Handle --disable-<component> generically.
4910 for dir in $configdirs $build_configdirs $target_configdirs ; do
4911   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4912   varname=`echo $dirname | sed -e s/+/_/g`
4913   if eval test x\${enable_${varname}} "=" xno ; then
4914     noconfigdirs="$noconfigdirs $dir"
4915   fi
4916 done
4917
4918 # Check for Boehm's garbage collector
4919 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4920 if test "${enable_objc_gc+set}" = set; then
4921   enableval="$enable_objc_gc"
4922   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4923   *,objc,*:*:yes:*target-boehm-gc*)
4924     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4925 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4926    { (exit 1); exit 1; }; }
4927     ;;
4928 esac
4929 fi;
4930
4931 # Make sure we only build Boehm's garbage collector if required.
4932 case ,${enable_languages},:${enable_objc_gc} in
4933   *,objc,*:yes)
4934     # Keep target-boehm-gc if requested for Objective-C.
4935     ;;
4936   *)
4937     # Otherwise remove target-boehm-gc depending on target-libjava.
4938     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
4939       noconfigdirs="$noconfigdirs target-boehm-gc"
4940     fi
4941     ;;
4942 esac
4943
4944 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
4945 # $build_configdirs and $target_configdirs.
4946 # If we have the source for $noconfigdirs entries, add them to $notsupp.
4947
4948 notsupp=""
4949 for dir in . $skipdirs $noconfigdirs ; do
4950   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
4951   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4952     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
4953     if test -r $srcdir/$dirname/configure ; then
4954       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4955         true
4956       else
4957         notsupp="$notsupp $dir"
4958       fi
4959     fi
4960   fi
4961   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4962     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
4963     if test -r $srcdir/$dirname/configure ; then
4964       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4965         true
4966       else
4967         notsupp="$notsupp $dir"
4968       fi
4969     fi
4970   fi
4971   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4972     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
4973     if test -r $srcdir/$dirname/configure ; then
4974       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4975         true
4976       else
4977         notsupp="$notsupp $dir"
4978       fi
4979     fi
4980   fi
4981 done
4982
4983 # Sometimes the tools are distributed with libiberty but with no other
4984 # libraries.  In that case, we don't want to build target-libiberty.
4985 # Don't let libgcc imply libiberty either.
4986 if test -n "${target_configdirs}" ; then
4987   libgcc=
4988   others=
4989   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
4990     if test "$i" = "libgcc"; then
4991       libgcc=target-libgcc
4992     elif test "$i" != "libiberty" ; then
4993       if test -r $srcdir/$i/configure ; then
4994         others=yes;
4995         break;
4996       fi
4997     fi
4998   done
4999   if test -z "${others}" ; then
5000     target_configdirs=$libgcc
5001   fi
5002 fi
5003
5004 # Quietly strip out all directories which aren't configurable in this tree.
5005 # This relies on all configurable subdirectories being autoconfiscated, which
5006 # is now the case.
5007 build_configdirs_all="$build_configdirs"
5008 build_configdirs=
5009 for i in ${build_configdirs_all} ; do
5010   j=`echo $i | sed -e s/build-//g`
5011   if test -f ${srcdir}/$j/configure ; then
5012     build_configdirs="${build_configdirs} $i"
5013   fi
5014 done
5015
5016 configdirs_all="$configdirs"
5017 configdirs=
5018 for i in ${configdirs_all} ; do
5019   if test -f ${srcdir}/$i/configure ; then
5020     configdirs="${configdirs} $i"
5021   fi
5022 done
5023
5024 target_configdirs_all="$target_configdirs"
5025 target_configdirs=
5026 for i in ${target_configdirs_all} ; do
5027   j=`echo $i | sed -e s/target-//g`
5028   if test -f ${srcdir}/$j/configure ; then
5029     target_configdirs="${target_configdirs} $i"
5030   fi
5031 done
5032
5033 # Produce a warning message for the subdirs we can't configure.
5034 # This isn't especially interesting in the Cygnus tree, but in the individual
5035 # FSF releases, it's important to let people know when their machine isn't
5036 # supported by the one or two programs in a package.
5037
5038 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5039   # If $appdirs is non-empty, at least one of those directories must still
5040   # be configured, or we error out.  (E.g., if the gas release supports a
5041   # specified target in some subdirs but not the gas subdir, we shouldn't
5042   # pretend that all is well.)
5043   if test -n "$appdirs" ; then
5044     for dir in $appdirs ; do
5045       if test -r $dir/Makefile.in ; then
5046         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5047           appdirs=""
5048           break
5049         fi
5050         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5051           appdirs=""
5052           break
5053         fi
5054       fi
5055     done
5056     if test -n "$appdirs" ; then
5057       echo "*** This configuration is not supported by this package." 1>&2
5058       exit 1
5059     fi
5060   fi
5061   # Okay, some application will build, or we don't care to check.  Still
5062   # notify of subdirs not getting built.
5063   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5064   echo "    ${notsupp}" 1>&2
5065   echo "    (Any other directories should still work fine.)" 1>&2
5066 fi
5067
5068 case "$host" in
5069   *msdosdjgpp*)
5070     enable_gdbtk=no ;;
5071 esac
5072
5073 # To find our prefix, in gcc_cv_tool_prefix.
5074
5075 # The user is always right.
5076 if test "${PATH_SEPARATOR+set}" != set; then
5077   echo "#! /bin/sh" >conf$$.sh
5078   echo  "exit 0"   >>conf$$.sh
5079   chmod +x conf$$.sh
5080   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5081     PATH_SEPARATOR=';'
5082   else
5083     PATH_SEPARATOR=:
5084   fi
5085   rm -f conf$$.sh
5086 fi
5087
5088
5089
5090 if test "x$exec_prefix" = xNONE; then
5091         if test "x$prefix" = xNONE; then
5092                 gcc_cv_tool_prefix=$ac_default_prefix
5093         else
5094                 gcc_cv_tool_prefix=$prefix
5095         fi
5096 else
5097         gcc_cv_tool_prefix=$exec_prefix
5098 fi
5099
5100 # If there is no compiler in the tree, use the PATH only.  In any
5101 # case, if there is no compiler in the tree nobody should use
5102 # AS_FOR_TARGET and LD_FOR_TARGET.
5103 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5104     gcc_version=`cat $srcdir/gcc/BASE-VER`
5105     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5106     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5107     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5108     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5109     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5110     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5111 else
5112     gcc_cv_tool_dirs=
5113 fi
5114
5115 if test x$build = x$target && test -n "$md_exec_prefix"; then
5116         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5117 fi
5118
5119
5120
5121 copy_dirs=
5122
5123
5124 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5125 if test "${with_build_sysroot+set}" = set; then
5126   withval="$with_build_sysroot"
5127   if test x"$withval" != x ; then
5128      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5129    fi
5130 else
5131   SYSROOT_CFLAGS_FOR_TARGET=
5132 fi;
5133
5134
5135
5136 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5137 if test "${with_debug_prefix_map+set}" = set; then
5138   withval="$with_debug_prefix_map"
5139   if test x"$withval" != x; then
5140      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5141      for debug_map in $withval; do
5142        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5143      done
5144    fi
5145 else
5146   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5147 fi;
5148
5149
5150 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5151 # the named directory are copied to $(tooldir)/sys-include.
5152 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5153   if test x${is_cross_compiler} = xno ; then
5154     echo 1>&2 '***' --with-headers is only supported when cross compiling
5155     exit 1
5156   fi
5157   if test x"${with_headers}" != xyes ; then
5158     x=${gcc_cv_tool_prefix}
5159     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5160   fi
5161 fi
5162
5163 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5164 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5165 # are permitted.
5166 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5167   if test x${is_cross_compiler} = xno ; then
5168     echo 1>&2 '***' --with-libs is only supported when cross compiling
5169     exit 1
5170   fi
5171   if test x"${with_libs}" != xyes ; then
5172     # Copy the libraries in reverse order, so that files in the first named
5173     # library override files in subsequent libraries.
5174     x=${gcc_cv_tool_prefix}
5175     for l in ${with_libs}; do
5176       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5177     done
5178   fi
5179 fi
5180
5181 # Set with_gnu_as and with_gnu_ld as appropriate.
5182 #
5183 # This is done by determining whether or not the appropriate directory
5184 # is available, and by checking whether or not specific configurations
5185 # have requested that this magic not happen.
5186 #
5187 # The command line options always override the explicit settings in
5188 # configure.in, and the settings in configure.in override this magic.
5189 #
5190 # If the default for a toolchain is to use GNU as and ld, and you don't
5191 # want to do that, then you should use the --without-gnu-as and
5192 # --without-gnu-ld options for the configure script.
5193
5194 if test x${use_gnu_as} = x &&
5195    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5196   with_gnu_as=yes
5197   extra_host_args="$extra_host_args --with-gnu-as"
5198 fi
5199
5200 if test x${use_gnu_ld} = x &&
5201    echo " ${configdirs} " | grep " ld " > /dev/null 2>&1 ; then
5202   with_gnu_ld=yes
5203   extra_host_args="$extra_host_args --with-gnu-ld"
5204 fi
5205
5206 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5207 # can detect this case.
5208
5209 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5210   with_newlib=yes
5211   extra_host_args="$extra_host_args --with-newlib"
5212 fi
5213
5214 # Handle ${copy_dirs}
5215 set fnord ${copy_dirs}
5216 shift
5217 while test $# != 0 ; do
5218   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5219     :
5220   else
5221     echo Copying $1 to $2
5222
5223     # Use the install script to create the directory and all required
5224     # parent directories.
5225     if test -d $2 ; then
5226       :
5227     else
5228       echo >config.temp
5229       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5230     fi
5231
5232     # Copy the directory, assuming we have tar.
5233     # FIXME: Should we use B in the second tar?  Not all systems support it.
5234     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5235
5236     # It is the responsibility of the user to correctly adjust all
5237     # symlinks.  If somebody can figure out how to handle them correctly
5238     # here, feel free to add the code.
5239
5240     echo $1 > $2/COPIED
5241   fi
5242   shift; shift
5243 done
5244
5245 # Determine a target-dependent exec_prefix that the installed
5246 # gcc will search in.  Keep this list sorted by triplet, with
5247 # the *-*-osname triplets last.
5248 md_exec_prefix=
5249 case "${target}" in
5250   alpha*-*-*vms*)
5251     md_exec_prefix=/gnu/lib/gcc-lib
5252     ;;
5253   i[34567]86-pc-msdosdjgpp*)
5254     md_exec_prefix=/dev/env/DJDIR/bin
5255     ;;
5256   i[34567]86-*-sco3.2v5*)
5257     if test $with_gnu_as = yes; then
5258       md_exec_prefix=/usr/gnu/bin
5259     else
5260       md_exec_prefix=/usr/ccs/bin/elf
5261     fi
5262     ;;
5263
5264   mn10300-*-* | \
5265   powerpc-*-chorusos* | \
5266   powerpc*-*-eabi* | \
5267   powerpc*-*-sysv* | \
5268   powerpc*-*-kaos* | \
5269   s390x-ibm-tpf*)
5270     md_exec_prefix=/usr/ccs/bin
5271     ;;
5272   sparc64-*-elf*)
5273     ;;
5274   v850*-*-*)
5275     md_exec_prefix=/usr/ccs/bin
5276     ;;
5277   xtensa*-*-elf*)
5278     ;;
5279
5280   *-*-beos* | \
5281   *-*-elf* | \
5282   *-*-hpux* | \
5283   *-*-netware* | \
5284   *-*-nto-qnx* | \
5285   *-*-rtems* | \
5286   *-*-solaris2* | \
5287   *-*-sysv[45]* | \
5288   *-*-vxworks* | \
5289   *-wrs-windiss)
5290     md_exec_prefix=/usr/ccs/bin
5291     ;;
5292 esac
5293
5294 extra_arflags_for_target=
5295 extra_nmflags_for_target=
5296 extra_ranlibflags_for_target=
5297 target_makefile_frag=/dev/null
5298 case "${target}" in
5299   mep*-*-*)
5300     target_makefile_frag="config/mt-mep"
5301     ;;
5302   spu-*-*)
5303     target_makefile_frag="config/mt-spu"
5304     ;;
5305   mips*-sde-elf*)
5306     target_makefile_frag="config/mt-sde"
5307     ;;
5308   mipsisa*-*-elfoabi*)
5309     target_makefile_frag="config/mt-mips-elfoabi"
5310     ;;
5311   *-*-netware*)
5312     target_makefile_frag="config/mt-netware"
5313     ;;
5314   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5315     target_makefile_frag="config/mt-gnu"
5316     ;;
5317   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5318     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5319     # commands to handle both 32-bit and 64-bit objects.  These flags are
5320     # harmless if we're using GNU nm or ar.
5321     extra_arflags_for_target=" -X32_64"
5322     extra_nmflags_for_target=" -B -X32_64"
5323     ;;
5324   *-*-darwin*)
5325     # ranlib from Darwin requires the -c flag to look at common symbols.
5326     extra_ranlibflags_for_target=" -c"
5327     ;;
5328   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5329     target_makefile_frag="config/mt-wince"
5330     ;;
5331 esac
5332
5333 alphaieee_frag=/dev/null
5334 case $target in
5335   alpha*-*-*)
5336     # This just makes sure to use the -mieee option to build target libs.
5337     # This should probably be set individually by each library.
5338     alphaieee_frag="config/mt-alphaieee"
5339     ;;
5340 esac
5341
5342 # If --enable-target-optspace always use -Os instead of -O2 to build
5343 # the target libraries, similarly if it is not specified, use -Os
5344 # on selected platforms.
5345 ospace_frag=/dev/null
5346 case "${enable_target_optspace}:${target}" in
5347   yes:*)
5348     ospace_frag="config/mt-ospace"
5349     ;;
5350   :d30v-*)
5351     ospace_frag="config/mt-d30v"
5352     ;;
5353   :m32r-* | :d10v-* | :fr30-*)
5354     ospace_frag="config/mt-ospace"
5355     ;;
5356   no:* | :*)
5357     ;;
5358   *)
5359     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5360     ;;
5361 esac
5362
5363 # Default to using --with-stabs for certain targets.
5364 if test x${with_stabs} = x ; then
5365   case "${target}" in
5366   mips*-*-irix[56]*)
5367     ;;
5368   mips*-*-* | alpha*-*-osf*)
5369     with_stabs=yes;
5370     extra_host_args="${extra_host_args} --with-stabs"
5371     ;;
5372   esac
5373 fi
5374
5375 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5376 # them automatically.
5377 case "${host}" in
5378   hppa*64*-*-hpux11*)
5379     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5380     ;;
5381 esac
5382
5383 # Some systems (e.g., one of the i386-aix systems the gas testers are
5384 # using) don't handle "\$" correctly, so don't use it here.
5385 tooldir='${exec_prefix}'/${target_noncanonical}
5386 build_tooldir=${tooldir}
5387
5388 # Create a .gdbinit file which runs the one in srcdir
5389 # and tells GDB to look there for source files.
5390
5391 if test -r ${srcdir}/.gdbinit ; then
5392   case ${srcdir} in
5393     .) ;;
5394     *) cat > ./.gdbinit <<EOF
5395 # ${NO_EDIT}
5396 dir ${srcdir}
5397 dir .
5398 source ${srcdir}/.gdbinit
5399 EOF
5400     ;;
5401   esac
5402 fi
5403
5404 # Make sure that the compiler is able to generate an executable.  If it
5405 # can't, we are probably in trouble.  We don't care whether we can run the
5406 # executable--we might be using a cross compiler--we only care whether it
5407 # can be created.  At this point the main configure script has set CC.
5408 we_are_ok=no
5409 echo "int main () { return 0; }" > conftest.c
5410 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5411 if test $? = 0 ; then
5412   if test -s conftest || test -s conftest.exe ; then
5413     we_are_ok=yes
5414   fi
5415 fi
5416 case $we_are_ok in
5417   no)
5418     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5419     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5420     rm -f conftest*
5421     exit 1
5422     ;;
5423 esac
5424 rm -f conftest*
5425
5426 # The Solaris /usr/ucb/cc compiler does not appear to work.
5427 case "${host}" in
5428   sparc-sun-solaris2*)
5429       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5430       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5431           could_use=
5432           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5433           if test -d /opt/cygnus/bin ; then
5434               if test "$could_use" = "" ; then
5435                   could_use="/opt/cygnus/bin"
5436               else
5437                   could_use="$could_use or /opt/cygnus/bin"
5438               fi
5439           fi
5440         if test "$could_use" = "" ; then
5441             echo "Warning: compilation may fail because you're using"
5442             echo "/usr/ucb/cc.  You should change your PATH or CC "
5443             echo "variable and rerun configure."
5444         else
5445             echo "Warning: compilation may fail because you're using"
5446             echo "/usr/ucb/cc, when you should use the C compiler from"
5447             echo "$could_use.  You should change your"
5448             echo "PATH or CC variable and rerun configure."
5449         fi
5450       fi
5451   ;;
5452 esac
5453
5454 case "${host}" in
5455   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5456   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5457   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5458 esac
5459
5460 # Record target_configdirs and the configure arguments for target and
5461 # build configuration in Makefile.
5462 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5463 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5464
5465 # Determine whether gdb needs tk/tcl or not.
5466 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5467 # and in that case we want gdb to be built without tk.  Ugh!
5468 # In fact I believe gdb is the *only* package directly dependent on tk,
5469 # so we should be able to put the 'maybe's in unconditionally and
5470 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5471 # 100% sure that that's safe though.
5472
5473 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5474 case "$enable_gdbtk" in
5475   no)
5476     GDB_TK="" ;;
5477   yes)
5478     GDB_TK="${gdb_tk}" ;;
5479   *)
5480     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5481     # distro.  Eventually someone will fix this and move Insight, nee
5482     # gdbtk to a separate directory.
5483     if test -d ${srcdir}/gdb/gdbtk ; then
5484       GDB_TK="${gdb_tk}"
5485     else
5486       GDB_TK=""
5487     fi
5488     ;;
5489 esac
5490 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5491 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5492
5493 # Strip out unwanted targets.
5494
5495 # While at that, we remove Makefiles if we were started for recursive
5496 # configuration, so that the top-level Makefile reconfigures them,
5497 # like we used to do when configure itself was recursive.
5498
5499 # Loop over modules.  $extrasub must be used with care, limiting as
5500 # much as possible the usage of range addresses.  That's because autoconf
5501 # splits the sed script to overcome limits in the number of commands,
5502 # and relying on carefully-timed sed passes may turn out to be very hard
5503 # to maintain later.  In this particular case, you just have to be careful
5504 # not to nest @if/@endif pairs, because configure will not warn you at all.
5505
5506 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5507 if test "${enable_bootstrap+set}" = set; then
5508   enableval="$enable_bootstrap"
5509
5510 else
5511   enable_bootstrap=default
5512 fi;
5513
5514 # Issue errors and warnings for invalid/strange bootstrap combinations.
5515 case "$configdirs" in
5516   *gcc*) have_compiler=yes ;;
5517   *) have_compiler=no ;;
5518 esac
5519
5520 case "$have_compiler:$host:$target:$enable_bootstrap" in
5521   *:*:*:no) ;;
5522
5523   # Default behavior.  Enable bootstrap if we have a compiler
5524   # and we are in a native configuration.
5525   yes:$build:$build:default)
5526     enable_bootstrap=yes ;;
5527
5528   *:*:*:default)
5529     enable_bootstrap=no ;;
5530
5531   # We have a compiler and we are in a native configuration, bootstrap is ok
5532   yes:$build:$build:yes)
5533     ;;
5534
5535   # Other configurations, but we have a compiler.  Assume the user knows
5536   # what he's doing.
5537   yes:*:*:yes)
5538     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5539 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5540     ;;
5541
5542   # No compiler: if they passed --enable-bootstrap explicitly, fail
5543   no:*:*:yes)
5544     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5545 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5546    { (exit 1); exit 1; }; } ;;
5547
5548   # Fail if wrong command line
5549   *)
5550     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5551 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5552    { (exit 1); exit 1; }; }
5553     ;;
5554 esac
5555
5556 # Adjust the toplevel makefile according to whether bootstrap was selected.
5557 case "$enable_bootstrap" in
5558   yes)
5559     bootstrap_suffix=bootstrap ;;
5560   no)
5561     bootstrap_suffix=no-bootstrap ;;
5562 esac
5563
5564 for module in ${build_configdirs} ; do
5565   if test -z "${no_recursion}" \
5566      && test -f ${build_subdir}/${module}/Makefile; then
5567     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5568     rm -f ${build_subdir}/${module}/Makefile
5569   fi
5570   extrasub="$extrasub
5571 /^@if build-$module\$/d
5572 /^@endif build-$module\$/d
5573 /^@if build-$module-$bootstrap_suffix\$/d
5574 /^@endif build-$module-$bootstrap_suffix\$/d"
5575 done
5576 for module in ${configdirs} ; do
5577   if test -z "${no_recursion}"; then
5578     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5579       if test -f ${file}; then
5580         echo 1>&2 "*** removing ${file} to force reconfigure"
5581         rm -f ${file}
5582       fi
5583     done
5584   fi
5585   extrasub="$extrasub
5586 /^@if $module\$/d
5587 /^@endif $module\$/d
5588 /^@if $module-$bootstrap_suffix\$/d
5589 /^@endif $module-$bootstrap_suffix\$/d"
5590 done
5591 for module in ${target_configdirs} ; do
5592   if test -z "${no_recursion}" \
5593      && test -f ${target_subdir}/${module}/Makefile; then
5594     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5595     rm -f ${target_subdir}/${module}/Makefile
5596   fi
5597   extrasub="$extrasub
5598 /^@if target-$module\$/d
5599 /^@endif target-$module\$/d
5600 /^@if target-$module-$bootstrap_suffix\$/d
5601 /^@endif target-$module-$bootstrap_suffix\$/d"
5602 done
5603
5604 extrasub="$extrasub
5605 /^@if /,/^@endif /d"
5606
5607 # Create the serialization dependencies.  This uses a temporary file.
5608
5609 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5610 if test "${enable_serial_configure+set}" = set; then
5611   enableval="$enable_serial_configure"
5612
5613 fi;
5614
5615 case ${enable_serial_configure} in
5616   yes)
5617     enable_serial_build_configure=yes
5618     enable_serial_host_configure=yes
5619     enable_serial_target_configure=yes
5620     ;;
5621 esac
5622
5623 # These force 'configure's to be done one at a time, to avoid problems
5624 # with contention over a shared config.cache.
5625 rm -f serdep.tmp
5626 echo '# serdep.tmp' > serdep.tmp
5627 olditem=
5628 test "x${enable_serial_build_configure}" = xyes &&
5629 for item in ${build_configdirs} ; do
5630   case ${olditem} in
5631     "") ;;
5632     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5633   esac
5634   olditem=${item}
5635 done
5636 olditem=
5637 test "x${enable_serial_host_configure}" = xyes &&
5638 for item in ${configdirs} ; do
5639   case ${olditem} in
5640     "") ;;
5641     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5642   esac
5643   olditem=${item}
5644 done
5645 olditem=
5646 test "x${enable_serial_target_configure}" = xyes &&
5647 for item in ${target_configdirs} ; do
5648   case ${olditem} in
5649     "") ;;
5650     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5651   esac
5652   olditem=${item}
5653 done
5654 serialization_dependencies=serdep.tmp
5655
5656
5657 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5658 # target, nonopt, and variable assignments.  These are the ones we
5659 # might not want to pass down to subconfigures.  Also strip
5660 # program-prefix, program-suffix, and program-transform-name, so that
5661 # we can pass down a consistent program-transform-name.
5662 baseargs=
5663 keep_next=no
5664 skip_next=no
5665 eval "set -- $ac_configure_args"
5666 for ac_arg
5667 do
5668   if test X"$skip_next" = X"yes"; then
5669     skip_next=no
5670     continue
5671   fi
5672   if test X"$keep_next" = X"yes"; then
5673     case $ac_arg in
5674       *\'*)
5675         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5676     esac
5677     baseargs="$baseargs '$ac_arg'"
5678     keep_next=no
5679     continue
5680   fi
5681
5682   # Handle separated arguments.  Based on the logic generated by
5683   # autoconf 2.59.
5684   case $ac_arg in
5685     *=* | --config-cache | -C | -disable-* | --disable-* \
5686       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5687       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5688       | -with-* | --with-* | -without-* | --without-* | --x)
5689       separate_arg=no
5690       ;;
5691     -*)
5692       separate_arg=yes
5693       ;;
5694     *)
5695       separate_arg=no
5696       ;;
5697   esac
5698
5699   case "$ac_arg" in
5700     --no*)
5701       continue
5702       ;;
5703     --c* | \
5704     --sr* | \
5705     --ho* | \
5706     --bu* | \
5707     --t* | \
5708     --program-* | \
5709     -cache_file* | \
5710     -srcdir* | \
5711     -host* | \
5712     -build* | \
5713     -target* | \
5714     -program-prefix* | \
5715     -program-suffix* | \
5716     -program-transform-name* )
5717       skip_next=$separate_arg
5718       continue
5719       ;;
5720     -*)
5721       # An option.  Add it.
5722       case $ac_arg in
5723         *\'*)
5724           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5725       esac
5726       baseargs="$baseargs '$ac_arg'"
5727       keep_next=$separate_arg
5728       ;;
5729     *)
5730       # Either a variable assignment, or a nonopt (triplet).  Don't
5731       # pass it down; let the Makefile handle this.
5732       continue
5733       ;;
5734   esac
5735 done
5736 # Remove the initial space we just introduced and, as these will be
5737 # expanded by make, quote '$'.
5738 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5739
5740 # Add in --program-transform-name, after --program-prefix and
5741 # --program-suffix have been applied to it.  Autoconf has already
5742 # doubled dollar signs and backslashes in program_transform_name; we want
5743 # the backslashes un-doubled, and then the entire thing wrapped in single
5744 # quotes, because this will be expanded first by make and then by the shell.
5745 # Also, because we want to override the logic in subdir configure scripts to
5746 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5747 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5748 ${program_transform_name}
5749 EOF_SED
5750 gcc_transform_name=`cat conftestsed.out`
5751 rm -f conftestsed.out
5752 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5753 if test "$silent" = yes; then
5754   baseargs="$baseargs --silent"
5755 fi
5756
5757 # For the build-side libraries, we just need to pretend we're native,
5758 # and not use the same cache file.  Multilibs are neither needed nor
5759 # desired.
5760 build_configargs="--cache-file=../config.cache ${baseargs}"
5761
5762 # For host modules, accept cache file option, or specification as blank.
5763 case "${cache_file}" in
5764 "") # empty
5765   cache_file_option="" ;;
5766 /* | [A-Za-z]:[\\/]* ) # absolute path
5767   cache_file_option="--cache-file=${cache_file}" ;;
5768 *) # relative path
5769   cache_file_option="--cache-file=../${cache_file}" ;;
5770 esac
5771
5772 # Host dirs don't like to share a cache file either, horribly enough.
5773 # This seems to be due to autoconf 2.5x stupidity.
5774 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5775
5776 target_configargs=${baseargs}
5777
5778 # Passing a --with-cross-host argument lets the target libraries know
5779 # whether they are being built with a cross-compiler or being built
5780 # native.  However, it would be better to use other mechanisms to make the
5781 # sorts of decisions they want to make on this basis.  Please consider
5782 # this option to be deprecated.  FIXME.
5783 if test x${is_cross_compiler} = xyes ; then
5784   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5785 fi
5786
5787 # Default to --enable-multilib.
5788 if test x${enable_multilib} = x ; then
5789   target_configargs="--enable-multilib ${target_configargs}"
5790 fi
5791
5792 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5793 # changed from the earlier setting of with_newlib.
5794 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5795   target_configargs="--with-newlib ${target_configargs}"
5796 fi
5797
5798 # Different target subdirs use different values of certain variables
5799 # (notably CXX).  Worse, multilibs use *lots* of different values.
5800 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5801 # it doesn't automatically accept command-line overrides of them.
5802 # This means it's not safe for target subdirs to share a cache file,
5803 # which is disgusting, but there you have it.  Hopefully this can be
5804 # fixed in future.  It's still worthwhile to use a cache file for each
5805 # directory.  I think.
5806
5807 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5808 # We need to pass --target, as newer autoconf's requires consistency
5809 # for target_alias and gcc doesn't manage it consistently.
5810 target_configargs="--cache-file=./config.cache ${target_configargs}"
5811
5812 FLAGS_FOR_TARGET=
5813 case " $target_configdirs " in
5814  *" newlib "*)
5815   case " $target_configargs " in
5816   *" --with-newlib "*)
5817    case "$target" in
5818    *-cygwin*)
5819      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' ;;
5820    esac
5821
5822    # If we're not building GCC, don't discard standard headers.
5823    if test -d ${srcdir}/gcc; then
5824      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5825
5826      if test "${build}" != "${host}"; then
5827        # On Canadian crosses, CC_FOR_TARGET will have already been set
5828        # by `configure', so we won't have an opportunity to add -Bgcc/
5829        # to it.  This is right: we don't want to search that directory
5830        # for binaries, but we want the header files in there, so add
5831        # them explicitly.
5832        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5833
5834        # Someone might think of using the pre-installed headers on
5835        # Canadian crosses, in case the installed compiler is not fully
5836        # compatible with the compiler being built.  In this case, it
5837        # would be better to flag an error than risking having
5838        # incompatible object files being constructed.  We can't
5839        # guarantee that an error will be flagged, but let's hope the
5840        # compiler will do it, when presented with incompatible header
5841        # files.
5842      fi
5843    fi
5844
5845    case "${target}-${is_cross_compiler}" in
5846    i[3456789]86-*-linux*-no)
5847       # Here host == target, so we don't need to build gcc,
5848       # so we don't want to discard standard headers.
5849       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5850       ;;
5851    *)
5852       # If we're building newlib, use its generic headers last, but search
5853       # for any libc-related directories first (so make it the last -B
5854       # switch).
5855       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5856
5857       # If we're building libgloss, find the startup file, simulator library
5858       # and linker script.
5859       case " $target_configdirs " in
5860         *" libgloss "*)
5861         # Look for startup file, simulator library and maybe linker script.
5862         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
5863         # Look for libnosys.a in case the target needs it.
5864         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5865         # Most targets have the linker script in the source directory.
5866         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
5867         ;;
5868       esac
5869       ;;
5870    esac
5871    ;;
5872   esac
5873   ;;
5874 esac
5875 case "$target" in
5876 *-mingw*)
5877   # Can't be handled as Cygwin above since Mingw does not use newlib.
5878   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' ;;
5879 esac
5880
5881 # Allow the user to override the flags for
5882 # our build compiler if desired.
5883 if test x"${build}" = x"${host}" ; then
5884   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5885   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
5886   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
5887 fi
5888
5889 # On Canadian crosses, we'll be searching the right directories for
5890 # the previously-installed cross compiler, so don't bother to add
5891 # flags for directories within the install tree of the compiler
5892 # being built; programs in there won't even run.
5893 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5894   # Search for pre-installed headers if nothing else fits.
5895   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5896 fi
5897
5898 if test "x${use_gnu_ld}" = x &&
5899    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5900   # Arrange for us to find uninstalled linker scripts.
5901   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5902 fi
5903
5904 # Search for other target-specific linker scripts and such.
5905 case "${target}" in
5906   mep*)
5907     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5908     ;;
5909 esac
5910
5911 # Makefile fragments.
5912 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5913 do
5914   eval fragval=\$$frag
5915   if test $fragval != /dev/null; then
5916     eval $frag=${srcdir}/$fragval
5917   fi
5918 done
5919
5920
5921
5922
5923
5924 # Miscellanea: directories, flags, etc.
5925
5926
5927
5928
5929
5930
5931
5932 # Build module lists & subconfigure args.
5933
5934
5935
5936 # Host module lists & subconfigure args.
5937
5938
5939
5940 # Target module lists & subconfigure args.
5941
5942
5943
5944 # Build tools.
5945
5946
5947
5948
5949
5950
5951
5952
5953
5954
5955
5956
5957
5958
5959
5960
5961
5962 # Generate default definitions for YACC, M4, LEX and other programs that run
5963 # on the build machine.  These are used if the Makefile can't locate these
5964 # programs in objdir.
5965 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
5966
5967 for ac_prog in 'bison -y' byacc yacc
5968 do
5969   # Extract the first word of "$ac_prog", so it can be a program name with args.
5970 set dummy $ac_prog; ac_word=$2
5971 echo "$as_me:$LINENO: checking for $ac_word" >&5
5972 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5973 if test "${ac_cv_prog_YACC+set}" = set; then
5974   echo $ECHO_N "(cached) $ECHO_C" >&6
5975 else
5976   if test -n "$YACC"; then
5977   ac_cv_prog_YACC="$YACC" # Let the user override the test.
5978 else
5979 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5980 for as_dir in $PATH
5981 do
5982   IFS=$as_save_IFS
5983   test -z "$as_dir" && as_dir=.
5984   for ac_exec_ext in '' $ac_executable_extensions; do
5985   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5986     ac_cv_prog_YACC="$ac_prog"
5987     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5988     break 2
5989   fi
5990 done
5991 done
5992
5993 fi
5994 fi
5995 YACC=$ac_cv_prog_YACC
5996 if test -n "$YACC"; then
5997   echo "$as_me:$LINENO: result: $YACC" >&5
5998 echo "${ECHO_T}$YACC" >&6
5999 else
6000   echo "$as_me:$LINENO: result: no" >&5
6001 echo "${ECHO_T}no" >&6
6002 fi
6003
6004   test -n "$YACC" && break
6005 done
6006 test -n "$YACC" || YACC="$MISSING bison -y"
6007
6008 case " $build_configdirs " in
6009   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6010   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6011 esac
6012
6013 for ac_prog in bison
6014 do
6015   # Extract the first word of "$ac_prog", so it can be a program name with args.
6016 set dummy $ac_prog; ac_word=$2
6017 echo "$as_me:$LINENO: checking for $ac_word" >&5
6018 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6019 if test "${ac_cv_prog_BISON+set}" = set; then
6020   echo $ECHO_N "(cached) $ECHO_C" >&6
6021 else
6022   if test -n "$BISON"; then
6023   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6024 else
6025 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6026 for as_dir in $PATH
6027 do
6028   IFS=$as_save_IFS
6029   test -z "$as_dir" && as_dir=.
6030   for ac_exec_ext in '' $ac_executable_extensions; do
6031   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6032     ac_cv_prog_BISON="$ac_prog"
6033     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6034     break 2
6035   fi
6036 done
6037 done
6038
6039 fi
6040 fi
6041 BISON=$ac_cv_prog_BISON
6042 if test -n "$BISON"; then
6043   echo "$as_me:$LINENO: result: $BISON" >&5
6044 echo "${ECHO_T}$BISON" >&6
6045 else
6046   echo "$as_me:$LINENO: result: no" >&5
6047 echo "${ECHO_T}no" >&6
6048 fi
6049
6050   test -n "$BISON" && break
6051 done
6052 test -n "$BISON" || BISON="$MISSING bison"
6053
6054 case " $build_configdirs " in
6055   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6056 esac
6057
6058 for ac_prog in gm4 gnum4 m4
6059 do
6060   # Extract the first word of "$ac_prog", so it can be a program name with args.
6061 set dummy $ac_prog; ac_word=$2
6062 echo "$as_me:$LINENO: checking for $ac_word" >&5
6063 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6064 if test "${ac_cv_prog_M4+set}" = set; then
6065   echo $ECHO_N "(cached) $ECHO_C" >&6
6066 else
6067   if test -n "$M4"; then
6068   ac_cv_prog_M4="$M4" # Let the user override the test.
6069 else
6070 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6071 for as_dir in $PATH
6072 do
6073   IFS=$as_save_IFS
6074   test -z "$as_dir" && as_dir=.
6075   for ac_exec_ext in '' $ac_executable_extensions; do
6076   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6077     ac_cv_prog_M4="$ac_prog"
6078     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6079     break 2
6080   fi
6081 done
6082 done
6083
6084 fi
6085 fi
6086 M4=$ac_cv_prog_M4
6087 if test -n "$M4"; then
6088   echo "$as_me:$LINENO: result: $M4" >&5
6089 echo "${ECHO_T}$M4" >&6
6090 else
6091   echo "$as_me:$LINENO: result: no" >&5
6092 echo "${ECHO_T}no" >&6
6093 fi
6094
6095   test -n "$M4" && break
6096 done
6097 test -n "$M4" || M4="$MISSING m4"
6098
6099 case " $build_configdirs " in
6100   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6101 esac
6102
6103 for ac_prog in flex lex
6104 do
6105   # Extract the first word of "$ac_prog", so it can be a program name with args.
6106 set dummy $ac_prog; ac_word=$2
6107 echo "$as_me:$LINENO: checking for $ac_word" >&5
6108 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6109 if test "${ac_cv_prog_LEX+set}" = set; then
6110   echo $ECHO_N "(cached) $ECHO_C" >&6
6111 else
6112   if test -n "$LEX"; then
6113   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6114 else
6115 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6116 for as_dir in $PATH
6117 do
6118   IFS=$as_save_IFS
6119   test -z "$as_dir" && as_dir=.
6120   for ac_exec_ext in '' $ac_executable_extensions; do
6121   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6122     ac_cv_prog_LEX="$ac_prog"
6123     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6124     break 2
6125   fi
6126 done
6127 done
6128
6129 fi
6130 fi
6131 LEX=$ac_cv_prog_LEX
6132 if test -n "$LEX"; then
6133   echo "$as_me:$LINENO: result: $LEX" >&5
6134 echo "${ECHO_T}$LEX" >&6
6135 else
6136   echo "$as_me:$LINENO: result: no" >&5
6137 echo "${ECHO_T}no" >&6
6138 fi
6139
6140   test -n "$LEX" && break
6141 done
6142 test -n "$LEX" || LEX="$MISSING flex"
6143
6144 case " $build_configdirs " in
6145   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6146   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6147 esac
6148
6149 for ac_prog in flex
6150 do
6151   # Extract the first word of "$ac_prog", so it can be a program name with args.
6152 set dummy $ac_prog; ac_word=$2
6153 echo "$as_me:$LINENO: checking for $ac_word" >&5
6154 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6155 if test "${ac_cv_prog_FLEX+set}" = set; then
6156   echo $ECHO_N "(cached) $ECHO_C" >&6
6157 else
6158   if test -n "$FLEX"; then
6159   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6160 else
6161 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6162 for as_dir in $PATH
6163 do
6164   IFS=$as_save_IFS
6165   test -z "$as_dir" && as_dir=.
6166   for ac_exec_ext in '' $ac_executable_extensions; do
6167   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6168     ac_cv_prog_FLEX="$ac_prog"
6169     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6170     break 2
6171   fi
6172 done
6173 done
6174
6175 fi
6176 fi
6177 FLEX=$ac_cv_prog_FLEX
6178 if test -n "$FLEX"; then
6179   echo "$as_me:$LINENO: result: $FLEX" >&5
6180 echo "${ECHO_T}$FLEX" >&6
6181 else
6182   echo "$as_me:$LINENO: result: no" >&5
6183 echo "${ECHO_T}no" >&6
6184 fi
6185
6186   test -n "$FLEX" && break
6187 done
6188 test -n "$FLEX" || FLEX="$MISSING flex"
6189
6190 case " $build_configdirs " in
6191   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6192 esac
6193
6194 for ac_prog in makeinfo
6195 do
6196   # Extract the first word of "$ac_prog", so it can be a program name with args.
6197 set dummy $ac_prog; ac_word=$2
6198 echo "$as_me:$LINENO: checking for $ac_word" >&5
6199 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6200 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6201   echo $ECHO_N "(cached) $ECHO_C" >&6
6202 else
6203   if test -n "$MAKEINFO"; then
6204   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6205 else
6206 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6207 for as_dir in $PATH
6208 do
6209   IFS=$as_save_IFS
6210   test -z "$as_dir" && as_dir=.
6211   for ac_exec_ext in '' $ac_executable_extensions; do
6212   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6213     ac_cv_prog_MAKEINFO="$ac_prog"
6214     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6215     break 2
6216   fi
6217 done
6218 done
6219
6220 fi
6221 fi
6222 MAKEINFO=$ac_cv_prog_MAKEINFO
6223 if test -n "$MAKEINFO"; then
6224   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6225 echo "${ECHO_T}$MAKEINFO" >&6
6226 else
6227   echo "$as_me:$LINENO: result: no" >&5
6228 echo "${ECHO_T}no" >&6
6229 fi
6230
6231   test -n "$MAKEINFO" && break
6232 done
6233 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6234
6235 case " $build_configdirs " in
6236   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6237   *)
6238
6239     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6240     # higher, else we use the "missing" dummy.
6241     if ${MAKEINFO} --version \
6242        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6243       :
6244     else
6245       MAKEINFO="$MISSING makeinfo"
6246     fi
6247     ;;
6248
6249 esac
6250
6251 # FIXME: expect and dejagnu may become build tools?
6252
6253 for ac_prog in expect
6254 do
6255   # Extract the first word of "$ac_prog", so it can be a program name with args.
6256 set dummy $ac_prog; ac_word=$2
6257 echo "$as_me:$LINENO: checking for $ac_word" >&5
6258 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6259 if test "${ac_cv_prog_EXPECT+set}" = set; then
6260   echo $ECHO_N "(cached) $ECHO_C" >&6
6261 else
6262   if test -n "$EXPECT"; then
6263   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6264 else
6265 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6266 for as_dir in $PATH
6267 do
6268   IFS=$as_save_IFS
6269   test -z "$as_dir" && as_dir=.
6270   for ac_exec_ext in '' $ac_executable_extensions; do
6271   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6272     ac_cv_prog_EXPECT="$ac_prog"
6273     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6274     break 2
6275   fi
6276 done
6277 done
6278
6279 fi
6280 fi
6281 EXPECT=$ac_cv_prog_EXPECT
6282 if test -n "$EXPECT"; then
6283   echo "$as_me:$LINENO: result: $EXPECT" >&5
6284 echo "${ECHO_T}$EXPECT" >&6
6285 else
6286   echo "$as_me:$LINENO: result: no" >&5
6287 echo "${ECHO_T}no" >&6
6288 fi
6289
6290   test -n "$EXPECT" && break
6291 done
6292 test -n "$EXPECT" || EXPECT="expect"
6293
6294 case " $configdirs " in
6295   *" expect "*)
6296     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6297     ;;
6298 esac
6299
6300 for ac_prog in runtest
6301 do
6302   # Extract the first word of "$ac_prog", so it can be a program name with args.
6303 set dummy $ac_prog; ac_word=$2
6304 echo "$as_me:$LINENO: checking for $ac_word" >&5
6305 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6306 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6307   echo $ECHO_N "(cached) $ECHO_C" >&6
6308 else
6309   if test -n "$RUNTEST"; then
6310   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6311 else
6312 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6313 for as_dir in $PATH
6314 do
6315   IFS=$as_save_IFS
6316   test -z "$as_dir" && as_dir=.
6317   for ac_exec_ext in '' $ac_executable_extensions; do
6318   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6319     ac_cv_prog_RUNTEST="$ac_prog"
6320     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6321     break 2
6322   fi
6323 done
6324 done
6325
6326 fi
6327 fi
6328 RUNTEST=$ac_cv_prog_RUNTEST
6329 if test -n "$RUNTEST"; then
6330   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6331 echo "${ECHO_T}$RUNTEST" >&6
6332 else
6333   echo "$as_me:$LINENO: result: no" >&5
6334 echo "${ECHO_T}no" >&6
6335 fi
6336
6337   test -n "$RUNTEST" && break
6338 done
6339 test -n "$RUNTEST" || RUNTEST="runtest"
6340
6341 case " $configdirs " in
6342   *" dejagnu "*)
6343     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6344     ;;
6345 esac
6346
6347
6348 # Host tools.
6349 ncn_tool_prefix=
6350 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6351 ncn_target_tool_prefix=
6352 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6353
6354
6355
6356 if test -n "$AR"; then
6357   ac_cv_prog_AR=$AR
6358 elif test -n "$ac_cv_prog_AR"; then
6359   AR=$ac_cv_prog_AR
6360 fi
6361
6362 if test -n "$ac_cv_prog_AR"; then
6363   for ncn_progname in ar; do
6364     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6365 set dummy ${ncn_progname}; ac_word=$2
6366 echo "$as_me:$LINENO: checking for $ac_word" >&5
6367 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6368 if test "${ac_cv_prog_AR+set}" = set; then
6369   echo $ECHO_N "(cached) $ECHO_C" >&6
6370 else
6371   if test -n "$AR"; then
6372   ac_cv_prog_AR="$AR" # Let the user override the test.
6373 else
6374 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6375 for as_dir in $PATH
6376 do
6377   IFS=$as_save_IFS
6378   test -z "$as_dir" && as_dir=.
6379   for ac_exec_ext in '' $ac_executable_extensions; do
6380   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6381     ac_cv_prog_AR="${ncn_progname}"
6382     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6383     break 2
6384   fi
6385 done
6386 done
6387
6388 fi
6389 fi
6390 AR=$ac_cv_prog_AR
6391 if test -n "$AR"; then
6392   echo "$as_me:$LINENO: result: $AR" >&5
6393 echo "${ECHO_T}$AR" >&6
6394 else
6395   echo "$as_me:$LINENO: result: no" >&5
6396 echo "${ECHO_T}no" >&6
6397 fi
6398
6399   done
6400 fi
6401
6402 for ncn_progname in ar; do
6403   if test -n "$ncn_tool_prefix"; then
6404     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6405 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6406 echo "$as_me:$LINENO: checking for $ac_word" >&5
6407 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6408 if test "${ac_cv_prog_AR+set}" = set; then
6409   echo $ECHO_N "(cached) $ECHO_C" >&6
6410 else
6411   if test -n "$AR"; then
6412   ac_cv_prog_AR="$AR" # Let the user override the test.
6413 else
6414 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6415 for as_dir in $PATH
6416 do
6417   IFS=$as_save_IFS
6418   test -z "$as_dir" && as_dir=.
6419   for ac_exec_ext in '' $ac_executable_extensions; do
6420   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6421     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6422     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6423     break 2
6424   fi
6425 done
6426 done
6427
6428 fi
6429 fi
6430 AR=$ac_cv_prog_AR
6431 if test -n "$AR"; then
6432   echo "$as_me:$LINENO: result: $AR" >&5
6433 echo "${ECHO_T}$AR" >&6
6434 else
6435   echo "$as_me:$LINENO: result: no" >&5
6436 echo "${ECHO_T}no" >&6
6437 fi
6438
6439   fi
6440   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6441     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6442 set dummy ${ncn_progname}; ac_word=$2
6443 echo "$as_me:$LINENO: checking for $ac_word" >&5
6444 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6445 if test "${ac_cv_prog_AR+set}" = set; then
6446   echo $ECHO_N "(cached) $ECHO_C" >&6
6447 else
6448   if test -n "$AR"; then
6449   ac_cv_prog_AR="$AR" # Let the user override the test.
6450 else
6451 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6452 for as_dir in $PATH
6453 do
6454   IFS=$as_save_IFS
6455   test -z "$as_dir" && as_dir=.
6456   for ac_exec_ext in '' $ac_executable_extensions; do
6457   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6458     ac_cv_prog_AR="${ncn_progname}"
6459     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6460     break 2
6461   fi
6462 done
6463 done
6464
6465 fi
6466 fi
6467 AR=$ac_cv_prog_AR
6468 if test -n "$AR"; then
6469   echo "$as_me:$LINENO: result: $AR" >&5
6470 echo "${ECHO_T}$AR" >&6
6471 else
6472   echo "$as_me:$LINENO: result: no" >&5
6473 echo "${ECHO_T}no" >&6
6474 fi
6475
6476   fi
6477   test -n "$ac_cv_prog_AR" && break
6478 done
6479
6480 if test -z "$ac_cv_prog_AR" ; then
6481   set dummy ar
6482   if test $build = $host ; then
6483     AR="$2"
6484   else
6485     AR="${ncn_tool_prefix}$2"
6486   fi
6487 fi
6488
6489
6490
6491 if test -n "$AS"; then
6492   ac_cv_prog_AS=$AS
6493 elif test -n "$ac_cv_prog_AS"; then
6494   AS=$ac_cv_prog_AS
6495 fi
6496
6497 if test -n "$ac_cv_prog_AS"; then
6498   for ncn_progname in as; do
6499     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6500 set dummy ${ncn_progname}; ac_word=$2
6501 echo "$as_me:$LINENO: checking for $ac_word" >&5
6502 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6503 if test "${ac_cv_prog_AS+set}" = set; then
6504   echo $ECHO_N "(cached) $ECHO_C" >&6
6505 else
6506   if test -n "$AS"; then
6507   ac_cv_prog_AS="$AS" # Let the user override the test.
6508 else
6509 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6510 for as_dir in $PATH
6511 do
6512   IFS=$as_save_IFS
6513   test -z "$as_dir" && as_dir=.
6514   for ac_exec_ext in '' $ac_executable_extensions; do
6515   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6516     ac_cv_prog_AS="${ncn_progname}"
6517     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6518     break 2
6519   fi
6520 done
6521 done
6522
6523 fi
6524 fi
6525 AS=$ac_cv_prog_AS
6526 if test -n "$AS"; then
6527   echo "$as_me:$LINENO: result: $AS" >&5
6528 echo "${ECHO_T}$AS" >&6
6529 else
6530   echo "$as_me:$LINENO: result: no" >&5
6531 echo "${ECHO_T}no" >&6
6532 fi
6533
6534   done
6535 fi
6536
6537 for ncn_progname in as; do
6538   if test -n "$ncn_tool_prefix"; then
6539     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6540 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6541 echo "$as_me:$LINENO: checking for $ac_word" >&5
6542 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6543 if test "${ac_cv_prog_AS+set}" = set; then
6544   echo $ECHO_N "(cached) $ECHO_C" >&6
6545 else
6546   if test -n "$AS"; then
6547   ac_cv_prog_AS="$AS" # Let the user override the test.
6548 else
6549 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6550 for as_dir in $PATH
6551 do
6552   IFS=$as_save_IFS
6553   test -z "$as_dir" && as_dir=.
6554   for ac_exec_ext in '' $ac_executable_extensions; do
6555   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6556     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6557     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6558     break 2
6559   fi
6560 done
6561 done
6562
6563 fi
6564 fi
6565 AS=$ac_cv_prog_AS
6566 if test -n "$AS"; then
6567   echo "$as_me:$LINENO: result: $AS" >&5
6568 echo "${ECHO_T}$AS" >&6
6569 else
6570   echo "$as_me:$LINENO: result: no" >&5
6571 echo "${ECHO_T}no" >&6
6572 fi
6573
6574   fi
6575   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6576     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6577 set dummy ${ncn_progname}; ac_word=$2
6578 echo "$as_me:$LINENO: checking for $ac_word" >&5
6579 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6580 if test "${ac_cv_prog_AS+set}" = set; then
6581   echo $ECHO_N "(cached) $ECHO_C" >&6
6582 else
6583   if test -n "$AS"; then
6584   ac_cv_prog_AS="$AS" # Let the user override the test.
6585 else
6586 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6587 for as_dir in $PATH
6588 do
6589   IFS=$as_save_IFS
6590   test -z "$as_dir" && as_dir=.
6591   for ac_exec_ext in '' $ac_executable_extensions; do
6592   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6593     ac_cv_prog_AS="${ncn_progname}"
6594     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6595     break 2
6596   fi
6597 done
6598 done
6599
6600 fi
6601 fi
6602 AS=$ac_cv_prog_AS
6603 if test -n "$AS"; then
6604   echo "$as_me:$LINENO: result: $AS" >&5
6605 echo "${ECHO_T}$AS" >&6
6606 else
6607   echo "$as_me:$LINENO: result: no" >&5
6608 echo "${ECHO_T}no" >&6
6609 fi
6610
6611   fi
6612   test -n "$ac_cv_prog_AS" && break
6613 done
6614
6615 if test -z "$ac_cv_prog_AS" ; then
6616   set dummy as
6617   if test $build = $host ; then
6618     AS="$2"
6619   else
6620     AS="${ncn_tool_prefix}$2"
6621   fi
6622 fi
6623
6624
6625
6626 if test -n "$DLLTOOL"; then
6627   ac_cv_prog_DLLTOOL=$DLLTOOL
6628 elif test -n "$ac_cv_prog_DLLTOOL"; then
6629   DLLTOOL=$ac_cv_prog_DLLTOOL
6630 fi
6631
6632 if test -n "$ac_cv_prog_DLLTOOL"; then
6633   for ncn_progname in dlltool; do
6634     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6635 set dummy ${ncn_progname}; ac_word=$2
6636 echo "$as_me:$LINENO: checking for $ac_word" >&5
6637 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6638 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6639   echo $ECHO_N "(cached) $ECHO_C" >&6
6640 else
6641   if test -n "$DLLTOOL"; then
6642   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6643 else
6644 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6645 for as_dir in $PATH
6646 do
6647   IFS=$as_save_IFS
6648   test -z "$as_dir" && as_dir=.
6649   for ac_exec_ext in '' $ac_executable_extensions; do
6650   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6651     ac_cv_prog_DLLTOOL="${ncn_progname}"
6652     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6653     break 2
6654   fi
6655 done
6656 done
6657
6658 fi
6659 fi
6660 DLLTOOL=$ac_cv_prog_DLLTOOL
6661 if test -n "$DLLTOOL"; then
6662   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6663 echo "${ECHO_T}$DLLTOOL" >&6
6664 else
6665   echo "$as_me:$LINENO: result: no" >&5
6666 echo "${ECHO_T}no" >&6
6667 fi
6668
6669   done
6670 fi
6671
6672 for ncn_progname in dlltool; do
6673   if test -n "$ncn_tool_prefix"; then
6674     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6675 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6676 echo "$as_me:$LINENO: checking for $ac_word" >&5
6677 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6678 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6679   echo $ECHO_N "(cached) $ECHO_C" >&6
6680 else
6681   if test -n "$DLLTOOL"; then
6682   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6683 else
6684 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6685 for as_dir in $PATH
6686 do
6687   IFS=$as_save_IFS
6688   test -z "$as_dir" && as_dir=.
6689   for ac_exec_ext in '' $ac_executable_extensions; do
6690   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6691     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6692     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6693     break 2
6694   fi
6695 done
6696 done
6697
6698 fi
6699 fi
6700 DLLTOOL=$ac_cv_prog_DLLTOOL
6701 if test -n "$DLLTOOL"; then
6702   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6703 echo "${ECHO_T}$DLLTOOL" >&6
6704 else
6705   echo "$as_me:$LINENO: result: no" >&5
6706 echo "${ECHO_T}no" >&6
6707 fi
6708
6709   fi
6710   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6711     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6712 set dummy ${ncn_progname}; ac_word=$2
6713 echo "$as_me:$LINENO: checking for $ac_word" >&5
6714 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6715 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6716   echo $ECHO_N "(cached) $ECHO_C" >&6
6717 else
6718   if test -n "$DLLTOOL"; then
6719   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6720 else
6721 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6722 for as_dir in $PATH
6723 do
6724   IFS=$as_save_IFS
6725   test -z "$as_dir" && as_dir=.
6726   for ac_exec_ext in '' $ac_executable_extensions; do
6727   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6728     ac_cv_prog_DLLTOOL="${ncn_progname}"
6729     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6730     break 2
6731   fi
6732 done
6733 done
6734
6735 fi
6736 fi
6737 DLLTOOL=$ac_cv_prog_DLLTOOL
6738 if test -n "$DLLTOOL"; then
6739   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6740 echo "${ECHO_T}$DLLTOOL" >&6
6741 else
6742   echo "$as_me:$LINENO: result: no" >&5
6743 echo "${ECHO_T}no" >&6
6744 fi
6745
6746   fi
6747   test -n "$ac_cv_prog_DLLTOOL" && break
6748 done
6749
6750 if test -z "$ac_cv_prog_DLLTOOL" ; then
6751   set dummy dlltool
6752   if test $build = $host ; then
6753     DLLTOOL="$2"
6754   else
6755     DLLTOOL="${ncn_tool_prefix}$2"
6756   fi
6757 fi
6758
6759
6760
6761 if test -n "$LD"; then
6762   ac_cv_prog_LD=$LD
6763 elif test -n "$ac_cv_prog_LD"; then
6764   LD=$ac_cv_prog_LD
6765 fi
6766
6767 if test -n "$ac_cv_prog_LD"; then
6768   for ncn_progname in ld; do
6769     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6770 set dummy ${ncn_progname}; ac_word=$2
6771 echo "$as_me:$LINENO: checking for $ac_word" >&5
6772 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6773 if test "${ac_cv_prog_LD+set}" = set; then
6774   echo $ECHO_N "(cached) $ECHO_C" >&6
6775 else
6776   if test -n "$LD"; then
6777   ac_cv_prog_LD="$LD" # Let the user override the test.
6778 else
6779 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6780 for as_dir in $PATH
6781 do
6782   IFS=$as_save_IFS
6783   test -z "$as_dir" && as_dir=.
6784   for ac_exec_ext in '' $ac_executable_extensions; do
6785   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6786     ac_cv_prog_LD="${ncn_progname}"
6787     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6788     break 2
6789   fi
6790 done
6791 done
6792
6793 fi
6794 fi
6795 LD=$ac_cv_prog_LD
6796 if test -n "$LD"; then
6797   echo "$as_me:$LINENO: result: $LD" >&5
6798 echo "${ECHO_T}$LD" >&6
6799 else
6800   echo "$as_me:$LINENO: result: no" >&5
6801 echo "${ECHO_T}no" >&6
6802 fi
6803
6804   done
6805 fi
6806
6807 for ncn_progname in ld; do
6808   if test -n "$ncn_tool_prefix"; then
6809     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6810 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6811 echo "$as_me:$LINENO: checking for $ac_word" >&5
6812 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6813 if test "${ac_cv_prog_LD+set}" = set; then
6814   echo $ECHO_N "(cached) $ECHO_C" >&6
6815 else
6816   if test -n "$LD"; then
6817   ac_cv_prog_LD="$LD" # Let the user override the test.
6818 else
6819 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6820 for as_dir in $PATH
6821 do
6822   IFS=$as_save_IFS
6823   test -z "$as_dir" && as_dir=.
6824   for ac_exec_ext in '' $ac_executable_extensions; do
6825   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6826     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6827     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6828     break 2
6829   fi
6830 done
6831 done
6832
6833 fi
6834 fi
6835 LD=$ac_cv_prog_LD
6836 if test -n "$LD"; then
6837   echo "$as_me:$LINENO: result: $LD" >&5
6838 echo "${ECHO_T}$LD" >&6
6839 else
6840   echo "$as_me:$LINENO: result: no" >&5
6841 echo "${ECHO_T}no" >&6
6842 fi
6843
6844   fi
6845   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6846     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6847 set dummy ${ncn_progname}; ac_word=$2
6848 echo "$as_me:$LINENO: checking for $ac_word" >&5
6849 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6850 if test "${ac_cv_prog_LD+set}" = set; then
6851   echo $ECHO_N "(cached) $ECHO_C" >&6
6852 else
6853   if test -n "$LD"; then
6854   ac_cv_prog_LD="$LD" # Let the user override the test.
6855 else
6856 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6857 for as_dir in $PATH
6858 do
6859   IFS=$as_save_IFS
6860   test -z "$as_dir" && as_dir=.
6861   for ac_exec_ext in '' $ac_executable_extensions; do
6862   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6863     ac_cv_prog_LD="${ncn_progname}"
6864     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6865     break 2
6866   fi
6867 done
6868 done
6869
6870 fi
6871 fi
6872 LD=$ac_cv_prog_LD
6873 if test -n "$LD"; then
6874   echo "$as_me:$LINENO: result: $LD" >&5
6875 echo "${ECHO_T}$LD" >&6
6876 else
6877   echo "$as_me:$LINENO: result: no" >&5
6878 echo "${ECHO_T}no" >&6
6879 fi
6880
6881   fi
6882   test -n "$ac_cv_prog_LD" && break
6883 done
6884
6885 if test -z "$ac_cv_prog_LD" ; then
6886   set dummy ld
6887   if test $build = $host ; then
6888     LD="$2"
6889   else
6890     LD="${ncn_tool_prefix}$2"
6891   fi
6892 fi
6893
6894
6895
6896 if test -n "$LIPO"; then
6897   ac_cv_prog_LIPO=$LIPO
6898 elif test -n "$ac_cv_prog_LIPO"; then
6899   LIPO=$ac_cv_prog_LIPO
6900 fi
6901
6902 if test -n "$ac_cv_prog_LIPO"; then
6903   for ncn_progname in lipo; do
6904     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6905 set dummy ${ncn_progname}; ac_word=$2
6906 echo "$as_me:$LINENO: checking for $ac_word" >&5
6907 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6908 if test "${ac_cv_prog_LIPO+set}" = set; then
6909   echo $ECHO_N "(cached) $ECHO_C" >&6
6910 else
6911   if test -n "$LIPO"; then
6912   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6913 else
6914 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6915 for as_dir in $PATH
6916 do
6917   IFS=$as_save_IFS
6918   test -z "$as_dir" && as_dir=.
6919   for ac_exec_ext in '' $ac_executable_extensions; do
6920   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6921     ac_cv_prog_LIPO="${ncn_progname}"
6922     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6923     break 2
6924   fi
6925 done
6926 done
6927
6928 fi
6929 fi
6930 LIPO=$ac_cv_prog_LIPO
6931 if test -n "$LIPO"; then
6932   echo "$as_me:$LINENO: result: $LIPO" >&5
6933 echo "${ECHO_T}$LIPO" >&6
6934 else
6935   echo "$as_me:$LINENO: result: no" >&5
6936 echo "${ECHO_T}no" >&6
6937 fi
6938
6939   done
6940 fi
6941
6942 for ncn_progname in lipo; do
6943   if test -n "$ncn_tool_prefix"; then
6944     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6945 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6946 echo "$as_me:$LINENO: checking for $ac_word" >&5
6947 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6948 if test "${ac_cv_prog_LIPO+set}" = set; then
6949   echo $ECHO_N "(cached) $ECHO_C" >&6
6950 else
6951   if test -n "$LIPO"; then
6952   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6953 else
6954 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6955 for as_dir in $PATH
6956 do
6957   IFS=$as_save_IFS
6958   test -z "$as_dir" && as_dir=.
6959   for ac_exec_ext in '' $ac_executable_extensions; do
6960   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6961     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
6962     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6963     break 2
6964   fi
6965 done
6966 done
6967
6968 fi
6969 fi
6970 LIPO=$ac_cv_prog_LIPO
6971 if test -n "$LIPO"; then
6972   echo "$as_me:$LINENO: result: $LIPO" >&5
6973 echo "${ECHO_T}$LIPO" >&6
6974 else
6975   echo "$as_me:$LINENO: result: no" >&5
6976 echo "${ECHO_T}no" >&6
6977 fi
6978
6979   fi
6980   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
6981     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6982 set dummy ${ncn_progname}; ac_word=$2
6983 echo "$as_me:$LINENO: checking for $ac_word" >&5
6984 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6985 if test "${ac_cv_prog_LIPO+set}" = set; then
6986   echo $ECHO_N "(cached) $ECHO_C" >&6
6987 else
6988   if test -n "$LIPO"; then
6989   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6990 else
6991 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6992 for as_dir in $PATH
6993 do
6994   IFS=$as_save_IFS
6995   test -z "$as_dir" && as_dir=.
6996   for ac_exec_ext in '' $ac_executable_extensions; do
6997   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6998     ac_cv_prog_LIPO="${ncn_progname}"
6999     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7000     break 2
7001   fi
7002 done
7003 done
7004
7005 fi
7006 fi
7007 LIPO=$ac_cv_prog_LIPO
7008 if test -n "$LIPO"; then
7009   echo "$as_me:$LINENO: result: $LIPO" >&5
7010 echo "${ECHO_T}$LIPO" >&6
7011 else
7012   echo "$as_me:$LINENO: result: no" >&5
7013 echo "${ECHO_T}no" >&6
7014 fi
7015
7016   fi
7017   test -n "$ac_cv_prog_LIPO" && break
7018 done
7019
7020 if test -z "$ac_cv_prog_LIPO" ; then
7021   set dummy lipo
7022   if test $build = $host ; then
7023     LIPO="$2"
7024   else
7025     LIPO="${ncn_tool_prefix}$2"
7026   fi
7027 fi
7028
7029
7030
7031 if test -n "$NM"; then
7032   ac_cv_prog_NM=$NM
7033 elif test -n "$ac_cv_prog_NM"; then
7034   NM=$ac_cv_prog_NM
7035 fi
7036
7037 if test -n "$ac_cv_prog_NM"; then
7038   for ncn_progname in nm; do
7039     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7040 set dummy ${ncn_progname}; ac_word=$2
7041 echo "$as_me:$LINENO: checking for $ac_word" >&5
7042 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7043 if test "${ac_cv_prog_NM+set}" = set; then
7044   echo $ECHO_N "(cached) $ECHO_C" >&6
7045 else
7046   if test -n "$NM"; then
7047   ac_cv_prog_NM="$NM" # Let the user override the test.
7048 else
7049 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7050 for as_dir in $PATH
7051 do
7052   IFS=$as_save_IFS
7053   test -z "$as_dir" && as_dir=.
7054   for ac_exec_ext in '' $ac_executable_extensions; do
7055   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7056     ac_cv_prog_NM="${ncn_progname}"
7057     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7058     break 2
7059   fi
7060 done
7061 done
7062
7063 fi
7064 fi
7065 NM=$ac_cv_prog_NM
7066 if test -n "$NM"; then
7067   echo "$as_me:$LINENO: result: $NM" >&5
7068 echo "${ECHO_T}$NM" >&6
7069 else
7070   echo "$as_me:$LINENO: result: no" >&5
7071 echo "${ECHO_T}no" >&6
7072 fi
7073
7074   done
7075 fi
7076
7077 for ncn_progname in nm; do
7078   if test -n "$ncn_tool_prefix"; then
7079     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7080 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7081 echo "$as_me:$LINENO: checking for $ac_word" >&5
7082 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7083 if test "${ac_cv_prog_NM+set}" = set; then
7084   echo $ECHO_N "(cached) $ECHO_C" >&6
7085 else
7086   if test -n "$NM"; then
7087   ac_cv_prog_NM="$NM" # Let the user override the test.
7088 else
7089 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7090 for as_dir in $PATH
7091 do
7092   IFS=$as_save_IFS
7093   test -z "$as_dir" && as_dir=.
7094   for ac_exec_ext in '' $ac_executable_extensions; do
7095   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7096     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7097     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7098     break 2
7099   fi
7100 done
7101 done
7102
7103 fi
7104 fi
7105 NM=$ac_cv_prog_NM
7106 if test -n "$NM"; then
7107   echo "$as_me:$LINENO: result: $NM" >&5
7108 echo "${ECHO_T}$NM" >&6
7109 else
7110   echo "$as_me:$LINENO: result: no" >&5
7111 echo "${ECHO_T}no" >&6
7112 fi
7113
7114   fi
7115   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7116     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7117 set dummy ${ncn_progname}; ac_word=$2
7118 echo "$as_me:$LINENO: checking for $ac_word" >&5
7119 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7120 if test "${ac_cv_prog_NM+set}" = set; then
7121   echo $ECHO_N "(cached) $ECHO_C" >&6
7122 else
7123   if test -n "$NM"; then
7124   ac_cv_prog_NM="$NM" # Let the user override the test.
7125 else
7126 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7127 for as_dir in $PATH
7128 do
7129   IFS=$as_save_IFS
7130   test -z "$as_dir" && as_dir=.
7131   for ac_exec_ext in '' $ac_executable_extensions; do
7132   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7133     ac_cv_prog_NM="${ncn_progname}"
7134     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7135     break 2
7136   fi
7137 done
7138 done
7139
7140 fi
7141 fi
7142 NM=$ac_cv_prog_NM
7143 if test -n "$NM"; then
7144   echo "$as_me:$LINENO: result: $NM" >&5
7145 echo "${ECHO_T}$NM" >&6
7146 else
7147   echo "$as_me:$LINENO: result: no" >&5
7148 echo "${ECHO_T}no" >&6
7149 fi
7150
7151   fi
7152   test -n "$ac_cv_prog_NM" && break
7153 done
7154
7155 if test -z "$ac_cv_prog_NM" ; then
7156   set dummy nm
7157   if test $build = $host ; then
7158     NM="$2"
7159   else
7160     NM="${ncn_tool_prefix}$2"
7161   fi
7162 fi
7163
7164
7165
7166 if test -n "$RANLIB"; then
7167   ac_cv_prog_RANLIB=$RANLIB
7168 elif test -n "$ac_cv_prog_RANLIB"; then
7169   RANLIB=$ac_cv_prog_RANLIB
7170 fi
7171
7172 if test -n "$ac_cv_prog_RANLIB"; then
7173   for ncn_progname in ranlib; do
7174     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7175 set dummy ${ncn_progname}; ac_word=$2
7176 echo "$as_me:$LINENO: checking for $ac_word" >&5
7177 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7178 if test "${ac_cv_prog_RANLIB+set}" = set; then
7179   echo $ECHO_N "(cached) $ECHO_C" >&6
7180 else
7181   if test -n "$RANLIB"; then
7182   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7183 else
7184 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7185 for as_dir in $PATH
7186 do
7187   IFS=$as_save_IFS
7188   test -z "$as_dir" && as_dir=.
7189   for ac_exec_ext in '' $ac_executable_extensions; do
7190   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7191     ac_cv_prog_RANLIB="${ncn_progname}"
7192     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7193     break 2
7194   fi
7195 done
7196 done
7197
7198 fi
7199 fi
7200 RANLIB=$ac_cv_prog_RANLIB
7201 if test -n "$RANLIB"; then
7202   echo "$as_me:$LINENO: result: $RANLIB" >&5
7203 echo "${ECHO_T}$RANLIB" >&6
7204 else
7205   echo "$as_me:$LINENO: result: no" >&5
7206 echo "${ECHO_T}no" >&6
7207 fi
7208
7209   done
7210 fi
7211
7212 for ncn_progname in ranlib; do
7213   if test -n "$ncn_tool_prefix"; then
7214     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7215 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7216 echo "$as_me:$LINENO: checking for $ac_word" >&5
7217 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7218 if test "${ac_cv_prog_RANLIB+set}" = set; then
7219   echo $ECHO_N "(cached) $ECHO_C" >&6
7220 else
7221   if test -n "$RANLIB"; then
7222   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7223 else
7224 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7225 for as_dir in $PATH
7226 do
7227   IFS=$as_save_IFS
7228   test -z "$as_dir" && as_dir=.
7229   for ac_exec_ext in '' $ac_executable_extensions; do
7230   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7231     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7232     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7233     break 2
7234   fi
7235 done
7236 done
7237
7238 fi
7239 fi
7240 RANLIB=$ac_cv_prog_RANLIB
7241 if test -n "$RANLIB"; then
7242   echo "$as_me:$LINENO: result: $RANLIB" >&5
7243 echo "${ECHO_T}$RANLIB" >&6
7244 else
7245   echo "$as_me:$LINENO: result: no" >&5
7246 echo "${ECHO_T}no" >&6
7247 fi
7248
7249   fi
7250   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7251     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7252 set dummy ${ncn_progname}; ac_word=$2
7253 echo "$as_me:$LINENO: checking for $ac_word" >&5
7254 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7255 if test "${ac_cv_prog_RANLIB+set}" = set; then
7256   echo $ECHO_N "(cached) $ECHO_C" >&6
7257 else
7258   if test -n "$RANLIB"; then
7259   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7260 else
7261 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7262 for as_dir in $PATH
7263 do
7264   IFS=$as_save_IFS
7265   test -z "$as_dir" && as_dir=.
7266   for ac_exec_ext in '' $ac_executable_extensions; do
7267   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7268     ac_cv_prog_RANLIB="${ncn_progname}"
7269     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7270     break 2
7271   fi
7272 done
7273 done
7274
7275 fi
7276 fi
7277 RANLIB=$ac_cv_prog_RANLIB
7278 if test -n "$RANLIB"; then
7279   echo "$as_me:$LINENO: result: $RANLIB" >&5
7280 echo "${ECHO_T}$RANLIB" >&6
7281 else
7282   echo "$as_me:$LINENO: result: no" >&5
7283 echo "${ECHO_T}no" >&6
7284 fi
7285
7286   fi
7287   test -n "$ac_cv_prog_RANLIB" && break
7288 done
7289
7290 if test -z "$ac_cv_prog_RANLIB" ; then
7291   RANLIB=":"
7292 fi
7293
7294
7295
7296 if test -n "$STRIP"; then
7297   ac_cv_prog_STRIP=$STRIP
7298 elif test -n "$ac_cv_prog_STRIP"; then
7299   STRIP=$ac_cv_prog_STRIP
7300 fi
7301
7302 if test -n "$ac_cv_prog_STRIP"; then
7303   for ncn_progname in strip; do
7304     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7305 set dummy ${ncn_progname}; ac_word=$2
7306 echo "$as_me:$LINENO: checking for $ac_word" >&5
7307 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7308 if test "${ac_cv_prog_STRIP+set}" = set; then
7309   echo $ECHO_N "(cached) $ECHO_C" >&6
7310 else
7311   if test -n "$STRIP"; then
7312   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7313 else
7314 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7315 for as_dir in $PATH
7316 do
7317   IFS=$as_save_IFS
7318   test -z "$as_dir" && as_dir=.
7319   for ac_exec_ext in '' $ac_executable_extensions; do
7320   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7321     ac_cv_prog_STRIP="${ncn_progname}"
7322     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7323     break 2
7324   fi
7325 done
7326 done
7327
7328 fi
7329 fi
7330 STRIP=$ac_cv_prog_STRIP
7331 if test -n "$STRIP"; then
7332   echo "$as_me:$LINENO: result: $STRIP" >&5
7333 echo "${ECHO_T}$STRIP" >&6
7334 else
7335   echo "$as_me:$LINENO: result: no" >&5
7336 echo "${ECHO_T}no" >&6
7337 fi
7338
7339   done
7340 fi
7341
7342 for ncn_progname in strip; do
7343   if test -n "$ncn_tool_prefix"; then
7344     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7345 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7346 echo "$as_me:$LINENO: checking for $ac_word" >&5
7347 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7348 if test "${ac_cv_prog_STRIP+set}" = set; then
7349   echo $ECHO_N "(cached) $ECHO_C" >&6
7350 else
7351   if test -n "$STRIP"; then
7352   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7353 else
7354 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7355 for as_dir in $PATH
7356 do
7357   IFS=$as_save_IFS
7358   test -z "$as_dir" && as_dir=.
7359   for ac_exec_ext in '' $ac_executable_extensions; do
7360   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7361     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7362     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7363     break 2
7364   fi
7365 done
7366 done
7367
7368 fi
7369 fi
7370 STRIP=$ac_cv_prog_STRIP
7371 if test -n "$STRIP"; then
7372   echo "$as_me:$LINENO: result: $STRIP" >&5
7373 echo "${ECHO_T}$STRIP" >&6
7374 else
7375   echo "$as_me:$LINENO: result: no" >&5
7376 echo "${ECHO_T}no" >&6
7377 fi
7378
7379   fi
7380   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7381     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7382 set dummy ${ncn_progname}; ac_word=$2
7383 echo "$as_me:$LINENO: checking for $ac_word" >&5
7384 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7385 if test "${ac_cv_prog_STRIP+set}" = set; then
7386   echo $ECHO_N "(cached) $ECHO_C" >&6
7387 else
7388   if test -n "$STRIP"; then
7389   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7390 else
7391 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7392 for as_dir in $PATH
7393 do
7394   IFS=$as_save_IFS
7395   test -z "$as_dir" && as_dir=.
7396   for ac_exec_ext in '' $ac_executable_extensions; do
7397   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7398     ac_cv_prog_STRIP="${ncn_progname}"
7399     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7400     break 2
7401   fi
7402 done
7403 done
7404
7405 fi
7406 fi
7407 STRIP=$ac_cv_prog_STRIP
7408 if test -n "$STRIP"; then
7409   echo "$as_me:$LINENO: result: $STRIP" >&5
7410 echo "${ECHO_T}$STRIP" >&6
7411 else
7412   echo "$as_me:$LINENO: result: no" >&5
7413 echo "${ECHO_T}no" >&6
7414 fi
7415
7416   fi
7417   test -n "$ac_cv_prog_STRIP" && break
7418 done
7419
7420 if test -z "$ac_cv_prog_STRIP" ; then
7421   STRIP=":"
7422 fi
7423
7424
7425
7426 if test -n "$WINDRES"; then
7427   ac_cv_prog_WINDRES=$WINDRES
7428 elif test -n "$ac_cv_prog_WINDRES"; then
7429   WINDRES=$ac_cv_prog_WINDRES
7430 fi
7431
7432 if test -n "$ac_cv_prog_WINDRES"; then
7433   for ncn_progname in windres; do
7434     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7435 set dummy ${ncn_progname}; ac_word=$2
7436 echo "$as_me:$LINENO: checking for $ac_word" >&5
7437 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7438 if test "${ac_cv_prog_WINDRES+set}" = set; then
7439   echo $ECHO_N "(cached) $ECHO_C" >&6
7440 else
7441   if test -n "$WINDRES"; then
7442   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7443 else
7444 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7445 for as_dir in $PATH
7446 do
7447   IFS=$as_save_IFS
7448   test -z "$as_dir" && as_dir=.
7449   for ac_exec_ext in '' $ac_executable_extensions; do
7450   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7451     ac_cv_prog_WINDRES="${ncn_progname}"
7452     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7453     break 2
7454   fi
7455 done
7456 done
7457
7458 fi
7459 fi
7460 WINDRES=$ac_cv_prog_WINDRES
7461 if test -n "$WINDRES"; then
7462   echo "$as_me:$LINENO: result: $WINDRES" >&5
7463 echo "${ECHO_T}$WINDRES" >&6
7464 else
7465   echo "$as_me:$LINENO: result: no" >&5
7466 echo "${ECHO_T}no" >&6
7467 fi
7468
7469   done
7470 fi
7471
7472 for ncn_progname in windres; do
7473   if test -n "$ncn_tool_prefix"; then
7474     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7475 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7476 echo "$as_me:$LINENO: checking for $ac_word" >&5
7477 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7478 if test "${ac_cv_prog_WINDRES+set}" = set; then
7479   echo $ECHO_N "(cached) $ECHO_C" >&6
7480 else
7481   if test -n "$WINDRES"; then
7482   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7483 else
7484 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7485 for as_dir in $PATH
7486 do
7487   IFS=$as_save_IFS
7488   test -z "$as_dir" && as_dir=.
7489   for ac_exec_ext in '' $ac_executable_extensions; do
7490   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7491     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7492     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7493     break 2
7494   fi
7495 done
7496 done
7497
7498 fi
7499 fi
7500 WINDRES=$ac_cv_prog_WINDRES
7501 if test -n "$WINDRES"; then
7502   echo "$as_me:$LINENO: result: $WINDRES" >&5
7503 echo "${ECHO_T}$WINDRES" >&6
7504 else
7505   echo "$as_me:$LINENO: result: no" >&5
7506 echo "${ECHO_T}no" >&6
7507 fi
7508
7509   fi
7510   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7511     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7512 set dummy ${ncn_progname}; ac_word=$2
7513 echo "$as_me:$LINENO: checking for $ac_word" >&5
7514 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7515 if test "${ac_cv_prog_WINDRES+set}" = set; then
7516   echo $ECHO_N "(cached) $ECHO_C" >&6
7517 else
7518   if test -n "$WINDRES"; then
7519   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7520 else
7521 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7522 for as_dir in $PATH
7523 do
7524   IFS=$as_save_IFS
7525   test -z "$as_dir" && as_dir=.
7526   for ac_exec_ext in '' $ac_executable_extensions; do
7527   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7528     ac_cv_prog_WINDRES="${ncn_progname}"
7529     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7530     break 2
7531   fi
7532 done
7533 done
7534
7535 fi
7536 fi
7537 WINDRES=$ac_cv_prog_WINDRES
7538 if test -n "$WINDRES"; then
7539   echo "$as_me:$LINENO: result: $WINDRES" >&5
7540 echo "${ECHO_T}$WINDRES" >&6
7541 else
7542   echo "$as_me:$LINENO: result: no" >&5
7543 echo "${ECHO_T}no" >&6
7544 fi
7545
7546   fi
7547   test -n "$ac_cv_prog_WINDRES" && break
7548 done
7549
7550 if test -z "$ac_cv_prog_WINDRES" ; then
7551   set dummy windres
7552   if test $build = $host ; then
7553     WINDRES="$2"
7554   else
7555     WINDRES="${ncn_tool_prefix}$2"
7556   fi
7557 fi
7558
7559
7560
7561 if test -n "$WINDMC"; then
7562   ac_cv_prog_WINDMC=$WINDMC
7563 elif test -n "$ac_cv_prog_WINDMC"; then
7564   WINDMC=$ac_cv_prog_WINDMC
7565 fi
7566
7567 if test -n "$ac_cv_prog_WINDMC"; then
7568   for ncn_progname in windmc; do
7569     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7570 set dummy ${ncn_progname}; ac_word=$2
7571 echo "$as_me:$LINENO: checking for $ac_word" >&5
7572 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7573 if test "${ac_cv_prog_WINDMC+set}" = set; then
7574   echo $ECHO_N "(cached) $ECHO_C" >&6
7575 else
7576   if test -n "$WINDMC"; then
7577   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7578 else
7579 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7580 for as_dir in $PATH
7581 do
7582   IFS=$as_save_IFS
7583   test -z "$as_dir" && as_dir=.
7584   for ac_exec_ext in '' $ac_executable_extensions; do
7585   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7586     ac_cv_prog_WINDMC="${ncn_progname}"
7587     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7588     break 2
7589   fi
7590 done
7591 done
7592
7593 fi
7594 fi
7595 WINDMC=$ac_cv_prog_WINDMC
7596 if test -n "$WINDMC"; then
7597   echo "$as_me:$LINENO: result: $WINDMC" >&5
7598 echo "${ECHO_T}$WINDMC" >&6
7599 else
7600   echo "$as_me:$LINENO: result: no" >&5
7601 echo "${ECHO_T}no" >&6
7602 fi
7603
7604   done
7605 fi
7606
7607 for ncn_progname in windmc; do
7608   if test -n "$ncn_tool_prefix"; then
7609     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7610 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7611 echo "$as_me:$LINENO: checking for $ac_word" >&5
7612 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7613 if test "${ac_cv_prog_WINDMC+set}" = set; then
7614   echo $ECHO_N "(cached) $ECHO_C" >&6
7615 else
7616   if test -n "$WINDMC"; then
7617   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7618 else
7619 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7620 for as_dir in $PATH
7621 do
7622   IFS=$as_save_IFS
7623   test -z "$as_dir" && as_dir=.
7624   for ac_exec_ext in '' $ac_executable_extensions; do
7625   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7626     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7627     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7628     break 2
7629   fi
7630 done
7631 done
7632
7633 fi
7634 fi
7635 WINDMC=$ac_cv_prog_WINDMC
7636 if test -n "$WINDMC"; then
7637   echo "$as_me:$LINENO: result: $WINDMC" >&5
7638 echo "${ECHO_T}$WINDMC" >&6
7639 else
7640   echo "$as_me:$LINENO: result: no" >&5
7641 echo "${ECHO_T}no" >&6
7642 fi
7643
7644   fi
7645   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7646     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7647 set dummy ${ncn_progname}; ac_word=$2
7648 echo "$as_me:$LINENO: checking for $ac_word" >&5
7649 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7650 if test "${ac_cv_prog_WINDMC+set}" = set; then
7651   echo $ECHO_N "(cached) $ECHO_C" >&6
7652 else
7653   if test -n "$WINDMC"; then
7654   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7655 else
7656 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7657 for as_dir in $PATH
7658 do
7659   IFS=$as_save_IFS
7660   test -z "$as_dir" && as_dir=.
7661   for ac_exec_ext in '' $ac_executable_extensions; do
7662   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7663     ac_cv_prog_WINDMC="${ncn_progname}"
7664     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7665     break 2
7666   fi
7667 done
7668 done
7669
7670 fi
7671 fi
7672 WINDMC=$ac_cv_prog_WINDMC
7673 if test -n "$WINDMC"; then
7674   echo "$as_me:$LINENO: result: $WINDMC" >&5
7675 echo "${ECHO_T}$WINDMC" >&6
7676 else
7677   echo "$as_me:$LINENO: result: no" >&5
7678 echo "${ECHO_T}no" >&6
7679 fi
7680
7681   fi
7682   test -n "$ac_cv_prog_WINDMC" && break
7683 done
7684
7685 if test -z "$ac_cv_prog_WINDMC" ; then
7686   set dummy windmc
7687   if test $build = $host ; then
7688     WINDMC="$2"
7689   else
7690     WINDMC="${ncn_tool_prefix}$2"
7691   fi
7692 fi
7693
7694
7695
7696 if test -n "$OBJCOPY"; then
7697   ac_cv_prog_OBJCOPY=$OBJCOPY
7698 elif test -n "$ac_cv_prog_OBJCOPY"; then
7699   OBJCOPY=$ac_cv_prog_OBJCOPY
7700 fi
7701
7702 if test -n "$ac_cv_prog_OBJCOPY"; then
7703   for ncn_progname in objcopy; do
7704     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7705 set dummy ${ncn_progname}; ac_word=$2
7706 echo "$as_me:$LINENO: checking for $ac_word" >&5
7707 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7708 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7709   echo $ECHO_N "(cached) $ECHO_C" >&6
7710 else
7711   if test -n "$OBJCOPY"; then
7712   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7713 else
7714 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7715 for as_dir in $PATH
7716 do
7717   IFS=$as_save_IFS
7718   test -z "$as_dir" && as_dir=.
7719   for ac_exec_ext in '' $ac_executable_extensions; do
7720   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7721     ac_cv_prog_OBJCOPY="${ncn_progname}"
7722     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7723     break 2
7724   fi
7725 done
7726 done
7727
7728 fi
7729 fi
7730 OBJCOPY=$ac_cv_prog_OBJCOPY
7731 if test -n "$OBJCOPY"; then
7732   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7733 echo "${ECHO_T}$OBJCOPY" >&6
7734 else
7735   echo "$as_me:$LINENO: result: no" >&5
7736 echo "${ECHO_T}no" >&6
7737 fi
7738
7739   done
7740 fi
7741
7742 for ncn_progname in objcopy; do
7743   if test -n "$ncn_tool_prefix"; then
7744     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7745 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7746 echo "$as_me:$LINENO: checking for $ac_word" >&5
7747 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7748 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7749   echo $ECHO_N "(cached) $ECHO_C" >&6
7750 else
7751   if test -n "$OBJCOPY"; then
7752   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7753 else
7754 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7755 for as_dir in $PATH
7756 do
7757   IFS=$as_save_IFS
7758   test -z "$as_dir" && as_dir=.
7759   for ac_exec_ext in '' $ac_executable_extensions; do
7760   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7761     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7762     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7763     break 2
7764   fi
7765 done
7766 done
7767
7768 fi
7769 fi
7770 OBJCOPY=$ac_cv_prog_OBJCOPY
7771 if test -n "$OBJCOPY"; then
7772   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7773 echo "${ECHO_T}$OBJCOPY" >&6
7774 else
7775   echo "$as_me:$LINENO: result: no" >&5
7776 echo "${ECHO_T}no" >&6
7777 fi
7778
7779   fi
7780   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7781     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7782 set dummy ${ncn_progname}; ac_word=$2
7783 echo "$as_me:$LINENO: checking for $ac_word" >&5
7784 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7785 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7786   echo $ECHO_N "(cached) $ECHO_C" >&6
7787 else
7788   if test -n "$OBJCOPY"; then
7789   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7790 else
7791 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7792 for as_dir in $PATH
7793 do
7794   IFS=$as_save_IFS
7795   test -z "$as_dir" && as_dir=.
7796   for ac_exec_ext in '' $ac_executable_extensions; do
7797   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7798     ac_cv_prog_OBJCOPY="${ncn_progname}"
7799     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7800     break 2
7801   fi
7802 done
7803 done
7804
7805 fi
7806 fi
7807 OBJCOPY=$ac_cv_prog_OBJCOPY
7808 if test -n "$OBJCOPY"; then
7809   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7810 echo "${ECHO_T}$OBJCOPY" >&6
7811 else
7812   echo "$as_me:$LINENO: result: no" >&5
7813 echo "${ECHO_T}no" >&6
7814 fi
7815
7816   fi
7817   test -n "$ac_cv_prog_OBJCOPY" && break
7818 done
7819
7820 if test -z "$ac_cv_prog_OBJCOPY" ; then
7821   set dummy objcopy
7822   if test $build = $host ; then
7823     OBJCOPY="$2"
7824   else
7825     OBJCOPY="${ncn_tool_prefix}$2"
7826   fi
7827 fi
7828
7829
7830
7831 if test -n "$OBJDUMP"; then
7832   ac_cv_prog_OBJDUMP=$OBJDUMP
7833 elif test -n "$ac_cv_prog_OBJDUMP"; then
7834   OBJDUMP=$ac_cv_prog_OBJDUMP
7835 fi
7836
7837 if test -n "$ac_cv_prog_OBJDUMP"; then
7838   for ncn_progname in objdump; do
7839     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7840 set dummy ${ncn_progname}; ac_word=$2
7841 echo "$as_me:$LINENO: checking for $ac_word" >&5
7842 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7843 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7844   echo $ECHO_N "(cached) $ECHO_C" >&6
7845 else
7846   if test -n "$OBJDUMP"; then
7847   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7848 else
7849 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7850 for as_dir in $PATH
7851 do
7852   IFS=$as_save_IFS
7853   test -z "$as_dir" && as_dir=.
7854   for ac_exec_ext in '' $ac_executable_extensions; do
7855   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7856     ac_cv_prog_OBJDUMP="${ncn_progname}"
7857     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7858     break 2
7859   fi
7860 done
7861 done
7862
7863 fi
7864 fi
7865 OBJDUMP=$ac_cv_prog_OBJDUMP
7866 if test -n "$OBJDUMP"; then
7867   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7868 echo "${ECHO_T}$OBJDUMP" >&6
7869 else
7870   echo "$as_me:$LINENO: result: no" >&5
7871 echo "${ECHO_T}no" >&6
7872 fi
7873
7874   done
7875 fi
7876
7877 for ncn_progname in objdump; do
7878   if test -n "$ncn_tool_prefix"; then
7879     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7880 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7881 echo "$as_me:$LINENO: checking for $ac_word" >&5
7882 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7883 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7884   echo $ECHO_N "(cached) $ECHO_C" >&6
7885 else
7886   if test -n "$OBJDUMP"; then
7887   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7888 else
7889 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7890 for as_dir in $PATH
7891 do
7892   IFS=$as_save_IFS
7893   test -z "$as_dir" && as_dir=.
7894   for ac_exec_ext in '' $ac_executable_extensions; do
7895   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7896     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7897     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7898     break 2
7899   fi
7900 done
7901 done
7902
7903 fi
7904 fi
7905 OBJDUMP=$ac_cv_prog_OBJDUMP
7906 if test -n "$OBJDUMP"; then
7907   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7908 echo "${ECHO_T}$OBJDUMP" >&6
7909 else
7910   echo "$as_me:$LINENO: result: no" >&5
7911 echo "${ECHO_T}no" >&6
7912 fi
7913
7914   fi
7915   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7916     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7917 set dummy ${ncn_progname}; ac_word=$2
7918 echo "$as_me:$LINENO: checking for $ac_word" >&5
7919 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7920 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7921   echo $ECHO_N "(cached) $ECHO_C" >&6
7922 else
7923   if test -n "$OBJDUMP"; then
7924   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7925 else
7926 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7927 for as_dir in $PATH
7928 do
7929   IFS=$as_save_IFS
7930   test -z "$as_dir" && as_dir=.
7931   for ac_exec_ext in '' $ac_executable_extensions; do
7932   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7933     ac_cv_prog_OBJDUMP="${ncn_progname}"
7934     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7935     break 2
7936   fi
7937 done
7938 done
7939
7940 fi
7941 fi
7942 OBJDUMP=$ac_cv_prog_OBJDUMP
7943 if test -n "$OBJDUMP"; then
7944   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7945 echo "${ECHO_T}$OBJDUMP" >&6
7946 else
7947   echo "$as_me:$LINENO: result: no" >&5
7948 echo "${ECHO_T}no" >&6
7949 fi
7950
7951   fi
7952   test -n "$ac_cv_prog_OBJDUMP" && break
7953 done
7954
7955 if test -z "$ac_cv_prog_OBJDUMP" ; then
7956   set dummy objdump
7957   if test $build = $host ; then
7958     OBJDUMP="$2"
7959   else
7960     OBJDUMP="${ncn_tool_prefix}$2"
7961   fi
7962 fi
7963
7964
7965
7966
7967
7968
7969 # Target tools.
7970
7971 # Check whether --with-build-time-tools or --without-build-time-tools was given.
7972 if test "${with_build_time_tools+set}" = set; then
7973   withval="$with_build_time_tools"
7974   case x"$withval" in
7975      x/*) ;;
7976      *)
7977        with_build_time_tools=
7978        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
7979 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
7980        ;;
7981    esac
7982 else
7983   with_build_time_tools=
7984 fi;
7985
7986
7987
7988 if test -n "$CC_FOR_TARGET"; then
7989   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
7990 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7991   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7992 fi
7993
7994 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7995   for ncn_progname in cc gcc; do
7996     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7997 set dummy ${ncn_progname}; ac_word=$2
7998 echo "$as_me:$LINENO: checking for $ac_word" >&5
7999 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8000 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8001   echo $ECHO_N "(cached) $ECHO_C" >&6
8002 else
8003   if test -n "$CC_FOR_TARGET"; then
8004   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8005 else
8006 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8007 for as_dir in $PATH
8008 do
8009   IFS=$as_save_IFS
8010   test -z "$as_dir" && as_dir=.
8011   for ac_exec_ext in '' $ac_executable_extensions; do
8012   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8013     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8014     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8015     break 2
8016   fi
8017 done
8018 done
8019
8020 fi
8021 fi
8022 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8023 if test -n "$CC_FOR_TARGET"; then
8024   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8025 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8026 else
8027   echo "$as_me:$LINENO: result: no" >&5
8028 echo "${ECHO_T}no" >&6
8029 fi
8030
8031   done
8032 fi
8033
8034 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8035   for ncn_progname in cc gcc; do
8036     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8037 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8038     if test -x $with_build_time_tools/${ncn_progname}; then
8039       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8040       echo "$as_me:$LINENO: result: yes" >&5
8041 echo "${ECHO_T}yes" >&6
8042       break
8043     else
8044       echo "$as_me:$LINENO: result: no" >&5
8045 echo "${ECHO_T}no" >&6
8046     fi
8047   done
8048 fi
8049
8050 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8051   for ncn_progname in cc gcc; do
8052     if test -n "$ncn_target_tool_prefix"; then
8053       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8054 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8055 echo "$as_me:$LINENO: checking for $ac_word" >&5
8056 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8057 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8058   echo $ECHO_N "(cached) $ECHO_C" >&6
8059 else
8060   if test -n "$CC_FOR_TARGET"; then
8061   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8062 else
8063 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8064 for as_dir in $PATH
8065 do
8066   IFS=$as_save_IFS
8067   test -z "$as_dir" && as_dir=.
8068   for ac_exec_ext in '' $ac_executable_extensions; do
8069   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8070     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8071     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8072     break 2
8073   fi
8074 done
8075 done
8076
8077 fi
8078 fi
8079 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8080 if test -n "$CC_FOR_TARGET"; then
8081   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8082 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8083 else
8084   echo "$as_me:$LINENO: result: no" >&5
8085 echo "${ECHO_T}no" >&6
8086 fi
8087
8088     fi
8089     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8090       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8091 set dummy ${ncn_progname}; ac_word=$2
8092 echo "$as_me:$LINENO: checking for $ac_word" >&5
8093 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8094 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8095   echo $ECHO_N "(cached) $ECHO_C" >&6
8096 else
8097   if test -n "$CC_FOR_TARGET"; then
8098   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8099 else
8100 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8101 for as_dir in $PATH
8102 do
8103   IFS=$as_save_IFS
8104   test -z "$as_dir" && as_dir=.
8105   for ac_exec_ext in '' $ac_executable_extensions; do
8106   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8107     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8108     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8109     break 2
8110   fi
8111 done
8112 done
8113
8114 fi
8115 fi
8116 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8117 if test -n "$CC_FOR_TARGET"; then
8118   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8119 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8120 else
8121   echo "$as_me:$LINENO: result: no" >&5
8122 echo "${ECHO_T}no" >&6
8123 fi
8124
8125     fi
8126     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8127   done
8128 fi
8129
8130 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8131   set dummy cc gcc
8132   if test $build = $target ; then
8133     CC_FOR_TARGET="$2"
8134   else
8135     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8136   fi
8137 else
8138   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8139 fi
8140
8141
8142
8143 if test -n "$CXX_FOR_TARGET"; then
8144   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8145 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8146   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8147 fi
8148
8149 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8150   for ncn_progname in c++ g++ cxx gxx; do
8151     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8152 set dummy ${ncn_progname}; ac_word=$2
8153 echo "$as_me:$LINENO: checking for $ac_word" >&5
8154 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8155 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8156   echo $ECHO_N "(cached) $ECHO_C" >&6
8157 else
8158   if test -n "$CXX_FOR_TARGET"; then
8159   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8160 else
8161 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8162 for as_dir in $PATH
8163 do
8164   IFS=$as_save_IFS
8165   test -z "$as_dir" && as_dir=.
8166   for ac_exec_ext in '' $ac_executable_extensions; do
8167   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8168     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8169     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8170     break 2
8171   fi
8172 done
8173 done
8174
8175 fi
8176 fi
8177 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8178 if test -n "$CXX_FOR_TARGET"; then
8179   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8180 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8181 else
8182   echo "$as_me:$LINENO: result: no" >&5
8183 echo "${ECHO_T}no" >&6
8184 fi
8185
8186   done
8187 fi
8188
8189 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8190   for ncn_progname in c++ g++ cxx gxx; do
8191     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8192 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8193     if test -x $with_build_time_tools/${ncn_progname}; then
8194       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8195       echo "$as_me:$LINENO: result: yes" >&5
8196 echo "${ECHO_T}yes" >&6
8197       break
8198     else
8199       echo "$as_me:$LINENO: result: no" >&5
8200 echo "${ECHO_T}no" >&6
8201     fi
8202   done
8203 fi
8204
8205 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8206   for ncn_progname in c++ g++ cxx gxx; do
8207     if test -n "$ncn_target_tool_prefix"; then
8208       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8209 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8210 echo "$as_me:$LINENO: checking for $ac_word" >&5
8211 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8212 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8213   echo $ECHO_N "(cached) $ECHO_C" >&6
8214 else
8215   if test -n "$CXX_FOR_TARGET"; then
8216   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8217 else
8218 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8219 for as_dir in $PATH
8220 do
8221   IFS=$as_save_IFS
8222   test -z "$as_dir" && as_dir=.
8223   for ac_exec_ext in '' $ac_executable_extensions; do
8224   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8225     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8226     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8227     break 2
8228   fi
8229 done
8230 done
8231
8232 fi
8233 fi
8234 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8235 if test -n "$CXX_FOR_TARGET"; then
8236   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8237 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8238 else
8239   echo "$as_me:$LINENO: result: no" >&5
8240 echo "${ECHO_T}no" >&6
8241 fi
8242
8243     fi
8244     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8245       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8246 set dummy ${ncn_progname}; ac_word=$2
8247 echo "$as_me:$LINENO: checking for $ac_word" >&5
8248 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8249 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8250   echo $ECHO_N "(cached) $ECHO_C" >&6
8251 else
8252   if test -n "$CXX_FOR_TARGET"; then
8253   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8254 else
8255 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8256 for as_dir in $PATH
8257 do
8258   IFS=$as_save_IFS
8259   test -z "$as_dir" && as_dir=.
8260   for ac_exec_ext in '' $ac_executable_extensions; do
8261   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8262     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8263     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8264     break 2
8265   fi
8266 done
8267 done
8268
8269 fi
8270 fi
8271 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8272 if test -n "$CXX_FOR_TARGET"; then
8273   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8274 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8275 else
8276   echo "$as_me:$LINENO: result: no" >&5
8277 echo "${ECHO_T}no" >&6
8278 fi
8279
8280     fi
8281     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8282   done
8283 fi
8284
8285 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8286   set dummy c++ g++ cxx gxx
8287   if test $build = $target ; then
8288     CXX_FOR_TARGET="$2"
8289   else
8290     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8291   fi
8292 else
8293   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8294 fi
8295
8296
8297
8298 if test -n "$GCC_FOR_TARGET"; then
8299   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8300 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8301   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8302 fi
8303
8304 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8305   for ncn_progname in gcc; do
8306     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8307 set dummy ${ncn_progname}; ac_word=$2
8308 echo "$as_me:$LINENO: checking for $ac_word" >&5
8309 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8310 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8311   echo $ECHO_N "(cached) $ECHO_C" >&6
8312 else
8313   if test -n "$GCC_FOR_TARGET"; then
8314   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8315 else
8316 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8317 for as_dir in $PATH
8318 do
8319   IFS=$as_save_IFS
8320   test -z "$as_dir" && as_dir=.
8321   for ac_exec_ext in '' $ac_executable_extensions; do
8322   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8323     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8324     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8325     break 2
8326   fi
8327 done
8328 done
8329
8330 fi
8331 fi
8332 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8333 if test -n "$GCC_FOR_TARGET"; then
8334   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8335 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8336 else
8337   echo "$as_me:$LINENO: result: no" >&5
8338 echo "${ECHO_T}no" >&6
8339 fi
8340
8341   done
8342 fi
8343
8344 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8345   for ncn_progname in gcc; do
8346     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8347 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8348     if test -x $with_build_time_tools/${ncn_progname}; then
8349       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8350       echo "$as_me:$LINENO: result: yes" >&5
8351 echo "${ECHO_T}yes" >&6
8352       break
8353     else
8354       echo "$as_me:$LINENO: result: no" >&5
8355 echo "${ECHO_T}no" >&6
8356     fi
8357   done
8358 fi
8359
8360 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8361   for ncn_progname in gcc; do
8362     if test -n "$ncn_target_tool_prefix"; then
8363       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8364 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8365 echo "$as_me:$LINENO: checking for $ac_word" >&5
8366 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8367 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8368   echo $ECHO_N "(cached) $ECHO_C" >&6
8369 else
8370   if test -n "$GCC_FOR_TARGET"; then
8371   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8372 else
8373 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8374 for as_dir in $PATH
8375 do
8376   IFS=$as_save_IFS
8377   test -z "$as_dir" && as_dir=.
8378   for ac_exec_ext in '' $ac_executable_extensions; do
8379   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8380     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8381     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8382     break 2
8383   fi
8384 done
8385 done
8386
8387 fi
8388 fi
8389 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8390 if test -n "$GCC_FOR_TARGET"; then
8391   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8392 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8393 else
8394   echo "$as_me:$LINENO: result: no" >&5
8395 echo "${ECHO_T}no" >&6
8396 fi
8397
8398     fi
8399     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8400       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8401 set dummy ${ncn_progname}; ac_word=$2
8402 echo "$as_me:$LINENO: checking for $ac_word" >&5
8403 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8404 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8405   echo $ECHO_N "(cached) $ECHO_C" >&6
8406 else
8407   if test -n "$GCC_FOR_TARGET"; then
8408   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8409 else
8410 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8411 for as_dir in $PATH
8412 do
8413   IFS=$as_save_IFS
8414   test -z "$as_dir" && as_dir=.
8415   for ac_exec_ext in '' $ac_executable_extensions; do
8416   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8417     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8418     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8419     break 2
8420   fi
8421 done
8422 done
8423
8424 fi
8425 fi
8426 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8427 if test -n "$GCC_FOR_TARGET"; then
8428   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8429 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8430 else
8431   echo "$as_me:$LINENO: result: no" >&5
8432 echo "${ECHO_T}no" >&6
8433 fi
8434
8435     fi
8436     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8437   done
8438 fi
8439
8440 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8441   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8442 else
8443   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8444 fi
8445
8446
8447
8448 if test -n "$GCJ_FOR_TARGET"; then
8449   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8450 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8451   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8452 fi
8453
8454 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8455   for ncn_progname in gcj; do
8456     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8457 set dummy ${ncn_progname}; ac_word=$2
8458 echo "$as_me:$LINENO: checking for $ac_word" >&5
8459 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8460 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8461   echo $ECHO_N "(cached) $ECHO_C" >&6
8462 else
8463   if test -n "$GCJ_FOR_TARGET"; then
8464   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8465 else
8466 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8467 for as_dir in $PATH
8468 do
8469   IFS=$as_save_IFS
8470   test -z "$as_dir" && as_dir=.
8471   for ac_exec_ext in '' $ac_executable_extensions; do
8472   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8473     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8474     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8475     break 2
8476   fi
8477 done
8478 done
8479
8480 fi
8481 fi
8482 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8483 if test -n "$GCJ_FOR_TARGET"; then
8484   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8485 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8486 else
8487   echo "$as_me:$LINENO: result: no" >&5
8488 echo "${ECHO_T}no" >&6
8489 fi
8490
8491   done
8492 fi
8493
8494 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8495   for ncn_progname in gcj; do
8496     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8497 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8498     if test -x $with_build_time_tools/${ncn_progname}; then
8499       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8500       echo "$as_me:$LINENO: result: yes" >&5
8501 echo "${ECHO_T}yes" >&6
8502       break
8503     else
8504       echo "$as_me:$LINENO: result: no" >&5
8505 echo "${ECHO_T}no" >&6
8506     fi
8507   done
8508 fi
8509
8510 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8511   for ncn_progname in gcj; do
8512     if test -n "$ncn_target_tool_prefix"; then
8513       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8514 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8515 echo "$as_me:$LINENO: checking for $ac_word" >&5
8516 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8517 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8518   echo $ECHO_N "(cached) $ECHO_C" >&6
8519 else
8520   if test -n "$GCJ_FOR_TARGET"; then
8521   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8522 else
8523 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8524 for as_dir in $PATH
8525 do
8526   IFS=$as_save_IFS
8527   test -z "$as_dir" && as_dir=.
8528   for ac_exec_ext in '' $ac_executable_extensions; do
8529   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8530     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8531     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8532     break 2
8533   fi
8534 done
8535 done
8536
8537 fi
8538 fi
8539 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8540 if test -n "$GCJ_FOR_TARGET"; then
8541   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8542 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8543 else
8544   echo "$as_me:$LINENO: result: no" >&5
8545 echo "${ECHO_T}no" >&6
8546 fi
8547
8548     fi
8549     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8550       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8551 set dummy ${ncn_progname}; ac_word=$2
8552 echo "$as_me:$LINENO: checking for $ac_word" >&5
8553 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8554 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8555   echo $ECHO_N "(cached) $ECHO_C" >&6
8556 else
8557   if test -n "$GCJ_FOR_TARGET"; then
8558   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8559 else
8560 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8561 for as_dir in $PATH
8562 do
8563   IFS=$as_save_IFS
8564   test -z "$as_dir" && as_dir=.
8565   for ac_exec_ext in '' $ac_executable_extensions; do
8566   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8567     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8568     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8569     break 2
8570   fi
8571 done
8572 done
8573
8574 fi
8575 fi
8576 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8577 if test -n "$GCJ_FOR_TARGET"; then
8578   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8579 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8580 else
8581   echo "$as_me:$LINENO: result: no" >&5
8582 echo "${ECHO_T}no" >&6
8583 fi
8584
8585     fi
8586     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8587   done
8588 fi
8589
8590 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8591   set dummy gcj
8592   if test $build = $target ; then
8593     GCJ_FOR_TARGET="$2"
8594   else
8595     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8596   fi
8597 else
8598   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8599 fi
8600
8601
8602
8603 if test -n "$GFORTRAN_FOR_TARGET"; then
8604   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8605 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8606   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8607 fi
8608
8609 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8610   for ncn_progname in gfortran; do
8611     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8612 set dummy ${ncn_progname}; ac_word=$2
8613 echo "$as_me:$LINENO: checking for $ac_word" >&5
8614 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8615 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8616   echo $ECHO_N "(cached) $ECHO_C" >&6
8617 else
8618   if test -n "$GFORTRAN_FOR_TARGET"; then
8619   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8620 else
8621 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8622 for as_dir in $PATH
8623 do
8624   IFS=$as_save_IFS
8625   test -z "$as_dir" && as_dir=.
8626   for ac_exec_ext in '' $ac_executable_extensions; do
8627   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8628     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8629     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8630     break 2
8631   fi
8632 done
8633 done
8634
8635 fi
8636 fi
8637 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8638 if test -n "$GFORTRAN_FOR_TARGET"; then
8639   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8640 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8641 else
8642   echo "$as_me:$LINENO: result: no" >&5
8643 echo "${ECHO_T}no" >&6
8644 fi
8645
8646   done
8647 fi
8648
8649 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8650   for ncn_progname in gfortran; do
8651     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8652 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8653     if test -x $with_build_time_tools/${ncn_progname}; then
8654       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8655       echo "$as_me:$LINENO: result: yes" >&5
8656 echo "${ECHO_T}yes" >&6
8657       break
8658     else
8659       echo "$as_me:$LINENO: result: no" >&5
8660 echo "${ECHO_T}no" >&6
8661     fi
8662   done
8663 fi
8664
8665 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8666   for ncn_progname in gfortran; do
8667     if test -n "$ncn_target_tool_prefix"; then
8668       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8669 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8670 echo "$as_me:$LINENO: checking for $ac_word" >&5
8671 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8672 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8673   echo $ECHO_N "(cached) $ECHO_C" >&6
8674 else
8675   if test -n "$GFORTRAN_FOR_TARGET"; then
8676   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8677 else
8678 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8679 for as_dir in $PATH
8680 do
8681   IFS=$as_save_IFS
8682   test -z "$as_dir" && as_dir=.
8683   for ac_exec_ext in '' $ac_executable_extensions; do
8684   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8685     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8686     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8687     break 2
8688   fi
8689 done
8690 done
8691
8692 fi
8693 fi
8694 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8695 if test -n "$GFORTRAN_FOR_TARGET"; then
8696   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8697 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8698 else
8699   echo "$as_me:$LINENO: result: no" >&5
8700 echo "${ECHO_T}no" >&6
8701 fi
8702
8703     fi
8704     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8705       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8706 set dummy ${ncn_progname}; ac_word=$2
8707 echo "$as_me:$LINENO: checking for $ac_word" >&5
8708 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8709 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8710   echo $ECHO_N "(cached) $ECHO_C" >&6
8711 else
8712   if test -n "$GFORTRAN_FOR_TARGET"; then
8713   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8714 else
8715 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8716 for as_dir in $PATH
8717 do
8718   IFS=$as_save_IFS
8719   test -z "$as_dir" && as_dir=.
8720   for ac_exec_ext in '' $ac_executable_extensions; do
8721   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8722     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8723     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8724     break 2
8725   fi
8726 done
8727 done
8728
8729 fi
8730 fi
8731 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8732 if test -n "$GFORTRAN_FOR_TARGET"; then
8733   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8734 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8735 else
8736   echo "$as_me:$LINENO: result: no" >&5
8737 echo "${ECHO_T}no" >&6
8738 fi
8739
8740     fi
8741     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8742   done
8743 fi
8744
8745 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8746   set dummy gfortran
8747   if test $build = $target ; then
8748     GFORTRAN_FOR_TARGET="$2"
8749   else
8750     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8751   fi
8752 else
8753   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8754 fi
8755
8756
8757
8758 cat > conftest.c << \EOF
8759 #ifdef __GNUC__
8760   gcc_yay;
8761 #endif
8762 EOF
8763 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8764   have_gcc_for_target=yes
8765 else
8766   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8767   have_gcc_for_target=no
8768 fi
8769 rm conftest.c
8770
8771
8772
8773
8774 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8775   if test -n "$with_build_time_tools"; then
8776     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8777 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8778     if test -x $with_build_time_tools/ar; then
8779       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8780       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8781       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8782 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8783     else
8784       echo "$as_me:$LINENO: result: no" >&5
8785 echo "${ECHO_T}no" >&6
8786     fi
8787   elif test $build != $host && test $have_gcc_for_target = yes; then
8788     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8789     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8790     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8791   fi
8792 fi
8793 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8794   # Extract the first word of "ar", so it can be a program name with args.
8795 set dummy ar; ac_word=$2
8796 echo "$as_me:$LINENO: checking for $ac_word" >&5
8797 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8798 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8799   echo $ECHO_N "(cached) $ECHO_C" >&6
8800 else
8801   case $AR_FOR_TARGET in
8802   [\\/]* | ?:[\\/]*)
8803   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8804   ;;
8805   *)
8806   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8807 for as_dir in $gcc_cv_tool_dirs
8808 do
8809   IFS=$as_save_IFS
8810   test -z "$as_dir" && as_dir=.
8811   for ac_exec_ext in '' $ac_executable_extensions; do
8812   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8813     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8814     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8815     break 2
8816   fi
8817 done
8818 done
8819
8820   ;;
8821 esac
8822 fi
8823 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8824
8825 if test -n "$AR_FOR_TARGET"; then
8826   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8827 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8828 else
8829   echo "$as_me:$LINENO: result: no" >&5
8830 echo "${ECHO_T}no" >&6
8831 fi
8832
8833 fi
8834 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8835
8836
8837 if test -n "$AR_FOR_TARGET"; then
8838   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8839 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8840   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8841 fi
8842
8843 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8844   for ncn_progname in ar; do
8845     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8846 set dummy ${ncn_progname}; ac_word=$2
8847 echo "$as_me:$LINENO: checking for $ac_word" >&5
8848 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8849 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8850   echo $ECHO_N "(cached) $ECHO_C" >&6
8851 else
8852   if test -n "$AR_FOR_TARGET"; then
8853   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8854 else
8855 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8856 for as_dir in $PATH
8857 do
8858   IFS=$as_save_IFS
8859   test -z "$as_dir" && as_dir=.
8860   for ac_exec_ext in '' $ac_executable_extensions; do
8861   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8862     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8863     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8864     break 2
8865   fi
8866 done
8867 done
8868
8869 fi
8870 fi
8871 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8872 if test -n "$AR_FOR_TARGET"; then
8873   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8874 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8875 else
8876   echo "$as_me:$LINENO: result: no" >&5
8877 echo "${ECHO_T}no" >&6
8878 fi
8879
8880   done
8881 fi
8882
8883 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8884   for ncn_progname in ar; do
8885     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8886 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8887     if test -x $with_build_time_tools/${ncn_progname}; then
8888       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8889       echo "$as_me:$LINENO: result: yes" >&5
8890 echo "${ECHO_T}yes" >&6
8891       break
8892     else
8893       echo "$as_me:$LINENO: result: no" >&5
8894 echo "${ECHO_T}no" >&6
8895     fi
8896   done
8897 fi
8898
8899 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8900   for ncn_progname in ar; do
8901     if test -n "$ncn_target_tool_prefix"; then
8902       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8903 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8904 echo "$as_me:$LINENO: checking for $ac_word" >&5
8905 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8906 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8907   echo $ECHO_N "(cached) $ECHO_C" >&6
8908 else
8909   if test -n "$AR_FOR_TARGET"; then
8910   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8911 else
8912 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8913 for as_dir in $PATH
8914 do
8915   IFS=$as_save_IFS
8916   test -z "$as_dir" && as_dir=.
8917   for ac_exec_ext in '' $ac_executable_extensions; do
8918   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8919     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8920     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8921     break 2
8922   fi
8923 done
8924 done
8925
8926 fi
8927 fi
8928 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8929 if test -n "$AR_FOR_TARGET"; then
8930   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8931 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8932 else
8933   echo "$as_me:$LINENO: result: no" >&5
8934 echo "${ECHO_T}no" >&6
8935 fi
8936
8937     fi
8938     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
8939       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8940 set dummy ${ncn_progname}; ac_word=$2
8941 echo "$as_me:$LINENO: checking for $ac_word" >&5
8942 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8943 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8944   echo $ECHO_N "(cached) $ECHO_C" >&6
8945 else
8946   if test -n "$AR_FOR_TARGET"; then
8947   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8948 else
8949 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8950 for as_dir in $PATH
8951 do
8952   IFS=$as_save_IFS
8953   test -z "$as_dir" && as_dir=.
8954   for ac_exec_ext in '' $ac_executable_extensions; do
8955   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8956     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8957     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8958     break 2
8959   fi
8960 done
8961 done
8962
8963 fi
8964 fi
8965 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8966 if test -n "$AR_FOR_TARGET"; then
8967   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8968 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8969 else
8970   echo "$as_me:$LINENO: result: no" >&5
8971 echo "${ECHO_T}no" >&6
8972 fi
8973
8974     fi
8975     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
8976   done
8977 fi
8978
8979 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
8980   set dummy ar
8981   if test $build = $target ; then
8982     AR_FOR_TARGET="$2"
8983   else
8984     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
8985   fi
8986 else
8987   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
8988 fi
8989
8990 else
8991   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8992 fi
8993
8994
8995
8996
8997 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8998   if test -n "$with_build_time_tools"; then
8999     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9000 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9001     if test -x $with_build_time_tools/as; then
9002       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9003       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9004       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9005 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9006     else
9007       echo "$as_me:$LINENO: result: no" >&5
9008 echo "${ECHO_T}no" >&6
9009     fi
9010   elif test $build != $host && test $have_gcc_for_target = yes; then
9011     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9012     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9013     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9014   fi
9015 fi
9016 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9017   # Extract the first word of "as", so it can be a program name with args.
9018 set dummy as; ac_word=$2
9019 echo "$as_me:$LINENO: checking for $ac_word" >&5
9020 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9021 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9022   echo $ECHO_N "(cached) $ECHO_C" >&6
9023 else
9024   case $AS_FOR_TARGET in
9025   [\\/]* | ?:[\\/]*)
9026   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9027   ;;
9028   *)
9029   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9030 for as_dir in $gcc_cv_tool_dirs
9031 do
9032   IFS=$as_save_IFS
9033   test -z "$as_dir" && as_dir=.
9034   for ac_exec_ext in '' $ac_executable_extensions; do
9035   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9036     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9037     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9038     break 2
9039   fi
9040 done
9041 done
9042
9043   ;;
9044 esac
9045 fi
9046 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9047
9048 if test -n "$AS_FOR_TARGET"; then
9049   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9050 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9051 else
9052   echo "$as_me:$LINENO: result: no" >&5
9053 echo "${ECHO_T}no" >&6
9054 fi
9055
9056 fi
9057 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9058
9059
9060 if test -n "$AS_FOR_TARGET"; then
9061   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9062 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9063   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9064 fi
9065
9066 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9067   for ncn_progname in as; do
9068     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9069 set dummy ${ncn_progname}; ac_word=$2
9070 echo "$as_me:$LINENO: checking for $ac_word" >&5
9071 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9072 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9073   echo $ECHO_N "(cached) $ECHO_C" >&6
9074 else
9075   if test -n "$AS_FOR_TARGET"; then
9076   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9077 else
9078 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9079 for as_dir in $PATH
9080 do
9081   IFS=$as_save_IFS
9082   test -z "$as_dir" && as_dir=.
9083   for ac_exec_ext in '' $ac_executable_extensions; do
9084   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9085     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9086     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9087     break 2
9088   fi
9089 done
9090 done
9091
9092 fi
9093 fi
9094 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9095 if test -n "$AS_FOR_TARGET"; then
9096   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9097 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9098 else
9099   echo "$as_me:$LINENO: result: no" >&5
9100 echo "${ECHO_T}no" >&6
9101 fi
9102
9103   done
9104 fi
9105
9106 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9107   for ncn_progname in as; do
9108     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9109 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9110     if test -x $with_build_time_tools/${ncn_progname}; then
9111       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9112       echo "$as_me:$LINENO: result: yes" >&5
9113 echo "${ECHO_T}yes" >&6
9114       break
9115     else
9116       echo "$as_me:$LINENO: result: no" >&5
9117 echo "${ECHO_T}no" >&6
9118     fi
9119   done
9120 fi
9121
9122 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9123   for ncn_progname in as; do
9124     if test -n "$ncn_target_tool_prefix"; then
9125       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9126 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9127 echo "$as_me:$LINENO: checking for $ac_word" >&5
9128 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9129 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9130   echo $ECHO_N "(cached) $ECHO_C" >&6
9131 else
9132   if test -n "$AS_FOR_TARGET"; then
9133   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9134 else
9135 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9136 for as_dir in $PATH
9137 do
9138   IFS=$as_save_IFS
9139   test -z "$as_dir" && as_dir=.
9140   for ac_exec_ext in '' $ac_executable_extensions; do
9141   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9142     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9143     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9144     break 2
9145   fi
9146 done
9147 done
9148
9149 fi
9150 fi
9151 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9152 if test -n "$AS_FOR_TARGET"; then
9153   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9154 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9155 else
9156   echo "$as_me:$LINENO: result: no" >&5
9157 echo "${ECHO_T}no" >&6
9158 fi
9159
9160     fi
9161     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9162       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9163 set dummy ${ncn_progname}; ac_word=$2
9164 echo "$as_me:$LINENO: checking for $ac_word" >&5
9165 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9166 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9167   echo $ECHO_N "(cached) $ECHO_C" >&6
9168 else
9169   if test -n "$AS_FOR_TARGET"; then
9170   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9171 else
9172 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9173 for as_dir in $PATH
9174 do
9175   IFS=$as_save_IFS
9176   test -z "$as_dir" && as_dir=.
9177   for ac_exec_ext in '' $ac_executable_extensions; do
9178   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9179     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9180     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9181     break 2
9182   fi
9183 done
9184 done
9185
9186 fi
9187 fi
9188 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9189 if test -n "$AS_FOR_TARGET"; then
9190   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9191 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9192 else
9193   echo "$as_me:$LINENO: result: no" >&5
9194 echo "${ECHO_T}no" >&6
9195 fi
9196
9197     fi
9198     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9199   done
9200 fi
9201
9202 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9203   set dummy as
9204   if test $build = $target ; then
9205     AS_FOR_TARGET="$2"
9206   else
9207     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9208   fi
9209 else
9210   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9211 fi
9212
9213 else
9214   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9215 fi
9216
9217
9218
9219
9220 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9221   if test -n "$with_build_time_tools"; then
9222     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9223 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9224     if test -x $with_build_time_tools/dlltool; then
9225       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9226       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9227       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9228 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9229     else
9230       echo "$as_me:$LINENO: result: no" >&5
9231 echo "${ECHO_T}no" >&6
9232     fi
9233   elif test $build != $host && test $have_gcc_for_target = yes; then
9234     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9235     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9236     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9237   fi
9238 fi
9239 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9240   # Extract the first word of "dlltool", so it can be a program name with args.
9241 set dummy dlltool; ac_word=$2
9242 echo "$as_me:$LINENO: checking for $ac_word" >&5
9243 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9244 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9245   echo $ECHO_N "(cached) $ECHO_C" >&6
9246 else
9247   case $DLLTOOL_FOR_TARGET in
9248   [\\/]* | ?:[\\/]*)
9249   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9250   ;;
9251   *)
9252   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9253 for as_dir in $gcc_cv_tool_dirs
9254 do
9255   IFS=$as_save_IFS
9256   test -z "$as_dir" && as_dir=.
9257   for ac_exec_ext in '' $ac_executable_extensions; do
9258   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9259     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9260     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9261     break 2
9262   fi
9263 done
9264 done
9265
9266   ;;
9267 esac
9268 fi
9269 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9270
9271 if test -n "$DLLTOOL_FOR_TARGET"; then
9272   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9273 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9274 else
9275   echo "$as_me:$LINENO: result: no" >&5
9276 echo "${ECHO_T}no" >&6
9277 fi
9278
9279 fi
9280 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9281
9282
9283 if test -n "$DLLTOOL_FOR_TARGET"; then
9284   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9285 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9286   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9287 fi
9288
9289 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9290   for ncn_progname in dlltool; do
9291     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9292 set dummy ${ncn_progname}; ac_word=$2
9293 echo "$as_me:$LINENO: checking for $ac_word" >&5
9294 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9295 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9296   echo $ECHO_N "(cached) $ECHO_C" >&6
9297 else
9298   if test -n "$DLLTOOL_FOR_TARGET"; then
9299   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9300 else
9301 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9302 for as_dir in $PATH
9303 do
9304   IFS=$as_save_IFS
9305   test -z "$as_dir" && as_dir=.
9306   for ac_exec_ext in '' $ac_executable_extensions; do
9307   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9308     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9309     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9310     break 2
9311   fi
9312 done
9313 done
9314
9315 fi
9316 fi
9317 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9318 if test -n "$DLLTOOL_FOR_TARGET"; then
9319   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9320 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9321 else
9322   echo "$as_me:$LINENO: result: no" >&5
9323 echo "${ECHO_T}no" >&6
9324 fi
9325
9326   done
9327 fi
9328
9329 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9330   for ncn_progname in dlltool; do
9331     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9332 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9333     if test -x $with_build_time_tools/${ncn_progname}; then
9334       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9335       echo "$as_me:$LINENO: result: yes" >&5
9336 echo "${ECHO_T}yes" >&6
9337       break
9338     else
9339       echo "$as_me:$LINENO: result: no" >&5
9340 echo "${ECHO_T}no" >&6
9341     fi
9342   done
9343 fi
9344
9345 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9346   for ncn_progname in dlltool; do
9347     if test -n "$ncn_target_tool_prefix"; then
9348       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9349 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9350 echo "$as_me:$LINENO: checking for $ac_word" >&5
9351 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9352 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9353   echo $ECHO_N "(cached) $ECHO_C" >&6
9354 else
9355   if test -n "$DLLTOOL_FOR_TARGET"; then
9356   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9357 else
9358 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9359 for as_dir in $PATH
9360 do
9361   IFS=$as_save_IFS
9362   test -z "$as_dir" && as_dir=.
9363   for ac_exec_ext in '' $ac_executable_extensions; do
9364   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9365     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9366     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9367     break 2
9368   fi
9369 done
9370 done
9371
9372 fi
9373 fi
9374 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9375 if test -n "$DLLTOOL_FOR_TARGET"; then
9376   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9377 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9378 else
9379   echo "$as_me:$LINENO: result: no" >&5
9380 echo "${ECHO_T}no" >&6
9381 fi
9382
9383     fi
9384     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9385       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9386 set dummy ${ncn_progname}; ac_word=$2
9387 echo "$as_me:$LINENO: checking for $ac_word" >&5
9388 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9389 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9390   echo $ECHO_N "(cached) $ECHO_C" >&6
9391 else
9392   if test -n "$DLLTOOL_FOR_TARGET"; then
9393   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9394 else
9395 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9396 for as_dir in $PATH
9397 do
9398   IFS=$as_save_IFS
9399   test -z "$as_dir" && as_dir=.
9400   for ac_exec_ext in '' $ac_executable_extensions; do
9401   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9402     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9403     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9404     break 2
9405   fi
9406 done
9407 done
9408
9409 fi
9410 fi
9411 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9412 if test -n "$DLLTOOL_FOR_TARGET"; then
9413   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9414 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9415 else
9416   echo "$as_me:$LINENO: result: no" >&5
9417 echo "${ECHO_T}no" >&6
9418 fi
9419
9420     fi
9421     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9422   done
9423 fi
9424
9425 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9426   set dummy dlltool
9427   if test $build = $target ; then
9428     DLLTOOL_FOR_TARGET="$2"
9429   else
9430     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9431   fi
9432 else
9433   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9434 fi
9435
9436 else
9437   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9438 fi
9439
9440
9441
9442
9443 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9444   if test -n "$with_build_time_tools"; then
9445     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9446 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9447     if test -x $with_build_time_tools/ld; then
9448       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9449       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9450       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9451 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9452     else
9453       echo "$as_me:$LINENO: result: no" >&5
9454 echo "${ECHO_T}no" >&6
9455     fi
9456   elif test $build != $host && test $have_gcc_for_target = yes; then
9457     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9458     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9459     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9460   fi
9461 fi
9462 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9463   # Extract the first word of "ld", so it can be a program name with args.
9464 set dummy ld; ac_word=$2
9465 echo "$as_me:$LINENO: checking for $ac_word" >&5
9466 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9467 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9468   echo $ECHO_N "(cached) $ECHO_C" >&6
9469 else
9470   case $LD_FOR_TARGET in
9471   [\\/]* | ?:[\\/]*)
9472   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9473   ;;
9474   *)
9475   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9476 for as_dir in $gcc_cv_tool_dirs
9477 do
9478   IFS=$as_save_IFS
9479   test -z "$as_dir" && as_dir=.
9480   for ac_exec_ext in '' $ac_executable_extensions; do
9481   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9482     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9483     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9484     break 2
9485   fi
9486 done
9487 done
9488
9489   ;;
9490 esac
9491 fi
9492 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9493
9494 if test -n "$LD_FOR_TARGET"; then
9495   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9496 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9497 else
9498   echo "$as_me:$LINENO: result: no" >&5
9499 echo "${ECHO_T}no" >&6
9500 fi
9501
9502 fi
9503 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9504
9505
9506 if test -n "$LD_FOR_TARGET"; then
9507   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9508 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9509   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9510 fi
9511
9512 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9513   for ncn_progname in ld; do
9514     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9515 set dummy ${ncn_progname}; ac_word=$2
9516 echo "$as_me:$LINENO: checking for $ac_word" >&5
9517 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9518 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9519   echo $ECHO_N "(cached) $ECHO_C" >&6
9520 else
9521   if test -n "$LD_FOR_TARGET"; then
9522   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9523 else
9524 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9525 for as_dir in $PATH
9526 do
9527   IFS=$as_save_IFS
9528   test -z "$as_dir" && as_dir=.
9529   for ac_exec_ext in '' $ac_executable_extensions; do
9530   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9531     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9532     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9533     break 2
9534   fi
9535 done
9536 done
9537
9538 fi
9539 fi
9540 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9541 if test -n "$LD_FOR_TARGET"; then
9542   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9543 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9544 else
9545   echo "$as_me:$LINENO: result: no" >&5
9546 echo "${ECHO_T}no" >&6
9547 fi
9548
9549   done
9550 fi
9551
9552 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9553   for ncn_progname in ld; do
9554     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9555 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9556     if test -x $with_build_time_tools/${ncn_progname}; then
9557       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9558       echo "$as_me:$LINENO: result: yes" >&5
9559 echo "${ECHO_T}yes" >&6
9560       break
9561     else
9562       echo "$as_me:$LINENO: result: no" >&5
9563 echo "${ECHO_T}no" >&6
9564     fi
9565   done
9566 fi
9567
9568 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9569   for ncn_progname in ld; do
9570     if test -n "$ncn_target_tool_prefix"; then
9571       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9572 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9573 echo "$as_me:$LINENO: checking for $ac_word" >&5
9574 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9575 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9576   echo $ECHO_N "(cached) $ECHO_C" >&6
9577 else
9578   if test -n "$LD_FOR_TARGET"; then
9579   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9580 else
9581 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9582 for as_dir in $PATH
9583 do
9584   IFS=$as_save_IFS
9585   test -z "$as_dir" && as_dir=.
9586   for ac_exec_ext in '' $ac_executable_extensions; do
9587   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9588     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9589     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9590     break 2
9591   fi
9592 done
9593 done
9594
9595 fi
9596 fi
9597 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9598 if test -n "$LD_FOR_TARGET"; then
9599   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9600 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9601 else
9602   echo "$as_me:$LINENO: result: no" >&5
9603 echo "${ECHO_T}no" >&6
9604 fi
9605
9606     fi
9607     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9608       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9609 set dummy ${ncn_progname}; ac_word=$2
9610 echo "$as_me:$LINENO: checking for $ac_word" >&5
9611 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9612 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9613   echo $ECHO_N "(cached) $ECHO_C" >&6
9614 else
9615   if test -n "$LD_FOR_TARGET"; then
9616   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9617 else
9618 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9619 for as_dir in $PATH
9620 do
9621   IFS=$as_save_IFS
9622   test -z "$as_dir" && as_dir=.
9623   for ac_exec_ext in '' $ac_executable_extensions; do
9624   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9625     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9626     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9627     break 2
9628   fi
9629 done
9630 done
9631
9632 fi
9633 fi
9634 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9635 if test -n "$LD_FOR_TARGET"; then
9636   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9637 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9638 else
9639   echo "$as_me:$LINENO: result: no" >&5
9640 echo "${ECHO_T}no" >&6
9641 fi
9642
9643     fi
9644     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9645   done
9646 fi
9647
9648 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9649   set dummy ld
9650   if test $build = $target ; then
9651     LD_FOR_TARGET="$2"
9652   else
9653     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9654   fi
9655 else
9656   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9657 fi
9658
9659 else
9660   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9661 fi
9662
9663
9664
9665
9666 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9667   if test -n "$with_build_time_tools"; then
9668     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9669 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9670     if test -x $with_build_time_tools/lipo; then
9671       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9672       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9673       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9674 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9675     else
9676       echo "$as_me:$LINENO: result: no" >&5
9677 echo "${ECHO_T}no" >&6
9678     fi
9679   elif test $build != $host && test $have_gcc_for_target = yes; then
9680     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9681     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9682     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9683   fi
9684 fi
9685 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9686   # Extract the first word of "lipo", so it can be a program name with args.
9687 set dummy lipo; ac_word=$2
9688 echo "$as_me:$LINENO: checking for $ac_word" >&5
9689 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9690 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9691   echo $ECHO_N "(cached) $ECHO_C" >&6
9692 else
9693   case $LIPO_FOR_TARGET in
9694   [\\/]* | ?:[\\/]*)
9695   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9696   ;;
9697   *)
9698   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9699 for as_dir in $gcc_cv_tool_dirs
9700 do
9701   IFS=$as_save_IFS
9702   test -z "$as_dir" && as_dir=.
9703   for ac_exec_ext in '' $ac_executable_extensions; do
9704   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9705     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9706     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9707     break 2
9708   fi
9709 done
9710 done
9711
9712   ;;
9713 esac
9714 fi
9715 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9716
9717 if test -n "$LIPO_FOR_TARGET"; then
9718   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9719 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9720 else
9721   echo "$as_me:$LINENO: result: no" >&5
9722 echo "${ECHO_T}no" >&6
9723 fi
9724
9725 fi
9726 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9727
9728
9729 if test -n "$LIPO_FOR_TARGET"; then
9730   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9731 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9732   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9733 fi
9734
9735 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9736   for ncn_progname in lipo; do
9737     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9738 set dummy ${ncn_progname}; ac_word=$2
9739 echo "$as_me:$LINENO: checking for $ac_word" >&5
9740 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9741 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9742   echo $ECHO_N "(cached) $ECHO_C" >&6
9743 else
9744   if test -n "$LIPO_FOR_TARGET"; then
9745   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9746 else
9747 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9748 for as_dir in $PATH
9749 do
9750   IFS=$as_save_IFS
9751   test -z "$as_dir" && as_dir=.
9752   for ac_exec_ext in '' $ac_executable_extensions; do
9753   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9754     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9755     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9756     break 2
9757   fi
9758 done
9759 done
9760
9761 fi
9762 fi
9763 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9764 if test -n "$LIPO_FOR_TARGET"; then
9765   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9766 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9767 else
9768   echo "$as_me:$LINENO: result: no" >&5
9769 echo "${ECHO_T}no" >&6
9770 fi
9771
9772   done
9773 fi
9774
9775 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9776   for ncn_progname in lipo; do
9777     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9778 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9779     if test -x $with_build_time_tools/${ncn_progname}; then
9780       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9781       echo "$as_me:$LINENO: result: yes" >&5
9782 echo "${ECHO_T}yes" >&6
9783       break
9784     else
9785       echo "$as_me:$LINENO: result: no" >&5
9786 echo "${ECHO_T}no" >&6
9787     fi
9788   done
9789 fi
9790
9791 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9792   for ncn_progname in lipo; do
9793     if test -n "$ncn_target_tool_prefix"; then
9794       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9795 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9796 echo "$as_me:$LINENO: checking for $ac_word" >&5
9797 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9798 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9799   echo $ECHO_N "(cached) $ECHO_C" >&6
9800 else
9801   if test -n "$LIPO_FOR_TARGET"; then
9802   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9803 else
9804 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9805 for as_dir in $PATH
9806 do
9807   IFS=$as_save_IFS
9808   test -z "$as_dir" && as_dir=.
9809   for ac_exec_ext in '' $ac_executable_extensions; do
9810   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9811     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9812     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9813     break 2
9814   fi
9815 done
9816 done
9817
9818 fi
9819 fi
9820 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9821 if test -n "$LIPO_FOR_TARGET"; then
9822   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9823 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9824 else
9825   echo "$as_me:$LINENO: result: no" >&5
9826 echo "${ECHO_T}no" >&6
9827 fi
9828
9829     fi
9830     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9831       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9832 set dummy ${ncn_progname}; ac_word=$2
9833 echo "$as_me:$LINENO: checking for $ac_word" >&5
9834 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9835 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9836   echo $ECHO_N "(cached) $ECHO_C" >&6
9837 else
9838   if test -n "$LIPO_FOR_TARGET"; then
9839   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9840 else
9841 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9842 for as_dir in $PATH
9843 do
9844   IFS=$as_save_IFS
9845   test -z "$as_dir" && as_dir=.
9846   for ac_exec_ext in '' $ac_executable_extensions; do
9847   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9848     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9849     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9850     break 2
9851   fi
9852 done
9853 done
9854
9855 fi
9856 fi
9857 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9858 if test -n "$LIPO_FOR_TARGET"; then
9859   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9860 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9861 else
9862   echo "$as_me:$LINENO: result: no" >&5
9863 echo "${ECHO_T}no" >&6
9864 fi
9865
9866     fi
9867     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9868   done
9869 fi
9870
9871 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9872   set dummy lipo
9873   if test $build = $target ; then
9874     LIPO_FOR_TARGET="$2"
9875   else
9876     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9877   fi
9878 else
9879   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9880 fi
9881
9882 else
9883   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9884 fi
9885
9886
9887
9888
9889 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9890   if test -n "$with_build_time_tools"; then
9891     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9892 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9893     if test -x $with_build_time_tools/nm; then
9894       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9895       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9896       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9897 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9898     else
9899       echo "$as_me:$LINENO: result: no" >&5
9900 echo "${ECHO_T}no" >&6
9901     fi
9902   elif test $build != $host && test $have_gcc_for_target = yes; then
9903     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9904     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
9905     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9906   fi
9907 fi
9908 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9909   # Extract the first word of "nm", so it can be a program name with args.
9910 set dummy nm; ac_word=$2
9911 echo "$as_me:$LINENO: checking for $ac_word" >&5
9912 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9913 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9914   echo $ECHO_N "(cached) $ECHO_C" >&6
9915 else
9916   case $NM_FOR_TARGET in
9917   [\\/]* | ?:[\\/]*)
9918   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9919   ;;
9920   *)
9921   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9922 for as_dir in $gcc_cv_tool_dirs
9923 do
9924   IFS=$as_save_IFS
9925   test -z "$as_dir" && as_dir=.
9926   for ac_exec_ext in '' $ac_executable_extensions; do
9927   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9928     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9929     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9930     break 2
9931   fi
9932 done
9933 done
9934
9935   ;;
9936 esac
9937 fi
9938 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9939
9940 if test -n "$NM_FOR_TARGET"; then
9941   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9942 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9943 else
9944   echo "$as_me:$LINENO: result: no" >&5
9945 echo "${ECHO_T}no" >&6
9946 fi
9947
9948 fi
9949 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9950
9951
9952 if test -n "$NM_FOR_TARGET"; then
9953   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
9954 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9955   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9956 fi
9957
9958 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9959   for ncn_progname in nm; do
9960     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9961 set dummy ${ncn_progname}; ac_word=$2
9962 echo "$as_me:$LINENO: checking for $ac_word" >&5
9963 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9964 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9965   echo $ECHO_N "(cached) $ECHO_C" >&6
9966 else
9967   if test -n "$NM_FOR_TARGET"; then
9968   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9969 else
9970 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9971 for as_dir in $PATH
9972 do
9973   IFS=$as_save_IFS
9974   test -z "$as_dir" && as_dir=.
9975   for ac_exec_ext in '' $ac_executable_extensions; do
9976   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9977     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9978     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9979     break 2
9980   fi
9981 done
9982 done
9983
9984 fi
9985 fi
9986 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9987 if test -n "$NM_FOR_TARGET"; then
9988   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9989 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9990 else
9991   echo "$as_me:$LINENO: result: no" >&5
9992 echo "${ECHO_T}no" >&6
9993 fi
9994
9995   done
9996 fi
9997
9998 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
9999   for ncn_progname in nm; do
10000     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10001 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10002     if test -x $with_build_time_tools/${ncn_progname}; then
10003       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10004       echo "$as_me:$LINENO: result: yes" >&5
10005 echo "${ECHO_T}yes" >&6
10006       break
10007     else
10008       echo "$as_me:$LINENO: result: no" >&5
10009 echo "${ECHO_T}no" >&6
10010     fi
10011   done
10012 fi
10013
10014 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10015   for ncn_progname in nm; do
10016     if test -n "$ncn_target_tool_prefix"; then
10017       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10018 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10019 echo "$as_me:$LINENO: checking for $ac_word" >&5
10020 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10021 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10022   echo $ECHO_N "(cached) $ECHO_C" >&6
10023 else
10024   if test -n "$NM_FOR_TARGET"; then
10025   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10026 else
10027 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10028 for as_dir in $PATH
10029 do
10030   IFS=$as_save_IFS
10031   test -z "$as_dir" && as_dir=.
10032   for ac_exec_ext in '' $ac_executable_extensions; do
10033   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10034     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10035     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10036     break 2
10037   fi
10038 done
10039 done
10040
10041 fi
10042 fi
10043 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10044 if test -n "$NM_FOR_TARGET"; then
10045   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10046 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10047 else
10048   echo "$as_me:$LINENO: result: no" >&5
10049 echo "${ECHO_T}no" >&6
10050 fi
10051
10052     fi
10053     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10054       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10055 set dummy ${ncn_progname}; ac_word=$2
10056 echo "$as_me:$LINENO: checking for $ac_word" >&5
10057 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10058 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10059   echo $ECHO_N "(cached) $ECHO_C" >&6
10060 else
10061   if test -n "$NM_FOR_TARGET"; then
10062   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10063 else
10064 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10065 for as_dir in $PATH
10066 do
10067   IFS=$as_save_IFS
10068   test -z "$as_dir" && as_dir=.
10069   for ac_exec_ext in '' $ac_executable_extensions; do
10070   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10071     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10072     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10073     break 2
10074   fi
10075 done
10076 done
10077
10078 fi
10079 fi
10080 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10081 if test -n "$NM_FOR_TARGET"; then
10082   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10083 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10084 else
10085   echo "$as_me:$LINENO: result: no" >&5
10086 echo "${ECHO_T}no" >&6
10087 fi
10088
10089     fi
10090     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10091   done
10092 fi
10093
10094 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10095   set dummy nm
10096   if test $build = $target ; then
10097     NM_FOR_TARGET="$2"
10098   else
10099     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10100   fi
10101 else
10102   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10103 fi
10104
10105 else
10106   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10107 fi
10108
10109
10110
10111
10112 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10113   if test -n "$with_build_time_tools"; then
10114     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10115 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10116     if test -x $with_build_time_tools/objdump; then
10117       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10118       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10119       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10120 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10121     else
10122       echo "$as_me:$LINENO: result: no" >&5
10123 echo "${ECHO_T}no" >&6
10124     fi
10125   elif test $build != $host && test $have_gcc_for_target = yes; then
10126     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10127     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10128     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10129   fi
10130 fi
10131 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10132   # Extract the first word of "objdump", so it can be a program name with args.
10133 set dummy objdump; ac_word=$2
10134 echo "$as_me:$LINENO: checking for $ac_word" >&5
10135 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10136 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10137   echo $ECHO_N "(cached) $ECHO_C" >&6
10138 else
10139   case $OBJDUMP_FOR_TARGET in
10140   [\\/]* | ?:[\\/]*)
10141   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10142   ;;
10143   *)
10144   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10145 for as_dir in $gcc_cv_tool_dirs
10146 do
10147   IFS=$as_save_IFS
10148   test -z "$as_dir" && as_dir=.
10149   for ac_exec_ext in '' $ac_executable_extensions; do
10150   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10151     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10152     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10153     break 2
10154   fi
10155 done
10156 done
10157
10158   ;;
10159 esac
10160 fi
10161 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10162
10163 if test -n "$OBJDUMP_FOR_TARGET"; then
10164   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10165 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10166 else
10167   echo "$as_me:$LINENO: result: no" >&5
10168 echo "${ECHO_T}no" >&6
10169 fi
10170
10171 fi
10172 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10173
10174
10175 if test -n "$OBJDUMP_FOR_TARGET"; then
10176   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10177 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10178   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10179 fi
10180
10181 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10182   for ncn_progname in objdump; do
10183     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10184 set dummy ${ncn_progname}; ac_word=$2
10185 echo "$as_me:$LINENO: checking for $ac_word" >&5
10186 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10187 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10188   echo $ECHO_N "(cached) $ECHO_C" >&6
10189 else
10190   if test -n "$OBJDUMP_FOR_TARGET"; then
10191   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10192 else
10193 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10194 for as_dir in $PATH
10195 do
10196   IFS=$as_save_IFS
10197   test -z "$as_dir" && as_dir=.
10198   for ac_exec_ext in '' $ac_executable_extensions; do
10199   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10200     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10201     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10202     break 2
10203   fi
10204 done
10205 done
10206
10207 fi
10208 fi
10209 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10210 if test -n "$OBJDUMP_FOR_TARGET"; then
10211   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10212 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10213 else
10214   echo "$as_me:$LINENO: result: no" >&5
10215 echo "${ECHO_T}no" >&6
10216 fi
10217
10218   done
10219 fi
10220
10221 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10222   for ncn_progname in objdump; do
10223     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10224 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10225     if test -x $with_build_time_tools/${ncn_progname}; then
10226       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10227       echo "$as_me:$LINENO: result: yes" >&5
10228 echo "${ECHO_T}yes" >&6
10229       break
10230     else
10231       echo "$as_me:$LINENO: result: no" >&5
10232 echo "${ECHO_T}no" >&6
10233     fi
10234   done
10235 fi
10236
10237 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10238   for ncn_progname in objdump; do
10239     if test -n "$ncn_target_tool_prefix"; then
10240       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10241 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10242 echo "$as_me:$LINENO: checking for $ac_word" >&5
10243 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10244 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10245   echo $ECHO_N "(cached) $ECHO_C" >&6
10246 else
10247   if test -n "$OBJDUMP_FOR_TARGET"; then
10248   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10249 else
10250 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10251 for as_dir in $PATH
10252 do
10253   IFS=$as_save_IFS
10254   test -z "$as_dir" && as_dir=.
10255   for ac_exec_ext in '' $ac_executable_extensions; do
10256   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10257     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10258     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10259     break 2
10260   fi
10261 done
10262 done
10263
10264 fi
10265 fi
10266 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10267 if test -n "$OBJDUMP_FOR_TARGET"; then
10268   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10269 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10270 else
10271   echo "$as_me:$LINENO: result: no" >&5
10272 echo "${ECHO_T}no" >&6
10273 fi
10274
10275     fi
10276     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10277       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10278 set dummy ${ncn_progname}; ac_word=$2
10279 echo "$as_me:$LINENO: checking for $ac_word" >&5
10280 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10281 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10282   echo $ECHO_N "(cached) $ECHO_C" >&6
10283 else
10284   if test -n "$OBJDUMP_FOR_TARGET"; then
10285   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10286 else
10287 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10288 for as_dir in $PATH
10289 do
10290   IFS=$as_save_IFS
10291   test -z "$as_dir" && as_dir=.
10292   for ac_exec_ext in '' $ac_executable_extensions; do
10293   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10294     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10295     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10296     break 2
10297   fi
10298 done
10299 done
10300
10301 fi
10302 fi
10303 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10304 if test -n "$OBJDUMP_FOR_TARGET"; then
10305   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10306 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10307 else
10308   echo "$as_me:$LINENO: result: no" >&5
10309 echo "${ECHO_T}no" >&6
10310 fi
10311
10312     fi
10313     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10314   done
10315 fi
10316
10317 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10318   set dummy objdump
10319   if test $build = $target ; then
10320     OBJDUMP_FOR_TARGET="$2"
10321   else
10322     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10323   fi
10324 else
10325   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10326 fi
10327
10328 else
10329   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10330 fi
10331
10332
10333
10334
10335 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10336   if test -n "$with_build_time_tools"; then
10337     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10338 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10339     if test -x $with_build_time_tools/ranlib; then
10340       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10341       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10342       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10343 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10344     else
10345       echo "$as_me:$LINENO: result: no" >&5
10346 echo "${ECHO_T}no" >&6
10347     fi
10348   elif test $build != $host && test $have_gcc_for_target = yes; then
10349     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10350     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10351     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10352   fi
10353 fi
10354 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10355   # Extract the first word of "ranlib", so it can be a program name with args.
10356 set dummy ranlib; ac_word=$2
10357 echo "$as_me:$LINENO: checking for $ac_word" >&5
10358 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10359 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10360   echo $ECHO_N "(cached) $ECHO_C" >&6
10361 else
10362   case $RANLIB_FOR_TARGET in
10363   [\\/]* | ?:[\\/]*)
10364   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10365   ;;
10366   *)
10367   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10368 for as_dir in $gcc_cv_tool_dirs
10369 do
10370   IFS=$as_save_IFS
10371   test -z "$as_dir" && as_dir=.
10372   for ac_exec_ext in '' $ac_executable_extensions; do
10373   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10374     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10375     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10376     break 2
10377   fi
10378 done
10379 done
10380
10381   ;;
10382 esac
10383 fi
10384 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10385
10386 if test -n "$RANLIB_FOR_TARGET"; then
10387   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10388 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10389 else
10390   echo "$as_me:$LINENO: result: no" >&5
10391 echo "${ECHO_T}no" >&6
10392 fi
10393
10394 fi
10395 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10396
10397
10398 if test -n "$RANLIB_FOR_TARGET"; then
10399   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10400 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10401   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10402 fi
10403
10404 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10405   for ncn_progname in ranlib; do
10406     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10407 set dummy ${ncn_progname}; ac_word=$2
10408 echo "$as_me:$LINENO: checking for $ac_word" >&5
10409 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10410 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10411   echo $ECHO_N "(cached) $ECHO_C" >&6
10412 else
10413   if test -n "$RANLIB_FOR_TARGET"; then
10414   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10415 else
10416 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10417 for as_dir in $PATH
10418 do
10419   IFS=$as_save_IFS
10420   test -z "$as_dir" && as_dir=.
10421   for ac_exec_ext in '' $ac_executable_extensions; do
10422   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10423     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10424     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10425     break 2
10426   fi
10427 done
10428 done
10429
10430 fi
10431 fi
10432 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10433 if test -n "$RANLIB_FOR_TARGET"; then
10434   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10435 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10436 else
10437   echo "$as_me:$LINENO: result: no" >&5
10438 echo "${ECHO_T}no" >&6
10439 fi
10440
10441   done
10442 fi
10443
10444 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10445   for ncn_progname in ranlib; do
10446     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10447 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10448     if test -x $with_build_time_tools/${ncn_progname}; then
10449       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10450       echo "$as_me:$LINENO: result: yes" >&5
10451 echo "${ECHO_T}yes" >&6
10452       break
10453     else
10454       echo "$as_me:$LINENO: result: no" >&5
10455 echo "${ECHO_T}no" >&6
10456     fi
10457   done
10458 fi
10459
10460 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10461   for ncn_progname in ranlib; do
10462     if test -n "$ncn_target_tool_prefix"; then
10463       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10464 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10465 echo "$as_me:$LINENO: checking for $ac_word" >&5
10466 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10467 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10468   echo $ECHO_N "(cached) $ECHO_C" >&6
10469 else
10470   if test -n "$RANLIB_FOR_TARGET"; then
10471   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10472 else
10473 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10474 for as_dir in $PATH
10475 do
10476   IFS=$as_save_IFS
10477   test -z "$as_dir" && as_dir=.
10478   for ac_exec_ext in '' $ac_executable_extensions; do
10479   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10480     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10481     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10482     break 2
10483   fi
10484 done
10485 done
10486
10487 fi
10488 fi
10489 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10490 if test -n "$RANLIB_FOR_TARGET"; then
10491   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10492 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10493 else
10494   echo "$as_me:$LINENO: result: no" >&5
10495 echo "${ECHO_T}no" >&6
10496 fi
10497
10498     fi
10499     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10500       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10501 set dummy ${ncn_progname}; ac_word=$2
10502 echo "$as_me:$LINENO: checking for $ac_word" >&5
10503 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10504 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10505   echo $ECHO_N "(cached) $ECHO_C" >&6
10506 else
10507   if test -n "$RANLIB_FOR_TARGET"; then
10508   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10509 else
10510 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10511 for as_dir in $PATH
10512 do
10513   IFS=$as_save_IFS
10514   test -z "$as_dir" && as_dir=.
10515   for ac_exec_ext in '' $ac_executable_extensions; do
10516   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10517     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10518     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10519     break 2
10520   fi
10521 done
10522 done
10523
10524 fi
10525 fi
10526 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10527 if test -n "$RANLIB_FOR_TARGET"; then
10528   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10529 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10530 else
10531   echo "$as_me:$LINENO: result: no" >&5
10532 echo "${ECHO_T}no" >&6
10533 fi
10534
10535     fi
10536     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10537   done
10538 fi
10539
10540 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10541   set dummy ranlib
10542   if test $build = $target ; then
10543     RANLIB_FOR_TARGET="$2"
10544   else
10545     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10546   fi
10547 else
10548   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10549 fi
10550
10551 else
10552   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10553 fi
10554
10555
10556
10557
10558 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10559   if test -n "$with_build_time_tools"; then
10560     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10561 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10562     if test -x $with_build_time_tools/strip; then
10563       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10564       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10565       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10566 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10567     else
10568       echo "$as_me:$LINENO: result: no" >&5
10569 echo "${ECHO_T}no" >&6
10570     fi
10571   elif test $build != $host && test $have_gcc_for_target = yes; then
10572     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10573     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10574     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10575   fi
10576 fi
10577 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10578   # Extract the first word of "strip", so it can be a program name with args.
10579 set dummy strip; ac_word=$2
10580 echo "$as_me:$LINENO: checking for $ac_word" >&5
10581 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10582 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10583   echo $ECHO_N "(cached) $ECHO_C" >&6
10584 else
10585   case $STRIP_FOR_TARGET in
10586   [\\/]* | ?:[\\/]*)
10587   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10588   ;;
10589   *)
10590   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10591 for as_dir in $gcc_cv_tool_dirs
10592 do
10593   IFS=$as_save_IFS
10594   test -z "$as_dir" && as_dir=.
10595   for ac_exec_ext in '' $ac_executable_extensions; do
10596   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10597     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10598     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10599     break 2
10600   fi
10601 done
10602 done
10603
10604   ;;
10605 esac
10606 fi
10607 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10608
10609 if test -n "$STRIP_FOR_TARGET"; then
10610   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10611 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10612 else
10613   echo "$as_me:$LINENO: result: no" >&5
10614 echo "${ECHO_T}no" >&6
10615 fi
10616
10617 fi
10618 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10619
10620
10621 if test -n "$STRIP_FOR_TARGET"; then
10622   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10623 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10624   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10625 fi
10626
10627 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10628   for ncn_progname in strip; do
10629     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10630 set dummy ${ncn_progname}; ac_word=$2
10631 echo "$as_me:$LINENO: checking for $ac_word" >&5
10632 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10633 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10634   echo $ECHO_N "(cached) $ECHO_C" >&6
10635 else
10636   if test -n "$STRIP_FOR_TARGET"; then
10637   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10638 else
10639 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10640 for as_dir in $PATH
10641 do
10642   IFS=$as_save_IFS
10643   test -z "$as_dir" && as_dir=.
10644   for ac_exec_ext in '' $ac_executable_extensions; do
10645   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10646     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10647     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10648     break 2
10649   fi
10650 done
10651 done
10652
10653 fi
10654 fi
10655 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10656 if test -n "$STRIP_FOR_TARGET"; then
10657   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10658 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10659 else
10660   echo "$as_me:$LINENO: result: no" >&5
10661 echo "${ECHO_T}no" >&6
10662 fi
10663
10664   done
10665 fi
10666
10667 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10668   for ncn_progname in strip; do
10669     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10670 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10671     if test -x $with_build_time_tools/${ncn_progname}; then
10672       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10673       echo "$as_me:$LINENO: result: yes" >&5
10674 echo "${ECHO_T}yes" >&6
10675       break
10676     else
10677       echo "$as_me:$LINENO: result: no" >&5
10678 echo "${ECHO_T}no" >&6
10679     fi
10680   done
10681 fi
10682
10683 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10684   for ncn_progname in strip; do
10685     if test -n "$ncn_target_tool_prefix"; then
10686       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10687 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10688 echo "$as_me:$LINENO: checking for $ac_word" >&5
10689 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10690 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10691   echo $ECHO_N "(cached) $ECHO_C" >&6
10692 else
10693   if test -n "$STRIP_FOR_TARGET"; then
10694   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10695 else
10696 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10697 for as_dir in $PATH
10698 do
10699   IFS=$as_save_IFS
10700   test -z "$as_dir" && as_dir=.
10701   for ac_exec_ext in '' $ac_executable_extensions; do
10702   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10703     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10704     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10705     break 2
10706   fi
10707 done
10708 done
10709
10710 fi
10711 fi
10712 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10713 if test -n "$STRIP_FOR_TARGET"; then
10714   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10715 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10716 else
10717   echo "$as_me:$LINENO: result: no" >&5
10718 echo "${ECHO_T}no" >&6
10719 fi
10720
10721     fi
10722     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10723       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10724 set dummy ${ncn_progname}; ac_word=$2
10725 echo "$as_me:$LINENO: checking for $ac_word" >&5
10726 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10727 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10728   echo $ECHO_N "(cached) $ECHO_C" >&6
10729 else
10730   if test -n "$STRIP_FOR_TARGET"; then
10731   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10732 else
10733 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10734 for as_dir in $PATH
10735 do
10736   IFS=$as_save_IFS
10737   test -z "$as_dir" && as_dir=.
10738   for ac_exec_ext in '' $ac_executable_extensions; do
10739   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10740     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10741     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10742     break 2
10743   fi
10744 done
10745 done
10746
10747 fi
10748 fi
10749 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10750 if test -n "$STRIP_FOR_TARGET"; then
10751   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10752 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10753 else
10754   echo "$as_me:$LINENO: result: no" >&5
10755 echo "${ECHO_T}no" >&6
10756 fi
10757
10758     fi
10759     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10760   done
10761 fi
10762
10763 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10764   set dummy strip
10765   if test $build = $target ; then
10766     STRIP_FOR_TARGET="$2"
10767   else
10768     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10769   fi
10770 else
10771   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10772 fi
10773
10774 else
10775   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10776 fi
10777
10778
10779
10780
10781 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10782   if test -n "$with_build_time_tools"; then
10783     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10784 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10785     if test -x $with_build_time_tools/windres; then
10786       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10787       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10788       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10789 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10790     else
10791       echo "$as_me:$LINENO: result: no" >&5
10792 echo "${ECHO_T}no" >&6
10793     fi
10794   elif test $build != $host && test $have_gcc_for_target = yes; then
10795     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10796     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10797     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10798   fi
10799 fi
10800 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10801   # Extract the first word of "windres", so it can be a program name with args.
10802 set dummy windres; ac_word=$2
10803 echo "$as_me:$LINENO: checking for $ac_word" >&5
10804 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10805 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10806   echo $ECHO_N "(cached) $ECHO_C" >&6
10807 else
10808   case $WINDRES_FOR_TARGET in
10809   [\\/]* | ?:[\\/]*)
10810   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10811   ;;
10812   *)
10813   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10814 for as_dir in $gcc_cv_tool_dirs
10815 do
10816   IFS=$as_save_IFS
10817   test -z "$as_dir" && as_dir=.
10818   for ac_exec_ext in '' $ac_executable_extensions; do
10819   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10820     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10821     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10822     break 2
10823   fi
10824 done
10825 done
10826
10827   ;;
10828 esac
10829 fi
10830 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10831
10832 if test -n "$WINDRES_FOR_TARGET"; then
10833   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10834 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10835 else
10836   echo "$as_me:$LINENO: result: no" >&5
10837 echo "${ECHO_T}no" >&6
10838 fi
10839
10840 fi
10841 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10842
10843
10844 if test -n "$WINDRES_FOR_TARGET"; then
10845   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10846 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10847   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10848 fi
10849
10850 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10851   for ncn_progname in windres; do
10852     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10853 set dummy ${ncn_progname}; ac_word=$2
10854 echo "$as_me:$LINENO: checking for $ac_word" >&5
10855 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10856 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10857   echo $ECHO_N "(cached) $ECHO_C" >&6
10858 else
10859   if test -n "$WINDRES_FOR_TARGET"; then
10860   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10861 else
10862 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10863 for as_dir in $PATH
10864 do
10865   IFS=$as_save_IFS
10866   test -z "$as_dir" && as_dir=.
10867   for ac_exec_ext in '' $ac_executable_extensions; do
10868   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10869     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10870     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10871     break 2
10872   fi
10873 done
10874 done
10875
10876 fi
10877 fi
10878 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10879 if test -n "$WINDRES_FOR_TARGET"; then
10880   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10881 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10882 else
10883   echo "$as_me:$LINENO: result: no" >&5
10884 echo "${ECHO_T}no" >&6
10885 fi
10886
10887   done
10888 fi
10889
10890 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10891   for ncn_progname in windres; do
10892     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10893 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10894     if test -x $with_build_time_tools/${ncn_progname}; then
10895       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10896       echo "$as_me:$LINENO: result: yes" >&5
10897 echo "${ECHO_T}yes" >&6
10898       break
10899     else
10900       echo "$as_me:$LINENO: result: no" >&5
10901 echo "${ECHO_T}no" >&6
10902     fi
10903   done
10904 fi
10905
10906 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10907   for ncn_progname in windres; do
10908     if test -n "$ncn_target_tool_prefix"; then
10909       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10910 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10911 echo "$as_me:$LINENO: checking for $ac_word" >&5
10912 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10913 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10914   echo $ECHO_N "(cached) $ECHO_C" >&6
10915 else
10916   if test -n "$WINDRES_FOR_TARGET"; then
10917   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10918 else
10919 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10920 for as_dir in $PATH
10921 do
10922   IFS=$as_save_IFS
10923   test -z "$as_dir" && as_dir=.
10924   for ac_exec_ext in '' $ac_executable_extensions; do
10925   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10926     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10927     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10928     break 2
10929   fi
10930 done
10931 done
10932
10933 fi
10934 fi
10935 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10936 if test -n "$WINDRES_FOR_TARGET"; then
10937   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10938 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10939 else
10940   echo "$as_me:$LINENO: result: no" >&5
10941 echo "${ECHO_T}no" >&6
10942 fi
10943
10944     fi
10945     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
10946       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10947 set dummy ${ncn_progname}; ac_word=$2
10948 echo "$as_me:$LINENO: checking for $ac_word" >&5
10949 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10950 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10951   echo $ECHO_N "(cached) $ECHO_C" >&6
10952 else
10953   if test -n "$WINDRES_FOR_TARGET"; then
10954   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10955 else
10956 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10957 for as_dir in $PATH
10958 do
10959   IFS=$as_save_IFS
10960   test -z "$as_dir" && as_dir=.
10961   for ac_exec_ext in '' $ac_executable_extensions; do
10962   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10963     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10964     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10965     break 2
10966   fi
10967 done
10968 done
10969
10970 fi
10971 fi
10972 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10973 if test -n "$WINDRES_FOR_TARGET"; then
10974   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10975 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10976 else
10977   echo "$as_me:$LINENO: result: no" >&5
10978 echo "${ECHO_T}no" >&6
10979 fi
10980
10981     fi
10982     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
10983   done
10984 fi
10985
10986 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
10987   set dummy windres
10988   if test $build = $target ; then
10989     WINDRES_FOR_TARGET="$2"
10990   else
10991     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
10992   fi
10993 else
10994   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
10995 fi
10996
10997 else
10998   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10999 fi
11000
11001
11002
11003
11004 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11005   if test -n "$with_build_time_tools"; then
11006     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11007 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11008     if test -x $with_build_time_tools/windmc; then
11009       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11010       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11011       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11012 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11013     else
11014       echo "$as_me:$LINENO: result: no" >&5
11015 echo "${ECHO_T}no" >&6
11016     fi
11017   elif test $build != $host && test $have_gcc_for_target = yes; then
11018     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11019     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11020     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11021   fi
11022 fi
11023 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11024   # Extract the first word of "windmc", so it can be a program name with args.
11025 set dummy windmc; ac_word=$2
11026 echo "$as_me:$LINENO: checking for $ac_word" >&5
11027 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11028 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11029   echo $ECHO_N "(cached) $ECHO_C" >&6
11030 else
11031   case $WINDMC_FOR_TARGET in
11032   [\\/]* | ?:[\\/]*)
11033   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11034   ;;
11035   *)
11036   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11037 for as_dir in $gcc_cv_tool_dirs
11038 do
11039   IFS=$as_save_IFS
11040   test -z "$as_dir" && as_dir=.
11041   for ac_exec_ext in '' $ac_executable_extensions; do
11042   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11043     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11044     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11045     break 2
11046   fi
11047 done
11048 done
11049
11050   ;;
11051 esac
11052 fi
11053 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11054
11055 if test -n "$WINDMC_FOR_TARGET"; then
11056   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11057 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11058 else
11059   echo "$as_me:$LINENO: result: no" >&5
11060 echo "${ECHO_T}no" >&6
11061 fi
11062
11063 fi
11064 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11065
11066
11067 if test -n "$WINDMC_FOR_TARGET"; then
11068   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11069 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11070   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11071 fi
11072
11073 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11074   for ncn_progname in windmc; do
11075     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11076 set dummy ${ncn_progname}; ac_word=$2
11077 echo "$as_me:$LINENO: checking for $ac_word" >&5
11078 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11079 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11080   echo $ECHO_N "(cached) $ECHO_C" >&6
11081 else
11082   if test -n "$WINDMC_FOR_TARGET"; then
11083   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11084 else
11085 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11086 for as_dir in $PATH
11087 do
11088   IFS=$as_save_IFS
11089   test -z "$as_dir" && as_dir=.
11090   for ac_exec_ext in '' $ac_executable_extensions; do
11091   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11092     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11093     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11094     break 2
11095   fi
11096 done
11097 done
11098
11099 fi
11100 fi
11101 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11102 if test -n "$WINDMC_FOR_TARGET"; then
11103   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11104 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11105 else
11106   echo "$as_me:$LINENO: result: no" >&5
11107 echo "${ECHO_T}no" >&6
11108 fi
11109
11110   done
11111 fi
11112
11113 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11114   for ncn_progname in windmc; do
11115     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11116 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11117     if test -x $with_build_time_tools/${ncn_progname}; then
11118       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11119       echo "$as_me:$LINENO: result: yes" >&5
11120 echo "${ECHO_T}yes" >&6
11121       break
11122     else
11123       echo "$as_me:$LINENO: result: no" >&5
11124 echo "${ECHO_T}no" >&6
11125     fi
11126   done
11127 fi
11128
11129 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11130   for ncn_progname in windmc; do
11131     if test -n "$ncn_target_tool_prefix"; then
11132       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11133 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11134 echo "$as_me:$LINENO: checking for $ac_word" >&5
11135 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11136 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11137   echo $ECHO_N "(cached) $ECHO_C" >&6
11138 else
11139   if test -n "$WINDMC_FOR_TARGET"; then
11140   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11141 else
11142 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11143 for as_dir in $PATH
11144 do
11145   IFS=$as_save_IFS
11146   test -z "$as_dir" && as_dir=.
11147   for ac_exec_ext in '' $ac_executable_extensions; do
11148   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11149     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11150     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11151     break 2
11152   fi
11153 done
11154 done
11155
11156 fi
11157 fi
11158 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11159 if test -n "$WINDMC_FOR_TARGET"; then
11160   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11161 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11162 else
11163   echo "$as_me:$LINENO: result: no" >&5
11164 echo "${ECHO_T}no" >&6
11165 fi
11166
11167     fi
11168     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11169       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11170 set dummy ${ncn_progname}; ac_word=$2
11171 echo "$as_me:$LINENO: checking for $ac_word" >&5
11172 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11173 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11174   echo $ECHO_N "(cached) $ECHO_C" >&6
11175 else
11176   if test -n "$WINDMC_FOR_TARGET"; then
11177   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11178 else
11179 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11180 for as_dir in $PATH
11181 do
11182   IFS=$as_save_IFS
11183   test -z "$as_dir" && as_dir=.
11184   for ac_exec_ext in '' $ac_executable_extensions; do
11185   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11186     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11187     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11188     break 2
11189   fi
11190 done
11191 done
11192
11193 fi
11194 fi
11195 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11196 if test -n "$WINDMC_FOR_TARGET"; then
11197   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11198 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11199 else
11200   echo "$as_me:$LINENO: result: no" >&5
11201 echo "${ECHO_T}no" >&6
11202 fi
11203
11204     fi
11205     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11206   done
11207 fi
11208
11209 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11210   set dummy windmc
11211   if test $build = $target ; then
11212     WINDMC_FOR_TARGET="$2"
11213   else
11214     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11215   fi
11216 else
11217   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11218 fi
11219
11220 else
11221   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11222 fi
11223
11224
11225 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11226
11227 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11228 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11229 if test "x${build}" != "x${host}" ; then
11230   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11231     # We already found the complete path
11232     ac_dir=`dirname $AR_FOR_TARGET`
11233     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11234 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11235   else
11236     # Canadian cross, just use what we found
11237     echo "$as_me:$LINENO: result: pre-installed" >&5
11238 echo "${ECHO_T}pre-installed" >&6
11239   fi
11240 else
11241   ok=yes
11242   case " ${configdirs} " in
11243     *" binutils "*) ;;
11244     *) ok=no ;;
11245   esac
11246
11247   if test $ok = yes; then
11248     # An in-tree tool is available and we can use it
11249     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11250     echo "$as_me:$LINENO: result: just compiled" >&5
11251 echo "${ECHO_T}just compiled" >&6
11252   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11253     # We already found the complete path
11254     ac_dir=`dirname $AR_FOR_TARGET`
11255     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11256 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11257   elif test "x$target" = "x$host"; then
11258     # We can use an host tool
11259     AR_FOR_TARGET='$(AR)'
11260     echo "$as_me:$LINENO: result: host tool" >&5
11261 echo "${ECHO_T}host tool" >&6
11262   else
11263     # We need a cross tool
11264     echo "$as_me:$LINENO: result: pre-installed" >&5
11265 echo "${ECHO_T}pre-installed" >&6
11266   fi
11267 fi
11268
11269 echo "$as_me:$LINENO: checking where to find the target as" >&5
11270 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11271 if test "x${build}" != "x${host}" ; then
11272   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11273     # We already found the complete path
11274     ac_dir=`dirname $AS_FOR_TARGET`
11275     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11276 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11277   else
11278     # Canadian cross, just use what we found
11279     echo "$as_me:$LINENO: result: pre-installed" >&5
11280 echo "${ECHO_T}pre-installed" >&6
11281   fi
11282 else
11283   ok=yes
11284   case " ${configdirs} " in
11285     *" gas "*) ;;
11286     *) ok=no ;;
11287   esac
11288
11289   if test $ok = yes; then
11290     # An in-tree tool is available and we can use it
11291     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11292     echo "$as_me:$LINENO: result: just compiled" >&5
11293 echo "${ECHO_T}just compiled" >&6
11294   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11295     # We already found the complete path
11296     ac_dir=`dirname $AS_FOR_TARGET`
11297     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11298 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11299   elif test "x$target" = "x$host"; then
11300     # We can use an host tool
11301     AS_FOR_TARGET='$(AS)'
11302     echo "$as_me:$LINENO: result: host tool" >&5
11303 echo "${ECHO_T}host tool" >&6
11304   else
11305     # We need a cross tool
11306     echo "$as_me:$LINENO: result: pre-installed" >&5
11307 echo "${ECHO_T}pre-installed" >&6
11308   fi
11309 fi
11310
11311 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11312 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11313 if test "x${build}" != "x${host}" ; then
11314   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11315     # We already found the complete path
11316     ac_dir=`dirname $CC_FOR_TARGET`
11317     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11318 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11319   else
11320     # Canadian cross, just use what we found
11321     echo "$as_me:$LINENO: result: pre-installed" >&5
11322 echo "${ECHO_T}pre-installed" >&6
11323   fi
11324 else
11325   ok=yes
11326   case " ${configdirs} " in
11327     *" gcc "*) ;;
11328     *) ok=no ;;
11329   esac
11330
11331   if test $ok = yes; then
11332     # An in-tree tool is available and we can use it
11333     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11334     echo "$as_me:$LINENO: result: just compiled" >&5
11335 echo "${ECHO_T}just compiled" >&6
11336   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11337     # We already found the complete path
11338     ac_dir=`dirname $CC_FOR_TARGET`
11339     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11340 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11341   elif test "x$target" = "x$host"; then
11342     # We can use an host tool
11343     CC_FOR_TARGET='$(CC)'
11344     echo "$as_me:$LINENO: result: host tool" >&5
11345 echo "${ECHO_T}host tool" >&6
11346   else
11347     # We need a cross tool
11348     echo "$as_me:$LINENO: result: pre-installed" >&5
11349 echo "${ECHO_T}pre-installed" >&6
11350   fi
11351 fi
11352
11353 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11354 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11355 if test "x${build}" != "x${host}" ; then
11356   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11357     # We already found the complete path
11358     ac_dir=`dirname $CXX_FOR_TARGET`
11359     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11360 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11361   else
11362     # Canadian cross, just use what we found
11363     echo "$as_me:$LINENO: result: pre-installed" >&5
11364 echo "${ECHO_T}pre-installed" >&6
11365   fi
11366 else
11367   ok=yes
11368   case " ${configdirs} " in
11369     *" gcc "*) ;;
11370     *) ok=no ;;
11371   esac
11372   case ,${enable_languages}, in
11373     *,c++,*) ;;
11374     *) ok=no ;;
11375   esac
11376   if test $ok = yes; then
11377     # An in-tree tool is available and we can use it
11378     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'
11379     echo "$as_me:$LINENO: result: just compiled" >&5
11380 echo "${ECHO_T}just compiled" >&6
11381   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11382     # We already found the complete path
11383     ac_dir=`dirname $CXX_FOR_TARGET`
11384     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11385 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11386   elif test "x$target" = "x$host"; then
11387     # We can use an host tool
11388     CXX_FOR_TARGET='$(CXX)'
11389     echo "$as_me:$LINENO: result: host tool" >&5
11390 echo "${ECHO_T}host tool" >&6
11391   else
11392     # We need a cross tool
11393     echo "$as_me:$LINENO: result: pre-installed" >&5
11394 echo "${ECHO_T}pre-installed" >&6
11395   fi
11396 fi
11397
11398 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11399 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11400 if test "x${build}" != "x${host}" ; then
11401   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11402     # We already found the complete path
11403     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11404     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11405 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11406   else
11407     # Canadian cross, just use what we found
11408     echo "$as_me:$LINENO: result: pre-installed" >&5
11409 echo "${ECHO_T}pre-installed" >&6
11410   fi
11411 else
11412   ok=yes
11413   case " ${configdirs} " in
11414     *" gcc "*) ;;
11415     *) ok=no ;;
11416   esac
11417   case ,${enable_languages}, in
11418     *,c++,*) ;;
11419     *) ok=no ;;
11420   esac
11421   if test $ok = yes; then
11422     # An in-tree tool is available and we can use it
11423     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'
11424     echo "$as_me:$LINENO: result: just compiled" >&5
11425 echo "${ECHO_T}just compiled" >&6
11426   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11427     # We already found the complete path
11428     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11429     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11430 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11431   elif test "x$target" = "x$host"; then
11432     # We can use an host tool
11433     RAW_CXX_FOR_TARGET='$(CXX)'
11434     echo "$as_me:$LINENO: result: host tool" >&5
11435 echo "${ECHO_T}host tool" >&6
11436   else
11437     # We need a cross tool
11438     echo "$as_me:$LINENO: result: pre-installed" >&5
11439 echo "${ECHO_T}pre-installed" >&6
11440   fi
11441 fi
11442
11443 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11444 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11445 if test "x${build}" != "x${host}" ; then
11446   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11447     # We already found the complete path
11448     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11449     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11450 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11451   else
11452     # Canadian cross, just use what we found
11453     echo "$as_me:$LINENO: result: pre-installed" >&5
11454 echo "${ECHO_T}pre-installed" >&6
11455   fi
11456 else
11457   ok=yes
11458   case " ${configdirs} " in
11459     *" binutils "*) ;;
11460     *) ok=no ;;
11461   esac
11462
11463   if test $ok = yes; then
11464     # An in-tree tool is available and we can use it
11465     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11466     echo "$as_me:$LINENO: result: just compiled" >&5
11467 echo "${ECHO_T}just compiled" >&6
11468   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11469     # We already found the complete path
11470     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11471     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11472 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11473   elif test "x$target" = "x$host"; then
11474     # We can use an host tool
11475     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11476     echo "$as_me:$LINENO: result: host tool" >&5
11477 echo "${ECHO_T}host tool" >&6
11478   else
11479     # We need a cross tool
11480     echo "$as_me:$LINENO: result: pre-installed" >&5
11481 echo "${ECHO_T}pre-installed" >&6
11482   fi
11483 fi
11484
11485 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11486 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11487 if test "x${build}" != "x${host}" ; then
11488   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11489     # We already found the complete path
11490     ac_dir=`dirname $GCC_FOR_TARGET`
11491     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11492 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11493   else
11494     # Canadian cross, just use what we found
11495     echo "$as_me:$LINENO: result: pre-installed" >&5
11496 echo "${ECHO_T}pre-installed" >&6
11497   fi
11498 else
11499   ok=yes
11500   case " ${configdirs} " in
11501     *" gcc "*) ;;
11502     *) ok=no ;;
11503   esac
11504
11505   if test $ok = yes; then
11506     # An in-tree tool is available and we can use it
11507     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11508     echo "$as_me:$LINENO: result: just compiled" >&5
11509 echo "${ECHO_T}just compiled" >&6
11510   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11511     # We already found the complete path
11512     ac_dir=`dirname $GCC_FOR_TARGET`
11513     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11514 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11515   elif test "x$target" = "x$host"; then
11516     # We can use an host tool
11517     GCC_FOR_TARGET='$()'
11518     echo "$as_me:$LINENO: result: host tool" >&5
11519 echo "${ECHO_T}host tool" >&6
11520   else
11521     # We need a cross tool
11522     echo "$as_me:$LINENO: result: pre-installed" >&5
11523 echo "${ECHO_T}pre-installed" >&6
11524   fi
11525 fi
11526
11527 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11528 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11529 if test "x${build}" != "x${host}" ; then
11530   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11531     # We already found the complete path
11532     ac_dir=`dirname $GCJ_FOR_TARGET`
11533     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11534 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11535   else
11536     # Canadian cross, just use what we found
11537     echo "$as_me:$LINENO: result: pre-installed" >&5
11538 echo "${ECHO_T}pre-installed" >&6
11539   fi
11540 else
11541   ok=yes
11542   case " ${configdirs} " in
11543     *" gcc "*) ;;
11544     *) ok=no ;;
11545   esac
11546   case ,${enable_languages}, in
11547     *,java,*) ;;
11548     *) ok=no ;;
11549   esac
11550   if test $ok = yes; then
11551     # An in-tree tool is available and we can use it
11552     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11553     echo "$as_me:$LINENO: result: just compiled" >&5
11554 echo "${ECHO_T}just compiled" >&6
11555   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11556     # We already found the complete path
11557     ac_dir=`dirname $GCJ_FOR_TARGET`
11558     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11559 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11560   elif test "x$target" = "x$host"; then
11561     # We can use an host tool
11562     GCJ_FOR_TARGET='$(GCJ)'
11563     echo "$as_me:$LINENO: result: host tool" >&5
11564 echo "${ECHO_T}host tool" >&6
11565   else
11566     # We need a cross tool
11567     echo "$as_me:$LINENO: result: pre-installed" >&5
11568 echo "${ECHO_T}pre-installed" >&6
11569   fi
11570 fi
11571
11572 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11573 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11574 if test "x${build}" != "x${host}" ; then
11575   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11576     # We already found the complete path
11577     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11578     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11579 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11580   else
11581     # Canadian cross, just use what we found
11582     echo "$as_me:$LINENO: result: pre-installed" >&5
11583 echo "${ECHO_T}pre-installed" >&6
11584   fi
11585 else
11586   ok=yes
11587   case " ${configdirs} " in
11588     *" gcc "*) ;;
11589     *) ok=no ;;
11590   esac
11591   case ,${enable_languages}, in
11592     *,fortran,*) ;;
11593     *) ok=no ;;
11594   esac
11595   if test $ok = yes; then
11596     # An in-tree tool is available and we can use it
11597     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11598     echo "$as_me:$LINENO: result: just compiled" >&5
11599 echo "${ECHO_T}just compiled" >&6
11600   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11601     # We already found the complete path
11602     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11603     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11604 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11605   elif test "x$target" = "x$host"; then
11606     # We can use an host tool
11607     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11608     echo "$as_me:$LINENO: result: host tool" >&5
11609 echo "${ECHO_T}host tool" >&6
11610   else
11611     # We need a cross tool
11612     echo "$as_me:$LINENO: result: pre-installed" >&5
11613 echo "${ECHO_T}pre-installed" >&6
11614   fi
11615 fi
11616
11617 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11618 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11619 if test "x${build}" != "x${host}" ; then
11620   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11621     # We already found the complete path
11622     ac_dir=`dirname $LD_FOR_TARGET`
11623     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11624 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11625   else
11626     # Canadian cross, just use what we found
11627     echo "$as_me:$LINENO: result: pre-installed" >&5
11628 echo "${ECHO_T}pre-installed" >&6
11629   fi
11630 else
11631   ok=yes
11632   case " ${configdirs} " in
11633     *" ld "*) ;;
11634     *) ok=no ;;
11635   esac
11636
11637   if test $ok = yes; then
11638     # An in-tree tool is available and we can use it
11639     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11640     echo "$as_me:$LINENO: result: just compiled" >&5
11641 echo "${ECHO_T}just compiled" >&6
11642   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11643     # We already found the complete path
11644     ac_dir=`dirname $LD_FOR_TARGET`
11645     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11646 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11647   elif test "x$target" = "x$host"; then
11648     # We can use an host tool
11649     LD_FOR_TARGET='$(LD)'
11650     echo "$as_me:$LINENO: result: host tool" >&5
11651 echo "${ECHO_T}host tool" >&6
11652   else
11653     # We need a cross tool
11654     echo "$as_me:$LINENO: result: pre-installed" >&5
11655 echo "${ECHO_T}pre-installed" >&6
11656   fi
11657 fi
11658
11659 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11660 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11661 if test "x${build}" != "x${host}" ; then
11662   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11663     # We already found the complete path
11664     ac_dir=`dirname $LIPO_FOR_TARGET`
11665     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11666 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11667   else
11668     # Canadian cross, just use what we found
11669     echo "$as_me:$LINENO: result: pre-installed" >&5
11670 echo "${ECHO_T}pre-installed" >&6
11671   fi
11672 else
11673   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11674     # We already found the complete path
11675     ac_dir=`dirname $LIPO_FOR_TARGET`
11676     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11677 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11678   elif test "x$target" = "x$host"; then
11679     # We can use an host tool
11680     LIPO_FOR_TARGET='$(LIPO)'
11681     echo "$as_me:$LINENO: result: host tool" >&5
11682 echo "${ECHO_T}host tool" >&6
11683   else
11684     # We need a cross tool
11685     echo "$as_me:$LINENO: result: pre-installed" >&5
11686 echo "${ECHO_T}pre-installed" >&6
11687   fi
11688 fi
11689
11690 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11691 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11692 if test "x${build}" != "x${host}" ; then
11693   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11694     # We already found the complete path
11695     ac_dir=`dirname $NM_FOR_TARGET`
11696     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11697 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11698   else
11699     # Canadian cross, just use what we found
11700     echo "$as_me:$LINENO: result: pre-installed" >&5
11701 echo "${ECHO_T}pre-installed" >&6
11702   fi
11703 else
11704   ok=yes
11705   case " ${configdirs} " in
11706     *" binutils "*) ;;
11707     *) ok=no ;;
11708   esac
11709
11710   if test $ok = yes; then
11711     # An in-tree tool is available and we can use it
11712     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11713     echo "$as_me:$LINENO: result: just compiled" >&5
11714 echo "${ECHO_T}just compiled" >&6
11715   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11716     # We already found the complete path
11717     ac_dir=`dirname $NM_FOR_TARGET`
11718     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11719 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11720   elif test "x$target" = "x$host"; then
11721     # We can use an host tool
11722     NM_FOR_TARGET='$(NM)'
11723     echo "$as_me:$LINENO: result: host tool" >&5
11724 echo "${ECHO_T}host tool" >&6
11725   else
11726     # We need a cross tool
11727     echo "$as_me:$LINENO: result: pre-installed" >&5
11728 echo "${ECHO_T}pre-installed" >&6
11729   fi
11730 fi
11731
11732 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11733 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11734 if test "x${build}" != "x${host}" ; then
11735   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11736     # We already found the complete path
11737     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11738     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11739 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11740   else
11741     # Canadian cross, just use what we found
11742     echo "$as_me:$LINENO: result: pre-installed" >&5
11743 echo "${ECHO_T}pre-installed" >&6
11744   fi
11745 else
11746   ok=yes
11747   case " ${configdirs} " in
11748     *" binutils "*) ;;
11749     *) ok=no ;;
11750   esac
11751
11752   if test $ok = yes; then
11753     # An in-tree tool is available and we can use it
11754     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11755     echo "$as_me:$LINENO: result: just compiled" >&5
11756 echo "${ECHO_T}just compiled" >&6
11757   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11758     # We already found the complete path
11759     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11760     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11761 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11762   elif test "x$target" = "x$host"; then
11763     # We can use an host tool
11764     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11765     echo "$as_me:$LINENO: result: host tool" >&5
11766 echo "${ECHO_T}host tool" >&6
11767   else
11768     # We need a cross tool
11769     echo "$as_me:$LINENO: result: pre-installed" >&5
11770 echo "${ECHO_T}pre-installed" >&6
11771   fi
11772 fi
11773
11774 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11775 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11776 if test "x${build}" != "x${host}" ; then
11777   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11778     # We already found the complete path
11779     ac_dir=`dirname $RANLIB_FOR_TARGET`
11780     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11781 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11782   else
11783     # Canadian cross, just use what we found
11784     echo "$as_me:$LINENO: result: pre-installed" >&5
11785 echo "${ECHO_T}pre-installed" >&6
11786   fi
11787 else
11788   ok=yes
11789   case " ${configdirs} " in
11790     *" binutils "*) ;;
11791     *) ok=no ;;
11792   esac
11793
11794   if test $ok = yes; then
11795     # An in-tree tool is available and we can use it
11796     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11797     echo "$as_me:$LINENO: result: just compiled" >&5
11798 echo "${ECHO_T}just compiled" >&6
11799   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11800     # We already found the complete path
11801     ac_dir=`dirname $RANLIB_FOR_TARGET`
11802     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11803 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11804   elif test "x$target" = "x$host"; then
11805     # We can use an host tool
11806     RANLIB_FOR_TARGET='$(RANLIB)'
11807     echo "$as_me:$LINENO: result: host tool" >&5
11808 echo "${ECHO_T}host tool" >&6
11809   else
11810     # We need a cross tool
11811     echo "$as_me:$LINENO: result: pre-installed" >&5
11812 echo "${ECHO_T}pre-installed" >&6
11813   fi
11814 fi
11815
11816 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11817 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11818 if test "x${build}" != "x${host}" ; then
11819   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11820     # We already found the complete path
11821     ac_dir=`dirname $STRIP_FOR_TARGET`
11822     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11823 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11824   else
11825     # Canadian cross, just use what we found
11826     echo "$as_me:$LINENO: result: pre-installed" >&5
11827 echo "${ECHO_T}pre-installed" >&6
11828   fi
11829 else
11830   ok=yes
11831   case " ${configdirs} " in
11832     *" binutils "*) ;;
11833     *) ok=no ;;
11834   esac
11835
11836   if test $ok = yes; then
11837     # An in-tree tool is available and we can use it
11838     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11839     echo "$as_me:$LINENO: result: just compiled" >&5
11840 echo "${ECHO_T}just compiled" >&6
11841   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11842     # We already found the complete path
11843     ac_dir=`dirname $STRIP_FOR_TARGET`
11844     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11845 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11846   elif test "x$target" = "x$host"; then
11847     # We can use an host tool
11848     STRIP_FOR_TARGET='$(STRIP)'
11849     echo "$as_me:$LINENO: result: host tool" >&5
11850 echo "${ECHO_T}host tool" >&6
11851   else
11852     # We need a cross tool
11853     echo "$as_me:$LINENO: result: pre-installed" >&5
11854 echo "${ECHO_T}pre-installed" >&6
11855   fi
11856 fi
11857
11858 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11859 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11860 if test "x${build}" != "x${host}" ; then
11861   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11862     # We already found the complete path
11863     ac_dir=`dirname $WINDRES_FOR_TARGET`
11864     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11865 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11866   else
11867     # Canadian cross, just use what we found
11868     echo "$as_me:$LINENO: result: pre-installed" >&5
11869 echo "${ECHO_T}pre-installed" >&6
11870   fi
11871 else
11872   ok=yes
11873   case " ${configdirs} " in
11874     *" binutils "*) ;;
11875     *) ok=no ;;
11876   esac
11877
11878   if test $ok = yes; then
11879     # An in-tree tool is available and we can use it
11880     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11881     echo "$as_me:$LINENO: result: just compiled" >&5
11882 echo "${ECHO_T}just compiled" >&6
11883   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11884     # We already found the complete path
11885     ac_dir=`dirname $WINDRES_FOR_TARGET`
11886     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11887 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11888   elif test "x$target" = "x$host"; then
11889     # We can use an host tool
11890     WINDRES_FOR_TARGET='$(WINDRES)'
11891     echo "$as_me:$LINENO: result: host tool" >&5
11892 echo "${ECHO_T}host tool" >&6
11893   else
11894     # We need a cross tool
11895     echo "$as_me:$LINENO: result: pre-installed" >&5
11896 echo "${ECHO_T}pre-installed" >&6
11897   fi
11898 fi
11899
11900 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
11901 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
11902 if test "x${build}" != "x${host}" ; then
11903   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11904     # We already found the complete path
11905     ac_dir=`dirname $WINDMC_FOR_TARGET`
11906     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11907 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11908   else
11909     # Canadian cross, just use what we found
11910     echo "$as_me:$LINENO: result: pre-installed" >&5
11911 echo "${ECHO_T}pre-installed" >&6
11912   fi
11913 else
11914   ok=yes
11915   case " ${configdirs} " in
11916     *" binutils "*) ;;
11917     *) ok=no ;;
11918   esac
11919
11920   if test $ok = yes; then
11921     # An in-tree tool is available and we can use it
11922     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
11923     echo "$as_me:$LINENO: result: just compiled" >&5
11924 echo "${ECHO_T}just compiled" >&6
11925   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11926     # We already found the complete path
11927     ac_dir=`dirname $WINDMC_FOR_TARGET`
11928     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11929 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11930   elif test "x$target" = "x$host"; then
11931     # We can use an host tool
11932     WINDMC_FOR_TARGET='$(WINDMC)'
11933     echo "$as_me:$LINENO: result: host tool" >&5
11934 echo "${ECHO_T}host tool" >&6
11935   else
11936     # We need a cross tool
11937     echo "$as_me:$LINENO: result: pre-installed" >&5
11938 echo "${ECHO_T}pre-installed" >&6
11939   fi
11940 fi
11941
11942
11943
11944
11945
11946 # Certain tools may need extra flags.
11947 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
11948 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
11949 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
11950
11951 # When building target libraries, except in a Canadian cross, we use
11952 # the same toolchain as the compiler we just built.
11953 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
11954 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
11955 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
11956 if test $host = $build; then
11957   case " $configdirs " in
11958     *" gcc "*)
11959       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
11960       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
11961       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
11962       ;;
11963   esac
11964 fi
11965
11966
11967
11968
11969
11970 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
11971 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
11972 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
11973 if test "${enable_maintainer_mode+set}" = set; then
11974   enableval="$enable_maintainer_mode"
11975   USE_MAINTAINER_MODE=$enableval
11976 else
11977   USE_MAINTAINER_MODE=no
11978 fi;
11979 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
11980 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
11981
11982
11983 if test "$USE_MAINTAINER_MODE" = yes; then
11984   MAINTAINER_MODE_TRUE=
11985   MAINTAINER_MODE_FALSE='#'
11986 else
11987   MAINTAINER_MODE_TRUE='#'
11988   MAINTAINER_MODE_FALSE=
11989 fi
11990 MAINT=$MAINTAINER_MODE_TRUE
11991
11992 # ---------------------
11993 # GCC bootstrap support
11994 # ---------------------
11995
11996 # Stage specific cflags for build.
11997 stage1_cflags="-g"
11998 case $build in
11999   vax-*-*)
12000     case ${GCC} in
12001       yes) stage1_cflags="-g -Wa,-J" ;;
12002       *) stage1_cflags="-g -J" ;;
12003     esac ;;
12004 esac
12005
12006 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12007 if test "$GCC" = yes; then
12008   saved_CFLAGS="$CFLAGS"
12009
12010   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12011   CFLAGS="$CFLAGS -fkeep-inline-functions"
12012   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12013 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12014   cat >conftest.$ac_ext <<_ACEOF
12015 /* confdefs.h.  */
12016 _ACEOF
12017 cat confdefs.h >>conftest.$ac_ext
12018 cat >>conftest.$ac_ext <<_ACEOF
12019 /* end confdefs.h.  */
12020
12021 #if (__GNUC__ < 3) \
12022     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12023                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12024 #error http://gcc.gnu.org/PR29382
12025 #endif
12026
12027 int
12028 main ()
12029 {
12030
12031   ;
12032   return 0;
12033 }
12034 _ACEOF
12035 rm -f conftest.$ac_objext
12036 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12037   (eval $ac_compile) 2>conftest.er1
12038   ac_status=$?
12039   grep -v '^ *+' conftest.er1 >conftest.err
12040   rm -f conftest.er1
12041   cat conftest.err >&5
12042   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12043   (exit $ac_status); } &&
12044          { ac_try='test -z "$ac_c_werror_flag"
12045                          || test ! -s conftest.err'
12046   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12047   (eval $ac_try) 2>&5
12048   ac_status=$?
12049   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12050   (exit $ac_status); }; } &&
12051          { ac_try='test -s conftest.$ac_objext'
12052   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12053   (eval $ac_try) 2>&5
12054   ac_status=$?
12055   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12056   (exit $ac_status); }; }; then
12057   echo "$as_me:$LINENO: result: yes" >&5
12058 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12059 else
12060   echo "$as_me: failed program was:" >&5
12061 sed 's/^/| /' conftest.$ac_ext >&5
12062
12063 echo "$as_me:$LINENO: result: no" >&5
12064 echo "${ECHO_T}no" >&6
12065 fi
12066 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12067
12068   CFLAGS="$saved_CFLAGS"
12069 fi
12070
12071
12072
12073 # Enable --enable-checking in stage1 of the compiler.
12074 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12075 if test "${enable_stage1_checking+set}" = set; then
12076   enableval="$enable_stage1_checking"
12077   stage1_checking=--enable-checking=${enable_stage1_checking}
12078 else
12079   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12080   stage1_checking=--enable-checking=yes,types
12081 else
12082   stage1_checking=--enable-checking=$enable_checking,types
12083 fi
12084 fi;
12085
12086
12087 # Enable -Werror in bootstrap stage2 and later.
12088 # Check whether --enable-werror or --disable-werror was given.
12089 if test "${enable_werror+set}" = set; then
12090   enableval="$enable_werror"
12091
12092 else
12093   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12094   enable_werror=yes
12095 else
12096   enable_werror=no
12097 fi
12098 fi;
12099 case ${enable_werror} in
12100   yes) stage2_werror_flag="--enable-werror-always" ;;
12101   *) stage2_werror_flag="" ;;
12102 esac
12103
12104
12105 # Flags needed to enable html installing and building
12106
12107 # Check whether --with-datarootdir or --without-datarootdir was given.
12108 if test "${with_datarootdir+set}" = set; then
12109   withval="$with_datarootdir"
12110   datarootdir="\${prefix}/${withval}"
12111 else
12112   datarootdir="\${prefix}/share"
12113 fi;
12114
12115
12116 # Check whether --with-docdir or --without-docdir was given.
12117 if test "${with_docdir+set}" = set; then
12118   withval="$with_docdir"
12119   docdir="\${prefix}/${withval}"
12120 else
12121   docdir="\${datarootdir}/doc"
12122 fi;
12123
12124
12125 # Check whether --with-pdfdir or --without-pdfdir was given.
12126 if test "${with_pdfdir+set}" = set; then
12127   withval="$with_pdfdir"
12128   pdfdir="\${prefix}/${withval}"
12129 else
12130   pdfdir="\${docdir}"
12131 fi;
12132
12133
12134 # Check whether --with-htmldir or --without-htmldir was given.
12135 if test "${with_htmldir+set}" = set; then
12136   withval="$with_htmldir"
12137   htmldir="\${prefix}/${withval}"
12138 else
12139   htmldir="\${docdir}"
12140 fi;
12141
12142
12143
12144
12145
12146
12147           ac_config_files="$ac_config_files Makefile"
12148 cat >confcache <<\_ACEOF
12149 # This file is a shell script that caches the results of configure
12150 # tests run on this system so they can be shared between configure
12151 # scripts and configure runs, see configure's option --config-cache.
12152 # It is not useful on other systems.  If it contains results you don't
12153 # want to keep, you may remove or edit it.
12154 #
12155 # config.status only pays attention to the cache file if you give it
12156 # the --recheck option to rerun configure.
12157 #
12158 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12159 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12160 # following values.
12161
12162 _ACEOF
12163
12164 # The following way of writing the cache mishandles newlines in values,
12165 # but we know of no workaround that is simple, portable, and efficient.
12166 # So, don't put newlines in cache variables' values.
12167 # Ultrix sh set writes to stderr and can't be redirected directly,
12168 # and sets the high bit in the cache file unless we assign to the vars.
12169 {
12170   (set) 2>&1 |
12171     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12172     *ac_space=\ *)
12173       # `set' does not quote correctly, so add quotes (double-quote
12174       # substitution turns \\\\ into \\, and sed turns \\ into \).
12175       sed -n \
12176         "s/'/'\\\\''/g;
12177           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12178       ;;
12179     *)
12180       # `set' quotes correctly as required by POSIX, so do not add quotes.
12181       sed -n \
12182         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12183       ;;
12184     esac;
12185 } |
12186   sed '
12187      t clear
12188      : clear
12189      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12190      t end
12191      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12192      : end' >>confcache
12193 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12194   if test -w $cache_file; then
12195     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12196     cat confcache >$cache_file
12197   else
12198     echo "not updating unwritable cache $cache_file"
12199   fi
12200 fi
12201 rm -f confcache
12202
12203 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12204 # Let make expand exec_prefix.
12205 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12206
12207 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12208 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12209 # trailing colons and then remove the whole line if VPATH becomes empty
12210 # (actually we leave an empty line to preserve line numbers).
12211 if test "x$srcdir" = x.; then
12212   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12213 s/:*\$(srcdir):*/:/;
12214 s/:*\${srcdir}:*/:/;
12215 s/:*@srcdir@:*/:/;
12216 s/^\([^=]*=[     ]*\):*/\1/;
12217 s/:*$//;
12218 s/^[^=]*=[       ]*$//;
12219 }'
12220 fi
12221
12222 # Transform confdefs.h into DEFS.
12223 # Protect against shell expansion while executing Makefile rules.
12224 # Protect against Makefile macro expansion.
12225 #
12226 # If the first sed substitution is executed (which looks for macros that
12227 # take arguments), then we branch to the quote section.  Otherwise,
12228 # look for a macro that doesn't take arguments.
12229 cat >confdef2opt.sed <<\_ACEOF
12230 t clear
12231 : clear
12232 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12233 t quote
12234 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12235 t quote
12236 d
12237 : quote
12238 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12239 s,\[,\\&,g
12240 s,\],\\&,g
12241 s,\$,$$,g
12242 p
12243 _ACEOF
12244 # We use echo to avoid assuming a particular line-breaking character.
12245 # The extra dot is to prevent the shell from consuming trailing
12246 # line-breaks from the sub-command output.  A line-break within
12247 # single-quotes doesn't work because, if this script is created in a
12248 # platform that uses two characters for line-breaks (e.g., DOS), tr
12249 # would break.
12250 ac_LF_and_DOT=`echo; echo .`
12251 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12252 rm -f confdef2opt.sed
12253
12254
12255 ac_libobjs=
12256 ac_ltlibobjs=
12257 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12258   # 1. Remove the extension, and $U if already installed.
12259   ac_i=`echo "$ac_i" |
12260          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12261   # 2. Add them.
12262   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12263   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12264 done
12265 LIBOBJS=$ac_libobjs
12266
12267 LTLIBOBJS=$ac_ltlibobjs
12268
12269
12270
12271 : ${CONFIG_STATUS=./config.status}
12272 ac_clean_files_save=$ac_clean_files
12273 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12274 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12275 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12276 cat >$CONFIG_STATUS <<_ACEOF
12277 #! $SHELL
12278 # Generated by $as_me.
12279 # Run this file to recreate the current configuration.
12280 # Compiler output produced by configure, useful for debugging
12281 # configure, is in config.log if it exists.
12282
12283 debug=false
12284 ac_cs_recheck=false
12285 ac_cs_silent=false
12286 SHELL=\${CONFIG_SHELL-$SHELL}
12287 _ACEOF
12288
12289 cat >>$CONFIG_STATUS <<\_ACEOF
12290 ## --------------------- ##
12291 ## M4sh Initialization.  ##
12292 ## --------------------- ##
12293
12294 # Be Bourne compatible
12295 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12296   emulate sh
12297   NULLCMD=:
12298   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12299   # is contrary to our usage.  Disable this feature.
12300   alias -g '${1+"$@"}'='"$@"'
12301 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12302   set -o posix
12303 fi
12304 DUALCASE=1; export DUALCASE # for MKS sh
12305
12306 # Support unset when possible.
12307 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12308   as_unset=unset
12309 else
12310   as_unset=false
12311 fi
12312
12313
12314 # Work around bugs in pre-3.0 UWIN ksh.
12315 $as_unset ENV MAIL MAILPATH
12316 PS1='$ '
12317 PS2='> '
12318 PS4='+ '
12319
12320 # NLS nuisances.
12321 for as_var in \
12322   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12323   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12324   LC_TELEPHONE LC_TIME
12325 do
12326   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12327     eval $as_var=C; export $as_var
12328   else
12329     $as_unset $as_var
12330   fi
12331 done
12332
12333 # Required to use basename.
12334 if expr a : '\(a\)' >/dev/null 2>&1; then
12335   as_expr=expr
12336 else
12337   as_expr=false
12338 fi
12339
12340 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12341   as_basename=basename
12342 else
12343   as_basename=false
12344 fi
12345
12346
12347 # Name of the executable.
12348 as_me=`$as_basename "$0" ||
12349 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12350          X"$0" : 'X\(//\)$' \| \
12351          X"$0" : 'X\(/\)$' \| \
12352          .     : '\(.\)' 2>/dev/null ||
12353 echo X/"$0" |
12354     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12355           /^X\/\(\/\/\)$/{ s//\1/; q; }
12356           /^X\/\(\/\).*/{ s//\1/; q; }
12357           s/.*/./; q'`
12358
12359
12360 # PATH needs CR, and LINENO needs CR and PATH.
12361 # Avoid depending upon Character Ranges.
12362 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12363 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12364 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12365 as_cr_digits='0123456789'
12366 as_cr_alnum=$as_cr_Letters$as_cr_digits
12367
12368 # The user is always right.
12369 if test "${PATH_SEPARATOR+set}" != set; then
12370   echo "#! /bin/sh" >conf$$.sh
12371   echo  "exit 0"   >>conf$$.sh
12372   chmod +x conf$$.sh
12373   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12374     PATH_SEPARATOR=';'
12375   else
12376     PATH_SEPARATOR=:
12377   fi
12378   rm -f conf$$.sh
12379 fi
12380
12381
12382   as_lineno_1=$LINENO
12383   as_lineno_2=$LINENO
12384   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12385   test "x$as_lineno_1" != "x$as_lineno_2" &&
12386   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12387   # Find who we are.  Look in the path if we contain no path at all
12388   # relative or not.
12389   case $0 in
12390     *[\\/]* ) as_myself=$0 ;;
12391     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12392 for as_dir in $PATH
12393 do
12394   IFS=$as_save_IFS
12395   test -z "$as_dir" && as_dir=.
12396   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12397 done
12398
12399        ;;
12400   esac
12401   # We did not find ourselves, most probably we were run as `sh COMMAND'
12402   # in which case we are not to be found in the path.
12403   if test "x$as_myself" = x; then
12404     as_myself=$0
12405   fi
12406   if test ! -f "$as_myself"; then
12407     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12408 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12409    { (exit 1); exit 1; }; }
12410   fi
12411   case $CONFIG_SHELL in
12412   '')
12413     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12414 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12415 do
12416   IFS=$as_save_IFS
12417   test -z "$as_dir" && as_dir=.
12418   for as_base in sh bash ksh sh5; do
12419          case $as_dir in
12420          /*)
12421            if ("$as_dir/$as_base" -c '
12422   as_lineno_1=$LINENO
12423   as_lineno_2=$LINENO
12424   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12425   test "x$as_lineno_1" != "x$as_lineno_2" &&
12426   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12427              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12428              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12429              CONFIG_SHELL=$as_dir/$as_base
12430              export CONFIG_SHELL
12431              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12432            fi;;
12433          esac
12434        done
12435 done
12436 ;;
12437   esac
12438
12439   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12440   # uniformly replaced by the line number.  The first 'sed' inserts a
12441   # line-number line before each line; the second 'sed' does the real
12442   # work.  The second script uses 'N' to pair each line-number line
12443   # with the numbered line, and appends trailing '-' during
12444   # substitution so that $LINENO is not a special case at line end.
12445   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12446   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12447   sed '=' <$as_myself |
12448     sed '
12449       N
12450       s,$,-,
12451       : loop
12452       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12453       t loop
12454       s,-$,,
12455       s,^['$as_cr_digits']*\n,,
12456     ' >$as_me.lineno &&
12457   chmod +x $as_me.lineno ||
12458     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12459 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12460    { (exit 1); exit 1; }; }
12461
12462   # Don't try to exec as it changes $[0], causing all sort of problems
12463   # (the dirname of $[0] is not the place where we might find the
12464   # original and so on.  Autoconf is especially sensible to this).
12465   . ./$as_me.lineno
12466   # Exit status is that of the last command.
12467   exit
12468 }
12469
12470
12471 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12472   *c*,-n*) ECHO_N= ECHO_C='
12473 ' ECHO_T='      ' ;;
12474   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12475   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12476 esac
12477
12478 if expr a : '\(a\)' >/dev/null 2>&1; then
12479   as_expr=expr
12480 else
12481   as_expr=false
12482 fi
12483
12484 rm -f conf$$ conf$$.exe conf$$.file
12485 echo >conf$$.file
12486 if ln -s conf$$.file conf$$ 2>/dev/null; then
12487   # We could just check for DJGPP; but this test a) works b) is more generic
12488   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12489   if test -f conf$$.exe; then
12490     # Don't use ln at all; we don't have any links
12491     as_ln_s='cp -p'
12492   else
12493     as_ln_s='ln -s'
12494   fi
12495 elif ln conf$$.file conf$$ 2>/dev/null; then
12496   as_ln_s=ln
12497 else
12498   as_ln_s='cp -p'
12499 fi
12500 rm -f conf$$ conf$$.exe conf$$.file
12501
12502 if mkdir -p . 2>/dev/null; then
12503   as_mkdir_p=:
12504 else
12505   test -d ./-p && rmdir ./-p
12506   as_mkdir_p=false
12507 fi
12508
12509 as_executable_p="test -f"
12510
12511 # Sed expression to map a string onto a valid CPP name.
12512 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12513
12514 # Sed expression to map a string onto a valid variable name.
12515 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12516
12517
12518 # IFS
12519 # We need space, tab and new line, in precisely that order.
12520 as_nl='
12521 '
12522 IFS="   $as_nl"
12523
12524 # CDPATH.
12525 $as_unset CDPATH
12526
12527 exec 6>&1
12528
12529 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12530 # report actual input values of CONFIG_FILES etc. instead of their
12531 # values after options handling.  Logging --version etc. is OK.
12532 exec 5>>config.log
12533 {
12534   echo
12535   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12536 ## Running $as_me. ##
12537 _ASBOX
12538 } >&5
12539 cat >&5 <<_CSEOF
12540
12541 This file was extended by $as_me, which was
12542 generated by GNU Autoconf 2.59.  Invocation command line was
12543
12544   CONFIG_FILES    = $CONFIG_FILES
12545   CONFIG_HEADERS  = $CONFIG_HEADERS
12546   CONFIG_LINKS    = $CONFIG_LINKS
12547   CONFIG_COMMANDS = $CONFIG_COMMANDS
12548   $ $0 $@
12549
12550 _CSEOF
12551 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12552 echo >&5
12553 _ACEOF
12554
12555 # Files that config.status was made for.
12556 if test -n "$ac_config_files"; then
12557   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12558 fi
12559
12560 if test -n "$ac_config_headers"; then
12561   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12562 fi
12563
12564 if test -n "$ac_config_links"; then
12565   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12566 fi
12567
12568 if test -n "$ac_config_commands"; then
12569   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12570 fi
12571
12572 cat >>$CONFIG_STATUS <<\_ACEOF
12573
12574 ac_cs_usage="\
12575 \`$as_me' instantiates files from templates according to the
12576 current configuration.
12577
12578 Usage: $0 [OPTIONS] [FILE]...
12579
12580   -h, --help       print this help, then exit
12581   -V, --version    print version number, then exit
12582   -q, --quiet      do not print progress messages
12583   -d, --debug      don't remove temporary files
12584       --recheck    update $as_me by reconfiguring in the same conditions
12585   --file=FILE[:TEMPLATE]
12586                    instantiate the configuration file FILE
12587
12588 Configuration files:
12589 $config_files
12590
12591 Report bugs to <bug-autoconf@gnu.org>."
12592 _ACEOF
12593
12594 cat >>$CONFIG_STATUS <<_ACEOF
12595 ac_cs_version="\\
12596 config.status
12597 configured by $0, generated by GNU Autoconf 2.59,
12598   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12599
12600 Copyright (C) 2003 Free Software Foundation, Inc.
12601 This config.status script is free software; the Free Software Foundation
12602 gives unlimited permission to copy, distribute and modify it."
12603 srcdir=$srcdir
12604 INSTALL="$INSTALL"
12605 _ACEOF
12606
12607 cat >>$CONFIG_STATUS <<\_ACEOF
12608 # If no file are specified by the user, then we need to provide default
12609 # value.  By we need to know if files were specified by the user.
12610 ac_need_defaults=:
12611 while test $# != 0
12612 do
12613   case $1 in
12614   --*=*)
12615     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12616     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12617     ac_shift=:
12618     ;;
12619   -*)
12620     ac_option=$1
12621     ac_optarg=$2
12622     ac_shift=shift
12623     ;;
12624   *) # This is not an option, so the user has probably given explicit
12625      # arguments.
12626      ac_option=$1
12627      ac_need_defaults=false;;
12628   esac
12629
12630   case $ac_option in
12631   # Handling of the options.
12632 _ACEOF
12633 cat >>$CONFIG_STATUS <<\_ACEOF
12634   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12635     ac_cs_recheck=: ;;
12636   --version | --vers* | -V )
12637     echo "$ac_cs_version"; exit 0 ;;
12638   --he | --h)
12639     # Conflict between --help and --header
12640     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12641 Try \`$0 --help' for more information." >&5
12642 echo "$as_me: error: ambiguous option: $1
12643 Try \`$0 --help' for more information." >&2;}
12644    { (exit 1); exit 1; }; };;
12645   --help | --hel | -h )
12646     echo "$ac_cs_usage"; exit 0 ;;
12647   --debug | --d* | -d )
12648     debug=: ;;
12649   --file | --fil | --fi | --f )
12650     $ac_shift
12651     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12652     ac_need_defaults=false;;
12653   --header | --heade | --head | --hea )
12654     $ac_shift
12655     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12656     ac_need_defaults=false;;
12657   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12658   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12659     ac_cs_silent=: ;;
12660
12661   # This is an error.
12662   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12663 Try \`$0 --help' for more information." >&5
12664 echo "$as_me: error: unrecognized option: $1
12665 Try \`$0 --help' for more information." >&2;}
12666    { (exit 1); exit 1; }; } ;;
12667
12668   *) ac_config_targets="$ac_config_targets $1" ;;
12669
12670   esac
12671   shift
12672 done
12673
12674 ac_configure_extra_args=
12675
12676 if $ac_cs_silent; then
12677   exec 6>/dev/null
12678   ac_configure_extra_args="$ac_configure_extra_args --silent"
12679 fi
12680
12681 _ACEOF
12682 cat >>$CONFIG_STATUS <<_ACEOF
12683 if \$ac_cs_recheck; then
12684   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12685   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12686 fi
12687
12688 _ACEOF
12689
12690
12691
12692
12693
12694 cat >>$CONFIG_STATUS <<\_ACEOF
12695 for ac_config_target in $ac_config_targets
12696 do
12697   case "$ac_config_target" in
12698   # Handling of arguments.
12699   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12700   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12701 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12702    { (exit 1); exit 1; }; };;
12703   esac
12704 done
12705
12706 # If the user did not use the arguments to specify the items to instantiate,
12707 # then the envvar interface is used.  Set only those that are not.
12708 # We use the long form for the default assignment because of an extremely
12709 # bizarre bug on SunOS 4.1.3.
12710 if $ac_need_defaults; then
12711   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12712 fi
12713
12714 # Have a temporary directory for convenience.  Make it in the build tree
12715 # simply because there is no reason to put it here, and in addition,
12716 # creating and moving files from /tmp can sometimes cause problems.
12717 # Create a temporary directory, and hook for its removal unless debugging.
12718 $debug ||
12719 {
12720   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12721   trap '{ (exit 1); exit 1; }' 1 2 13 15
12722 }
12723
12724 # Create a (secure) tmp directory for tmp files.
12725
12726 {
12727   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12728   test -n "$tmp" && test -d "$tmp"
12729 }  ||
12730 {
12731   tmp=./confstat$$-$RANDOM
12732   (umask 077 && mkdir $tmp)
12733 } ||
12734 {
12735    echo "$me: cannot create a temporary directory in ." >&2
12736    { (exit 1); exit 1; }
12737 }
12738
12739 _ACEOF
12740
12741 cat >>$CONFIG_STATUS <<_ACEOF
12742
12743 #
12744 # CONFIG_FILES section.
12745 #
12746
12747 # No need to generate the scripts if there are no CONFIG_FILES.
12748 # This happens for instance when ./config.status config.h
12749 if test -n "\$CONFIG_FILES"; then
12750   # Protect against being on the right side of a sed subst in config.status.
12751   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12752    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12753 s,@SHELL@,$SHELL,;t t
12754 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12755 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12756 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12757 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12758 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12759 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12760 s,@exec_prefix@,$exec_prefix,;t t
12761 s,@prefix@,$prefix,;t t
12762 s,@program_transform_name@,$program_transform_name,;t t
12763 s,@bindir@,$bindir,;t t
12764 s,@sbindir@,$sbindir,;t t
12765 s,@libexecdir@,$libexecdir,;t t
12766 s,@datadir@,$datadir,;t t
12767 s,@sysconfdir@,$sysconfdir,;t t
12768 s,@sharedstatedir@,$sharedstatedir,;t t
12769 s,@localstatedir@,$localstatedir,;t t
12770 s,@libdir@,$libdir,;t t
12771 s,@includedir@,$includedir,;t t
12772 s,@oldincludedir@,$oldincludedir,;t t
12773 s,@infodir@,$infodir,;t t
12774 s,@mandir@,$mandir,;t t
12775 s,@build_alias@,$build_alias,;t t
12776 s,@host_alias@,$host_alias,;t t
12777 s,@target_alias@,$target_alias,;t t
12778 s,@DEFS@,$DEFS,;t t
12779 s,@ECHO_C@,$ECHO_C,;t t
12780 s,@ECHO_N@,$ECHO_N,;t t
12781 s,@ECHO_T@,$ECHO_T,;t t
12782 s,@LIBS@,$LIBS,;t t
12783 s,@build@,$build,;t t
12784 s,@build_cpu@,$build_cpu,;t t
12785 s,@build_vendor@,$build_vendor,;t t
12786 s,@build_os@,$build_os,;t t
12787 s,@build_noncanonical@,$build_noncanonical,;t t
12788 s,@host_noncanonical@,$host_noncanonical,;t t
12789 s,@target_noncanonical@,$target_noncanonical,;t t
12790 s,@host@,$host,;t t
12791 s,@host_cpu@,$host_cpu,;t t
12792 s,@host_vendor@,$host_vendor,;t t
12793 s,@host_os@,$host_os,;t t
12794 s,@target@,$target,;t t
12795 s,@target_cpu@,$target_cpu,;t t
12796 s,@target_vendor@,$target_vendor,;t t
12797 s,@target_os@,$target_os,;t t
12798 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12799 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12800 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12801 s,@LN@,$LN,;t t
12802 s,@LN_S@,$LN_S,;t t
12803 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12804 s,@build_libsubdir@,$build_libsubdir,;t t
12805 s,@build_subdir@,$build_subdir,;t t
12806 s,@host_subdir@,$host_subdir,;t t
12807 s,@target_subdir@,$target_subdir,;t t
12808 s,@CC@,$CC,;t t
12809 s,@CFLAGS@,$CFLAGS,;t t
12810 s,@LDFLAGS@,$LDFLAGS,;t t
12811 s,@CPPFLAGS@,$CPPFLAGS,;t t
12812 s,@ac_ct_CC@,$ac_ct_CC,;t t
12813 s,@EXEEXT@,$EXEEXT,;t t
12814 s,@OBJEXT@,$OBJEXT,;t t
12815 s,@CXX@,$CXX,;t t
12816 s,@CXXFLAGS@,$CXXFLAGS,;t t
12817 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12818 s,@GNATBIND@,$GNATBIND,;t t
12819 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12820 s,@GNATMAKE@,$GNATMAKE,;t t
12821 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12822 s,@do_compare@,$do_compare,;t t
12823 s,@gmplibs@,$gmplibs,;t t
12824 s,@gmpinc@,$gmpinc,;t t
12825 s,@stage1_languages@,$stage1_languages,;t t
12826 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12827 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12828 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12829 s,@tooldir@,$tooldir,;t t
12830 s,@build_tooldir@,$build_tooldir,;t t
12831 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12832 s,@GDB_TK@,$GDB_TK,;t t
12833 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12834 s,@build_configargs@,$build_configargs,;t t
12835 s,@build_configdirs@,$build_configdirs,;t t
12836 s,@host_configargs@,$host_configargs,;t t
12837 s,@configdirs@,$configdirs,;t t
12838 s,@target_configargs@,$target_configargs,;t t
12839 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
12840 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
12841 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12842 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12843 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
12844 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
12845 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
12846 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
12847 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
12848 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
12849 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
12850 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
12851 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
12852 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
12853 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
12854 s,@config_shell@,$config_shell,;t t
12855 s,@YACC@,$YACC,;t t
12856 s,@BISON@,$BISON,;t t
12857 s,@M4@,$M4,;t t
12858 s,@LEX@,$LEX,;t t
12859 s,@FLEX@,$FLEX,;t t
12860 s,@MAKEINFO@,$MAKEINFO,;t t
12861 s,@EXPECT@,$EXPECT,;t t
12862 s,@RUNTEST@,$RUNTEST,;t t
12863 s,@AR@,$AR,;t t
12864 s,@AS@,$AS,;t t
12865 s,@DLLTOOL@,$DLLTOOL,;t t
12866 s,@LD@,$LD,;t t
12867 s,@LIPO@,$LIPO,;t t
12868 s,@NM@,$NM,;t t
12869 s,@RANLIB@,$RANLIB,;t t
12870 s,@STRIP@,$STRIP,;t t
12871 s,@WINDRES@,$WINDRES,;t t
12872 s,@WINDMC@,$WINDMC,;t t
12873 s,@OBJCOPY@,$OBJCOPY,;t t
12874 s,@OBJDUMP@,$OBJDUMP,;t t
12875 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12876 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12877 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12878 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12879 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12880 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12881 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12882 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12883 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12884 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12885 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12886 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12887 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12888 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12889 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12890 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
12891 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12892 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12893 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12894 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12895 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12896 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12897 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12898 s,@MAINT@,$MAINT,;t t
12899 s,@stage1_cflags@,$stage1_cflags,;t t
12900 s,@stage1_checking@,$stage1_checking,;t t
12901 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12902 s,@datarootdir@,$datarootdir,;t t
12903 s,@docdir@,$docdir,;t t
12904 s,@pdfdir@,$pdfdir,;t t
12905 s,@htmldir@,$htmldir,;t t
12906 s,@LIBOBJS@,$LIBOBJS,;t t
12907 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12908 /@serialization_dependencies@/r $serialization_dependencies
12909 s,@serialization_dependencies@,,;t t
12910 /@host_makefile_frag@/r $host_makefile_frag
12911 s,@host_makefile_frag@,,;t t
12912 /@target_makefile_frag@/r $target_makefile_frag
12913 s,@target_makefile_frag@,,;t t
12914 /@alphaieee_frag@/r $alphaieee_frag
12915 s,@alphaieee_frag@,,;t t
12916 /@ospace_frag@/r $ospace_frag
12917 s,@ospace_frag@,,;t t
12918 CEOF
12919
12920 _ACEOF
12921
12922   cat >>$CONFIG_STATUS <<\_ACEOF
12923   # Split the substitutions into bite-sized pieces for seds with
12924   # small command number limits, like on Digital OSF/1 and HP-UX.
12925   ac_max_sed_lines=48
12926   ac_sed_frag=1 # Number of current file.
12927   ac_beg=1 # First line for current file.
12928   ac_end=$ac_max_sed_lines # Line after last line for current file.
12929   ac_more_lines=:
12930   ac_sed_cmds=
12931   while $ac_more_lines; do
12932     if test $ac_beg -gt 1; then
12933       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12934     else
12935       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12936     fi
12937     if test ! -s $tmp/subs.frag; then
12938       ac_more_lines=false
12939     else
12940       # The purpose of the label and of the branching condition is to
12941       # speed up the sed processing (if there are no `@' at all, there
12942       # is no need to browse any of the substitutions).
12943       # These are the two extra sed commands mentioned above.
12944       (echo ':t
12945   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
12946       if test -z "$ac_sed_cmds"; then
12947         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
12948       else
12949         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
12950       fi
12951       ac_sed_frag=`expr $ac_sed_frag + 1`
12952       ac_beg=$ac_end
12953       ac_end=`expr $ac_end + $ac_max_sed_lines`
12954     fi
12955   done
12956   if test -z "$ac_sed_cmds"; then
12957     ac_sed_cmds=cat
12958   fi
12959 fi # test -n "$CONFIG_FILES"
12960
12961 _ACEOF
12962 cat >>$CONFIG_STATUS <<\_ACEOF
12963 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
12964   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
12965   case $ac_file in
12966   - | *:- | *:-:* ) # input from stdin
12967         cat >$tmp/stdin
12968         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12969         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12970   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12971         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12972   * )   ac_file_in=$ac_file.in ;;
12973   esac
12974
12975   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
12976   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
12977 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12978          X"$ac_file" : 'X\(//\)[^/]' \| \
12979          X"$ac_file" : 'X\(//\)$' \| \
12980          X"$ac_file" : 'X\(/\)' \| \
12981          .     : '\(.\)' 2>/dev/null ||
12982 echo X"$ac_file" |
12983     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12984           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12985           /^X\(\/\/\)$/{ s//\1/; q; }
12986           /^X\(\/\).*/{ s//\1/; q; }
12987           s/.*/./; q'`
12988   { if $as_mkdir_p; then
12989     mkdir -p "$ac_dir"
12990   else
12991     as_dir="$ac_dir"
12992     as_dirs=
12993     while test ! -d "$as_dir"; do
12994       as_dirs="$as_dir $as_dirs"
12995       as_dir=`(dirname "$as_dir") 2>/dev/null ||
12996 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12997          X"$as_dir" : 'X\(//\)[^/]' \| \
12998          X"$as_dir" : 'X\(//\)$' \| \
12999          X"$as_dir" : 'X\(/\)' \| \
13000          .     : '\(.\)' 2>/dev/null ||
13001 echo X"$as_dir" |
13002     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13003           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13004           /^X\(\/\/\)$/{ s//\1/; q; }
13005           /^X\(\/\).*/{ s//\1/; q; }
13006           s/.*/./; q'`
13007     done
13008     test ! -n "$as_dirs" || mkdir $as_dirs
13009   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13010 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13011    { (exit 1); exit 1; }; }; }
13012
13013   ac_builddir=.
13014
13015 if test "$ac_dir" != .; then
13016   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13017   # A "../" for each directory in $ac_dir_suffix.
13018   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13019 else
13020   ac_dir_suffix= ac_top_builddir=
13021 fi
13022
13023 case $srcdir in
13024   .)  # No --srcdir option.  We are building in place.
13025     ac_srcdir=.
13026     if test -z "$ac_top_builddir"; then
13027        ac_top_srcdir=.
13028     else
13029        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13030     fi ;;
13031   [\\/]* | ?:[\\/]* )  # Absolute path.
13032     ac_srcdir=$srcdir$ac_dir_suffix;
13033     ac_top_srcdir=$srcdir ;;
13034   *) # Relative path.
13035     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13036     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13037 esac
13038
13039 # Do not use `cd foo && pwd` to compute absolute paths, because
13040 # the directories may not exist.
13041 case `pwd` in
13042 .) ac_abs_builddir="$ac_dir";;
13043 *)
13044   case "$ac_dir" in
13045   .) ac_abs_builddir=`pwd`;;
13046   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13047   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13048   esac;;
13049 esac
13050 case $ac_abs_builddir in
13051 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13052 *)
13053   case ${ac_top_builddir}. in
13054   .) ac_abs_top_builddir=$ac_abs_builddir;;
13055   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13056   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13057   esac;;
13058 esac
13059 case $ac_abs_builddir in
13060 .) ac_abs_srcdir=$ac_srcdir;;
13061 *)
13062   case $ac_srcdir in
13063   .) ac_abs_srcdir=$ac_abs_builddir;;
13064   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13065   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13066   esac;;
13067 esac
13068 case $ac_abs_builddir in
13069 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13070 *)
13071   case $ac_top_srcdir in
13072   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13073   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13074   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13075   esac;;
13076 esac
13077
13078
13079   case $INSTALL in
13080   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13081   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13082   esac
13083
13084   if test x"$ac_file" != x-; then
13085     { echo "$as_me:$LINENO: creating $ac_file" >&5
13086 echo "$as_me: creating $ac_file" >&6;}
13087     rm -f "$ac_file"
13088   fi
13089   # Let's still pretend it is `configure' which instantiates (i.e., don't
13090   # use $as_me), people would be surprised to read:
13091   #    /* config.h.  Generated by config.status.  */
13092   if test x"$ac_file" = x-; then
13093     configure_input=
13094   else
13095     configure_input="$ac_file.  "
13096   fi
13097   configure_input=$configure_input"Generated from `echo $ac_file_in |
13098                                      sed 's,.*/,,'` by configure."
13099
13100   # First look for the input files in the build tree, otherwise in the
13101   # src tree.
13102   ac_file_inputs=`IFS=:
13103     for f in $ac_file_in; do
13104       case $f in
13105       -) echo $tmp/stdin ;;
13106       [\\/$]*)
13107          # Absolute (can't be DOS-style, as IFS=:)
13108          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13109 echo "$as_me: error: cannot find input file: $f" >&2;}
13110    { (exit 1); exit 1; }; }
13111          echo "$f";;
13112       *) # Relative
13113          if test -f "$f"; then
13114            # Build tree
13115            echo "$f"
13116          elif test -f "$srcdir/$f"; then
13117            # Source tree
13118            echo "$srcdir/$f"
13119          else
13120            # /dev/null tree
13121            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13122 echo "$as_me: error: cannot find input file: $f" >&2;}
13123    { (exit 1); exit 1; }; }
13124          fi;;
13125       esac
13126     done` || { (exit 1); exit 1; }
13127 _ACEOF
13128 cat >>$CONFIG_STATUS <<_ACEOF
13129   sed "$ac_vpsub
13130 $extrasub
13131 _ACEOF
13132 cat >>$CONFIG_STATUS <<\_ACEOF
13133 :t
13134 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13135 s,@configure_input@,$configure_input,;t t
13136 s,@srcdir@,$ac_srcdir,;t t
13137 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13138 s,@top_srcdir@,$ac_top_srcdir,;t t
13139 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13140 s,@builddir@,$ac_builddir,;t t
13141 s,@abs_builddir@,$ac_abs_builddir,;t t
13142 s,@top_builddir@,$ac_top_builddir,;t t
13143 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13144 s,@INSTALL@,$ac_INSTALL,;t t
13145 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13146   rm -f $tmp/stdin
13147   if test x"$ac_file" != x-; then
13148     mv $tmp/out $ac_file
13149   else
13150     cat $tmp/out
13151     rm -f $tmp/out
13152   fi
13153
13154 done
13155 _ACEOF
13156
13157 cat >>$CONFIG_STATUS <<\_ACEOF
13158
13159 { (exit 0); exit 0; }
13160 _ACEOF
13161 chmod +x $CONFIG_STATUS
13162 ac_clean_files=$ac_clean_files_save
13163
13164
13165 # configure is writing to config.log, and then calls config.status.
13166 # config.status does its own redirection, appending to config.log.
13167 # Unfortunately, on DOS this fails, as config.log is still kept open
13168 # by configure, so config.status won't be able to write to it; its
13169 # output is simply discarded.  So we exec the FD to /dev/null,
13170 # effectively closing config.log, so it can be properly (re)opened and
13171 # appended to by config.status.  When coming back to configure, we
13172 # need to make the FD available again.
13173 if test "$no_create" != yes; then
13174   ac_cs_success=:
13175   ac_config_status_args=
13176   test "$silent" = yes &&
13177     ac_config_status_args="$ac_config_status_args --quiet"
13178   exec 5>/dev/null
13179   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13180   exec 5>>config.log
13181   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13182   # would make configure fail if this is the last instruction.
13183   $ac_cs_success || { (exit 1); exit 1; }
13184 fi
13185