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 CFLAGS_FOR_TARGET CXXFLAGS_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 # Reject install programs that cannot install multiple files.
1638 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1639 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1640 if test -z "$INSTALL"; then
1641 if test "${ac_cv_path_install+set}" = set; then
1642   echo $ECHO_N "(cached) $ECHO_C" >&6
1643 else
1644   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1645 for as_dir in $PATH
1646 do
1647   IFS=$as_save_IFS
1648   test -z "$as_dir" && as_dir=.
1649   # Account for people who put trailing slashes in PATH elements.
1650 case $as_dir/ in
1651   ./ | .// | /cC/* | \
1652   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1653   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1654   /usr/ucb/* ) ;;
1655   *)
1656     # OSF1 and SCO ODT 3.0 have their own names for install.
1657     # Don't use installbsd from OSF since it installs stuff as root
1658     # by default.
1659     for ac_prog in ginstall scoinst install; do
1660       for ac_exec_ext in '' $ac_executable_extensions; do
1661         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1662           if test $ac_prog = install &&
1663             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1664             # AIX install.  It has an incompatible calling convention.
1665             :
1666           elif test $ac_prog = install &&
1667             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1668             # program-specific install script used by HP pwplus--don't use.
1669             :
1670           else
1671             rm -rf conftest.one conftest.two conftest.dir
1672             echo one > conftest.one
1673             echo two > conftest.two
1674             mkdir conftest.dir
1675             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1676               test -s conftest.one && test -s conftest.two &&
1677               test -s conftest.dir/conftest.one &&
1678               test -s conftest.dir/conftest.two
1679             then
1680               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1681               break 3
1682             fi
1683           fi
1684         fi
1685       done
1686     done
1687     ;;
1688 esac
1689 done
1690
1691 rm -rf conftest.one conftest.two conftest.dir
1692
1693 fi
1694   if test "${ac_cv_path_install+set}" = set; then
1695     INSTALL=$ac_cv_path_install
1696   else
1697     # As a last resort, use the slow shell script.  Don't cache a
1698     # value for INSTALL within a source directory, because that will
1699     # break other packages using the cache if that directory is
1700     # removed, or if the value is a relative name.
1701     INSTALL=$ac_install_sh
1702   fi
1703 fi
1704 echo "$as_me:$LINENO: result: $INSTALL" >&5
1705 echo "${ECHO_T}$INSTALL" >&6
1706
1707 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1708 # It thinks the first close brace ends the variable substitution.
1709 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1710
1711 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1712
1713 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1714
1715 echo "$as_me:$LINENO: checking whether ln works" >&5
1716 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1717 if test "${acx_cv_prog_LN+set}" = set; then
1718   echo $ECHO_N "(cached) $ECHO_C" >&6
1719 else
1720   rm -f conftestdata_t
1721 echo >conftestdata_f
1722 if ln conftestdata_f conftestdata_t 2>/dev/null
1723 then
1724   acx_cv_prog_LN=ln
1725 else
1726   acx_cv_prog_LN=no
1727 fi
1728 rm -f conftestdata_f conftestdata_t
1729
1730 fi
1731 if test $acx_cv_prog_LN = no; then
1732   LN="cp"
1733   echo "$as_me:$LINENO: result: no, using $LN" >&5
1734 echo "${ECHO_T}no, using $LN" >&6
1735 else
1736   LN="$acx_cv_prog_LN"
1737   echo "$as_me:$LINENO: result: yes" >&5
1738 echo "${ECHO_T}yes" >&6
1739 fi
1740
1741 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1742 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1743 LN_S=$as_ln_s
1744 if test "$LN_S" = "ln -s"; then
1745   echo "$as_me:$LINENO: result: yes" >&5
1746 echo "${ECHO_T}yes" >&6
1747 else
1748   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1749 echo "${ECHO_T}no, using $LN_S" >&6
1750 fi
1751
1752
1753 ### we might need to use some other shell than /bin/sh for running subshells
1754 ### If we are on Windows, search for the shell.  This will permit people
1755 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1756 ### without also having to set CONFIG_SHELL.  This code will work when
1757 ### using bash, which sets OSTYPE.
1758 case "${OSTYPE}" in
1759 *win32*)
1760   if test x${CONFIG_SHELL} = x ; then
1761     if test ! -f /bin/sh ; then
1762       if test x${SHELL} != x && test -f ${SHELL} ; then
1763         CONFIG_SHELL=${SHELL}
1764         export CONFIG_SHELL
1765       else
1766         for prog in sh sh.exe bash bash.exe; do
1767           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1768           for dir in $PATH; do
1769             test -z "$dir" && dir=.
1770             if test -f $dir/$prog; then
1771               CONFIG_SHELL=$dir/$prog
1772               export CONFIG_SHELL
1773               break
1774             fi
1775           done
1776           IFS="$save_ifs"
1777           test -n "${CONFIG_SHELL}" && break
1778         done
1779       fi
1780     fi
1781   fi
1782   ;;
1783 esac
1784
1785 config_shell=${CONFIG_SHELL-/bin/sh}
1786
1787 progname=$0
1788 # if PWD already has a value, it is probably wrong.
1789 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1790
1791 # Export original configure arguments for use by sub-configures.
1792 # Quote arguments with shell meta charatcers.
1793 TOPLEVEL_CONFIGURE_ARGUMENTS=
1794 set -- "$progname" "$@"
1795 for ac_arg
1796 do
1797   case "$ac_arg" in
1798   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1799     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1800     # if the argument is of the form -foo=baz, quote the baz part only
1801     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1802   *) ;;
1803   esac
1804   # Add the quoted argument to the list.
1805   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1806 done
1807 if test "$silent" = yes; then
1808   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1809 fi
1810 # Remove the initial space we just introduced and, as these will be
1811 # expanded by make, quote '$'.
1812 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1813
1814
1815 moveifchange=${srcdir}/move-if-change
1816
1817 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1818
1819 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1820 # a relative path.
1821 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1822   INSTALL="${srcpwd}/install-sh -c"
1823 fi
1824
1825 # Set srcdir to "." if that's what it is.
1826 # This is important for multilib support.
1827 pwd=`${PWDCMD-pwd}`
1828 if test "${pwd}" = "${srcpwd}" ; then
1829   srcdir=.
1830 fi
1831
1832 topsrcdir=$srcpwd
1833
1834 extra_host_args=
1835
1836 ### To add a new directory to the tree, first choose whether it is a target
1837 ### or a host dependent tool.  Then put it into the appropriate list
1838 ### (library or tools, host or target), doing a dependency sort.
1839
1840 # Subdirs will be configured in the order listed in build_configdirs,
1841 # configdirs, or target_configdirs; see the serialization section below.
1842
1843 # Dependency sorting is only needed when *configuration* must be done in
1844 # a particular order.  In all cases a dependency should be specified in
1845 # the Makefile, whether or not it's implicitly specified here.
1846
1847 # Double entries in build_configdirs, configdirs, or target_configdirs may
1848 # cause circular dependencies and break everything horribly.
1849
1850 # these library is used by various programs built for the build
1851 # environment
1852 #
1853 build_libs="build-libiberty"
1854
1855 # these tools are built for the build environment
1856 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1857
1858 # these libraries are used by various programs built for the host environment
1859 #
1860 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1861
1862 # these tools are built for the host environment
1863 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1864 # know that we are building the simulator.
1865 # binutils, gas and ld appear in that order because it makes sense to run
1866 # "make check" in that particular order.
1867 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"
1868
1869 # libgcj represents the runtime libraries only used by gcj.
1870 libgcj="target-libffi \
1871         target-zlib \
1872         target-qthreads \
1873         target-libjava"
1874
1875 # these libraries are built for the target environment, and are built after
1876 # the host libraries and the host tools (which may be a cross compiler)
1877 #
1878 target_libraries="target-libgcc \
1879                 target-libiberty \
1880                 target-libgloss \
1881                 target-newlib \
1882                 target-libgomp \
1883                 target-libstdc++-v3 \
1884                 target-libmudflap \
1885                 target-libssp \
1886                 target-libgfortran \
1887                 target-boehm-gc \
1888                 ${libgcj} \
1889                 target-libobjc \
1890                 target-libada"
1891
1892 # these tools are built using the target libraries, and are intended to
1893 # run only in the target environment
1894 #
1895 # note: any program that *uses* libraries that are in the "target_libraries"
1896 # list belongs in this list.  those programs are also very likely
1897 # candidates for the "native_only" list which follows
1898 #
1899 target_tools="target-examples target-groff target-gperf target-rda"
1900
1901 ################################################################################
1902
1903 ## All tools belong in one of the four categories, and are assigned above
1904 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1905 ## is important because configure will choke if they ever get through.
1906 ## ${configdirs} is directories we build using the host tools.
1907 ## ${target_configdirs} is directories we build using the target tools.
1908 configdirs=`echo ${host_libs} ${host_tools}`
1909 target_configdirs=`echo ${target_libraries} ${target_tools}`
1910 build_configdirs=`echo ${build_libs} ${build_tools}`
1911
1912
1913
1914 ################################################################################
1915
1916 srcname="gnu development package"
1917
1918 # This gets set non-empty for some net releases of packages.
1919 appdirs=""
1920
1921 # Define is_cross_compiler to save on calls to 'test'.
1922 is_cross_compiler=
1923 if test x"${host}" = x"${target}" ; then
1924   is_cross_compiler=no
1925 else
1926   is_cross_compiler=yes
1927 fi
1928
1929 # Find the build and target subdir names.
1930
1931 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1932 # have matching libraries, they should use host libraries: Makefile.tpl
1933 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1934 # However, they still use the build modules, because the corresponding
1935 # host modules (e.g. bison) are only built for the host when bootstrap
1936 # finishes. So:
1937 # - build_subdir is where we find build modules, and never changes.
1938 # - build_libsubdir is where we find build libraries, and can be overridden.
1939
1940 # Prefix 'build-' so this never conflicts with target_subdir.
1941 build_subdir="build-${build_noncanonical}"
1942
1943 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1944 if test "${with_build_libsubdir+set}" = set; then
1945   withval="$with_build_libsubdir"
1946   build_libsubdir="$withval"
1947 else
1948   build_libsubdir="$build_subdir"
1949 fi;
1950 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1951 if ( test $srcdir = . && test -d gcc ) \
1952    || test -d $srcdir/../host-${host_noncanonical}; then
1953   host_subdir="host-${host_noncanonical}"
1954 else
1955   host_subdir=.
1956 fi
1957 # No prefix.
1958 target_subdir=${target_noncanonical}
1959
1960
1961 # Skipdirs are removed silently.
1962 skipdirs=
1963 # Noconfigdirs are removed loudly.
1964 noconfigdirs=""
1965
1966 use_gnu_ld=
1967 # Make sure we don't let GNU ld be added if we didn't want it.
1968 if test x$with_gnu_ld = xno ; then
1969   use_gnu_ld=no
1970   noconfigdirs="$noconfigdirs ld"
1971 fi
1972
1973 use_gnu_as=
1974 # Make sure we don't let GNU as be added if we didn't want it.
1975 if test x$with_gnu_as = xno ; then
1976   use_gnu_as=no
1977   noconfigdirs="$noconfigdirs gas"
1978 fi
1979
1980 # some tools are so dependent upon X11 that if we're not building with X,
1981 # it's not even worth trying to configure, much less build, that tool.
1982
1983 case ${with_x} in
1984   yes | "") ;; # the default value for this tree is that X11 is available
1985   no)
1986     skipdirs="${skipdirs} tk itcl libgui"
1987     # We won't be able to build gdbtk without X.
1988     enable_gdbtk=no
1989     ;;
1990   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
1991 esac
1992
1993 # Some tools are only suitable for building in a "native" situation.
1994 # Remove these if host!=target.
1995 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"
1996
1997 # Similarly, some are only suitable for cross toolchains.
1998 # Remove these if host=target.
1999 cross_only="target-libgloss target-newlib target-opcodes"
2000
2001 case $is_cross_compiler in
2002   no) skipdirs="${skipdirs} ${cross_only}" ;;
2003   yes) skipdirs="${skipdirs} ${native_only}" ;;
2004 esac
2005
2006 # If both --with-headers and --with-libs are specified, default to
2007 # --without-newlib.
2008 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2009    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2010   if test x"${with_newlib}" = x ; then
2011     with_newlib=no
2012   fi
2013 fi
2014
2015 # Recognize --with-newlib/--without-newlib.
2016 case ${with_newlib} in
2017   no) skipdirs="${skipdirs} target-newlib" ;;
2018   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2019 esac
2020
2021 # Configure extra directories which are host specific
2022
2023 case "${host}" in
2024   *-cygwin*)
2025     configdirs="$configdirs libtermcap" ;;
2026 esac
2027
2028 # A target can indicate whether a language isn't supported for some reason.
2029 # Only spaces may be used in this macro; not newlines or tabs.
2030 unsupported_languages=
2031
2032 # Remove more programs from consideration, based on the host or
2033 # target this usually means that a port of the program doesn't
2034 # exist yet.
2035
2036 case "${host}" in
2037   hppa*64*-*-*)
2038     noconfigdirs="$noconfigdirs byacc"
2039     ;;
2040   i[3456789]86-*-vsta)
2041     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2042     ;;
2043   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2044     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2045     ;;
2046   x86_64-*-mingw*)
2047     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2048     ;;
2049   i[3456789]86-*-mingw32*)
2050     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2051     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2052     ;;
2053   i[3456789]86-*-beos*)
2054     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2055     ;;
2056   *-*-cygwin*)
2057     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2058     ;;
2059   *-*-netbsd*)
2060     noconfigdirs="$noconfigdirs rcs"
2061     ;;
2062   ppc*-*-pe)
2063     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2064     ;;
2065   powerpc-*-beos*)
2066     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2067     ;;
2068 esac
2069
2070
2071 # Check whether --enable-libada or --disable-libada was given.
2072 if test "${enable_libada+set}" = set; then
2073   enableval="$enable_libada"
2074   ENABLE_LIBADA=$enableval
2075 else
2076   ENABLE_LIBADA=yes
2077 fi;
2078 if test "${ENABLE_LIBADA}" != "yes" ; then
2079   noconfigdirs="$noconfigdirs gnattools"
2080 fi
2081
2082 # Check whether --enable-libssp or --disable-libssp was given.
2083 if test "${enable_libssp+set}" = set; then
2084   enableval="$enable_libssp"
2085   ENABLE_LIBSSP=$enableval
2086 else
2087   ENABLE_LIBSSP=yes
2088 fi;
2089
2090 # Save it here so that, even in case of --enable-libgcj, if the Java
2091 # front-end isn't enabled, we still get libgcj disabled.
2092 libgcj_saved=$libgcj
2093 case $enable_libgcj in
2094 yes)
2095   # If we reset it here, it won't get added to noconfigdirs in the
2096   # target-specific build rules, so it will be forcibly enabled
2097   # (unless the Java language itself isn't enabled).
2098   libgcj=
2099   ;;
2100 no)
2101   # Make sure we get it printed in the list of not supported target libs.
2102   noconfigdirs="$noconfigdirs ${libgcj}"
2103   ;;
2104 esac
2105
2106
2107 # Disable libmudflap on some systems.
2108 if test x$enable_libmudflap = x ; then
2109     case "${target}" in
2110     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2111         # Enable libmudflap by default in GNU and friends.
2112         ;;
2113     *-*-freebsd*)
2114         # Enable libmudflap by default in FreeBSD.
2115         ;;
2116     *)
2117         # Disable it by default everywhere else.
2118         noconfigdirs="$noconfigdirs target-libmudflap"
2119         ;;
2120     esac
2121 fi
2122
2123 # Disable libgomp on non POSIX hosted systems.
2124 if test x$enable_libgomp = x ; then
2125     # Enable libgomp by default on hosted POSIX systems.
2126     case "${target}" in
2127     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2128         ;;
2129     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2130         ;;
2131     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2132         ;;
2133     *-*-darwin* | *-*-aix*)
2134         ;;
2135     *)
2136         noconfigdirs="$noconfigdirs target-libgomp"
2137         ;;
2138     esac
2139 fi
2140
2141 # Default libgloss CPU subdirectory.
2142 libgloss_dir="$target_cpu"
2143
2144 case "${target}" in
2145   *-*-chorusos)
2146     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2147     ;;
2148   powerpc-*-darwin* | i[3456789]86-*-darwin* | x86_64-*-darwin9*)
2149     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2150     noconfigdirs="$noconfigdirs sim target-rda"
2151     ;;
2152   *-*-darwin*)
2153     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2154     noconfigdirs="$noconfigdirs sim target-rda"
2155     noconfigdirs="$noconfigdirs ${libgcj}"
2156     ;;
2157   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2158     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2159     ;;
2160   *-*-freebsd*)
2161     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2162     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2163         && test -f /usr/local/include/gmp.h; then
2164       with_gmp=/usr/local
2165     fi
2166
2167     # Skip some stuff that's unsupported on some FreeBSD configurations.
2168     case "${target}" in
2169       i*86-*-*) ;;
2170       alpha*-*-*) ;;
2171       *)
2172         noconfigdirs="$noconfigdirs ${libgcj}"
2173         ;;
2174     esac
2175     ;;
2176   *-*-kaos*)
2177     # Remove unsupported stuff on all kaOS configurations.
2178     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2179     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2180     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2181     noconfigdirs="$noconfigdirs target-libgloss"
2182     ;;
2183   *-*-netbsd*)
2184     # Skip some stuff on all NetBSD configurations.
2185     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2186
2187     # Skip some stuff that's unsupported on some NetBSD configurations.
2188     case "${target}" in
2189       i*86-*-netbsdelf*) ;;
2190       arm*-*-netbsdelf*) ;;
2191       *)
2192         noconfigdirs="$noconfigdirs ${libgcj}"
2193         ;;
2194     esac
2195     ;;
2196   *-*-netware*)
2197     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2198     ;;
2199   *-*-rtems*)
2200     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2201     ;;
2202     # The tpf target doesn't support gdb yet.
2203   *-*-tpf*)
2204     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2205     ;;
2206   *-*-uclinux*)
2207     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2208     ;;
2209   *-*-vxworks*)
2210     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2211     ;;
2212   alpha*-dec-osf*)
2213     # ld works, but does not support shared libraries.
2214     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2215     # gas doesn't generate exception information.
2216     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2217     ;;
2218   alpha*-*-*vms*)
2219     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2220     ;;
2221   alpha*-*-linux*)
2222     # newlib is not 64 bit ready
2223     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2224     ;;
2225   alpha*-*-*)
2226     # newlib is not 64 bit ready
2227     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2228     ;;
2229   am33_2.0-*-linux*)
2230     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2231     ;;
2232   sh-*-linux*)
2233     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2234     ;;
2235   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2236     noconfigdirs="$noconfigdirs ${libgcj}"
2237     noconfigdirs="$noconfigdirs target-examples"
2238     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2239     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2240     noconfigdirs="$noconfigdirs expect dejagnu"
2241     # the C++ libraries don't build on top of CE's C libraries
2242     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2243     noconfigdirs="$noconfigdirs target-newlib"
2244     case "${host}" in
2245       *-*-cygwin*) ;; # keep gdb and readline
2246       *) noconfigdirs="$noconfigdirs gdb readline"
2247          ;;
2248     esac
2249     libgloss_dir=wince
2250     ;;
2251   arc-*-*)
2252     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2253     ;;
2254   arm-semi-aof )
2255     ;;
2256   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2257     noconfigdirs="$noconfigdirs ${libgcj}"
2258     libgloss_dir=arm
2259     ;;
2260   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2261     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2262     libgloss_dir=arm
2263     ;;
2264   arm*-*-linux-gnueabi)
2265     noconfigdirs="$noconfigdirs target-qthreads"
2266     noconfigdirs="$noconfigdirs target-libobjc"
2267     case ${with_newlib} in
2268       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2269     esac
2270     libgloss_dir=arm
2271     ;;
2272   arm*-*-symbianelf*)
2273     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2274     libgloss_dir=arm
2275     ;;
2276   arm-*-pe*)
2277     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2278     ;;
2279   thumb-*-coff)
2280     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2281     ;;
2282   thumb-*-elf)
2283     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2284     ;;
2285   thumb-*-pe)
2286     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2287     ;;
2288   arm-*-riscix*)
2289     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2290     ;;
2291   avr-*-*)
2292     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2293     ;;
2294   bfin-*-*)
2295     noconfigdirs="$noconfigdirs gdb"
2296     if test x${is_cross_compiler} != xno ; then
2297       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2298     fi
2299     ;;
2300   c4x-*-* | tic4x-*-*)
2301     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2302     ;;
2303   c54x*-*-* | tic54x-*-*)
2304     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2305     ;;
2306   cris-*-* | crisv32-*-*)
2307     unsupported_languages="$unsupported_languages java"
2308     case "${target}" in
2309       *-*-aout)
2310         unsupported_languages="$unsupported_languages fortran"
2311         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2312       *-*-elf)
2313         noconfigdirs="$noconfigdirs target-boehm-gc";;
2314       *-*-linux*)
2315         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2316       *)
2317         unsupported_languages="$unsupported_languages fortran"
2318         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2319     esac
2320     libgloss_dir=cris
2321     ;;
2322   crx-*-*)
2323     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2324     ;;
2325   d10v-*-*)
2326     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2327     ;;
2328   d30v-*-*)
2329     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2330     ;;
2331   ep9312-*-elf | ep9312-*-coff)
2332     libgloss_dir=arm
2333     ;;
2334   fr30-*-elf*)
2335     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2336     ;;
2337   frv-*-*)
2338     noconfigdirs="$noconfigdirs ${libgcj}"
2339     ;;
2340   h8300*-*-*)
2341     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2342     ;;
2343   h8500-*-*)
2344     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2345     ;;
2346   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2347     ;;
2348   hppa*64*-*-linux* | parisc*64*-*-linux*)
2349     # In this case, it's because the hppa64-linux target is for
2350     # the kernel only at this point and has no libc, and thus no
2351     # headers, crt*.o, etc., all of which are needed by these.
2352     noconfigdirs="$noconfigdirs target-zlib"
2353     ;;
2354   parisc*-*-linux* | hppa*-*-linux*)
2355     ;;
2356   hppa*-*-*elf* | \
2357   hppa*-*-lites* | \
2358   hppa*-*-openbsd* | \
2359   hppa*64*-*-*)
2360     noconfigdirs="$noconfigdirs ${libgcj}"
2361     ;;
2362   hppa*-hp-hpux11*)
2363     noconfigdirs="$noconfigdirs ld shellutils"
2364     ;;
2365   hppa*-*-pro*)
2366     libgloss_dir=pa
2367     ;;
2368   hppa*-*-*)
2369     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2370     # build on HP-UX 10.20.
2371     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2372     ;;
2373   i960-*-*)
2374     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2375     ;;
2376   ia64*-*-elf*)
2377     # No gdb support yet.
2378     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2379     ;;
2380   ia64*-**-hpux*)
2381     # No gdb or ld support yet.
2382     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2383     ;;
2384   i370-*-opened*)
2385     ;;
2386   i[3456789]86-*-coff | i[3456789]86-*-elf)
2387     noconfigdirs="$noconfigdirs ${libgcj}"
2388     libgloss_dir=i386
2389     ;;
2390   i[3456789]86-*-linux*)
2391     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2392     # not build java stuff by default.
2393     case "${target}" in
2394       *-*-*libc1*)
2395         noconfigdirs="$noconfigdirs ${libgcj}";;
2396     esac
2397
2398     # This section makes it possible to build newlib natively on linux.
2399     # If we are using a cross compiler then don't configure newlib.
2400     if test x${is_cross_compiler} != xno ; then
2401       noconfigdirs="$noconfigdirs target-newlib"
2402     fi
2403     noconfigdirs="$noconfigdirs target-libgloss"
2404     # If we are not using a cross compiler, do configure newlib.
2405     # Note however, that newlib will only be configured in this situation
2406     # if the --with-newlib option has been given, because otherwise
2407     # 'target-newlib' will appear in skipdirs.
2408     ;;
2409   i[3456789]86-*-mingw32*)
2410     target_configdirs="$target_configdirs target-winsup"
2411     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2412     ;;
2413   x86_64-*-mingw*)
2414     target_configdirs="$target_configdirs target-winsup"
2415     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2416     ;;
2417   *-*-cygwin*)
2418     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2419     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2420     # always build newlib if winsup directory is present.
2421     if test -d "$srcdir/winsup/cygwin"; then
2422       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2423     elif test -d "$srcdir/newlib"; then
2424       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2425     fi
2426     ;;
2427   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2428   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2429     ;;
2430   i[3456789]86-*-pe)
2431     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2432     ;;
2433   i[3456789]86-*-sco3.2v5*)
2434     # The linker does not yet know about weak symbols in COFF,
2435     # and is not configured to handle mixed ELF and COFF.
2436     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2437     ;;
2438   i[3456789]86-*-sco*)
2439     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2440     ;;
2441   i[3456789]86-*-solaris2*)
2442     noconfigdirs="$noconfigdirs target-libgloss"
2443     ;;
2444   i[3456789]86-*-sysv4*)
2445     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2446     ;;
2447   i[3456789]86-*-beos*)
2448     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2449     ;;
2450   i[3456789]86-*-rdos*)
2451     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2452     ;;
2453   m32r-*-*)
2454     noconfigdirs="$noconfigdirs ${libgcj}"
2455     ;;
2456   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2457     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2458     libgloss_dir=m68hc11
2459     ;;
2460   m68k-*-elf*)
2461     noconfigdirs="$noconfigdirs ${libgcj}"
2462     ;;
2463   m68k-*-coff*)
2464     noconfigdirs="$noconfigdirs ${libgcj}"
2465     ;;
2466   m68*-*-* | fido-*-*)
2467     libgloss_dir=m68k
2468     ;;
2469   mcore-*-pe*)
2470   # The EPOC C++ environment does not support exceptions or rtti,
2471   # and so building libstdc++-v3 tends not to always work.
2472     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2473     ;;
2474   mmix-*-*)
2475     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2476     unsupported_languages="$unsupported_languages fortran java"
2477     ;;
2478   mn10200-*-*)
2479     noconfigdirs="$noconfigdirs ${libgcj}"
2480     ;;
2481   mn10300-*-*)
2482     noconfigdirs="$noconfigdirs ${libgcj}"
2483     ;;
2484   mt-*-*)
2485     noconfigdirs="$noconfigdirs sim"
2486     ;;
2487   powerpc-*-aix*)
2488     # copied from rs6000-*-* entry
2489     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2490     ;;
2491   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2492     target_configdirs="$target_configdirs target-winsup"
2493     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2494     # always build newlib.
2495     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2496     ;;
2497     # This is temporary until we can link against shared libraries
2498   powerpcle-*-solaris*)
2499     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2500     libgloss_dir=rs6000
2501     ;;
2502   powerpc-*-beos*)
2503     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2504     ;;
2505   powerpc-*-eabi)
2506     noconfigdirs="$noconfigdirs ${libgcj}"
2507     libgloss_dir=rs6000
2508     ;;
2509   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2510     libgloss_dir=rs6000
2511     ;;
2512   rs6000-*-lynxos*)
2513     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2514     ;;
2515   rs6000-*-aix*)
2516     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2517     ;;
2518   rs6000-*-*)
2519     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2520     ;;
2521   m68k-apollo-*)
2522     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2523     ;;
2524   mips*-sde-elf*)
2525     skipdirs="$skipdirs target-libiberty"
2526     noconfigdirs="$noconfigdirs ${libgcj}"
2527     if test x$with_newlib = xyes; then
2528       noconfigdirs="$noconfigdirs gprof"
2529     fi
2530     libgloss_dir=mips
2531     ;;
2532   mips*-*-irix5*)
2533     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2534     ;;
2535   mips*-*-irix6*)
2536     # Linking libjava exceeds command-line length limits on at least
2537     # IRIX 6.2, but not on IRIX 6.5.
2538     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2539     # <oldham@codesourcery.com>
2540     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2541     ;;
2542   mips*-*-bsd*)
2543     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2544     ;;
2545   mips*-*-linux*)
2546     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2547     ;;
2548   mips*-*-*)
2549     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2550     libgloss_dir=mips
2551     ;;
2552   romp-*-*)
2553     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2554     ;;
2555   sh-*-* | sh64-*-*)
2556     case "${host}" in
2557       i[3456789]86-*-vsta) ;; # don't add gprof back in
2558       i[3456789]86-*-go32*) ;; # don't add gprof back in
2559       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2560       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2561     esac
2562     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2563     ;;
2564   sparclet-*-aout* | sparc86x-*-*)
2565     libgloss_dir=sparc
2566     ;;
2567   sparc-*-elf*)
2568     noconfigdirs="$noconfigdirs ${libgcj}"
2569     ;;
2570   sparc64-*-elf*)
2571     noconfigdirs="$noconfigdirs ${libgcj}"
2572     libgloss_dir=sparc
2573     ;;
2574   sparclite-*-*)
2575     noconfigdirs="$noconfigdirs ${libgcj}"
2576     libgloss_dir=sparc
2577     ;;
2578   sparc-*-sunos4*)
2579     noconfigdirs="$noconfigdirs ${libgcj}"
2580     if test x${is_cross_compiler} != xno ; then
2581            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2582     else
2583            use_gnu_ld=no
2584     fi
2585     ;;
2586   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2587     noconfigdirs="$noconfigdirs ${libgcj}"
2588     ;;
2589   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2590     ;;
2591   spu-*-*)
2592     skipdirs="target-libssp"
2593     ;;
2594   v810-*-*)
2595     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2596     ;;
2597   v850-*-*)
2598     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2599     ;;
2600   v850e-*-*)
2601     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2602     ;;
2603   v850ea-*-*)
2604     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2605     ;;
2606   vax-*-vms)
2607     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2608     ;;
2609   vax-*-*)
2610     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2611     ;;
2612   xtensa*-*-*)
2613     noconfigdirs="$noconfigdirs ${libgcj}"
2614     ;;
2615   ip2k-*-*)
2616     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2617     ;;
2618   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2619     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2620     ;;
2621   *-*-lynxos*)
2622     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2623     ;;
2624   *-*-*)
2625     noconfigdirs="$noconfigdirs ${libgcj}"
2626     ;;
2627 esac
2628
2629 # If we aren't building newlib, then don't build libgloss, since libgloss
2630 # depends upon some newlib header files.
2631 case "${noconfigdirs}" in
2632   *target-libgloss*) ;;
2633   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2634 esac
2635
2636 # Work in distributions that contain no compiler tools, like Autoconf.
2637 tentative_cc=""
2638 host_makefile_frag=/dev/null
2639 if test -d ${srcdir}/config ; then
2640 case "${host}" in
2641   m68k-hp-hpux*)
2642     # Avoid "too much defining" errors from HPUX compiler.
2643     tentative_cc="cc -Wp,-H256000"
2644     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2645     # If it's HP/UX ar, this should be harmless.
2646     RANLIB="ar ts"
2647     ;;
2648   m68k-apollo-sysv*)
2649     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2650     ;;
2651   m68k-apollo-bsd*)
2652     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2653     # chokes on bfd, the compiler won't let you assign integers to enums, and
2654     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2655     # the apollo compiler" (the preferred version of GCC could be called cc,
2656     # or whatever), but I'm not sure leaving CC as cc is any better...
2657     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2658     # Used to have BISON=yacc.
2659     tentative_cc=gcc
2660     ;;
2661   m88k-dg-dgux*)
2662     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2663     ;;
2664   m88k-harris-cxux*)
2665     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2666     tentative_cc="cc -Xa"
2667     host_makefile_frag="config/mh-cxux"
2668     ;;
2669   m88k-motorola-sysv*)
2670     ;;
2671   mips*-dec-ultrix*)
2672     tentative_cc="cc -Wf,-XNg1000"
2673     host_makefile_frag="config/mh-decstation"
2674     ;;
2675   mips*-nec-sysv4*)
2676     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2677     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2678     host_makefile_frag="config/mh-necv4"
2679     ;;
2680   mips*-sgi-irix4*)
2681     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2682     # environment.  Also bump switch table size so that cp-parse will
2683     # compile.  Bump string length limit so linker builds.
2684     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2685     ;;
2686   mips*-*-sysv4*)
2687     host_makefile_frag="config/mh-sysv4"
2688     ;;
2689   mips*-*-sysv*)
2690     # This is for a MIPS running RISC/os 4.52C.
2691
2692     # This is needed for GDB, but needs to be in the top-level make because
2693     # if a library is compiled with the bsd headers and gets linked with the
2694     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2695     # a different size).
2696     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2697     # known except to select the sysv environment.  Could we use /proc instead?
2698     # These "sysv environments" and "bsd environments" often end up being a pain.
2699     #
2700     # This is not part of CFLAGS because perhaps not all C compilers have this
2701     # option.
2702     tentative_cc="cc -systype sysv"
2703     ;;
2704   i370-ibm-opened*)
2705     tentative_cc="c89"
2706     ;;
2707   i[3456789]86-*-sysv5*)
2708     host_makefile_frag="config/mh-sysv5"
2709     ;;
2710   i[3456789]86-*-dgux*)
2711     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2712     host_makefile_frag="config/mh-dgux386"
2713     ;;
2714   i[3456789]86-ncr-sysv4.3*)
2715     # The MetaWare compiler will generate a copyright message unless you
2716     # turn it off by adding the -Hnocopyr flag.
2717     tentative_cc="cc -Hnocopyr"
2718     ;;
2719   i[3456789]86-ncr-sysv4*)
2720     # for an NCR 3000 (i486/SVR4) system.
2721     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2722     # This compiler not only emits obnoxious copyright messages every time
2723     # you run it, but it chokes and dies on a whole bunch of GNU source
2724     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2725     tentative_cc="/usr/ccs/ATT/cc"
2726     host_makefile_frag="config/mh-ncr3000"
2727     ;;
2728   i[3456789]86-*-sco3.2v5*)
2729     ;;
2730   i[3456789]86-*-sco*)
2731     # The native C compiler botches some simple uses of const.  Unfortunately,
2732     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2733     tentative_cc="cc -Dconst="
2734     host_makefile_frag="config/mh-sco"
2735     ;;
2736   i[3456789]86-*-udk*)
2737     host_makefile_frag="config/mh-sysv5"
2738     ;;
2739   i[3456789]86-*-solaris2*)
2740     host_makefile_frag="config/mh-sysv4"
2741     ;;
2742   i[3456789]86-*-msdosdjgpp*)
2743     host_makefile_frag="config/mh-djgpp"
2744     ;;
2745   *-cygwin*)
2746     host_makefile_frag="config/mh-cygwin"
2747     ;;
2748   *-mingw32*)
2749     host_makefile_frag="config/mh-mingw"
2750     ;;
2751   *-mingw64*)
2752     host_makefile_frag="config/mh-mingw"
2753     ;;
2754   *-interix*)
2755     host_makefile_frag="config/mh-interix"
2756     ;;
2757   vax-*-ultrix2*)
2758     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2759     tentative_cc=gcc
2760     ;;
2761   *-*-solaris2*)
2762     host_makefile_frag="config/mh-solaris"
2763     ;;
2764   m68k-sun-sunos*)
2765     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2766     # without overflowing the jump tables (-J says to use a 32 bit table)
2767     tentative_cc="cc -J"
2768     ;;
2769   *-hp-hpux*)
2770     tentative_cc="cc -Wp,-H256000"
2771     ;;
2772   *-*-hiux*)
2773     tentative_cc="cc -Wp,-H256000"
2774     ;;
2775   rs6000-*-lynxos*)
2776     # /bin/cc is less than useful for our purposes.  Always use GCC
2777     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2778     host_makefile_frag="config/mh-lynxrs6k"
2779     ;;
2780   powerpc-*-darwin*)
2781     host_makefile_frag="config/mh-ppc-darwin"
2782     ;;
2783   powerpc-*-aix*)
2784     host_makefile_frag="config/mh-ppc-aix"
2785     ;;
2786   rs6000-*-aix*)
2787     host_makefile_frag="config/mh-ppc-aix"
2788     ;;
2789   *-*-lynxos*)
2790     # /bin/cc is less than useful for our purposes.  Always use GCC
2791     tentative_cc="/bin/gcc"
2792     ;;
2793   *-*-sysv4*)
2794     host_makefile_frag="config/mh-sysv4"
2795     ;;
2796   # This is placed last to prevent interfering with the cases above.
2797   i[3456789]86-*-*)
2798     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2799     host_makefile_frag="config/mh-x86omitfp"
2800     ;;
2801 esac
2802 fi
2803
2804 # If we aren't going to be using gcc, see if we can extract a definition
2805 # of CC from the fragment.
2806 # Actually, use the 'pre-extracted' version above.
2807 if test -z "${CC}" && test "${build}" = "${host}" ; then
2808   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2809   found=
2810   for dir in $PATH; do
2811     test -z "$dir" && dir=.
2812     if test -f $dir/gcc; then
2813       found=yes
2814       break
2815     fi
2816   done
2817   IFS="$save_ifs"
2818   if test -z "${found}" && test -n "${tentative_cc}" ; then
2819     CC=$tentative_cc
2820   fi
2821 fi
2822
2823 if test "${build}" != "${host}" ; then
2824   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2825   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2826   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2827   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2828   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2829   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2830   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2831   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2832   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2833   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2834   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2835   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2836 else
2837   AR_FOR_BUILD="\$(AR)"
2838   AS_FOR_BUILD="\$(AS)"
2839   CC_FOR_BUILD="\$(CC)"
2840   CXX_FOR_BUILD="\$(CXX)"
2841   GCJ_FOR_BUILD="\$(GCJ)"
2842   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2843   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2844   LD_FOR_BUILD="\$(LD)"
2845   NM_FOR_BUILD="\$(NM)"
2846   RANLIB_FOR_BUILD="\$(RANLIB)"
2847   WINDRES_FOR_BUILD="\$(WINDRES)"
2848   WINDMC_FOR_BUILD="\$(WINDMC)"
2849 fi
2850
2851 ac_ext=c
2852 ac_cpp='$CPP $CPPFLAGS'
2853 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2854 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2855 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2856 if test -n "$ac_tool_prefix"; then
2857   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2858 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2859 echo "$as_me:$LINENO: checking for $ac_word" >&5
2860 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2861 if test "${ac_cv_prog_CC+set}" = set; then
2862   echo $ECHO_N "(cached) $ECHO_C" >&6
2863 else
2864   if test -n "$CC"; then
2865   ac_cv_prog_CC="$CC" # Let the user override the test.
2866 else
2867 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2868 for as_dir in $PATH
2869 do
2870   IFS=$as_save_IFS
2871   test -z "$as_dir" && as_dir=.
2872   for ac_exec_ext in '' $ac_executable_extensions; do
2873   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2874     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2875     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2876     break 2
2877   fi
2878 done
2879 done
2880
2881 fi
2882 fi
2883 CC=$ac_cv_prog_CC
2884 if test -n "$CC"; then
2885   echo "$as_me:$LINENO: result: $CC" >&5
2886 echo "${ECHO_T}$CC" >&6
2887 else
2888   echo "$as_me:$LINENO: result: no" >&5
2889 echo "${ECHO_T}no" >&6
2890 fi
2891
2892 fi
2893 if test -z "$ac_cv_prog_CC"; then
2894   ac_ct_CC=$CC
2895   # Extract the first word of "gcc", so it can be a program name with args.
2896 set dummy gcc; ac_word=$2
2897 echo "$as_me:$LINENO: checking for $ac_word" >&5
2898 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2899 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2900   echo $ECHO_N "(cached) $ECHO_C" >&6
2901 else
2902   if test -n "$ac_ct_CC"; then
2903   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2904 else
2905 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2906 for as_dir in $PATH
2907 do
2908   IFS=$as_save_IFS
2909   test -z "$as_dir" && as_dir=.
2910   for ac_exec_ext in '' $ac_executable_extensions; do
2911   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2912     ac_cv_prog_ac_ct_CC="gcc"
2913     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2914     break 2
2915   fi
2916 done
2917 done
2918
2919 fi
2920 fi
2921 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2922 if test -n "$ac_ct_CC"; then
2923   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2924 echo "${ECHO_T}$ac_ct_CC" >&6
2925 else
2926   echo "$as_me:$LINENO: result: no" >&5
2927 echo "${ECHO_T}no" >&6
2928 fi
2929
2930   CC=$ac_ct_CC
2931 else
2932   CC="$ac_cv_prog_CC"
2933 fi
2934
2935 if test -z "$CC"; then
2936   if test -n "$ac_tool_prefix"; then
2937   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2938 set dummy ${ac_tool_prefix}cc; ac_word=$2
2939 echo "$as_me:$LINENO: checking for $ac_word" >&5
2940 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2941 if test "${ac_cv_prog_CC+set}" = set; then
2942   echo $ECHO_N "(cached) $ECHO_C" >&6
2943 else
2944   if test -n "$CC"; then
2945   ac_cv_prog_CC="$CC" # Let the user override the test.
2946 else
2947 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2948 for as_dir in $PATH
2949 do
2950   IFS=$as_save_IFS
2951   test -z "$as_dir" && as_dir=.
2952   for ac_exec_ext in '' $ac_executable_extensions; do
2953   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2954     ac_cv_prog_CC="${ac_tool_prefix}cc"
2955     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2956     break 2
2957   fi
2958 done
2959 done
2960
2961 fi
2962 fi
2963 CC=$ac_cv_prog_CC
2964 if test -n "$CC"; then
2965   echo "$as_me:$LINENO: result: $CC" >&5
2966 echo "${ECHO_T}$CC" >&6
2967 else
2968   echo "$as_me:$LINENO: result: no" >&5
2969 echo "${ECHO_T}no" >&6
2970 fi
2971
2972 fi
2973 if test -z "$ac_cv_prog_CC"; then
2974   ac_ct_CC=$CC
2975   # Extract the first word of "cc", so it can be a program name with args.
2976 set dummy cc; ac_word=$2
2977 echo "$as_me:$LINENO: checking for $ac_word" >&5
2978 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2979 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2980   echo $ECHO_N "(cached) $ECHO_C" >&6
2981 else
2982   if test -n "$ac_ct_CC"; then
2983   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2984 else
2985 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2986 for as_dir in $PATH
2987 do
2988   IFS=$as_save_IFS
2989   test -z "$as_dir" && as_dir=.
2990   for ac_exec_ext in '' $ac_executable_extensions; do
2991   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2992     ac_cv_prog_ac_ct_CC="cc"
2993     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2994     break 2
2995   fi
2996 done
2997 done
2998
2999 fi
3000 fi
3001 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3002 if test -n "$ac_ct_CC"; then
3003   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3004 echo "${ECHO_T}$ac_ct_CC" >&6
3005 else
3006   echo "$as_me:$LINENO: result: no" >&5
3007 echo "${ECHO_T}no" >&6
3008 fi
3009
3010   CC=$ac_ct_CC
3011 else
3012   CC="$ac_cv_prog_CC"
3013 fi
3014
3015 fi
3016 if test -z "$CC"; then
3017   # Extract the first word of "cc", so it can be a program name with args.
3018 set dummy cc; ac_word=$2
3019 echo "$as_me:$LINENO: checking for $ac_word" >&5
3020 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3021 if test "${ac_cv_prog_CC+set}" = set; then
3022   echo $ECHO_N "(cached) $ECHO_C" >&6
3023 else
3024   if test -n "$CC"; then
3025   ac_cv_prog_CC="$CC" # Let the user override the test.
3026 else
3027   ac_prog_rejected=no
3028 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3029 for as_dir in $PATH
3030 do
3031   IFS=$as_save_IFS
3032   test -z "$as_dir" && as_dir=.
3033   for ac_exec_ext in '' $ac_executable_extensions; do
3034   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3035     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3036        ac_prog_rejected=yes
3037        continue
3038      fi
3039     ac_cv_prog_CC="cc"
3040     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3041     break 2
3042   fi
3043 done
3044 done
3045
3046 if test $ac_prog_rejected = yes; then
3047   # We found a bogon in the path, so make sure we never use it.
3048   set dummy $ac_cv_prog_CC
3049   shift
3050   if test $# != 0; then
3051     # We chose a different compiler from the bogus one.
3052     # However, it has the same basename, so the bogon will be chosen
3053     # first if we set CC to just the basename; use the full file name.
3054     shift
3055     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3056   fi
3057 fi
3058 fi
3059 fi
3060 CC=$ac_cv_prog_CC
3061 if test -n "$CC"; then
3062   echo "$as_me:$LINENO: result: $CC" >&5
3063 echo "${ECHO_T}$CC" >&6
3064 else
3065   echo "$as_me:$LINENO: result: no" >&5
3066 echo "${ECHO_T}no" >&6
3067 fi
3068
3069 fi
3070 if test -z "$CC"; then
3071   if test -n "$ac_tool_prefix"; then
3072   for ac_prog in cl
3073   do
3074     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3075 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3076 echo "$as_me:$LINENO: checking for $ac_word" >&5
3077 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3078 if test "${ac_cv_prog_CC+set}" = set; then
3079   echo $ECHO_N "(cached) $ECHO_C" >&6
3080 else
3081   if test -n "$CC"; then
3082   ac_cv_prog_CC="$CC" # Let the user override the test.
3083 else
3084 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3085 for as_dir in $PATH
3086 do
3087   IFS=$as_save_IFS
3088   test -z "$as_dir" && as_dir=.
3089   for ac_exec_ext in '' $ac_executable_extensions; do
3090   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3091     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3092     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3093     break 2
3094   fi
3095 done
3096 done
3097
3098 fi
3099 fi
3100 CC=$ac_cv_prog_CC
3101 if test -n "$CC"; then
3102   echo "$as_me:$LINENO: result: $CC" >&5
3103 echo "${ECHO_T}$CC" >&6
3104 else
3105   echo "$as_me:$LINENO: result: no" >&5
3106 echo "${ECHO_T}no" >&6
3107 fi
3108
3109     test -n "$CC" && break
3110   done
3111 fi
3112 if test -z "$CC"; then
3113   ac_ct_CC=$CC
3114   for ac_prog in cl
3115 do
3116   # Extract the first word of "$ac_prog", so it can be a program name with args.
3117 set dummy $ac_prog; ac_word=$2
3118 echo "$as_me:$LINENO: checking for $ac_word" >&5
3119 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3120 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3121   echo $ECHO_N "(cached) $ECHO_C" >&6
3122 else
3123   if test -n "$ac_ct_CC"; then
3124   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3125 else
3126 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3127 for as_dir in $PATH
3128 do
3129   IFS=$as_save_IFS
3130   test -z "$as_dir" && as_dir=.
3131   for ac_exec_ext in '' $ac_executable_extensions; do
3132   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3133     ac_cv_prog_ac_ct_CC="$ac_prog"
3134     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3135     break 2
3136   fi
3137 done
3138 done
3139
3140 fi
3141 fi
3142 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3143 if test -n "$ac_ct_CC"; then
3144   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3145 echo "${ECHO_T}$ac_ct_CC" >&6
3146 else
3147   echo "$as_me:$LINENO: result: no" >&5
3148 echo "${ECHO_T}no" >&6
3149 fi
3150
3151   test -n "$ac_ct_CC" && break
3152 done
3153
3154   CC=$ac_ct_CC
3155 fi
3156
3157 fi
3158
3159
3160 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3161 See \`config.log' for more details." >&5
3162 echo "$as_me: error: no acceptable C compiler found in \$PATH
3163 See \`config.log' for more details." >&2;}
3164    { (exit 1); exit 1; }; }
3165
3166 # Provide some information about the compiler.
3167 echo "$as_me:$LINENO:" \
3168      "checking for C compiler version" >&5
3169 ac_compiler=`set X $ac_compile; echo $2`
3170 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3171   (eval $ac_compiler --version </dev/null >&5) 2>&5
3172   ac_status=$?
3173   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3174   (exit $ac_status); }
3175 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3176   (eval $ac_compiler -v </dev/null >&5) 2>&5
3177   ac_status=$?
3178   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3179   (exit $ac_status); }
3180 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3181   (eval $ac_compiler -V </dev/null >&5) 2>&5
3182   ac_status=$?
3183   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3184   (exit $ac_status); }
3185
3186 cat >conftest.$ac_ext <<_ACEOF
3187 /* confdefs.h.  */
3188 _ACEOF
3189 cat confdefs.h >>conftest.$ac_ext
3190 cat >>conftest.$ac_ext <<_ACEOF
3191 /* end confdefs.h.  */
3192
3193 int
3194 main ()
3195 {
3196
3197   ;
3198   return 0;
3199 }
3200 _ACEOF
3201 ac_clean_files_save=$ac_clean_files
3202 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3203 # Try to create an executable without -o first, disregard a.out.
3204 # It will help us diagnose broken compilers, and finding out an intuition
3205 # of exeext.
3206 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3207 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3208 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3209 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3210   (eval $ac_link_default) 2>&5
3211   ac_status=$?
3212   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3213   (exit $ac_status); }; then
3214   # Find the output, starting from the most likely.  This scheme is
3215 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3216 # resort.
3217
3218 # Be careful to initialize this variable, since it used to be cached.
3219 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3220 ac_cv_exeext=
3221 # b.out is created by i960 compilers.
3222 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3223 do
3224   test -f "$ac_file" || continue
3225   case $ac_file in
3226     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3227         ;;
3228     conftest.$ac_ext )
3229         # This is the source file.
3230         ;;
3231     [ab].out )
3232         # We found the default executable, but exeext='' is most
3233         # certainly right.
3234         break;;
3235     *.* )
3236         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3237         # FIXME: I believe we export ac_cv_exeext for Libtool,
3238         # but it would be cool to find out if it's true.  Does anybody
3239         # maintain Libtool? --akim.
3240         export ac_cv_exeext
3241         break;;
3242     * )
3243         break;;
3244   esac
3245 done
3246 else
3247   echo "$as_me: failed program was:" >&5
3248 sed 's/^/| /' conftest.$ac_ext >&5
3249
3250 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3251 See \`config.log' for more details." >&5
3252 echo "$as_me: error: C compiler cannot create executables
3253 See \`config.log' for more details." >&2;}
3254    { (exit 77); exit 77; }; }
3255 fi
3256
3257 ac_exeext=$ac_cv_exeext
3258 echo "$as_me:$LINENO: result: $ac_file" >&5
3259 echo "${ECHO_T}$ac_file" >&6
3260
3261 # Check the compiler produces executables we can run.  If not, either
3262 # the compiler is broken, or we cross compile.
3263 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3264 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3265 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3266 # If not cross compiling, check that we can run a simple program.
3267 if test "$cross_compiling" != yes; then
3268   if { ac_try='./$ac_file'
3269   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3270   (eval $ac_try) 2>&5
3271   ac_status=$?
3272   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3273   (exit $ac_status); }; }; then
3274     cross_compiling=no
3275   else
3276     if test "$cross_compiling" = maybe; then
3277         cross_compiling=yes
3278     else
3279         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3280 If you meant to cross compile, use \`--host'.
3281 See \`config.log' for more details." >&5
3282 echo "$as_me: error: cannot run C compiled programs.
3283 If you meant to cross compile, use \`--host'.
3284 See \`config.log' for more details." >&2;}
3285    { (exit 1); exit 1; }; }
3286     fi
3287   fi
3288 fi
3289 echo "$as_me:$LINENO: result: yes" >&5
3290 echo "${ECHO_T}yes" >&6
3291
3292 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3293 ac_clean_files=$ac_clean_files_save
3294 # Check the compiler produces executables we can run.  If not, either
3295 # the compiler is broken, or we cross compile.
3296 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3297 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3298 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3299 echo "${ECHO_T}$cross_compiling" >&6
3300
3301 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3302 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3303 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3304   (eval $ac_link) 2>&5
3305   ac_status=$?
3306   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3307   (exit $ac_status); }; then
3308   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3309 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3310 # work properly (i.e., refer to `conftest.exe'), while it won't with
3311 # `rm'.
3312 for ac_file in conftest.exe conftest conftest.*; do
3313   test -f "$ac_file" || continue
3314   case $ac_file in
3315     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3316     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3317           export ac_cv_exeext
3318           break;;
3319     * ) break;;
3320   esac
3321 done
3322 else
3323   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3324 See \`config.log' for more details." >&5
3325 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3326 See \`config.log' for more details." >&2;}
3327    { (exit 1); exit 1; }; }
3328 fi
3329
3330 rm -f conftest$ac_cv_exeext
3331 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3332 echo "${ECHO_T}$ac_cv_exeext" >&6
3333
3334 rm -f conftest.$ac_ext
3335 EXEEXT=$ac_cv_exeext
3336 ac_exeext=$EXEEXT
3337 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3338 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3339 if test "${ac_cv_objext+set}" = set; then
3340   echo $ECHO_N "(cached) $ECHO_C" >&6
3341 else
3342   cat >conftest.$ac_ext <<_ACEOF
3343 /* confdefs.h.  */
3344 _ACEOF
3345 cat confdefs.h >>conftest.$ac_ext
3346 cat >>conftest.$ac_ext <<_ACEOF
3347 /* end confdefs.h.  */
3348
3349 int
3350 main ()
3351 {
3352
3353   ;
3354   return 0;
3355 }
3356 _ACEOF
3357 rm -f conftest.o conftest.obj
3358 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3359   (eval $ac_compile) 2>&5
3360   ac_status=$?
3361   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3362   (exit $ac_status); }; then
3363   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3364   case $ac_file in
3365     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3366     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3367        break;;
3368   esac
3369 done
3370 else
3371   echo "$as_me: failed program was:" >&5
3372 sed 's/^/| /' conftest.$ac_ext >&5
3373
3374 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3375 See \`config.log' for more details." >&5
3376 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3377 See \`config.log' for more details." >&2;}
3378    { (exit 1); exit 1; }; }
3379 fi
3380
3381 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3382 fi
3383 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3384 echo "${ECHO_T}$ac_cv_objext" >&6
3385 OBJEXT=$ac_cv_objext
3386 ac_objext=$OBJEXT
3387 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3388 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3389 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3390   echo $ECHO_N "(cached) $ECHO_C" >&6
3391 else
3392   cat >conftest.$ac_ext <<_ACEOF
3393 /* confdefs.h.  */
3394 _ACEOF
3395 cat confdefs.h >>conftest.$ac_ext
3396 cat >>conftest.$ac_ext <<_ACEOF
3397 /* end confdefs.h.  */
3398
3399 int
3400 main ()
3401 {
3402 #ifndef __GNUC__
3403        choke me
3404 #endif
3405
3406   ;
3407   return 0;
3408 }
3409 _ACEOF
3410 rm -f conftest.$ac_objext
3411 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3412   (eval $ac_compile) 2>conftest.er1
3413   ac_status=$?
3414   grep -v '^ *+' conftest.er1 >conftest.err
3415   rm -f conftest.er1
3416   cat conftest.err >&5
3417   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3418   (exit $ac_status); } &&
3419          { ac_try='test -z "$ac_c_werror_flag"
3420                          || test ! -s conftest.err'
3421   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3422   (eval $ac_try) 2>&5
3423   ac_status=$?
3424   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3425   (exit $ac_status); }; } &&
3426          { ac_try='test -s conftest.$ac_objext'
3427   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3428   (eval $ac_try) 2>&5
3429   ac_status=$?
3430   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3431   (exit $ac_status); }; }; then
3432   ac_compiler_gnu=yes
3433 else
3434   echo "$as_me: failed program was:" >&5
3435 sed 's/^/| /' conftest.$ac_ext >&5
3436
3437 ac_compiler_gnu=no
3438 fi
3439 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3440 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3441
3442 fi
3443 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3444 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3445 GCC=`test $ac_compiler_gnu = yes && echo yes`
3446 ac_test_CFLAGS=${CFLAGS+set}
3447 ac_save_CFLAGS=$CFLAGS
3448 CFLAGS="-g"
3449 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3450 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3451 if test "${ac_cv_prog_cc_g+set}" = set; then
3452   echo $ECHO_N "(cached) $ECHO_C" >&6
3453 else
3454   cat >conftest.$ac_ext <<_ACEOF
3455 /* confdefs.h.  */
3456 _ACEOF
3457 cat confdefs.h >>conftest.$ac_ext
3458 cat >>conftest.$ac_ext <<_ACEOF
3459 /* end confdefs.h.  */
3460
3461 int
3462 main ()
3463 {
3464
3465   ;
3466   return 0;
3467 }
3468 _ACEOF
3469 rm -f conftest.$ac_objext
3470 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3471   (eval $ac_compile) 2>conftest.er1
3472   ac_status=$?
3473   grep -v '^ *+' conftest.er1 >conftest.err
3474   rm -f conftest.er1
3475   cat conftest.err >&5
3476   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3477   (exit $ac_status); } &&
3478          { ac_try='test -z "$ac_c_werror_flag"
3479                          || test ! -s conftest.err'
3480   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3481   (eval $ac_try) 2>&5
3482   ac_status=$?
3483   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3484   (exit $ac_status); }; } &&
3485          { ac_try='test -s conftest.$ac_objext'
3486   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3487   (eval $ac_try) 2>&5
3488   ac_status=$?
3489   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3490   (exit $ac_status); }; }; then
3491   ac_cv_prog_cc_g=yes
3492 else
3493   echo "$as_me: failed program was:" >&5
3494 sed 's/^/| /' conftest.$ac_ext >&5
3495
3496 ac_cv_prog_cc_g=no
3497 fi
3498 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3499 fi
3500 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3501 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3502 if test "$ac_test_CFLAGS" = set; then
3503   CFLAGS=$ac_save_CFLAGS
3504 elif test $ac_cv_prog_cc_g = yes; then
3505   if test "$GCC" = yes; then
3506     CFLAGS="-g -O2"
3507   else
3508     CFLAGS="-g"
3509   fi
3510 else
3511   if test "$GCC" = yes; then
3512     CFLAGS="-O2"
3513   else
3514     CFLAGS=
3515   fi
3516 fi
3517 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3518 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3519 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3520   echo $ECHO_N "(cached) $ECHO_C" >&6
3521 else
3522   ac_cv_prog_cc_stdc=no
3523 ac_save_CC=$CC
3524 cat >conftest.$ac_ext <<_ACEOF
3525 /* confdefs.h.  */
3526 _ACEOF
3527 cat confdefs.h >>conftest.$ac_ext
3528 cat >>conftest.$ac_ext <<_ACEOF
3529 /* end confdefs.h.  */
3530 #include <stdarg.h>
3531 #include <stdio.h>
3532 #include <sys/types.h>
3533 #include <sys/stat.h>
3534 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3535 struct buf { int x; };
3536 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3537 static char *e (p, i)
3538      char **p;
3539      int i;
3540 {
3541   return p[i];
3542 }
3543 static char *f (char * (*g) (char **, int), char **p, ...)
3544 {
3545   char *s;
3546   va_list v;
3547   va_start (v,p);
3548   s = g (p, va_arg (v,int));
3549   va_end (v);
3550   return s;
3551 }
3552
3553 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3554    function prototypes and stuff, but not '\xHH' hex character constants.
3555    These don't provoke an error unfortunately, instead are silently treated
3556    as 'x'.  The following induces an error, until -std1 is added to get
3557    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3558    array size at least.  It's necessary to write '\x00'==0 to get something
3559    that's true only with -std1.  */
3560 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3561
3562 int test (int i, double x);
3563 struct s1 {int (*f) (int a);};
3564 struct s2 {int (*f) (double a);};
3565 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3566 int argc;
3567 char **argv;
3568 int
3569 main ()
3570 {
3571 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3572   ;
3573   return 0;
3574 }
3575 _ACEOF
3576 # Don't try gcc -ansi; that turns off useful extensions and
3577 # breaks some systems' header files.
3578 # AIX                   -qlanglvl=ansi
3579 # Ultrix and OSF/1      -std1
3580 # HP-UX 10.20 and later -Ae
3581 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3582 # SVR4                  -Xc -D__EXTENSIONS__
3583 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3584 do
3585   CC="$ac_save_CC $ac_arg"
3586   rm -f conftest.$ac_objext
3587 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3588   (eval $ac_compile) 2>conftest.er1
3589   ac_status=$?
3590   grep -v '^ *+' conftest.er1 >conftest.err
3591   rm -f conftest.er1
3592   cat conftest.err >&5
3593   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3594   (exit $ac_status); } &&
3595          { ac_try='test -z "$ac_c_werror_flag"
3596                          || test ! -s conftest.err'
3597   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3598   (eval $ac_try) 2>&5
3599   ac_status=$?
3600   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3601   (exit $ac_status); }; } &&
3602          { ac_try='test -s conftest.$ac_objext'
3603   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3604   (eval $ac_try) 2>&5
3605   ac_status=$?
3606   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3607   (exit $ac_status); }; }; then
3608   ac_cv_prog_cc_stdc=$ac_arg
3609 break
3610 else
3611   echo "$as_me: failed program was:" >&5
3612 sed 's/^/| /' conftest.$ac_ext >&5
3613
3614 fi
3615 rm -f conftest.err conftest.$ac_objext
3616 done
3617 rm -f conftest.$ac_ext conftest.$ac_objext
3618 CC=$ac_save_CC
3619
3620 fi
3621
3622 case "x$ac_cv_prog_cc_stdc" in
3623   x|xno)
3624     echo "$as_me:$LINENO: result: none needed" >&5
3625 echo "${ECHO_T}none needed" >&6 ;;
3626   *)
3627     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3628 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3629     CC="$CC $ac_cv_prog_cc_stdc" ;;
3630 esac
3631
3632 # Some people use a C++ compiler to compile C.  Since we use `exit',
3633 # in C++ we need to declare it.  In case someone uses the same compiler
3634 # for both compiling C and C++ we need to have the C++ compiler decide
3635 # the declaration of exit, since it's the most demanding environment.
3636 cat >conftest.$ac_ext <<_ACEOF
3637 #ifndef __cplusplus
3638   choke me
3639 #endif
3640 _ACEOF
3641 rm -f conftest.$ac_objext
3642 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3643   (eval $ac_compile) 2>conftest.er1
3644   ac_status=$?
3645   grep -v '^ *+' conftest.er1 >conftest.err
3646   rm -f conftest.er1
3647   cat conftest.err >&5
3648   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3649   (exit $ac_status); } &&
3650          { ac_try='test -z "$ac_c_werror_flag"
3651                          || test ! -s conftest.err'
3652   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3653   (eval $ac_try) 2>&5
3654   ac_status=$?
3655   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3656   (exit $ac_status); }; } &&
3657          { ac_try='test -s conftest.$ac_objext'
3658   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3659   (eval $ac_try) 2>&5
3660   ac_status=$?
3661   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3662   (exit $ac_status); }; }; then
3663   for ac_declaration in \
3664    '' \
3665    'extern "C" void std::exit (int) throw (); using std::exit;' \
3666    'extern "C" void std::exit (int); using std::exit;' \
3667    'extern "C" void exit (int) throw ();' \
3668    'extern "C" void exit (int);' \
3669    'void exit (int);'
3670 do
3671   cat >conftest.$ac_ext <<_ACEOF
3672 /* confdefs.h.  */
3673 _ACEOF
3674 cat confdefs.h >>conftest.$ac_ext
3675 cat >>conftest.$ac_ext <<_ACEOF
3676 /* end confdefs.h.  */
3677 $ac_declaration
3678 #include <stdlib.h>
3679 int
3680 main ()
3681 {
3682 exit (42);
3683   ;
3684   return 0;
3685 }
3686 _ACEOF
3687 rm -f conftest.$ac_objext
3688 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3689   (eval $ac_compile) 2>conftest.er1
3690   ac_status=$?
3691   grep -v '^ *+' conftest.er1 >conftest.err
3692   rm -f conftest.er1
3693   cat conftest.err >&5
3694   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3695   (exit $ac_status); } &&
3696          { ac_try='test -z "$ac_c_werror_flag"
3697                          || test ! -s conftest.err'
3698   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3699   (eval $ac_try) 2>&5
3700   ac_status=$?
3701   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3702   (exit $ac_status); }; } &&
3703          { ac_try='test -s conftest.$ac_objext'
3704   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3705   (eval $ac_try) 2>&5
3706   ac_status=$?
3707   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3708   (exit $ac_status); }; }; then
3709   :
3710 else
3711   echo "$as_me: failed program was:" >&5
3712 sed 's/^/| /' conftest.$ac_ext >&5
3713
3714 continue
3715 fi
3716 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3717   cat >conftest.$ac_ext <<_ACEOF
3718 /* confdefs.h.  */
3719 _ACEOF
3720 cat confdefs.h >>conftest.$ac_ext
3721 cat >>conftest.$ac_ext <<_ACEOF
3722 /* end confdefs.h.  */
3723 $ac_declaration
3724 int
3725 main ()
3726 {
3727 exit (42);
3728   ;
3729   return 0;
3730 }
3731 _ACEOF
3732 rm -f conftest.$ac_objext
3733 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3734   (eval $ac_compile) 2>conftest.er1
3735   ac_status=$?
3736   grep -v '^ *+' conftest.er1 >conftest.err
3737   rm -f conftest.er1
3738   cat conftest.err >&5
3739   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3740   (exit $ac_status); } &&
3741          { ac_try='test -z "$ac_c_werror_flag"
3742                          || test ! -s conftest.err'
3743   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3744   (eval $ac_try) 2>&5
3745   ac_status=$?
3746   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3747   (exit $ac_status); }; } &&
3748          { ac_try='test -s conftest.$ac_objext'
3749   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3750   (eval $ac_try) 2>&5
3751   ac_status=$?
3752   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3753   (exit $ac_status); }; }; then
3754   break
3755 else
3756   echo "$as_me: failed program was:" >&5
3757 sed 's/^/| /' conftest.$ac_ext >&5
3758
3759 fi
3760 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3761 done
3762 rm -f conftest*
3763 if test -n "$ac_declaration"; then
3764   echo '#ifdef __cplusplus' >>confdefs.h
3765   echo $ac_declaration      >>confdefs.h
3766   echo '#endif'             >>confdefs.h
3767 fi
3768
3769 else
3770   echo "$as_me: failed program was:" >&5
3771 sed 's/^/| /' conftest.$ac_ext >&5
3772
3773 fi
3774 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3775 ac_ext=c
3776 ac_cpp='$CPP $CPPFLAGS'
3777 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3778 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3779 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3780
3781 ac_ext=cc
3782 ac_cpp='$CXXCPP $CPPFLAGS'
3783 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3784 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3785 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3786 if test -n "$ac_tool_prefix"; then
3787   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3788   do
3789     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3790 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3791 echo "$as_me:$LINENO: checking for $ac_word" >&5
3792 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3793 if test "${ac_cv_prog_CXX+set}" = set; then
3794   echo $ECHO_N "(cached) $ECHO_C" >&6
3795 else
3796   if test -n "$CXX"; then
3797   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3798 else
3799 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3800 for as_dir in $PATH
3801 do
3802   IFS=$as_save_IFS
3803   test -z "$as_dir" && as_dir=.
3804   for ac_exec_ext in '' $ac_executable_extensions; do
3805   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3806     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3807     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3808     break 2
3809   fi
3810 done
3811 done
3812
3813 fi
3814 fi
3815 CXX=$ac_cv_prog_CXX
3816 if test -n "$CXX"; then
3817   echo "$as_me:$LINENO: result: $CXX" >&5
3818 echo "${ECHO_T}$CXX" >&6
3819 else
3820   echo "$as_me:$LINENO: result: no" >&5
3821 echo "${ECHO_T}no" >&6
3822 fi
3823
3824     test -n "$CXX" && break
3825   done
3826 fi
3827 if test -z "$CXX"; then
3828   ac_ct_CXX=$CXX
3829   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3830 do
3831   # Extract the first word of "$ac_prog", so it can be a program name with args.
3832 set dummy $ac_prog; ac_word=$2
3833 echo "$as_me:$LINENO: checking for $ac_word" >&5
3834 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3835 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3836   echo $ECHO_N "(cached) $ECHO_C" >&6
3837 else
3838   if test -n "$ac_ct_CXX"; then
3839   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3840 else
3841 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3842 for as_dir in $PATH
3843 do
3844   IFS=$as_save_IFS
3845   test -z "$as_dir" && as_dir=.
3846   for ac_exec_ext in '' $ac_executable_extensions; do
3847   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3848     ac_cv_prog_ac_ct_CXX="$ac_prog"
3849     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3850     break 2
3851   fi
3852 done
3853 done
3854
3855 fi
3856 fi
3857 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3858 if test -n "$ac_ct_CXX"; then
3859   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3860 echo "${ECHO_T}$ac_ct_CXX" >&6
3861 else
3862   echo "$as_me:$LINENO: result: no" >&5
3863 echo "${ECHO_T}no" >&6
3864 fi
3865
3866   test -n "$ac_ct_CXX" && break
3867 done
3868 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3869
3870   CXX=$ac_ct_CXX
3871 fi
3872
3873
3874 # Provide some information about the compiler.
3875 echo "$as_me:$LINENO:" \
3876      "checking for C++ compiler version" >&5
3877 ac_compiler=`set X $ac_compile; echo $2`
3878 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3879   (eval $ac_compiler --version </dev/null >&5) 2>&5
3880   ac_status=$?
3881   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3882   (exit $ac_status); }
3883 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3884   (eval $ac_compiler -v </dev/null >&5) 2>&5
3885   ac_status=$?
3886   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3887   (exit $ac_status); }
3888 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3889   (eval $ac_compiler -V </dev/null >&5) 2>&5
3890   ac_status=$?
3891   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3892   (exit $ac_status); }
3893
3894 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3895 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3896 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3897   echo $ECHO_N "(cached) $ECHO_C" >&6
3898 else
3899   cat >conftest.$ac_ext <<_ACEOF
3900 /* confdefs.h.  */
3901 _ACEOF
3902 cat confdefs.h >>conftest.$ac_ext
3903 cat >>conftest.$ac_ext <<_ACEOF
3904 /* end confdefs.h.  */
3905
3906 int
3907 main ()
3908 {
3909 #ifndef __GNUC__
3910        choke me
3911 #endif
3912
3913   ;
3914   return 0;
3915 }
3916 _ACEOF
3917 rm -f conftest.$ac_objext
3918 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3919   (eval $ac_compile) 2>conftest.er1
3920   ac_status=$?
3921   grep -v '^ *+' conftest.er1 >conftest.err
3922   rm -f conftest.er1
3923   cat conftest.err >&5
3924   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3925   (exit $ac_status); } &&
3926          { ac_try='test -z "$ac_cxx_werror_flag"
3927                          || test ! -s conftest.err'
3928   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3929   (eval $ac_try) 2>&5
3930   ac_status=$?
3931   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3932   (exit $ac_status); }; } &&
3933          { ac_try='test -s conftest.$ac_objext'
3934   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3935   (eval $ac_try) 2>&5
3936   ac_status=$?
3937   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3938   (exit $ac_status); }; }; then
3939   ac_compiler_gnu=yes
3940 else
3941   echo "$as_me: failed program was:" >&5
3942 sed 's/^/| /' conftest.$ac_ext >&5
3943
3944 ac_compiler_gnu=no
3945 fi
3946 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3947 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3948
3949 fi
3950 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3951 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
3952 GXX=`test $ac_compiler_gnu = yes && echo yes`
3953 ac_test_CXXFLAGS=${CXXFLAGS+set}
3954 ac_save_CXXFLAGS=$CXXFLAGS
3955 CXXFLAGS="-g"
3956 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3957 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
3958 if test "${ac_cv_prog_cxx_g+set}" = set; then
3959   echo $ECHO_N "(cached) $ECHO_C" >&6
3960 else
3961   cat >conftest.$ac_ext <<_ACEOF
3962 /* confdefs.h.  */
3963 _ACEOF
3964 cat confdefs.h >>conftest.$ac_ext
3965 cat >>conftest.$ac_ext <<_ACEOF
3966 /* end confdefs.h.  */
3967
3968 int
3969 main ()
3970 {
3971
3972   ;
3973   return 0;
3974 }
3975 _ACEOF
3976 rm -f conftest.$ac_objext
3977 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3978   (eval $ac_compile) 2>conftest.er1
3979   ac_status=$?
3980   grep -v '^ *+' conftest.er1 >conftest.err
3981   rm -f conftest.er1
3982   cat conftest.err >&5
3983   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3984   (exit $ac_status); } &&
3985          { ac_try='test -z "$ac_cxx_werror_flag"
3986                          || test ! -s conftest.err'
3987   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3988   (eval $ac_try) 2>&5
3989   ac_status=$?
3990   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3991   (exit $ac_status); }; } &&
3992          { ac_try='test -s conftest.$ac_objext'
3993   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3994   (eval $ac_try) 2>&5
3995   ac_status=$?
3996   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3997   (exit $ac_status); }; }; then
3998   ac_cv_prog_cxx_g=yes
3999 else
4000   echo "$as_me: failed program was:" >&5
4001 sed 's/^/| /' conftest.$ac_ext >&5
4002
4003 ac_cv_prog_cxx_g=no
4004 fi
4005 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4006 fi
4007 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4008 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4009 if test "$ac_test_CXXFLAGS" = set; then
4010   CXXFLAGS=$ac_save_CXXFLAGS
4011 elif test $ac_cv_prog_cxx_g = yes; then
4012   if test "$GXX" = yes; then
4013     CXXFLAGS="-g -O2"
4014   else
4015     CXXFLAGS="-g"
4016   fi
4017 else
4018   if test "$GXX" = yes; then
4019     CXXFLAGS="-O2"
4020   else
4021     CXXFLAGS=
4022   fi
4023 fi
4024 for ac_declaration in \
4025    '' \
4026    'extern "C" void std::exit (int) throw (); using std::exit;' \
4027    'extern "C" void std::exit (int); using std::exit;' \
4028    'extern "C" void exit (int) throw ();' \
4029    'extern "C" void exit (int);' \
4030    'void exit (int);'
4031 do
4032   cat >conftest.$ac_ext <<_ACEOF
4033 /* confdefs.h.  */
4034 _ACEOF
4035 cat confdefs.h >>conftest.$ac_ext
4036 cat >>conftest.$ac_ext <<_ACEOF
4037 /* end confdefs.h.  */
4038 $ac_declaration
4039 #include <stdlib.h>
4040 int
4041 main ()
4042 {
4043 exit (42);
4044   ;
4045   return 0;
4046 }
4047 _ACEOF
4048 rm -f conftest.$ac_objext
4049 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4050   (eval $ac_compile) 2>conftest.er1
4051   ac_status=$?
4052   grep -v '^ *+' conftest.er1 >conftest.err
4053   rm -f conftest.er1
4054   cat conftest.err >&5
4055   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4056   (exit $ac_status); } &&
4057          { ac_try='test -z "$ac_cxx_werror_flag"
4058                          || test ! -s conftest.err'
4059   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4060   (eval $ac_try) 2>&5
4061   ac_status=$?
4062   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4063   (exit $ac_status); }; } &&
4064          { ac_try='test -s conftest.$ac_objext'
4065   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4066   (eval $ac_try) 2>&5
4067   ac_status=$?
4068   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4069   (exit $ac_status); }; }; then
4070   :
4071 else
4072   echo "$as_me: failed program was:" >&5
4073 sed 's/^/| /' conftest.$ac_ext >&5
4074
4075 continue
4076 fi
4077 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4078   cat >conftest.$ac_ext <<_ACEOF
4079 /* confdefs.h.  */
4080 _ACEOF
4081 cat confdefs.h >>conftest.$ac_ext
4082 cat >>conftest.$ac_ext <<_ACEOF
4083 /* end confdefs.h.  */
4084 $ac_declaration
4085 int
4086 main ()
4087 {
4088 exit (42);
4089   ;
4090   return 0;
4091 }
4092 _ACEOF
4093 rm -f conftest.$ac_objext
4094 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4095   (eval $ac_compile) 2>conftest.er1
4096   ac_status=$?
4097   grep -v '^ *+' conftest.er1 >conftest.err
4098   rm -f conftest.er1
4099   cat conftest.err >&5
4100   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4101   (exit $ac_status); } &&
4102          { ac_try='test -z "$ac_cxx_werror_flag"
4103                          || test ! -s conftest.err'
4104   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4105   (eval $ac_try) 2>&5
4106   ac_status=$?
4107   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4108   (exit $ac_status); }; } &&
4109          { ac_try='test -s conftest.$ac_objext'
4110   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4111   (eval $ac_try) 2>&5
4112   ac_status=$?
4113   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4114   (exit $ac_status); }; }; then
4115   break
4116 else
4117   echo "$as_me: failed program was:" >&5
4118 sed 's/^/| /' conftest.$ac_ext >&5
4119
4120 fi
4121 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4122 done
4123 rm -f conftest*
4124 if test -n "$ac_declaration"; then
4125   echo '#ifdef __cplusplus' >>confdefs.h
4126   echo $ac_declaration      >>confdefs.h
4127   echo '#endif'             >>confdefs.h
4128 fi
4129
4130 ac_ext=c
4131 ac_cpp='$CPP $CPPFLAGS'
4132 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4133 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4134 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4135
4136
4137 # We must set the default linker to the linker used by gcc for the correct
4138 # operation of libtool.  If LD is not defined and we are using gcc, try to
4139 # set the LD default to the ld used by gcc.
4140 if test -z "$LD"; then
4141   if test "$GCC" = yes; then
4142     case $build in
4143     *-*-mingw*)
4144       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4145     *)
4146       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4147     esac
4148     case $gcc_prog_ld in
4149     # Accept absolute paths.
4150     [\\/]* | [A-Za-z]:[\\/]*)
4151       LD="$gcc_prog_ld" ;;
4152     esac
4153   fi
4154 fi
4155
4156
4157
4158
4159 if test -n "$ac_tool_prefix"; then
4160   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4161 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4162 echo "$as_me:$LINENO: checking for $ac_word" >&5
4163 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4164 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4165   echo $ECHO_N "(cached) $ECHO_C" >&6
4166 else
4167   if test -n "$GNATBIND"; then
4168   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4169 else
4170 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4171 for as_dir in $PATH
4172 do
4173   IFS=$as_save_IFS
4174   test -z "$as_dir" && as_dir=.
4175   for ac_exec_ext in '' $ac_executable_extensions; do
4176   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4177     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4178     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4179     break 2
4180   fi
4181 done
4182 done
4183
4184 fi
4185 fi
4186 GNATBIND=$ac_cv_prog_GNATBIND
4187 if test -n "$GNATBIND"; then
4188   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4189 echo "${ECHO_T}$GNATBIND" >&6
4190 else
4191   echo "$as_me:$LINENO: result: no" >&5
4192 echo "${ECHO_T}no" >&6
4193 fi
4194
4195 fi
4196 if test -z "$ac_cv_prog_GNATBIND"; then
4197   ac_ct_GNATBIND=$GNATBIND
4198   # Extract the first word of "gnatbind", so it can be a program name with args.
4199 set dummy gnatbind; ac_word=$2
4200 echo "$as_me:$LINENO: checking for $ac_word" >&5
4201 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4202 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4203   echo $ECHO_N "(cached) $ECHO_C" >&6
4204 else
4205   if test -n "$ac_ct_GNATBIND"; then
4206   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4207 else
4208 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4209 for as_dir in $PATH
4210 do
4211   IFS=$as_save_IFS
4212   test -z "$as_dir" && as_dir=.
4213   for ac_exec_ext in '' $ac_executable_extensions; do
4214   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4215     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4216     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4217     break 2
4218   fi
4219 done
4220 done
4221
4222   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4223 fi
4224 fi
4225 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4226 if test -n "$ac_ct_GNATBIND"; then
4227   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4228 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4229 else
4230   echo "$as_me:$LINENO: result: no" >&5
4231 echo "${ECHO_T}no" >&6
4232 fi
4233
4234   GNATBIND=$ac_ct_GNATBIND
4235 else
4236   GNATBIND="$ac_cv_prog_GNATBIND"
4237 fi
4238
4239 if test -n "$ac_tool_prefix"; then
4240   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4241 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4242 echo "$as_me:$LINENO: checking for $ac_word" >&5
4243 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4244 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4245   echo $ECHO_N "(cached) $ECHO_C" >&6
4246 else
4247   if test -n "$GNATMAKE"; then
4248   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4249 else
4250 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4251 for as_dir in $PATH
4252 do
4253   IFS=$as_save_IFS
4254   test -z "$as_dir" && as_dir=.
4255   for ac_exec_ext in '' $ac_executable_extensions; do
4256   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4257     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4258     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4259     break 2
4260   fi
4261 done
4262 done
4263
4264 fi
4265 fi
4266 GNATMAKE=$ac_cv_prog_GNATMAKE
4267 if test -n "$GNATMAKE"; then
4268   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4269 echo "${ECHO_T}$GNATMAKE" >&6
4270 else
4271   echo "$as_me:$LINENO: result: no" >&5
4272 echo "${ECHO_T}no" >&6
4273 fi
4274
4275 fi
4276 if test -z "$ac_cv_prog_GNATMAKE"; then
4277   ac_ct_GNATMAKE=$GNATMAKE
4278   # Extract the first word of "gnatmake", so it can be a program name with args.
4279 set dummy gnatmake; ac_word=$2
4280 echo "$as_me:$LINENO: checking for $ac_word" >&5
4281 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4282 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4283   echo $ECHO_N "(cached) $ECHO_C" >&6
4284 else
4285   if test -n "$ac_ct_GNATMAKE"; then
4286   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4287 else
4288 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4289 for as_dir in $PATH
4290 do
4291   IFS=$as_save_IFS
4292   test -z "$as_dir" && as_dir=.
4293   for ac_exec_ext in '' $ac_executable_extensions; do
4294   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4295     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4296     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4297     break 2
4298   fi
4299 done
4300 done
4301
4302   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4303 fi
4304 fi
4305 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4306 if test -n "$ac_ct_GNATMAKE"; then
4307   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4308 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4309 else
4310   echo "$as_me:$LINENO: result: no" >&5
4311 echo "${ECHO_T}no" >&6
4312 fi
4313
4314   GNATMAKE=$ac_ct_GNATMAKE
4315 else
4316   GNATMAKE="$ac_cv_prog_GNATMAKE"
4317 fi
4318
4319 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4320 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4321 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4322   echo $ECHO_N "(cached) $ECHO_C" >&6
4323 else
4324   cat >conftest.adb <<EOF
4325 procedure conftest is begin null; end conftest;
4326 EOF
4327 acx_cv_cc_gcc_supports_ada=no
4328 # There is a bug in old released versions of GCC which causes the
4329 # driver to exit successfully when the appropriate language module
4330 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4331 # Therefore we must check for the error message as well as an
4332 # unsuccessful exit.
4333 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4334 # given a .adb file, but produce no object file.  So we must check
4335 # if an object file was really produced to guard against this.
4336 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4337 if test x"$errors" = x && test -f conftest.$ac_objext; then
4338   acx_cv_cc_gcc_supports_ada=yes
4339 fi
4340 rm -f conftest.*
4341 fi
4342 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4343 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4344
4345 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4346   have_gnat=yes
4347 else
4348   have_gnat=no
4349 fi
4350
4351 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4352 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4353 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4354   echo $ECHO_N "(cached) $ECHO_C" >&6
4355 else
4356    echo abfoo >t1
4357   echo cdfoo >t2
4358   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4359   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4360     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4361       :
4362     else
4363       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4364     fi
4365   fi
4366   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4367     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4368       :
4369     else
4370       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4371     fi
4372   fi
4373   rm t1 t2
4374
4375 fi
4376 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4377 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4378 do_compare="$gcc_cv_prog_cmp_skip"
4379
4380
4381
4382 # Check for GMP and MPFR
4383 gmplibs="-lmpfr -lgmp"
4384 gmpinc=
4385 have_gmp=no
4386
4387 # Specify a location for mpfr
4388 # check for this first so it ends up on the link line before gmp.
4389
4390 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4391 if test "${with_mpfr_dir+set}" = set; then
4392   withval="$with_mpfr_dir"
4393   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4394 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4395 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4396 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4397    { (exit 1); exit 1; }; }
4398 fi;
4399
4400
4401 # Check whether --with-mpfr or --without-mpfr was given.
4402 if test "${with_mpfr+set}" = set; then
4403   withval="$with_mpfr"
4404
4405 fi;
4406
4407 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4408 if test "${with_mpfr_include+set}" = set; then
4409   withval="$with_mpfr_include"
4410
4411 fi;
4412
4413 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4414 if test "${with_mpfr_lib+set}" = set; then
4415   withval="$with_mpfr_lib"
4416
4417 fi;
4418
4419 if test "x$with_mpfr" != x; then
4420   gmplibs="-L$with_mpfr/lib $gmplibs"
4421   gmpinc="-I$with_mpfr/include"
4422 fi
4423 if test "x$with_mpfr_include" != x; then
4424   gmpinc="-I$with_mpfr_include"
4425 fi
4426 if test "x$with_mpfr_lib" != x; then
4427   gmplibs="-L$with_mpfr_lib $gmplibs"
4428 fi
4429 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4430   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4431   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4432   # Do not test the mpfr version.  Assume that it is sufficient, since
4433   # it is in the source tree, and the library has not been built yet
4434   # but it would be included on the link line in the version check below
4435   # hence making the test fail.
4436   have_gmp=yes
4437 fi
4438
4439 # Specify a location for gmp
4440
4441 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4442 if test "${with_gmp_dir+set}" = set; then
4443   withval="$with_gmp_dir"
4444   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4445 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4446 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4447 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4448    { (exit 1); exit 1; }; }
4449 fi;
4450
4451
4452 # Check whether --with-gmp or --without-gmp was given.
4453 if test "${with_gmp+set}" = set; then
4454   withval="$with_gmp"
4455
4456 fi;
4457
4458 # Check whether --with-gmp_include or --without-gmp_include was given.
4459 if test "${with_gmp_include+set}" = set; then
4460   withval="$with_gmp_include"
4461
4462 fi;
4463
4464 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4465 if test "${with_gmp_lib+set}" = set; then
4466   withval="$with_gmp_lib"
4467
4468 fi;
4469
4470
4471 if test "x$with_gmp" != x; then
4472   gmplibs="-L$with_gmp/lib $gmplibs"
4473   gmpinc="-I$with_gmp/include $gmpinc"
4474 fi
4475 if test "x$with_gmp_include" != x; then
4476   gmpinc="-I$with_gmp_include $gmpinc"
4477 fi
4478 if test "x$with_gmp_lib" != x; then
4479   gmplibs="-L$with_gmp_lib $gmplibs"
4480 fi
4481 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4482   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4483   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4484   # Do not test the gmp version.  Assume that it is sufficient, since
4485   # it is in the source tree, and the library has not been built yet
4486   # but it would be included on the link line in the version check below
4487   # hence making the test fail.
4488   have_gmp=yes
4489 fi
4490
4491 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4492   have_gmp=yes
4493   saved_CFLAGS="$CFLAGS"
4494   CFLAGS="$CFLAGS $gmpinc"
4495   # Check GMP actually works
4496   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4497 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4498
4499 cat >conftest.$ac_ext <<_ACEOF
4500 /* confdefs.h.  */
4501 _ACEOF
4502 cat confdefs.h >>conftest.$ac_ext
4503 cat >>conftest.$ac_ext <<_ACEOF
4504 /* end confdefs.h.  */
4505 #include "gmp.h"
4506 int
4507 main ()
4508 {
4509
4510   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4511   choke me
4512   #endif
4513
4514   ;
4515   return 0;
4516 }
4517 _ACEOF
4518 rm -f conftest.$ac_objext
4519 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4520   (eval $ac_compile) 2>conftest.er1
4521   ac_status=$?
4522   grep -v '^ *+' conftest.er1 >conftest.err
4523   rm -f conftest.er1
4524   cat conftest.err >&5
4525   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4526   (exit $ac_status); } &&
4527          { ac_try='test -z "$ac_c_werror_flag"
4528                          || test ! -s conftest.err'
4529   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4530   (eval $ac_try) 2>&5
4531   ac_status=$?
4532   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4533   (exit $ac_status); }; } &&
4534          { ac_try='test -s conftest.$ac_objext'
4535   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4536   (eval $ac_try) 2>&5
4537   ac_status=$?
4538   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4539   (exit $ac_status); }; }; then
4540   echo "$as_me:$LINENO: result: yes" >&5
4541 echo "${ECHO_T}yes" >&6
4542 else
4543   echo "$as_me: failed program was:" >&5
4544 sed 's/^/| /' conftest.$ac_ext >&5
4545
4546 echo "$as_me:$LINENO: result: no" >&5
4547 echo "${ECHO_T}no" >&6; have_gmp=no
4548 fi
4549 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4550
4551   if test x"$have_gmp" = xyes; then
4552     saved_LIBS="$LIBS"
4553     LIBS="$LIBS $gmplibs"
4554         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4555 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4556     cat >conftest.$ac_ext <<_ACEOF
4557 /* confdefs.h.  */
4558 _ACEOF
4559 cat confdefs.h >>conftest.$ac_ext
4560 cat >>conftest.$ac_ext <<_ACEOF
4561 /* end confdefs.h.  */
4562 #include <gmp.h>
4563     #include <mpfr.h>
4564 int
4565 main ()
4566 {
4567
4568     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4569     choke me
4570     #endif
4571     mpfr_t n;
4572     mpfr_t x;
4573     int t;
4574     mpfr_init (n);
4575     mpfr_init (x);
4576     mpfr_atan2 (n, n, x, GMP_RNDN);
4577     mpfr_erfc (n, x, GMP_RNDN);
4578     mpfr_subnormalize (x, t, GMP_RNDN);
4579
4580   ;
4581   return 0;
4582 }
4583 _ACEOF
4584 rm -f conftest.$ac_objext conftest$ac_exeext
4585 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4586   (eval $ac_link) 2>conftest.er1
4587   ac_status=$?
4588   grep -v '^ *+' conftest.er1 >conftest.err
4589   rm -f conftest.er1
4590   cat conftest.err >&5
4591   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4592   (exit $ac_status); } &&
4593          { ac_try='test -z "$ac_c_werror_flag"
4594                          || test ! -s conftest.err'
4595   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4596   (eval $ac_try) 2>&5
4597   ac_status=$?
4598   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4599   (exit $ac_status); }; } &&
4600          { ac_try='test -s conftest$ac_exeext'
4601   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4602   (eval $ac_try) 2>&5
4603   ac_status=$?
4604   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4605   (exit $ac_status); }; }; then
4606   cat >conftest.$ac_ext <<_ACEOF
4607 /* confdefs.h.  */
4608 _ACEOF
4609 cat confdefs.h >>conftest.$ac_ext
4610 cat >>conftest.$ac_ext <<_ACEOF
4611 /* end confdefs.h.  */
4612 #include <gmp.h>
4613     #include <mpfr.h>
4614 int
4615 main ()
4616 {
4617
4618     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4619     choke me
4620     #endif
4621     mpfr_t n; mpfr_init(n);
4622
4623   ;
4624   return 0;
4625 }
4626 _ACEOF
4627 rm -f conftest.$ac_objext conftest$ac_exeext
4628 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4629   (eval $ac_link) 2>conftest.er1
4630   ac_status=$?
4631   grep -v '^ *+' conftest.er1 >conftest.err
4632   rm -f conftest.er1
4633   cat conftest.err >&5
4634   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4635   (exit $ac_status); } &&
4636          { ac_try='test -z "$ac_c_werror_flag"
4637                          || test ! -s conftest.err'
4638   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4639   (eval $ac_try) 2>&5
4640   ac_status=$?
4641   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4642   (exit $ac_status); }; } &&
4643          { ac_try='test -s conftest$ac_exeext'
4644   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4645   (eval $ac_try) 2>&5
4646   ac_status=$?
4647   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4648   (exit $ac_status); }; }; then
4649   echo "$as_me:$LINENO: result: yes" >&5
4650 echo "${ECHO_T}yes" >&6
4651 else
4652   echo "$as_me: failed program was:" >&5
4653 sed 's/^/| /' conftest.$ac_ext >&5
4654
4655 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4656 echo "${ECHO_T}buggy but acceptable" >&6
4657 fi
4658 rm -f conftest.err conftest.$ac_objext \
4659       conftest$ac_exeext conftest.$ac_ext
4660 else
4661   echo "$as_me: failed program was:" >&5
4662 sed 's/^/| /' conftest.$ac_ext >&5
4663
4664 echo "$as_me:$LINENO: result: no" >&5
4665 echo "${ECHO_T}no" >&6; have_gmp=no
4666 fi
4667 rm -f conftest.err conftest.$ac_objext \
4668       conftest$ac_exeext conftest.$ac_ext
4669       LIBS="$saved_LIBS"
4670   fi
4671   CFLAGS="$saved_CFLAGS"
4672
4673   if test x$have_gmp != xyes; then
4674     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4675 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4676 Copies of these libraries' source code can be found at their respective
4677 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4678 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4679 If you obtained GMP and/or MPFR from a vendor distribution package, make
4680 sure that you have installed both the libraries and the header files.
4681 They may be located in separate packages." >&5
4682 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4683 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4684 Copies of these libraries' source code can be found at their respective
4685 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4686 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4687 If you obtained GMP and/or MPFR from a vendor distribution package, make
4688 sure that you have installed both the libraries and the header files.
4689 They may be located in separate packages." >&2;}
4690    { (exit 1); exit 1; }; }
4691   fi
4692 fi
4693
4694 # Flags needed for both GMP and/or MPFR
4695
4696
4697
4698 # By default, C is the only stage 1 language.
4699 stage1_languages=,c,
4700
4701 # Figure out what language subdirectories are present.
4702 # Look if the user specified --enable-languages="..."; if not, use
4703 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4704 # go away some day.
4705 # NB:  embedded tabs in this IF block -- do not untabify
4706 if test -d ${srcdir}/gcc; then
4707   if test x"${enable_languages+set}" != xset; then
4708     if test x"${LANGUAGES+set}" = xset; then
4709       enable_languages="${LANGUAGES}"
4710         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4711     else
4712       enable_languages=all
4713     fi
4714   else
4715     if test x"${enable_languages}" = x ||
4716        test x"${enable_languages}" = xyes;
4717        then
4718       echo configure.in: --enable-languages needs at least one language argument 1>&2
4719       exit 1
4720     fi
4721   fi
4722   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4723
4724   # 'f95' is the old name for the 'fortran' language. We issue a warning
4725   # and make the substitution.
4726   case ,${enable_languages}, in
4727     *,f95,*)
4728       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4729       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4730       ;;
4731   esac
4732
4733   # First scan to see if an enabled language requires some other language.
4734   # We assume that a given config-lang.in will list all the language
4735   # front ends it requires, even if some are required indirectly.
4736   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4737     case ${lang_frag} in
4738       ..) ;;
4739       # The odd quoting in the next line works around
4740       # an apparent bug in bash 1.12 on linux.
4741       ${srcdir}/gcc/[*]/config-lang.in) ;;
4742       *)
4743         # From the config-lang.in, get $language, $lang_requires
4744         language=
4745         lang_requires=
4746         . ${lang_frag}
4747         for other in ${lang_requires} ; do
4748           case ,${enable_languages}, in
4749             *,$other,*) ;;
4750             *,all,*) ;;
4751             *,$language,*)
4752               echo " \`$other' language required by \`$language'; enabling" 1>&2
4753               enable_languages="${enable_languages},${other}"
4754               ;;
4755           esac
4756         done
4757         ;;
4758     esac
4759   done
4760
4761   new_enable_languages=,c,
4762   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4763   potential_languages=,c,
4764
4765   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4766     case ${lang_frag} in
4767       ..) ;;
4768       # The odd quoting in the next line works around
4769       # an apparent bug in bash 1.12 on linux.
4770       ${srcdir}/gcc/[*]/config-lang.in) ;;
4771       *)
4772         # From the config-lang.in, get $language, $target_libs,
4773         # $lang_dirs, $boot_language, and $build_by_default
4774         language=
4775         target_libs=
4776         lang_dirs=
4777         subdir_requires=
4778         boot_language=no
4779         build_by_default=yes
4780         . ${lang_frag}
4781         if test x${language} = x; then
4782           echo "${lang_frag} doesn't set \$language." 1>&2
4783           exit 1
4784         fi
4785
4786         case ,${enable_languages}, in
4787           *,${language},*)
4788             # Language was explicitly selected; include it.
4789             add_this_lang=yes
4790             ;;
4791           *,all,*)
4792             # 'all' was selected, select it if it is a default language
4793             add_this_lang=${build_by_default}
4794             ;;
4795           *)
4796             add_this_lang=no
4797             ;;
4798         esac
4799
4800         # Disable languages that need other directories if these aren't available.
4801         for i in $subdir_requires; do
4802           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4803           case ,${enable_languages}, in
4804             *,${language},*)
4805               # Specifically requested language; tell them.
4806               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4807 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4808    { (exit 1); exit 1; }; }
4809               ;;
4810             *)
4811               # Silently disable.
4812               add_this_lang=unsupported
4813               ;;
4814           esac
4815         done
4816
4817         # Disable Ada if no preexisting GNAT is available.
4818         case ,${enable_languages},:${language}:${have_gnat} in
4819           *,${language},*:ada:no)
4820             # Specifically requested language; tell them.
4821             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4822 echo "$as_me: error: GNAT is required to build $language" >&2;}
4823    { (exit 1); exit 1; }; }
4824             ;;
4825           *:ada:no)
4826             # Silently disable.
4827             add_this_lang=unsupported
4828             ;;
4829         esac
4830
4831         # Disable a language that is unsupported by the target.
4832         case " $unsupported_languages " in
4833           *" $language "*)
4834             add_this_lang=unsupported
4835             ;;
4836         esac
4837
4838         case $add_this_lang in
4839           unsupported)
4840             # Remove language-dependent dirs.
4841             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4842             ;;
4843           no)
4844             # Remove language-dependent dirs; still show language as supported.
4845             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4846             potential_languages="${potential_languages}${language},"
4847             ;;
4848           yes)
4849             new_enable_languages="${new_enable_languages}${language},"
4850             potential_languages="${potential_languages}${language},"
4851             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4852             case ${boot_language} in
4853               yes)
4854                 # Add to (comma-separated) list of stage 1 languages.
4855                 stage1_languages="${stage1_languages}${language},"
4856                 ;;
4857             esac
4858             ;;
4859         esac
4860         ;;
4861     esac
4862   done
4863
4864   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4865 if test "${enable_stage1_languages+set}" = set; then
4866   enableval="$enable_stage1_languages"
4867   case ,${enable_stage1_languages}, in
4868     ,no,|,,)
4869       # Set it to something that will have no effect in the loop below
4870       enable_stage1_languages=c ;;
4871     ,yes,)
4872       enable_stage1_languages=`echo $new_enable_languages | \
4873         sed -e "s/^,//" -e "s/,$//" ` ;;
4874     *,all,*)
4875       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4876         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4877   esac
4878
4879   # Add "good" languages from enable_stage1_languages to stage1_languages,
4880   # while "bad" languages go in missing_languages.  Leave no duplicates.
4881   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4882     case $potential_languages in
4883       *,$i,*)
4884         case $stage1_languages in
4885           *,$i,*) ;;
4886           *) stage1_languages="$stage1_languages$i," ;;
4887         esac ;;
4888       *)
4889         case $missing_languages in
4890           *,$i,*) ;;
4891           *) missing_languages="$missing_languages$i," ;;
4892         esac ;;
4893      esac
4894   done
4895 fi;
4896
4897   # Remove leading/trailing commas that were added for simplicity
4898   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4899   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4900   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4901   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4902
4903   if test "x$missing_languages" != x; then
4904     { { echo "$as_me:$LINENO: error:
4905 The following requested languages could not be built: ${missing_languages}
4906 Supported languages are: ${potential_languages}" >&5
4907 echo "$as_me: error:
4908 The following requested languages could not be built: ${missing_languages}
4909 Supported languages are: ${potential_languages}" >&2;}
4910    { (exit 1); exit 1; }; }
4911   fi
4912   if test "x$new_enable_languages" != "x$enable_languages"; then
4913     echo The following languages will be built: ${new_enable_languages}
4914     enable_languages="$new_enable_languages"
4915   fi
4916
4917
4918   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4919 fi
4920
4921 # Handle --disable-<component> generically.
4922 for dir in $configdirs $build_configdirs $target_configdirs ; do
4923   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4924   varname=`echo $dirname | sed -e s/+/_/g`
4925   if eval test x\${enable_${varname}} "=" xno ; then
4926     noconfigdirs="$noconfigdirs $dir"
4927   fi
4928 done
4929
4930 # Check for Boehm's garbage collector
4931 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4932 if test "${enable_objc_gc+set}" = set; then
4933   enableval="$enable_objc_gc"
4934   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4935   *,objc,*:*:yes:*target-boehm-gc*)
4936     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4937 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4938    { (exit 1); exit 1; }; }
4939     ;;
4940 esac
4941 fi;
4942
4943 # Make sure we only build Boehm's garbage collector if required.
4944 case ,${enable_languages},:${enable_objc_gc} in
4945   *,objc,*:yes)
4946     # Keep target-boehm-gc if requested for Objective-C.
4947     ;;
4948   *)
4949     # Otherwise remove target-boehm-gc depending on target-libjava.
4950     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
4951       noconfigdirs="$noconfigdirs target-boehm-gc"
4952     fi
4953     ;;
4954 esac
4955
4956 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
4957 # $build_configdirs and $target_configdirs.
4958 # If we have the source for $noconfigdirs entries, add them to $notsupp.
4959
4960 notsupp=""
4961 for dir in . $skipdirs $noconfigdirs ; do
4962   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
4963   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4964     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
4965     if test -r $srcdir/$dirname/configure ; then
4966       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4967         true
4968       else
4969         notsupp="$notsupp $dir"
4970       fi
4971     fi
4972   fi
4973   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4974     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
4975     if test -r $srcdir/$dirname/configure ; then
4976       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4977         true
4978       else
4979         notsupp="$notsupp $dir"
4980       fi
4981     fi
4982   fi
4983   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4984     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
4985     if test -r $srcdir/$dirname/configure ; then
4986       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4987         true
4988       else
4989         notsupp="$notsupp $dir"
4990       fi
4991     fi
4992   fi
4993 done
4994
4995 # Sometimes the tools are distributed with libiberty but with no other
4996 # libraries.  In that case, we don't want to build target-libiberty.
4997 # Don't let libgcc imply libiberty either.
4998 if test -n "${target_configdirs}" ; then
4999   libgcc=
5000   others=
5001   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5002     if test "$i" = "libgcc"; then
5003       libgcc=target-libgcc
5004     elif test "$i" != "libiberty" ; then
5005       if test -r $srcdir/$i/configure ; then
5006         others=yes;
5007         break;
5008       fi
5009     fi
5010   done
5011   if test -z "${others}" ; then
5012     target_configdirs=$libgcc
5013   fi
5014 fi
5015
5016 # Quietly strip out all directories which aren't configurable in this tree.
5017 # This relies on all configurable subdirectories being autoconfiscated, which
5018 # is now the case.
5019 build_configdirs_all="$build_configdirs"
5020 build_configdirs=
5021 for i in ${build_configdirs_all} ; do
5022   j=`echo $i | sed -e s/build-//g`
5023   if test -f ${srcdir}/$j/configure ; then
5024     build_configdirs="${build_configdirs} $i"
5025   fi
5026 done
5027
5028 configdirs_all="$configdirs"
5029 configdirs=
5030 for i in ${configdirs_all} ; do
5031   if test -f ${srcdir}/$i/configure ; then
5032     configdirs="${configdirs} $i"
5033   fi
5034 done
5035
5036 target_configdirs_all="$target_configdirs"
5037 target_configdirs=
5038 for i in ${target_configdirs_all} ; do
5039   j=`echo $i | sed -e s/target-//g`
5040   if test -f ${srcdir}/$j/configure ; then
5041     target_configdirs="${target_configdirs} $i"
5042   fi
5043 done
5044
5045 # Produce a warning message for the subdirs we can't configure.
5046 # This isn't especially interesting in the Cygnus tree, but in the individual
5047 # FSF releases, it's important to let people know when their machine isn't
5048 # supported by the one or two programs in a package.
5049
5050 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5051   # If $appdirs is non-empty, at least one of those directories must still
5052   # be configured, or we error out.  (E.g., if the gas release supports a
5053   # specified target in some subdirs but not the gas subdir, we shouldn't
5054   # pretend that all is well.)
5055   if test -n "$appdirs" ; then
5056     for dir in $appdirs ; do
5057       if test -r $dir/Makefile.in ; then
5058         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5059           appdirs=""
5060           break
5061         fi
5062         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5063           appdirs=""
5064           break
5065         fi
5066       fi
5067     done
5068     if test -n "$appdirs" ; then
5069       echo "*** This configuration is not supported by this package." 1>&2
5070       exit 1
5071     fi
5072   fi
5073   # Okay, some application will build, or we don't care to check.  Still
5074   # notify of subdirs not getting built.
5075   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5076   echo "    ${notsupp}" 1>&2
5077   echo "    (Any other directories should still work fine.)" 1>&2
5078 fi
5079
5080 case "$host" in
5081   *msdosdjgpp*)
5082     enable_gdbtk=no ;;
5083 esac
5084
5085 # To find our prefix, in gcc_cv_tool_prefix.
5086
5087 # The user is always right.
5088 if test "${PATH_SEPARATOR+set}" != set; then
5089   echo "#! /bin/sh" >conf$$.sh
5090   echo  "exit 0"   >>conf$$.sh
5091   chmod +x conf$$.sh
5092   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5093     PATH_SEPARATOR=';'
5094   else
5095     PATH_SEPARATOR=:
5096   fi
5097   rm -f conf$$.sh
5098 fi
5099
5100
5101
5102 if test "x$exec_prefix" = xNONE; then
5103         if test "x$prefix" = xNONE; then
5104                 gcc_cv_tool_prefix=$ac_default_prefix
5105         else
5106                 gcc_cv_tool_prefix=$prefix
5107         fi
5108 else
5109         gcc_cv_tool_prefix=$exec_prefix
5110 fi
5111
5112 # If there is no compiler in the tree, use the PATH only.  In any
5113 # case, if there is no compiler in the tree nobody should use
5114 # AS_FOR_TARGET and LD_FOR_TARGET.
5115 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5116     gcc_version=`cat $srcdir/gcc/BASE-VER`
5117     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5118     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5119     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5120     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5121     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5122     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5123 else
5124     gcc_cv_tool_dirs=
5125 fi
5126
5127 if test x$build = x$target && test -n "$md_exec_prefix"; then
5128         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5129 fi
5130
5131
5132
5133 copy_dirs=
5134
5135
5136 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5137 if test "${with_build_sysroot+set}" = set; then
5138   withval="$with_build_sysroot"
5139   if test x"$withval" != x ; then
5140      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5141    fi
5142 else
5143   SYSROOT_CFLAGS_FOR_TARGET=
5144 fi;
5145
5146
5147
5148 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5149 if test "${with_debug_prefix_map+set}" = set; then
5150   withval="$with_debug_prefix_map"
5151   if test x"$withval" != x; then
5152      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5153      for debug_map in $withval; do
5154        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5155      done
5156    fi
5157 else
5158   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5159 fi;
5160
5161
5162 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5163 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5164 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5165 # We want to ensure that TARGET libraries (which we know are built with
5166 # gcc) are built with "-O2 -g", so include those options when setting
5167 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5168 if test "x$CFLAGS_FOR_TARGET" = x; then
5169   CFLAGS_FOR_TARGET=$CFLAGS
5170   case " $CFLAGS " in
5171     *" -O2 "*) ;;
5172     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5173   esac
5174   case " $CFLAGS " in
5175     *" -g "* | *" -g3 "*) ;;
5176     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5177   esac
5178 fi
5179
5180
5181 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5182   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5183   case " $CXXFLAGS " in
5184     *" -O2 "*) ;;
5185     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5186   esac
5187   case " $CXXFLAGS " in
5188     *" -g "* | *" -g3 "*) ;;
5189     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5190   esac
5191 fi
5192
5193
5194 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5195 # the named directory are copied to $(tooldir)/sys-include.
5196 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5197   if test x${is_cross_compiler} = xno ; then
5198     echo 1>&2 '***' --with-headers is only supported when cross compiling
5199     exit 1
5200   fi
5201   if test x"${with_headers}" != xyes ; then
5202     x=${gcc_cv_tool_prefix}
5203     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5204   fi
5205 fi
5206
5207 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5208 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5209 # are permitted.
5210 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5211   if test x${is_cross_compiler} = xno ; then
5212     echo 1>&2 '***' --with-libs is only supported when cross compiling
5213     exit 1
5214   fi
5215   if test x"${with_libs}" != xyes ; then
5216     # Copy the libraries in reverse order, so that files in the first named
5217     # library override files in subsequent libraries.
5218     x=${gcc_cv_tool_prefix}
5219     for l in ${with_libs}; do
5220       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5221     done
5222   fi
5223 fi
5224
5225 # Set with_gnu_as and with_gnu_ld as appropriate.
5226 #
5227 # This is done by determining whether or not the appropriate directory
5228 # is available, and by checking whether or not specific configurations
5229 # have requested that this magic not happen.
5230 #
5231 # The command line options always override the explicit settings in
5232 # configure.in, and the settings in configure.in override this magic.
5233 #
5234 # If the default for a toolchain is to use GNU as and ld, and you don't
5235 # want to do that, then you should use the --without-gnu-as and
5236 # --without-gnu-ld options for the configure script.
5237
5238 if test x${use_gnu_as} = x &&
5239    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5240   with_gnu_as=yes
5241   extra_host_args="$extra_host_args --with-gnu-as"
5242 fi
5243
5244 if test x${use_gnu_ld} = x &&
5245    echo " ${configdirs} " | grep " ld " > /dev/null 2>&1 ; then
5246   with_gnu_ld=yes
5247   extra_host_args="$extra_host_args --with-gnu-ld"
5248 fi
5249
5250 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5251 # can detect this case.
5252
5253 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5254   with_newlib=yes
5255   extra_host_args="$extra_host_args --with-newlib"
5256 fi
5257
5258 # Handle ${copy_dirs}
5259 set fnord ${copy_dirs}
5260 shift
5261 while test $# != 0 ; do
5262   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5263     :
5264   else
5265     echo Copying $1 to $2
5266
5267     # Use the install script to create the directory and all required
5268     # parent directories.
5269     if test -d $2 ; then
5270       :
5271     else
5272       echo >config.temp
5273       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5274     fi
5275
5276     # Copy the directory, assuming we have tar.
5277     # FIXME: Should we use B in the second tar?  Not all systems support it.
5278     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5279
5280     # It is the responsibility of the user to correctly adjust all
5281     # symlinks.  If somebody can figure out how to handle them correctly
5282     # here, feel free to add the code.
5283
5284     echo $1 > $2/COPIED
5285   fi
5286   shift; shift
5287 done
5288
5289 # Determine a target-dependent exec_prefix that the installed
5290 # gcc will search in.  Keep this list sorted by triplet, with
5291 # the *-*-osname triplets last.
5292 md_exec_prefix=
5293 case "${target}" in
5294   alpha*-*-*vms*)
5295     md_exec_prefix=/gnu/lib/gcc-lib
5296     ;;
5297   i[34567]86-pc-msdosdjgpp*)
5298     md_exec_prefix=/dev/env/DJDIR/bin
5299     ;;
5300   i[34567]86-*-sco3.2v5*)
5301     if test $with_gnu_as = yes; then
5302       md_exec_prefix=/usr/gnu/bin
5303     else
5304       md_exec_prefix=/usr/ccs/bin/elf
5305     fi
5306     ;;
5307
5308   mn10300-*-* | \
5309   powerpc-*-chorusos* | \
5310   powerpc*-*-eabi* | \
5311   powerpc*-*-sysv* | \
5312   powerpc*-*-kaos* | \
5313   s390x-ibm-tpf*)
5314     md_exec_prefix=/usr/ccs/bin
5315     ;;
5316   sparc64-*-elf*)
5317     ;;
5318   v850*-*-*)
5319     md_exec_prefix=/usr/ccs/bin
5320     ;;
5321   xtensa*-*-elf*)
5322     ;;
5323
5324   *-*-beos* | \
5325   *-*-elf* | \
5326   *-*-hpux* | \
5327   *-*-netware* | \
5328   *-*-nto-qnx* | \
5329   *-*-rtems* | \
5330   *-*-solaris2* | \
5331   *-*-sysv[45]* | \
5332   *-*-vxworks* | \
5333   *-wrs-windiss)
5334     md_exec_prefix=/usr/ccs/bin
5335     ;;
5336 esac
5337
5338 extra_arflags_for_target=
5339 extra_nmflags_for_target=
5340 extra_ranlibflags_for_target=
5341 target_makefile_frag=/dev/null
5342 case "${target}" in
5343   mep*-*-*)
5344     target_makefile_frag="config/mt-mep"
5345     ;;
5346   spu-*-*)
5347     target_makefile_frag="config/mt-spu"
5348     ;;
5349   mips*-sde-elf*)
5350     target_makefile_frag="config/mt-sde"
5351     ;;
5352   mipsisa*-*-elfoabi*)
5353     target_makefile_frag="config/mt-mips-elfoabi"
5354     ;;
5355   *-*-netware*)
5356     target_makefile_frag="config/mt-netware"
5357     ;;
5358   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5359     target_makefile_frag="config/mt-gnu"
5360     ;;
5361   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5362     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5363     # commands to handle both 32-bit and 64-bit objects.  These flags are
5364     # harmless if we're using GNU nm or ar.
5365     extra_arflags_for_target=" -X32_64"
5366     extra_nmflags_for_target=" -B -X32_64"
5367     ;;
5368   *-*-darwin*)
5369     # ranlib from Darwin requires the -c flag to look at common symbols.
5370     extra_ranlibflags_for_target=" -c"
5371     ;;
5372   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5373     target_makefile_frag="config/mt-wince"
5374     ;;
5375 esac
5376
5377 alphaieee_frag=/dev/null
5378 case $target in
5379   alpha*-*-*)
5380     # This just makes sure to use the -mieee option to build target libs.
5381     # This should probably be set individually by each library.
5382     alphaieee_frag="config/mt-alphaieee"
5383     ;;
5384 esac
5385
5386 # If --enable-target-optspace always use -Os instead of -O2 to build
5387 # the target libraries, similarly if it is not specified, use -Os
5388 # on selected platforms.
5389 ospace_frag=/dev/null
5390 case "${enable_target_optspace}:${target}" in
5391   yes:*)
5392     ospace_frag="config/mt-ospace"
5393     ;;
5394   :d30v-*)
5395     ospace_frag="config/mt-d30v"
5396     ;;
5397   :m32r-* | :d10v-* | :fr30-*)
5398     ospace_frag="config/mt-ospace"
5399     ;;
5400   no:* | :*)
5401     ;;
5402   *)
5403     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5404     ;;
5405 esac
5406
5407 # Default to using --with-stabs for certain targets.
5408 if test x${with_stabs} = x ; then
5409   case "${target}" in
5410   mips*-*-irix[56]*)
5411     ;;
5412   mips*-*-* | alpha*-*-osf*)
5413     with_stabs=yes;
5414     extra_host_args="${extra_host_args} --with-stabs"
5415     ;;
5416   esac
5417 fi
5418
5419 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5420 # them automatically.
5421 case "${host}" in
5422   hppa*64*-*-hpux11*)
5423     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5424     ;;
5425 esac
5426
5427 # Some systems (e.g., one of the i386-aix systems the gas testers are
5428 # using) don't handle "\$" correctly, so don't use it here.
5429 tooldir='${exec_prefix}'/${target_noncanonical}
5430 build_tooldir=${tooldir}
5431
5432 # Create a .gdbinit file which runs the one in srcdir
5433 # and tells GDB to look there for source files.
5434
5435 if test -r ${srcdir}/.gdbinit ; then
5436   case ${srcdir} in
5437     .) ;;
5438     *) cat > ./.gdbinit <<EOF
5439 # ${NO_EDIT}
5440 dir ${srcdir}
5441 dir .
5442 source ${srcdir}/.gdbinit
5443 EOF
5444     ;;
5445   esac
5446 fi
5447
5448 # Make sure that the compiler is able to generate an executable.  If it
5449 # can't, we are probably in trouble.  We don't care whether we can run the
5450 # executable--we might be using a cross compiler--we only care whether it
5451 # can be created.  At this point the main configure script has set CC.
5452 we_are_ok=no
5453 echo "int main () { return 0; }" > conftest.c
5454 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5455 if test $? = 0 ; then
5456   if test -s conftest || test -s conftest.exe ; then
5457     we_are_ok=yes
5458   fi
5459 fi
5460 case $we_are_ok in
5461   no)
5462     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5463     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5464     rm -f conftest*
5465     exit 1
5466     ;;
5467 esac
5468 rm -f conftest*
5469
5470 # The Solaris /usr/ucb/cc compiler does not appear to work.
5471 case "${host}" in
5472   sparc-sun-solaris2*)
5473       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5474       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5475           could_use=
5476           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5477           if test -d /opt/cygnus/bin ; then
5478               if test "$could_use" = "" ; then
5479                   could_use="/opt/cygnus/bin"
5480               else
5481                   could_use="$could_use or /opt/cygnus/bin"
5482               fi
5483           fi
5484         if test "$could_use" = "" ; then
5485             echo "Warning: compilation may fail because you're using"
5486             echo "/usr/ucb/cc.  You should change your PATH or CC "
5487             echo "variable and rerun configure."
5488         else
5489             echo "Warning: compilation may fail because you're using"
5490             echo "/usr/ucb/cc, when you should use the C compiler from"
5491             echo "$could_use.  You should change your"
5492             echo "PATH or CC variable and rerun configure."
5493         fi
5494       fi
5495   ;;
5496 esac
5497
5498 case "${host}" in
5499   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5500   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5501   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5502 esac
5503
5504 # Record target_configdirs and the configure arguments for target and
5505 # build configuration in Makefile.
5506 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5507 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5508
5509 # Determine whether gdb needs tk/tcl or not.
5510 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5511 # and in that case we want gdb to be built without tk.  Ugh!
5512 # In fact I believe gdb is the *only* package directly dependent on tk,
5513 # so we should be able to put the 'maybe's in unconditionally and
5514 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5515 # 100% sure that that's safe though.
5516
5517 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5518 case "$enable_gdbtk" in
5519   no)
5520     GDB_TK="" ;;
5521   yes)
5522     GDB_TK="${gdb_tk}" ;;
5523   *)
5524     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5525     # distro.  Eventually someone will fix this and move Insight, nee
5526     # gdbtk to a separate directory.
5527     if test -d ${srcdir}/gdb/gdbtk ; then
5528       GDB_TK="${gdb_tk}"
5529     else
5530       GDB_TK=""
5531     fi
5532     ;;
5533 esac
5534 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5535 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5536
5537 # Strip out unwanted targets.
5538
5539 # While at that, we remove Makefiles if we were started for recursive
5540 # configuration, so that the top-level Makefile reconfigures them,
5541 # like we used to do when configure itself was recursive.
5542
5543 # Loop over modules.  $extrasub must be used with care, limiting as
5544 # much as possible the usage of range addresses.  That's because autoconf
5545 # splits the sed script to overcome limits in the number of commands,
5546 # and relying on carefully-timed sed passes may turn out to be very hard
5547 # to maintain later.  In this particular case, you just have to be careful
5548 # not to nest @if/@endif pairs, because configure will not warn you at all.
5549
5550 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5551 if test "${enable_bootstrap+set}" = set; then
5552   enableval="$enable_bootstrap"
5553
5554 else
5555   enable_bootstrap=default
5556 fi;
5557
5558 # Issue errors and warnings for invalid/strange bootstrap combinations.
5559 case "$configdirs" in
5560   *gcc*) have_compiler=yes ;;
5561   *) have_compiler=no ;;
5562 esac
5563
5564 case "$have_compiler:$host:$target:$enable_bootstrap" in
5565   *:*:*:no) ;;
5566
5567   # Default behavior.  Enable bootstrap if we have a compiler
5568   # and we are in a native configuration.
5569   yes:$build:$build:default)
5570     enable_bootstrap=yes ;;
5571
5572   *:*:*:default)
5573     enable_bootstrap=no ;;
5574
5575   # We have a compiler and we are in a native configuration, bootstrap is ok
5576   yes:$build:$build:yes)
5577     ;;
5578
5579   # Other configurations, but we have a compiler.  Assume the user knows
5580   # what he's doing.
5581   yes:*:*:yes)
5582     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5583 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5584     ;;
5585
5586   # No compiler: if they passed --enable-bootstrap explicitly, fail
5587   no:*:*:yes)
5588     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5589 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5590    { (exit 1); exit 1; }; } ;;
5591
5592   # Fail if wrong command line
5593   *)
5594     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5595 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5596    { (exit 1); exit 1; }; }
5597     ;;
5598 esac
5599
5600 # Adjust the toplevel makefile according to whether bootstrap was selected.
5601 case "$enable_bootstrap" in
5602   yes)
5603     bootstrap_suffix=bootstrap ;;
5604   no)
5605     bootstrap_suffix=no-bootstrap ;;
5606 esac
5607
5608 for module in ${build_configdirs} ; do
5609   if test -z "${no_recursion}" \
5610      && test -f ${build_subdir}/${module}/Makefile; then
5611     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5612     rm -f ${build_subdir}/${module}/Makefile
5613   fi
5614   extrasub="$extrasub
5615 /^@if build-$module\$/d
5616 /^@endif build-$module\$/d
5617 /^@if build-$module-$bootstrap_suffix\$/d
5618 /^@endif build-$module-$bootstrap_suffix\$/d"
5619 done
5620 for module in ${configdirs} ; do
5621   if test -z "${no_recursion}"; then
5622     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5623       if test -f ${file}; then
5624         echo 1>&2 "*** removing ${file} to force reconfigure"
5625         rm -f ${file}
5626       fi
5627     done
5628   fi
5629   extrasub="$extrasub
5630 /^@if $module\$/d
5631 /^@endif $module\$/d
5632 /^@if $module-$bootstrap_suffix\$/d
5633 /^@endif $module-$bootstrap_suffix\$/d"
5634 done
5635 for module in ${target_configdirs} ; do
5636   if test -z "${no_recursion}" \
5637      && test -f ${target_subdir}/${module}/Makefile; then
5638     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5639     rm -f ${target_subdir}/${module}/Makefile
5640   fi
5641   extrasub="$extrasub
5642 /^@if target-$module\$/d
5643 /^@endif target-$module\$/d
5644 /^@if target-$module-$bootstrap_suffix\$/d
5645 /^@endif target-$module-$bootstrap_suffix\$/d"
5646 done
5647
5648 extrasub="$extrasub
5649 /^@if /,/^@endif /d"
5650
5651 # Create the serialization dependencies.  This uses a temporary file.
5652
5653 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5654 if test "${enable_serial_configure+set}" = set; then
5655   enableval="$enable_serial_configure"
5656
5657 fi;
5658
5659 case ${enable_serial_configure} in
5660   yes)
5661     enable_serial_build_configure=yes
5662     enable_serial_host_configure=yes
5663     enable_serial_target_configure=yes
5664     ;;
5665 esac
5666
5667 # These force 'configure's to be done one at a time, to avoid problems
5668 # with contention over a shared config.cache.
5669 rm -f serdep.tmp
5670 echo '# serdep.tmp' > serdep.tmp
5671 olditem=
5672 test "x${enable_serial_build_configure}" = xyes &&
5673 for item in ${build_configdirs} ; do
5674   case ${olditem} in
5675     "") ;;
5676     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5677   esac
5678   olditem=${item}
5679 done
5680 olditem=
5681 test "x${enable_serial_host_configure}" = xyes &&
5682 for item in ${configdirs} ; do
5683   case ${olditem} in
5684     "") ;;
5685     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5686   esac
5687   olditem=${item}
5688 done
5689 olditem=
5690 test "x${enable_serial_target_configure}" = xyes &&
5691 for item in ${target_configdirs} ; do
5692   case ${olditem} in
5693     "") ;;
5694     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5695   esac
5696   olditem=${item}
5697 done
5698 serialization_dependencies=serdep.tmp
5699
5700
5701 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5702 # target, nonopt, and variable assignments.  These are the ones we
5703 # might not want to pass down to subconfigures.  Also strip
5704 # program-prefix, program-suffix, and program-transform-name, so that
5705 # we can pass down a consistent program-transform-name.
5706 baseargs=
5707 keep_next=no
5708 skip_next=no
5709 eval "set -- $ac_configure_args"
5710 for ac_arg
5711 do
5712   if test X"$skip_next" = X"yes"; then
5713     skip_next=no
5714     continue
5715   fi
5716   if test X"$keep_next" = X"yes"; then
5717     case $ac_arg in
5718       *\'*)
5719         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5720     esac
5721     baseargs="$baseargs '$ac_arg'"
5722     keep_next=no
5723     continue
5724   fi
5725
5726   # Handle separated arguments.  Based on the logic generated by
5727   # autoconf 2.59.
5728   case $ac_arg in
5729     *=* | --config-cache | -C | -disable-* | --disable-* \
5730       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5731       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5732       | -with-* | --with-* | -without-* | --without-* | --x)
5733       separate_arg=no
5734       ;;
5735     -*)
5736       separate_arg=yes
5737       ;;
5738     *)
5739       separate_arg=no
5740       ;;
5741   esac
5742
5743   case "$ac_arg" in
5744     --no*)
5745       continue
5746       ;;
5747     --c* | \
5748     --sr* | \
5749     --ho* | \
5750     --bu* | \
5751     --t* | \
5752     --program-* | \
5753     -cache_file* | \
5754     -srcdir* | \
5755     -host* | \
5756     -build* | \
5757     -target* | \
5758     -program-prefix* | \
5759     -program-suffix* | \
5760     -program-transform-name* )
5761       skip_next=$separate_arg
5762       continue
5763       ;;
5764     -*)
5765       # An option.  Add it.
5766       case $ac_arg in
5767         *\'*)
5768           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5769       esac
5770       baseargs="$baseargs '$ac_arg'"
5771       keep_next=$separate_arg
5772       ;;
5773     *)
5774       # Either a variable assignment, or a nonopt (triplet).  Don't
5775       # pass it down; let the Makefile handle this.
5776       continue
5777       ;;
5778   esac
5779 done
5780 # Remove the initial space we just introduced and, as these will be
5781 # expanded by make, quote '$'.
5782 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5783
5784 # Add in --program-transform-name, after --program-prefix and
5785 # --program-suffix have been applied to it.  Autoconf has already
5786 # doubled dollar signs and backslashes in program_transform_name; we want
5787 # the backslashes un-doubled, and then the entire thing wrapped in single
5788 # quotes, because this will be expanded first by make and then by the shell.
5789 # Also, because we want to override the logic in subdir configure scripts to
5790 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5791 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5792 ${program_transform_name}
5793 EOF_SED
5794 gcc_transform_name=`cat conftestsed.out`
5795 rm -f conftestsed.out
5796 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5797 if test "$silent" = yes; then
5798   baseargs="$baseargs --silent"
5799 fi
5800
5801 # For the build-side libraries, we just need to pretend we're native,
5802 # and not use the same cache file.  Multilibs are neither needed nor
5803 # desired.
5804 build_configargs="--cache-file=../config.cache ${baseargs}"
5805
5806 # For host modules, accept cache file option, or specification as blank.
5807 case "${cache_file}" in
5808 "") # empty
5809   cache_file_option="" ;;
5810 /* | [A-Za-z]:[\\/]* ) # absolute path
5811   cache_file_option="--cache-file=${cache_file}" ;;
5812 *) # relative path
5813   cache_file_option="--cache-file=../${cache_file}" ;;
5814 esac
5815
5816 # Host dirs don't like to share a cache file either, horribly enough.
5817 # This seems to be due to autoconf 2.5x stupidity.
5818 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5819
5820 target_configargs=${baseargs}
5821
5822 # Passing a --with-cross-host argument lets the target libraries know
5823 # whether they are being built with a cross-compiler or being built
5824 # native.  However, it would be better to use other mechanisms to make the
5825 # sorts of decisions they want to make on this basis.  Please consider
5826 # this option to be deprecated.  FIXME.
5827 if test x${is_cross_compiler} = xyes ; then
5828   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5829 fi
5830
5831 # Default to --enable-multilib.
5832 if test x${enable_multilib} = x ; then
5833   target_configargs="--enable-multilib ${target_configargs}"
5834 fi
5835
5836 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5837 # changed from the earlier setting of with_newlib.
5838 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5839   target_configargs="--with-newlib ${target_configargs}"
5840 fi
5841
5842 # Different target subdirs use different values of certain variables
5843 # (notably CXX).  Worse, multilibs use *lots* of different values.
5844 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5845 # it doesn't automatically accept command-line overrides of them.
5846 # This means it's not safe for target subdirs to share a cache file,
5847 # which is disgusting, but there you have it.  Hopefully this can be
5848 # fixed in future.  It's still worthwhile to use a cache file for each
5849 # directory.  I think.
5850
5851 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5852 # We need to pass --target, as newer autoconf's requires consistency
5853 # for target_alias and gcc doesn't manage it consistently.
5854 target_configargs="--cache-file=./config.cache ${target_configargs}"
5855
5856 FLAGS_FOR_TARGET=
5857 case " $target_configdirs " in
5858  *" newlib "*)
5859   case " $target_configargs " in
5860   *" --with-newlib "*)
5861    case "$target" in
5862    *-cygwin*)
5863      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' ;;
5864    esac
5865
5866    # If we're not building GCC, don't discard standard headers.
5867    if test -d ${srcdir}/gcc; then
5868      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5869
5870      if test "${build}" != "${host}"; then
5871        # On Canadian crosses, CC_FOR_TARGET will have already been set
5872        # by `configure', so we won't have an opportunity to add -Bgcc/
5873        # to it.  This is right: we don't want to search that directory
5874        # for binaries, but we want the header files in there, so add
5875        # them explicitly.
5876        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5877
5878        # Someone might think of using the pre-installed headers on
5879        # Canadian crosses, in case the installed compiler is not fully
5880        # compatible with the compiler being built.  In this case, it
5881        # would be better to flag an error than risking having
5882        # incompatible object files being constructed.  We can't
5883        # guarantee that an error will be flagged, but let's hope the
5884        # compiler will do it, when presented with incompatible header
5885        # files.
5886      fi
5887    fi
5888
5889    case "${target}-${is_cross_compiler}" in
5890    i[3456789]86-*-linux*-no)
5891       # Here host == target, so we don't need to build gcc,
5892       # so we don't want to discard standard headers.
5893       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5894       ;;
5895    *)
5896       # If we're building newlib, use its generic headers last, but search
5897       # for any libc-related directories first (so make it the last -B
5898       # switch).
5899       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5900
5901       # If we're building libgloss, find the startup file, simulator library
5902       # and linker script.
5903       case " $target_configdirs " in
5904         *" libgloss "*)
5905         # Look for startup file, simulator library and maybe linker script.
5906         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
5907         # Look for libnosys.a in case the target needs it.
5908         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5909         # Most targets have the linker script in the source directory.
5910         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
5911         ;;
5912       esac
5913       ;;
5914    esac
5915    ;;
5916   esac
5917   ;;
5918 esac
5919 case "$target" in
5920 *-mingw*)
5921   # Can't be handled as Cygwin above since Mingw does not use newlib.
5922   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' ;;
5923 esac
5924
5925 # Allow the user to override the flags for
5926 # our build compiler if desired.
5927 if test x"${build}" = x"${host}" ; then
5928   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5929   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
5930   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
5931 fi
5932
5933 # On Canadian crosses, we'll be searching the right directories for
5934 # the previously-installed cross compiler, so don't bother to add
5935 # flags for directories within the install tree of the compiler
5936 # being built; programs in there won't even run.
5937 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5938   # Search for pre-installed headers if nothing else fits.
5939   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5940 fi
5941
5942 if test "x${use_gnu_ld}" = x &&
5943    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5944   # Arrange for us to find uninstalled linker scripts.
5945   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5946 fi
5947
5948 # Search for other target-specific linker scripts and such.
5949 case "${target}" in
5950   mep*)
5951     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5952     ;;
5953 esac
5954
5955 # Makefile fragments.
5956 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5957 do
5958   eval fragval=\$$frag
5959   if test $fragval != /dev/null; then
5960     eval $frag=${srcdir}/$fragval
5961   fi
5962 done
5963
5964
5965
5966
5967
5968 # Miscellanea: directories, flags, etc.
5969
5970
5971
5972
5973
5974
5975
5976 # Build module lists & subconfigure args.
5977
5978
5979
5980 # Host module lists & subconfigure args.
5981
5982
5983
5984 # Target module lists & subconfigure args.
5985
5986
5987
5988 # Build tools.
5989
5990
5991
5992
5993
5994
5995
5996
5997
5998
5999
6000
6001
6002
6003
6004
6005
6006 # Generate default definitions for YACC, M4, LEX and other programs that run
6007 # on the build machine.  These are used if the Makefile can't locate these
6008 # programs in objdir.
6009 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6010
6011 for ac_prog in 'bison -y' byacc yacc
6012 do
6013   # Extract the first word of "$ac_prog", so it can be a program name with args.
6014 set dummy $ac_prog; ac_word=$2
6015 echo "$as_me:$LINENO: checking for $ac_word" >&5
6016 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6017 if test "${ac_cv_prog_YACC+set}" = set; then
6018   echo $ECHO_N "(cached) $ECHO_C" >&6
6019 else
6020   if test -n "$YACC"; then
6021   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6022 else
6023 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6024 for as_dir in $PATH
6025 do
6026   IFS=$as_save_IFS
6027   test -z "$as_dir" && as_dir=.
6028   for ac_exec_ext in '' $ac_executable_extensions; do
6029   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6030     ac_cv_prog_YACC="$ac_prog"
6031     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6032     break 2
6033   fi
6034 done
6035 done
6036
6037 fi
6038 fi
6039 YACC=$ac_cv_prog_YACC
6040 if test -n "$YACC"; then
6041   echo "$as_me:$LINENO: result: $YACC" >&5
6042 echo "${ECHO_T}$YACC" >&6
6043 else
6044   echo "$as_me:$LINENO: result: no" >&5
6045 echo "${ECHO_T}no" >&6
6046 fi
6047
6048   test -n "$YACC" && break
6049 done
6050 test -n "$YACC" || YACC="$MISSING bison -y"
6051
6052 case " $build_configdirs " in
6053   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6054   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6055 esac
6056
6057 for ac_prog in bison
6058 do
6059   # Extract the first word of "$ac_prog", so it can be a program name with args.
6060 set dummy $ac_prog; ac_word=$2
6061 echo "$as_me:$LINENO: checking for $ac_word" >&5
6062 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6063 if test "${ac_cv_prog_BISON+set}" = set; then
6064   echo $ECHO_N "(cached) $ECHO_C" >&6
6065 else
6066   if test -n "$BISON"; then
6067   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6068 else
6069 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6070 for as_dir in $PATH
6071 do
6072   IFS=$as_save_IFS
6073   test -z "$as_dir" && as_dir=.
6074   for ac_exec_ext in '' $ac_executable_extensions; do
6075   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6076     ac_cv_prog_BISON="$ac_prog"
6077     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6078     break 2
6079   fi
6080 done
6081 done
6082
6083 fi
6084 fi
6085 BISON=$ac_cv_prog_BISON
6086 if test -n "$BISON"; then
6087   echo "$as_me:$LINENO: result: $BISON" >&5
6088 echo "${ECHO_T}$BISON" >&6
6089 else
6090   echo "$as_me:$LINENO: result: no" >&5
6091 echo "${ECHO_T}no" >&6
6092 fi
6093
6094   test -n "$BISON" && break
6095 done
6096 test -n "$BISON" || BISON="$MISSING bison"
6097
6098 case " $build_configdirs " in
6099   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6100 esac
6101
6102 for ac_prog in gm4 gnum4 m4
6103 do
6104   # Extract the first word of "$ac_prog", so it can be a program name with args.
6105 set dummy $ac_prog; ac_word=$2
6106 echo "$as_me:$LINENO: checking for $ac_word" >&5
6107 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6108 if test "${ac_cv_prog_M4+set}" = set; then
6109   echo $ECHO_N "(cached) $ECHO_C" >&6
6110 else
6111   if test -n "$M4"; then
6112   ac_cv_prog_M4="$M4" # Let the user override the test.
6113 else
6114 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6115 for as_dir in $PATH
6116 do
6117   IFS=$as_save_IFS
6118   test -z "$as_dir" && as_dir=.
6119   for ac_exec_ext in '' $ac_executable_extensions; do
6120   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6121     ac_cv_prog_M4="$ac_prog"
6122     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6123     break 2
6124   fi
6125 done
6126 done
6127
6128 fi
6129 fi
6130 M4=$ac_cv_prog_M4
6131 if test -n "$M4"; then
6132   echo "$as_me:$LINENO: result: $M4" >&5
6133 echo "${ECHO_T}$M4" >&6
6134 else
6135   echo "$as_me:$LINENO: result: no" >&5
6136 echo "${ECHO_T}no" >&6
6137 fi
6138
6139   test -n "$M4" && break
6140 done
6141 test -n "$M4" || M4="$MISSING m4"
6142
6143 case " $build_configdirs " in
6144   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6145 esac
6146
6147 for ac_prog in flex lex
6148 do
6149   # Extract the first word of "$ac_prog", so it can be a program name with args.
6150 set dummy $ac_prog; ac_word=$2
6151 echo "$as_me:$LINENO: checking for $ac_word" >&5
6152 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6153 if test "${ac_cv_prog_LEX+set}" = set; then
6154   echo $ECHO_N "(cached) $ECHO_C" >&6
6155 else
6156   if test -n "$LEX"; then
6157   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6158 else
6159 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6160 for as_dir in $PATH
6161 do
6162   IFS=$as_save_IFS
6163   test -z "$as_dir" && as_dir=.
6164   for ac_exec_ext in '' $ac_executable_extensions; do
6165   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6166     ac_cv_prog_LEX="$ac_prog"
6167     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6168     break 2
6169   fi
6170 done
6171 done
6172
6173 fi
6174 fi
6175 LEX=$ac_cv_prog_LEX
6176 if test -n "$LEX"; then
6177   echo "$as_me:$LINENO: result: $LEX" >&5
6178 echo "${ECHO_T}$LEX" >&6
6179 else
6180   echo "$as_me:$LINENO: result: no" >&5
6181 echo "${ECHO_T}no" >&6
6182 fi
6183
6184   test -n "$LEX" && break
6185 done
6186 test -n "$LEX" || LEX="$MISSING flex"
6187
6188 case " $build_configdirs " in
6189   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6190   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6191 esac
6192
6193 for ac_prog in flex
6194 do
6195   # Extract the first word of "$ac_prog", so it can be a program name with args.
6196 set dummy $ac_prog; ac_word=$2
6197 echo "$as_me:$LINENO: checking for $ac_word" >&5
6198 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6199 if test "${ac_cv_prog_FLEX+set}" = set; then
6200   echo $ECHO_N "(cached) $ECHO_C" >&6
6201 else
6202   if test -n "$FLEX"; then
6203   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6204 else
6205 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6206 for as_dir in $PATH
6207 do
6208   IFS=$as_save_IFS
6209   test -z "$as_dir" && as_dir=.
6210   for ac_exec_ext in '' $ac_executable_extensions; do
6211   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6212     ac_cv_prog_FLEX="$ac_prog"
6213     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6214     break 2
6215   fi
6216 done
6217 done
6218
6219 fi
6220 fi
6221 FLEX=$ac_cv_prog_FLEX
6222 if test -n "$FLEX"; then
6223   echo "$as_me:$LINENO: result: $FLEX" >&5
6224 echo "${ECHO_T}$FLEX" >&6
6225 else
6226   echo "$as_me:$LINENO: result: no" >&5
6227 echo "${ECHO_T}no" >&6
6228 fi
6229
6230   test -n "$FLEX" && break
6231 done
6232 test -n "$FLEX" || FLEX="$MISSING flex"
6233
6234 case " $build_configdirs " in
6235   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6236 esac
6237
6238 for ac_prog in makeinfo
6239 do
6240   # Extract the first word of "$ac_prog", so it can be a program name with args.
6241 set dummy $ac_prog; ac_word=$2
6242 echo "$as_me:$LINENO: checking for $ac_word" >&5
6243 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6244 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6245   echo $ECHO_N "(cached) $ECHO_C" >&6
6246 else
6247   if test -n "$MAKEINFO"; then
6248   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6249 else
6250 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6251 for as_dir in $PATH
6252 do
6253   IFS=$as_save_IFS
6254   test -z "$as_dir" && as_dir=.
6255   for ac_exec_ext in '' $ac_executable_extensions; do
6256   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6257     ac_cv_prog_MAKEINFO="$ac_prog"
6258     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6259     break 2
6260   fi
6261 done
6262 done
6263
6264 fi
6265 fi
6266 MAKEINFO=$ac_cv_prog_MAKEINFO
6267 if test -n "$MAKEINFO"; then
6268   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6269 echo "${ECHO_T}$MAKEINFO" >&6
6270 else
6271   echo "$as_me:$LINENO: result: no" >&5
6272 echo "${ECHO_T}no" >&6
6273 fi
6274
6275   test -n "$MAKEINFO" && break
6276 done
6277 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6278
6279 case " $build_configdirs " in
6280   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6281   *)
6282
6283     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6284     # higher, else we use the "missing" dummy.
6285     if ${MAKEINFO} --version \
6286        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6287       :
6288     else
6289       MAKEINFO="$MISSING makeinfo"
6290     fi
6291     ;;
6292
6293 esac
6294
6295 # FIXME: expect and dejagnu may become build tools?
6296
6297 for ac_prog in expect
6298 do
6299   # Extract the first word of "$ac_prog", so it can be a program name with args.
6300 set dummy $ac_prog; ac_word=$2
6301 echo "$as_me:$LINENO: checking for $ac_word" >&5
6302 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6303 if test "${ac_cv_prog_EXPECT+set}" = set; then
6304   echo $ECHO_N "(cached) $ECHO_C" >&6
6305 else
6306   if test -n "$EXPECT"; then
6307   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6308 else
6309 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6310 for as_dir in $PATH
6311 do
6312   IFS=$as_save_IFS
6313   test -z "$as_dir" && as_dir=.
6314   for ac_exec_ext in '' $ac_executable_extensions; do
6315   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6316     ac_cv_prog_EXPECT="$ac_prog"
6317     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6318     break 2
6319   fi
6320 done
6321 done
6322
6323 fi
6324 fi
6325 EXPECT=$ac_cv_prog_EXPECT
6326 if test -n "$EXPECT"; then
6327   echo "$as_me:$LINENO: result: $EXPECT" >&5
6328 echo "${ECHO_T}$EXPECT" >&6
6329 else
6330   echo "$as_me:$LINENO: result: no" >&5
6331 echo "${ECHO_T}no" >&6
6332 fi
6333
6334   test -n "$EXPECT" && break
6335 done
6336 test -n "$EXPECT" || EXPECT="expect"
6337
6338 case " $configdirs " in
6339   *" expect "*)
6340     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6341     ;;
6342 esac
6343
6344 for ac_prog in runtest
6345 do
6346   # Extract the first word of "$ac_prog", so it can be a program name with args.
6347 set dummy $ac_prog; ac_word=$2
6348 echo "$as_me:$LINENO: checking for $ac_word" >&5
6349 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6350 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6351   echo $ECHO_N "(cached) $ECHO_C" >&6
6352 else
6353   if test -n "$RUNTEST"; then
6354   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6355 else
6356 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6357 for as_dir in $PATH
6358 do
6359   IFS=$as_save_IFS
6360   test -z "$as_dir" && as_dir=.
6361   for ac_exec_ext in '' $ac_executable_extensions; do
6362   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6363     ac_cv_prog_RUNTEST="$ac_prog"
6364     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6365     break 2
6366   fi
6367 done
6368 done
6369
6370 fi
6371 fi
6372 RUNTEST=$ac_cv_prog_RUNTEST
6373 if test -n "$RUNTEST"; then
6374   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6375 echo "${ECHO_T}$RUNTEST" >&6
6376 else
6377   echo "$as_me:$LINENO: result: no" >&5
6378 echo "${ECHO_T}no" >&6
6379 fi
6380
6381   test -n "$RUNTEST" && break
6382 done
6383 test -n "$RUNTEST" || RUNTEST="runtest"
6384
6385 case " $configdirs " in
6386   *" dejagnu "*)
6387     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6388     ;;
6389 esac
6390
6391
6392 # Host tools.
6393 ncn_tool_prefix=
6394 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6395 ncn_target_tool_prefix=
6396 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6397
6398
6399
6400 if test -n "$AR"; then
6401   ac_cv_prog_AR=$AR
6402 elif test -n "$ac_cv_prog_AR"; then
6403   AR=$ac_cv_prog_AR
6404 fi
6405
6406 if test -n "$ac_cv_prog_AR"; then
6407   for ncn_progname in ar; do
6408     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6409 set dummy ${ncn_progname}; ac_word=$2
6410 echo "$as_me:$LINENO: checking for $ac_word" >&5
6411 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6412 if test "${ac_cv_prog_AR+set}" = set; then
6413   echo $ECHO_N "(cached) $ECHO_C" >&6
6414 else
6415   if test -n "$AR"; then
6416   ac_cv_prog_AR="$AR" # Let the user override the test.
6417 else
6418 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6419 for as_dir in $PATH
6420 do
6421   IFS=$as_save_IFS
6422   test -z "$as_dir" && as_dir=.
6423   for ac_exec_ext in '' $ac_executable_extensions; do
6424   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6425     ac_cv_prog_AR="${ncn_progname}"
6426     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6427     break 2
6428   fi
6429 done
6430 done
6431
6432 fi
6433 fi
6434 AR=$ac_cv_prog_AR
6435 if test -n "$AR"; then
6436   echo "$as_me:$LINENO: result: $AR" >&5
6437 echo "${ECHO_T}$AR" >&6
6438 else
6439   echo "$as_me:$LINENO: result: no" >&5
6440 echo "${ECHO_T}no" >&6
6441 fi
6442
6443   done
6444 fi
6445
6446 for ncn_progname in ar; do
6447   if test -n "$ncn_tool_prefix"; then
6448     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6449 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6450 echo "$as_me:$LINENO: checking for $ac_word" >&5
6451 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6452 if test "${ac_cv_prog_AR+set}" = set; then
6453   echo $ECHO_N "(cached) $ECHO_C" >&6
6454 else
6455   if test -n "$AR"; then
6456   ac_cv_prog_AR="$AR" # Let the user override the test.
6457 else
6458 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6459 for as_dir in $PATH
6460 do
6461   IFS=$as_save_IFS
6462   test -z "$as_dir" && as_dir=.
6463   for ac_exec_ext in '' $ac_executable_extensions; do
6464   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6465     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6466     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6467     break 2
6468   fi
6469 done
6470 done
6471
6472 fi
6473 fi
6474 AR=$ac_cv_prog_AR
6475 if test -n "$AR"; then
6476   echo "$as_me:$LINENO: result: $AR" >&5
6477 echo "${ECHO_T}$AR" >&6
6478 else
6479   echo "$as_me:$LINENO: result: no" >&5
6480 echo "${ECHO_T}no" >&6
6481 fi
6482
6483   fi
6484   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6485     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6486 set dummy ${ncn_progname}; ac_word=$2
6487 echo "$as_me:$LINENO: checking for $ac_word" >&5
6488 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6489 if test "${ac_cv_prog_AR+set}" = set; then
6490   echo $ECHO_N "(cached) $ECHO_C" >&6
6491 else
6492   if test -n "$AR"; then
6493   ac_cv_prog_AR="$AR" # Let the user override the test.
6494 else
6495 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6496 for as_dir in $PATH
6497 do
6498   IFS=$as_save_IFS
6499   test -z "$as_dir" && as_dir=.
6500   for ac_exec_ext in '' $ac_executable_extensions; do
6501   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6502     ac_cv_prog_AR="${ncn_progname}"
6503     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6504     break 2
6505   fi
6506 done
6507 done
6508
6509 fi
6510 fi
6511 AR=$ac_cv_prog_AR
6512 if test -n "$AR"; then
6513   echo "$as_me:$LINENO: result: $AR" >&5
6514 echo "${ECHO_T}$AR" >&6
6515 else
6516   echo "$as_me:$LINENO: result: no" >&5
6517 echo "${ECHO_T}no" >&6
6518 fi
6519
6520   fi
6521   test -n "$ac_cv_prog_AR" && break
6522 done
6523
6524 if test -z "$ac_cv_prog_AR" ; then
6525   set dummy ar
6526   if test $build = $host ; then
6527     AR="$2"
6528   else
6529     AR="${ncn_tool_prefix}$2"
6530   fi
6531 fi
6532
6533
6534
6535 if test -n "$AS"; then
6536   ac_cv_prog_AS=$AS
6537 elif test -n "$ac_cv_prog_AS"; then
6538   AS=$ac_cv_prog_AS
6539 fi
6540
6541 if test -n "$ac_cv_prog_AS"; then
6542   for ncn_progname in as; do
6543     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6544 set dummy ${ncn_progname}; ac_word=$2
6545 echo "$as_me:$LINENO: checking for $ac_word" >&5
6546 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6547 if test "${ac_cv_prog_AS+set}" = set; then
6548   echo $ECHO_N "(cached) $ECHO_C" >&6
6549 else
6550   if test -n "$AS"; then
6551   ac_cv_prog_AS="$AS" # Let the user override the test.
6552 else
6553 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6554 for as_dir in $PATH
6555 do
6556   IFS=$as_save_IFS
6557   test -z "$as_dir" && as_dir=.
6558   for ac_exec_ext in '' $ac_executable_extensions; do
6559   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6560     ac_cv_prog_AS="${ncn_progname}"
6561     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6562     break 2
6563   fi
6564 done
6565 done
6566
6567 fi
6568 fi
6569 AS=$ac_cv_prog_AS
6570 if test -n "$AS"; then
6571   echo "$as_me:$LINENO: result: $AS" >&5
6572 echo "${ECHO_T}$AS" >&6
6573 else
6574   echo "$as_me:$LINENO: result: no" >&5
6575 echo "${ECHO_T}no" >&6
6576 fi
6577
6578   done
6579 fi
6580
6581 for ncn_progname in as; do
6582   if test -n "$ncn_tool_prefix"; then
6583     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6584 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6585 echo "$as_me:$LINENO: checking for $ac_word" >&5
6586 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6587 if test "${ac_cv_prog_AS+set}" = set; then
6588   echo $ECHO_N "(cached) $ECHO_C" >&6
6589 else
6590   if test -n "$AS"; then
6591   ac_cv_prog_AS="$AS" # Let the user override the test.
6592 else
6593 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6594 for as_dir in $PATH
6595 do
6596   IFS=$as_save_IFS
6597   test -z "$as_dir" && as_dir=.
6598   for ac_exec_ext in '' $ac_executable_extensions; do
6599   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6600     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6601     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6602     break 2
6603   fi
6604 done
6605 done
6606
6607 fi
6608 fi
6609 AS=$ac_cv_prog_AS
6610 if test -n "$AS"; then
6611   echo "$as_me:$LINENO: result: $AS" >&5
6612 echo "${ECHO_T}$AS" >&6
6613 else
6614   echo "$as_me:$LINENO: result: no" >&5
6615 echo "${ECHO_T}no" >&6
6616 fi
6617
6618   fi
6619   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6620     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6621 set dummy ${ncn_progname}; ac_word=$2
6622 echo "$as_me:$LINENO: checking for $ac_word" >&5
6623 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6624 if test "${ac_cv_prog_AS+set}" = set; then
6625   echo $ECHO_N "(cached) $ECHO_C" >&6
6626 else
6627   if test -n "$AS"; then
6628   ac_cv_prog_AS="$AS" # Let the user override the test.
6629 else
6630 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6631 for as_dir in $PATH
6632 do
6633   IFS=$as_save_IFS
6634   test -z "$as_dir" && as_dir=.
6635   for ac_exec_ext in '' $ac_executable_extensions; do
6636   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6637     ac_cv_prog_AS="${ncn_progname}"
6638     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6639     break 2
6640   fi
6641 done
6642 done
6643
6644 fi
6645 fi
6646 AS=$ac_cv_prog_AS
6647 if test -n "$AS"; then
6648   echo "$as_me:$LINENO: result: $AS" >&5
6649 echo "${ECHO_T}$AS" >&6
6650 else
6651   echo "$as_me:$LINENO: result: no" >&5
6652 echo "${ECHO_T}no" >&6
6653 fi
6654
6655   fi
6656   test -n "$ac_cv_prog_AS" && break
6657 done
6658
6659 if test -z "$ac_cv_prog_AS" ; then
6660   set dummy as
6661   if test $build = $host ; then
6662     AS="$2"
6663   else
6664     AS="${ncn_tool_prefix}$2"
6665   fi
6666 fi
6667
6668
6669
6670 if test -n "$DLLTOOL"; then
6671   ac_cv_prog_DLLTOOL=$DLLTOOL
6672 elif test -n "$ac_cv_prog_DLLTOOL"; then
6673   DLLTOOL=$ac_cv_prog_DLLTOOL
6674 fi
6675
6676 if test -n "$ac_cv_prog_DLLTOOL"; then
6677   for ncn_progname in dlltool; do
6678     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6679 set dummy ${ncn_progname}; ac_word=$2
6680 echo "$as_me:$LINENO: checking for $ac_word" >&5
6681 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6682 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6683   echo $ECHO_N "(cached) $ECHO_C" >&6
6684 else
6685   if test -n "$DLLTOOL"; then
6686   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6687 else
6688 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6689 for as_dir in $PATH
6690 do
6691   IFS=$as_save_IFS
6692   test -z "$as_dir" && as_dir=.
6693   for ac_exec_ext in '' $ac_executable_extensions; do
6694   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6695     ac_cv_prog_DLLTOOL="${ncn_progname}"
6696     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6697     break 2
6698   fi
6699 done
6700 done
6701
6702 fi
6703 fi
6704 DLLTOOL=$ac_cv_prog_DLLTOOL
6705 if test -n "$DLLTOOL"; then
6706   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6707 echo "${ECHO_T}$DLLTOOL" >&6
6708 else
6709   echo "$as_me:$LINENO: result: no" >&5
6710 echo "${ECHO_T}no" >&6
6711 fi
6712
6713   done
6714 fi
6715
6716 for ncn_progname in dlltool; do
6717   if test -n "$ncn_tool_prefix"; then
6718     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6719 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6720 echo "$as_me:$LINENO: checking for $ac_word" >&5
6721 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6722 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6723   echo $ECHO_N "(cached) $ECHO_C" >&6
6724 else
6725   if test -n "$DLLTOOL"; then
6726   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6727 else
6728 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6729 for as_dir in $PATH
6730 do
6731   IFS=$as_save_IFS
6732   test -z "$as_dir" && as_dir=.
6733   for ac_exec_ext in '' $ac_executable_extensions; do
6734   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6735     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6736     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6737     break 2
6738   fi
6739 done
6740 done
6741
6742 fi
6743 fi
6744 DLLTOOL=$ac_cv_prog_DLLTOOL
6745 if test -n "$DLLTOOL"; then
6746   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6747 echo "${ECHO_T}$DLLTOOL" >&6
6748 else
6749   echo "$as_me:$LINENO: result: no" >&5
6750 echo "${ECHO_T}no" >&6
6751 fi
6752
6753   fi
6754   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6755     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6756 set dummy ${ncn_progname}; ac_word=$2
6757 echo "$as_me:$LINENO: checking for $ac_word" >&5
6758 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6759 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6760   echo $ECHO_N "(cached) $ECHO_C" >&6
6761 else
6762   if test -n "$DLLTOOL"; then
6763   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6764 else
6765 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6766 for as_dir in $PATH
6767 do
6768   IFS=$as_save_IFS
6769   test -z "$as_dir" && as_dir=.
6770   for ac_exec_ext in '' $ac_executable_extensions; do
6771   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6772     ac_cv_prog_DLLTOOL="${ncn_progname}"
6773     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6774     break 2
6775   fi
6776 done
6777 done
6778
6779 fi
6780 fi
6781 DLLTOOL=$ac_cv_prog_DLLTOOL
6782 if test -n "$DLLTOOL"; then
6783   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6784 echo "${ECHO_T}$DLLTOOL" >&6
6785 else
6786   echo "$as_me:$LINENO: result: no" >&5
6787 echo "${ECHO_T}no" >&6
6788 fi
6789
6790   fi
6791   test -n "$ac_cv_prog_DLLTOOL" && break
6792 done
6793
6794 if test -z "$ac_cv_prog_DLLTOOL" ; then
6795   set dummy dlltool
6796   if test $build = $host ; then
6797     DLLTOOL="$2"
6798   else
6799     DLLTOOL="${ncn_tool_prefix}$2"
6800   fi
6801 fi
6802
6803
6804
6805 if test -n "$LD"; then
6806   ac_cv_prog_LD=$LD
6807 elif test -n "$ac_cv_prog_LD"; then
6808   LD=$ac_cv_prog_LD
6809 fi
6810
6811 if test -n "$ac_cv_prog_LD"; then
6812   for ncn_progname in ld; do
6813     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6814 set dummy ${ncn_progname}; ac_word=$2
6815 echo "$as_me:$LINENO: checking for $ac_word" >&5
6816 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6817 if test "${ac_cv_prog_LD+set}" = set; then
6818   echo $ECHO_N "(cached) $ECHO_C" >&6
6819 else
6820   if test -n "$LD"; then
6821   ac_cv_prog_LD="$LD" # Let the user override the test.
6822 else
6823 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6824 for as_dir in $PATH
6825 do
6826   IFS=$as_save_IFS
6827   test -z "$as_dir" && as_dir=.
6828   for ac_exec_ext in '' $ac_executable_extensions; do
6829   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6830     ac_cv_prog_LD="${ncn_progname}"
6831     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6832     break 2
6833   fi
6834 done
6835 done
6836
6837 fi
6838 fi
6839 LD=$ac_cv_prog_LD
6840 if test -n "$LD"; then
6841   echo "$as_me:$LINENO: result: $LD" >&5
6842 echo "${ECHO_T}$LD" >&6
6843 else
6844   echo "$as_me:$LINENO: result: no" >&5
6845 echo "${ECHO_T}no" >&6
6846 fi
6847
6848   done
6849 fi
6850
6851 for ncn_progname in ld; do
6852   if test -n "$ncn_tool_prefix"; then
6853     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6854 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6855 echo "$as_me:$LINENO: checking for $ac_word" >&5
6856 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6857 if test "${ac_cv_prog_LD+set}" = set; then
6858   echo $ECHO_N "(cached) $ECHO_C" >&6
6859 else
6860   if test -n "$LD"; then
6861   ac_cv_prog_LD="$LD" # Let the user override the test.
6862 else
6863 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6864 for as_dir in $PATH
6865 do
6866   IFS=$as_save_IFS
6867   test -z "$as_dir" && as_dir=.
6868   for ac_exec_ext in '' $ac_executable_extensions; do
6869   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6870     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6871     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6872     break 2
6873   fi
6874 done
6875 done
6876
6877 fi
6878 fi
6879 LD=$ac_cv_prog_LD
6880 if test -n "$LD"; then
6881   echo "$as_me:$LINENO: result: $LD" >&5
6882 echo "${ECHO_T}$LD" >&6
6883 else
6884   echo "$as_me:$LINENO: result: no" >&5
6885 echo "${ECHO_T}no" >&6
6886 fi
6887
6888   fi
6889   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6890     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6891 set dummy ${ncn_progname}; ac_word=$2
6892 echo "$as_me:$LINENO: checking for $ac_word" >&5
6893 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6894 if test "${ac_cv_prog_LD+set}" = set; then
6895   echo $ECHO_N "(cached) $ECHO_C" >&6
6896 else
6897   if test -n "$LD"; then
6898   ac_cv_prog_LD="$LD" # Let the user override the test.
6899 else
6900 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6901 for as_dir in $PATH
6902 do
6903   IFS=$as_save_IFS
6904   test -z "$as_dir" && as_dir=.
6905   for ac_exec_ext in '' $ac_executable_extensions; do
6906   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6907     ac_cv_prog_LD="${ncn_progname}"
6908     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6909     break 2
6910   fi
6911 done
6912 done
6913
6914 fi
6915 fi
6916 LD=$ac_cv_prog_LD
6917 if test -n "$LD"; then
6918   echo "$as_me:$LINENO: result: $LD" >&5
6919 echo "${ECHO_T}$LD" >&6
6920 else
6921   echo "$as_me:$LINENO: result: no" >&5
6922 echo "${ECHO_T}no" >&6
6923 fi
6924
6925   fi
6926   test -n "$ac_cv_prog_LD" && break
6927 done
6928
6929 if test -z "$ac_cv_prog_LD" ; then
6930   set dummy ld
6931   if test $build = $host ; then
6932     LD="$2"
6933   else
6934     LD="${ncn_tool_prefix}$2"
6935   fi
6936 fi
6937
6938
6939
6940 if test -n "$LIPO"; then
6941   ac_cv_prog_LIPO=$LIPO
6942 elif test -n "$ac_cv_prog_LIPO"; then
6943   LIPO=$ac_cv_prog_LIPO
6944 fi
6945
6946 if test -n "$ac_cv_prog_LIPO"; then
6947   for ncn_progname in lipo; do
6948     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6949 set dummy ${ncn_progname}; ac_word=$2
6950 echo "$as_me:$LINENO: checking for $ac_word" >&5
6951 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6952 if test "${ac_cv_prog_LIPO+set}" = set; then
6953   echo $ECHO_N "(cached) $ECHO_C" >&6
6954 else
6955   if test -n "$LIPO"; then
6956   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6957 else
6958 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6959 for as_dir in $PATH
6960 do
6961   IFS=$as_save_IFS
6962   test -z "$as_dir" && as_dir=.
6963   for ac_exec_ext in '' $ac_executable_extensions; do
6964   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6965     ac_cv_prog_LIPO="${ncn_progname}"
6966     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6967     break 2
6968   fi
6969 done
6970 done
6971
6972 fi
6973 fi
6974 LIPO=$ac_cv_prog_LIPO
6975 if test -n "$LIPO"; then
6976   echo "$as_me:$LINENO: result: $LIPO" >&5
6977 echo "${ECHO_T}$LIPO" >&6
6978 else
6979   echo "$as_me:$LINENO: result: no" >&5
6980 echo "${ECHO_T}no" >&6
6981 fi
6982
6983   done
6984 fi
6985
6986 for ncn_progname in lipo; do
6987   if test -n "$ncn_tool_prefix"; then
6988     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6989 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6990 echo "$as_me:$LINENO: checking for $ac_word" >&5
6991 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6992 if test "${ac_cv_prog_LIPO+set}" = set; then
6993   echo $ECHO_N "(cached) $ECHO_C" >&6
6994 else
6995   if test -n "$LIPO"; then
6996   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6997 else
6998 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6999 for as_dir in $PATH
7000 do
7001   IFS=$as_save_IFS
7002   test -z "$as_dir" && as_dir=.
7003   for ac_exec_ext in '' $ac_executable_extensions; do
7004   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7005     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7006     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7007     break 2
7008   fi
7009 done
7010 done
7011
7012 fi
7013 fi
7014 LIPO=$ac_cv_prog_LIPO
7015 if test -n "$LIPO"; then
7016   echo "$as_me:$LINENO: result: $LIPO" >&5
7017 echo "${ECHO_T}$LIPO" >&6
7018 else
7019   echo "$as_me:$LINENO: result: no" >&5
7020 echo "${ECHO_T}no" >&6
7021 fi
7022
7023   fi
7024   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7025     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7026 set dummy ${ncn_progname}; ac_word=$2
7027 echo "$as_me:$LINENO: checking for $ac_word" >&5
7028 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7029 if test "${ac_cv_prog_LIPO+set}" = set; then
7030   echo $ECHO_N "(cached) $ECHO_C" >&6
7031 else
7032   if test -n "$LIPO"; then
7033   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7034 else
7035 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7036 for as_dir in $PATH
7037 do
7038   IFS=$as_save_IFS
7039   test -z "$as_dir" && as_dir=.
7040   for ac_exec_ext in '' $ac_executable_extensions; do
7041   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7042     ac_cv_prog_LIPO="${ncn_progname}"
7043     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7044     break 2
7045   fi
7046 done
7047 done
7048
7049 fi
7050 fi
7051 LIPO=$ac_cv_prog_LIPO
7052 if test -n "$LIPO"; then
7053   echo "$as_me:$LINENO: result: $LIPO" >&5
7054 echo "${ECHO_T}$LIPO" >&6
7055 else
7056   echo "$as_me:$LINENO: result: no" >&5
7057 echo "${ECHO_T}no" >&6
7058 fi
7059
7060   fi
7061   test -n "$ac_cv_prog_LIPO" && break
7062 done
7063
7064 if test -z "$ac_cv_prog_LIPO" ; then
7065   set dummy lipo
7066   if test $build = $host ; then
7067     LIPO="$2"
7068   else
7069     LIPO="${ncn_tool_prefix}$2"
7070   fi
7071 fi
7072
7073
7074
7075 if test -n "$NM"; then
7076   ac_cv_prog_NM=$NM
7077 elif test -n "$ac_cv_prog_NM"; then
7078   NM=$ac_cv_prog_NM
7079 fi
7080
7081 if test -n "$ac_cv_prog_NM"; then
7082   for ncn_progname in nm; do
7083     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7084 set dummy ${ncn_progname}; ac_word=$2
7085 echo "$as_me:$LINENO: checking for $ac_word" >&5
7086 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7087 if test "${ac_cv_prog_NM+set}" = set; then
7088   echo $ECHO_N "(cached) $ECHO_C" >&6
7089 else
7090   if test -n "$NM"; then
7091   ac_cv_prog_NM="$NM" # Let the user override the test.
7092 else
7093 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7094 for as_dir in $PATH
7095 do
7096   IFS=$as_save_IFS
7097   test -z "$as_dir" && as_dir=.
7098   for ac_exec_ext in '' $ac_executable_extensions; do
7099   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7100     ac_cv_prog_NM="${ncn_progname}"
7101     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7102     break 2
7103   fi
7104 done
7105 done
7106
7107 fi
7108 fi
7109 NM=$ac_cv_prog_NM
7110 if test -n "$NM"; then
7111   echo "$as_me:$LINENO: result: $NM" >&5
7112 echo "${ECHO_T}$NM" >&6
7113 else
7114   echo "$as_me:$LINENO: result: no" >&5
7115 echo "${ECHO_T}no" >&6
7116 fi
7117
7118   done
7119 fi
7120
7121 for ncn_progname in nm; do
7122   if test -n "$ncn_tool_prefix"; then
7123     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7124 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7125 echo "$as_me:$LINENO: checking for $ac_word" >&5
7126 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7127 if test "${ac_cv_prog_NM+set}" = set; then
7128   echo $ECHO_N "(cached) $ECHO_C" >&6
7129 else
7130   if test -n "$NM"; then
7131   ac_cv_prog_NM="$NM" # Let the user override the test.
7132 else
7133 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7134 for as_dir in $PATH
7135 do
7136   IFS=$as_save_IFS
7137   test -z "$as_dir" && as_dir=.
7138   for ac_exec_ext in '' $ac_executable_extensions; do
7139   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7140     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7141     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7142     break 2
7143   fi
7144 done
7145 done
7146
7147 fi
7148 fi
7149 NM=$ac_cv_prog_NM
7150 if test -n "$NM"; then
7151   echo "$as_me:$LINENO: result: $NM" >&5
7152 echo "${ECHO_T}$NM" >&6
7153 else
7154   echo "$as_me:$LINENO: result: no" >&5
7155 echo "${ECHO_T}no" >&6
7156 fi
7157
7158   fi
7159   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7160     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7161 set dummy ${ncn_progname}; ac_word=$2
7162 echo "$as_me:$LINENO: checking for $ac_word" >&5
7163 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7164 if test "${ac_cv_prog_NM+set}" = set; then
7165   echo $ECHO_N "(cached) $ECHO_C" >&6
7166 else
7167   if test -n "$NM"; then
7168   ac_cv_prog_NM="$NM" # Let the user override the test.
7169 else
7170 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7171 for as_dir in $PATH
7172 do
7173   IFS=$as_save_IFS
7174   test -z "$as_dir" && as_dir=.
7175   for ac_exec_ext in '' $ac_executable_extensions; do
7176   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7177     ac_cv_prog_NM="${ncn_progname}"
7178     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7179     break 2
7180   fi
7181 done
7182 done
7183
7184 fi
7185 fi
7186 NM=$ac_cv_prog_NM
7187 if test -n "$NM"; then
7188   echo "$as_me:$LINENO: result: $NM" >&5
7189 echo "${ECHO_T}$NM" >&6
7190 else
7191   echo "$as_me:$LINENO: result: no" >&5
7192 echo "${ECHO_T}no" >&6
7193 fi
7194
7195   fi
7196   test -n "$ac_cv_prog_NM" && break
7197 done
7198
7199 if test -z "$ac_cv_prog_NM" ; then
7200   set dummy nm
7201   if test $build = $host ; then
7202     NM="$2"
7203   else
7204     NM="${ncn_tool_prefix}$2"
7205   fi
7206 fi
7207
7208
7209
7210 if test -n "$RANLIB"; then
7211   ac_cv_prog_RANLIB=$RANLIB
7212 elif test -n "$ac_cv_prog_RANLIB"; then
7213   RANLIB=$ac_cv_prog_RANLIB
7214 fi
7215
7216 if test -n "$ac_cv_prog_RANLIB"; then
7217   for ncn_progname in ranlib; do
7218     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7219 set dummy ${ncn_progname}; ac_word=$2
7220 echo "$as_me:$LINENO: checking for $ac_word" >&5
7221 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7222 if test "${ac_cv_prog_RANLIB+set}" = set; then
7223   echo $ECHO_N "(cached) $ECHO_C" >&6
7224 else
7225   if test -n "$RANLIB"; then
7226   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7227 else
7228 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7229 for as_dir in $PATH
7230 do
7231   IFS=$as_save_IFS
7232   test -z "$as_dir" && as_dir=.
7233   for ac_exec_ext in '' $ac_executable_extensions; do
7234   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7235     ac_cv_prog_RANLIB="${ncn_progname}"
7236     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7237     break 2
7238   fi
7239 done
7240 done
7241
7242 fi
7243 fi
7244 RANLIB=$ac_cv_prog_RANLIB
7245 if test -n "$RANLIB"; then
7246   echo "$as_me:$LINENO: result: $RANLIB" >&5
7247 echo "${ECHO_T}$RANLIB" >&6
7248 else
7249   echo "$as_me:$LINENO: result: no" >&5
7250 echo "${ECHO_T}no" >&6
7251 fi
7252
7253   done
7254 fi
7255
7256 for ncn_progname in ranlib; do
7257   if test -n "$ncn_tool_prefix"; then
7258     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7259 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7260 echo "$as_me:$LINENO: checking for $ac_word" >&5
7261 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7262 if test "${ac_cv_prog_RANLIB+set}" = set; then
7263   echo $ECHO_N "(cached) $ECHO_C" >&6
7264 else
7265   if test -n "$RANLIB"; then
7266   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7267 else
7268 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7269 for as_dir in $PATH
7270 do
7271   IFS=$as_save_IFS
7272   test -z "$as_dir" && as_dir=.
7273   for ac_exec_ext in '' $ac_executable_extensions; do
7274   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7275     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7276     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7277     break 2
7278   fi
7279 done
7280 done
7281
7282 fi
7283 fi
7284 RANLIB=$ac_cv_prog_RANLIB
7285 if test -n "$RANLIB"; then
7286   echo "$as_me:$LINENO: result: $RANLIB" >&5
7287 echo "${ECHO_T}$RANLIB" >&6
7288 else
7289   echo "$as_me:$LINENO: result: no" >&5
7290 echo "${ECHO_T}no" >&6
7291 fi
7292
7293   fi
7294   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7295     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7296 set dummy ${ncn_progname}; ac_word=$2
7297 echo "$as_me:$LINENO: checking for $ac_word" >&5
7298 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7299 if test "${ac_cv_prog_RANLIB+set}" = set; then
7300   echo $ECHO_N "(cached) $ECHO_C" >&6
7301 else
7302   if test -n "$RANLIB"; then
7303   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7304 else
7305 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7306 for as_dir in $PATH
7307 do
7308   IFS=$as_save_IFS
7309   test -z "$as_dir" && as_dir=.
7310   for ac_exec_ext in '' $ac_executable_extensions; do
7311   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7312     ac_cv_prog_RANLIB="${ncn_progname}"
7313     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7314     break 2
7315   fi
7316 done
7317 done
7318
7319 fi
7320 fi
7321 RANLIB=$ac_cv_prog_RANLIB
7322 if test -n "$RANLIB"; then
7323   echo "$as_me:$LINENO: result: $RANLIB" >&5
7324 echo "${ECHO_T}$RANLIB" >&6
7325 else
7326   echo "$as_me:$LINENO: result: no" >&5
7327 echo "${ECHO_T}no" >&6
7328 fi
7329
7330   fi
7331   test -n "$ac_cv_prog_RANLIB" && break
7332 done
7333
7334 if test -z "$ac_cv_prog_RANLIB" ; then
7335   RANLIB=":"
7336 fi
7337
7338
7339
7340 if test -n "$STRIP"; then
7341   ac_cv_prog_STRIP=$STRIP
7342 elif test -n "$ac_cv_prog_STRIP"; then
7343   STRIP=$ac_cv_prog_STRIP
7344 fi
7345
7346 if test -n "$ac_cv_prog_STRIP"; then
7347   for ncn_progname in strip; do
7348     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7349 set dummy ${ncn_progname}; ac_word=$2
7350 echo "$as_me:$LINENO: checking for $ac_word" >&5
7351 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7352 if test "${ac_cv_prog_STRIP+set}" = set; then
7353   echo $ECHO_N "(cached) $ECHO_C" >&6
7354 else
7355   if test -n "$STRIP"; then
7356   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7357 else
7358 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7359 for as_dir in $PATH
7360 do
7361   IFS=$as_save_IFS
7362   test -z "$as_dir" && as_dir=.
7363   for ac_exec_ext in '' $ac_executable_extensions; do
7364   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7365     ac_cv_prog_STRIP="${ncn_progname}"
7366     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7367     break 2
7368   fi
7369 done
7370 done
7371
7372 fi
7373 fi
7374 STRIP=$ac_cv_prog_STRIP
7375 if test -n "$STRIP"; then
7376   echo "$as_me:$LINENO: result: $STRIP" >&5
7377 echo "${ECHO_T}$STRIP" >&6
7378 else
7379   echo "$as_me:$LINENO: result: no" >&5
7380 echo "${ECHO_T}no" >&6
7381 fi
7382
7383   done
7384 fi
7385
7386 for ncn_progname in strip; do
7387   if test -n "$ncn_tool_prefix"; then
7388     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7389 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7390 echo "$as_me:$LINENO: checking for $ac_word" >&5
7391 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7392 if test "${ac_cv_prog_STRIP+set}" = set; then
7393   echo $ECHO_N "(cached) $ECHO_C" >&6
7394 else
7395   if test -n "$STRIP"; then
7396   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7397 else
7398 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7399 for as_dir in $PATH
7400 do
7401   IFS=$as_save_IFS
7402   test -z "$as_dir" && as_dir=.
7403   for ac_exec_ext in '' $ac_executable_extensions; do
7404   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7405     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7406     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7407     break 2
7408   fi
7409 done
7410 done
7411
7412 fi
7413 fi
7414 STRIP=$ac_cv_prog_STRIP
7415 if test -n "$STRIP"; then
7416   echo "$as_me:$LINENO: result: $STRIP" >&5
7417 echo "${ECHO_T}$STRIP" >&6
7418 else
7419   echo "$as_me:$LINENO: result: no" >&5
7420 echo "${ECHO_T}no" >&6
7421 fi
7422
7423   fi
7424   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7425     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7426 set dummy ${ncn_progname}; ac_word=$2
7427 echo "$as_me:$LINENO: checking for $ac_word" >&5
7428 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7429 if test "${ac_cv_prog_STRIP+set}" = set; then
7430   echo $ECHO_N "(cached) $ECHO_C" >&6
7431 else
7432   if test -n "$STRIP"; then
7433   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7434 else
7435 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7436 for as_dir in $PATH
7437 do
7438   IFS=$as_save_IFS
7439   test -z "$as_dir" && as_dir=.
7440   for ac_exec_ext in '' $ac_executable_extensions; do
7441   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7442     ac_cv_prog_STRIP="${ncn_progname}"
7443     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7444     break 2
7445   fi
7446 done
7447 done
7448
7449 fi
7450 fi
7451 STRIP=$ac_cv_prog_STRIP
7452 if test -n "$STRIP"; then
7453   echo "$as_me:$LINENO: result: $STRIP" >&5
7454 echo "${ECHO_T}$STRIP" >&6
7455 else
7456   echo "$as_me:$LINENO: result: no" >&5
7457 echo "${ECHO_T}no" >&6
7458 fi
7459
7460   fi
7461   test -n "$ac_cv_prog_STRIP" && break
7462 done
7463
7464 if test -z "$ac_cv_prog_STRIP" ; then
7465   STRIP=":"
7466 fi
7467
7468
7469
7470 if test -n "$WINDRES"; then
7471   ac_cv_prog_WINDRES=$WINDRES
7472 elif test -n "$ac_cv_prog_WINDRES"; then
7473   WINDRES=$ac_cv_prog_WINDRES
7474 fi
7475
7476 if test -n "$ac_cv_prog_WINDRES"; then
7477   for ncn_progname in windres; do
7478     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7479 set dummy ${ncn_progname}; ac_word=$2
7480 echo "$as_me:$LINENO: checking for $ac_word" >&5
7481 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7482 if test "${ac_cv_prog_WINDRES+set}" = set; then
7483   echo $ECHO_N "(cached) $ECHO_C" >&6
7484 else
7485   if test -n "$WINDRES"; then
7486   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7487 else
7488 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7489 for as_dir in $PATH
7490 do
7491   IFS=$as_save_IFS
7492   test -z "$as_dir" && as_dir=.
7493   for ac_exec_ext in '' $ac_executable_extensions; do
7494   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7495     ac_cv_prog_WINDRES="${ncn_progname}"
7496     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7497     break 2
7498   fi
7499 done
7500 done
7501
7502 fi
7503 fi
7504 WINDRES=$ac_cv_prog_WINDRES
7505 if test -n "$WINDRES"; then
7506   echo "$as_me:$LINENO: result: $WINDRES" >&5
7507 echo "${ECHO_T}$WINDRES" >&6
7508 else
7509   echo "$as_me:$LINENO: result: no" >&5
7510 echo "${ECHO_T}no" >&6
7511 fi
7512
7513   done
7514 fi
7515
7516 for ncn_progname in windres; do
7517   if test -n "$ncn_tool_prefix"; then
7518     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7519 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7520 echo "$as_me:$LINENO: checking for $ac_word" >&5
7521 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7522 if test "${ac_cv_prog_WINDRES+set}" = set; then
7523   echo $ECHO_N "(cached) $ECHO_C" >&6
7524 else
7525   if test -n "$WINDRES"; then
7526   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7527 else
7528 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7529 for as_dir in $PATH
7530 do
7531   IFS=$as_save_IFS
7532   test -z "$as_dir" && as_dir=.
7533   for ac_exec_ext in '' $ac_executable_extensions; do
7534   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7535     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7536     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7537     break 2
7538   fi
7539 done
7540 done
7541
7542 fi
7543 fi
7544 WINDRES=$ac_cv_prog_WINDRES
7545 if test -n "$WINDRES"; then
7546   echo "$as_me:$LINENO: result: $WINDRES" >&5
7547 echo "${ECHO_T}$WINDRES" >&6
7548 else
7549   echo "$as_me:$LINENO: result: no" >&5
7550 echo "${ECHO_T}no" >&6
7551 fi
7552
7553   fi
7554   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7555     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7556 set dummy ${ncn_progname}; ac_word=$2
7557 echo "$as_me:$LINENO: checking for $ac_word" >&5
7558 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7559 if test "${ac_cv_prog_WINDRES+set}" = set; then
7560   echo $ECHO_N "(cached) $ECHO_C" >&6
7561 else
7562   if test -n "$WINDRES"; then
7563   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7564 else
7565 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7566 for as_dir in $PATH
7567 do
7568   IFS=$as_save_IFS
7569   test -z "$as_dir" && as_dir=.
7570   for ac_exec_ext in '' $ac_executable_extensions; do
7571   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7572     ac_cv_prog_WINDRES="${ncn_progname}"
7573     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7574     break 2
7575   fi
7576 done
7577 done
7578
7579 fi
7580 fi
7581 WINDRES=$ac_cv_prog_WINDRES
7582 if test -n "$WINDRES"; then
7583   echo "$as_me:$LINENO: result: $WINDRES" >&5
7584 echo "${ECHO_T}$WINDRES" >&6
7585 else
7586   echo "$as_me:$LINENO: result: no" >&5
7587 echo "${ECHO_T}no" >&6
7588 fi
7589
7590   fi
7591   test -n "$ac_cv_prog_WINDRES" && break
7592 done
7593
7594 if test -z "$ac_cv_prog_WINDRES" ; then
7595   set dummy windres
7596   if test $build = $host ; then
7597     WINDRES="$2"
7598   else
7599     WINDRES="${ncn_tool_prefix}$2"
7600   fi
7601 fi
7602
7603
7604
7605 if test -n "$WINDMC"; then
7606   ac_cv_prog_WINDMC=$WINDMC
7607 elif test -n "$ac_cv_prog_WINDMC"; then
7608   WINDMC=$ac_cv_prog_WINDMC
7609 fi
7610
7611 if test -n "$ac_cv_prog_WINDMC"; then
7612   for ncn_progname in windmc; do
7613     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7614 set dummy ${ncn_progname}; ac_word=$2
7615 echo "$as_me:$LINENO: checking for $ac_word" >&5
7616 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7617 if test "${ac_cv_prog_WINDMC+set}" = set; then
7618   echo $ECHO_N "(cached) $ECHO_C" >&6
7619 else
7620   if test -n "$WINDMC"; then
7621   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7622 else
7623 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7624 for as_dir in $PATH
7625 do
7626   IFS=$as_save_IFS
7627   test -z "$as_dir" && as_dir=.
7628   for ac_exec_ext in '' $ac_executable_extensions; do
7629   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7630     ac_cv_prog_WINDMC="${ncn_progname}"
7631     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7632     break 2
7633   fi
7634 done
7635 done
7636
7637 fi
7638 fi
7639 WINDMC=$ac_cv_prog_WINDMC
7640 if test -n "$WINDMC"; then
7641   echo "$as_me:$LINENO: result: $WINDMC" >&5
7642 echo "${ECHO_T}$WINDMC" >&6
7643 else
7644   echo "$as_me:$LINENO: result: no" >&5
7645 echo "${ECHO_T}no" >&6
7646 fi
7647
7648   done
7649 fi
7650
7651 for ncn_progname in windmc; do
7652   if test -n "$ncn_tool_prefix"; then
7653     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7654 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7655 echo "$as_me:$LINENO: checking for $ac_word" >&5
7656 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7657 if test "${ac_cv_prog_WINDMC+set}" = set; then
7658   echo $ECHO_N "(cached) $ECHO_C" >&6
7659 else
7660   if test -n "$WINDMC"; then
7661   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7662 else
7663 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7664 for as_dir in $PATH
7665 do
7666   IFS=$as_save_IFS
7667   test -z "$as_dir" && as_dir=.
7668   for ac_exec_ext in '' $ac_executable_extensions; do
7669   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7670     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7671     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7672     break 2
7673   fi
7674 done
7675 done
7676
7677 fi
7678 fi
7679 WINDMC=$ac_cv_prog_WINDMC
7680 if test -n "$WINDMC"; then
7681   echo "$as_me:$LINENO: result: $WINDMC" >&5
7682 echo "${ECHO_T}$WINDMC" >&6
7683 else
7684   echo "$as_me:$LINENO: result: no" >&5
7685 echo "${ECHO_T}no" >&6
7686 fi
7687
7688   fi
7689   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7690     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7691 set dummy ${ncn_progname}; ac_word=$2
7692 echo "$as_me:$LINENO: checking for $ac_word" >&5
7693 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7694 if test "${ac_cv_prog_WINDMC+set}" = set; then
7695   echo $ECHO_N "(cached) $ECHO_C" >&6
7696 else
7697   if test -n "$WINDMC"; then
7698   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7699 else
7700 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7701 for as_dir in $PATH
7702 do
7703   IFS=$as_save_IFS
7704   test -z "$as_dir" && as_dir=.
7705   for ac_exec_ext in '' $ac_executable_extensions; do
7706   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7707     ac_cv_prog_WINDMC="${ncn_progname}"
7708     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7709     break 2
7710   fi
7711 done
7712 done
7713
7714 fi
7715 fi
7716 WINDMC=$ac_cv_prog_WINDMC
7717 if test -n "$WINDMC"; then
7718   echo "$as_me:$LINENO: result: $WINDMC" >&5
7719 echo "${ECHO_T}$WINDMC" >&6
7720 else
7721   echo "$as_me:$LINENO: result: no" >&5
7722 echo "${ECHO_T}no" >&6
7723 fi
7724
7725   fi
7726   test -n "$ac_cv_prog_WINDMC" && break
7727 done
7728
7729 if test -z "$ac_cv_prog_WINDMC" ; then
7730   set dummy windmc
7731   if test $build = $host ; then
7732     WINDMC="$2"
7733   else
7734     WINDMC="${ncn_tool_prefix}$2"
7735   fi
7736 fi
7737
7738
7739
7740 if test -n "$OBJCOPY"; then
7741   ac_cv_prog_OBJCOPY=$OBJCOPY
7742 elif test -n "$ac_cv_prog_OBJCOPY"; then
7743   OBJCOPY=$ac_cv_prog_OBJCOPY
7744 fi
7745
7746 if test -n "$ac_cv_prog_OBJCOPY"; then
7747   for ncn_progname in objcopy; do
7748     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7749 set dummy ${ncn_progname}; ac_word=$2
7750 echo "$as_me:$LINENO: checking for $ac_word" >&5
7751 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7752 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7753   echo $ECHO_N "(cached) $ECHO_C" >&6
7754 else
7755   if test -n "$OBJCOPY"; then
7756   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7757 else
7758 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7759 for as_dir in $PATH
7760 do
7761   IFS=$as_save_IFS
7762   test -z "$as_dir" && as_dir=.
7763   for ac_exec_ext in '' $ac_executable_extensions; do
7764   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7765     ac_cv_prog_OBJCOPY="${ncn_progname}"
7766     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7767     break 2
7768   fi
7769 done
7770 done
7771
7772 fi
7773 fi
7774 OBJCOPY=$ac_cv_prog_OBJCOPY
7775 if test -n "$OBJCOPY"; then
7776   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7777 echo "${ECHO_T}$OBJCOPY" >&6
7778 else
7779   echo "$as_me:$LINENO: result: no" >&5
7780 echo "${ECHO_T}no" >&6
7781 fi
7782
7783   done
7784 fi
7785
7786 for ncn_progname in objcopy; do
7787   if test -n "$ncn_tool_prefix"; then
7788     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7789 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7790 echo "$as_me:$LINENO: checking for $ac_word" >&5
7791 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7792 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7793   echo $ECHO_N "(cached) $ECHO_C" >&6
7794 else
7795   if test -n "$OBJCOPY"; then
7796   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7797 else
7798 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7799 for as_dir in $PATH
7800 do
7801   IFS=$as_save_IFS
7802   test -z "$as_dir" && as_dir=.
7803   for ac_exec_ext in '' $ac_executable_extensions; do
7804   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7805     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7806     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7807     break 2
7808   fi
7809 done
7810 done
7811
7812 fi
7813 fi
7814 OBJCOPY=$ac_cv_prog_OBJCOPY
7815 if test -n "$OBJCOPY"; then
7816   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7817 echo "${ECHO_T}$OBJCOPY" >&6
7818 else
7819   echo "$as_me:$LINENO: result: no" >&5
7820 echo "${ECHO_T}no" >&6
7821 fi
7822
7823   fi
7824   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7825     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7826 set dummy ${ncn_progname}; ac_word=$2
7827 echo "$as_me:$LINENO: checking for $ac_word" >&5
7828 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7829 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7830   echo $ECHO_N "(cached) $ECHO_C" >&6
7831 else
7832   if test -n "$OBJCOPY"; then
7833   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7834 else
7835 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7836 for as_dir in $PATH
7837 do
7838   IFS=$as_save_IFS
7839   test -z "$as_dir" && as_dir=.
7840   for ac_exec_ext in '' $ac_executable_extensions; do
7841   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7842     ac_cv_prog_OBJCOPY="${ncn_progname}"
7843     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7844     break 2
7845   fi
7846 done
7847 done
7848
7849 fi
7850 fi
7851 OBJCOPY=$ac_cv_prog_OBJCOPY
7852 if test -n "$OBJCOPY"; then
7853   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7854 echo "${ECHO_T}$OBJCOPY" >&6
7855 else
7856   echo "$as_me:$LINENO: result: no" >&5
7857 echo "${ECHO_T}no" >&6
7858 fi
7859
7860   fi
7861   test -n "$ac_cv_prog_OBJCOPY" && break
7862 done
7863
7864 if test -z "$ac_cv_prog_OBJCOPY" ; then
7865   set dummy objcopy
7866   if test $build = $host ; then
7867     OBJCOPY="$2"
7868   else
7869     OBJCOPY="${ncn_tool_prefix}$2"
7870   fi
7871 fi
7872
7873
7874
7875 if test -n "$OBJDUMP"; then
7876   ac_cv_prog_OBJDUMP=$OBJDUMP
7877 elif test -n "$ac_cv_prog_OBJDUMP"; then
7878   OBJDUMP=$ac_cv_prog_OBJDUMP
7879 fi
7880
7881 if test -n "$ac_cv_prog_OBJDUMP"; then
7882   for ncn_progname in objdump; do
7883     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7884 set dummy ${ncn_progname}; ac_word=$2
7885 echo "$as_me:$LINENO: checking for $ac_word" >&5
7886 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7887 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7888   echo $ECHO_N "(cached) $ECHO_C" >&6
7889 else
7890   if test -n "$OBJDUMP"; then
7891   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7892 else
7893 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7894 for as_dir in $PATH
7895 do
7896   IFS=$as_save_IFS
7897   test -z "$as_dir" && as_dir=.
7898   for ac_exec_ext in '' $ac_executable_extensions; do
7899   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7900     ac_cv_prog_OBJDUMP="${ncn_progname}"
7901     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7902     break 2
7903   fi
7904 done
7905 done
7906
7907 fi
7908 fi
7909 OBJDUMP=$ac_cv_prog_OBJDUMP
7910 if test -n "$OBJDUMP"; then
7911   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7912 echo "${ECHO_T}$OBJDUMP" >&6
7913 else
7914   echo "$as_me:$LINENO: result: no" >&5
7915 echo "${ECHO_T}no" >&6
7916 fi
7917
7918   done
7919 fi
7920
7921 for ncn_progname in objdump; do
7922   if test -n "$ncn_tool_prefix"; then
7923     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7924 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7925 echo "$as_me:$LINENO: checking for $ac_word" >&5
7926 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7927 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7928   echo $ECHO_N "(cached) $ECHO_C" >&6
7929 else
7930   if test -n "$OBJDUMP"; then
7931   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7932 else
7933 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7934 for as_dir in $PATH
7935 do
7936   IFS=$as_save_IFS
7937   test -z "$as_dir" && as_dir=.
7938   for ac_exec_ext in '' $ac_executable_extensions; do
7939   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7940     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7941     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7942     break 2
7943   fi
7944 done
7945 done
7946
7947 fi
7948 fi
7949 OBJDUMP=$ac_cv_prog_OBJDUMP
7950 if test -n "$OBJDUMP"; then
7951   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7952 echo "${ECHO_T}$OBJDUMP" >&6
7953 else
7954   echo "$as_me:$LINENO: result: no" >&5
7955 echo "${ECHO_T}no" >&6
7956 fi
7957
7958   fi
7959   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7960     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7961 set dummy ${ncn_progname}; ac_word=$2
7962 echo "$as_me:$LINENO: checking for $ac_word" >&5
7963 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7964 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7965   echo $ECHO_N "(cached) $ECHO_C" >&6
7966 else
7967   if test -n "$OBJDUMP"; then
7968   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7969 else
7970 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7971 for as_dir in $PATH
7972 do
7973   IFS=$as_save_IFS
7974   test -z "$as_dir" && as_dir=.
7975   for ac_exec_ext in '' $ac_executable_extensions; do
7976   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7977     ac_cv_prog_OBJDUMP="${ncn_progname}"
7978     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7979     break 2
7980   fi
7981 done
7982 done
7983
7984 fi
7985 fi
7986 OBJDUMP=$ac_cv_prog_OBJDUMP
7987 if test -n "$OBJDUMP"; then
7988   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7989 echo "${ECHO_T}$OBJDUMP" >&6
7990 else
7991   echo "$as_me:$LINENO: result: no" >&5
7992 echo "${ECHO_T}no" >&6
7993 fi
7994
7995   fi
7996   test -n "$ac_cv_prog_OBJDUMP" && break
7997 done
7998
7999 if test -z "$ac_cv_prog_OBJDUMP" ; then
8000   set dummy objdump
8001   if test $build = $host ; then
8002     OBJDUMP="$2"
8003   else
8004     OBJDUMP="${ncn_tool_prefix}$2"
8005   fi
8006 fi
8007
8008
8009
8010
8011
8012
8013 # Target tools.
8014
8015 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8016 if test "${with_build_time_tools+set}" = set; then
8017   withval="$with_build_time_tools"
8018   case x"$withval" in
8019      x/*) ;;
8020      *)
8021        with_build_time_tools=
8022        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8023 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8024        ;;
8025    esac
8026 else
8027   with_build_time_tools=
8028 fi;
8029
8030
8031
8032 if test -n "$CC_FOR_TARGET"; then
8033   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8034 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8035   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8036 fi
8037
8038 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8039   for ncn_progname in cc gcc; do
8040     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8041 set dummy ${ncn_progname}; ac_word=$2
8042 echo "$as_me:$LINENO: checking for $ac_word" >&5
8043 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8044 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8045   echo $ECHO_N "(cached) $ECHO_C" >&6
8046 else
8047   if test -n "$CC_FOR_TARGET"; then
8048   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8049 else
8050 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8051 for as_dir in $PATH
8052 do
8053   IFS=$as_save_IFS
8054   test -z "$as_dir" && as_dir=.
8055   for ac_exec_ext in '' $ac_executable_extensions; do
8056   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8057     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8058     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8059     break 2
8060   fi
8061 done
8062 done
8063
8064 fi
8065 fi
8066 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8067 if test -n "$CC_FOR_TARGET"; then
8068   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8069 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8070 else
8071   echo "$as_me:$LINENO: result: no" >&5
8072 echo "${ECHO_T}no" >&6
8073 fi
8074
8075   done
8076 fi
8077
8078 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8079   for ncn_progname in cc gcc; do
8080     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8081 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8082     if test -x $with_build_time_tools/${ncn_progname}; then
8083       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8084       echo "$as_me:$LINENO: result: yes" >&5
8085 echo "${ECHO_T}yes" >&6
8086       break
8087     else
8088       echo "$as_me:$LINENO: result: no" >&5
8089 echo "${ECHO_T}no" >&6
8090     fi
8091   done
8092 fi
8093
8094 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8095   for ncn_progname in cc gcc; do
8096     if test -n "$ncn_target_tool_prefix"; then
8097       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8098 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8099 echo "$as_me:$LINENO: checking for $ac_word" >&5
8100 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8101 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8102   echo $ECHO_N "(cached) $ECHO_C" >&6
8103 else
8104   if test -n "$CC_FOR_TARGET"; then
8105   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8106 else
8107 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8108 for as_dir in $PATH
8109 do
8110   IFS=$as_save_IFS
8111   test -z "$as_dir" && as_dir=.
8112   for ac_exec_ext in '' $ac_executable_extensions; do
8113   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8114     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8115     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8116     break 2
8117   fi
8118 done
8119 done
8120
8121 fi
8122 fi
8123 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8124 if test -n "$CC_FOR_TARGET"; then
8125   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8126 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8127 else
8128   echo "$as_me:$LINENO: result: no" >&5
8129 echo "${ECHO_T}no" >&6
8130 fi
8131
8132     fi
8133     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8134       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8135 set dummy ${ncn_progname}; ac_word=$2
8136 echo "$as_me:$LINENO: checking for $ac_word" >&5
8137 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8138 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8139   echo $ECHO_N "(cached) $ECHO_C" >&6
8140 else
8141   if test -n "$CC_FOR_TARGET"; then
8142   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8143 else
8144 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8145 for as_dir in $PATH
8146 do
8147   IFS=$as_save_IFS
8148   test -z "$as_dir" && as_dir=.
8149   for ac_exec_ext in '' $ac_executable_extensions; do
8150   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8151     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8152     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8153     break 2
8154   fi
8155 done
8156 done
8157
8158 fi
8159 fi
8160 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8161 if test -n "$CC_FOR_TARGET"; then
8162   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8163 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8164 else
8165   echo "$as_me:$LINENO: result: no" >&5
8166 echo "${ECHO_T}no" >&6
8167 fi
8168
8169     fi
8170     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8171   done
8172 fi
8173
8174 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8175   set dummy cc gcc
8176   if test $build = $target ; then
8177     CC_FOR_TARGET="$2"
8178   else
8179     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8180   fi
8181 else
8182   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8183 fi
8184
8185
8186
8187 if test -n "$CXX_FOR_TARGET"; then
8188   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8189 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8190   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8191 fi
8192
8193 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8194   for ncn_progname in c++ g++ cxx gxx; do
8195     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8196 set dummy ${ncn_progname}; ac_word=$2
8197 echo "$as_me:$LINENO: checking for $ac_word" >&5
8198 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8199 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8200   echo $ECHO_N "(cached) $ECHO_C" >&6
8201 else
8202   if test -n "$CXX_FOR_TARGET"; then
8203   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8204 else
8205 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8206 for as_dir in $PATH
8207 do
8208   IFS=$as_save_IFS
8209   test -z "$as_dir" && as_dir=.
8210   for ac_exec_ext in '' $ac_executable_extensions; do
8211   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8212     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8213     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8214     break 2
8215   fi
8216 done
8217 done
8218
8219 fi
8220 fi
8221 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8222 if test -n "$CXX_FOR_TARGET"; then
8223   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8224 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8225 else
8226   echo "$as_me:$LINENO: result: no" >&5
8227 echo "${ECHO_T}no" >&6
8228 fi
8229
8230   done
8231 fi
8232
8233 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8234   for ncn_progname in c++ g++ cxx gxx; do
8235     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8236 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8237     if test -x $with_build_time_tools/${ncn_progname}; then
8238       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8239       echo "$as_me:$LINENO: result: yes" >&5
8240 echo "${ECHO_T}yes" >&6
8241       break
8242     else
8243       echo "$as_me:$LINENO: result: no" >&5
8244 echo "${ECHO_T}no" >&6
8245     fi
8246   done
8247 fi
8248
8249 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8250   for ncn_progname in c++ g++ cxx gxx; do
8251     if test -n "$ncn_target_tool_prefix"; then
8252       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8253 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8254 echo "$as_me:$LINENO: checking for $ac_word" >&5
8255 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8256 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8257   echo $ECHO_N "(cached) $ECHO_C" >&6
8258 else
8259   if test -n "$CXX_FOR_TARGET"; then
8260   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8261 else
8262 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8263 for as_dir in $PATH
8264 do
8265   IFS=$as_save_IFS
8266   test -z "$as_dir" && as_dir=.
8267   for ac_exec_ext in '' $ac_executable_extensions; do
8268   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8269     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8270     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8271     break 2
8272   fi
8273 done
8274 done
8275
8276 fi
8277 fi
8278 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8279 if test -n "$CXX_FOR_TARGET"; then
8280   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8281 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8282 else
8283   echo "$as_me:$LINENO: result: no" >&5
8284 echo "${ECHO_T}no" >&6
8285 fi
8286
8287     fi
8288     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8289       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8290 set dummy ${ncn_progname}; ac_word=$2
8291 echo "$as_me:$LINENO: checking for $ac_word" >&5
8292 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8293 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8294   echo $ECHO_N "(cached) $ECHO_C" >&6
8295 else
8296   if test -n "$CXX_FOR_TARGET"; then
8297   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8298 else
8299 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8300 for as_dir in $PATH
8301 do
8302   IFS=$as_save_IFS
8303   test -z "$as_dir" && as_dir=.
8304   for ac_exec_ext in '' $ac_executable_extensions; do
8305   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8306     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8307     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8308     break 2
8309   fi
8310 done
8311 done
8312
8313 fi
8314 fi
8315 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8316 if test -n "$CXX_FOR_TARGET"; then
8317   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8318 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8319 else
8320   echo "$as_me:$LINENO: result: no" >&5
8321 echo "${ECHO_T}no" >&6
8322 fi
8323
8324     fi
8325     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8326   done
8327 fi
8328
8329 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8330   set dummy c++ g++ cxx gxx
8331   if test $build = $target ; then
8332     CXX_FOR_TARGET="$2"
8333   else
8334     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8335   fi
8336 else
8337   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8338 fi
8339
8340
8341
8342 if test -n "$GCC_FOR_TARGET"; then
8343   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8344 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8345   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8346 fi
8347
8348 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8349   for ncn_progname in gcc; do
8350     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8351 set dummy ${ncn_progname}; ac_word=$2
8352 echo "$as_me:$LINENO: checking for $ac_word" >&5
8353 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8354 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8355   echo $ECHO_N "(cached) $ECHO_C" >&6
8356 else
8357   if test -n "$GCC_FOR_TARGET"; then
8358   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8359 else
8360 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8361 for as_dir in $PATH
8362 do
8363   IFS=$as_save_IFS
8364   test -z "$as_dir" && as_dir=.
8365   for ac_exec_ext in '' $ac_executable_extensions; do
8366   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8367     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8368     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8369     break 2
8370   fi
8371 done
8372 done
8373
8374 fi
8375 fi
8376 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8377 if test -n "$GCC_FOR_TARGET"; then
8378   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8379 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8380 else
8381   echo "$as_me:$LINENO: result: no" >&5
8382 echo "${ECHO_T}no" >&6
8383 fi
8384
8385   done
8386 fi
8387
8388 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8389   for ncn_progname in gcc; do
8390     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8391 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8392     if test -x $with_build_time_tools/${ncn_progname}; then
8393       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8394       echo "$as_me:$LINENO: result: yes" >&5
8395 echo "${ECHO_T}yes" >&6
8396       break
8397     else
8398       echo "$as_me:$LINENO: result: no" >&5
8399 echo "${ECHO_T}no" >&6
8400     fi
8401   done
8402 fi
8403
8404 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8405   for ncn_progname in gcc; do
8406     if test -n "$ncn_target_tool_prefix"; then
8407       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8408 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8409 echo "$as_me:$LINENO: checking for $ac_word" >&5
8410 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8411 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8412   echo $ECHO_N "(cached) $ECHO_C" >&6
8413 else
8414   if test -n "$GCC_FOR_TARGET"; then
8415   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8416 else
8417 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8418 for as_dir in $PATH
8419 do
8420   IFS=$as_save_IFS
8421   test -z "$as_dir" && as_dir=.
8422   for ac_exec_ext in '' $ac_executable_extensions; do
8423   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8424     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8425     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8426     break 2
8427   fi
8428 done
8429 done
8430
8431 fi
8432 fi
8433 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8434 if test -n "$GCC_FOR_TARGET"; then
8435   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8436 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8437 else
8438   echo "$as_me:$LINENO: result: no" >&5
8439 echo "${ECHO_T}no" >&6
8440 fi
8441
8442     fi
8443     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8444       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8445 set dummy ${ncn_progname}; ac_word=$2
8446 echo "$as_me:$LINENO: checking for $ac_word" >&5
8447 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8448 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8449   echo $ECHO_N "(cached) $ECHO_C" >&6
8450 else
8451   if test -n "$GCC_FOR_TARGET"; then
8452   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8453 else
8454 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8455 for as_dir in $PATH
8456 do
8457   IFS=$as_save_IFS
8458   test -z "$as_dir" && as_dir=.
8459   for ac_exec_ext in '' $ac_executable_extensions; do
8460   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8461     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8462     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8463     break 2
8464   fi
8465 done
8466 done
8467
8468 fi
8469 fi
8470 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8471 if test -n "$GCC_FOR_TARGET"; then
8472   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8473 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8474 else
8475   echo "$as_me:$LINENO: result: no" >&5
8476 echo "${ECHO_T}no" >&6
8477 fi
8478
8479     fi
8480     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8481   done
8482 fi
8483
8484 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8485   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8486 else
8487   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8488 fi
8489
8490
8491
8492 if test -n "$GCJ_FOR_TARGET"; then
8493   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8494 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8495   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8496 fi
8497
8498 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8499   for ncn_progname in gcj; do
8500     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8501 set dummy ${ncn_progname}; ac_word=$2
8502 echo "$as_me:$LINENO: checking for $ac_word" >&5
8503 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8504 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8505   echo $ECHO_N "(cached) $ECHO_C" >&6
8506 else
8507   if test -n "$GCJ_FOR_TARGET"; then
8508   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8509 else
8510 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8511 for as_dir in $PATH
8512 do
8513   IFS=$as_save_IFS
8514   test -z "$as_dir" && as_dir=.
8515   for ac_exec_ext in '' $ac_executable_extensions; do
8516   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8517     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8518     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8519     break 2
8520   fi
8521 done
8522 done
8523
8524 fi
8525 fi
8526 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8527 if test -n "$GCJ_FOR_TARGET"; then
8528   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8529 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8530 else
8531   echo "$as_me:$LINENO: result: no" >&5
8532 echo "${ECHO_T}no" >&6
8533 fi
8534
8535   done
8536 fi
8537
8538 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8539   for ncn_progname in gcj; do
8540     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8541 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8542     if test -x $with_build_time_tools/${ncn_progname}; then
8543       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8544       echo "$as_me:$LINENO: result: yes" >&5
8545 echo "${ECHO_T}yes" >&6
8546       break
8547     else
8548       echo "$as_me:$LINENO: result: no" >&5
8549 echo "${ECHO_T}no" >&6
8550     fi
8551   done
8552 fi
8553
8554 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8555   for ncn_progname in gcj; do
8556     if test -n "$ncn_target_tool_prefix"; then
8557       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8558 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8559 echo "$as_me:$LINENO: checking for $ac_word" >&5
8560 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8561 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8562   echo $ECHO_N "(cached) $ECHO_C" >&6
8563 else
8564   if test -n "$GCJ_FOR_TARGET"; then
8565   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8566 else
8567 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8568 for as_dir in $PATH
8569 do
8570   IFS=$as_save_IFS
8571   test -z "$as_dir" && as_dir=.
8572   for ac_exec_ext in '' $ac_executable_extensions; do
8573   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8574     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8575     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8576     break 2
8577   fi
8578 done
8579 done
8580
8581 fi
8582 fi
8583 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8584 if test -n "$GCJ_FOR_TARGET"; then
8585   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8586 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8587 else
8588   echo "$as_me:$LINENO: result: no" >&5
8589 echo "${ECHO_T}no" >&6
8590 fi
8591
8592     fi
8593     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8594       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8595 set dummy ${ncn_progname}; ac_word=$2
8596 echo "$as_me:$LINENO: checking for $ac_word" >&5
8597 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8598 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8599   echo $ECHO_N "(cached) $ECHO_C" >&6
8600 else
8601   if test -n "$GCJ_FOR_TARGET"; then
8602   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8603 else
8604 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8605 for as_dir in $PATH
8606 do
8607   IFS=$as_save_IFS
8608   test -z "$as_dir" && as_dir=.
8609   for ac_exec_ext in '' $ac_executable_extensions; do
8610   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8611     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8612     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8613     break 2
8614   fi
8615 done
8616 done
8617
8618 fi
8619 fi
8620 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8621 if test -n "$GCJ_FOR_TARGET"; then
8622   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8623 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8624 else
8625   echo "$as_me:$LINENO: result: no" >&5
8626 echo "${ECHO_T}no" >&6
8627 fi
8628
8629     fi
8630     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8631   done
8632 fi
8633
8634 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8635   set dummy gcj
8636   if test $build = $target ; then
8637     GCJ_FOR_TARGET="$2"
8638   else
8639     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8640   fi
8641 else
8642   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8643 fi
8644
8645
8646
8647 if test -n "$GFORTRAN_FOR_TARGET"; then
8648   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8649 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8650   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8651 fi
8652
8653 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8654   for ncn_progname in gfortran; do
8655     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8656 set dummy ${ncn_progname}; ac_word=$2
8657 echo "$as_me:$LINENO: checking for $ac_word" >&5
8658 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8659 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8660   echo $ECHO_N "(cached) $ECHO_C" >&6
8661 else
8662   if test -n "$GFORTRAN_FOR_TARGET"; then
8663   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8664 else
8665 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8666 for as_dir in $PATH
8667 do
8668   IFS=$as_save_IFS
8669   test -z "$as_dir" && as_dir=.
8670   for ac_exec_ext in '' $ac_executable_extensions; do
8671   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8672     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8673     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8674     break 2
8675   fi
8676 done
8677 done
8678
8679 fi
8680 fi
8681 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8682 if test -n "$GFORTRAN_FOR_TARGET"; then
8683   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8684 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8685 else
8686   echo "$as_me:$LINENO: result: no" >&5
8687 echo "${ECHO_T}no" >&6
8688 fi
8689
8690   done
8691 fi
8692
8693 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8694   for ncn_progname in gfortran; do
8695     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8696 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8697     if test -x $with_build_time_tools/${ncn_progname}; then
8698       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8699       echo "$as_me:$LINENO: result: yes" >&5
8700 echo "${ECHO_T}yes" >&6
8701       break
8702     else
8703       echo "$as_me:$LINENO: result: no" >&5
8704 echo "${ECHO_T}no" >&6
8705     fi
8706   done
8707 fi
8708
8709 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8710   for ncn_progname in gfortran; do
8711     if test -n "$ncn_target_tool_prefix"; then
8712       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8713 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8714 echo "$as_me:$LINENO: checking for $ac_word" >&5
8715 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8716 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8717   echo $ECHO_N "(cached) $ECHO_C" >&6
8718 else
8719   if test -n "$GFORTRAN_FOR_TARGET"; then
8720   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8721 else
8722 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8723 for as_dir in $PATH
8724 do
8725   IFS=$as_save_IFS
8726   test -z "$as_dir" && as_dir=.
8727   for ac_exec_ext in '' $ac_executable_extensions; do
8728   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8729     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8730     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8731     break 2
8732   fi
8733 done
8734 done
8735
8736 fi
8737 fi
8738 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8739 if test -n "$GFORTRAN_FOR_TARGET"; then
8740   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8741 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8742 else
8743   echo "$as_me:$LINENO: result: no" >&5
8744 echo "${ECHO_T}no" >&6
8745 fi
8746
8747     fi
8748     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8749       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8750 set dummy ${ncn_progname}; ac_word=$2
8751 echo "$as_me:$LINENO: checking for $ac_word" >&5
8752 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8753 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8754   echo $ECHO_N "(cached) $ECHO_C" >&6
8755 else
8756   if test -n "$GFORTRAN_FOR_TARGET"; then
8757   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8758 else
8759 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8760 for as_dir in $PATH
8761 do
8762   IFS=$as_save_IFS
8763   test -z "$as_dir" && as_dir=.
8764   for ac_exec_ext in '' $ac_executable_extensions; do
8765   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8766     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8767     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8768     break 2
8769   fi
8770 done
8771 done
8772
8773 fi
8774 fi
8775 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8776 if test -n "$GFORTRAN_FOR_TARGET"; then
8777   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8778 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8779 else
8780   echo "$as_me:$LINENO: result: no" >&5
8781 echo "${ECHO_T}no" >&6
8782 fi
8783
8784     fi
8785     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8786   done
8787 fi
8788
8789 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8790   set dummy gfortran
8791   if test $build = $target ; then
8792     GFORTRAN_FOR_TARGET="$2"
8793   else
8794     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8795   fi
8796 else
8797   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8798 fi
8799
8800
8801
8802 cat > conftest.c << \EOF
8803 #ifdef __GNUC__
8804   gcc_yay;
8805 #endif
8806 EOF
8807 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8808   have_gcc_for_target=yes
8809 else
8810   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8811   have_gcc_for_target=no
8812 fi
8813 rm conftest.c
8814
8815
8816
8817
8818 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8819   if test -n "$with_build_time_tools"; then
8820     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8821 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8822     if test -x $with_build_time_tools/ar; then
8823       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8824       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8825       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8826 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8827     else
8828       echo "$as_me:$LINENO: result: no" >&5
8829 echo "${ECHO_T}no" >&6
8830     fi
8831   elif test $build != $host && test $have_gcc_for_target = yes; then
8832     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8833     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8834     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8835   fi
8836 fi
8837 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8838   # Extract the first word of "ar", so it can be a program name with args.
8839 set dummy ar; ac_word=$2
8840 echo "$as_me:$LINENO: checking for $ac_word" >&5
8841 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8842 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8843   echo $ECHO_N "(cached) $ECHO_C" >&6
8844 else
8845   case $AR_FOR_TARGET in
8846   [\\/]* | ?:[\\/]*)
8847   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8848   ;;
8849   *)
8850   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8851 for as_dir in $gcc_cv_tool_dirs
8852 do
8853   IFS=$as_save_IFS
8854   test -z "$as_dir" && as_dir=.
8855   for ac_exec_ext in '' $ac_executable_extensions; do
8856   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8857     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8858     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8859     break 2
8860   fi
8861 done
8862 done
8863
8864   ;;
8865 esac
8866 fi
8867 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8868
8869 if test -n "$AR_FOR_TARGET"; then
8870   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8871 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8872 else
8873   echo "$as_me:$LINENO: result: no" >&5
8874 echo "${ECHO_T}no" >&6
8875 fi
8876
8877 fi
8878 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8879
8880
8881 if test -n "$AR_FOR_TARGET"; then
8882   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8883 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8884   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8885 fi
8886
8887 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8888   for ncn_progname in ar; do
8889     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8890 set dummy ${ncn_progname}; ac_word=$2
8891 echo "$as_me:$LINENO: checking for $ac_word" >&5
8892 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8893 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8894   echo $ECHO_N "(cached) $ECHO_C" >&6
8895 else
8896   if test -n "$AR_FOR_TARGET"; then
8897   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8898 else
8899 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8900 for as_dir in $PATH
8901 do
8902   IFS=$as_save_IFS
8903   test -z "$as_dir" && as_dir=.
8904   for ac_exec_ext in '' $ac_executable_extensions; do
8905   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8906     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8907     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8908     break 2
8909   fi
8910 done
8911 done
8912
8913 fi
8914 fi
8915 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8916 if test -n "$AR_FOR_TARGET"; then
8917   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8918 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8919 else
8920   echo "$as_me:$LINENO: result: no" >&5
8921 echo "${ECHO_T}no" >&6
8922 fi
8923
8924   done
8925 fi
8926
8927 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8928   for ncn_progname in ar; do
8929     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8930 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8931     if test -x $with_build_time_tools/${ncn_progname}; then
8932       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8933       echo "$as_me:$LINENO: result: yes" >&5
8934 echo "${ECHO_T}yes" >&6
8935       break
8936     else
8937       echo "$as_me:$LINENO: result: no" >&5
8938 echo "${ECHO_T}no" >&6
8939     fi
8940   done
8941 fi
8942
8943 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8944   for ncn_progname in ar; do
8945     if test -n "$ncn_target_tool_prefix"; then
8946       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8947 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8948 echo "$as_me:$LINENO: checking for $ac_word" >&5
8949 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8950 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8951   echo $ECHO_N "(cached) $ECHO_C" >&6
8952 else
8953   if test -n "$AR_FOR_TARGET"; then
8954   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8955 else
8956 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8957 for as_dir in $PATH
8958 do
8959   IFS=$as_save_IFS
8960   test -z "$as_dir" && as_dir=.
8961   for ac_exec_ext in '' $ac_executable_extensions; do
8962   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8963     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8964     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8965     break 2
8966   fi
8967 done
8968 done
8969
8970 fi
8971 fi
8972 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8973 if test -n "$AR_FOR_TARGET"; then
8974   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8975 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8976 else
8977   echo "$as_me:$LINENO: result: no" >&5
8978 echo "${ECHO_T}no" >&6
8979 fi
8980
8981     fi
8982     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
8983       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8984 set dummy ${ncn_progname}; ac_word=$2
8985 echo "$as_me:$LINENO: checking for $ac_word" >&5
8986 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8987 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8988   echo $ECHO_N "(cached) $ECHO_C" >&6
8989 else
8990   if test -n "$AR_FOR_TARGET"; then
8991   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8992 else
8993 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8994 for as_dir in $PATH
8995 do
8996   IFS=$as_save_IFS
8997   test -z "$as_dir" && as_dir=.
8998   for ac_exec_ext in '' $ac_executable_extensions; do
8999   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9000     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9001     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9002     break 2
9003   fi
9004 done
9005 done
9006
9007 fi
9008 fi
9009 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9010 if test -n "$AR_FOR_TARGET"; then
9011   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9012 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9013 else
9014   echo "$as_me:$LINENO: result: no" >&5
9015 echo "${ECHO_T}no" >&6
9016 fi
9017
9018     fi
9019     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9020   done
9021 fi
9022
9023 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9024   set dummy ar
9025   if test $build = $target ; then
9026     AR_FOR_TARGET="$2"
9027   else
9028     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9029   fi
9030 else
9031   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9032 fi
9033
9034 else
9035   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9036 fi
9037
9038
9039
9040
9041 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9042   if test -n "$with_build_time_tools"; then
9043     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9044 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9045     if test -x $with_build_time_tools/as; then
9046       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9047       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9048       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9049 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9050     else
9051       echo "$as_me:$LINENO: result: no" >&5
9052 echo "${ECHO_T}no" >&6
9053     fi
9054   elif test $build != $host && test $have_gcc_for_target = yes; then
9055     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9056     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9057     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9058   fi
9059 fi
9060 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9061   # Extract the first word of "as", so it can be a program name with args.
9062 set dummy as; ac_word=$2
9063 echo "$as_me:$LINENO: checking for $ac_word" >&5
9064 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9065 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9066   echo $ECHO_N "(cached) $ECHO_C" >&6
9067 else
9068   case $AS_FOR_TARGET in
9069   [\\/]* | ?:[\\/]*)
9070   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9071   ;;
9072   *)
9073   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9074 for as_dir in $gcc_cv_tool_dirs
9075 do
9076   IFS=$as_save_IFS
9077   test -z "$as_dir" && as_dir=.
9078   for ac_exec_ext in '' $ac_executable_extensions; do
9079   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9080     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9081     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9082     break 2
9083   fi
9084 done
9085 done
9086
9087   ;;
9088 esac
9089 fi
9090 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9091
9092 if test -n "$AS_FOR_TARGET"; then
9093   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9094 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9095 else
9096   echo "$as_me:$LINENO: result: no" >&5
9097 echo "${ECHO_T}no" >&6
9098 fi
9099
9100 fi
9101 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9102
9103
9104 if test -n "$AS_FOR_TARGET"; then
9105   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9106 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9107   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9108 fi
9109
9110 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9111   for ncn_progname in as; do
9112     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9113 set dummy ${ncn_progname}; ac_word=$2
9114 echo "$as_me:$LINENO: checking for $ac_word" >&5
9115 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9116 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9117   echo $ECHO_N "(cached) $ECHO_C" >&6
9118 else
9119   if test -n "$AS_FOR_TARGET"; then
9120   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9121 else
9122 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9123 for as_dir in $PATH
9124 do
9125   IFS=$as_save_IFS
9126   test -z "$as_dir" && as_dir=.
9127   for ac_exec_ext in '' $ac_executable_extensions; do
9128   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9129     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9130     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9131     break 2
9132   fi
9133 done
9134 done
9135
9136 fi
9137 fi
9138 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9139 if test -n "$AS_FOR_TARGET"; then
9140   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9141 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9142 else
9143   echo "$as_me:$LINENO: result: no" >&5
9144 echo "${ECHO_T}no" >&6
9145 fi
9146
9147   done
9148 fi
9149
9150 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9151   for ncn_progname in as; do
9152     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9153 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9154     if test -x $with_build_time_tools/${ncn_progname}; then
9155       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9156       echo "$as_me:$LINENO: result: yes" >&5
9157 echo "${ECHO_T}yes" >&6
9158       break
9159     else
9160       echo "$as_me:$LINENO: result: no" >&5
9161 echo "${ECHO_T}no" >&6
9162     fi
9163   done
9164 fi
9165
9166 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9167   for ncn_progname in as; do
9168     if test -n "$ncn_target_tool_prefix"; then
9169       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9170 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9171 echo "$as_me:$LINENO: checking for $ac_word" >&5
9172 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9173 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9174   echo $ECHO_N "(cached) $ECHO_C" >&6
9175 else
9176   if test -n "$AS_FOR_TARGET"; then
9177   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9178 else
9179 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9180 for as_dir in $PATH
9181 do
9182   IFS=$as_save_IFS
9183   test -z "$as_dir" && as_dir=.
9184   for ac_exec_ext in '' $ac_executable_extensions; do
9185   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9186     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9187     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9188     break 2
9189   fi
9190 done
9191 done
9192
9193 fi
9194 fi
9195 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9196 if test -n "$AS_FOR_TARGET"; then
9197   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9198 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9199 else
9200   echo "$as_me:$LINENO: result: no" >&5
9201 echo "${ECHO_T}no" >&6
9202 fi
9203
9204     fi
9205     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9206       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9207 set dummy ${ncn_progname}; ac_word=$2
9208 echo "$as_me:$LINENO: checking for $ac_word" >&5
9209 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9210 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9211   echo $ECHO_N "(cached) $ECHO_C" >&6
9212 else
9213   if test -n "$AS_FOR_TARGET"; then
9214   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9215 else
9216 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9217 for as_dir in $PATH
9218 do
9219   IFS=$as_save_IFS
9220   test -z "$as_dir" && as_dir=.
9221   for ac_exec_ext in '' $ac_executable_extensions; do
9222   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9223     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9224     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9225     break 2
9226   fi
9227 done
9228 done
9229
9230 fi
9231 fi
9232 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9233 if test -n "$AS_FOR_TARGET"; then
9234   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9235 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9236 else
9237   echo "$as_me:$LINENO: result: no" >&5
9238 echo "${ECHO_T}no" >&6
9239 fi
9240
9241     fi
9242     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9243   done
9244 fi
9245
9246 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9247   set dummy as
9248   if test $build = $target ; then
9249     AS_FOR_TARGET="$2"
9250   else
9251     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9252   fi
9253 else
9254   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9255 fi
9256
9257 else
9258   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9259 fi
9260
9261
9262
9263
9264 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9265   if test -n "$with_build_time_tools"; then
9266     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9267 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9268     if test -x $with_build_time_tools/dlltool; then
9269       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9270       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9271       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9272 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9273     else
9274       echo "$as_me:$LINENO: result: no" >&5
9275 echo "${ECHO_T}no" >&6
9276     fi
9277   elif test $build != $host && test $have_gcc_for_target = yes; then
9278     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9279     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9280     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9281   fi
9282 fi
9283 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9284   # Extract the first word of "dlltool", so it can be a program name with args.
9285 set dummy dlltool; ac_word=$2
9286 echo "$as_me:$LINENO: checking for $ac_word" >&5
9287 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9288 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9289   echo $ECHO_N "(cached) $ECHO_C" >&6
9290 else
9291   case $DLLTOOL_FOR_TARGET in
9292   [\\/]* | ?:[\\/]*)
9293   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9294   ;;
9295   *)
9296   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9297 for as_dir in $gcc_cv_tool_dirs
9298 do
9299   IFS=$as_save_IFS
9300   test -z "$as_dir" && as_dir=.
9301   for ac_exec_ext in '' $ac_executable_extensions; do
9302   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9303     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9304     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9305     break 2
9306   fi
9307 done
9308 done
9309
9310   ;;
9311 esac
9312 fi
9313 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9314
9315 if test -n "$DLLTOOL_FOR_TARGET"; then
9316   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9317 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9318 else
9319   echo "$as_me:$LINENO: result: no" >&5
9320 echo "${ECHO_T}no" >&6
9321 fi
9322
9323 fi
9324 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9325
9326
9327 if test -n "$DLLTOOL_FOR_TARGET"; then
9328   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9329 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9330   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9331 fi
9332
9333 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9334   for ncn_progname in dlltool; do
9335     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9336 set dummy ${ncn_progname}; ac_word=$2
9337 echo "$as_me:$LINENO: checking for $ac_word" >&5
9338 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9339 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9340   echo $ECHO_N "(cached) $ECHO_C" >&6
9341 else
9342   if test -n "$DLLTOOL_FOR_TARGET"; then
9343   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9344 else
9345 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9346 for as_dir in $PATH
9347 do
9348   IFS=$as_save_IFS
9349   test -z "$as_dir" && as_dir=.
9350   for ac_exec_ext in '' $ac_executable_extensions; do
9351   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9352     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9353     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9354     break 2
9355   fi
9356 done
9357 done
9358
9359 fi
9360 fi
9361 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9362 if test -n "$DLLTOOL_FOR_TARGET"; then
9363   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9364 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9365 else
9366   echo "$as_me:$LINENO: result: no" >&5
9367 echo "${ECHO_T}no" >&6
9368 fi
9369
9370   done
9371 fi
9372
9373 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9374   for ncn_progname in dlltool; do
9375     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9376 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9377     if test -x $with_build_time_tools/${ncn_progname}; then
9378       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9379       echo "$as_me:$LINENO: result: yes" >&5
9380 echo "${ECHO_T}yes" >&6
9381       break
9382     else
9383       echo "$as_me:$LINENO: result: no" >&5
9384 echo "${ECHO_T}no" >&6
9385     fi
9386   done
9387 fi
9388
9389 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9390   for ncn_progname in dlltool; do
9391     if test -n "$ncn_target_tool_prefix"; then
9392       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9393 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9394 echo "$as_me:$LINENO: checking for $ac_word" >&5
9395 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9396 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9397   echo $ECHO_N "(cached) $ECHO_C" >&6
9398 else
9399   if test -n "$DLLTOOL_FOR_TARGET"; then
9400   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9401 else
9402 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9403 for as_dir in $PATH
9404 do
9405   IFS=$as_save_IFS
9406   test -z "$as_dir" && as_dir=.
9407   for ac_exec_ext in '' $ac_executable_extensions; do
9408   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9409     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9410     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9411     break 2
9412   fi
9413 done
9414 done
9415
9416 fi
9417 fi
9418 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9419 if test -n "$DLLTOOL_FOR_TARGET"; then
9420   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9421 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9422 else
9423   echo "$as_me:$LINENO: result: no" >&5
9424 echo "${ECHO_T}no" >&6
9425 fi
9426
9427     fi
9428     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9429       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9430 set dummy ${ncn_progname}; ac_word=$2
9431 echo "$as_me:$LINENO: checking for $ac_word" >&5
9432 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9433 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9434   echo $ECHO_N "(cached) $ECHO_C" >&6
9435 else
9436   if test -n "$DLLTOOL_FOR_TARGET"; then
9437   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9438 else
9439 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9440 for as_dir in $PATH
9441 do
9442   IFS=$as_save_IFS
9443   test -z "$as_dir" && as_dir=.
9444   for ac_exec_ext in '' $ac_executable_extensions; do
9445   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9446     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9447     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9448     break 2
9449   fi
9450 done
9451 done
9452
9453 fi
9454 fi
9455 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9456 if test -n "$DLLTOOL_FOR_TARGET"; then
9457   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9458 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9459 else
9460   echo "$as_me:$LINENO: result: no" >&5
9461 echo "${ECHO_T}no" >&6
9462 fi
9463
9464     fi
9465     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9466   done
9467 fi
9468
9469 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9470   set dummy dlltool
9471   if test $build = $target ; then
9472     DLLTOOL_FOR_TARGET="$2"
9473   else
9474     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9475   fi
9476 else
9477   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9478 fi
9479
9480 else
9481   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9482 fi
9483
9484
9485
9486
9487 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9488   if test -n "$with_build_time_tools"; then
9489     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9490 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9491     if test -x $with_build_time_tools/ld; then
9492       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9493       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9494       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9495 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9496     else
9497       echo "$as_me:$LINENO: result: no" >&5
9498 echo "${ECHO_T}no" >&6
9499     fi
9500   elif test $build != $host && test $have_gcc_for_target = yes; then
9501     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9502     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9503     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9504   fi
9505 fi
9506 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9507   # Extract the first word of "ld", so it can be a program name with args.
9508 set dummy ld; ac_word=$2
9509 echo "$as_me:$LINENO: checking for $ac_word" >&5
9510 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9511 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9512   echo $ECHO_N "(cached) $ECHO_C" >&6
9513 else
9514   case $LD_FOR_TARGET in
9515   [\\/]* | ?:[\\/]*)
9516   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9517   ;;
9518   *)
9519   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9520 for as_dir in $gcc_cv_tool_dirs
9521 do
9522   IFS=$as_save_IFS
9523   test -z "$as_dir" && as_dir=.
9524   for ac_exec_ext in '' $ac_executable_extensions; do
9525   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9526     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9527     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9528     break 2
9529   fi
9530 done
9531 done
9532
9533   ;;
9534 esac
9535 fi
9536 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9537
9538 if test -n "$LD_FOR_TARGET"; then
9539   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9540 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9541 else
9542   echo "$as_me:$LINENO: result: no" >&5
9543 echo "${ECHO_T}no" >&6
9544 fi
9545
9546 fi
9547 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9548
9549
9550 if test -n "$LD_FOR_TARGET"; then
9551   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9552 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9553   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9554 fi
9555
9556 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9557   for ncn_progname in ld; do
9558     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9559 set dummy ${ncn_progname}; ac_word=$2
9560 echo "$as_me:$LINENO: checking for $ac_word" >&5
9561 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9562 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9563   echo $ECHO_N "(cached) $ECHO_C" >&6
9564 else
9565   if test -n "$LD_FOR_TARGET"; then
9566   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9567 else
9568 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9569 for as_dir in $PATH
9570 do
9571   IFS=$as_save_IFS
9572   test -z "$as_dir" && as_dir=.
9573   for ac_exec_ext in '' $ac_executable_extensions; do
9574   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9575     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9576     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9577     break 2
9578   fi
9579 done
9580 done
9581
9582 fi
9583 fi
9584 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9585 if test -n "$LD_FOR_TARGET"; then
9586   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9587 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9588 else
9589   echo "$as_me:$LINENO: result: no" >&5
9590 echo "${ECHO_T}no" >&6
9591 fi
9592
9593   done
9594 fi
9595
9596 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9597   for ncn_progname in ld; do
9598     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9599 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9600     if test -x $with_build_time_tools/${ncn_progname}; then
9601       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9602       echo "$as_me:$LINENO: result: yes" >&5
9603 echo "${ECHO_T}yes" >&6
9604       break
9605     else
9606       echo "$as_me:$LINENO: result: no" >&5
9607 echo "${ECHO_T}no" >&6
9608     fi
9609   done
9610 fi
9611
9612 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9613   for ncn_progname in ld; do
9614     if test -n "$ncn_target_tool_prefix"; then
9615       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9616 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9617 echo "$as_me:$LINENO: checking for $ac_word" >&5
9618 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9619 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9620   echo $ECHO_N "(cached) $ECHO_C" >&6
9621 else
9622   if test -n "$LD_FOR_TARGET"; then
9623   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9624 else
9625 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9626 for as_dir in $PATH
9627 do
9628   IFS=$as_save_IFS
9629   test -z "$as_dir" && as_dir=.
9630   for ac_exec_ext in '' $ac_executable_extensions; do
9631   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9632     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9633     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9634     break 2
9635   fi
9636 done
9637 done
9638
9639 fi
9640 fi
9641 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9642 if test -n "$LD_FOR_TARGET"; then
9643   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9644 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9645 else
9646   echo "$as_me:$LINENO: result: no" >&5
9647 echo "${ECHO_T}no" >&6
9648 fi
9649
9650     fi
9651     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9652       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9653 set dummy ${ncn_progname}; ac_word=$2
9654 echo "$as_me:$LINENO: checking for $ac_word" >&5
9655 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9656 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9657   echo $ECHO_N "(cached) $ECHO_C" >&6
9658 else
9659   if test -n "$LD_FOR_TARGET"; then
9660   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9661 else
9662 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9663 for as_dir in $PATH
9664 do
9665   IFS=$as_save_IFS
9666   test -z "$as_dir" && as_dir=.
9667   for ac_exec_ext in '' $ac_executable_extensions; do
9668   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9669     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9670     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9671     break 2
9672   fi
9673 done
9674 done
9675
9676 fi
9677 fi
9678 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9679 if test -n "$LD_FOR_TARGET"; then
9680   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9681 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9682 else
9683   echo "$as_me:$LINENO: result: no" >&5
9684 echo "${ECHO_T}no" >&6
9685 fi
9686
9687     fi
9688     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9689   done
9690 fi
9691
9692 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9693   set dummy ld
9694   if test $build = $target ; then
9695     LD_FOR_TARGET="$2"
9696   else
9697     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9698   fi
9699 else
9700   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9701 fi
9702
9703 else
9704   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9705 fi
9706
9707
9708
9709
9710 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9711   if test -n "$with_build_time_tools"; then
9712     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9713 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9714     if test -x $with_build_time_tools/lipo; then
9715       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9716       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9717       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9718 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9719     else
9720       echo "$as_me:$LINENO: result: no" >&5
9721 echo "${ECHO_T}no" >&6
9722     fi
9723   elif test $build != $host && test $have_gcc_for_target = yes; then
9724     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9725     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9726     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9727   fi
9728 fi
9729 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9730   # Extract the first word of "lipo", so it can be a program name with args.
9731 set dummy lipo; ac_word=$2
9732 echo "$as_me:$LINENO: checking for $ac_word" >&5
9733 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9734 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9735   echo $ECHO_N "(cached) $ECHO_C" >&6
9736 else
9737   case $LIPO_FOR_TARGET in
9738   [\\/]* | ?:[\\/]*)
9739   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9740   ;;
9741   *)
9742   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9743 for as_dir in $gcc_cv_tool_dirs
9744 do
9745   IFS=$as_save_IFS
9746   test -z "$as_dir" && as_dir=.
9747   for ac_exec_ext in '' $ac_executable_extensions; do
9748   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9749     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9750     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9751     break 2
9752   fi
9753 done
9754 done
9755
9756   ;;
9757 esac
9758 fi
9759 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9760
9761 if test -n "$LIPO_FOR_TARGET"; then
9762   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9763 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9764 else
9765   echo "$as_me:$LINENO: result: no" >&5
9766 echo "${ECHO_T}no" >&6
9767 fi
9768
9769 fi
9770 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9771
9772
9773 if test -n "$LIPO_FOR_TARGET"; then
9774   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9775 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9776   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9777 fi
9778
9779 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9780   for ncn_progname in lipo; do
9781     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9782 set dummy ${ncn_progname}; ac_word=$2
9783 echo "$as_me:$LINENO: checking for $ac_word" >&5
9784 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9785 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9786   echo $ECHO_N "(cached) $ECHO_C" >&6
9787 else
9788   if test -n "$LIPO_FOR_TARGET"; then
9789   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9790 else
9791 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9792 for as_dir in $PATH
9793 do
9794   IFS=$as_save_IFS
9795   test -z "$as_dir" && as_dir=.
9796   for ac_exec_ext in '' $ac_executable_extensions; do
9797   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9798     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9799     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9800     break 2
9801   fi
9802 done
9803 done
9804
9805 fi
9806 fi
9807 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9808 if test -n "$LIPO_FOR_TARGET"; then
9809   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9810 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9811 else
9812   echo "$as_me:$LINENO: result: no" >&5
9813 echo "${ECHO_T}no" >&6
9814 fi
9815
9816   done
9817 fi
9818
9819 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9820   for ncn_progname in lipo; do
9821     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9822 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9823     if test -x $with_build_time_tools/${ncn_progname}; then
9824       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9825       echo "$as_me:$LINENO: result: yes" >&5
9826 echo "${ECHO_T}yes" >&6
9827       break
9828     else
9829       echo "$as_me:$LINENO: result: no" >&5
9830 echo "${ECHO_T}no" >&6
9831     fi
9832   done
9833 fi
9834
9835 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9836   for ncn_progname in lipo; do
9837     if test -n "$ncn_target_tool_prefix"; then
9838       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9839 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9840 echo "$as_me:$LINENO: checking for $ac_word" >&5
9841 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9842 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9843   echo $ECHO_N "(cached) $ECHO_C" >&6
9844 else
9845   if test -n "$LIPO_FOR_TARGET"; then
9846   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9847 else
9848 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9849 for as_dir in $PATH
9850 do
9851   IFS=$as_save_IFS
9852   test -z "$as_dir" && as_dir=.
9853   for ac_exec_ext in '' $ac_executable_extensions; do
9854   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9855     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9856     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9857     break 2
9858   fi
9859 done
9860 done
9861
9862 fi
9863 fi
9864 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9865 if test -n "$LIPO_FOR_TARGET"; then
9866   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9867 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9868 else
9869   echo "$as_me:$LINENO: result: no" >&5
9870 echo "${ECHO_T}no" >&6
9871 fi
9872
9873     fi
9874     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9875       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9876 set dummy ${ncn_progname}; ac_word=$2
9877 echo "$as_me:$LINENO: checking for $ac_word" >&5
9878 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9879 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9880   echo $ECHO_N "(cached) $ECHO_C" >&6
9881 else
9882   if test -n "$LIPO_FOR_TARGET"; then
9883   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9884 else
9885 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9886 for as_dir in $PATH
9887 do
9888   IFS=$as_save_IFS
9889   test -z "$as_dir" && as_dir=.
9890   for ac_exec_ext in '' $ac_executable_extensions; do
9891   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9892     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9893     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9894     break 2
9895   fi
9896 done
9897 done
9898
9899 fi
9900 fi
9901 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9902 if test -n "$LIPO_FOR_TARGET"; then
9903   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9904 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9905 else
9906   echo "$as_me:$LINENO: result: no" >&5
9907 echo "${ECHO_T}no" >&6
9908 fi
9909
9910     fi
9911     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9912   done
9913 fi
9914
9915 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9916   set dummy lipo
9917   if test $build = $target ; then
9918     LIPO_FOR_TARGET="$2"
9919   else
9920     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9921   fi
9922 else
9923   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9924 fi
9925
9926 else
9927   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9928 fi
9929
9930
9931
9932
9933 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9934   if test -n "$with_build_time_tools"; then
9935     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9936 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9937     if test -x $with_build_time_tools/nm; then
9938       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9939       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9940       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9941 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9942     else
9943       echo "$as_me:$LINENO: result: no" >&5
9944 echo "${ECHO_T}no" >&6
9945     fi
9946   elif test $build != $host && test $have_gcc_for_target = yes; then
9947     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9948     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
9949     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9950   fi
9951 fi
9952 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9953   # Extract the first word of "nm", so it can be a program name with args.
9954 set dummy nm; ac_word=$2
9955 echo "$as_me:$LINENO: checking for $ac_word" >&5
9956 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9957 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9958   echo $ECHO_N "(cached) $ECHO_C" >&6
9959 else
9960   case $NM_FOR_TARGET in
9961   [\\/]* | ?:[\\/]*)
9962   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9963   ;;
9964   *)
9965   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9966 for as_dir in $gcc_cv_tool_dirs
9967 do
9968   IFS=$as_save_IFS
9969   test -z "$as_dir" && as_dir=.
9970   for ac_exec_ext in '' $ac_executable_extensions; do
9971   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9972     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9973     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9974     break 2
9975   fi
9976 done
9977 done
9978
9979   ;;
9980 esac
9981 fi
9982 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9983
9984 if test -n "$NM_FOR_TARGET"; then
9985   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9986 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9987 else
9988   echo "$as_me:$LINENO: result: no" >&5
9989 echo "${ECHO_T}no" >&6
9990 fi
9991
9992 fi
9993 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9994
9995
9996 if test -n "$NM_FOR_TARGET"; then
9997   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
9998 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9999   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10000 fi
10001
10002 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10003   for ncn_progname in nm; do
10004     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10005 set dummy ${ncn_progname}; ac_word=$2
10006 echo "$as_me:$LINENO: checking for $ac_word" >&5
10007 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10008 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10009   echo $ECHO_N "(cached) $ECHO_C" >&6
10010 else
10011   if test -n "$NM_FOR_TARGET"; then
10012   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10013 else
10014 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10015 for as_dir in $PATH
10016 do
10017   IFS=$as_save_IFS
10018   test -z "$as_dir" && as_dir=.
10019   for ac_exec_ext in '' $ac_executable_extensions; do
10020   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10021     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10022     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10023     break 2
10024   fi
10025 done
10026 done
10027
10028 fi
10029 fi
10030 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10031 if test -n "$NM_FOR_TARGET"; then
10032   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10033 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10034 else
10035   echo "$as_me:$LINENO: result: no" >&5
10036 echo "${ECHO_T}no" >&6
10037 fi
10038
10039   done
10040 fi
10041
10042 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10043   for ncn_progname in nm; do
10044     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10045 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10046     if test -x $with_build_time_tools/${ncn_progname}; then
10047       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10048       echo "$as_me:$LINENO: result: yes" >&5
10049 echo "${ECHO_T}yes" >&6
10050       break
10051     else
10052       echo "$as_me:$LINENO: result: no" >&5
10053 echo "${ECHO_T}no" >&6
10054     fi
10055   done
10056 fi
10057
10058 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10059   for ncn_progname in nm; do
10060     if test -n "$ncn_target_tool_prefix"; then
10061       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10062 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10063 echo "$as_me:$LINENO: checking for $ac_word" >&5
10064 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10065 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10066   echo $ECHO_N "(cached) $ECHO_C" >&6
10067 else
10068   if test -n "$NM_FOR_TARGET"; then
10069   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10070 else
10071 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10072 for as_dir in $PATH
10073 do
10074   IFS=$as_save_IFS
10075   test -z "$as_dir" && as_dir=.
10076   for ac_exec_ext in '' $ac_executable_extensions; do
10077   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10078     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10079     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10080     break 2
10081   fi
10082 done
10083 done
10084
10085 fi
10086 fi
10087 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10088 if test -n "$NM_FOR_TARGET"; then
10089   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10090 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10091 else
10092   echo "$as_me:$LINENO: result: no" >&5
10093 echo "${ECHO_T}no" >&6
10094 fi
10095
10096     fi
10097     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10098       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10099 set dummy ${ncn_progname}; ac_word=$2
10100 echo "$as_me:$LINENO: checking for $ac_word" >&5
10101 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10102 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10103   echo $ECHO_N "(cached) $ECHO_C" >&6
10104 else
10105   if test -n "$NM_FOR_TARGET"; then
10106   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10107 else
10108 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10109 for as_dir in $PATH
10110 do
10111   IFS=$as_save_IFS
10112   test -z "$as_dir" && as_dir=.
10113   for ac_exec_ext in '' $ac_executable_extensions; do
10114   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10115     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10116     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10117     break 2
10118   fi
10119 done
10120 done
10121
10122 fi
10123 fi
10124 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10125 if test -n "$NM_FOR_TARGET"; then
10126   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10127 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10128 else
10129   echo "$as_me:$LINENO: result: no" >&5
10130 echo "${ECHO_T}no" >&6
10131 fi
10132
10133     fi
10134     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10135   done
10136 fi
10137
10138 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10139   set dummy nm
10140   if test $build = $target ; then
10141     NM_FOR_TARGET="$2"
10142   else
10143     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10144   fi
10145 else
10146   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10147 fi
10148
10149 else
10150   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10151 fi
10152
10153
10154
10155
10156 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10157   if test -n "$with_build_time_tools"; then
10158     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10159 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10160     if test -x $with_build_time_tools/objdump; then
10161       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10162       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10163       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10164 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10165     else
10166       echo "$as_me:$LINENO: result: no" >&5
10167 echo "${ECHO_T}no" >&6
10168     fi
10169   elif test $build != $host && test $have_gcc_for_target = yes; then
10170     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10171     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10172     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10173   fi
10174 fi
10175 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10176   # Extract the first word of "objdump", so it can be a program name with args.
10177 set dummy objdump; ac_word=$2
10178 echo "$as_me:$LINENO: checking for $ac_word" >&5
10179 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10180 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10181   echo $ECHO_N "(cached) $ECHO_C" >&6
10182 else
10183   case $OBJDUMP_FOR_TARGET in
10184   [\\/]* | ?:[\\/]*)
10185   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10186   ;;
10187   *)
10188   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10189 for as_dir in $gcc_cv_tool_dirs
10190 do
10191   IFS=$as_save_IFS
10192   test -z "$as_dir" && as_dir=.
10193   for ac_exec_ext in '' $ac_executable_extensions; do
10194   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10195     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10196     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10197     break 2
10198   fi
10199 done
10200 done
10201
10202   ;;
10203 esac
10204 fi
10205 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10206
10207 if test -n "$OBJDUMP_FOR_TARGET"; then
10208   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10209 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10210 else
10211   echo "$as_me:$LINENO: result: no" >&5
10212 echo "${ECHO_T}no" >&6
10213 fi
10214
10215 fi
10216 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10217
10218
10219 if test -n "$OBJDUMP_FOR_TARGET"; then
10220   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10221 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10222   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10223 fi
10224
10225 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10226   for ncn_progname in objdump; do
10227     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10228 set dummy ${ncn_progname}; ac_word=$2
10229 echo "$as_me:$LINENO: checking for $ac_word" >&5
10230 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10231 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10232   echo $ECHO_N "(cached) $ECHO_C" >&6
10233 else
10234   if test -n "$OBJDUMP_FOR_TARGET"; then
10235   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10236 else
10237 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10238 for as_dir in $PATH
10239 do
10240   IFS=$as_save_IFS
10241   test -z "$as_dir" && as_dir=.
10242   for ac_exec_ext in '' $ac_executable_extensions; do
10243   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10244     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10245     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10246     break 2
10247   fi
10248 done
10249 done
10250
10251 fi
10252 fi
10253 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10254 if test -n "$OBJDUMP_FOR_TARGET"; then
10255   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10256 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10257 else
10258   echo "$as_me:$LINENO: result: no" >&5
10259 echo "${ECHO_T}no" >&6
10260 fi
10261
10262   done
10263 fi
10264
10265 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10266   for ncn_progname in objdump; do
10267     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10268 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10269     if test -x $with_build_time_tools/${ncn_progname}; then
10270       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10271       echo "$as_me:$LINENO: result: yes" >&5
10272 echo "${ECHO_T}yes" >&6
10273       break
10274     else
10275       echo "$as_me:$LINENO: result: no" >&5
10276 echo "${ECHO_T}no" >&6
10277     fi
10278   done
10279 fi
10280
10281 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10282   for ncn_progname in objdump; do
10283     if test -n "$ncn_target_tool_prefix"; then
10284       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10285 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10286 echo "$as_me:$LINENO: checking for $ac_word" >&5
10287 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10288 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10289   echo $ECHO_N "(cached) $ECHO_C" >&6
10290 else
10291   if test -n "$OBJDUMP_FOR_TARGET"; then
10292   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10293 else
10294 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10295 for as_dir in $PATH
10296 do
10297   IFS=$as_save_IFS
10298   test -z "$as_dir" && as_dir=.
10299   for ac_exec_ext in '' $ac_executable_extensions; do
10300   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10301     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10302     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10303     break 2
10304   fi
10305 done
10306 done
10307
10308 fi
10309 fi
10310 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10311 if test -n "$OBJDUMP_FOR_TARGET"; then
10312   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10313 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10314 else
10315   echo "$as_me:$LINENO: result: no" >&5
10316 echo "${ECHO_T}no" >&6
10317 fi
10318
10319     fi
10320     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10321       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10322 set dummy ${ncn_progname}; ac_word=$2
10323 echo "$as_me:$LINENO: checking for $ac_word" >&5
10324 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10325 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10326   echo $ECHO_N "(cached) $ECHO_C" >&6
10327 else
10328   if test -n "$OBJDUMP_FOR_TARGET"; then
10329   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10330 else
10331 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10332 for as_dir in $PATH
10333 do
10334   IFS=$as_save_IFS
10335   test -z "$as_dir" && as_dir=.
10336   for ac_exec_ext in '' $ac_executable_extensions; do
10337   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10338     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10339     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10340     break 2
10341   fi
10342 done
10343 done
10344
10345 fi
10346 fi
10347 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10348 if test -n "$OBJDUMP_FOR_TARGET"; then
10349   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10350 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10351 else
10352   echo "$as_me:$LINENO: result: no" >&5
10353 echo "${ECHO_T}no" >&6
10354 fi
10355
10356     fi
10357     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10358   done
10359 fi
10360
10361 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10362   set dummy objdump
10363   if test $build = $target ; then
10364     OBJDUMP_FOR_TARGET="$2"
10365   else
10366     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10367   fi
10368 else
10369   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10370 fi
10371
10372 else
10373   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10374 fi
10375
10376
10377
10378
10379 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10380   if test -n "$with_build_time_tools"; then
10381     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10382 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10383     if test -x $with_build_time_tools/ranlib; then
10384       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10385       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10386       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10387 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10388     else
10389       echo "$as_me:$LINENO: result: no" >&5
10390 echo "${ECHO_T}no" >&6
10391     fi
10392   elif test $build != $host && test $have_gcc_for_target = yes; then
10393     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10394     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10395     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10396   fi
10397 fi
10398 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10399   # Extract the first word of "ranlib", so it can be a program name with args.
10400 set dummy ranlib; ac_word=$2
10401 echo "$as_me:$LINENO: checking for $ac_word" >&5
10402 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10403 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10404   echo $ECHO_N "(cached) $ECHO_C" >&6
10405 else
10406   case $RANLIB_FOR_TARGET in
10407   [\\/]* | ?:[\\/]*)
10408   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10409   ;;
10410   *)
10411   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10412 for as_dir in $gcc_cv_tool_dirs
10413 do
10414   IFS=$as_save_IFS
10415   test -z "$as_dir" && as_dir=.
10416   for ac_exec_ext in '' $ac_executable_extensions; do
10417   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10418     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10419     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10420     break 2
10421   fi
10422 done
10423 done
10424
10425   ;;
10426 esac
10427 fi
10428 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10429
10430 if test -n "$RANLIB_FOR_TARGET"; then
10431   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10432 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10433 else
10434   echo "$as_me:$LINENO: result: no" >&5
10435 echo "${ECHO_T}no" >&6
10436 fi
10437
10438 fi
10439 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10440
10441
10442 if test -n "$RANLIB_FOR_TARGET"; then
10443   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10444 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10445   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10446 fi
10447
10448 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10449   for ncn_progname in ranlib; do
10450     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10451 set dummy ${ncn_progname}; ac_word=$2
10452 echo "$as_me:$LINENO: checking for $ac_word" >&5
10453 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10454 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10455   echo $ECHO_N "(cached) $ECHO_C" >&6
10456 else
10457   if test -n "$RANLIB_FOR_TARGET"; then
10458   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10459 else
10460 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10461 for as_dir in $PATH
10462 do
10463   IFS=$as_save_IFS
10464   test -z "$as_dir" && as_dir=.
10465   for ac_exec_ext in '' $ac_executable_extensions; do
10466   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10467     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10468     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10469     break 2
10470   fi
10471 done
10472 done
10473
10474 fi
10475 fi
10476 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10477 if test -n "$RANLIB_FOR_TARGET"; then
10478   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10479 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10480 else
10481   echo "$as_me:$LINENO: result: no" >&5
10482 echo "${ECHO_T}no" >&6
10483 fi
10484
10485   done
10486 fi
10487
10488 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10489   for ncn_progname in ranlib; do
10490     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10491 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10492     if test -x $with_build_time_tools/${ncn_progname}; then
10493       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10494       echo "$as_me:$LINENO: result: yes" >&5
10495 echo "${ECHO_T}yes" >&6
10496       break
10497     else
10498       echo "$as_me:$LINENO: result: no" >&5
10499 echo "${ECHO_T}no" >&6
10500     fi
10501   done
10502 fi
10503
10504 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10505   for ncn_progname in ranlib; do
10506     if test -n "$ncn_target_tool_prefix"; then
10507       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10508 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10509 echo "$as_me:$LINENO: checking for $ac_word" >&5
10510 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10511 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10512   echo $ECHO_N "(cached) $ECHO_C" >&6
10513 else
10514   if test -n "$RANLIB_FOR_TARGET"; then
10515   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10516 else
10517 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10518 for as_dir in $PATH
10519 do
10520   IFS=$as_save_IFS
10521   test -z "$as_dir" && as_dir=.
10522   for ac_exec_ext in '' $ac_executable_extensions; do
10523   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10524     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10525     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10526     break 2
10527   fi
10528 done
10529 done
10530
10531 fi
10532 fi
10533 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10534 if test -n "$RANLIB_FOR_TARGET"; then
10535   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10536 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10537 else
10538   echo "$as_me:$LINENO: result: no" >&5
10539 echo "${ECHO_T}no" >&6
10540 fi
10541
10542     fi
10543     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10544       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10545 set dummy ${ncn_progname}; ac_word=$2
10546 echo "$as_me:$LINENO: checking for $ac_word" >&5
10547 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10548 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10549   echo $ECHO_N "(cached) $ECHO_C" >&6
10550 else
10551   if test -n "$RANLIB_FOR_TARGET"; then
10552   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10553 else
10554 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10555 for as_dir in $PATH
10556 do
10557   IFS=$as_save_IFS
10558   test -z "$as_dir" && as_dir=.
10559   for ac_exec_ext in '' $ac_executable_extensions; do
10560   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10561     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10562     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10563     break 2
10564   fi
10565 done
10566 done
10567
10568 fi
10569 fi
10570 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10571 if test -n "$RANLIB_FOR_TARGET"; then
10572   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10573 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10574 else
10575   echo "$as_me:$LINENO: result: no" >&5
10576 echo "${ECHO_T}no" >&6
10577 fi
10578
10579     fi
10580     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10581   done
10582 fi
10583
10584 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10585   set dummy ranlib
10586   if test $build = $target ; then
10587     RANLIB_FOR_TARGET="$2"
10588   else
10589     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10590   fi
10591 else
10592   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10593 fi
10594
10595 else
10596   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10597 fi
10598
10599
10600
10601
10602 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10603   if test -n "$with_build_time_tools"; then
10604     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10605 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10606     if test -x $with_build_time_tools/strip; then
10607       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10608       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10609       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10610 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10611     else
10612       echo "$as_me:$LINENO: result: no" >&5
10613 echo "${ECHO_T}no" >&6
10614     fi
10615   elif test $build != $host && test $have_gcc_for_target = yes; then
10616     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10617     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10618     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10619   fi
10620 fi
10621 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10622   # Extract the first word of "strip", so it can be a program name with args.
10623 set dummy strip; ac_word=$2
10624 echo "$as_me:$LINENO: checking for $ac_word" >&5
10625 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10626 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10627   echo $ECHO_N "(cached) $ECHO_C" >&6
10628 else
10629   case $STRIP_FOR_TARGET in
10630   [\\/]* | ?:[\\/]*)
10631   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10632   ;;
10633   *)
10634   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10635 for as_dir in $gcc_cv_tool_dirs
10636 do
10637   IFS=$as_save_IFS
10638   test -z "$as_dir" && as_dir=.
10639   for ac_exec_ext in '' $ac_executable_extensions; do
10640   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10641     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10642     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10643     break 2
10644   fi
10645 done
10646 done
10647
10648   ;;
10649 esac
10650 fi
10651 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10652
10653 if test -n "$STRIP_FOR_TARGET"; then
10654   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10655 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10656 else
10657   echo "$as_me:$LINENO: result: no" >&5
10658 echo "${ECHO_T}no" >&6
10659 fi
10660
10661 fi
10662 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10663
10664
10665 if test -n "$STRIP_FOR_TARGET"; then
10666   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10667 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10668   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10669 fi
10670
10671 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10672   for ncn_progname in strip; do
10673     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10674 set dummy ${ncn_progname}; ac_word=$2
10675 echo "$as_me:$LINENO: checking for $ac_word" >&5
10676 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10677 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10678   echo $ECHO_N "(cached) $ECHO_C" >&6
10679 else
10680   if test -n "$STRIP_FOR_TARGET"; then
10681   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10682 else
10683 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10684 for as_dir in $PATH
10685 do
10686   IFS=$as_save_IFS
10687   test -z "$as_dir" && as_dir=.
10688   for ac_exec_ext in '' $ac_executable_extensions; do
10689   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10690     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10691     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10692     break 2
10693   fi
10694 done
10695 done
10696
10697 fi
10698 fi
10699 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10700 if test -n "$STRIP_FOR_TARGET"; then
10701   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10702 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10703 else
10704   echo "$as_me:$LINENO: result: no" >&5
10705 echo "${ECHO_T}no" >&6
10706 fi
10707
10708   done
10709 fi
10710
10711 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10712   for ncn_progname in strip; do
10713     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10714 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10715     if test -x $with_build_time_tools/${ncn_progname}; then
10716       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10717       echo "$as_me:$LINENO: result: yes" >&5
10718 echo "${ECHO_T}yes" >&6
10719       break
10720     else
10721       echo "$as_me:$LINENO: result: no" >&5
10722 echo "${ECHO_T}no" >&6
10723     fi
10724   done
10725 fi
10726
10727 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10728   for ncn_progname in strip; do
10729     if test -n "$ncn_target_tool_prefix"; then
10730       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10731 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10732 echo "$as_me:$LINENO: checking for $ac_word" >&5
10733 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10734 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10735   echo $ECHO_N "(cached) $ECHO_C" >&6
10736 else
10737   if test -n "$STRIP_FOR_TARGET"; then
10738   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10739 else
10740 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10741 for as_dir in $PATH
10742 do
10743   IFS=$as_save_IFS
10744   test -z "$as_dir" && as_dir=.
10745   for ac_exec_ext in '' $ac_executable_extensions; do
10746   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10747     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10748     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10749     break 2
10750   fi
10751 done
10752 done
10753
10754 fi
10755 fi
10756 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10757 if test -n "$STRIP_FOR_TARGET"; then
10758   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10759 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10760 else
10761   echo "$as_me:$LINENO: result: no" >&5
10762 echo "${ECHO_T}no" >&6
10763 fi
10764
10765     fi
10766     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10767       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10768 set dummy ${ncn_progname}; ac_word=$2
10769 echo "$as_me:$LINENO: checking for $ac_word" >&5
10770 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10771 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10772   echo $ECHO_N "(cached) $ECHO_C" >&6
10773 else
10774   if test -n "$STRIP_FOR_TARGET"; then
10775   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10776 else
10777 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10778 for as_dir in $PATH
10779 do
10780   IFS=$as_save_IFS
10781   test -z "$as_dir" && as_dir=.
10782   for ac_exec_ext in '' $ac_executable_extensions; do
10783   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10784     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10785     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10786     break 2
10787   fi
10788 done
10789 done
10790
10791 fi
10792 fi
10793 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10794 if test -n "$STRIP_FOR_TARGET"; then
10795   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10796 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10797 else
10798   echo "$as_me:$LINENO: result: no" >&5
10799 echo "${ECHO_T}no" >&6
10800 fi
10801
10802     fi
10803     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10804   done
10805 fi
10806
10807 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10808   set dummy strip
10809   if test $build = $target ; then
10810     STRIP_FOR_TARGET="$2"
10811   else
10812     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10813   fi
10814 else
10815   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10816 fi
10817
10818 else
10819   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10820 fi
10821
10822
10823
10824
10825 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10826   if test -n "$with_build_time_tools"; then
10827     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10828 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10829     if test -x $with_build_time_tools/windres; then
10830       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10831       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10832       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10833 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10834     else
10835       echo "$as_me:$LINENO: result: no" >&5
10836 echo "${ECHO_T}no" >&6
10837     fi
10838   elif test $build != $host && test $have_gcc_for_target = yes; then
10839     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10840     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10841     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10842   fi
10843 fi
10844 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10845   # Extract the first word of "windres", so it can be a program name with args.
10846 set dummy windres; ac_word=$2
10847 echo "$as_me:$LINENO: checking for $ac_word" >&5
10848 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10849 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10850   echo $ECHO_N "(cached) $ECHO_C" >&6
10851 else
10852   case $WINDRES_FOR_TARGET in
10853   [\\/]* | ?:[\\/]*)
10854   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10855   ;;
10856   *)
10857   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10858 for as_dir in $gcc_cv_tool_dirs
10859 do
10860   IFS=$as_save_IFS
10861   test -z "$as_dir" && as_dir=.
10862   for ac_exec_ext in '' $ac_executable_extensions; do
10863   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10864     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10865     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10866     break 2
10867   fi
10868 done
10869 done
10870
10871   ;;
10872 esac
10873 fi
10874 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10875
10876 if test -n "$WINDRES_FOR_TARGET"; then
10877   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10878 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10879 else
10880   echo "$as_me:$LINENO: result: no" >&5
10881 echo "${ECHO_T}no" >&6
10882 fi
10883
10884 fi
10885 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10886
10887
10888 if test -n "$WINDRES_FOR_TARGET"; then
10889   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10890 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10891   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10892 fi
10893
10894 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10895   for ncn_progname in windres; do
10896     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10897 set dummy ${ncn_progname}; ac_word=$2
10898 echo "$as_me:$LINENO: checking for $ac_word" >&5
10899 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10900 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10901   echo $ECHO_N "(cached) $ECHO_C" >&6
10902 else
10903   if test -n "$WINDRES_FOR_TARGET"; then
10904   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10905 else
10906 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10907 for as_dir in $PATH
10908 do
10909   IFS=$as_save_IFS
10910   test -z "$as_dir" && as_dir=.
10911   for ac_exec_ext in '' $ac_executable_extensions; do
10912   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10913     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10914     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10915     break 2
10916   fi
10917 done
10918 done
10919
10920 fi
10921 fi
10922 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10923 if test -n "$WINDRES_FOR_TARGET"; then
10924   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10925 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10926 else
10927   echo "$as_me:$LINENO: result: no" >&5
10928 echo "${ECHO_T}no" >&6
10929 fi
10930
10931   done
10932 fi
10933
10934 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10935   for ncn_progname in windres; do
10936     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10937 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10938     if test -x $with_build_time_tools/${ncn_progname}; then
10939       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10940       echo "$as_me:$LINENO: result: yes" >&5
10941 echo "${ECHO_T}yes" >&6
10942       break
10943     else
10944       echo "$as_me:$LINENO: result: no" >&5
10945 echo "${ECHO_T}no" >&6
10946     fi
10947   done
10948 fi
10949
10950 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10951   for ncn_progname in windres; do
10952     if test -n "$ncn_target_tool_prefix"; then
10953       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10954 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10955 echo "$as_me:$LINENO: checking for $ac_word" >&5
10956 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10957 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10958   echo $ECHO_N "(cached) $ECHO_C" >&6
10959 else
10960   if test -n "$WINDRES_FOR_TARGET"; then
10961   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10962 else
10963 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10964 for as_dir in $PATH
10965 do
10966   IFS=$as_save_IFS
10967   test -z "$as_dir" && as_dir=.
10968   for ac_exec_ext in '' $ac_executable_extensions; do
10969   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10970     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10971     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10972     break 2
10973   fi
10974 done
10975 done
10976
10977 fi
10978 fi
10979 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10980 if test -n "$WINDRES_FOR_TARGET"; then
10981   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10982 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10983 else
10984   echo "$as_me:$LINENO: result: no" >&5
10985 echo "${ECHO_T}no" >&6
10986 fi
10987
10988     fi
10989     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
10990       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10991 set dummy ${ncn_progname}; ac_word=$2
10992 echo "$as_me:$LINENO: checking for $ac_word" >&5
10993 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10994 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10995   echo $ECHO_N "(cached) $ECHO_C" >&6
10996 else
10997   if test -n "$WINDRES_FOR_TARGET"; then
10998   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10999 else
11000 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11001 for as_dir in $PATH
11002 do
11003   IFS=$as_save_IFS
11004   test -z "$as_dir" && as_dir=.
11005   for ac_exec_ext in '' $ac_executable_extensions; do
11006   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11007     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11008     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11009     break 2
11010   fi
11011 done
11012 done
11013
11014 fi
11015 fi
11016 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11017 if test -n "$WINDRES_FOR_TARGET"; then
11018   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11019 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11020 else
11021   echo "$as_me:$LINENO: result: no" >&5
11022 echo "${ECHO_T}no" >&6
11023 fi
11024
11025     fi
11026     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11027   done
11028 fi
11029
11030 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11031   set dummy windres
11032   if test $build = $target ; then
11033     WINDRES_FOR_TARGET="$2"
11034   else
11035     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11036   fi
11037 else
11038   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11039 fi
11040
11041 else
11042   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11043 fi
11044
11045
11046
11047
11048 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11049   if test -n "$with_build_time_tools"; then
11050     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11051 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11052     if test -x $with_build_time_tools/windmc; then
11053       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11054       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11055       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11056 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11057     else
11058       echo "$as_me:$LINENO: result: no" >&5
11059 echo "${ECHO_T}no" >&6
11060     fi
11061   elif test $build != $host && test $have_gcc_for_target = yes; then
11062     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11063     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11064     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11065   fi
11066 fi
11067 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11068   # Extract the first word of "windmc", so it can be a program name with args.
11069 set dummy windmc; ac_word=$2
11070 echo "$as_me:$LINENO: checking for $ac_word" >&5
11071 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11072 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11073   echo $ECHO_N "(cached) $ECHO_C" >&6
11074 else
11075   case $WINDMC_FOR_TARGET in
11076   [\\/]* | ?:[\\/]*)
11077   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11078   ;;
11079   *)
11080   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11081 for as_dir in $gcc_cv_tool_dirs
11082 do
11083   IFS=$as_save_IFS
11084   test -z "$as_dir" && as_dir=.
11085   for ac_exec_ext in '' $ac_executable_extensions; do
11086   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11087     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11088     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11089     break 2
11090   fi
11091 done
11092 done
11093
11094   ;;
11095 esac
11096 fi
11097 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11098
11099 if test -n "$WINDMC_FOR_TARGET"; then
11100   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11101 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11102 else
11103   echo "$as_me:$LINENO: result: no" >&5
11104 echo "${ECHO_T}no" >&6
11105 fi
11106
11107 fi
11108 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11109
11110
11111 if test -n "$WINDMC_FOR_TARGET"; then
11112   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11113 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11114   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11115 fi
11116
11117 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11118   for ncn_progname in windmc; do
11119     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11120 set dummy ${ncn_progname}; ac_word=$2
11121 echo "$as_me:$LINENO: checking for $ac_word" >&5
11122 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11123 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11124   echo $ECHO_N "(cached) $ECHO_C" >&6
11125 else
11126   if test -n "$WINDMC_FOR_TARGET"; then
11127   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11128 else
11129 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11130 for as_dir in $PATH
11131 do
11132   IFS=$as_save_IFS
11133   test -z "$as_dir" && as_dir=.
11134   for ac_exec_ext in '' $ac_executable_extensions; do
11135   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11136     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11137     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11138     break 2
11139   fi
11140 done
11141 done
11142
11143 fi
11144 fi
11145 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11146 if test -n "$WINDMC_FOR_TARGET"; then
11147   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11148 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11149 else
11150   echo "$as_me:$LINENO: result: no" >&5
11151 echo "${ECHO_T}no" >&6
11152 fi
11153
11154   done
11155 fi
11156
11157 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11158   for ncn_progname in windmc; do
11159     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11160 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11161     if test -x $with_build_time_tools/${ncn_progname}; then
11162       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11163       echo "$as_me:$LINENO: result: yes" >&5
11164 echo "${ECHO_T}yes" >&6
11165       break
11166     else
11167       echo "$as_me:$LINENO: result: no" >&5
11168 echo "${ECHO_T}no" >&6
11169     fi
11170   done
11171 fi
11172
11173 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11174   for ncn_progname in windmc; do
11175     if test -n "$ncn_target_tool_prefix"; then
11176       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11177 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11178 echo "$as_me:$LINENO: checking for $ac_word" >&5
11179 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11180 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11181   echo $ECHO_N "(cached) $ECHO_C" >&6
11182 else
11183   if test -n "$WINDMC_FOR_TARGET"; then
11184   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11185 else
11186 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11187 for as_dir in $PATH
11188 do
11189   IFS=$as_save_IFS
11190   test -z "$as_dir" && as_dir=.
11191   for ac_exec_ext in '' $ac_executable_extensions; do
11192   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11193     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11194     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11195     break 2
11196   fi
11197 done
11198 done
11199
11200 fi
11201 fi
11202 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11203 if test -n "$WINDMC_FOR_TARGET"; then
11204   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11205 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11206 else
11207   echo "$as_me:$LINENO: result: no" >&5
11208 echo "${ECHO_T}no" >&6
11209 fi
11210
11211     fi
11212     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11213       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11214 set dummy ${ncn_progname}; ac_word=$2
11215 echo "$as_me:$LINENO: checking for $ac_word" >&5
11216 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11217 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11218   echo $ECHO_N "(cached) $ECHO_C" >&6
11219 else
11220   if test -n "$WINDMC_FOR_TARGET"; then
11221   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11222 else
11223 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11224 for as_dir in $PATH
11225 do
11226   IFS=$as_save_IFS
11227   test -z "$as_dir" && as_dir=.
11228   for ac_exec_ext in '' $ac_executable_extensions; do
11229   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11230     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11231     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11232     break 2
11233   fi
11234 done
11235 done
11236
11237 fi
11238 fi
11239 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11240 if test -n "$WINDMC_FOR_TARGET"; then
11241   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11242 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11243 else
11244   echo "$as_me:$LINENO: result: no" >&5
11245 echo "${ECHO_T}no" >&6
11246 fi
11247
11248     fi
11249     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11250   done
11251 fi
11252
11253 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11254   set dummy windmc
11255   if test $build = $target ; then
11256     WINDMC_FOR_TARGET="$2"
11257   else
11258     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11259   fi
11260 else
11261   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11262 fi
11263
11264 else
11265   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11266 fi
11267
11268
11269 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11270
11271 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11272 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11273 if test "x${build}" != "x${host}" ; then
11274   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11275     # We already found the complete path
11276     ac_dir=`dirname $AR_FOR_TARGET`
11277     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11278 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11279   else
11280     # Canadian cross, just use what we found
11281     echo "$as_me:$LINENO: result: pre-installed" >&5
11282 echo "${ECHO_T}pre-installed" >&6
11283   fi
11284 else
11285   ok=yes
11286   case " ${configdirs} " in
11287     *" binutils "*) ;;
11288     *) ok=no ;;
11289   esac
11290
11291   if test $ok = yes; then
11292     # An in-tree tool is available and we can use it
11293     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11294     echo "$as_me:$LINENO: result: just compiled" >&5
11295 echo "${ECHO_T}just compiled" >&6
11296   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11297     # We already found the complete path
11298     ac_dir=`dirname $AR_FOR_TARGET`
11299     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11300 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11301   elif test "x$target" = "x$host"; then
11302     # We can use an host tool
11303     AR_FOR_TARGET='$(AR)'
11304     echo "$as_me:$LINENO: result: host tool" >&5
11305 echo "${ECHO_T}host tool" >&6
11306   else
11307     # We need a cross tool
11308     echo "$as_me:$LINENO: result: pre-installed" >&5
11309 echo "${ECHO_T}pre-installed" >&6
11310   fi
11311 fi
11312
11313 echo "$as_me:$LINENO: checking where to find the target as" >&5
11314 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11315 if test "x${build}" != "x${host}" ; then
11316   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11317     # We already found the complete path
11318     ac_dir=`dirname $AS_FOR_TARGET`
11319     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11320 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11321   else
11322     # Canadian cross, just use what we found
11323     echo "$as_me:$LINENO: result: pre-installed" >&5
11324 echo "${ECHO_T}pre-installed" >&6
11325   fi
11326 else
11327   ok=yes
11328   case " ${configdirs} " in
11329     *" gas "*) ;;
11330     *) ok=no ;;
11331   esac
11332
11333   if test $ok = yes; then
11334     # An in-tree tool is available and we can use it
11335     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11336     echo "$as_me:$LINENO: result: just compiled" >&5
11337 echo "${ECHO_T}just compiled" >&6
11338   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11339     # We already found the complete path
11340     ac_dir=`dirname $AS_FOR_TARGET`
11341     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11342 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11343   elif test "x$target" = "x$host"; then
11344     # We can use an host tool
11345     AS_FOR_TARGET='$(AS)'
11346     echo "$as_me:$LINENO: result: host tool" >&5
11347 echo "${ECHO_T}host tool" >&6
11348   else
11349     # We need a cross tool
11350     echo "$as_me:$LINENO: result: pre-installed" >&5
11351 echo "${ECHO_T}pre-installed" >&6
11352   fi
11353 fi
11354
11355 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11356 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11357 if test "x${build}" != "x${host}" ; then
11358   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11359     # We already found the complete path
11360     ac_dir=`dirname $CC_FOR_TARGET`
11361     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11362 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11363   else
11364     # Canadian cross, just use what we found
11365     echo "$as_me:$LINENO: result: pre-installed" >&5
11366 echo "${ECHO_T}pre-installed" >&6
11367   fi
11368 else
11369   ok=yes
11370   case " ${configdirs} " in
11371     *" gcc "*) ;;
11372     *) ok=no ;;
11373   esac
11374
11375   if test $ok = yes; then
11376     # An in-tree tool is available and we can use it
11377     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11378     echo "$as_me:$LINENO: result: just compiled" >&5
11379 echo "${ECHO_T}just compiled" >&6
11380   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11381     # We already found the complete path
11382     ac_dir=`dirname $CC_FOR_TARGET`
11383     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11384 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11385   elif test "x$target" = "x$host"; then
11386     # We can use an host tool
11387     CC_FOR_TARGET='$(CC)'
11388     echo "$as_me:$LINENO: result: host tool" >&5
11389 echo "${ECHO_T}host tool" >&6
11390   else
11391     # We need a cross tool
11392     echo "$as_me:$LINENO: result: pre-installed" >&5
11393 echo "${ECHO_T}pre-installed" >&6
11394   fi
11395 fi
11396
11397 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11398 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11399 if test "x${build}" != "x${host}" ; then
11400   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11401     # We already found the complete path
11402     ac_dir=`dirname $CXX_FOR_TARGET`
11403     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11404 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11405   else
11406     # Canadian cross, just use what we found
11407     echo "$as_me:$LINENO: result: pre-installed" >&5
11408 echo "${ECHO_T}pre-installed" >&6
11409   fi
11410 else
11411   ok=yes
11412   case " ${configdirs} " in
11413     *" gcc "*) ;;
11414     *) ok=no ;;
11415   esac
11416   case ,${enable_languages}, in
11417     *,c++,*) ;;
11418     *) ok=no ;;
11419   esac
11420   if test $ok = yes; then
11421     # An in-tree tool is available and we can use it
11422     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'
11423     echo "$as_me:$LINENO: result: just compiled" >&5
11424 echo "${ECHO_T}just compiled" >&6
11425   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11426     # We already found the complete path
11427     ac_dir=`dirname $CXX_FOR_TARGET`
11428     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11429 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11430   elif test "x$target" = "x$host"; then
11431     # We can use an host tool
11432     CXX_FOR_TARGET='$(CXX)'
11433     echo "$as_me:$LINENO: result: host tool" >&5
11434 echo "${ECHO_T}host tool" >&6
11435   else
11436     # We need a cross tool
11437     echo "$as_me:$LINENO: result: pre-installed" >&5
11438 echo "${ECHO_T}pre-installed" >&6
11439   fi
11440 fi
11441
11442 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11443 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11444 if test "x${build}" != "x${host}" ; then
11445   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11446     # We already found the complete path
11447     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11448     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11449 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11450   else
11451     # Canadian cross, just use what we found
11452     echo "$as_me:$LINENO: result: pre-installed" >&5
11453 echo "${ECHO_T}pre-installed" >&6
11454   fi
11455 else
11456   ok=yes
11457   case " ${configdirs} " in
11458     *" gcc "*) ;;
11459     *) ok=no ;;
11460   esac
11461   case ,${enable_languages}, in
11462     *,c++,*) ;;
11463     *) ok=no ;;
11464   esac
11465   if test $ok = yes; then
11466     # An in-tree tool is available and we can use it
11467     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'
11468     echo "$as_me:$LINENO: result: just compiled" >&5
11469 echo "${ECHO_T}just compiled" >&6
11470   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11471     # We already found the complete path
11472     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11473     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11474 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11475   elif test "x$target" = "x$host"; then
11476     # We can use an host tool
11477     RAW_CXX_FOR_TARGET='$(CXX)'
11478     echo "$as_me:$LINENO: result: host tool" >&5
11479 echo "${ECHO_T}host tool" >&6
11480   else
11481     # We need a cross tool
11482     echo "$as_me:$LINENO: result: pre-installed" >&5
11483 echo "${ECHO_T}pre-installed" >&6
11484   fi
11485 fi
11486
11487 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11488 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11489 if test "x${build}" != "x${host}" ; then
11490   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11491     # We already found the complete path
11492     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11493     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11494 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11495   else
11496     # Canadian cross, just use what we found
11497     echo "$as_me:$LINENO: result: pre-installed" >&5
11498 echo "${ECHO_T}pre-installed" >&6
11499   fi
11500 else
11501   ok=yes
11502   case " ${configdirs} " in
11503     *" binutils "*) ;;
11504     *) ok=no ;;
11505   esac
11506
11507   if test $ok = yes; then
11508     # An in-tree tool is available and we can use it
11509     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11510     echo "$as_me:$LINENO: result: just compiled" >&5
11511 echo "${ECHO_T}just compiled" >&6
11512   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11513     # We already found the complete path
11514     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11515     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11516 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11517   elif test "x$target" = "x$host"; then
11518     # We can use an host tool
11519     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11520     echo "$as_me:$LINENO: result: host tool" >&5
11521 echo "${ECHO_T}host tool" >&6
11522   else
11523     # We need a cross tool
11524     echo "$as_me:$LINENO: result: pre-installed" >&5
11525 echo "${ECHO_T}pre-installed" >&6
11526   fi
11527 fi
11528
11529 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11530 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11531 if test "x${build}" != "x${host}" ; then
11532   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11533     # We already found the complete path
11534     ac_dir=`dirname $GCC_FOR_TARGET`
11535     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11536 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11537   else
11538     # Canadian cross, just use what we found
11539     echo "$as_me:$LINENO: result: pre-installed" >&5
11540 echo "${ECHO_T}pre-installed" >&6
11541   fi
11542 else
11543   ok=yes
11544   case " ${configdirs} " in
11545     *" gcc "*) ;;
11546     *) ok=no ;;
11547   esac
11548
11549   if test $ok = yes; then
11550     # An in-tree tool is available and we can use it
11551     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11552     echo "$as_me:$LINENO: result: just compiled" >&5
11553 echo "${ECHO_T}just compiled" >&6
11554   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11555     # We already found the complete path
11556     ac_dir=`dirname $GCC_FOR_TARGET`
11557     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11558 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11559   elif test "x$target" = "x$host"; then
11560     # We can use an host tool
11561     GCC_FOR_TARGET='$()'
11562     echo "$as_me:$LINENO: result: host tool" >&5
11563 echo "${ECHO_T}host tool" >&6
11564   else
11565     # We need a cross tool
11566     echo "$as_me:$LINENO: result: pre-installed" >&5
11567 echo "${ECHO_T}pre-installed" >&6
11568   fi
11569 fi
11570
11571 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11572 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11573 if test "x${build}" != "x${host}" ; then
11574   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11575     # We already found the complete path
11576     ac_dir=`dirname $GCJ_FOR_TARGET`
11577     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11578 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11579   else
11580     # Canadian cross, just use what we found
11581     echo "$as_me:$LINENO: result: pre-installed" >&5
11582 echo "${ECHO_T}pre-installed" >&6
11583   fi
11584 else
11585   ok=yes
11586   case " ${configdirs} " in
11587     *" gcc "*) ;;
11588     *) ok=no ;;
11589   esac
11590   case ,${enable_languages}, in
11591     *,java,*) ;;
11592     *) ok=no ;;
11593   esac
11594   if test $ok = yes; then
11595     # An in-tree tool is available and we can use it
11596     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11597     echo "$as_me:$LINENO: result: just compiled" >&5
11598 echo "${ECHO_T}just compiled" >&6
11599   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11600     # We already found the complete path
11601     ac_dir=`dirname $GCJ_FOR_TARGET`
11602     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11603 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11604   elif test "x$target" = "x$host"; then
11605     # We can use an host tool
11606     GCJ_FOR_TARGET='$(GCJ)'
11607     echo "$as_me:$LINENO: result: host tool" >&5
11608 echo "${ECHO_T}host tool" >&6
11609   else
11610     # We need a cross tool
11611     echo "$as_me:$LINENO: result: pre-installed" >&5
11612 echo "${ECHO_T}pre-installed" >&6
11613   fi
11614 fi
11615
11616 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11617 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11618 if test "x${build}" != "x${host}" ; then
11619   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11620     # We already found the complete path
11621     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11622     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11623 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11624   else
11625     # Canadian cross, just use what we found
11626     echo "$as_me:$LINENO: result: pre-installed" >&5
11627 echo "${ECHO_T}pre-installed" >&6
11628   fi
11629 else
11630   ok=yes
11631   case " ${configdirs} " in
11632     *" gcc "*) ;;
11633     *) ok=no ;;
11634   esac
11635   case ,${enable_languages}, in
11636     *,fortran,*) ;;
11637     *) ok=no ;;
11638   esac
11639   if test $ok = yes; then
11640     # An in-tree tool is available and we can use it
11641     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11642     echo "$as_me:$LINENO: result: just compiled" >&5
11643 echo "${ECHO_T}just compiled" >&6
11644   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11645     # We already found the complete path
11646     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11647     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11648 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11649   elif test "x$target" = "x$host"; then
11650     # We can use an host tool
11651     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11652     echo "$as_me:$LINENO: result: host tool" >&5
11653 echo "${ECHO_T}host tool" >&6
11654   else
11655     # We need a cross tool
11656     echo "$as_me:$LINENO: result: pre-installed" >&5
11657 echo "${ECHO_T}pre-installed" >&6
11658   fi
11659 fi
11660
11661 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11662 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11663 if test "x${build}" != "x${host}" ; then
11664   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11665     # We already found the complete path
11666     ac_dir=`dirname $LD_FOR_TARGET`
11667     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11668 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11669   else
11670     # Canadian cross, just use what we found
11671     echo "$as_me:$LINENO: result: pre-installed" >&5
11672 echo "${ECHO_T}pre-installed" >&6
11673   fi
11674 else
11675   ok=yes
11676   case " ${configdirs} " in
11677     *" ld "*) ;;
11678     *) ok=no ;;
11679   esac
11680
11681   if test $ok = yes; then
11682     # An in-tree tool is available and we can use it
11683     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11684     echo "$as_me:$LINENO: result: just compiled" >&5
11685 echo "${ECHO_T}just compiled" >&6
11686   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11687     # We already found the complete path
11688     ac_dir=`dirname $LD_FOR_TARGET`
11689     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11690 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11691   elif test "x$target" = "x$host"; then
11692     # We can use an host tool
11693     LD_FOR_TARGET='$(LD)'
11694     echo "$as_me:$LINENO: result: host tool" >&5
11695 echo "${ECHO_T}host tool" >&6
11696   else
11697     # We need a cross tool
11698     echo "$as_me:$LINENO: result: pre-installed" >&5
11699 echo "${ECHO_T}pre-installed" >&6
11700   fi
11701 fi
11702
11703 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11704 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11705 if test "x${build}" != "x${host}" ; then
11706   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11707     # We already found the complete path
11708     ac_dir=`dirname $LIPO_FOR_TARGET`
11709     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11710 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11711   else
11712     # Canadian cross, just use what we found
11713     echo "$as_me:$LINENO: result: pre-installed" >&5
11714 echo "${ECHO_T}pre-installed" >&6
11715   fi
11716 else
11717   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11718     # We already found the complete path
11719     ac_dir=`dirname $LIPO_FOR_TARGET`
11720     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11721 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11722   elif test "x$target" = "x$host"; then
11723     # We can use an host tool
11724     LIPO_FOR_TARGET='$(LIPO)'
11725     echo "$as_me:$LINENO: result: host tool" >&5
11726 echo "${ECHO_T}host tool" >&6
11727   else
11728     # We need a cross tool
11729     echo "$as_me:$LINENO: result: pre-installed" >&5
11730 echo "${ECHO_T}pre-installed" >&6
11731   fi
11732 fi
11733
11734 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11735 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11736 if test "x${build}" != "x${host}" ; then
11737   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11738     # We already found the complete path
11739     ac_dir=`dirname $NM_FOR_TARGET`
11740     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11741 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11742   else
11743     # Canadian cross, just use what we found
11744     echo "$as_me:$LINENO: result: pre-installed" >&5
11745 echo "${ECHO_T}pre-installed" >&6
11746   fi
11747 else
11748   ok=yes
11749   case " ${configdirs} " in
11750     *" binutils "*) ;;
11751     *) ok=no ;;
11752   esac
11753
11754   if test $ok = yes; then
11755     # An in-tree tool is available and we can use it
11756     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11757     echo "$as_me:$LINENO: result: just compiled" >&5
11758 echo "${ECHO_T}just compiled" >&6
11759   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11760     # We already found the complete path
11761     ac_dir=`dirname $NM_FOR_TARGET`
11762     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11763 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11764   elif test "x$target" = "x$host"; then
11765     # We can use an host tool
11766     NM_FOR_TARGET='$(NM)'
11767     echo "$as_me:$LINENO: result: host tool" >&5
11768 echo "${ECHO_T}host tool" >&6
11769   else
11770     # We need a cross tool
11771     echo "$as_me:$LINENO: result: pre-installed" >&5
11772 echo "${ECHO_T}pre-installed" >&6
11773   fi
11774 fi
11775
11776 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11777 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11778 if test "x${build}" != "x${host}" ; then
11779   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11780     # We already found the complete path
11781     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11782     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11783 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11784   else
11785     # Canadian cross, just use what we found
11786     echo "$as_me:$LINENO: result: pre-installed" >&5
11787 echo "${ECHO_T}pre-installed" >&6
11788   fi
11789 else
11790   ok=yes
11791   case " ${configdirs} " in
11792     *" binutils "*) ;;
11793     *) ok=no ;;
11794   esac
11795
11796   if test $ok = yes; then
11797     # An in-tree tool is available and we can use it
11798     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11799     echo "$as_me:$LINENO: result: just compiled" >&5
11800 echo "${ECHO_T}just compiled" >&6
11801   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11802     # We already found the complete path
11803     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11804     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11805 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11806   elif test "x$target" = "x$host"; then
11807     # We can use an host tool
11808     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11809     echo "$as_me:$LINENO: result: host tool" >&5
11810 echo "${ECHO_T}host tool" >&6
11811   else
11812     # We need a cross tool
11813     echo "$as_me:$LINENO: result: pre-installed" >&5
11814 echo "${ECHO_T}pre-installed" >&6
11815   fi
11816 fi
11817
11818 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11819 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11820 if test "x${build}" != "x${host}" ; then
11821   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11822     # We already found the complete path
11823     ac_dir=`dirname $RANLIB_FOR_TARGET`
11824     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11825 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11826   else
11827     # Canadian cross, just use what we found
11828     echo "$as_me:$LINENO: result: pre-installed" >&5
11829 echo "${ECHO_T}pre-installed" >&6
11830   fi
11831 else
11832   ok=yes
11833   case " ${configdirs} " in
11834     *" binutils "*) ;;
11835     *) ok=no ;;
11836   esac
11837
11838   if test $ok = yes; then
11839     # An in-tree tool is available and we can use it
11840     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11841     echo "$as_me:$LINENO: result: just compiled" >&5
11842 echo "${ECHO_T}just compiled" >&6
11843   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11844     # We already found the complete path
11845     ac_dir=`dirname $RANLIB_FOR_TARGET`
11846     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11847 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11848   elif test "x$target" = "x$host"; then
11849     # We can use an host tool
11850     RANLIB_FOR_TARGET='$(RANLIB)'
11851     echo "$as_me:$LINENO: result: host tool" >&5
11852 echo "${ECHO_T}host tool" >&6
11853   else
11854     # We need a cross tool
11855     echo "$as_me:$LINENO: result: pre-installed" >&5
11856 echo "${ECHO_T}pre-installed" >&6
11857   fi
11858 fi
11859
11860 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11861 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11862 if test "x${build}" != "x${host}" ; then
11863   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11864     # We already found the complete path
11865     ac_dir=`dirname $STRIP_FOR_TARGET`
11866     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11867 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11868   else
11869     # Canadian cross, just use what we found
11870     echo "$as_me:$LINENO: result: pre-installed" >&5
11871 echo "${ECHO_T}pre-installed" >&6
11872   fi
11873 else
11874   ok=yes
11875   case " ${configdirs} " in
11876     *" binutils "*) ;;
11877     *) ok=no ;;
11878   esac
11879
11880   if test $ok = yes; then
11881     # An in-tree tool is available and we can use it
11882     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11883     echo "$as_me:$LINENO: result: just compiled" >&5
11884 echo "${ECHO_T}just compiled" >&6
11885   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11886     # We already found the complete path
11887     ac_dir=`dirname $STRIP_FOR_TARGET`
11888     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11889 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11890   elif test "x$target" = "x$host"; then
11891     # We can use an host tool
11892     STRIP_FOR_TARGET='$(STRIP)'
11893     echo "$as_me:$LINENO: result: host tool" >&5
11894 echo "${ECHO_T}host tool" >&6
11895   else
11896     # We need a cross tool
11897     echo "$as_me:$LINENO: result: pre-installed" >&5
11898 echo "${ECHO_T}pre-installed" >&6
11899   fi
11900 fi
11901
11902 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11903 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11904 if test "x${build}" != "x${host}" ; then
11905   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11906     # We already found the complete path
11907     ac_dir=`dirname $WINDRES_FOR_TARGET`
11908     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11909 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11910   else
11911     # Canadian cross, just use what we found
11912     echo "$as_me:$LINENO: result: pre-installed" >&5
11913 echo "${ECHO_T}pre-installed" >&6
11914   fi
11915 else
11916   ok=yes
11917   case " ${configdirs} " in
11918     *" binutils "*) ;;
11919     *) ok=no ;;
11920   esac
11921
11922   if test $ok = yes; then
11923     # An in-tree tool is available and we can use it
11924     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11925     echo "$as_me:$LINENO: result: just compiled" >&5
11926 echo "${ECHO_T}just compiled" >&6
11927   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11928     # We already found the complete path
11929     ac_dir=`dirname $WINDRES_FOR_TARGET`
11930     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11931 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11932   elif test "x$target" = "x$host"; then
11933     # We can use an host tool
11934     WINDRES_FOR_TARGET='$(WINDRES)'
11935     echo "$as_me:$LINENO: result: host tool" >&5
11936 echo "${ECHO_T}host tool" >&6
11937   else
11938     # We need a cross tool
11939     echo "$as_me:$LINENO: result: pre-installed" >&5
11940 echo "${ECHO_T}pre-installed" >&6
11941   fi
11942 fi
11943
11944 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
11945 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
11946 if test "x${build}" != "x${host}" ; then
11947   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11948     # We already found the complete path
11949     ac_dir=`dirname $WINDMC_FOR_TARGET`
11950     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11951 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11952   else
11953     # Canadian cross, just use what we found
11954     echo "$as_me:$LINENO: result: pre-installed" >&5
11955 echo "${ECHO_T}pre-installed" >&6
11956   fi
11957 else
11958   ok=yes
11959   case " ${configdirs} " in
11960     *" binutils "*) ;;
11961     *) ok=no ;;
11962   esac
11963
11964   if test $ok = yes; then
11965     # An in-tree tool is available and we can use it
11966     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
11967     echo "$as_me:$LINENO: result: just compiled" >&5
11968 echo "${ECHO_T}just compiled" >&6
11969   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11970     # We already found the complete path
11971     ac_dir=`dirname $WINDMC_FOR_TARGET`
11972     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11973 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11974   elif test "x$target" = "x$host"; then
11975     # We can use an host tool
11976     WINDMC_FOR_TARGET='$(WINDMC)'
11977     echo "$as_me:$LINENO: result: host tool" >&5
11978 echo "${ECHO_T}host tool" >&6
11979   else
11980     # We need a cross tool
11981     echo "$as_me:$LINENO: result: pre-installed" >&5
11982 echo "${ECHO_T}pre-installed" >&6
11983   fi
11984 fi
11985
11986
11987
11988
11989
11990 # Certain tools may need extra flags.
11991 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
11992 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
11993 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
11994
11995 # When building target libraries, except in a Canadian cross, we use
11996 # the same toolchain as the compiler we just built.
11997 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
11998 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
11999 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12000 if test $host = $build; then
12001   case " $configdirs " in
12002     *" gcc "*)
12003       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12004       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12005       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12006       ;;
12007   esac
12008 fi
12009
12010
12011
12012
12013
12014 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12015 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12016 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12017 if test "${enable_maintainer_mode+set}" = set; then
12018   enableval="$enable_maintainer_mode"
12019   USE_MAINTAINER_MODE=$enableval
12020 else
12021   USE_MAINTAINER_MODE=no
12022 fi;
12023 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12024 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12025
12026
12027 if test "$USE_MAINTAINER_MODE" = yes; then
12028   MAINTAINER_MODE_TRUE=
12029   MAINTAINER_MODE_FALSE='#'
12030 else
12031   MAINTAINER_MODE_TRUE='#'
12032   MAINTAINER_MODE_FALSE=
12033 fi
12034 MAINT=$MAINTAINER_MODE_TRUE
12035
12036 # ---------------------
12037 # GCC bootstrap support
12038 # ---------------------
12039
12040 # Stage specific cflags for build.
12041 stage1_cflags="-g"
12042 case $build in
12043   vax-*-*)
12044     case ${GCC} in
12045       yes) stage1_cflags="-g -Wa,-J" ;;
12046       *) stage1_cflags="-g -J" ;;
12047     esac ;;
12048 esac
12049
12050 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12051 if test "$GCC" = yes; then
12052   saved_CFLAGS="$CFLAGS"
12053
12054   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12055   CFLAGS="$CFLAGS -fkeep-inline-functions"
12056   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12057 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12058   cat >conftest.$ac_ext <<_ACEOF
12059 /* confdefs.h.  */
12060 _ACEOF
12061 cat confdefs.h >>conftest.$ac_ext
12062 cat >>conftest.$ac_ext <<_ACEOF
12063 /* end confdefs.h.  */
12064
12065 #if (__GNUC__ < 3) \
12066     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12067                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12068 #error http://gcc.gnu.org/PR29382
12069 #endif
12070
12071 int
12072 main ()
12073 {
12074
12075   ;
12076   return 0;
12077 }
12078 _ACEOF
12079 rm -f conftest.$ac_objext
12080 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12081   (eval $ac_compile) 2>conftest.er1
12082   ac_status=$?
12083   grep -v '^ *+' conftest.er1 >conftest.err
12084   rm -f conftest.er1
12085   cat conftest.err >&5
12086   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12087   (exit $ac_status); } &&
12088          { ac_try='test -z "$ac_c_werror_flag"
12089                          || test ! -s conftest.err'
12090   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12091   (eval $ac_try) 2>&5
12092   ac_status=$?
12093   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12094   (exit $ac_status); }; } &&
12095          { ac_try='test -s conftest.$ac_objext'
12096   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12097   (eval $ac_try) 2>&5
12098   ac_status=$?
12099   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12100   (exit $ac_status); }; }; then
12101   echo "$as_me:$LINENO: result: yes" >&5
12102 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12103 else
12104   echo "$as_me: failed program was:" >&5
12105 sed 's/^/| /' conftest.$ac_ext >&5
12106
12107 echo "$as_me:$LINENO: result: no" >&5
12108 echo "${ECHO_T}no" >&6
12109 fi
12110 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12111
12112   CFLAGS="$saved_CFLAGS"
12113 fi
12114
12115
12116
12117 # Enable --enable-checking in stage1 of the compiler.
12118 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12119 if test "${enable_stage1_checking+set}" = set; then
12120   enableval="$enable_stage1_checking"
12121   stage1_checking=--enable-checking=${enable_stage1_checking}
12122 else
12123   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12124   stage1_checking=--enable-checking=yes,types
12125 else
12126   stage1_checking=--enable-checking=$enable_checking,types
12127 fi
12128 fi;
12129
12130
12131 # Enable -Werror in bootstrap stage2 and later.
12132 # Check whether --enable-werror or --disable-werror was given.
12133 if test "${enable_werror+set}" = set; then
12134   enableval="$enable_werror"
12135
12136 else
12137   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12138   enable_werror=yes
12139 else
12140   enable_werror=no
12141 fi
12142 fi;
12143 case ${enable_werror} in
12144   yes) stage2_werror_flag="--enable-werror-always" ;;
12145   *) stage2_werror_flag="" ;;
12146 esac
12147
12148
12149 # Flags needed to enable html installing and building
12150
12151 # Check whether --with-datarootdir or --without-datarootdir was given.
12152 if test "${with_datarootdir+set}" = set; then
12153   withval="$with_datarootdir"
12154   datarootdir="\${prefix}/${withval}"
12155 else
12156   datarootdir="\${prefix}/share"
12157 fi;
12158
12159
12160 # Check whether --with-docdir or --without-docdir was given.
12161 if test "${with_docdir+set}" = set; then
12162   withval="$with_docdir"
12163   docdir="\${prefix}/${withval}"
12164 else
12165   docdir="\${datarootdir}/doc"
12166 fi;
12167
12168
12169 # Check whether --with-pdfdir or --without-pdfdir was given.
12170 if test "${with_pdfdir+set}" = set; then
12171   withval="$with_pdfdir"
12172   pdfdir="\${prefix}/${withval}"
12173 else
12174   pdfdir="\${docdir}"
12175 fi;
12176
12177
12178 # Check whether --with-htmldir or --without-htmldir was given.
12179 if test "${with_htmldir+set}" = set; then
12180   withval="$with_htmldir"
12181   htmldir="\${prefix}/${withval}"
12182 else
12183   htmldir="\${docdir}"
12184 fi;
12185
12186
12187
12188
12189
12190
12191           ac_config_files="$ac_config_files Makefile"
12192 cat >confcache <<\_ACEOF
12193 # This file is a shell script that caches the results of configure
12194 # tests run on this system so they can be shared between configure
12195 # scripts and configure runs, see configure's option --config-cache.
12196 # It is not useful on other systems.  If it contains results you don't
12197 # want to keep, you may remove or edit it.
12198 #
12199 # config.status only pays attention to the cache file if you give it
12200 # the --recheck option to rerun configure.
12201 #
12202 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12203 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12204 # following values.
12205
12206 _ACEOF
12207
12208 # The following way of writing the cache mishandles newlines in values,
12209 # but we know of no workaround that is simple, portable, and efficient.
12210 # So, don't put newlines in cache variables' values.
12211 # Ultrix sh set writes to stderr and can't be redirected directly,
12212 # and sets the high bit in the cache file unless we assign to the vars.
12213 {
12214   (set) 2>&1 |
12215     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12216     *ac_space=\ *)
12217       # `set' does not quote correctly, so add quotes (double-quote
12218       # substitution turns \\\\ into \\, and sed turns \\ into \).
12219       sed -n \
12220         "s/'/'\\\\''/g;
12221           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12222       ;;
12223     *)
12224       # `set' quotes correctly as required by POSIX, so do not add quotes.
12225       sed -n \
12226         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12227       ;;
12228     esac;
12229 } |
12230   sed '
12231      t clear
12232      : clear
12233      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12234      t end
12235      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12236      : end' >>confcache
12237 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12238   if test -w $cache_file; then
12239     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12240     cat confcache >$cache_file
12241   else
12242     echo "not updating unwritable cache $cache_file"
12243   fi
12244 fi
12245 rm -f confcache
12246
12247 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12248 # Let make expand exec_prefix.
12249 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12250
12251 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12252 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12253 # trailing colons and then remove the whole line if VPATH becomes empty
12254 # (actually we leave an empty line to preserve line numbers).
12255 if test "x$srcdir" = x.; then
12256   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12257 s/:*\$(srcdir):*/:/;
12258 s/:*\${srcdir}:*/:/;
12259 s/:*@srcdir@:*/:/;
12260 s/^\([^=]*=[     ]*\):*/\1/;
12261 s/:*$//;
12262 s/^[^=]*=[       ]*$//;
12263 }'
12264 fi
12265
12266 # Transform confdefs.h into DEFS.
12267 # Protect against shell expansion while executing Makefile rules.
12268 # Protect against Makefile macro expansion.
12269 #
12270 # If the first sed substitution is executed (which looks for macros that
12271 # take arguments), then we branch to the quote section.  Otherwise,
12272 # look for a macro that doesn't take arguments.
12273 cat >confdef2opt.sed <<\_ACEOF
12274 t clear
12275 : clear
12276 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12277 t quote
12278 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12279 t quote
12280 d
12281 : quote
12282 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12283 s,\[,\\&,g
12284 s,\],\\&,g
12285 s,\$,$$,g
12286 p
12287 _ACEOF
12288 # We use echo to avoid assuming a particular line-breaking character.
12289 # The extra dot is to prevent the shell from consuming trailing
12290 # line-breaks from the sub-command output.  A line-break within
12291 # single-quotes doesn't work because, if this script is created in a
12292 # platform that uses two characters for line-breaks (e.g., DOS), tr
12293 # would break.
12294 ac_LF_and_DOT=`echo; echo .`
12295 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12296 rm -f confdef2opt.sed
12297
12298
12299 ac_libobjs=
12300 ac_ltlibobjs=
12301 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12302   # 1. Remove the extension, and $U if already installed.
12303   ac_i=`echo "$ac_i" |
12304          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12305   # 2. Add them.
12306   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12307   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12308 done
12309 LIBOBJS=$ac_libobjs
12310
12311 LTLIBOBJS=$ac_ltlibobjs
12312
12313
12314
12315 : ${CONFIG_STATUS=./config.status}
12316 ac_clean_files_save=$ac_clean_files
12317 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12318 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12319 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12320 cat >$CONFIG_STATUS <<_ACEOF
12321 #! $SHELL
12322 # Generated by $as_me.
12323 # Run this file to recreate the current configuration.
12324 # Compiler output produced by configure, useful for debugging
12325 # configure, is in config.log if it exists.
12326
12327 debug=false
12328 ac_cs_recheck=false
12329 ac_cs_silent=false
12330 SHELL=\${CONFIG_SHELL-$SHELL}
12331 _ACEOF
12332
12333 cat >>$CONFIG_STATUS <<\_ACEOF
12334 ## --------------------- ##
12335 ## M4sh Initialization.  ##
12336 ## --------------------- ##
12337
12338 # Be Bourne compatible
12339 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12340   emulate sh
12341   NULLCMD=:
12342   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12343   # is contrary to our usage.  Disable this feature.
12344   alias -g '${1+"$@"}'='"$@"'
12345 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12346   set -o posix
12347 fi
12348 DUALCASE=1; export DUALCASE # for MKS sh
12349
12350 # Support unset when possible.
12351 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12352   as_unset=unset
12353 else
12354   as_unset=false
12355 fi
12356
12357
12358 # Work around bugs in pre-3.0 UWIN ksh.
12359 $as_unset ENV MAIL MAILPATH
12360 PS1='$ '
12361 PS2='> '
12362 PS4='+ '
12363
12364 # NLS nuisances.
12365 for as_var in \
12366   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12367   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12368   LC_TELEPHONE LC_TIME
12369 do
12370   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12371     eval $as_var=C; export $as_var
12372   else
12373     $as_unset $as_var
12374   fi
12375 done
12376
12377 # Required to use basename.
12378 if expr a : '\(a\)' >/dev/null 2>&1; then
12379   as_expr=expr
12380 else
12381   as_expr=false
12382 fi
12383
12384 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12385   as_basename=basename
12386 else
12387   as_basename=false
12388 fi
12389
12390
12391 # Name of the executable.
12392 as_me=`$as_basename "$0" ||
12393 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12394          X"$0" : 'X\(//\)$' \| \
12395          X"$0" : 'X\(/\)$' \| \
12396          .     : '\(.\)' 2>/dev/null ||
12397 echo X/"$0" |
12398     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12399           /^X\/\(\/\/\)$/{ s//\1/; q; }
12400           /^X\/\(\/\).*/{ s//\1/; q; }
12401           s/.*/./; q'`
12402
12403
12404 # PATH needs CR, and LINENO needs CR and PATH.
12405 # Avoid depending upon Character Ranges.
12406 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12407 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12408 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12409 as_cr_digits='0123456789'
12410 as_cr_alnum=$as_cr_Letters$as_cr_digits
12411
12412 # The user is always right.
12413 if test "${PATH_SEPARATOR+set}" != set; then
12414   echo "#! /bin/sh" >conf$$.sh
12415   echo  "exit 0"   >>conf$$.sh
12416   chmod +x conf$$.sh
12417   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12418     PATH_SEPARATOR=';'
12419   else
12420     PATH_SEPARATOR=:
12421   fi
12422   rm -f conf$$.sh
12423 fi
12424
12425
12426   as_lineno_1=$LINENO
12427   as_lineno_2=$LINENO
12428   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12429   test "x$as_lineno_1" != "x$as_lineno_2" &&
12430   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12431   # Find who we are.  Look in the path if we contain no path at all
12432   # relative or not.
12433   case $0 in
12434     *[\\/]* ) as_myself=$0 ;;
12435     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12436 for as_dir in $PATH
12437 do
12438   IFS=$as_save_IFS
12439   test -z "$as_dir" && as_dir=.
12440   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12441 done
12442
12443        ;;
12444   esac
12445   # We did not find ourselves, most probably we were run as `sh COMMAND'
12446   # in which case we are not to be found in the path.
12447   if test "x$as_myself" = x; then
12448     as_myself=$0
12449   fi
12450   if test ! -f "$as_myself"; then
12451     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12452 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12453    { (exit 1); exit 1; }; }
12454   fi
12455   case $CONFIG_SHELL in
12456   '')
12457     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12458 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12459 do
12460   IFS=$as_save_IFS
12461   test -z "$as_dir" && as_dir=.
12462   for as_base in sh bash ksh sh5; do
12463          case $as_dir in
12464          /*)
12465            if ("$as_dir/$as_base" -c '
12466   as_lineno_1=$LINENO
12467   as_lineno_2=$LINENO
12468   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12469   test "x$as_lineno_1" != "x$as_lineno_2" &&
12470   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12471              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12472              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12473              CONFIG_SHELL=$as_dir/$as_base
12474              export CONFIG_SHELL
12475              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12476            fi;;
12477          esac
12478        done
12479 done
12480 ;;
12481   esac
12482
12483   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12484   # uniformly replaced by the line number.  The first 'sed' inserts a
12485   # line-number line before each line; the second 'sed' does the real
12486   # work.  The second script uses 'N' to pair each line-number line
12487   # with the numbered line, and appends trailing '-' during
12488   # substitution so that $LINENO is not a special case at line end.
12489   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12490   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12491   sed '=' <$as_myself |
12492     sed '
12493       N
12494       s,$,-,
12495       : loop
12496       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12497       t loop
12498       s,-$,,
12499       s,^['$as_cr_digits']*\n,,
12500     ' >$as_me.lineno &&
12501   chmod +x $as_me.lineno ||
12502     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12503 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12504    { (exit 1); exit 1; }; }
12505
12506   # Don't try to exec as it changes $[0], causing all sort of problems
12507   # (the dirname of $[0] is not the place where we might find the
12508   # original and so on.  Autoconf is especially sensible to this).
12509   . ./$as_me.lineno
12510   # Exit status is that of the last command.
12511   exit
12512 }
12513
12514
12515 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12516   *c*,-n*) ECHO_N= ECHO_C='
12517 ' ECHO_T='      ' ;;
12518   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12519   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12520 esac
12521
12522 if expr a : '\(a\)' >/dev/null 2>&1; then
12523   as_expr=expr
12524 else
12525   as_expr=false
12526 fi
12527
12528 rm -f conf$$ conf$$.exe conf$$.file
12529 echo >conf$$.file
12530 if ln -s conf$$.file conf$$ 2>/dev/null; then
12531   # We could just check for DJGPP; but this test a) works b) is more generic
12532   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12533   if test -f conf$$.exe; then
12534     # Don't use ln at all; we don't have any links
12535     as_ln_s='cp -p'
12536   else
12537     as_ln_s='ln -s'
12538   fi
12539 elif ln conf$$.file conf$$ 2>/dev/null; then
12540   as_ln_s=ln
12541 else
12542   as_ln_s='cp -p'
12543 fi
12544 rm -f conf$$ conf$$.exe conf$$.file
12545
12546 if mkdir -p . 2>/dev/null; then
12547   as_mkdir_p=:
12548 else
12549   test -d ./-p && rmdir ./-p
12550   as_mkdir_p=false
12551 fi
12552
12553 as_executable_p="test -f"
12554
12555 # Sed expression to map a string onto a valid CPP name.
12556 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12557
12558 # Sed expression to map a string onto a valid variable name.
12559 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12560
12561
12562 # IFS
12563 # We need space, tab and new line, in precisely that order.
12564 as_nl='
12565 '
12566 IFS="   $as_nl"
12567
12568 # CDPATH.
12569 $as_unset CDPATH
12570
12571 exec 6>&1
12572
12573 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12574 # report actual input values of CONFIG_FILES etc. instead of their
12575 # values after options handling.  Logging --version etc. is OK.
12576 exec 5>>config.log
12577 {
12578   echo
12579   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12580 ## Running $as_me. ##
12581 _ASBOX
12582 } >&5
12583 cat >&5 <<_CSEOF
12584
12585 This file was extended by $as_me, which was
12586 generated by GNU Autoconf 2.59.  Invocation command line was
12587
12588   CONFIG_FILES    = $CONFIG_FILES
12589   CONFIG_HEADERS  = $CONFIG_HEADERS
12590   CONFIG_LINKS    = $CONFIG_LINKS
12591   CONFIG_COMMANDS = $CONFIG_COMMANDS
12592   $ $0 $@
12593
12594 _CSEOF
12595 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12596 echo >&5
12597 _ACEOF
12598
12599 # Files that config.status was made for.
12600 if test -n "$ac_config_files"; then
12601   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12602 fi
12603
12604 if test -n "$ac_config_headers"; then
12605   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12606 fi
12607
12608 if test -n "$ac_config_links"; then
12609   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12610 fi
12611
12612 if test -n "$ac_config_commands"; then
12613   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12614 fi
12615
12616 cat >>$CONFIG_STATUS <<\_ACEOF
12617
12618 ac_cs_usage="\
12619 \`$as_me' instantiates files from templates according to the
12620 current configuration.
12621
12622 Usage: $0 [OPTIONS] [FILE]...
12623
12624   -h, --help       print this help, then exit
12625   -V, --version    print version number, then exit
12626   -q, --quiet      do not print progress messages
12627   -d, --debug      don't remove temporary files
12628       --recheck    update $as_me by reconfiguring in the same conditions
12629   --file=FILE[:TEMPLATE]
12630                    instantiate the configuration file FILE
12631
12632 Configuration files:
12633 $config_files
12634
12635 Report bugs to <bug-autoconf@gnu.org>."
12636 _ACEOF
12637
12638 cat >>$CONFIG_STATUS <<_ACEOF
12639 ac_cs_version="\\
12640 config.status
12641 configured by $0, generated by GNU Autoconf 2.59,
12642   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12643
12644 Copyright (C) 2003 Free Software Foundation, Inc.
12645 This config.status script is free software; the Free Software Foundation
12646 gives unlimited permission to copy, distribute and modify it."
12647 srcdir=$srcdir
12648 INSTALL="$INSTALL"
12649 _ACEOF
12650
12651 cat >>$CONFIG_STATUS <<\_ACEOF
12652 # If no file are specified by the user, then we need to provide default
12653 # value.  By we need to know if files were specified by the user.
12654 ac_need_defaults=:
12655 while test $# != 0
12656 do
12657   case $1 in
12658   --*=*)
12659     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12660     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12661     ac_shift=:
12662     ;;
12663   -*)
12664     ac_option=$1
12665     ac_optarg=$2
12666     ac_shift=shift
12667     ;;
12668   *) # This is not an option, so the user has probably given explicit
12669      # arguments.
12670      ac_option=$1
12671      ac_need_defaults=false;;
12672   esac
12673
12674   case $ac_option in
12675   # Handling of the options.
12676 _ACEOF
12677 cat >>$CONFIG_STATUS <<\_ACEOF
12678   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12679     ac_cs_recheck=: ;;
12680   --version | --vers* | -V )
12681     echo "$ac_cs_version"; exit 0 ;;
12682   --he | --h)
12683     # Conflict between --help and --header
12684     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12685 Try \`$0 --help' for more information." >&5
12686 echo "$as_me: error: ambiguous option: $1
12687 Try \`$0 --help' for more information." >&2;}
12688    { (exit 1); exit 1; }; };;
12689   --help | --hel | -h )
12690     echo "$ac_cs_usage"; exit 0 ;;
12691   --debug | --d* | -d )
12692     debug=: ;;
12693   --file | --fil | --fi | --f )
12694     $ac_shift
12695     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12696     ac_need_defaults=false;;
12697   --header | --heade | --head | --hea )
12698     $ac_shift
12699     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12700     ac_need_defaults=false;;
12701   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12702   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12703     ac_cs_silent=: ;;
12704
12705   # This is an error.
12706   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12707 Try \`$0 --help' for more information." >&5
12708 echo "$as_me: error: unrecognized option: $1
12709 Try \`$0 --help' for more information." >&2;}
12710    { (exit 1); exit 1; }; } ;;
12711
12712   *) ac_config_targets="$ac_config_targets $1" ;;
12713
12714   esac
12715   shift
12716 done
12717
12718 ac_configure_extra_args=
12719
12720 if $ac_cs_silent; then
12721   exec 6>/dev/null
12722   ac_configure_extra_args="$ac_configure_extra_args --silent"
12723 fi
12724
12725 _ACEOF
12726 cat >>$CONFIG_STATUS <<_ACEOF
12727 if \$ac_cs_recheck; then
12728   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12729   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12730 fi
12731
12732 _ACEOF
12733
12734
12735
12736
12737
12738 cat >>$CONFIG_STATUS <<\_ACEOF
12739 for ac_config_target in $ac_config_targets
12740 do
12741   case "$ac_config_target" in
12742   # Handling of arguments.
12743   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12744   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12745 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12746    { (exit 1); exit 1; }; };;
12747   esac
12748 done
12749
12750 # If the user did not use the arguments to specify the items to instantiate,
12751 # then the envvar interface is used.  Set only those that are not.
12752 # We use the long form for the default assignment because of an extremely
12753 # bizarre bug on SunOS 4.1.3.
12754 if $ac_need_defaults; then
12755   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12756 fi
12757
12758 # Have a temporary directory for convenience.  Make it in the build tree
12759 # simply because there is no reason to put it here, and in addition,
12760 # creating and moving files from /tmp can sometimes cause problems.
12761 # Create a temporary directory, and hook for its removal unless debugging.
12762 $debug ||
12763 {
12764   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12765   trap '{ (exit 1); exit 1; }' 1 2 13 15
12766 }
12767
12768 # Create a (secure) tmp directory for tmp files.
12769
12770 {
12771   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12772   test -n "$tmp" && test -d "$tmp"
12773 }  ||
12774 {
12775   tmp=./confstat$$-$RANDOM
12776   (umask 077 && mkdir $tmp)
12777 } ||
12778 {
12779    echo "$me: cannot create a temporary directory in ." >&2
12780    { (exit 1); exit 1; }
12781 }
12782
12783 _ACEOF
12784
12785 cat >>$CONFIG_STATUS <<_ACEOF
12786
12787 #
12788 # CONFIG_FILES section.
12789 #
12790
12791 # No need to generate the scripts if there are no CONFIG_FILES.
12792 # This happens for instance when ./config.status config.h
12793 if test -n "\$CONFIG_FILES"; then
12794   # Protect against being on the right side of a sed subst in config.status.
12795   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12796    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12797 s,@SHELL@,$SHELL,;t t
12798 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12799 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12800 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12801 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12802 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12803 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12804 s,@exec_prefix@,$exec_prefix,;t t
12805 s,@prefix@,$prefix,;t t
12806 s,@program_transform_name@,$program_transform_name,;t t
12807 s,@bindir@,$bindir,;t t
12808 s,@sbindir@,$sbindir,;t t
12809 s,@libexecdir@,$libexecdir,;t t
12810 s,@datadir@,$datadir,;t t
12811 s,@sysconfdir@,$sysconfdir,;t t
12812 s,@sharedstatedir@,$sharedstatedir,;t t
12813 s,@localstatedir@,$localstatedir,;t t
12814 s,@libdir@,$libdir,;t t
12815 s,@includedir@,$includedir,;t t
12816 s,@oldincludedir@,$oldincludedir,;t t
12817 s,@infodir@,$infodir,;t t
12818 s,@mandir@,$mandir,;t t
12819 s,@build_alias@,$build_alias,;t t
12820 s,@host_alias@,$host_alias,;t t
12821 s,@target_alias@,$target_alias,;t t
12822 s,@DEFS@,$DEFS,;t t
12823 s,@ECHO_C@,$ECHO_C,;t t
12824 s,@ECHO_N@,$ECHO_N,;t t
12825 s,@ECHO_T@,$ECHO_T,;t t
12826 s,@LIBS@,$LIBS,;t t
12827 s,@build@,$build,;t t
12828 s,@build_cpu@,$build_cpu,;t t
12829 s,@build_vendor@,$build_vendor,;t t
12830 s,@build_os@,$build_os,;t t
12831 s,@build_noncanonical@,$build_noncanonical,;t t
12832 s,@host_noncanonical@,$host_noncanonical,;t t
12833 s,@target_noncanonical@,$target_noncanonical,;t t
12834 s,@host@,$host,;t t
12835 s,@host_cpu@,$host_cpu,;t t
12836 s,@host_vendor@,$host_vendor,;t t
12837 s,@host_os@,$host_os,;t t
12838 s,@target@,$target,;t t
12839 s,@target_cpu@,$target_cpu,;t t
12840 s,@target_vendor@,$target_vendor,;t t
12841 s,@target_os@,$target_os,;t t
12842 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12843 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12844 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12845 s,@LN@,$LN,;t t
12846 s,@LN_S@,$LN_S,;t t
12847 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12848 s,@build_libsubdir@,$build_libsubdir,;t t
12849 s,@build_subdir@,$build_subdir,;t t
12850 s,@host_subdir@,$host_subdir,;t t
12851 s,@target_subdir@,$target_subdir,;t t
12852 s,@CC@,$CC,;t t
12853 s,@CFLAGS@,$CFLAGS,;t t
12854 s,@LDFLAGS@,$LDFLAGS,;t t
12855 s,@CPPFLAGS@,$CPPFLAGS,;t t
12856 s,@ac_ct_CC@,$ac_ct_CC,;t t
12857 s,@EXEEXT@,$EXEEXT,;t t
12858 s,@OBJEXT@,$OBJEXT,;t t
12859 s,@CXX@,$CXX,;t t
12860 s,@CXXFLAGS@,$CXXFLAGS,;t t
12861 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12862 s,@GNATBIND@,$GNATBIND,;t t
12863 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12864 s,@GNATMAKE@,$GNATMAKE,;t t
12865 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12866 s,@do_compare@,$do_compare,;t t
12867 s,@gmplibs@,$gmplibs,;t t
12868 s,@gmpinc@,$gmpinc,;t t
12869 s,@stage1_languages@,$stage1_languages,;t t
12870 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12871 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12872 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
12873 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
12874 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12875 s,@tooldir@,$tooldir,;t t
12876 s,@build_tooldir@,$build_tooldir,;t t
12877 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12878 s,@GDB_TK@,$GDB_TK,;t t
12879 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12880 s,@build_configargs@,$build_configargs,;t t
12881 s,@build_configdirs@,$build_configdirs,;t t
12882 s,@host_configargs@,$host_configargs,;t t
12883 s,@configdirs@,$configdirs,;t t
12884 s,@target_configargs@,$target_configargs,;t t
12885 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
12886 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
12887 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12888 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12889 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
12890 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
12891 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
12892 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
12893 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
12894 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
12895 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
12896 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
12897 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
12898 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
12899 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
12900 s,@config_shell@,$config_shell,;t t
12901 s,@YACC@,$YACC,;t t
12902 s,@BISON@,$BISON,;t t
12903 s,@M4@,$M4,;t t
12904 s,@LEX@,$LEX,;t t
12905 s,@FLEX@,$FLEX,;t t
12906 s,@MAKEINFO@,$MAKEINFO,;t t
12907 s,@EXPECT@,$EXPECT,;t t
12908 s,@RUNTEST@,$RUNTEST,;t t
12909 s,@AR@,$AR,;t t
12910 s,@AS@,$AS,;t t
12911 s,@DLLTOOL@,$DLLTOOL,;t t
12912 s,@LD@,$LD,;t t
12913 s,@LIPO@,$LIPO,;t t
12914 s,@NM@,$NM,;t t
12915 s,@RANLIB@,$RANLIB,;t t
12916 s,@STRIP@,$STRIP,;t t
12917 s,@WINDRES@,$WINDRES,;t t
12918 s,@WINDMC@,$WINDMC,;t t
12919 s,@OBJCOPY@,$OBJCOPY,;t t
12920 s,@OBJDUMP@,$OBJDUMP,;t t
12921 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12922 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12923 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12924 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12925 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12926 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12927 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12928 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12929 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12930 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12931 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12932 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12933 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12934 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12935 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12936 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
12937 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12938 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12939 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12940 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12941 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12942 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12943 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12944 s,@MAINT@,$MAINT,;t t
12945 s,@stage1_cflags@,$stage1_cflags,;t t
12946 s,@stage1_checking@,$stage1_checking,;t t
12947 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12948 s,@datarootdir@,$datarootdir,;t t
12949 s,@docdir@,$docdir,;t t
12950 s,@pdfdir@,$pdfdir,;t t
12951 s,@htmldir@,$htmldir,;t t
12952 s,@LIBOBJS@,$LIBOBJS,;t t
12953 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12954 /@serialization_dependencies@/r $serialization_dependencies
12955 s,@serialization_dependencies@,,;t t
12956 /@host_makefile_frag@/r $host_makefile_frag
12957 s,@host_makefile_frag@,,;t t
12958 /@target_makefile_frag@/r $target_makefile_frag
12959 s,@target_makefile_frag@,,;t t
12960 /@alphaieee_frag@/r $alphaieee_frag
12961 s,@alphaieee_frag@,,;t t
12962 /@ospace_frag@/r $ospace_frag
12963 s,@ospace_frag@,,;t t
12964 CEOF
12965
12966 _ACEOF
12967
12968   cat >>$CONFIG_STATUS <<\_ACEOF
12969   # Split the substitutions into bite-sized pieces for seds with
12970   # small command number limits, like on Digital OSF/1 and HP-UX.
12971   ac_max_sed_lines=48
12972   ac_sed_frag=1 # Number of current file.
12973   ac_beg=1 # First line for current file.
12974   ac_end=$ac_max_sed_lines # Line after last line for current file.
12975   ac_more_lines=:
12976   ac_sed_cmds=
12977   while $ac_more_lines; do
12978     if test $ac_beg -gt 1; then
12979       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12980     else
12981       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12982     fi
12983     if test ! -s $tmp/subs.frag; then
12984       ac_more_lines=false
12985     else
12986       # The purpose of the label and of the branching condition is to
12987       # speed up the sed processing (if there are no `@' at all, there
12988       # is no need to browse any of the substitutions).
12989       # These are the two extra sed commands mentioned above.
12990       (echo ':t
12991   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
12992       if test -z "$ac_sed_cmds"; then
12993         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
12994       else
12995         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
12996       fi
12997       ac_sed_frag=`expr $ac_sed_frag + 1`
12998       ac_beg=$ac_end
12999       ac_end=`expr $ac_end + $ac_max_sed_lines`
13000     fi
13001   done
13002   if test -z "$ac_sed_cmds"; then
13003     ac_sed_cmds=cat
13004   fi
13005 fi # test -n "$CONFIG_FILES"
13006
13007 _ACEOF
13008 cat >>$CONFIG_STATUS <<\_ACEOF
13009 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13010   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13011   case $ac_file in
13012   - | *:- | *:-:* ) # input from stdin
13013         cat >$tmp/stdin
13014         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13015         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13016   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13017         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13018   * )   ac_file_in=$ac_file.in ;;
13019   esac
13020
13021   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13022   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13023 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13024          X"$ac_file" : 'X\(//\)[^/]' \| \
13025          X"$ac_file" : 'X\(//\)$' \| \
13026          X"$ac_file" : 'X\(/\)' \| \
13027          .     : '\(.\)' 2>/dev/null ||
13028 echo X"$ac_file" |
13029     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13030           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13031           /^X\(\/\/\)$/{ s//\1/; q; }
13032           /^X\(\/\).*/{ s//\1/; q; }
13033           s/.*/./; q'`
13034   { if $as_mkdir_p; then
13035     mkdir -p "$ac_dir"
13036   else
13037     as_dir="$ac_dir"
13038     as_dirs=
13039     while test ! -d "$as_dir"; do
13040       as_dirs="$as_dir $as_dirs"
13041       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13042 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13043          X"$as_dir" : 'X\(//\)[^/]' \| \
13044          X"$as_dir" : 'X\(//\)$' \| \
13045          X"$as_dir" : 'X\(/\)' \| \
13046          .     : '\(.\)' 2>/dev/null ||
13047 echo X"$as_dir" |
13048     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13049           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13050           /^X\(\/\/\)$/{ s//\1/; q; }
13051           /^X\(\/\).*/{ s//\1/; q; }
13052           s/.*/./; q'`
13053     done
13054     test ! -n "$as_dirs" || mkdir $as_dirs
13055   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13056 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13057    { (exit 1); exit 1; }; }; }
13058
13059   ac_builddir=.
13060
13061 if test "$ac_dir" != .; then
13062   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13063   # A "../" for each directory in $ac_dir_suffix.
13064   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13065 else
13066   ac_dir_suffix= ac_top_builddir=
13067 fi
13068
13069 case $srcdir in
13070   .)  # No --srcdir option.  We are building in place.
13071     ac_srcdir=.
13072     if test -z "$ac_top_builddir"; then
13073        ac_top_srcdir=.
13074     else
13075        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13076     fi ;;
13077   [\\/]* | ?:[\\/]* )  # Absolute path.
13078     ac_srcdir=$srcdir$ac_dir_suffix;
13079     ac_top_srcdir=$srcdir ;;
13080   *) # Relative path.
13081     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13082     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13083 esac
13084
13085 # Do not use `cd foo && pwd` to compute absolute paths, because
13086 # the directories may not exist.
13087 case `pwd` in
13088 .) ac_abs_builddir="$ac_dir";;
13089 *)
13090   case "$ac_dir" in
13091   .) ac_abs_builddir=`pwd`;;
13092   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13093   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13094   esac;;
13095 esac
13096 case $ac_abs_builddir in
13097 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13098 *)
13099   case ${ac_top_builddir}. in
13100   .) ac_abs_top_builddir=$ac_abs_builddir;;
13101   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13102   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13103   esac;;
13104 esac
13105 case $ac_abs_builddir in
13106 .) ac_abs_srcdir=$ac_srcdir;;
13107 *)
13108   case $ac_srcdir in
13109   .) ac_abs_srcdir=$ac_abs_builddir;;
13110   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13111   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13112   esac;;
13113 esac
13114 case $ac_abs_builddir in
13115 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13116 *)
13117   case $ac_top_srcdir in
13118   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13119   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13120   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13121   esac;;
13122 esac
13123
13124
13125   case $INSTALL in
13126   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13127   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13128   esac
13129
13130   if test x"$ac_file" != x-; then
13131     { echo "$as_me:$LINENO: creating $ac_file" >&5
13132 echo "$as_me: creating $ac_file" >&6;}
13133     rm -f "$ac_file"
13134   fi
13135   # Let's still pretend it is `configure' which instantiates (i.e., don't
13136   # use $as_me), people would be surprised to read:
13137   #    /* config.h.  Generated by config.status.  */
13138   if test x"$ac_file" = x-; then
13139     configure_input=
13140   else
13141     configure_input="$ac_file.  "
13142   fi
13143   configure_input=$configure_input"Generated from `echo $ac_file_in |
13144                                      sed 's,.*/,,'` by configure."
13145
13146   # First look for the input files in the build tree, otherwise in the
13147   # src tree.
13148   ac_file_inputs=`IFS=:
13149     for f in $ac_file_in; do
13150       case $f in
13151       -) echo $tmp/stdin ;;
13152       [\\/$]*)
13153          # Absolute (can't be DOS-style, as IFS=:)
13154          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13155 echo "$as_me: error: cannot find input file: $f" >&2;}
13156    { (exit 1); exit 1; }; }
13157          echo "$f";;
13158       *) # Relative
13159          if test -f "$f"; then
13160            # Build tree
13161            echo "$f"
13162          elif test -f "$srcdir/$f"; then
13163            # Source tree
13164            echo "$srcdir/$f"
13165          else
13166            # /dev/null tree
13167            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13168 echo "$as_me: error: cannot find input file: $f" >&2;}
13169    { (exit 1); exit 1; }; }
13170          fi;;
13171       esac
13172     done` || { (exit 1); exit 1; }
13173 _ACEOF
13174 cat >>$CONFIG_STATUS <<_ACEOF
13175   sed "$ac_vpsub
13176 $extrasub
13177 _ACEOF
13178 cat >>$CONFIG_STATUS <<\_ACEOF
13179 :t
13180 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13181 s,@configure_input@,$configure_input,;t t
13182 s,@srcdir@,$ac_srcdir,;t t
13183 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13184 s,@top_srcdir@,$ac_top_srcdir,;t t
13185 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13186 s,@builddir@,$ac_builddir,;t t
13187 s,@abs_builddir@,$ac_abs_builddir,;t t
13188 s,@top_builddir@,$ac_top_builddir,;t t
13189 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13190 s,@INSTALL@,$ac_INSTALL,;t t
13191 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13192   rm -f $tmp/stdin
13193   if test x"$ac_file" != x-; then
13194     mv $tmp/out $ac_file
13195   else
13196     cat $tmp/out
13197     rm -f $tmp/out
13198   fi
13199
13200 done
13201 _ACEOF
13202
13203 cat >>$CONFIG_STATUS <<\_ACEOF
13204
13205 { (exit 0); exit 0; }
13206 _ACEOF
13207 chmod +x $CONFIG_STATUS
13208 ac_clean_files=$ac_clean_files_save
13209
13210
13211 # configure is writing to config.log, and then calls config.status.
13212 # config.status does its own redirection, appending to config.log.
13213 # Unfortunately, on DOS this fails, as config.log is still kept open
13214 # by configure, so config.status won't be able to write to it; its
13215 # output is simply discarded.  So we exec the FD to /dev/null,
13216 # effectively closing config.log, so it can be properly (re)opened and
13217 # appended to by config.status.  When coming back to configure, we
13218 # need to make the FD available again.
13219 if test "$no_create" != yes; then
13220   ac_cs_success=:
13221   ac_config_status_args=
13222   test "$silent" = yes &&
13223     ac_config_status_args="$ac_config_status_args --quiet"
13224   exec 5>/dev/null
13225   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13226   exec 5>>config.log
13227   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13228   # would make configure fail if this is the last instruction.
13229   $ac_cs_success || { (exit 1); exit 1; }
13230 fi
13231