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-gold           use gold instead of ld
 935   --enable-libada         build libada directory
 936   --enable-libssp         build libssp directory
 937   --enable-stage1-languages[=all]   choose additional languages to build during
 938                           stage1.  Mostly useful for compiler development.
 939   --enable-objc-gc        enable use of Boehm's garbage collector with the
 940                           GNU Objective-C runtime
 941   --enable-bootstrap      enable bootstrapping [yes if native build]
 942   --enable-serial-[{host,target,build}-]configure
 943                           force sequential configuration of
 944                           sub-packages for the host, target or build
 945                           machine, or all sub-packages
 946   --enable-maintainer-mode enable make rules and dependencies not useful
 947                           (and sometimes confusing) to the casual installer
 948   --enable-stage1-checking[=all]   choose additional checking for stage1
 949                           of the compiler
 950   --enable-werror         enable -Werror in bootstrap stage2 and later
 951
 952 Optional Packages:
 953   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 954   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 955   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 956   --with-mpfr-dir=PATH    this option has been REMOVED
 957   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 958                           Equivalent to --with-mpfr-include=PATH/include
 959                           plus --with-mpfr-lib=PATH/lib
 960   --with-mpfr-include=PATH
 961                           specify directory for installed MPFR include files
 962   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 963   --with-gmp-dir=PATH     this option has been REMOVED
 964   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 965                           Equivalent to --with-gmp-include=PATH/include
 966                           plus --with-gmp-lib=PATH/lib
 967   --with-gmp-include=PATH specify directory for installed GMP include files
 968   --with-gmp-lib=PATH     specify directory for the installed GMP library
 969   --with-build-sysroot=SYSROOT
 970                           use sysroot as the system root during the build
 971   --with-debug-prefix-map='A=B C=D ...'
 972                              map A to B, C to D ... in debug information
 973   --with-build-time-tools=PATH
 974                           use given path to find target tools during the build
 975   --with-datarootdir      use datarootdir as the data root directory.
 976   --with-docdir           install documentation in this directory.
 977   --with-pdfdir           install pdf in this directory.
 978   --with-htmldir          install html in this directory.
 979
 980 Some influential environment variables:
 981   CC          C compiler command
 982   CFLAGS      C compiler flags
 983   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 984               nonstandard directory <lib dir>
 985   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 986               headers in a nonstandard directory <include dir>
 987   CXX         C++ compiler command
 988   CXXFLAGS    C++ compiler flags
 989   AR          AR for the host
 990   AS          AS for the host
 991   DLLTOOL     DLLTOOL for the host
 992   LD          LD for the host
 993   LIPO        LIPO for the host
 994   NM          NM for the host
 995   RANLIB      RANLIB for the host
 996   STRIP       STRIP for the host
 997   WINDRES     WINDRES for the host
 998   WINDMC      WINDMC for the host
 999   OBJCOPY     OBJCOPY for the host
1000   OBJDUMP     OBJDUMP for the host
1001   CC_FOR_TARGET
1002               CC for the target
1003   CXX_FOR_TARGET
1004               CXX for the target
1005   GCC_FOR_TARGET
1006               GCC for the target
1007   GCJ_FOR_TARGET
1008               GCJ for the target
1009   GFORTRAN_FOR_TARGET
1010               GFORTRAN for the target
1011   AR_FOR_TARGET
1012               AR for the target
1013   AS_FOR_TARGET
1014               AS for the target
1015   DLLTOOL_FOR_TARGET
1016               DLLTOOL for the target
1017   LD_FOR_TARGET
1018               LD for the target
1019   LIPO_FOR_TARGET
1020               LIPO for the target
1021   NM_FOR_TARGET
1022               NM for the target
1023   OBJDUMP_FOR_TARGET
1024               OBJDUMP for the target
1025   RANLIB_FOR_TARGET
1026               RANLIB for the target
1027   STRIP_FOR_TARGET
1028               STRIP for the target
1029   WINDRES_FOR_TARGET
1030               WINDRES for the target
1031   WINDMC_FOR_TARGET
1032               WINDMC for the target
1033
1034 Use these variables to override the choices made by `configure' or to help
1035 it to find libraries and programs with nonstandard names/locations.
1036
1037 _ACEOF
1038 fi
1039
1040 if test "$ac_init_help" = "recursive"; then
1041   # If there are subdirs, report their specific --help.
1042   ac_popdir=`pwd`
1043   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1044     test -d $ac_dir || continue
1045     ac_builddir=.
1046
1047 if test "$ac_dir" != .; then
1048   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1049   # A "../" for each directory in $ac_dir_suffix.
1050   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1051 else
1052   ac_dir_suffix= ac_top_builddir=
1053 fi
1054
1055 case $srcdir in
1056   .)  # No --srcdir option.  We are building in place.
1057     ac_srcdir=.
1058     if test -z "$ac_top_builddir"; then
1059        ac_top_srcdir=.
1060     else
1061        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1062     fi ;;
1063   [\\/]* | ?:[\\/]* )  # Absolute path.
1064     ac_srcdir=$srcdir$ac_dir_suffix;
1065     ac_top_srcdir=$srcdir ;;
1066   *) # Relative path.
1067     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1068     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1069 esac
1070
1071 # Do not use `cd foo && pwd` to compute absolute paths, because
1072 # the directories may not exist.
1073 case `pwd` in
1074 .) ac_abs_builddir="$ac_dir";;
1075 *)
1076   case "$ac_dir" in
1077   .) ac_abs_builddir=`pwd`;;
1078   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1079   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1080   esac;;
1081 esac
1082 case $ac_abs_builddir in
1083 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1084 *)
1085   case ${ac_top_builddir}. in
1086   .) ac_abs_top_builddir=$ac_abs_builddir;;
1087   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1088   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1089   esac;;
1090 esac
1091 case $ac_abs_builddir in
1092 .) ac_abs_srcdir=$ac_srcdir;;
1093 *)
1094   case $ac_srcdir in
1095   .) ac_abs_srcdir=$ac_abs_builddir;;
1096   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1097   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1098   esac;;
1099 esac
1100 case $ac_abs_builddir in
1101 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1102 *)
1103   case $ac_top_srcdir in
1104   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1105   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1106   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1107   esac;;
1108 esac
1109
1110     cd $ac_dir
1111     # Check for guested configure; otherwise get Cygnus style configure.
1112     if test -f $ac_srcdir/configure.gnu; then
1113       echo
1114       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1115     elif test -f $ac_srcdir/configure; then
1116       echo
1117       $SHELL $ac_srcdir/configure  --help=recursive
1118     elif test -f $ac_srcdir/configure.ac ||
1119            test -f $ac_srcdir/configure.in; then
1120       echo
1121       $ac_configure --help
1122     else
1123       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1124     fi
1125     cd $ac_popdir
1126   done
1127 fi
1128
1129 test -n "$ac_init_help" && exit 0
1130 if $ac_init_version; then
1131   cat <<\_ACEOF
1132
1133 Copyright (C) 2003 Free Software Foundation, Inc.
1134 This configure script is free software; the Free Software Foundation
1135 gives unlimited permission to copy, distribute and modify it.
1136 _ACEOF
1137   exit 0
1138 fi
1139 exec 5>config.log
1140 cat >&5 <<_ACEOF
1141 This file contains any messages produced by compilers while
1142 running configure, to aid debugging if configure makes a mistake.
1143
1144 It was created by $as_me, which was
1145 generated by GNU Autoconf 2.59.  Invocation command line was
1146
1147   $ $0 $@
1148
1149 _ACEOF
1150 {
1151 cat <<_ASUNAME
1152 ## --------- ##
1153 ## Platform. ##
1154 ## --------- ##
1155
1156 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1157 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1158 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1159 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1160 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1161
1162 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1163 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1164
1165 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1166 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1167 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1168 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1169 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1170 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1171 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1172
1173 _ASUNAME
1174
1175 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1176 for as_dir in $PATH
1177 do
1178   IFS=$as_save_IFS
1179   test -z "$as_dir" && as_dir=.
1180   echo "PATH: $as_dir"
1181 done
1182
1183 } >&5
1184
1185 cat >&5 <<_ACEOF
1186
1187
1188 ## ----------- ##
1189 ## Core tests. ##
1190 ## ----------- ##
1191
1192 _ACEOF
1193
1194
1195 # Keep a trace of the command line.
1196 # Strip out --no-create and --no-recursion so they do not pile up.
1197 # Strip out --silent because we don't want to record it for future runs.
1198 # Also quote any args containing shell meta-characters.
1199 # Make two passes to allow for proper duplicate-argument suppression.
1200 ac_configure_args=
1201 ac_configure_args0=
1202 ac_configure_args1=
1203 ac_sep=
1204 ac_must_keep_next=false
1205 for ac_pass in 1 2
1206 do
1207   for ac_arg
1208   do
1209     case $ac_arg in
1210     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1211     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1212     | -silent | --silent | --silen | --sile | --sil)
1213       continue ;;
1214     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1215       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1216     esac
1217     case $ac_pass in
1218     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1219     2)
1220       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1221       if test $ac_must_keep_next = true; then
1222         ac_must_keep_next=false # Got value, back to normal.
1223       else
1224         case $ac_arg in
1225           *=* | --config-cache | -C | -disable-* | --disable-* \
1226           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1227           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1228           | -with-* | --with-* | -without-* | --without-* | --x)
1229             case "$ac_configure_args0 " in
1230               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1231             esac
1232             ;;
1233           -* ) ac_must_keep_next=true ;;
1234         esac
1235       fi
1236       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1237       # Get rid of the leading space.
1238       ac_sep=" "
1239       ;;
1240     esac
1241   done
1242 done
1243 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1244 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1245
1246 # When interrupted or exit'd, cleanup temporary files, and complete
1247 # config.log.  We remove comments because anyway the quotes in there
1248 # would cause problems or look ugly.
1249 # WARNING: Be sure not to use single quotes in there, as some shells,
1250 # such as our DU 5.0 friend, will then `close' the trap.
1251 trap 'exit_status=$?
1252   # Save into config.log some information that might help in debugging.
1253   {
1254     echo
1255
1256     cat <<\_ASBOX
1257 ## ---------------- ##
1258 ## Cache variables. ##
1259 ## ---------------- ##
1260 _ASBOX
1261     echo
1262     # The following way of writing the cache mishandles newlines in values,
1263 {
1264   (set) 2>&1 |
1265     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1266     *ac_space=\ *)
1267       sed -n \
1268         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1269           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1270       ;;
1271     *)
1272       sed -n \
1273         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1274       ;;
1275     esac;
1276 }
1277     echo
1278
1279     cat <<\_ASBOX
1280 ## ----------------- ##
1281 ## Output variables. ##
1282 ## ----------------- ##
1283 _ASBOX
1284     echo
1285     for ac_var in $ac_subst_vars
1286     do
1287       eval ac_val=$`echo $ac_var`
1288       echo "$ac_var='"'"'$ac_val'"'"'"
1289     done | sort
1290     echo
1291
1292     if test -n "$ac_subst_files"; then
1293       cat <<\_ASBOX
1294 ## ------------- ##
1295 ## Output files. ##
1296 ## ------------- ##
1297 _ASBOX
1298       echo
1299       for ac_var in $ac_subst_files
1300       do
1301         eval ac_val=$`echo $ac_var`
1302         echo "$ac_var='"'"'$ac_val'"'"'"
1303       done | sort
1304       echo
1305     fi
1306
1307     if test -s confdefs.h; then
1308       cat <<\_ASBOX
1309 ## ----------- ##
1310 ## confdefs.h. ##
1311 ## ----------- ##
1312 _ASBOX
1313       echo
1314       sed "/^$/d" confdefs.h | sort
1315       echo
1316     fi
1317     test "$ac_signal" != 0 &&
1318       echo "$as_me: caught signal $ac_signal"
1319     echo "$as_me: exit $exit_status"
1320   } >&5
1321   rm -f core *.core &&
1322   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1323     exit $exit_status
1324      ' 0
1325 for ac_signal in 1 2 13 15; do
1326   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1327 done
1328 ac_signal=0
1329
1330 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1331 rm -rf conftest* confdefs.h
1332 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1333 echo >confdefs.h
1334
1335 # Predefined preprocessor variables.
1336
1337 cat >>confdefs.h <<_ACEOF
1338 #define PACKAGE_NAME "$PACKAGE_NAME"
1339 _ACEOF
1340
1341
1342 cat >>confdefs.h <<_ACEOF
1343 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1344 _ACEOF
1345
1346
1347 cat >>confdefs.h <<_ACEOF
1348 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1349 _ACEOF
1350
1351
1352 cat >>confdefs.h <<_ACEOF
1353 #define PACKAGE_STRING "$PACKAGE_STRING"
1354 _ACEOF
1355
1356
1357 cat >>confdefs.h <<_ACEOF
1358 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1359 _ACEOF
1360
1361
1362 # Let the site file select an alternate cache file if it wants to.
1363 # Prefer explicitly selected file to automatically selected ones.
1364 if test -z "$CONFIG_SITE"; then
1365   if test "x$prefix" != xNONE; then
1366     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1367   else
1368     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1369   fi
1370 fi
1371 for ac_site_file in $CONFIG_SITE; do
1372   if test -r "$ac_site_file"; then
1373     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1374 echo "$as_me: loading site script $ac_site_file" >&6;}
1375     sed 's/^/| /' "$ac_site_file" >&5
1376     . "$ac_site_file"
1377   fi
1378 done
1379
1380 if test -r "$cache_file"; then
1381   # Some versions of bash will fail to source /dev/null (special
1382   # files actually), so we avoid doing that.
1383   if test -f "$cache_file"; then
1384     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1385 echo "$as_me: loading cache $cache_file" >&6;}
1386     case $cache_file in
1387       [\\/]* | ?:[\\/]* ) . $cache_file;;
1388       *)                      . ./$cache_file;;
1389     esac
1390   fi
1391 else
1392   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1393 echo "$as_me: creating cache $cache_file" >&6;}
1394   >$cache_file
1395 fi
1396
1397 # Check that the precious variables saved in the cache have kept the same
1398 # value.
1399 ac_cache_corrupted=false
1400 for ac_var in `(set) 2>&1 |
1401                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1402   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1403   eval ac_new_set=\$ac_env_${ac_var}_set
1404   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1405   eval ac_new_val="\$ac_env_${ac_var}_value"
1406   case $ac_old_set,$ac_new_set in
1407     set,)
1408       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1409 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1410       ac_cache_corrupted=: ;;
1411     ,set)
1412       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1413 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1414       ac_cache_corrupted=: ;;
1415     ,);;
1416     *)
1417       if test "x$ac_old_val" != "x$ac_new_val"; then
1418         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1419 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1420         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1421 echo "$as_me:   former value:  $ac_old_val" >&2;}
1422         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1423 echo "$as_me:   current value: $ac_new_val" >&2;}
1424         ac_cache_corrupted=:
1425       fi;;
1426   esac
1427   # Pass precious variables to config.status.
1428   if test "$ac_new_set" = set; then
1429     case $ac_new_val in
1430     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1431       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1432     *) ac_arg=$ac_var=$ac_new_val ;;
1433     esac
1434     case " $ac_configure_args " in
1435       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1436       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1437     esac
1438   fi
1439 done
1440 if $ac_cache_corrupted; then
1441   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1442 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1443   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1444 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1445    { (exit 1); exit 1; }; }
1446 fi
1447
1448 ac_ext=c
1449 ac_cpp='$CPP $CPPFLAGS'
1450 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1451 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1452 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474 # Find the build, host, and target systems.
1475 ac_aux_dir=
1476 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1477   if test -f $ac_dir/install-sh; then
1478     ac_aux_dir=$ac_dir
1479     ac_install_sh="$ac_aux_dir/install-sh -c"
1480     break
1481   elif test -f $ac_dir/install.sh; then
1482     ac_aux_dir=$ac_dir
1483     ac_install_sh="$ac_aux_dir/install.sh -c"
1484     break
1485   elif test -f $ac_dir/shtool; then
1486     ac_aux_dir=$ac_dir
1487     ac_install_sh="$ac_aux_dir/shtool install -c"
1488     break
1489   fi
1490 done
1491 if test -z "$ac_aux_dir"; then
1492   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1493 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1494    { (exit 1); exit 1; }; }
1495 fi
1496 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1497 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1498 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1499
1500 # Make sure we can run config.sub.
1501 $ac_config_sub sun4 >/dev/null 2>&1 ||
1502   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1503 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1504    { (exit 1); exit 1; }; }
1505
1506 echo "$as_me:$LINENO: checking build system type" >&5
1507 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1508 if test "${ac_cv_build+set}" = set; then
1509   echo $ECHO_N "(cached) $ECHO_C" >&6
1510 else
1511   ac_cv_build_alias=$build_alias
1512 test -z "$ac_cv_build_alias" &&
1513   ac_cv_build_alias=`$ac_config_guess`
1514 test -z "$ac_cv_build_alias" &&
1515   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1516 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1517    { (exit 1); exit 1; }; }
1518 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1519   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1520 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1521    { (exit 1); exit 1; }; }
1522
1523 fi
1524 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1525 echo "${ECHO_T}$ac_cv_build" >&6
1526 build=$ac_cv_build
1527 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1528 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1529 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1530
1531
1532  case ${build_alias} in
1533   "") build_noncanonical=${build} ;;
1534   *) build_noncanonical=${build_alias} ;;
1535 esac
1536
1537
1538
1539  case ${host_alias} in
1540   "") host_noncanonical=${build_noncanonical} ;;
1541   *) host_noncanonical=${host_alias} ;;
1542 esac
1543
1544
1545
1546  case ${target_alias} in
1547   "") target_noncanonical=${host_noncanonical} ;;
1548   *) target_noncanonical=${target_alias} ;;
1549 esac
1550
1551
1552
1553
1554 test "$host_noncanonical" = "$target_noncanonical" &&
1555   test "$program_prefix$program_suffix$program_transform_name" = \
1556     NONENONEs,x,x, &&
1557   program_transform_name=s,y,y,
1558
1559 echo "$as_me:$LINENO: checking host system type" >&5
1560 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1561 if test "${ac_cv_host+set}" = set; then
1562   echo $ECHO_N "(cached) $ECHO_C" >&6
1563 else
1564   ac_cv_host_alias=$host_alias
1565 test -z "$ac_cv_host_alias" &&
1566   ac_cv_host_alias=$ac_cv_build_alias
1567 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1568   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1569 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1570    { (exit 1); exit 1; }; }
1571
1572 fi
1573 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1574 echo "${ECHO_T}$ac_cv_host" >&6
1575 host=$ac_cv_host
1576 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1577 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1578 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1579
1580
1581 echo "$as_me:$LINENO: checking target system type" >&5
1582 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1583 if test "${ac_cv_target+set}" = set; then
1584   echo $ECHO_N "(cached) $ECHO_C" >&6
1585 else
1586   ac_cv_target_alias=$target_alias
1587 test "x$ac_cv_target_alias" = "x" &&
1588   ac_cv_target_alias=$ac_cv_host_alias
1589 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1590   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1591 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1592    { (exit 1); exit 1; }; }
1593
1594 fi
1595 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1596 echo "${ECHO_T}$ac_cv_target" >&6
1597 target=$ac_cv_target
1598 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1599 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1600 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1601
1602
1603 # The aliases save the names the user supplied, while $host etc.
1604 # will get canonicalized.
1605 test -n "$target_alias" &&
1606   test "$program_prefix$program_suffix$program_transform_name" = \
1607     NONENONEs,x,x, &&
1608   program_prefix=${target_alias}-
1609 test "$program_prefix" != NONE &&
1610   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1611 # Use a double $ so make ignores it.
1612 test "$program_suffix" != NONE &&
1613   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1614 # Double any \ or $.  echo might interpret backslashes.
1615 # By default was `s,x,x', remove it if useless.
1616 cat <<\_ACEOF >conftest.sed
1617 s/[\\$]/&&/g;s/;s,x,x,$//
1618 _ACEOF
1619 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1620 rm conftest.sed
1621
1622
1623
1624 # Get 'install' or 'install-sh' and its variants.
1625 # Find a good install program.  We prefer a C program (faster),
1626 # so one script is as good as another.  But avoid the broken or
1627 # incompatible versions:
1628 # SysV /etc/install, /usr/sbin/install
1629 # SunOS /usr/etc/install
1630 # IRIX /sbin/install
1631 # AIX /bin/install
1632 # AmigaOS /C/install, which installs bootblocks on floppy discs
1633 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1634 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1635 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1636 # OS/2's system install, which has a completely different semantic
1637 # ./install, which can be erroneously created by make from ./install.sh.
1638 # Reject install programs that cannot install multiple files.
1639 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1640 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1641 if test -z "$INSTALL"; then
1642 if test "${ac_cv_path_install+set}" = set; then
1643   echo $ECHO_N "(cached) $ECHO_C" >&6
1644 else
1645   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1646 for as_dir in $PATH
1647 do
1648   IFS=$as_save_IFS
1649   test -z "$as_dir" && as_dir=.
1650   # Account for people who put trailing slashes in PATH elements.
1651 case $as_dir/ in
1652   ./ | .// | /cC/* | \
1653   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1654   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1655   /usr/ucb/* ) ;;
1656   *)
1657     # OSF1 and SCO ODT 3.0 have their own names for install.
1658     # Don't use installbsd from OSF since it installs stuff as root
1659     # by default.
1660     for ac_prog in ginstall scoinst install; do
1661       for ac_exec_ext in '' $ac_executable_extensions; do
1662         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1663           if test $ac_prog = install &&
1664             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1665             # AIX install.  It has an incompatible calling convention.
1666             :
1667           elif test $ac_prog = install &&
1668             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1669             # program-specific install script used by HP pwplus--don't use.
1670             :
1671           else
1672             rm -rf conftest.one conftest.two conftest.dir
1673             echo one > conftest.one
1674             echo two > conftest.two
1675             mkdir conftest.dir
1676             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1677               test -s conftest.one && test -s conftest.two &&
1678               test -s conftest.dir/conftest.one &&
1679               test -s conftest.dir/conftest.two
1680             then
1681               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1682               break 3
1683             fi
1684           fi
1685         fi
1686       done
1687     done
1688     ;;
1689 esac
1690 done
1691
1692 rm -rf conftest.one conftest.two conftest.dir
1693
1694 fi
1695   if test "${ac_cv_path_install+set}" = set; then
1696     INSTALL=$ac_cv_path_install
1697   else
1698     # As a last resort, use the slow shell script.  Don't cache a
1699     # value for INSTALL within a source directory, because that will
1700     # break other packages using the cache if that directory is
1701     # removed, or if the value is a relative name.
1702     INSTALL=$ac_install_sh
1703   fi
1704 fi
1705 echo "$as_me:$LINENO: result: $INSTALL" >&5
1706 echo "${ECHO_T}$INSTALL" >&6
1707
1708 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1709 # It thinks the first close brace ends the variable substitution.
1710 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1711
1712 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1713
1714 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1715
1716 echo "$as_me:$LINENO: checking whether ln works" >&5
1717 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1718 if test "${acx_cv_prog_LN+set}" = set; then
1719   echo $ECHO_N "(cached) $ECHO_C" >&6
1720 else
1721   rm -f conftestdata_t
1722 echo >conftestdata_f
1723 if ln conftestdata_f conftestdata_t 2>/dev/null
1724 then
1725   acx_cv_prog_LN=ln
1726 else
1727   acx_cv_prog_LN=no
1728 fi
1729 rm -f conftestdata_f conftestdata_t
1730
1731 fi
1732 if test $acx_cv_prog_LN = no; then
1733   LN="cp"
1734   echo "$as_me:$LINENO: result: no, using $LN" >&5
1735 echo "${ECHO_T}no, using $LN" >&6
1736 else
1737   LN="$acx_cv_prog_LN"
1738   echo "$as_me:$LINENO: result: yes" >&5
1739 echo "${ECHO_T}yes" >&6
1740 fi
1741
1742 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1743 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1744 LN_S=$as_ln_s
1745 if test "$LN_S" = "ln -s"; then
1746   echo "$as_me:$LINENO: result: yes" >&5
1747 echo "${ECHO_T}yes" >&6
1748 else
1749   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1750 echo "${ECHO_T}no, using $LN_S" >&6
1751 fi
1752
1753
1754 ### we might need to use some other shell than /bin/sh for running subshells
1755 ### If we are on Windows, search for the shell.  This will permit people
1756 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1757 ### without also having to set CONFIG_SHELL.  This code will work when
1758 ### using bash, which sets OSTYPE.
1759 case "${OSTYPE}" in
1760 *win32*)
1761   if test x${CONFIG_SHELL} = x ; then
1762     if test ! -f /bin/sh ; then
1763       if test x${SHELL} != x && test -f ${SHELL} ; then
1764         CONFIG_SHELL=${SHELL}
1765         export CONFIG_SHELL
1766       else
1767         for prog in sh sh.exe bash bash.exe; do
1768           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1769           for dir in $PATH; do
1770             test -z "$dir" && dir=.
1771             if test -f $dir/$prog; then
1772               CONFIG_SHELL=$dir/$prog
1773               export CONFIG_SHELL
1774               break
1775             fi
1776           done
1777           IFS="$save_ifs"
1778           test -n "${CONFIG_SHELL}" && break
1779         done
1780       fi
1781     fi
1782   fi
1783   ;;
1784 esac
1785
1786 config_shell=${CONFIG_SHELL-/bin/sh}
1787
1788 progname=$0
1789 # if PWD already has a value, it is probably wrong.
1790 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1791
1792 # Export original configure arguments for use by sub-configures.
1793 # Quote arguments with shell meta charatcers.
1794 TOPLEVEL_CONFIGURE_ARGUMENTS=
1795 set -- "$progname" "$@"
1796 for ac_arg
1797 do
1798   case "$ac_arg" in
1799   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1800     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1801     # if the argument is of the form -foo=baz, quote the baz part only
1802     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1803   *) ;;
1804   esac
1805   # Add the quoted argument to the list.
1806   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1807 done
1808 if test "$silent" = yes; then
1809   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1810 fi
1811 # Remove the initial space we just introduced and, as these will be
1812 # expanded by make, quote '$'.
1813 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1814
1815
1816 moveifchange=${srcdir}/move-if-change
1817
1818 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1819
1820 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1821 # a relative path.
1822 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1823   INSTALL="${srcpwd}/install-sh -c"
1824 fi
1825
1826 # Set srcdir to "." if that's what it is.
1827 # This is important for multilib support.
1828 pwd=`${PWDCMD-pwd}`
1829 if test "${pwd}" = "${srcpwd}" ; then
1830   srcdir=.
1831 fi
1832
1833 topsrcdir=$srcpwd
1834
1835 extra_host_args=
1836
1837 ### To add a new directory to the tree, first choose whether it is a target
1838 ### or a host dependent tool.  Then put it into the appropriate list
1839 ### (library or tools, host or target), doing a dependency sort.
1840
1841 # Subdirs will be configured in the order listed in build_configdirs,
1842 # configdirs, or target_configdirs; see the serialization section below.
1843
1844 # Dependency sorting is only needed when *configuration* must be done in
1845 # a particular order.  In all cases a dependency should be specified in
1846 # the Makefile, whether or not it's implicitly specified here.
1847
1848 # Double entries in build_configdirs, configdirs, or target_configdirs may
1849 # cause circular dependencies and break everything horribly.
1850
1851 # these library is used by various programs built for the build
1852 # environment
1853 #
1854 build_libs="build-libiberty"
1855
1856 # these tools are built for the build environment
1857 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1858
1859 # these libraries are used by various programs built for the host environment
1860 #
1861 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1862
1863 # these tools are built for the host environment
1864 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1865 # know that we are building the simulator.
1866 # binutils, gas and ld appear in that order because it makes sense to run
1867 # "make check" in that particular order.
1868 # If --enable-gold is used, "gold" will replace "ld".
1869 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"
1870
1871 # libgcj represents the runtime libraries only used by gcj.
1872 libgcj="target-libffi \
1873         target-zlib \
1874         target-qthreads \
1875         target-libjava"
1876
1877 # these libraries are built for the target environment, and are built after
1878 # the host libraries and the host tools (which may be a cross compiler)
1879 #
1880 target_libraries="target-libgcc \
1881                 target-libiberty \
1882                 target-libgloss \
1883                 target-newlib \
1884                 target-libgomp \
1885                 target-libstdc++-v3 \
1886                 target-libmudflap \
1887                 target-libssp \
1888                 target-libgfortran \
1889                 target-boehm-gc \
1890                 ${libgcj} \
1891                 target-libobjc \
1892                 target-libada"
1893
1894 # these tools are built using the target libraries, and are intended to
1895 # run only in the target environment
1896 #
1897 # note: any program that *uses* libraries that are in the "target_libraries"
1898 # list belongs in this list.  those programs are also very likely
1899 # candidates for the "native_only" list which follows
1900 #
1901 target_tools="target-examples target-groff target-gperf target-rda"
1902
1903 ################################################################################
1904
1905 ## All tools belong in one of the four categories, and are assigned above
1906 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1907 ## is important because configure will choke if they ever get through.
1908 ## ${configdirs} is directories we build using the host tools.
1909 ## ${target_configdirs} is directories we build using the target tools.
1910 configdirs=`echo ${host_libs} ${host_tools}`
1911 target_configdirs=`echo ${target_libraries} ${target_tools}`
1912 build_configdirs=`echo ${build_libs} ${build_tools}`
1913
1914
1915
1916 ################################################################################
1917
1918 srcname="gnu development package"
1919
1920 # This gets set non-empty for some net releases of packages.
1921 appdirs=""
1922
1923 # Define is_cross_compiler to save on calls to 'test'.
1924 is_cross_compiler=
1925 if test x"${host}" = x"${target}" ; then
1926   is_cross_compiler=no
1927 else
1928   is_cross_compiler=yes
1929 fi
1930
1931 # Find the build and target subdir names.
1932
1933 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1934 # have matching libraries, they should use host libraries: Makefile.tpl
1935 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1936 # However, they still use the build modules, because the corresponding
1937 # host modules (e.g. bison) are only built for the host when bootstrap
1938 # finishes. So:
1939 # - build_subdir is where we find build modules, and never changes.
1940 # - build_libsubdir is where we find build libraries, and can be overridden.
1941
1942 # Prefix 'build-' so this never conflicts with target_subdir.
1943 build_subdir="build-${build_noncanonical}"
1944
1945 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1946 if test "${with_build_libsubdir+set}" = set; then
1947   withval="$with_build_libsubdir"
1948   build_libsubdir="$withval"
1949 else
1950   build_libsubdir="$build_subdir"
1951 fi;
1952 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1953 if ( test $srcdir = . && test -d gcc ) \
1954    || test -d $srcdir/../host-${host_noncanonical}; then
1955   host_subdir="host-${host_noncanonical}"
1956 else
1957   host_subdir=.
1958 fi
1959 # No prefix.
1960 target_subdir=${target_noncanonical}
1961
1962
1963 # Skipdirs are removed silently.
1964 skipdirs=
1965 # Noconfigdirs are removed loudly.
1966 noconfigdirs=""
1967
1968 use_gnu_ld=
1969 # Make sure we don't let GNU ld be added if we didn't want it.
1970 if test x$with_gnu_ld = xno ; then
1971   use_gnu_ld=no
1972   noconfigdirs="$noconfigdirs ld gold"
1973 fi
1974
1975 use_gnu_as=
1976 # Make sure we don't let GNU as be added if we didn't want it.
1977 if test x$with_gnu_as = xno ; then
1978   use_gnu_as=no
1979   noconfigdirs="$noconfigdirs gas"
1980 fi
1981
1982 # some tools are so dependent upon X11 that if we're not building with X,
1983 # it's not even worth trying to configure, much less build, that tool.
1984
1985 case ${with_x} in
1986   yes | "") ;; # the default value for this tree is that X11 is available
1987   no)
1988     skipdirs="${skipdirs} tk itcl libgui"
1989     # We won't be able to build gdbtk without X.
1990     enable_gdbtk=no
1991     ;;
1992   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
1993 esac
1994
1995 # Some tools are only suitable for building in a "native" situation.
1996 # Remove these if host!=target.
1997 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"
1998
1999 # Similarly, some are only suitable for cross toolchains.
2000 # Remove these if host=target.
2001 cross_only="target-libgloss target-newlib target-opcodes"
2002
2003 case $is_cross_compiler in
2004   no) skipdirs="${skipdirs} ${cross_only}" ;;
2005   yes) skipdirs="${skipdirs} ${native_only}" ;;
2006 esac
2007
2008 # If both --with-headers and --with-libs are specified, default to
2009 # --without-newlib.
2010 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2011    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2012   if test x"${with_newlib}" = x ; then
2013     with_newlib=no
2014   fi
2015 fi
2016
2017 # Recognize --with-newlib/--without-newlib.
2018 case ${with_newlib} in
2019   no) skipdirs="${skipdirs} target-newlib" ;;
2020   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2021 esac
2022
2023 # Handle --enable-gold.
2024
2025 # Check whether --enable-gold or --disable-gold was given.
2026 if test "${enable_gold+set}" = set; then
2027   enableval="$enable_gold"
2028   ENABLE_GOLD=$enableval
2029 else
2030   ENABLE_GOLD=no
2031 fi;
2032 if test "${ENABLE_GOLD}" = "yes"; then
2033   # Check for ELF target.
2034   is_elf=no
2035   case "${target}" in
2036     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2037     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2038     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2039       case "${target}" in
2040         *-*-linux*aout* | *-*-linux*oldld*)
2041           ;;
2042         *)
2043           is_elf=yes
2044           ;;
2045       esac
2046   esac
2047
2048   if test "$is_elf" = "yes"; then
2049     # Check for target supported by gold.
2050     case "${target}" in
2051       i?86-*-* | x86_64-*-*)
2052         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2053         ;;
2054     esac
2055   fi
2056 fi
2057
2058 # Configure extra directories which are host specific
2059
2060 case "${host}" in
2061   *-cygwin*)
2062     configdirs="$configdirs libtermcap" ;;
2063 esac
2064
2065 # A target can indicate whether a language isn't supported for some reason.
2066 # Only spaces may be used in this macro; not newlines or tabs.
2067 unsupported_languages=
2068
2069 # Remove more programs from consideration, based on the host or
2070 # target this usually means that a port of the program doesn't
2071 # exist yet.
2072
2073 case "${host}" in
2074   hppa*64*-*-*)
2075     noconfigdirs="$noconfigdirs byacc"
2076     ;;
2077   i[3456789]86-*-vsta)
2078     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2079     ;;
2080   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2081     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2082     ;;
2083   x86_64-*-mingw*)
2084     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2085     ;;
2086   i[3456789]86-*-mingw32*)
2087     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2088     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2089     ;;
2090   i[3456789]86-*-beos*)
2091     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2092     ;;
2093   *-*-cygwin*)
2094     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2095     ;;
2096   *-*-netbsd*)
2097     noconfigdirs="$noconfigdirs rcs"
2098     ;;
2099   ppc*-*-pe)
2100     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2101     ;;
2102   powerpc-*-beos*)
2103     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2104     ;;
2105 esac
2106
2107
2108 # Check whether --enable-libada or --disable-libada was given.
2109 if test "${enable_libada+set}" = set; then
2110   enableval="$enable_libada"
2111   ENABLE_LIBADA=$enableval
2112 else
2113   ENABLE_LIBADA=yes
2114 fi;
2115 if test "${ENABLE_LIBADA}" != "yes" ; then
2116   noconfigdirs="$noconfigdirs gnattools"
2117 fi
2118
2119 # Check whether --enable-libssp or --disable-libssp was given.
2120 if test "${enable_libssp+set}" = set; then
2121   enableval="$enable_libssp"
2122   ENABLE_LIBSSP=$enableval
2123 else
2124   ENABLE_LIBSSP=yes
2125 fi;
2126
2127 # Save it here so that, even in case of --enable-libgcj, if the Java
2128 # front-end isn't enabled, we still get libgcj disabled.
2129 libgcj_saved=$libgcj
2130 case $enable_libgcj in
2131 yes)
2132   # If we reset it here, it won't get added to noconfigdirs in the
2133   # target-specific build rules, so it will be forcibly enabled
2134   # (unless the Java language itself isn't enabled).
2135   libgcj=
2136   ;;
2137 no)
2138   # Make sure we get it printed in the list of not supported target libs.
2139   noconfigdirs="$noconfigdirs ${libgcj}"
2140   ;;
2141 esac
2142
2143
2144 # Disable libmudflap on some systems.
2145 if test x$enable_libmudflap = x ; then
2146     case "${target}" in
2147     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2148         # Enable libmudflap by default in GNU and friends.
2149         ;;
2150     *-*-freebsd*)
2151         # Enable libmudflap by default in FreeBSD.
2152         ;;
2153     *)
2154         # Disable it by default everywhere else.
2155         noconfigdirs="$noconfigdirs target-libmudflap"
2156         ;;
2157     esac
2158 fi
2159
2160 # Disable libgomp on non POSIX hosted systems.
2161 if test x$enable_libgomp = x ; then
2162     # Enable libgomp by default on hosted POSIX systems.
2163     case "${target}" in
2164     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2165         ;;
2166     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2167         ;;
2168     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2169         ;;
2170     *-*-darwin* | *-*-aix*)
2171         ;;
2172     *)
2173         noconfigdirs="$noconfigdirs target-libgomp"
2174         ;;
2175     esac
2176 fi
2177
2178 # Default libgloss CPU subdirectory.
2179 libgloss_dir="$target_cpu"
2180
2181 case "${target}" in
2182   *-*-chorusos)
2183     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2184     ;;
2185   powerpc-*-darwin* | i[3456789]86-*-darwin* | x86_64-*-darwin9*)
2186     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2187     noconfigdirs="$noconfigdirs sim target-rda"
2188     ;;
2189   *-*-darwin*)
2190     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2191     noconfigdirs="$noconfigdirs sim target-rda"
2192     noconfigdirs="$noconfigdirs ${libgcj}"
2193     ;;
2194   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2195     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2196     ;;
2197   *-*-freebsd*)
2198     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2199     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2200         && test -f /usr/local/include/gmp.h; then
2201       with_gmp=/usr/local
2202     fi
2203
2204     # Skip some stuff that's unsupported on some FreeBSD configurations.
2205     case "${target}" in
2206       i*86-*-*) ;;
2207       alpha*-*-*) ;;
2208       *)
2209         noconfigdirs="$noconfigdirs ${libgcj}"
2210         ;;
2211     esac
2212     ;;
2213   *-*-kaos*)
2214     # Remove unsupported stuff on all kaOS configurations.
2215     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2216     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2217     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2218     noconfigdirs="$noconfigdirs target-libgloss"
2219     ;;
2220   *-*-netbsd*)
2221     # Skip some stuff on all NetBSD configurations.
2222     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2223
2224     # Skip some stuff that's unsupported on some NetBSD configurations.
2225     case "${target}" in
2226       i*86-*-netbsdelf*) ;;
2227       arm*-*-netbsdelf*) ;;
2228       *)
2229         noconfigdirs="$noconfigdirs ${libgcj}"
2230         ;;
2231     esac
2232     ;;
2233   *-*-netware*)
2234     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2235     ;;
2236   *-*-rtems*)
2237     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2238     ;;
2239     # The tpf target doesn't support gdb yet.
2240   *-*-tpf*)
2241     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2242     ;;
2243   *-*-uclinux*)
2244     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2245     ;;
2246   *-*-vxworks*)
2247     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2248     ;;
2249   alpha*-dec-osf*)
2250     # ld works, but does not support shared libraries.
2251     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2252     # gas doesn't generate exception information.
2253     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2254     ;;
2255   alpha*-*-*vms*)
2256     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2257     ;;
2258   alpha*-*-linux*)
2259     # newlib is not 64 bit ready
2260     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2261     ;;
2262   alpha*-*-*)
2263     # newlib is not 64 bit ready
2264     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2265     ;;
2266   am33_2.0-*-linux*)
2267     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2268     ;;
2269   sh-*-linux*)
2270     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2271     ;;
2272   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2273     noconfigdirs="$noconfigdirs ${libgcj}"
2274     noconfigdirs="$noconfigdirs target-examples"
2275     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2276     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2277     noconfigdirs="$noconfigdirs expect dejagnu"
2278     # the C++ libraries don't build on top of CE's C libraries
2279     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2280     noconfigdirs="$noconfigdirs target-newlib"
2281     case "${host}" in
2282       *-*-cygwin*) ;; # keep gdb and readline
2283       *) noconfigdirs="$noconfigdirs gdb readline"
2284          ;;
2285     esac
2286     libgloss_dir=wince
2287     ;;
2288   arc-*-*)
2289     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2290     ;;
2291   arm-semi-aof )
2292     ;;
2293   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2294     noconfigdirs="$noconfigdirs ${libgcj}"
2295     libgloss_dir=arm
2296     ;;
2297   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2298     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2299     libgloss_dir=arm
2300     ;;
2301   arm*-*-linux-gnueabi)
2302     noconfigdirs="$noconfigdirs target-qthreads"
2303     noconfigdirs="$noconfigdirs target-libobjc"
2304     case ${with_newlib} in
2305       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2306     esac
2307     libgloss_dir=arm
2308     ;;
2309   arm*-*-symbianelf*)
2310     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2311     libgloss_dir=arm
2312     ;;
2313   arm-*-pe*)
2314     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2315     ;;
2316   thumb-*-coff)
2317     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2318     ;;
2319   thumb-*-elf)
2320     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2321     ;;
2322   thumb-*-pe)
2323     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2324     ;;
2325   arm-*-riscix*)
2326     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2327     ;;
2328   avr-*-*)
2329     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2330     ;;
2331   bfin-*-*)
2332     noconfigdirs="$noconfigdirs gdb"
2333     if test x${is_cross_compiler} != xno ; then
2334       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2335     fi
2336     ;;
2337   c4x-*-* | tic4x-*-*)
2338     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2339     ;;
2340   c54x*-*-* | tic54x-*-*)
2341     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2342     ;;
2343   cris-*-* | crisv32-*-*)
2344     unsupported_languages="$unsupported_languages java"
2345     case "${target}" in
2346       *-*-aout)
2347         unsupported_languages="$unsupported_languages fortran"
2348         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2349       *-*-elf)
2350         noconfigdirs="$noconfigdirs target-boehm-gc";;
2351       *-*-linux*)
2352         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2353       *)
2354         unsupported_languages="$unsupported_languages fortran"
2355         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2356     esac
2357     libgloss_dir=cris
2358     ;;
2359   crx-*-*)
2360     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2361     ;;
2362   d10v-*-*)
2363     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2364     ;;
2365   d30v-*-*)
2366     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2367     ;;
2368   ep9312-*-elf | ep9312-*-coff)
2369     libgloss_dir=arm
2370     ;;
2371   fr30-*-elf*)
2372     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2373     ;;
2374   frv-*-*)
2375     noconfigdirs="$noconfigdirs ${libgcj}"
2376     ;;
2377   h8300*-*-*)
2378     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2379     ;;
2380   h8500-*-*)
2381     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2382     ;;
2383   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2384     ;;
2385   hppa*64*-*-linux* | parisc*64*-*-linux*)
2386     # In this case, it's because the hppa64-linux target is for
2387     # the kernel only at this point and has no libc, and thus no
2388     # headers, crt*.o, etc., all of which are needed by these.
2389     noconfigdirs="$noconfigdirs target-zlib"
2390     ;;
2391   parisc*-*-linux* | hppa*-*-linux*)
2392     ;;
2393   hppa*-*-*elf* | \
2394   hppa*-*-lites* | \
2395   hppa*-*-openbsd* | \
2396   hppa*64*-*-*)
2397     noconfigdirs="$noconfigdirs ${libgcj}"
2398     ;;
2399   hppa*-hp-hpux11*)
2400     noconfigdirs="$noconfigdirs ld shellutils"
2401     ;;
2402   hppa*-*-pro*)
2403     libgloss_dir=pa
2404     ;;
2405   hppa*-*-*)
2406     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2407     # build on HP-UX 10.20.
2408     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2409     ;;
2410   i960-*-*)
2411     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2412     ;;
2413   ia64*-*-elf*)
2414     # No gdb support yet.
2415     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2416     ;;
2417   ia64*-**-hpux*)
2418     # No gdb or ld support yet.
2419     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2420     ;;
2421   i370-*-opened*)
2422     ;;
2423   i[3456789]86-*-coff | i[3456789]86-*-elf)
2424     noconfigdirs="$noconfigdirs ${libgcj}"
2425     libgloss_dir=i386
2426     ;;
2427   i[3456789]86-*-linux*)
2428     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2429     # not build java stuff by default.
2430     case "${target}" in
2431       *-*-*libc1*)
2432         noconfigdirs="$noconfigdirs ${libgcj}";;
2433     esac
2434
2435     # This section makes it possible to build newlib natively on linux.
2436     # If we are using a cross compiler then don't configure newlib.
2437     if test x${is_cross_compiler} != xno ; then
2438       noconfigdirs="$noconfigdirs target-newlib"
2439     fi
2440     noconfigdirs="$noconfigdirs target-libgloss"
2441     # If we are not using a cross compiler, do configure newlib.
2442     # Note however, that newlib will only be configured in this situation
2443     # if the --with-newlib option has been given, because otherwise
2444     # 'target-newlib' will appear in skipdirs.
2445     ;;
2446   i[3456789]86-*-mingw32*)
2447     target_configdirs="$target_configdirs target-winsup"
2448     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2449     ;;
2450   x86_64-*-mingw*)
2451     target_configdirs="$target_configdirs target-winsup"
2452     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2453     ;;
2454   *-*-cygwin*)
2455     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2456     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2457     # always build newlib if winsup directory is present.
2458     if test -d "$srcdir/winsup/cygwin"; then
2459       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2460     elif test -d "$srcdir/newlib"; then
2461       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2462     fi
2463     ;;
2464   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2465   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2466     ;;
2467   i[3456789]86-*-pe)
2468     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2469     ;;
2470   i[3456789]86-*-sco3.2v5*)
2471     # The linker does not yet know about weak symbols in COFF,
2472     # and is not configured to handle mixed ELF and COFF.
2473     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2474     ;;
2475   i[3456789]86-*-sco*)
2476     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2477     ;;
2478   i[3456789]86-*-solaris2*)
2479     noconfigdirs="$noconfigdirs target-libgloss"
2480     ;;
2481   i[3456789]86-*-sysv4*)
2482     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2483     ;;
2484   i[3456789]86-*-beos*)
2485     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2486     ;;
2487   i[3456789]86-*-rdos*)
2488     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2489     ;;
2490   m32r-*-*)
2491     noconfigdirs="$noconfigdirs ${libgcj}"
2492     ;;
2493   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2494     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2495     libgloss_dir=m68hc11
2496     ;;
2497   m68k-*-elf*)
2498     noconfigdirs="$noconfigdirs ${libgcj}"
2499     ;;
2500   m68k-*-coff*)
2501     noconfigdirs="$noconfigdirs ${libgcj}"
2502     ;;
2503   m68*-*-* | fido-*-*)
2504     libgloss_dir=m68k
2505     ;;
2506   mcore-*-pe*)
2507   # The EPOC C++ environment does not support exceptions or rtti,
2508   # and so building libstdc++-v3 tends not to always work.
2509     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2510     ;;
2511   mmix-*-*)
2512     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2513     unsupported_languages="$unsupported_languages fortran java"
2514     ;;
2515   mn10200-*-*)
2516     noconfigdirs="$noconfigdirs ${libgcj}"
2517     ;;
2518   mn10300-*-*)
2519     noconfigdirs="$noconfigdirs ${libgcj}"
2520     ;;
2521   mt-*-*)
2522     noconfigdirs="$noconfigdirs sim"
2523     ;;
2524   powerpc-*-aix*)
2525     # copied from rs6000-*-* entry
2526     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2527     ;;
2528   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2529     target_configdirs="$target_configdirs target-winsup"
2530     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2531     # always build newlib.
2532     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2533     ;;
2534     # This is temporary until we can link against shared libraries
2535   powerpcle-*-solaris*)
2536     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2537     libgloss_dir=rs6000
2538     ;;
2539   powerpc-*-beos*)
2540     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2541     ;;
2542   powerpc-*-eabi)
2543     noconfigdirs="$noconfigdirs ${libgcj}"
2544     libgloss_dir=rs6000
2545     ;;
2546   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2547     libgloss_dir=rs6000
2548     ;;
2549   rs6000-*-lynxos*)
2550     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2551     ;;
2552   rs6000-*-aix*)
2553     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2554     ;;
2555   rs6000-*-*)
2556     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2557     ;;
2558   m68k-apollo-*)
2559     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2560     ;;
2561   mips*-sde-elf*)
2562     skipdirs="$skipdirs target-libiberty"
2563     noconfigdirs="$noconfigdirs ${libgcj}"
2564     if test x$with_newlib = xyes; then
2565       noconfigdirs="$noconfigdirs gprof"
2566     fi
2567     libgloss_dir=mips
2568     ;;
2569   mips*-*-irix5*)
2570     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2571     ;;
2572   mips*-*-irix6*)
2573     # Linking libjava exceeds command-line length limits on at least
2574     # IRIX 6.2, but not on IRIX 6.5.
2575     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2576     # <oldham@codesourcery.com>
2577     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2578     ;;
2579   mips*-*-bsd*)
2580     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2581     ;;
2582   mips*-*-linux*)
2583     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2584     ;;
2585   mips*-*-*)
2586     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2587     libgloss_dir=mips
2588     ;;
2589   romp-*-*)
2590     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2591     ;;
2592   sh-*-* | sh64-*-*)
2593     case "${host}" in
2594       i[3456789]86-*-vsta) ;; # don't add gprof back in
2595       i[3456789]86-*-go32*) ;; # don't add gprof back in
2596       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2597       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2598     esac
2599     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2600     ;;
2601   sparclet-*-aout* | sparc86x-*-*)
2602     libgloss_dir=sparc
2603     ;;
2604   sparc-*-elf*)
2605     noconfigdirs="$noconfigdirs ${libgcj}"
2606     ;;
2607   sparc64-*-elf*)
2608     noconfigdirs="$noconfigdirs ${libgcj}"
2609     libgloss_dir=sparc
2610     ;;
2611   sparclite-*-*)
2612     noconfigdirs="$noconfigdirs ${libgcj}"
2613     libgloss_dir=sparc
2614     ;;
2615   sparc-*-sunos4*)
2616     noconfigdirs="$noconfigdirs ${libgcj}"
2617     if test x${is_cross_compiler} != xno ; then
2618            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2619     else
2620            use_gnu_ld=no
2621     fi
2622     ;;
2623   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2624     noconfigdirs="$noconfigdirs ${libgcj}"
2625     ;;
2626   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2627     ;;
2628   spu-*-*)
2629     skipdirs="target-libssp"
2630     ;;
2631   v810-*-*)
2632     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2633     ;;
2634   v850-*-*)
2635     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2636     ;;
2637   v850e-*-*)
2638     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2639     ;;
2640   v850ea-*-*)
2641     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2642     ;;
2643   vax-*-vms)
2644     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2645     ;;
2646   vax-*-*)
2647     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2648     ;;
2649   xtensa*-*-*)
2650     noconfigdirs="$noconfigdirs ${libgcj}"
2651     ;;
2652   ip2k-*-*)
2653     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2654     ;;
2655   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2656     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2657     ;;
2658   *-*-lynxos*)
2659     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2660     ;;
2661   *-*-*)
2662     noconfigdirs="$noconfigdirs ${libgcj}"
2663     ;;
2664 esac
2665
2666 # If we aren't building newlib, then don't build libgloss, since libgloss
2667 # depends upon some newlib header files.
2668 case "${noconfigdirs}" in
2669   *target-libgloss*) ;;
2670   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2671 esac
2672
2673 # Work in distributions that contain no compiler tools, like Autoconf.
2674 tentative_cc=""
2675 host_makefile_frag=/dev/null
2676 if test -d ${srcdir}/config ; then
2677 case "${host}" in
2678   m68k-hp-hpux*)
2679     # Avoid "too much defining" errors from HPUX compiler.
2680     tentative_cc="cc -Wp,-H256000"
2681     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2682     # If it's HP/UX ar, this should be harmless.
2683     RANLIB="ar ts"
2684     ;;
2685   m68k-apollo-sysv*)
2686     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2687     ;;
2688   m68k-apollo-bsd*)
2689     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2690     # chokes on bfd, the compiler won't let you assign integers to enums, and
2691     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2692     # the apollo compiler" (the preferred version of GCC could be called cc,
2693     # or whatever), but I'm not sure leaving CC as cc is any better...
2694     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2695     # Used to have BISON=yacc.
2696     tentative_cc=gcc
2697     ;;
2698   m88k-dg-dgux*)
2699     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2700     ;;
2701   m88k-harris-cxux*)
2702     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2703     tentative_cc="cc -Xa"
2704     host_makefile_frag="config/mh-cxux"
2705     ;;
2706   m88k-motorola-sysv*)
2707     ;;
2708   mips*-dec-ultrix*)
2709     tentative_cc="cc -Wf,-XNg1000"
2710     host_makefile_frag="config/mh-decstation"
2711     ;;
2712   mips*-nec-sysv4*)
2713     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2714     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2715     host_makefile_frag="config/mh-necv4"
2716     ;;
2717   mips*-sgi-irix4*)
2718     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2719     # environment.  Also bump switch table size so that cp-parse will
2720     # compile.  Bump string length limit so linker builds.
2721     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2722     ;;
2723   mips*-*-sysv4*)
2724     host_makefile_frag="config/mh-sysv4"
2725     ;;
2726   mips*-*-sysv*)
2727     # This is for a MIPS running RISC/os 4.52C.
2728
2729     # This is needed for GDB, but needs to be in the top-level make because
2730     # if a library is compiled with the bsd headers and gets linked with the
2731     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2732     # a different size).
2733     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2734     # known except to select the sysv environment.  Could we use /proc instead?
2735     # These "sysv environments" and "bsd environments" often end up being a pain.
2736     #
2737     # This is not part of CFLAGS because perhaps not all C compilers have this
2738     # option.
2739     tentative_cc="cc -systype sysv"
2740     ;;
2741   i370-ibm-opened*)
2742     tentative_cc="c89"
2743     ;;
2744   i[3456789]86-*-sysv5*)
2745     host_makefile_frag="config/mh-sysv5"
2746     ;;
2747   i[3456789]86-*-dgux*)
2748     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2749     host_makefile_frag="config/mh-dgux386"
2750     ;;
2751   i[3456789]86-ncr-sysv4.3*)
2752     # The MetaWare compiler will generate a copyright message unless you
2753     # turn it off by adding the -Hnocopyr flag.
2754     tentative_cc="cc -Hnocopyr"
2755     ;;
2756   i[3456789]86-ncr-sysv4*)
2757     # for an NCR 3000 (i486/SVR4) system.
2758     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2759     # This compiler not only emits obnoxious copyright messages every time
2760     # you run it, but it chokes and dies on a whole bunch of GNU source
2761     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2762     tentative_cc="/usr/ccs/ATT/cc"
2763     host_makefile_frag="config/mh-ncr3000"
2764     ;;
2765   i[3456789]86-*-sco3.2v5*)
2766     ;;
2767   i[3456789]86-*-sco*)
2768     # The native C compiler botches some simple uses of const.  Unfortunately,
2769     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2770     tentative_cc="cc -Dconst="
2771     host_makefile_frag="config/mh-sco"
2772     ;;
2773   i[3456789]86-*-udk*)
2774     host_makefile_frag="config/mh-sysv5"
2775     ;;
2776   i[3456789]86-*-solaris2*)
2777     host_makefile_frag="config/mh-sysv4"
2778     ;;
2779   i[3456789]86-*-msdosdjgpp*)
2780     host_makefile_frag="config/mh-djgpp"
2781     ;;
2782   *-cygwin*)
2783     host_makefile_frag="config/mh-cygwin"
2784     ;;
2785   *-mingw*)
2786     host_makefile_frag="config/mh-mingw"
2787     ;;
2788   *-interix*)
2789     host_makefile_frag="config/mh-interix"
2790     ;;
2791   vax-*-ultrix2*)
2792     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2793     tentative_cc=gcc
2794     ;;
2795   *-*-solaris2*)
2796     host_makefile_frag="config/mh-solaris"
2797     ;;
2798   m68k-sun-sunos*)
2799     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2800     # without overflowing the jump tables (-J says to use a 32 bit table)
2801     tentative_cc="cc -J"
2802     ;;
2803   *-hp-hpux*)
2804     tentative_cc="cc -Wp,-H256000"
2805     ;;
2806   *-*-hiux*)
2807     tentative_cc="cc -Wp,-H256000"
2808     ;;
2809   rs6000-*-lynxos*)
2810     # /bin/cc is less than useful for our purposes.  Always use GCC
2811     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2812     host_makefile_frag="config/mh-lynxrs6k"
2813     ;;
2814   powerpc-*-darwin*)
2815     host_makefile_frag="config/mh-ppc-darwin"
2816     ;;
2817   powerpc-*-aix*)
2818     host_makefile_frag="config/mh-ppc-aix"
2819     ;;
2820   rs6000-*-aix*)
2821     host_makefile_frag="config/mh-ppc-aix"
2822     ;;
2823   *-*-lynxos*)
2824     # /bin/cc is less than useful for our purposes.  Always use GCC
2825     tentative_cc="/bin/gcc"
2826     ;;
2827   *-*-sysv4*)
2828     host_makefile_frag="config/mh-sysv4"
2829     ;;
2830   # This is placed last to prevent interfering with the cases above.
2831   i[3456789]86-*-*)
2832     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2833     host_makefile_frag="config/mh-x86omitfp"
2834     ;;
2835 esac
2836 fi
2837
2838 # If we aren't going to be using gcc, see if we can extract a definition
2839 # of CC from the fragment.
2840 # Actually, use the 'pre-extracted' version above.
2841 if test -z "${CC}" && test "${build}" = "${host}" ; then
2842   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2843   found=
2844   for dir in $PATH; do
2845     test -z "$dir" && dir=.
2846     if test -f $dir/gcc; then
2847       found=yes
2848       break
2849     fi
2850   done
2851   IFS="$save_ifs"
2852   if test -z "${found}" && test -n "${tentative_cc}" ; then
2853     CC=$tentative_cc
2854   fi
2855 fi
2856
2857 if test "${build}" != "${host}" ; then
2858   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2859   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2860   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2861   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2862   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2863   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2864   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2865   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2866   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2867   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2868   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2869   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2870 else
2871   AR_FOR_BUILD="\$(AR)"
2872   AS_FOR_BUILD="\$(AS)"
2873   CC_FOR_BUILD="\$(CC)"
2874   CXX_FOR_BUILD="\$(CXX)"
2875   GCJ_FOR_BUILD="\$(GCJ)"
2876   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2877   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2878   LD_FOR_BUILD="\$(LD)"
2879   NM_FOR_BUILD="\$(NM)"
2880   RANLIB_FOR_BUILD="\$(RANLIB)"
2881   WINDRES_FOR_BUILD="\$(WINDRES)"
2882   WINDMC_FOR_BUILD="\$(WINDMC)"
2883 fi
2884
2885 ac_ext=c
2886 ac_cpp='$CPP $CPPFLAGS'
2887 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2888 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2889 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2890 if test -n "$ac_tool_prefix"; then
2891   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2892 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2893 echo "$as_me:$LINENO: checking for $ac_word" >&5
2894 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2895 if test "${ac_cv_prog_CC+set}" = set; then
2896   echo $ECHO_N "(cached) $ECHO_C" >&6
2897 else
2898   if test -n "$CC"; then
2899   ac_cv_prog_CC="$CC" # Let the user override the test.
2900 else
2901 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2902 for as_dir in $PATH
2903 do
2904   IFS=$as_save_IFS
2905   test -z "$as_dir" && as_dir=.
2906   for ac_exec_ext in '' $ac_executable_extensions; do
2907   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2908     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2909     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2910     break 2
2911   fi
2912 done
2913 done
2914
2915 fi
2916 fi
2917 CC=$ac_cv_prog_CC
2918 if test -n "$CC"; then
2919   echo "$as_me:$LINENO: result: $CC" >&5
2920 echo "${ECHO_T}$CC" >&6
2921 else
2922   echo "$as_me:$LINENO: result: no" >&5
2923 echo "${ECHO_T}no" >&6
2924 fi
2925
2926 fi
2927 if test -z "$ac_cv_prog_CC"; then
2928   ac_ct_CC=$CC
2929   # Extract the first word of "gcc", so it can be a program name with args.
2930 set dummy gcc; ac_word=$2
2931 echo "$as_me:$LINENO: checking for $ac_word" >&5
2932 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2933 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2934   echo $ECHO_N "(cached) $ECHO_C" >&6
2935 else
2936   if test -n "$ac_ct_CC"; then
2937   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2938 else
2939 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2940 for as_dir in $PATH
2941 do
2942   IFS=$as_save_IFS
2943   test -z "$as_dir" && as_dir=.
2944   for ac_exec_ext in '' $ac_executable_extensions; do
2945   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2946     ac_cv_prog_ac_ct_CC="gcc"
2947     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2948     break 2
2949   fi
2950 done
2951 done
2952
2953 fi
2954 fi
2955 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2956 if test -n "$ac_ct_CC"; then
2957   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2958 echo "${ECHO_T}$ac_ct_CC" >&6
2959 else
2960   echo "$as_me:$LINENO: result: no" >&5
2961 echo "${ECHO_T}no" >&6
2962 fi
2963
2964   CC=$ac_ct_CC
2965 else
2966   CC="$ac_cv_prog_CC"
2967 fi
2968
2969 if test -z "$CC"; then
2970   if test -n "$ac_tool_prefix"; then
2971   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2972 set dummy ${ac_tool_prefix}cc; ac_word=$2
2973 echo "$as_me:$LINENO: checking for $ac_word" >&5
2974 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2975 if test "${ac_cv_prog_CC+set}" = set; then
2976   echo $ECHO_N "(cached) $ECHO_C" >&6
2977 else
2978   if test -n "$CC"; then
2979   ac_cv_prog_CC="$CC" # Let the user override the test.
2980 else
2981 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2982 for as_dir in $PATH
2983 do
2984   IFS=$as_save_IFS
2985   test -z "$as_dir" && as_dir=.
2986   for ac_exec_ext in '' $ac_executable_extensions; do
2987   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2988     ac_cv_prog_CC="${ac_tool_prefix}cc"
2989     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2990     break 2
2991   fi
2992 done
2993 done
2994
2995 fi
2996 fi
2997 CC=$ac_cv_prog_CC
2998 if test -n "$CC"; then
2999   echo "$as_me:$LINENO: result: $CC" >&5
3000 echo "${ECHO_T}$CC" >&6
3001 else
3002   echo "$as_me:$LINENO: result: no" >&5
3003 echo "${ECHO_T}no" >&6
3004 fi
3005
3006 fi
3007 if test -z "$ac_cv_prog_CC"; then
3008   ac_ct_CC=$CC
3009   # Extract the first word of "cc", so it can be a program name with args.
3010 set dummy cc; ac_word=$2
3011 echo "$as_me:$LINENO: checking for $ac_word" >&5
3012 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3013 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3014   echo $ECHO_N "(cached) $ECHO_C" >&6
3015 else
3016   if test -n "$ac_ct_CC"; then
3017   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3018 else
3019 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3020 for as_dir in $PATH
3021 do
3022   IFS=$as_save_IFS
3023   test -z "$as_dir" && as_dir=.
3024   for ac_exec_ext in '' $ac_executable_extensions; do
3025   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3026     ac_cv_prog_ac_ct_CC="cc"
3027     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3028     break 2
3029   fi
3030 done
3031 done
3032
3033 fi
3034 fi
3035 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3036 if test -n "$ac_ct_CC"; then
3037   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3038 echo "${ECHO_T}$ac_ct_CC" >&6
3039 else
3040   echo "$as_me:$LINENO: result: no" >&5
3041 echo "${ECHO_T}no" >&6
3042 fi
3043
3044   CC=$ac_ct_CC
3045 else
3046   CC="$ac_cv_prog_CC"
3047 fi
3048
3049 fi
3050 if test -z "$CC"; then
3051   # Extract the first word of "cc", so it can be a program name with args.
3052 set dummy cc; ac_word=$2
3053 echo "$as_me:$LINENO: checking for $ac_word" >&5
3054 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3055 if test "${ac_cv_prog_CC+set}" = set; then
3056   echo $ECHO_N "(cached) $ECHO_C" >&6
3057 else
3058   if test -n "$CC"; then
3059   ac_cv_prog_CC="$CC" # Let the user override the test.
3060 else
3061   ac_prog_rejected=no
3062 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3063 for as_dir in $PATH
3064 do
3065   IFS=$as_save_IFS
3066   test -z "$as_dir" && as_dir=.
3067   for ac_exec_ext in '' $ac_executable_extensions; do
3068   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3069     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3070        ac_prog_rejected=yes
3071        continue
3072      fi
3073     ac_cv_prog_CC="cc"
3074     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3075     break 2
3076   fi
3077 done
3078 done
3079
3080 if test $ac_prog_rejected = yes; then
3081   # We found a bogon in the path, so make sure we never use it.
3082   set dummy $ac_cv_prog_CC
3083   shift
3084   if test $# != 0; then
3085     # We chose a different compiler from the bogus one.
3086     # However, it has the same basename, so the bogon will be chosen
3087     # first if we set CC to just the basename; use the full file name.
3088     shift
3089     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3090   fi
3091 fi
3092 fi
3093 fi
3094 CC=$ac_cv_prog_CC
3095 if test -n "$CC"; then
3096   echo "$as_me:$LINENO: result: $CC" >&5
3097 echo "${ECHO_T}$CC" >&6
3098 else
3099   echo "$as_me:$LINENO: result: no" >&5
3100 echo "${ECHO_T}no" >&6
3101 fi
3102
3103 fi
3104 if test -z "$CC"; then
3105   if test -n "$ac_tool_prefix"; then
3106   for ac_prog in cl
3107   do
3108     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3109 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3110 echo "$as_me:$LINENO: checking for $ac_word" >&5
3111 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3112 if test "${ac_cv_prog_CC+set}" = set; then
3113   echo $ECHO_N "(cached) $ECHO_C" >&6
3114 else
3115   if test -n "$CC"; then
3116   ac_cv_prog_CC="$CC" # Let the user override the test.
3117 else
3118 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3119 for as_dir in $PATH
3120 do
3121   IFS=$as_save_IFS
3122   test -z "$as_dir" && as_dir=.
3123   for ac_exec_ext in '' $ac_executable_extensions; do
3124   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3125     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3126     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3127     break 2
3128   fi
3129 done
3130 done
3131
3132 fi
3133 fi
3134 CC=$ac_cv_prog_CC
3135 if test -n "$CC"; then
3136   echo "$as_me:$LINENO: result: $CC" >&5
3137 echo "${ECHO_T}$CC" >&6
3138 else
3139   echo "$as_me:$LINENO: result: no" >&5
3140 echo "${ECHO_T}no" >&6
3141 fi
3142
3143     test -n "$CC" && break
3144   done
3145 fi
3146 if test -z "$CC"; then
3147   ac_ct_CC=$CC
3148   for ac_prog in cl
3149 do
3150   # Extract the first word of "$ac_prog", so it can be a program name with args.
3151 set dummy $ac_prog; ac_word=$2
3152 echo "$as_me:$LINENO: checking for $ac_word" >&5
3153 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3154 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3155   echo $ECHO_N "(cached) $ECHO_C" >&6
3156 else
3157   if test -n "$ac_ct_CC"; then
3158   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3159 else
3160 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3161 for as_dir in $PATH
3162 do
3163   IFS=$as_save_IFS
3164   test -z "$as_dir" && as_dir=.
3165   for ac_exec_ext in '' $ac_executable_extensions; do
3166   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3167     ac_cv_prog_ac_ct_CC="$ac_prog"
3168     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3169     break 2
3170   fi
3171 done
3172 done
3173
3174 fi
3175 fi
3176 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3177 if test -n "$ac_ct_CC"; then
3178   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3179 echo "${ECHO_T}$ac_ct_CC" >&6
3180 else
3181   echo "$as_me:$LINENO: result: no" >&5
3182 echo "${ECHO_T}no" >&6
3183 fi
3184
3185   test -n "$ac_ct_CC" && break
3186 done
3187
3188   CC=$ac_ct_CC
3189 fi
3190
3191 fi
3192
3193
3194 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3195 See \`config.log' for more details." >&5
3196 echo "$as_me: error: no acceptable C compiler found in \$PATH
3197 See \`config.log' for more details." >&2;}
3198    { (exit 1); exit 1; }; }
3199
3200 # Provide some information about the compiler.
3201 echo "$as_me:$LINENO:" \
3202      "checking for C compiler version" >&5
3203 ac_compiler=`set X $ac_compile; echo $2`
3204 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3205   (eval $ac_compiler --version </dev/null >&5) 2>&5
3206   ac_status=$?
3207   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3208   (exit $ac_status); }
3209 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3210   (eval $ac_compiler -v </dev/null >&5) 2>&5
3211   ac_status=$?
3212   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3213   (exit $ac_status); }
3214 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3215   (eval $ac_compiler -V </dev/null >&5) 2>&5
3216   ac_status=$?
3217   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3218   (exit $ac_status); }
3219
3220 cat >conftest.$ac_ext <<_ACEOF
3221 /* confdefs.h.  */
3222 _ACEOF
3223 cat confdefs.h >>conftest.$ac_ext
3224 cat >>conftest.$ac_ext <<_ACEOF
3225 /* end confdefs.h.  */
3226
3227 int
3228 main ()
3229 {
3230
3231   ;
3232   return 0;
3233 }
3234 _ACEOF
3235 ac_clean_files_save=$ac_clean_files
3236 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3237 # Try to create an executable without -o first, disregard a.out.
3238 # It will help us diagnose broken compilers, and finding out an intuition
3239 # of exeext.
3240 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3241 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3242 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3243 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3244   (eval $ac_link_default) 2>&5
3245   ac_status=$?
3246   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3247   (exit $ac_status); }; then
3248   # Find the output, starting from the most likely.  This scheme is
3249 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3250 # resort.
3251
3252 # Be careful to initialize this variable, since it used to be cached.
3253 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3254 ac_cv_exeext=
3255 # b.out is created by i960 compilers.
3256 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3257 do
3258   test -f "$ac_file" || continue
3259   case $ac_file in
3260     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3261         ;;
3262     conftest.$ac_ext )
3263         # This is the source file.
3264         ;;
3265     [ab].out )
3266         # We found the default executable, but exeext='' is most
3267         # certainly right.
3268         break;;
3269     *.* )
3270         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3271         # FIXME: I believe we export ac_cv_exeext for Libtool,
3272         # but it would be cool to find out if it's true.  Does anybody
3273         # maintain Libtool? --akim.
3274         export ac_cv_exeext
3275         break;;
3276     * )
3277         break;;
3278   esac
3279 done
3280 else
3281   echo "$as_me: failed program was:" >&5
3282 sed 's/^/| /' conftest.$ac_ext >&5
3283
3284 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3285 See \`config.log' for more details." >&5
3286 echo "$as_me: error: C compiler cannot create executables
3287 See \`config.log' for more details." >&2;}
3288    { (exit 77); exit 77; }; }
3289 fi
3290
3291 ac_exeext=$ac_cv_exeext
3292 echo "$as_me:$LINENO: result: $ac_file" >&5
3293 echo "${ECHO_T}$ac_file" >&6
3294
3295 # Check the compiler produces executables we can run.  If not, either
3296 # the compiler is broken, or we cross compile.
3297 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3298 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3299 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3300 # If not cross compiling, check that we can run a simple program.
3301 if test "$cross_compiling" != yes; then
3302   if { ac_try='./$ac_file'
3303   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3304   (eval $ac_try) 2>&5
3305   ac_status=$?
3306   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3307   (exit $ac_status); }; }; then
3308     cross_compiling=no
3309   else
3310     if test "$cross_compiling" = maybe; then
3311         cross_compiling=yes
3312     else
3313         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3314 If you meant to cross compile, use \`--host'.
3315 See \`config.log' for more details." >&5
3316 echo "$as_me: error: cannot run C compiled programs.
3317 If you meant to cross compile, use \`--host'.
3318 See \`config.log' for more details." >&2;}
3319    { (exit 1); exit 1; }; }
3320     fi
3321   fi
3322 fi
3323 echo "$as_me:$LINENO: result: yes" >&5
3324 echo "${ECHO_T}yes" >&6
3325
3326 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3327 ac_clean_files=$ac_clean_files_save
3328 # Check the compiler produces executables we can run.  If not, either
3329 # the compiler is broken, or we cross compile.
3330 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3331 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3332 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3333 echo "${ECHO_T}$cross_compiling" >&6
3334
3335 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3336 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3337 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3338   (eval $ac_link) 2>&5
3339   ac_status=$?
3340   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3341   (exit $ac_status); }; then
3342   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3343 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3344 # work properly (i.e., refer to `conftest.exe'), while it won't with
3345 # `rm'.
3346 for ac_file in conftest.exe conftest conftest.*; do
3347   test -f "$ac_file" || continue
3348   case $ac_file in
3349     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3350     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3351           export ac_cv_exeext
3352           break;;
3353     * ) break;;
3354   esac
3355 done
3356 else
3357   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3358 See \`config.log' for more details." >&5
3359 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3360 See \`config.log' for more details." >&2;}
3361    { (exit 1); exit 1; }; }
3362 fi
3363
3364 rm -f conftest$ac_cv_exeext
3365 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3366 echo "${ECHO_T}$ac_cv_exeext" >&6
3367
3368 rm -f conftest.$ac_ext
3369 EXEEXT=$ac_cv_exeext
3370 ac_exeext=$EXEEXT
3371 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3372 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3373 if test "${ac_cv_objext+set}" = set; then
3374   echo $ECHO_N "(cached) $ECHO_C" >&6
3375 else
3376   cat >conftest.$ac_ext <<_ACEOF
3377 /* confdefs.h.  */
3378 _ACEOF
3379 cat confdefs.h >>conftest.$ac_ext
3380 cat >>conftest.$ac_ext <<_ACEOF
3381 /* end confdefs.h.  */
3382
3383 int
3384 main ()
3385 {
3386
3387   ;
3388   return 0;
3389 }
3390 _ACEOF
3391 rm -f conftest.o conftest.obj
3392 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3393   (eval $ac_compile) 2>&5
3394   ac_status=$?
3395   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3396   (exit $ac_status); }; then
3397   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3398   case $ac_file in
3399     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3400     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3401        break;;
3402   esac
3403 done
3404 else
3405   echo "$as_me: failed program was:" >&5
3406 sed 's/^/| /' conftest.$ac_ext >&5
3407
3408 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3409 See \`config.log' for more details." >&5
3410 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3411 See \`config.log' for more details." >&2;}
3412    { (exit 1); exit 1; }; }
3413 fi
3414
3415 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3416 fi
3417 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3418 echo "${ECHO_T}$ac_cv_objext" >&6
3419 OBJEXT=$ac_cv_objext
3420 ac_objext=$OBJEXT
3421 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3422 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3423 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3424   echo $ECHO_N "(cached) $ECHO_C" >&6
3425 else
3426   cat >conftest.$ac_ext <<_ACEOF
3427 /* confdefs.h.  */
3428 _ACEOF
3429 cat confdefs.h >>conftest.$ac_ext
3430 cat >>conftest.$ac_ext <<_ACEOF
3431 /* end confdefs.h.  */
3432
3433 int
3434 main ()
3435 {
3436 #ifndef __GNUC__
3437        choke me
3438 #endif
3439
3440   ;
3441   return 0;
3442 }
3443 _ACEOF
3444 rm -f conftest.$ac_objext
3445 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3446   (eval $ac_compile) 2>conftest.er1
3447   ac_status=$?
3448   grep -v '^ *+' conftest.er1 >conftest.err
3449   rm -f conftest.er1
3450   cat conftest.err >&5
3451   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3452   (exit $ac_status); } &&
3453          { ac_try='test -z "$ac_c_werror_flag"
3454                          || test ! -s conftest.err'
3455   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3456   (eval $ac_try) 2>&5
3457   ac_status=$?
3458   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3459   (exit $ac_status); }; } &&
3460          { ac_try='test -s conftest.$ac_objext'
3461   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3462   (eval $ac_try) 2>&5
3463   ac_status=$?
3464   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3465   (exit $ac_status); }; }; then
3466   ac_compiler_gnu=yes
3467 else
3468   echo "$as_me: failed program was:" >&5
3469 sed 's/^/| /' conftest.$ac_ext >&5
3470
3471 ac_compiler_gnu=no
3472 fi
3473 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3474 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3475
3476 fi
3477 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3478 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3479 GCC=`test $ac_compiler_gnu = yes && echo yes`
3480 ac_test_CFLAGS=${CFLAGS+set}
3481 ac_save_CFLAGS=$CFLAGS
3482 CFLAGS="-g"
3483 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3484 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3485 if test "${ac_cv_prog_cc_g+set}" = set; then
3486   echo $ECHO_N "(cached) $ECHO_C" >&6
3487 else
3488   cat >conftest.$ac_ext <<_ACEOF
3489 /* confdefs.h.  */
3490 _ACEOF
3491 cat confdefs.h >>conftest.$ac_ext
3492 cat >>conftest.$ac_ext <<_ACEOF
3493 /* end confdefs.h.  */
3494
3495 int
3496 main ()
3497 {
3498
3499   ;
3500   return 0;
3501 }
3502 _ACEOF
3503 rm -f conftest.$ac_objext
3504 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3505   (eval $ac_compile) 2>conftest.er1
3506   ac_status=$?
3507   grep -v '^ *+' conftest.er1 >conftest.err
3508   rm -f conftest.er1
3509   cat conftest.err >&5
3510   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3511   (exit $ac_status); } &&
3512          { ac_try='test -z "$ac_c_werror_flag"
3513                          || test ! -s conftest.err'
3514   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3515   (eval $ac_try) 2>&5
3516   ac_status=$?
3517   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3518   (exit $ac_status); }; } &&
3519          { ac_try='test -s conftest.$ac_objext'
3520   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3521   (eval $ac_try) 2>&5
3522   ac_status=$?
3523   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3524   (exit $ac_status); }; }; then
3525   ac_cv_prog_cc_g=yes
3526 else
3527   echo "$as_me: failed program was:" >&5
3528 sed 's/^/| /' conftest.$ac_ext >&5
3529
3530 ac_cv_prog_cc_g=no
3531 fi
3532 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3533 fi
3534 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3535 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3536 if test "$ac_test_CFLAGS" = set; then
3537   CFLAGS=$ac_save_CFLAGS
3538 elif test $ac_cv_prog_cc_g = yes; then
3539   if test "$GCC" = yes; then
3540     CFLAGS="-g -O2"
3541   else
3542     CFLAGS="-g"
3543   fi
3544 else
3545   if test "$GCC" = yes; then
3546     CFLAGS="-O2"
3547   else
3548     CFLAGS=
3549   fi
3550 fi
3551 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3552 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3553 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3554   echo $ECHO_N "(cached) $ECHO_C" >&6
3555 else
3556   ac_cv_prog_cc_stdc=no
3557 ac_save_CC=$CC
3558 cat >conftest.$ac_ext <<_ACEOF
3559 /* confdefs.h.  */
3560 _ACEOF
3561 cat confdefs.h >>conftest.$ac_ext
3562 cat >>conftest.$ac_ext <<_ACEOF
3563 /* end confdefs.h.  */
3564 #include <stdarg.h>
3565 #include <stdio.h>
3566 #include <sys/types.h>
3567 #include <sys/stat.h>
3568 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3569 struct buf { int x; };
3570 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3571 static char *e (p, i)
3572      char **p;
3573      int i;
3574 {
3575   return p[i];
3576 }
3577 static char *f (char * (*g) (char **, int), char **p, ...)
3578 {
3579   char *s;
3580   va_list v;
3581   va_start (v,p);
3582   s = g (p, va_arg (v,int));
3583   va_end (v);
3584   return s;
3585 }
3586
3587 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3588    function prototypes and stuff, but not '\xHH' hex character constants.
3589    These don't provoke an error unfortunately, instead are silently treated
3590    as 'x'.  The following induces an error, until -std1 is added to get
3591    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3592    array size at least.  It's necessary to write '\x00'==0 to get something
3593    that's true only with -std1.  */
3594 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3595
3596 int test (int i, double x);
3597 struct s1 {int (*f) (int a);};
3598 struct s2 {int (*f) (double a);};
3599 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3600 int argc;
3601 char **argv;
3602 int
3603 main ()
3604 {
3605 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3606   ;
3607   return 0;
3608 }
3609 _ACEOF
3610 # Don't try gcc -ansi; that turns off useful extensions and
3611 # breaks some systems' header files.
3612 # AIX                   -qlanglvl=ansi
3613 # Ultrix and OSF/1      -std1
3614 # HP-UX 10.20 and later -Ae
3615 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3616 # SVR4                  -Xc -D__EXTENSIONS__
3617 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3618 do
3619   CC="$ac_save_CC $ac_arg"
3620   rm -f conftest.$ac_objext
3621 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3622   (eval $ac_compile) 2>conftest.er1
3623   ac_status=$?
3624   grep -v '^ *+' conftest.er1 >conftest.err
3625   rm -f conftest.er1
3626   cat conftest.err >&5
3627   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3628   (exit $ac_status); } &&
3629          { ac_try='test -z "$ac_c_werror_flag"
3630                          || test ! -s conftest.err'
3631   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3632   (eval $ac_try) 2>&5
3633   ac_status=$?
3634   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3635   (exit $ac_status); }; } &&
3636          { ac_try='test -s conftest.$ac_objext'
3637   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3638   (eval $ac_try) 2>&5
3639   ac_status=$?
3640   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3641   (exit $ac_status); }; }; then
3642   ac_cv_prog_cc_stdc=$ac_arg
3643 break
3644 else
3645   echo "$as_me: failed program was:" >&5
3646 sed 's/^/| /' conftest.$ac_ext >&5
3647
3648 fi
3649 rm -f conftest.err conftest.$ac_objext
3650 done
3651 rm -f conftest.$ac_ext conftest.$ac_objext
3652 CC=$ac_save_CC
3653
3654 fi
3655
3656 case "x$ac_cv_prog_cc_stdc" in
3657   x|xno)
3658     echo "$as_me:$LINENO: result: none needed" >&5
3659 echo "${ECHO_T}none needed" >&6 ;;
3660   *)
3661     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3662 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3663     CC="$CC $ac_cv_prog_cc_stdc" ;;
3664 esac
3665
3666 # Some people use a C++ compiler to compile C.  Since we use `exit',
3667 # in C++ we need to declare it.  In case someone uses the same compiler
3668 # for both compiling C and C++ we need to have the C++ compiler decide
3669 # the declaration of exit, since it's the most demanding environment.
3670 cat >conftest.$ac_ext <<_ACEOF
3671 #ifndef __cplusplus
3672   choke me
3673 #endif
3674 _ACEOF
3675 rm -f conftest.$ac_objext
3676 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3677   (eval $ac_compile) 2>conftest.er1
3678   ac_status=$?
3679   grep -v '^ *+' conftest.er1 >conftest.err
3680   rm -f conftest.er1
3681   cat conftest.err >&5
3682   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3683   (exit $ac_status); } &&
3684          { ac_try='test -z "$ac_c_werror_flag"
3685                          || test ! -s conftest.err'
3686   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3687   (eval $ac_try) 2>&5
3688   ac_status=$?
3689   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3690   (exit $ac_status); }; } &&
3691          { ac_try='test -s conftest.$ac_objext'
3692   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3693   (eval $ac_try) 2>&5
3694   ac_status=$?
3695   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3696   (exit $ac_status); }; }; then
3697   for ac_declaration in \
3698    '' \
3699    'extern "C" void std::exit (int) throw (); using std::exit;' \
3700    'extern "C" void std::exit (int); using std::exit;' \
3701    'extern "C" void exit (int) throw ();' \
3702    'extern "C" void exit (int);' \
3703    'void exit (int);'
3704 do
3705   cat >conftest.$ac_ext <<_ACEOF
3706 /* confdefs.h.  */
3707 _ACEOF
3708 cat confdefs.h >>conftest.$ac_ext
3709 cat >>conftest.$ac_ext <<_ACEOF
3710 /* end confdefs.h.  */
3711 $ac_declaration
3712 #include <stdlib.h>
3713 int
3714 main ()
3715 {
3716 exit (42);
3717   ;
3718   return 0;
3719 }
3720 _ACEOF
3721 rm -f conftest.$ac_objext
3722 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3723   (eval $ac_compile) 2>conftest.er1
3724   ac_status=$?
3725   grep -v '^ *+' conftest.er1 >conftest.err
3726   rm -f conftest.er1
3727   cat conftest.err >&5
3728   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3729   (exit $ac_status); } &&
3730          { ac_try='test -z "$ac_c_werror_flag"
3731                          || test ! -s conftest.err'
3732   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3733   (eval $ac_try) 2>&5
3734   ac_status=$?
3735   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3736   (exit $ac_status); }; } &&
3737          { ac_try='test -s conftest.$ac_objext'
3738   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3739   (eval $ac_try) 2>&5
3740   ac_status=$?
3741   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3742   (exit $ac_status); }; }; then
3743   :
3744 else
3745   echo "$as_me: failed program was:" >&5
3746 sed 's/^/| /' conftest.$ac_ext >&5
3747
3748 continue
3749 fi
3750 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3751   cat >conftest.$ac_ext <<_ACEOF
3752 /* confdefs.h.  */
3753 _ACEOF
3754 cat confdefs.h >>conftest.$ac_ext
3755 cat >>conftest.$ac_ext <<_ACEOF
3756 /* end confdefs.h.  */
3757 $ac_declaration
3758 int
3759 main ()
3760 {
3761 exit (42);
3762   ;
3763   return 0;
3764 }
3765 _ACEOF
3766 rm -f conftest.$ac_objext
3767 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3768   (eval $ac_compile) 2>conftest.er1
3769   ac_status=$?
3770   grep -v '^ *+' conftest.er1 >conftest.err
3771   rm -f conftest.er1
3772   cat conftest.err >&5
3773   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3774   (exit $ac_status); } &&
3775          { ac_try='test -z "$ac_c_werror_flag"
3776                          || test ! -s conftest.err'
3777   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3778   (eval $ac_try) 2>&5
3779   ac_status=$?
3780   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3781   (exit $ac_status); }; } &&
3782          { ac_try='test -s conftest.$ac_objext'
3783   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3784   (eval $ac_try) 2>&5
3785   ac_status=$?
3786   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3787   (exit $ac_status); }; }; then
3788   break
3789 else
3790   echo "$as_me: failed program was:" >&5
3791 sed 's/^/| /' conftest.$ac_ext >&5
3792
3793 fi
3794 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3795 done
3796 rm -f conftest*
3797 if test -n "$ac_declaration"; then
3798   echo '#ifdef __cplusplus' >>confdefs.h
3799   echo $ac_declaration      >>confdefs.h
3800   echo '#endif'             >>confdefs.h
3801 fi
3802
3803 else
3804   echo "$as_me: failed program was:" >&5
3805 sed 's/^/| /' conftest.$ac_ext >&5
3806
3807 fi
3808 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3809 ac_ext=c
3810 ac_cpp='$CPP $CPPFLAGS'
3811 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3812 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3813 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3814
3815 ac_ext=cc
3816 ac_cpp='$CXXCPP $CPPFLAGS'
3817 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3818 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3819 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3820 if test -n "$ac_tool_prefix"; then
3821   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3822   do
3823     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3824 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3825 echo "$as_me:$LINENO: checking for $ac_word" >&5
3826 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3827 if test "${ac_cv_prog_CXX+set}" = set; then
3828   echo $ECHO_N "(cached) $ECHO_C" >&6
3829 else
3830   if test -n "$CXX"; then
3831   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3832 else
3833 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3834 for as_dir in $PATH
3835 do
3836   IFS=$as_save_IFS
3837   test -z "$as_dir" && as_dir=.
3838   for ac_exec_ext in '' $ac_executable_extensions; do
3839   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3840     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3841     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3842     break 2
3843   fi
3844 done
3845 done
3846
3847 fi
3848 fi
3849 CXX=$ac_cv_prog_CXX
3850 if test -n "$CXX"; then
3851   echo "$as_me:$LINENO: result: $CXX" >&5
3852 echo "${ECHO_T}$CXX" >&6
3853 else
3854   echo "$as_me:$LINENO: result: no" >&5
3855 echo "${ECHO_T}no" >&6
3856 fi
3857
3858     test -n "$CXX" && break
3859   done
3860 fi
3861 if test -z "$CXX"; then
3862   ac_ct_CXX=$CXX
3863   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3864 do
3865   # Extract the first word of "$ac_prog", so it can be a program name with args.
3866 set dummy $ac_prog; ac_word=$2
3867 echo "$as_me:$LINENO: checking for $ac_word" >&5
3868 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3869 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3870   echo $ECHO_N "(cached) $ECHO_C" >&6
3871 else
3872   if test -n "$ac_ct_CXX"; then
3873   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3874 else
3875 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3876 for as_dir in $PATH
3877 do
3878   IFS=$as_save_IFS
3879   test -z "$as_dir" && as_dir=.
3880   for ac_exec_ext in '' $ac_executable_extensions; do
3881   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3882     ac_cv_prog_ac_ct_CXX="$ac_prog"
3883     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3884     break 2
3885   fi
3886 done
3887 done
3888
3889 fi
3890 fi
3891 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3892 if test -n "$ac_ct_CXX"; then
3893   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3894 echo "${ECHO_T}$ac_ct_CXX" >&6
3895 else
3896   echo "$as_me:$LINENO: result: no" >&5
3897 echo "${ECHO_T}no" >&6
3898 fi
3899
3900   test -n "$ac_ct_CXX" && break
3901 done
3902 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3903
3904   CXX=$ac_ct_CXX
3905 fi
3906
3907
3908 # Provide some information about the compiler.
3909 echo "$as_me:$LINENO:" \
3910      "checking for C++ compiler version" >&5
3911 ac_compiler=`set X $ac_compile; echo $2`
3912 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3913   (eval $ac_compiler --version </dev/null >&5) 2>&5
3914   ac_status=$?
3915   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3916   (exit $ac_status); }
3917 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3918   (eval $ac_compiler -v </dev/null >&5) 2>&5
3919   ac_status=$?
3920   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3921   (exit $ac_status); }
3922 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3923   (eval $ac_compiler -V </dev/null >&5) 2>&5
3924   ac_status=$?
3925   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3926   (exit $ac_status); }
3927
3928 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3929 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3930 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3931   echo $ECHO_N "(cached) $ECHO_C" >&6
3932 else
3933   cat >conftest.$ac_ext <<_ACEOF
3934 /* confdefs.h.  */
3935 _ACEOF
3936 cat confdefs.h >>conftest.$ac_ext
3937 cat >>conftest.$ac_ext <<_ACEOF
3938 /* end confdefs.h.  */
3939
3940 int
3941 main ()
3942 {
3943 #ifndef __GNUC__
3944        choke me
3945 #endif
3946
3947   ;
3948   return 0;
3949 }
3950 _ACEOF
3951 rm -f conftest.$ac_objext
3952 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3953   (eval $ac_compile) 2>conftest.er1
3954   ac_status=$?
3955   grep -v '^ *+' conftest.er1 >conftest.err
3956   rm -f conftest.er1
3957   cat conftest.err >&5
3958   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3959   (exit $ac_status); } &&
3960          { ac_try='test -z "$ac_cxx_werror_flag"
3961                          || test ! -s conftest.err'
3962   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3963   (eval $ac_try) 2>&5
3964   ac_status=$?
3965   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3966   (exit $ac_status); }; } &&
3967          { ac_try='test -s conftest.$ac_objext'
3968   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3969   (eval $ac_try) 2>&5
3970   ac_status=$?
3971   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3972   (exit $ac_status); }; }; then
3973   ac_compiler_gnu=yes
3974 else
3975   echo "$as_me: failed program was:" >&5
3976 sed 's/^/| /' conftest.$ac_ext >&5
3977
3978 ac_compiler_gnu=no
3979 fi
3980 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3981 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3982
3983 fi
3984 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3985 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
3986 GXX=`test $ac_compiler_gnu = yes && echo yes`
3987 ac_test_CXXFLAGS=${CXXFLAGS+set}
3988 ac_save_CXXFLAGS=$CXXFLAGS
3989 CXXFLAGS="-g"
3990 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3991 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
3992 if test "${ac_cv_prog_cxx_g+set}" = set; then
3993   echo $ECHO_N "(cached) $ECHO_C" >&6
3994 else
3995   cat >conftest.$ac_ext <<_ACEOF
3996 /* confdefs.h.  */
3997 _ACEOF
3998 cat confdefs.h >>conftest.$ac_ext
3999 cat >>conftest.$ac_ext <<_ACEOF
4000 /* end confdefs.h.  */
4001
4002 int
4003 main ()
4004 {
4005
4006   ;
4007   return 0;
4008 }
4009 _ACEOF
4010 rm -f conftest.$ac_objext
4011 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4012   (eval $ac_compile) 2>conftest.er1
4013   ac_status=$?
4014   grep -v '^ *+' conftest.er1 >conftest.err
4015   rm -f conftest.er1
4016   cat conftest.err >&5
4017   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4018   (exit $ac_status); } &&
4019          { ac_try='test -z "$ac_cxx_werror_flag"
4020                          || test ! -s conftest.err'
4021   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4022   (eval $ac_try) 2>&5
4023   ac_status=$?
4024   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4025   (exit $ac_status); }; } &&
4026          { ac_try='test -s conftest.$ac_objext'
4027   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4028   (eval $ac_try) 2>&5
4029   ac_status=$?
4030   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4031   (exit $ac_status); }; }; then
4032   ac_cv_prog_cxx_g=yes
4033 else
4034   echo "$as_me: failed program was:" >&5
4035 sed 's/^/| /' conftest.$ac_ext >&5
4036
4037 ac_cv_prog_cxx_g=no
4038 fi
4039 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4040 fi
4041 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4042 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4043 if test "$ac_test_CXXFLAGS" = set; then
4044   CXXFLAGS=$ac_save_CXXFLAGS
4045 elif test $ac_cv_prog_cxx_g = yes; then
4046   if test "$GXX" = yes; then
4047     CXXFLAGS="-g -O2"
4048   else
4049     CXXFLAGS="-g"
4050   fi
4051 else
4052   if test "$GXX" = yes; then
4053     CXXFLAGS="-O2"
4054   else
4055     CXXFLAGS=
4056   fi
4057 fi
4058 for ac_declaration in \
4059    '' \
4060    'extern "C" void std::exit (int) throw (); using std::exit;' \
4061    'extern "C" void std::exit (int); using std::exit;' \
4062    'extern "C" void exit (int) throw ();' \
4063    'extern "C" void exit (int);' \
4064    'void exit (int);'
4065 do
4066   cat >conftest.$ac_ext <<_ACEOF
4067 /* confdefs.h.  */
4068 _ACEOF
4069 cat confdefs.h >>conftest.$ac_ext
4070 cat >>conftest.$ac_ext <<_ACEOF
4071 /* end confdefs.h.  */
4072 $ac_declaration
4073 #include <stdlib.h>
4074 int
4075 main ()
4076 {
4077 exit (42);
4078   ;
4079   return 0;
4080 }
4081 _ACEOF
4082 rm -f conftest.$ac_objext
4083 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4084   (eval $ac_compile) 2>conftest.er1
4085   ac_status=$?
4086   grep -v '^ *+' conftest.er1 >conftest.err
4087   rm -f conftest.er1
4088   cat conftest.err >&5
4089   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4090   (exit $ac_status); } &&
4091          { ac_try='test -z "$ac_cxx_werror_flag"
4092                          || test ! -s conftest.err'
4093   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4094   (eval $ac_try) 2>&5
4095   ac_status=$?
4096   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4097   (exit $ac_status); }; } &&
4098          { ac_try='test -s conftest.$ac_objext'
4099   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4100   (eval $ac_try) 2>&5
4101   ac_status=$?
4102   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4103   (exit $ac_status); }; }; then
4104   :
4105 else
4106   echo "$as_me: failed program was:" >&5
4107 sed 's/^/| /' conftest.$ac_ext >&5
4108
4109 continue
4110 fi
4111 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4112   cat >conftest.$ac_ext <<_ACEOF
4113 /* confdefs.h.  */
4114 _ACEOF
4115 cat confdefs.h >>conftest.$ac_ext
4116 cat >>conftest.$ac_ext <<_ACEOF
4117 /* end confdefs.h.  */
4118 $ac_declaration
4119 int
4120 main ()
4121 {
4122 exit (42);
4123   ;
4124   return 0;
4125 }
4126 _ACEOF
4127 rm -f conftest.$ac_objext
4128 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4129   (eval $ac_compile) 2>conftest.er1
4130   ac_status=$?
4131   grep -v '^ *+' conftest.er1 >conftest.err
4132   rm -f conftest.er1
4133   cat conftest.err >&5
4134   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4135   (exit $ac_status); } &&
4136          { ac_try='test -z "$ac_cxx_werror_flag"
4137                          || test ! -s conftest.err'
4138   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4139   (eval $ac_try) 2>&5
4140   ac_status=$?
4141   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4142   (exit $ac_status); }; } &&
4143          { ac_try='test -s conftest.$ac_objext'
4144   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4145   (eval $ac_try) 2>&5
4146   ac_status=$?
4147   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4148   (exit $ac_status); }; }; then
4149   break
4150 else
4151   echo "$as_me: failed program was:" >&5
4152 sed 's/^/| /' conftest.$ac_ext >&5
4153
4154 fi
4155 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4156 done
4157 rm -f conftest*
4158 if test -n "$ac_declaration"; then
4159   echo '#ifdef __cplusplus' >>confdefs.h
4160   echo $ac_declaration      >>confdefs.h
4161   echo '#endif'             >>confdefs.h
4162 fi
4163
4164 ac_ext=c
4165 ac_cpp='$CPP $CPPFLAGS'
4166 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4167 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4168 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4169
4170
4171 # We must set the default linker to the linker used by gcc for the correct
4172 # operation of libtool.  If LD is not defined and we are using gcc, try to
4173 # set the LD default to the ld used by gcc.
4174 if test -z "$LD"; then
4175   if test "$GCC" = yes; then
4176     case $build in
4177     *-*-mingw*)
4178       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4179     *)
4180       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4181     esac
4182     case $gcc_prog_ld in
4183     # Accept absolute paths.
4184     [\\/]* | [A-Za-z]:[\\/]*)
4185       LD="$gcc_prog_ld" ;;
4186     esac
4187   fi
4188 fi
4189
4190
4191
4192
4193 if test -n "$ac_tool_prefix"; then
4194   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4195 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4196 echo "$as_me:$LINENO: checking for $ac_word" >&5
4197 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4198 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4199   echo $ECHO_N "(cached) $ECHO_C" >&6
4200 else
4201   if test -n "$GNATBIND"; then
4202   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4203 else
4204 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4205 for as_dir in $PATH
4206 do
4207   IFS=$as_save_IFS
4208   test -z "$as_dir" && as_dir=.
4209   for ac_exec_ext in '' $ac_executable_extensions; do
4210   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4211     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4212     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4213     break 2
4214   fi
4215 done
4216 done
4217
4218 fi
4219 fi
4220 GNATBIND=$ac_cv_prog_GNATBIND
4221 if test -n "$GNATBIND"; then
4222   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4223 echo "${ECHO_T}$GNATBIND" >&6
4224 else
4225   echo "$as_me:$LINENO: result: no" >&5
4226 echo "${ECHO_T}no" >&6
4227 fi
4228
4229 fi
4230 if test -z "$ac_cv_prog_GNATBIND"; then
4231   ac_ct_GNATBIND=$GNATBIND
4232   # Extract the first word of "gnatbind", so it can be a program name with args.
4233 set dummy gnatbind; ac_word=$2
4234 echo "$as_me:$LINENO: checking for $ac_word" >&5
4235 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4236 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4237   echo $ECHO_N "(cached) $ECHO_C" >&6
4238 else
4239   if test -n "$ac_ct_GNATBIND"; then
4240   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4241 else
4242 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4243 for as_dir in $PATH
4244 do
4245   IFS=$as_save_IFS
4246   test -z "$as_dir" && as_dir=.
4247   for ac_exec_ext in '' $ac_executable_extensions; do
4248   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4249     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4250     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4251     break 2
4252   fi
4253 done
4254 done
4255
4256   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4257 fi
4258 fi
4259 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4260 if test -n "$ac_ct_GNATBIND"; then
4261   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4262 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4263 else
4264   echo "$as_me:$LINENO: result: no" >&5
4265 echo "${ECHO_T}no" >&6
4266 fi
4267
4268   GNATBIND=$ac_ct_GNATBIND
4269 else
4270   GNATBIND="$ac_cv_prog_GNATBIND"
4271 fi
4272
4273 if test -n "$ac_tool_prefix"; then
4274   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4275 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4276 echo "$as_me:$LINENO: checking for $ac_word" >&5
4277 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4278 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4279   echo $ECHO_N "(cached) $ECHO_C" >&6
4280 else
4281   if test -n "$GNATMAKE"; then
4282   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4283 else
4284 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4285 for as_dir in $PATH
4286 do
4287   IFS=$as_save_IFS
4288   test -z "$as_dir" && as_dir=.
4289   for ac_exec_ext in '' $ac_executable_extensions; do
4290   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4291     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4292     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4293     break 2
4294   fi
4295 done
4296 done
4297
4298 fi
4299 fi
4300 GNATMAKE=$ac_cv_prog_GNATMAKE
4301 if test -n "$GNATMAKE"; then
4302   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4303 echo "${ECHO_T}$GNATMAKE" >&6
4304 else
4305   echo "$as_me:$LINENO: result: no" >&5
4306 echo "${ECHO_T}no" >&6
4307 fi
4308
4309 fi
4310 if test -z "$ac_cv_prog_GNATMAKE"; then
4311   ac_ct_GNATMAKE=$GNATMAKE
4312   # Extract the first word of "gnatmake", so it can be a program name with args.
4313 set dummy gnatmake; ac_word=$2
4314 echo "$as_me:$LINENO: checking for $ac_word" >&5
4315 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4316 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4317   echo $ECHO_N "(cached) $ECHO_C" >&6
4318 else
4319   if test -n "$ac_ct_GNATMAKE"; then
4320   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4321 else
4322 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4323 for as_dir in $PATH
4324 do
4325   IFS=$as_save_IFS
4326   test -z "$as_dir" && as_dir=.
4327   for ac_exec_ext in '' $ac_executable_extensions; do
4328   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4329     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4330     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4331     break 2
4332   fi
4333 done
4334 done
4335
4336   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4337 fi
4338 fi
4339 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4340 if test -n "$ac_ct_GNATMAKE"; then
4341   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4342 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4343 else
4344   echo "$as_me:$LINENO: result: no" >&5
4345 echo "${ECHO_T}no" >&6
4346 fi
4347
4348   GNATMAKE=$ac_ct_GNATMAKE
4349 else
4350   GNATMAKE="$ac_cv_prog_GNATMAKE"
4351 fi
4352
4353 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4354 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4355 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4356   echo $ECHO_N "(cached) $ECHO_C" >&6
4357 else
4358   cat >conftest.adb <<EOF
4359 procedure conftest is begin null; end conftest;
4360 EOF
4361 acx_cv_cc_gcc_supports_ada=no
4362 # There is a bug in old released versions of GCC which causes the
4363 # driver to exit successfully when the appropriate language module
4364 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4365 # Therefore we must check for the error message as well as an
4366 # unsuccessful exit.
4367 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4368 # given a .adb file, but produce no object file.  So we must check
4369 # if an object file was really produced to guard against this.
4370 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4371 if test x"$errors" = x && test -f conftest.$ac_objext; then
4372   acx_cv_cc_gcc_supports_ada=yes
4373 fi
4374 rm -f conftest.*
4375 fi
4376 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4377 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4378
4379 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4380   have_gnat=yes
4381 else
4382   have_gnat=no
4383 fi
4384
4385 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4386 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4387 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4388   echo $ECHO_N "(cached) $ECHO_C" >&6
4389 else
4390    echo abfoo >t1
4391   echo cdfoo >t2
4392   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4393   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4394     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4395       :
4396     else
4397       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4398     fi
4399   fi
4400   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4401     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4402       :
4403     else
4404       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4405     fi
4406   fi
4407   rm t1 t2
4408
4409 fi
4410 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4411 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4412 do_compare="$gcc_cv_prog_cmp_skip"
4413
4414
4415
4416 # Check for GMP and MPFR
4417 gmplibs="-lmpfr -lgmp"
4418 gmpinc=
4419 have_gmp=no
4420
4421 # Specify a location for mpfr
4422 # check for this first so it ends up on the link line before gmp.
4423
4424 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4425 if test "${with_mpfr_dir+set}" = set; then
4426   withval="$with_mpfr_dir"
4427   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4428 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4429 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4430 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4431    { (exit 1); exit 1; }; }
4432 fi;
4433
4434
4435 # Check whether --with-mpfr or --without-mpfr was given.
4436 if test "${with_mpfr+set}" = set; then
4437   withval="$with_mpfr"
4438
4439 fi;
4440
4441 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4442 if test "${with_mpfr_include+set}" = set; then
4443   withval="$with_mpfr_include"
4444
4445 fi;
4446
4447 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4448 if test "${with_mpfr_lib+set}" = set; then
4449   withval="$with_mpfr_lib"
4450
4451 fi;
4452
4453 if test "x$with_mpfr" != x; then
4454   gmplibs="-L$with_mpfr/lib $gmplibs"
4455   gmpinc="-I$with_mpfr/include"
4456 fi
4457 if test "x$with_mpfr_include" != x; then
4458   gmpinc="-I$with_mpfr_include"
4459 fi
4460 if test "x$with_mpfr_lib" != x; then
4461   gmplibs="-L$with_mpfr_lib $gmplibs"
4462 fi
4463 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4464   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4465   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4466   # Do not test the mpfr version.  Assume that it is sufficient, since
4467   # it is in the source tree, and the library has not been built yet
4468   # but it would be included on the link line in the version check below
4469   # hence making the test fail.
4470   have_gmp=yes
4471 fi
4472
4473 # Specify a location for gmp
4474
4475 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4476 if test "${with_gmp_dir+set}" = set; then
4477   withval="$with_gmp_dir"
4478   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4479 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4480 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4481 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4482    { (exit 1); exit 1; }; }
4483 fi;
4484
4485
4486 # Check whether --with-gmp or --without-gmp was given.
4487 if test "${with_gmp+set}" = set; then
4488   withval="$with_gmp"
4489
4490 fi;
4491
4492 # Check whether --with-gmp_include or --without-gmp_include was given.
4493 if test "${with_gmp_include+set}" = set; then
4494   withval="$with_gmp_include"
4495
4496 fi;
4497
4498 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4499 if test "${with_gmp_lib+set}" = set; then
4500   withval="$with_gmp_lib"
4501
4502 fi;
4503
4504
4505 if test "x$with_gmp" != x; then
4506   gmplibs="-L$with_gmp/lib $gmplibs"
4507   gmpinc="-I$with_gmp/include $gmpinc"
4508 fi
4509 if test "x$with_gmp_include" != x; then
4510   gmpinc="-I$with_gmp_include $gmpinc"
4511 fi
4512 if test "x$with_gmp_lib" != x; then
4513   gmplibs="-L$with_gmp_lib $gmplibs"
4514 fi
4515 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4516   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4517   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4518   # Do not test the gmp version.  Assume that it is sufficient, since
4519   # it is in the source tree, and the library has not been built yet
4520   # but it would be included on the link line in the version check below
4521   # hence making the test fail.
4522   have_gmp=yes
4523 fi
4524
4525 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4526   have_gmp=yes
4527   saved_CFLAGS="$CFLAGS"
4528   CFLAGS="$CFLAGS $gmpinc"
4529   # Check GMP actually works
4530   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4531 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4532
4533 cat >conftest.$ac_ext <<_ACEOF
4534 /* confdefs.h.  */
4535 _ACEOF
4536 cat confdefs.h >>conftest.$ac_ext
4537 cat >>conftest.$ac_ext <<_ACEOF
4538 /* end confdefs.h.  */
4539 #include "gmp.h"
4540 int
4541 main ()
4542 {
4543
4544   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4545   choke me
4546   #endif
4547
4548   ;
4549   return 0;
4550 }
4551 _ACEOF
4552 rm -f conftest.$ac_objext
4553 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4554   (eval $ac_compile) 2>conftest.er1
4555   ac_status=$?
4556   grep -v '^ *+' conftest.er1 >conftest.err
4557   rm -f conftest.er1
4558   cat conftest.err >&5
4559   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4560   (exit $ac_status); } &&
4561          { ac_try='test -z "$ac_c_werror_flag"
4562                          || test ! -s conftest.err'
4563   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4564   (eval $ac_try) 2>&5
4565   ac_status=$?
4566   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4567   (exit $ac_status); }; } &&
4568          { ac_try='test -s conftest.$ac_objext'
4569   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4570   (eval $ac_try) 2>&5
4571   ac_status=$?
4572   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4573   (exit $ac_status); }; }; then
4574   echo "$as_me:$LINENO: result: yes" >&5
4575 echo "${ECHO_T}yes" >&6
4576 else
4577   echo "$as_me: failed program was:" >&5
4578 sed 's/^/| /' conftest.$ac_ext >&5
4579
4580 echo "$as_me:$LINENO: result: no" >&5
4581 echo "${ECHO_T}no" >&6; have_gmp=no
4582 fi
4583 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4584
4585   if test x"$have_gmp" = xyes; then
4586     saved_LIBS="$LIBS"
4587     LIBS="$LIBS $gmplibs"
4588         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4589 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4590     cat >conftest.$ac_ext <<_ACEOF
4591 /* confdefs.h.  */
4592 _ACEOF
4593 cat confdefs.h >>conftest.$ac_ext
4594 cat >>conftest.$ac_ext <<_ACEOF
4595 /* end confdefs.h.  */
4596 #include <gmp.h>
4597     #include <mpfr.h>
4598 int
4599 main ()
4600 {
4601
4602     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4603     choke me
4604     #endif
4605     mpfr_t n;
4606     mpfr_t x;
4607     int t;
4608     mpfr_init (n);
4609     mpfr_init (x);
4610     mpfr_atan2 (n, n, x, GMP_RNDN);
4611     mpfr_erfc (n, x, GMP_RNDN);
4612     mpfr_subnormalize (x, t, GMP_RNDN);
4613
4614   ;
4615   return 0;
4616 }
4617 _ACEOF
4618 rm -f conftest.$ac_objext conftest$ac_exeext
4619 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4620   (eval $ac_link) 2>conftest.er1
4621   ac_status=$?
4622   grep -v '^ *+' conftest.er1 >conftest.err
4623   rm -f conftest.er1
4624   cat conftest.err >&5
4625   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4626   (exit $ac_status); } &&
4627          { ac_try='test -z "$ac_c_werror_flag"
4628                          || test ! -s conftest.err'
4629   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4630   (eval $ac_try) 2>&5
4631   ac_status=$?
4632   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4633   (exit $ac_status); }; } &&
4634          { ac_try='test -s conftest$ac_exeext'
4635   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4636   (eval $ac_try) 2>&5
4637   ac_status=$?
4638   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4639   (exit $ac_status); }; }; then
4640   cat >conftest.$ac_ext <<_ACEOF
4641 /* confdefs.h.  */
4642 _ACEOF
4643 cat confdefs.h >>conftest.$ac_ext
4644 cat >>conftest.$ac_ext <<_ACEOF
4645 /* end confdefs.h.  */
4646 #include <gmp.h>
4647     #include <mpfr.h>
4648 int
4649 main ()
4650 {
4651
4652     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4653     choke me
4654     #endif
4655     mpfr_t n; mpfr_init(n);
4656
4657   ;
4658   return 0;
4659 }
4660 _ACEOF
4661 rm -f conftest.$ac_objext conftest$ac_exeext
4662 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4663   (eval $ac_link) 2>conftest.er1
4664   ac_status=$?
4665   grep -v '^ *+' conftest.er1 >conftest.err
4666   rm -f conftest.er1
4667   cat conftest.err >&5
4668   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4669   (exit $ac_status); } &&
4670          { ac_try='test -z "$ac_c_werror_flag"
4671                          || test ! -s conftest.err'
4672   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4673   (eval $ac_try) 2>&5
4674   ac_status=$?
4675   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4676   (exit $ac_status); }; } &&
4677          { ac_try='test -s conftest$ac_exeext'
4678   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4679   (eval $ac_try) 2>&5
4680   ac_status=$?
4681   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4682   (exit $ac_status); }; }; then
4683   echo "$as_me:$LINENO: result: yes" >&5
4684 echo "${ECHO_T}yes" >&6
4685 else
4686   echo "$as_me: failed program was:" >&5
4687 sed 's/^/| /' conftest.$ac_ext >&5
4688
4689 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4690 echo "${ECHO_T}buggy but acceptable" >&6
4691 fi
4692 rm -f conftest.err conftest.$ac_objext \
4693       conftest$ac_exeext conftest.$ac_ext
4694 else
4695   echo "$as_me: failed program was:" >&5
4696 sed 's/^/| /' conftest.$ac_ext >&5
4697
4698 echo "$as_me:$LINENO: result: no" >&5
4699 echo "${ECHO_T}no" >&6; have_gmp=no
4700 fi
4701 rm -f conftest.err conftest.$ac_objext \
4702       conftest$ac_exeext conftest.$ac_ext
4703       LIBS="$saved_LIBS"
4704   fi
4705   CFLAGS="$saved_CFLAGS"
4706
4707   if test x$have_gmp != xyes; then
4708     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4709 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4710 Copies of these libraries' source code can be found at their respective
4711 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4712 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4713 If you obtained GMP and/or MPFR from a vendor distribution package, make
4714 sure that you have installed both the libraries and the header files.
4715 They may be located in separate packages." >&5
4716 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4717 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4718 Copies of these libraries' source code can be found at their respective
4719 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4720 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4721 If you obtained GMP and/or MPFR from a vendor distribution package, make
4722 sure that you have installed both the libraries and the header files.
4723 They may be located in separate packages." >&2;}
4724    { (exit 1); exit 1; }; }
4725   fi
4726 fi
4727
4728 # Flags needed for both GMP and/or MPFR
4729
4730
4731
4732 # By default, C is the only stage 1 language.
4733 stage1_languages=,c,
4734
4735 # Figure out what language subdirectories are present.
4736 # Look if the user specified --enable-languages="..."; if not, use
4737 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4738 # go away some day.
4739 # NB:  embedded tabs in this IF block -- do not untabify
4740 if test -d ${srcdir}/gcc; then
4741   if test x"${enable_languages+set}" != xset; then
4742     if test x"${LANGUAGES+set}" = xset; then
4743       enable_languages="${LANGUAGES}"
4744         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4745     else
4746       enable_languages=all
4747     fi
4748   else
4749     if test x"${enable_languages}" = x ||
4750        test x"${enable_languages}" = xyes;
4751        then
4752       echo configure.in: --enable-languages needs at least one language argument 1>&2
4753       exit 1
4754     fi
4755   fi
4756   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4757
4758   # 'f95' is the old name for the 'fortran' language. We issue a warning
4759   # and make the substitution.
4760   case ,${enable_languages}, in
4761     *,f95,*)
4762       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4763       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4764       ;;
4765   esac
4766
4767   # First scan to see if an enabled language requires some other language.
4768   # We assume that a given config-lang.in will list all the language
4769   # front ends it requires, even if some are required indirectly.
4770   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4771     case ${lang_frag} in
4772       ..) ;;
4773       # The odd quoting in the next line works around
4774       # an apparent bug in bash 1.12 on linux.
4775       ${srcdir}/gcc/[*]/config-lang.in) ;;
4776       *)
4777         # From the config-lang.in, get $language, $lang_requires
4778         language=
4779         lang_requires=
4780         . ${lang_frag}
4781         for other in ${lang_requires} ; do
4782           case ,${enable_languages}, in
4783             *,$other,*) ;;
4784             *,all,*) ;;
4785             *,$language,*)
4786               echo " \`$other' language required by \`$language'; enabling" 1>&2
4787               enable_languages="${enable_languages},${other}"
4788               ;;
4789           esac
4790         done
4791         ;;
4792     esac
4793   done
4794
4795   new_enable_languages=,c,
4796   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4797   potential_languages=,c,
4798
4799   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4800     case ${lang_frag} in
4801       ..) ;;
4802       # The odd quoting in the next line works around
4803       # an apparent bug in bash 1.12 on linux.
4804       ${srcdir}/gcc/[*]/config-lang.in) ;;
4805       *)
4806         # From the config-lang.in, get $language, $target_libs,
4807         # $lang_dirs, $boot_language, and $build_by_default
4808         language=
4809         target_libs=
4810         lang_dirs=
4811         subdir_requires=
4812         boot_language=no
4813         build_by_default=yes
4814         . ${lang_frag}
4815         if test x${language} = x; then
4816           echo "${lang_frag} doesn't set \$language." 1>&2
4817           exit 1
4818         fi
4819
4820         case ,${enable_languages}, in
4821           *,${language},*)
4822             # Language was explicitly selected; include it.
4823             add_this_lang=yes
4824             ;;
4825           *,all,*)
4826             # 'all' was selected, select it if it is a default language
4827             add_this_lang=${build_by_default}
4828             ;;
4829           *)
4830             add_this_lang=no
4831             ;;
4832         esac
4833
4834         # Disable languages that need other directories if these aren't available.
4835         for i in $subdir_requires; do
4836           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4837           case ,${enable_languages}, in
4838             *,${language},*)
4839               # Specifically requested language; tell them.
4840               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4841 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4842    { (exit 1); exit 1; }; }
4843               ;;
4844             *)
4845               # Silently disable.
4846               add_this_lang=unsupported
4847               ;;
4848           esac
4849         done
4850
4851         # Disable Ada if no preexisting GNAT is available.
4852         case ,${enable_languages},:${language}:${have_gnat} in
4853           *,${language},*:ada:no)
4854             # Specifically requested language; tell them.
4855             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4856 echo "$as_me: error: GNAT is required to build $language" >&2;}
4857    { (exit 1); exit 1; }; }
4858             ;;
4859           *:ada:no)
4860             # Silently disable.
4861             add_this_lang=unsupported
4862             ;;
4863         esac
4864
4865         # Disable a language that is unsupported by the target.
4866         case " $unsupported_languages " in
4867           *" $language "*)
4868             add_this_lang=unsupported
4869             ;;
4870         esac
4871
4872         case $add_this_lang in
4873           unsupported)
4874             # Remove language-dependent dirs.
4875             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4876             ;;
4877           no)
4878             # Remove language-dependent dirs; still show language as supported.
4879             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4880             potential_languages="${potential_languages}${language},"
4881             ;;
4882           yes)
4883             new_enable_languages="${new_enable_languages}${language},"
4884             potential_languages="${potential_languages}${language},"
4885             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4886             case ${boot_language} in
4887               yes)
4888                 # Add to (comma-separated) list of stage 1 languages.
4889                 stage1_languages="${stage1_languages}${language},"
4890                 ;;
4891             esac
4892             ;;
4893         esac
4894         ;;
4895     esac
4896   done
4897
4898   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4899 if test "${enable_stage1_languages+set}" = set; then
4900   enableval="$enable_stage1_languages"
4901   case ,${enable_stage1_languages}, in
4902     ,no,|,,)
4903       # Set it to something that will have no effect in the loop below
4904       enable_stage1_languages=c ;;
4905     ,yes,)
4906       enable_stage1_languages=`echo $new_enable_languages | \
4907         sed -e "s/^,//" -e "s/,$//" ` ;;
4908     *,all,*)
4909       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4910         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4911   esac
4912
4913   # Add "good" languages from enable_stage1_languages to stage1_languages,
4914   # while "bad" languages go in missing_languages.  Leave no duplicates.
4915   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4916     case $potential_languages in
4917       *,$i,*)
4918         case $stage1_languages in
4919           *,$i,*) ;;
4920           *) stage1_languages="$stage1_languages$i," ;;
4921         esac ;;
4922       *)
4923         case $missing_languages in
4924           *,$i,*) ;;
4925           *) missing_languages="$missing_languages$i," ;;
4926         esac ;;
4927      esac
4928   done
4929 fi;
4930
4931   # Remove leading/trailing commas that were added for simplicity
4932   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4933   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4934   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4935   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4936
4937   if test "x$missing_languages" != x; then
4938     { { echo "$as_me:$LINENO: error:
4939 The following requested languages could not be built: ${missing_languages}
4940 Supported languages are: ${potential_languages}" >&5
4941 echo "$as_me: error:
4942 The following requested languages could not be built: ${missing_languages}
4943 Supported languages are: ${potential_languages}" >&2;}
4944    { (exit 1); exit 1; }; }
4945   fi
4946   if test "x$new_enable_languages" != "x$enable_languages"; then
4947     echo The following languages will be built: ${new_enable_languages}
4948     enable_languages="$new_enable_languages"
4949   fi
4950
4951
4952   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4953 fi
4954
4955 # Handle --disable-<component> generically.
4956 for dir in $configdirs $build_configdirs $target_configdirs ; do
4957   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4958   varname=`echo $dirname | sed -e s/+/_/g`
4959   if eval test x\${enable_${varname}} "=" xno ; then
4960     noconfigdirs="$noconfigdirs $dir"
4961   fi
4962 done
4963
4964 # Check for Boehm's garbage collector
4965 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4966 if test "${enable_objc_gc+set}" = set; then
4967   enableval="$enable_objc_gc"
4968   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4969   *,objc,*:*:yes:*target-boehm-gc*)
4970     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4971 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4972    { (exit 1); exit 1; }; }
4973     ;;
4974 esac
4975 fi;
4976
4977 # Make sure we only build Boehm's garbage collector if required.
4978 case ,${enable_languages},:${enable_objc_gc} in
4979   *,objc,*:yes)
4980     # Keep target-boehm-gc if requested for Objective-C.
4981     ;;
4982   *)
4983     # Otherwise remove target-boehm-gc depending on target-libjava.
4984     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
4985       noconfigdirs="$noconfigdirs target-boehm-gc"
4986     fi
4987     ;;
4988 esac
4989
4990 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
4991 # $build_configdirs and $target_configdirs.
4992 # If we have the source for $noconfigdirs entries, add them to $notsupp.
4993
4994 notsupp=""
4995 for dir in . $skipdirs $noconfigdirs ; do
4996   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
4997   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4998     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
4999     if test -r $srcdir/$dirname/configure ; then
5000       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5001         true
5002       else
5003         notsupp="$notsupp $dir"
5004       fi
5005     fi
5006   fi
5007   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5008     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5009     if test -r $srcdir/$dirname/configure ; then
5010       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5011         true
5012       else
5013         notsupp="$notsupp $dir"
5014       fi
5015     fi
5016   fi
5017   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5018     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5019     if test -r $srcdir/$dirname/configure ; then
5020       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5021         true
5022       else
5023         notsupp="$notsupp $dir"
5024       fi
5025     fi
5026   fi
5027 done
5028
5029 # Sometimes the tools are distributed with libiberty but with no other
5030 # libraries.  In that case, we don't want to build target-libiberty.
5031 # Don't let libgcc imply libiberty either.
5032 if test -n "${target_configdirs}" ; then
5033   libgcc=
5034   others=
5035   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5036     if test "$i" = "libgcc"; then
5037       libgcc=target-libgcc
5038     elif test "$i" != "libiberty" ; then
5039       if test -r $srcdir/$i/configure ; then
5040         others=yes;
5041         break;
5042       fi
5043     fi
5044   done
5045   if test -z "${others}" ; then
5046     target_configdirs=$libgcc
5047   fi
5048 fi
5049
5050 # Quietly strip out all directories which aren't configurable in this tree.
5051 # This relies on all configurable subdirectories being autoconfiscated, which
5052 # is now the case.
5053 build_configdirs_all="$build_configdirs"
5054 build_configdirs=
5055 for i in ${build_configdirs_all} ; do
5056   j=`echo $i | sed -e s/build-//g`
5057   if test -f ${srcdir}/$j/configure ; then
5058     build_configdirs="${build_configdirs} $i"
5059   fi
5060 done
5061
5062 configdirs_all="$configdirs"
5063 configdirs=
5064 for i in ${configdirs_all} ; do
5065   if test -f ${srcdir}/$i/configure ; then
5066     configdirs="${configdirs} $i"
5067   fi
5068 done
5069
5070 target_configdirs_all="$target_configdirs"
5071 target_configdirs=
5072 for i in ${target_configdirs_all} ; do
5073   j=`echo $i | sed -e s/target-//g`
5074   if test -f ${srcdir}/$j/configure ; then
5075     target_configdirs="${target_configdirs} $i"
5076   fi
5077 done
5078
5079 # Produce a warning message for the subdirs we can't configure.
5080 # This isn't especially interesting in the Cygnus tree, but in the individual
5081 # FSF releases, it's important to let people know when their machine isn't
5082 # supported by the one or two programs in a package.
5083
5084 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5085   # If $appdirs is non-empty, at least one of those directories must still
5086   # be configured, or we error out.  (E.g., if the gas release supports a
5087   # specified target in some subdirs but not the gas subdir, we shouldn't
5088   # pretend that all is well.)
5089   if test -n "$appdirs" ; then
5090     for dir in $appdirs ; do
5091       if test -r $dir/Makefile.in ; then
5092         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5093           appdirs=""
5094           break
5095         fi
5096         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5097           appdirs=""
5098           break
5099         fi
5100       fi
5101     done
5102     if test -n "$appdirs" ; then
5103       echo "*** This configuration is not supported by this package." 1>&2
5104       exit 1
5105     fi
5106   fi
5107   # Okay, some application will build, or we don't care to check.  Still
5108   # notify of subdirs not getting built.
5109   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5110   echo "    ${notsupp}" 1>&2
5111   echo "    (Any other directories should still work fine.)" 1>&2
5112 fi
5113
5114 case "$host" in
5115   *msdosdjgpp*)
5116     enable_gdbtk=no ;;
5117 esac
5118
5119 # To find our prefix, in gcc_cv_tool_prefix.
5120
5121 # The user is always right.
5122 if test "${PATH_SEPARATOR+set}" != set; then
5123   echo "#! /bin/sh" >conf$$.sh
5124   echo  "exit 0"   >>conf$$.sh
5125   chmod +x conf$$.sh
5126   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5127     PATH_SEPARATOR=';'
5128   else
5129     PATH_SEPARATOR=:
5130   fi
5131   rm -f conf$$.sh
5132 fi
5133
5134
5135
5136 if test "x$exec_prefix" = xNONE; then
5137         if test "x$prefix" = xNONE; then
5138                 gcc_cv_tool_prefix=$ac_default_prefix
5139         else
5140                 gcc_cv_tool_prefix=$prefix
5141         fi
5142 else
5143         gcc_cv_tool_prefix=$exec_prefix
5144 fi
5145
5146 # If there is no compiler in the tree, use the PATH only.  In any
5147 # case, if there is no compiler in the tree nobody should use
5148 # AS_FOR_TARGET and LD_FOR_TARGET.
5149 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5150     gcc_version=`cat $srcdir/gcc/BASE-VER`
5151     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5152     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5153     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5154     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5155     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5156     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5157 else
5158     gcc_cv_tool_dirs=
5159 fi
5160
5161 if test x$build = x$target && test -n "$md_exec_prefix"; then
5162         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5163 fi
5164
5165
5166
5167 copy_dirs=
5168
5169
5170 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5171 if test "${with_build_sysroot+set}" = set; then
5172   withval="$with_build_sysroot"
5173   if test x"$withval" != x ; then
5174      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5175    fi
5176 else
5177   SYSROOT_CFLAGS_FOR_TARGET=
5178 fi;
5179
5180
5181
5182 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5183 if test "${with_debug_prefix_map+set}" = set; then
5184   withval="$with_debug_prefix_map"
5185   if test x"$withval" != x; then
5186      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5187      for debug_map in $withval; do
5188        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5189      done
5190    fi
5191 else
5192   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5193 fi;
5194
5195
5196 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5197 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5198 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5199 # We want to ensure that TARGET libraries (which we know are built with
5200 # gcc) are built with "-O2 -g", so include those options when setting
5201 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5202 if test "x$CFLAGS_FOR_TARGET" = x; then
5203   CFLAGS_FOR_TARGET=$CFLAGS
5204   case " $CFLAGS " in
5205     *" -O2 "*) ;;
5206     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5207   esac
5208   case " $CFLAGS " in
5209     *" -g "* | *" -g3 "*) ;;
5210     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5211   esac
5212 fi
5213
5214
5215 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5216   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5217   case " $CXXFLAGS " in
5218     *" -O2 "*) ;;
5219     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5220   esac
5221   case " $CXXFLAGS " in
5222     *" -g "* | *" -g3 "*) ;;
5223     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5224   esac
5225 fi
5226
5227
5228 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5229 # the named directory are copied to $(tooldir)/sys-include.
5230 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5231   if test x${is_cross_compiler} = xno ; then
5232     echo 1>&2 '***' --with-headers is only supported when cross compiling
5233     exit 1
5234   fi
5235   if test x"${with_headers}" != xyes ; then
5236     x=${gcc_cv_tool_prefix}
5237     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5238   fi
5239 fi
5240
5241 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5242 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5243 # are permitted.
5244 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5245   if test x${is_cross_compiler} = xno ; then
5246     echo 1>&2 '***' --with-libs is only supported when cross compiling
5247     exit 1
5248   fi
5249   if test x"${with_libs}" != xyes ; then
5250     # Copy the libraries in reverse order, so that files in the first named
5251     # library override files in subsequent libraries.
5252     x=${gcc_cv_tool_prefix}
5253     for l in ${with_libs}; do
5254       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5255     done
5256   fi
5257 fi
5258
5259 # Set with_gnu_as and with_gnu_ld as appropriate.
5260 #
5261 # This is done by determining whether or not the appropriate directory
5262 # is available, and by checking whether or not specific configurations
5263 # have requested that this magic not happen.
5264 #
5265 # The command line options always override the explicit settings in
5266 # configure.in, and the settings in configure.in override this magic.
5267 #
5268 # If the default for a toolchain is to use GNU as and ld, and you don't
5269 # want to do that, then you should use the --without-gnu-as and
5270 # --without-gnu-ld options for the configure script.
5271
5272 if test x${use_gnu_as} = x &&
5273    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5274   with_gnu_as=yes
5275   extra_host_args="$extra_host_args --with-gnu-as"
5276 fi
5277
5278 if test x${use_gnu_ld} = x &&
5279    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5280   with_gnu_ld=yes
5281   extra_host_args="$extra_host_args --with-gnu-ld"
5282 fi
5283
5284 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5285 # can detect this case.
5286
5287 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5288   with_newlib=yes
5289   extra_host_args="$extra_host_args --with-newlib"
5290 fi
5291
5292 # Handle ${copy_dirs}
5293 set fnord ${copy_dirs}
5294 shift
5295 while test $# != 0 ; do
5296   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5297     :
5298   else
5299     echo Copying $1 to $2
5300
5301     # Use the install script to create the directory and all required
5302     # parent directories.
5303     if test -d $2 ; then
5304       :
5305     else
5306       echo >config.temp
5307       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5308     fi
5309
5310     # Copy the directory, assuming we have tar.
5311     # FIXME: Should we use B in the second tar?  Not all systems support it.
5312     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5313
5314     # It is the responsibility of the user to correctly adjust all
5315     # symlinks.  If somebody can figure out how to handle them correctly
5316     # here, feel free to add the code.
5317
5318     echo $1 > $2/COPIED
5319   fi
5320   shift; shift
5321 done
5322
5323 # Determine a target-dependent exec_prefix that the installed
5324 # gcc will search in.  Keep this list sorted by triplet, with
5325 # the *-*-osname triplets last.
5326 md_exec_prefix=
5327 case "${target}" in
5328   alpha*-*-*vms*)
5329     md_exec_prefix=/gnu/lib/gcc-lib
5330     ;;
5331   i[34567]86-pc-msdosdjgpp*)
5332     md_exec_prefix=/dev/env/DJDIR/bin
5333     ;;
5334   i[34567]86-*-sco3.2v5*)
5335     if test $with_gnu_as = yes; then
5336       md_exec_prefix=/usr/gnu/bin
5337     else
5338       md_exec_prefix=/usr/ccs/bin/elf
5339     fi
5340     ;;
5341
5342   mn10300-*-* | \
5343   powerpc-*-chorusos* | \
5344   powerpc*-*-eabi* | \
5345   powerpc*-*-sysv* | \
5346   powerpc*-*-kaos* | \
5347   s390x-ibm-tpf*)
5348     md_exec_prefix=/usr/ccs/bin
5349     ;;
5350   sparc64-*-elf*)
5351     ;;
5352   v850*-*-*)
5353     md_exec_prefix=/usr/ccs/bin
5354     ;;
5355   xtensa*-*-elf*)
5356     ;;
5357
5358   *-*-beos* | \
5359   *-*-elf* | \
5360   *-*-hpux* | \
5361   *-*-netware* | \
5362   *-*-nto-qnx* | \
5363   *-*-rtems* | \
5364   *-*-solaris2* | \
5365   *-*-sysv[45]* | \
5366   *-*-vxworks* | \
5367   *-wrs-windiss)
5368     md_exec_prefix=/usr/ccs/bin
5369     ;;
5370 esac
5371
5372 extra_arflags_for_target=
5373 extra_nmflags_for_target=
5374 extra_ranlibflags_for_target=
5375 target_makefile_frag=/dev/null
5376 case "${target}" in
5377   mep*-*-*)
5378     target_makefile_frag="config/mt-mep"
5379     ;;
5380   spu-*-*)
5381     target_makefile_frag="config/mt-spu"
5382     ;;
5383   mips*-sde-elf*)
5384     target_makefile_frag="config/mt-sde"
5385     ;;
5386   mipsisa*-*-elfoabi*)
5387     target_makefile_frag="config/mt-mips-elfoabi"
5388     ;;
5389   *-*-netware*)
5390     target_makefile_frag="config/mt-netware"
5391     ;;
5392   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5393     target_makefile_frag="config/mt-gnu"
5394     ;;
5395   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5396     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5397     # commands to handle both 32-bit and 64-bit objects.  These flags are
5398     # harmless if we're using GNU nm or ar.
5399     extra_arflags_for_target=" -X32_64"
5400     extra_nmflags_for_target=" -B -X32_64"
5401     ;;
5402   *-*-darwin*)
5403     # ranlib from Darwin requires the -c flag to look at common symbols.
5404     extra_ranlibflags_for_target=" -c"
5405     ;;
5406   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5407     target_makefile_frag="config/mt-wince"
5408     ;;
5409 esac
5410
5411 alphaieee_frag=/dev/null
5412 case $target in
5413   alpha*-*-*)
5414     # This just makes sure to use the -mieee option to build target libs.
5415     # This should probably be set individually by each library.
5416     alphaieee_frag="config/mt-alphaieee"
5417     ;;
5418 esac
5419
5420 # If --enable-target-optspace always use -Os instead of -O2 to build
5421 # the target libraries, similarly if it is not specified, use -Os
5422 # on selected platforms.
5423 ospace_frag=/dev/null
5424 case "${enable_target_optspace}:${target}" in
5425   yes:*)
5426     ospace_frag="config/mt-ospace"
5427     ;;
5428   :d30v-*)
5429     ospace_frag="config/mt-d30v"
5430     ;;
5431   :m32r-* | :d10v-* | :fr30-*)
5432     ospace_frag="config/mt-ospace"
5433     ;;
5434   no:* | :*)
5435     ;;
5436   *)
5437     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5438     ;;
5439 esac
5440
5441 # Default to using --with-stabs for certain targets.
5442 if test x${with_stabs} = x ; then
5443   case "${target}" in
5444   mips*-*-irix[56]*)
5445     ;;
5446   mips*-*-* | alpha*-*-osf*)
5447     with_stabs=yes;
5448     extra_host_args="${extra_host_args} --with-stabs"
5449     ;;
5450   esac
5451 fi
5452
5453 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5454 # them automatically.
5455 case "${host}" in
5456   hppa*64*-*-hpux11*)
5457     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5458     ;;
5459 esac
5460
5461 # Some systems (e.g., one of the i386-aix systems the gas testers are
5462 # using) don't handle "\$" correctly, so don't use it here.
5463 tooldir='${exec_prefix}'/${target_noncanonical}
5464 build_tooldir=${tooldir}
5465
5466 # Create a .gdbinit file which runs the one in srcdir
5467 # and tells GDB to look there for source files.
5468
5469 if test -r ${srcdir}/.gdbinit ; then
5470   case ${srcdir} in
5471     .) ;;
5472     *) cat > ./.gdbinit <<EOF
5473 # ${NO_EDIT}
5474 dir ${srcdir}
5475 dir .
5476 source ${srcdir}/.gdbinit
5477 EOF
5478     ;;
5479   esac
5480 fi
5481
5482 # Make sure that the compiler is able to generate an executable.  If it
5483 # can't, we are probably in trouble.  We don't care whether we can run the
5484 # executable--we might be using a cross compiler--we only care whether it
5485 # can be created.  At this point the main configure script has set CC.
5486 we_are_ok=no
5487 echo "int main () { return 0; }" > conftest.c
5488 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5489 if test $? = 0 ; then
5490   if test -s conftest || test -s conftest.exe ; then
5491     we_are_ok=yes
5492   fi
5493 fi
5494 case $we_are_ok in
5495   no)
5496     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5497     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5498     rm -f conftest*
5499     exit 1
5500     ;;
5501 esac
5502 rm -f conftest*
5503
5504 # The Solaris /usr/ucb/cc compiler does not appear to work.
5505 case "${host}" in
5506   sparc-sun-solaris2*)
5507       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5508       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5509           could_use=
5510           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5511           if test -d /opt/cygnus/bin ; then
5512               if test "$could_use" = "" ; then
5513                   could_use="/opt/cygnus/bin"
5514               else
5515                   could_use="$could_use or /opt/cygnus/bin"
5516               fi
5517           fi
5518         if test "$could_use" = "" ; then
5519             echo "Warning: compilation may fail because you're using"
5520             echo "/usr/ucb/cc.  You should change your PATH or CC "
5521             echo "variable and rerun configure."
5522         else
5523             echo "Warning: compilation may fail because you're using"
5524             echo "/usr/ucb/cc, when you should use the C compiler from"
5525             echo "$could_use.  You should change your"
5526             echo "PATH or CC variable and rerun configure."
5527         fi
5528       fi
5529   ;;
5530 esac
5531
5532 case "${host}" in
5533   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5534   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5535   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5536 esac
5537
5538 # Record target_configdirs and the configure arguments for target and
5539 # build configuration in Makefile.
5540 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5541 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5542
5543 # Determine whether gdb needs tk/tcl or not.
5544 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5545 # and in that case we want gdb to be built without tk.  Ugh!
5546 # In fact I believe gdb is the *only* package directly dependent on tk,
5547 # so we should be able to put the 'maybe's in unconditionally and
5548 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5549 # 100% sure that that's safe though.
5550
5551 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5552 case "$enable_gdbtk" in
5553   no)
5554     GDB_TK="" ;;
5555   yes)
5556     GDB_TK="${gdb_tk}" ;;
5557   *)
5558     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5559     # distro.  Eventually someone will fix this and move Insight, nee
5560     # gdbtk to a separate directory.
5561     if test -d ${srcdir}/gdb/gdbtk ; then
5562       GDB_TK="${gdb_tk}"
5563     else
5564       GDB_TK=""
5565     fi
5566     ;;
5567 esac
5568 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5569 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5570
5571 # Strip out unwanted targets.
5572
5573 # While at that, we remove Makefiles if we were started for recursive
5574 # configuration, so that the top-level Makefile reconfigures them,
5575 # like we used to do when configure itself was recursive.
5576
5577 # Loop over modules.  $extrasub must be used with care, limiting as
5578 # much as possible the usage of range addresses.  That's because autoconf
5579 # splits the sed script to overcome limits in the number of commands,
5580 # and relying on carefully-timed sed passes may turn out to be very hard
5581 # to maintain later.  In this particular case, you just have to be careful
5582 # not to nest @if/@endif pairs, because configure will not warn you at all.
5583
5584 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5585 if test "${enable_bootstrap+set}" = set; then
5586   enableval="$enable_bootstrap"
5587
5588 else
5589   enable_bootstrap=default
5590 fi;
5591
5592 # Issue errors and warnings for invalid/strange bootstrap combinations.
5593 case "$configdirs" in
5594   *gcc*) have_compiler=yes ;;
5595   *) have_compiler=no ;;
5596 esac
5597
5598 case "$have_compiler:$host:$target:$enable_bootstrap" in
5599   *:*:*:no) ;;
5600
5601   # Default behavior.  Enable bootstrap if we have a compiler
5602   # and we are in a native configuration.
5603   yes:$build:$build:default)
5604     enable_bootstrap=yes ;;
5605
5606   *:*:*:default)
5607     enable_bootstrap=no ;;
5608
5609   # We have a compiler and we are in a native configuration, bootstrap is ok
5610   yes:$build:$build:yes)
5611     ;;
5612
5613   # Other configurations, but we have a compiler.  Assume the user knows
5614   # what he's doing.
5615   yes:*:*:yes)
5616     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5617 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5618     ;;
5619
5620   # No compiler: if they passed --enable-bootstrap explicitly, fail
5621   no:*:*:yes)
5622     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5623 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5624    { (exit 1); exit 1; }; } ;;
5625
5626   # Fail if wrong command line
5627   *)
5628     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5629 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5630    { (exit 1); exit 1; }; }
5631     ;;
5632 esac
5633
5634 # Adjust the toplevel makefile according to whether bootstrap was selected.
5635 case "$enable_bootstrap" in
5636   yes)
5637     bootstrap_suffix=bootstrap ;;
5638   no)
5639     bootstrap_suffix=no-bootstrap ;;
5640 esac
5641
5642 for module in ${build_configdirs} ; do
5643   if test -z "${no_recursion}" \
5644      && test -f ${build_subdir}/${module}/Makefile; then
5645     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5646     rm -f ${build_subdir}/${module}/Makefile
5647   fi
5648   extrasub="$extrasub
5649 /^@if build-$module\$/d
5650 /^@endif build-$module\$/d
5651 /^@if build-$module-$bootstrap_suffix\$/d
5652 /^@endif build-$module-$bootstrap_suffix\$/d"
5653 done
5654 for module in ${configdirs} ; do
5655   if test -z "${no_recursion}"; then
5656     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5657       if test -f ${file}; then
5658         echo 1>&2 "*** removing ${file} to force reconfigure"
5659         rm -f ${file}
5660       fi
5661     done
5662   fi
5663   extrasub="$extrasub
5664 /^@if $module\$/d
5665 /^@endif $module\$/d
5666 /^@if $module-$bootstrap_suffix\$/d
5667 /^@endif $module-$bootstrap_suffix\$/d"
5668 done
5669 for module in ${target_configdirs} ; do
5670   if test -z "${no_recursion}" \
5671      && test -f ${target_subdir}/${module}/Makefile; then
5672     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5673     rm -f ${target_subdir}/${module}/Makefile
5674   fi
5675   extrasub="$extrasub
5676 /^@if target-$module\$/d
5677 /^@endif target-$module\$/d
5678 /^@if target-$module-$bootstrap_suffix\$/d
5679 /^@endif target-$module-$bootstrap_suffix\$/d"
5680 done
5681
5682 extrasub="$extrasub
5683 /^@if /,/^@endif /d"
5684
5685 # Create the serialization dependencies.  This uses a temporary file.
5686
5687 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5688 if test "${enable_serial_configure+set}" = set; then
5689   enableval="$enable_serial_configure"
5690
5691 fi;
5692
5693 case ${enable_serial_configure} in
5694   yes)
5695     enable_serial_build_configure=yes
5696     enable_serial_host_configure=yes
5697     enable_serial_target_configure=yes
5698     ;;
5699 esac
5700
5701 # These force 'configure's to be done one at a time, to avoid problems
5702 # with contention over a shared config.cache.
5703 rm -f serdep.tmp
5704 echo '# serdep.tmp' > serdep.tmp
5705 olditem=
5706 test "x${enable_serial_build_configure}" = xyes &&
5707 for item in ${build_configdirs} ; do
5708   case ${olditem} in
5709     "") ;;
5710     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5711   esac
5712   olditem=${item}
5713 done
5714 olditem=
5715 test "x${enable_serial_host_configure}" = xyes &&
5716 for item in ${configdirs} ; do
5717   case ${olditem} in
5718     "") ;;
5719     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5720   esac
5721   olditem=${item}
5722 done
5723 olditem=
5724 test "x${enable_serial_target_configure}" = xyes &&
5725 for item in ${target_configdirs} ; do
5726   case ${olditem} in
5727     "") ;;
5728     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5729   esac
5730   olditem=${item}
5731 done
5732 serialization_dependencies=serdep.tmp
5733
5734
5735 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5736 # target, nonopt, and variable assignments.  These are the ones we
5737 # might not want to pass down to subconfigures.  Also strip
5738 # program-prefix, program-suffix, and program-transform-name, so that
5739 # we can pass down a consistent program-transform-name.
5740 baseargs=
5741 keep_next=no
5742 skip_next=no
5743 eval "set -- $ac_configure_args"
5744 for ac_arg
5745 do
5746   if test X"$skip_next" = X"yes"; then
5747     skip_next=no
5748     continue
5749   fi
5750   if test X"$keep_next" = X"yes"; then
5751     case $ac_arg in
5752       *\'*)
5753         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5754     esac
5755     baseargs="$baseargs '$ac_arg'"
5756     keep_next=no
5757     continue
5758   fi
5759
5760   # Handle separated arguments.  Based on the logic generated by
5761   # autoconf 2.59.
5762   case $ac_arg in
5763     *=* | --config-cache | -C | -disable-* | --disable-* \
5764       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5765       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5766       | -with-* | --with-* | -without-* | --without-* | --x)
5767       separate_arg=no
5768       ;;
5769     -*)
5770       separate_arg=yes
5771       ;;
5772     *)
5773       separate_arg=no
5774       ;;
5775   esac
5776
5777   case "$ac_arg" in
5778     --no*)
5779       continue
5780       ;;
5781     --c* | \
5782     --sr* | \
5783     --ho* | \
5784     --bu* | \
5785     --t* | \
5786     --program-* | \
5787     -cache_file* | \
5788     -srcdir* | \
5789     -host* | \
5790     -build* | \
5791     -target* | \
5792     -program-prefix* | \
5793     -program-suffix* | \
5794     -program-transform-name* )
5795       skip_next=$separate_arg
5796       continue
5797       ;;
5798     -*)
5799       # An option.  Add it.
5800       case $ac_arg in
5801         *\'*)
5802           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5803       esac
5804       baseargs="$baseargs '$ac_arg'"
5805       keep_next=$separate_arg
5806       ;;
5807     *)
5808       # Either a variable assignment, or a nonopt (triplet).  Don't
5809       # pass it down; let the Makefile handle this.
5810       continue
5811       ;;
5812   esac
5813 done
5814 # Remove the initial space we just introduced and, as these will be
5815 # expanded by make, quote '$'.
5816 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5817
5818 # Add in --program-transform-name, after --program-prefix and
5819 # --program-suffix have been applied to it.  Autoconf has already
5820 # doubled dollar signs and backslashes in program_transform_name; we want
5821 # the backslashes un-doubled, and then the entire thing wrapped in single
5822 # quotes, because this will be expanded first by make and then by the shell.
5823 # Also, because we want to override the logic in subdir configure scripts to
5824 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5825 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5826 ${program_transform_name}
5827 EOF_SED
5828 gcc_transform_name=`cat conftestsed.out`
5829 rm -f conftestsed.out
5830 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5831 if test "$silent" = yes; then
5832   baseargs="$baseargs --silent"
5833 fi
5834
5835 # For the build-side libraries, we just need to pretend we're native,
5836 # and not use the same cache file.  Multilibs are neither needed nor
5837 # desired.
5838 build_configargs="--cache-file=../config.cache ${baseargs}"
5839
5840 # For host modules, accept cache file option, or specification as blank.
5841 case "${cache_file}" in
5842 "") # empty
5843   cache_file_option="" ;;
5844 /* | [A-Za-z]:[\\/]* ) # absolute path
5845   cache_file_option="--cache-file=${cache_file}" ;;
5846 *) # relative path
5847   cache_file_option="--cache-file=../${cache_file}" ;;
5848 esac
5849
5850 # Host dirs don't like to share a cache file either, horribly enough.
5851 # This seems to be due to autoconf 2.5x stupidity.
5852 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5853
5854 target_configargs=${baseargs}
5855
5856 # Passing a --with-cross-host argument lets the target libraries know
5857 # whether they are being built with a cross-compiler or being built
5858 # native.  However, it would be better to use other mechanisms to make the
5859 # sorts of decisions they want to make on this basis.  Please consider
5860 # this option to be deprecated.  FIXME.
5861 if test x${is_cross_compiler} = xyes ; then
5862   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5863 fi
5864
5865 # Default to --enable-multilib.
5866 if test x${enable_multilib} = x ; then
5867   target_configargs="--enable-multilib ${target_configargs}"
5868 fi
5869
5870 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5871 # changed from the earlier setting of with_newlib.
5872 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5873   target_configargs="--with-newlib ${target_configargs}"
5874 fi
5875
5876 # Different target subdirs use different values of certain variables
5877 # (notably CXX).  Worse, multilibs use *lots* of different values.
5878 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5879 # it doesn't automatically accept command-line overrides of them.
5880 # This means it's not safe for target subdirs to share a cache file,
5881 # which is disgusting, but there you have it.  Hopefully this can be
5882 # fixed in future.  It's still worthwhile to use a cache file for each
5883 # directory.  I think.
5884
5885 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5886 # We need to pass --target, as newer autoconf's requires consistency
5887 # for target_alias and gcc doesn't manage it consistently.
5888 target_configargs="--cache-file=./config.cache ${target_configargs}"
5889
5890 FLAGS_FOR_TARGET=
5891 case " $target_configdirs " in
5892  *" newlib "*)
5893   case " $target_configargs " in
5894   *" --with-newlib "*)
5895    case "$target" in
5896    *-cygwin*)
5897      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' ;;
5898    esac
5899
5900    # If we're not building GCC, don't discard standard headers.
5901    if test -d ${srcdir}/gcc; then
5902      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5903
5904      if test "${build}" != "${host}"; then
5905        # On Canadian crosses, CC_FOR_TARGET will have already been set
5906        # by `configure', so we won't have an opportunity to add -Bgcc/
5907        # to it.  This is right: we don't want to search that directory
5908        # for binaries, but we want the header files in there, so add
5909        # them explicitly.
5910        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5911
5912        # Someone might think of using the pre-installed headers on
5913        # Canadian crosses, in case the installed compiler is not fully
5914        # compatible with the compiler being built.  In this case, it
5915        # would be better to flag an error than risking having
5916        # incompatible object files being constructed.  We can't
5917        # guarantee that an error will be flagged, but let's hope the
5918        # compiler will do it, when presented with incompatible header
5919        # files.
5920      fi
5921    fi
5922
5923    case "${target}-${is_cross_compiler}" in
5924    i[3456789]86-*-linux*-no)
5925       # Here host == target, so we don't need to build gcc,
5926       # so we don't want to discard standard headers.
5927       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5928       ;;
5929    *)
5930       # If we're building newlib, use its generic headers last, but search
5931       # for any libc-related directories first (so make it the last -B
5932       # switch).
5933       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5934
5935       # If we're building libgloss, find the startup file, simulator library
5936       # and linker script.
5937       case " $target_configdirs " in
5938         *" libgloss "*)
5939         # Look for startup file, simulator library and maybe linker script.
5940         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
5941         # Look for libnosys.a in case the target needs it.
5942         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5943         # Most targets have the linker script in the source directory.
5944         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
5945         ;;
5946       esac
5947       ;;
5948    esac
5949    ;;
5950   esac
5951   ;;
5952 esac
5953 case "$target" in
5954 *-mingw*)
5955   # Can't be handled as Cygwin above since Mingw does not use newlib.
5956   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' ;;
5957 esac
5958
5959 # Allow the user to override the flags for
5960 # our build compiler if desired.
5961 if test x"${build}" = x"${host}" ; then
5962   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5963   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
5964   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
5965 fi
5966
5967 # On Canadian crosses, we'll be searching the right directories for
5968 # the previously-installed cross compiler, so don't bother to add
5969 # flags for directories within the install tree of the compiler
5970 # being built; programs in there won't even run.
5971 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5972   # Search for pre-installed headers if nothing else fits.
5973   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5974 fi
5975
5976 if test "x${use_gnu_ld}" = x &&
5977    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5978   # Arrange for us to find uninstalled linker scripts.
5979   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5980 fi
5981
5982 # Search for other target-specific linker scripts and such.
5983 case "${target}" in
5984   mep*)
5985     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5986     ;;
5987 esac
5988
5989 # Makefile fragments.
5990 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5991 do
5992   eval fragval=\$$frag
5993   if test $fragval != /dev/null; then
5994     eval $frag=${srcdir}/$fragval
5995   fi
5996 done
5997
5998
5999
6000
6001
6002 # Miscellanea: directories, flags, etc.
6003
6004
6005
6006
6007
6008
6009
6010 # Build module lists & subconfigure args.
6011
6012
6013
6014 # Host module lists & subconfigure args.
6015
6016
6017
6018 # Target module lists & subconfigure args.
6019
6020
6021
6022 # Build tools.
6023
6024
6025
6026
6027
6028
6029
6030
6031
6032
6033
6034
6035
6036
6037
6038
6039
6040 # Generate default definitions for YACC, M4, LEX and other programs that run
6041 # on the build machine.  These are used if the Makefile can't locate these
6042 # programs in objdir.
6043 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6044
6045 for ac_prog in 'bison -y' byacc yacc
6046 do
6047   # Extract the first word of "$ac_prog", so it can be a program name with args.
6048 set dummy $ac_prog; ac_word=$2
6049 echo "$as_me:$LINENO: checking for $ac_word" >&5
6050 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6051 if test "${ac_cv_prog_YACC+set}" = set; then
6052   echo $ECHO_N "(cached) $ECHO_C" >&6
6053 else
6054   if test -n "$YACC"; then
6055   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6056 else
6057 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6058 for as_dir in $PATH
6059 do
6060   IFS=$as_save_IFS
6061   test -z "$as_dir" && as_dir=.
6062   for ac_exec_ext in '' $ac_executable_extensions; do
6063   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6064     ac_cv_prog_YACC="$ac_prog"
6065     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6066     break 2
6067   fi
6068 done
6069 done
6070
6071 fi
6072 fi
6073 YACC=$ac_cv_prog_YACC
6074 if test -n "$YACC"; then
6075   echo "$as_me:$LINENO: result: $YACC" >&5
6076 echo "${ECHO_T}$YACC" >&6
6077 else
6078   echo "$as_me:$LINENO: result: no" >&5
6079 echo "${ECHO_T}no" >&6
6080 fi
6081
6082   test -n "$YACC" && break
6083 done
6084 test -n "$YACC" || YACC="$MISSING bison -y"
6085
6086 case " $build_configdirs " in
6087   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6088   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6089 esac
6090
6091 for ac_prog in bison
6092 do
6093   # Extract the first word of "$ac_prog", so it can be a program name with args.
6094 set dummy $ac_prog; ac_word=$2
6095 echo "$as_me:$LINENO: checking for $ac_word" >&5
6096 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6097 if test "${ac_cv_prog_BISON+set}" = set; then
6098   echo $ECHO_N "(cached) $ECHO_C" >&6
6099 else
6100   if test -n "$BISON"; then
6101   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6102 else
6103 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6104 for as_dir in $PATH
6105 do
6106   IFS=$as_save_IFS
6107   test -z "$as_dir" && as_dir=.
6108   for ac_exec_ext in '' $ac_executable_extensions; do
6109   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6110     ac_cv_prog_BISON="$ac_prog"
6111     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6112     break 2
6113   fi
6114 done
6115 done
6116
6117 fi
6118 fi
6119 BISON=$ac_cv_prog_BISON
6120 if test -n "$BISON"; then
6121   echo "$as_me:$LINENO: result: $BISON" >&5
6122 echo "${ECHO_T}$BISON" >&6
6123 else
6124   echo "$as_me:$LINENO: result: no" >&5
6125 echo "${ECHO_T}no" >&6
6126 fi
6127
6128   test -n "$BISON" && break
6129 done
6130 test -n "$BISON" || BISON="$MISSING bison"
6131
6132 case " $build_configdirs " in
6133   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6134 esac
6135
6136 for ac_prog in gm4 gnum4 m4
6137 do
6138   # Extract the first word of "$ac_prog", so it can be a program name with args.
6139 set dummy $ac_prog; ac_word=$2
6140 echo "$as_me:$LINENO: checking for $ac_word" >&5
6141 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6142 if test "${ac_cv_prog_M4+set}" = set; then
6143   echo $ECHO_N "(cached) $ECHO_C" >&6
6144 else
6145   if test -n "$M4"; then
6146   ac_cv_prog_M4="$M4" # Let the user override the test.
6147 else
6148 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6149 for as_dir in $PATH
6150 do
6151   IFS=$as_save_IFS
6152   test -z "$as_dir" && as_dir=.
6153   for ac_exec_ext in '' $ac_executable_extensions; do
6154   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6155     ac_cv_prog_M4="$ac_prog"
6156     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6157     break 2
6158   fi
6159 done
6160 done
6161
6162 fi
6163 fi
6164 M4=$ac_cv_prog_M4
6165 if test -n "$M4"; then
6166   echo "$as_me:$LINENO: result: $M4" >&5
6167 echo "${ECHO_T}$M4" >&6
6168 else
6169   echo "$as_me:$LINENO: result: no" >&5
6170 echo "${ECHO_T}no" >&6
6171 fi
6172
6173   test -n "$M4" && break
6174 done
6175 test -n "$M4" || M4="$MISSING m4"
6176
6177 case " $build_configdirs " in
6178   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6179 esac
6180
6181 for ac_prog in flex lex
6182 do
6183   # Extract the first word of "$ac_prog", so it can be a program name with args.
6184 set dummy $ac_prog; ac_word=$2
6185 echo "$as_me:$LINENO: checking for $ac_word" >&5
6186 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6187 if test "${ac_cv_prog_LEX+set}" = set; then
6188   echo $ECHO_N "(cached) $ECHO_C" >&6
6189 else
6190   if test -n "$LEX"; then
6191   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6192 else
6193 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6194 for as_dir in $PATH
6195 do
6196   IFS=$as_save_IFS
6197   test -z "$as_dir" && as_dir=.
6198   for ac_exec_ext in '' $ac_executable_extensions; do
6199   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6200     ac_cv_prog_LEX="$ac_prog"
6201     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6202     break 2
6203   fi
6204 done
6205 done
6206
6207 fi
6208 fi
6209 LEX=$ac_cv_prog_LEX
6210 if test -n "$LEX"; then
6211   echo "$as_me:$LINENO: result: $LEX" >&5
6212 echo "${ECHO_T}$LEX" >&6
6213 else
6214   echo "$as_me:$LINENO: result: no" >&5
6215 echo "${ECHO_T}no" >&6
6216 fi
6217
6218   test -n "$LEX" && break
6219 done
6220 test -n "$LEX" || LEX="$MISSING flex"
6221
6222 case " $build_configdirs " in
6223   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6224   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6225 esac
6226
6227 for ac_prog in flex
6228 do
6229   # Extract the first word of "$ac_prog", so it can be a program name with args.
6230 set dummy $ac_prog; ac_word=$2
6231 echo "$as_me:$LINENO: checking for $ac_word" >&5
6232 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6233 if test "${ac_cv_prog_FLEX+set}" = set; then
6234   echo $ECHO_N "(cached) $ECHO_C" >&6
6235 else
6236   if test -n "$FLEX"; then
6237   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6238 else
6239 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6240 for as_dir in $PATH
6241 do
6242   IFS=$as_save_IFS
6243   test -z "$as_dir" && as_dir=.
6244   for ac_exec_ext in '' $ac_executable_extensions; do
6245   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6246     ac_cv_prog_FLEX="$ac_prog"
6247     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6248     break 2
6249   fi
6250 done
6251 done
6252
6253 fi
6254 fi
6255 FLEX=$ac_cv_prog_FLEX
6256 if test -n "$FLEX"; then
6257   echo "$as_me:$LINENO: result: $FLEX" >&5
6258 echo "${ECHO_T}$FLEX" >&6
6259 else
6260   echo "$as_me:$LINENO: result: no" >&5
6261 echo "${ECHO_T}no" >&6
6262 fi
6263
6264   test -n "$FLEX" && break
6265 done
6266 test -n "$FLEX" || FLEX="$MISSING flex"
6267
6268 case " $build_configdirs " in
6269   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6270 esac
6271
6272 for ac_prog in makeinfo
6273 do
6274   # Extract the first word of "$ac_prog", so it can be a program name with args.
6275 set dummy $ac_prog; ac_word=$2
6276 echo "$as_me:$LINENO: checking for $ac_word" >&5
6277 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6278 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6279   echo $ECHO_N "(cached) $ECHO_C" >&6
6280 else
6281   if test -n "$MAKEINFO"; then
6282   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6283 else
6284 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6285 for as_dir in $PATH
6286 do
6287   IFS=$as_save_IFS
6288   test -z "$as_dir" && as_dir=.
6289   for ac_exec_ext in '' $ac_executable_extensions; do
6290   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6291     ac_cv_prog_MAKEINFO="$ac_prog"
6292     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6293     break 2
6294   fi
6295 done
6296 done
6297
6298 fi
6299 fi
6300 MAKEINFO=$ac_cv_prog_MAKEINFO
6301 if test -n "$MAKEINFO"; then
6302   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6303 echo "${ECHO_T}$MAKEINFO" >&6
6304 else
6305   echo "$as_me:$LINENO: result: no" >&5
6306 echo "${ECHO_T}no" >&6
6307 fi
6308
6309   test -n "$MAKEINFO" && break
6310 done
6311 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6312
6313 case " $build_configdirs " in
6314   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6315   *)
6316
6317     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6318     # higher, else we use the "missing" dummy.
6319     if ${MAKEINFO} --version \
6320        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6321       :
6322     else
6323       MAKEINFO="$MISSING makeinfo"
6324     fi
6325     ;;
6326
6327 esac
6328
6329 # FIXME: expect and dejagnu may become build tools?
6330
6331 for ac_prog in expect
6332 do
6333   # Extract the first word of "$ac_prog", so it can be a program name with args.
6334 set dummy $ac_prog; ac_word=$2
6335 echo "$as_me:$LINENO: checking for $ac_word" >&5
6336 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6337 if test "${ac_cv_prog_EXPECT+set}" = set; then
6338   echo $ECHO_N "(cached) $ECHO_C" >&6
6339 else
6340   if test -n "$EXPECT"; then
6341   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6342 else
6343 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6344 for as_dir in $PATH
6345 do
6346   IFS=$as_save_IFS
6347   test -z "$as_dir" && as_dir=.
6348   for ac_exec_ext in '' $ac_executable_extensions; do
6349   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6350     ac_cv_prog_EXPECT="$ac_prog"
6351     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6352     break 2
6353   fi
6354 done
6355 done
6356
6357 fi
6358 fi
6359 EXPECT=$ac_cv_prog_EXPECT
6360 if test -n "$EXPECT"; then
6361   echo "$as_me:$LINENO: result: $EXPECT" >&5
6362 echo "${ECHO_T}$EXPECT" >&6
6363 else
6364   echo "$as_me:$LINENO: result: no" >&5
6365 echo "${ECHO_T}no" >&6
6366 fi
6367
6368   test -n "$EXPECT" && break
6369 done
6370 test -n "$EXPECT" || EXPECT="expect"
6371
6372 case " $configdirs " in
6373   *" expect "*)
6374     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6375     ;;
6376 esac
6377
6378 for ac_prog in runtest
6379 do
6380   # Extract the first word of "$ac_prog", so it can be a program name with args.
6381 set dummy $ac_prog; ac_word=$2
6382 echo "$as_me:$LINENO: checking for $ac_word" >&5
6383 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6384 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6385   echo $ECHO_N "(cached) $ECHO_C" >&6
6386 else
6387   if test -n "$RUNTEST"; then
6388   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6389 else
6390 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6391 for as_dir in $PATH
6392 do
6393   IFS=$as_save_IFS
6394   test -z "$as_dir" && as_dir=.
6395   for ac_exec_ext in '' $ac_executable_extensions; do
6396   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6397     ac_cv_prog_RUNTEST="$ac_prog"
6398     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6399     break 2
6400   fi
6401 done
6402 done
6403
6404 fi
6405 fi
6406 RUNTEST=$ac_cv_prog_RUNTEST
6407 if test -n "$RUNTEST"; then
6408   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6409 echo "${ECHO_T}$RUNTEST" >&6
6410 else
6411   echo "$as_me:$LINENO: result: no" >&5
6412 echo "${ECHO_T}no" >&6
6413 fi
6414
6415   test -n "$RUNTEST" && break
6416 done
6417 test -n "$RUNTEST" || RUNTEST="runtest"
6418
6419 case " $configdirs " in
6420   *" dejagnu "*)
6421     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6422     ;;
6423 esac
6424
6425
6426 # Host tools.
6427 ncn_tool_prefix=
6428 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6429 ncn_target_tool_prefix=
6430 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6431
6432
6433
6434 if test -n "$AR"; then
6435   ac_cv_prog_AR=$AR
6436 elif test -n "$ac_cv_prog_AR"; then
6437   AR=$ac_cv_prog_AR
6438 fi
6439
6440 if test -n "$ac_cv_prog_AR"; then
6441   for ncn_progname in ar; do
6442     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6443 set dummy ${ncn_progname}; ac_word=$2
6444 echo "$as_me:$LINENO: checking for $ac_word" >&5
6445 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6446 if test "${ac_cv_prog_AR+set}" = set; then
6447   echo $ECHO_N "(cached) $ECHO_C" >&6
6448 else
6449   if test -n "$AR"; then
6450   ac_cv_prog_AR="$AR" # Let the user override the test.
6451 else
6452 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6453 for as_dir in $PATH
6454 do
6455   IFS=$as_save_IFS
6456   test -z "$as_dir" && as_dir=.
6457   for ac_exec_ext in '' $ac_executable_extensions; do
6458   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6459     ac_cv_prog_AR="${ncn_progname}"
6460     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6461     break 2
6462   fi
6463 done
6464 done
6465
6466 fi
6467 fi
6468 AR=$ac_cv_prog_AR
6469 if test -n "$AR"; then
6470   echo "$as_me:$LINENO: result: $AR" >&5
6471 echo "${ECHO_T}$AR" >&6
6472 else
6473   echo "$as_me:$LINENO: result: no" >&5
6474 echo "${ECHO_T}no" >&6
6475 fi
6476
6477   done
6478 fi
6479
6480 for ncn_progname in ar; do
6481   if test -n "$ncn_tool_prefix"; then
6482     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6483 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6484 echo "$as_me:$LINENO: checking for $ac_word" >&5
6485 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6486 if test "${ac_cv_prog_AR+set}" = set; then
6487   echo $ECHO_N "(cached) $ECHO_C" >&6
6488 else
6489   if test -n "$AR"; then
6490   ac_cv_prog_AR="$AR" # Let the user override the test.
6491 else
6492 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6493 for as_dir in $PATH
6494 do
6495   IFS=$as_save_IFS
6496   test -z "$as_dir" && as_dir=.
6497   for ac_exec_ext in '' $ac_executable_extensions; do
6498   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6499     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6500     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6501     break 2
6502   fi
6503 done
6504 done
6505
6506 fi
6507 fi
6508 AR=$ac_cv_prog_AR
6509 if test -n "$AR"; then
6510   echo "$as_me:$LINENO: result: $AR" >&5
6511 echo "${ECHO_T}$AR" >&6
6512 else
6513   echo "$as_me:$LINENO: result: no" >&5
6514 echo "${ECHO_T}no" >&6
6515 fi
6516
6517   fi
6518   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6519     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6520 set dummy ${ncn_progname}; ac_word=$2
6521 echo "$as_me:$LINENO: checking for $ac_word" >&5
6522 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6523 if test "${ac_cv_prog_AR+set}" = set; then
6524   echo $ECHO_N "(cached) $ECHO_C" >&6
6525 else
6526   if test -n "$AR"; then
6527   ac_cv_prog_AR="$AR" # Let the user override the test.
6528 else
6529 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6530 for as_dir in $PATH
6531 do
6532   IFS=$as_save_IFS
6533   test -z "$as_dir" && as_dir=.
6534   for ac_exec_ext in '' $ac_executable_extensions; do
6535   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6536     ac_cv_prog_AR="${ncn_progname}"
6537     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6538     break 2
6539   fi
6540 done
6541 done
6542
6543 fi
6544 fi
6545 AR=$ac_cv_prog_AR
6546 if test -n "$AR"; then
6547   echo "$as_me:$LINENO: result: $AR" >&5
6548 echo "${ECHO_T}$AR" >&6
6549 else
6550   echo "$as_me:$LINENO: result: no" >&5
6551 echo "${ECHO_T}no" >&6
6552 fi
6553
6554   fi
6555   test -n "$ac_cv_prog_AR" && break
6556 done
6557
6558 if test -z "$ac_cv_prog_AR" ; then
6559   set dummy ar
6560   if test $build = $host ; then
6561     AR="$2"
6562   else
6563     AR="${ncn_tool_prefix}$2"
6564   fi
6565 fi
6566
6567
6568
6569 if test -n "$AS"; then
6570   ac_cv_prog_AS=$AS
6571 elif test -n "$ac_cv_prog_AS"; then
6572   AS=$ac_cv_prog_AS
6573 fi
6574
6575 if test -n "$ac_cv_prog_AS"; then
6576   for ncn_progname in as; do
6577     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6578 set dummy ${ncn_progname}; ac_word=$2
6579 echo "$as_me:$LINENO: checking for $ac_word" >&5
6580 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6581 if test "${ac_cv_prog_AS+set}" = set; then
6582   echo $ECHO_N "(cached) $ECHO_C" >&6
6583 else
6584   if test -n "$AS"; then
6585   ac_cv_prog_AS="$AS" # Let the user override the test.
6586 else
6587 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6588 for as_dir in $PATH
6589 do
6590   IFS=$as_save_IFS
6591   test -z "$as_dir" && as_dir=.
6592   for ac_exec_ext in '' $ac_executable_extensions; do
6593   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6594     ac_cv_prog_AS="${ncn_progname}"
6595     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6596     break 2
6597   fi
6598 done
6599 done
6600
6601 fi
6602 fi
6603 AS=$ac_cv_prog_AS
6604 if test -n "$AS"; then
6605   echo "$as_me:$LINENO: result: $AS" >&5
6606 echo "${ECHO_T}$AS" >&6
6607 else
6608   echo "$as_me:$LINENO: result: no" >&5
6609 echo "${ECHO_T}no" >&6
6610 fi
6611
6612   done
6613 fi
6614
6615 for ncn_progname in as; do
6616   if test -n "$ncn_tool_prefix"; then
6617     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6618 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6619 echo "$as_me:$LINENO: checking for $ac_word" >&5
6620 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6621 if test "${ac_cv_prog_AS+set}" = set; then
6622   echo $ECHO_N "(cached) $ECHO_C" >&6
6623 else
6624   if test -n "$AS"; then
6625   ac_cv_prog_AS="$AS" # Let the user override the test.
6626 else
6627 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6628 for as_dir in $PATH
6629 do
6630   IFS=$as_save_IFS
6631   test -z "$as_dir" && as_dir=.
6632   for ac_exec_ext in '' $ac_executable_extensions; do
6633   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6634     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6635     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6636     break 2
6637   fi
6638 done
6639 done
6640
6641 fi
6642 fi
6643 AS=$ac_cv_prog_AS
6644 if test -n "$AS"; then
6645   echo "$as_me:$LINENO: result: $AS" >&5
6646 echo "${ECHO_T}$AS" >&6
6647 else
6648   echo "$as_me:$LINENO: result: no" >&5
6649 echo "${ECHO_T}no" >&6
6650 fi
6651
6652   fi
6653   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6654     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6655 set dummy ${ncn_progname}; ac_word=$2
6656 echo "$as_me:$LINENO: checking for $ac_word" >&5
6657 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6658 if test "${ac_cv_prog_AS+set}" = set; then
6659   echo $ECHO_N "(cached) $ECHO_C" >&6
6660 else
6661   if test -n "$AS"; then
6662   ac_cv_prog_AS="$AS" # Let the user override the test.
6663 else
6664 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6665 for as_dir in $PATH
6666 do
6667   IFS=$as_save_IFS
6668   test -z "$as_dir" && as_dir=.
6669   for ac_exec_ext in '' $ac_executable_extensions; do
6670   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6671     ac_cv_prog_AS="${ncn_progname}"
6672     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6673     break 2
6674   fi
6675 done
6676 done
6677
6678 fi
6679 fi
6680 AS=$ac_cv_prog_AS
6681 if test -n "$AS"; then
6682   echo "$as_me:$LINENO: result: $AS" >&5
6683 echo "${ECHO_T}$AS" >&6
6684 else
6685   echo "$as_me:$LINENO: result: no" >&5
6686 echo "${ECHO_T}no" >&6
6687 fi
6688
6689   fi
6690   test -n "$ac_cv_prog_AS" && break
6691 done
6692
6693 if test -z "$ac_cv_prog_AS" ; then
6694   set dummy as
6695   if test $build = $host ; then
6696     AS="$2"
6697   else
6698     AS="${ncn_tool_prefix}$2"
6699   fi
6700 fi
6701
6702
6703
6704 if test -n "$DLLTOOL"; then
6705   ac_cv_prog_DLLTOOL=$DLLTOOL
6706 elif test -n "$ac_cv_prog_DLLTOOL"; then
6707   DLLTOOL=$ac_cv_prog_DLLTOOL
6708 fi
6709
6710 if test -n "$ac_cv_prog_DLLTOOL"; then
6711   for ncn_progname in dlltool; do
6712     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6713 set dummy ${ncn_progname}; ac_word=$2
6714 echo "$as_me:$LINENO: checking for $ac_word" >&5
6715 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6716 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6717   echo $ECHO_N "(cached) $ECHO_C" >&6
6718 else
6719   if test -n "$DLLTOOL"; then
6720   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6721 else
6722 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6723 for as_dir in $PATH
6724 do
6725   IFS=$as_save_IFS
6726   test -z "$as_dir" && as_dir=.
6727   for ac_exec_ext in '' $ac_executable_extensions; do
6728   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6729     ac_cv_prog_DLLTOOL="${ncn_progname}"
6730     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6731     break 2
6732   fi
6733 done
6734 done
6735
6736 fi
6737 fi
6738 DLLTOOL=$ac_cv_prog_DLLTOOL
6739 if test -n "$DLLTOOL"; then
6740   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6741 echo "${ECHO_T}$DLLTOOL" >&6
6742 else
6743   echo "$as_me:$LINENO: result: no" >&5
6744 echo "${ECHO_T}no" >&6
6745 fi
6746
6747   done
6748 fi
6749
6750 for ncn_progname in dlltool; do
6751   if test -n "$ncn_tool_prefix"; then
6752     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6753 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6754 echo "$as_me:$LINENO: checking for $ac_word" >&5
6755 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6756 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6757   echo $ECHO_N "(cached) $ECHO_C" >&6
6758 else
6759   if test -n "$DLLTOOL"; then
6760   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6761 else
6762 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6763 for as_dir in $PATH
6764 do
6765   IFS=$as_save_IFS
6766   test -z "$as_dir" && as_dir=.
6767   for ac_exec_ext in '' $ac_executable_extensions; do
6768   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6769     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6770     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6771     break 2
6772   fi
6773 done
6774 done
6775
6776 fi
6777 fi
6778 DLLTOOL=$ac_cv_prog_DLLTOOL
6779 if test -n "$DLLTOOL"; then
6780   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6781 echo "${ECHO_T}$DLLTOOL" >&6
6782 else
6783   echo "$as_me:$LINENO: result: no" >&5
6784 echo "${ECHO_T}no" >&6
6785 fi
6786
6787   fi
6788   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6789     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6790 set dummy ${ncn_progname}; ac_word=$2
6791 echo "$as_me:$LINENO: checking for $ac_word" >&5
6792 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6793 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6794   echo $ECHO_N "(cached) $ECHO_C" >&6
6795 else
6796   if test -n "$DLLTOOL"; then
6797   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6798 else
6799 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6800 for as_dir in $PATH
6801 do
6802   IFS=$as_save_IFS
6803   test -z "$as_dir" && as_dir=.
6804   for ac_exec_ext in '' $ac_executable_extensions; do
6805   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6806     ac_cv_prog_DLLTOOL="${ncn_progname}"
6807     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6808     break 2
6809   fi
6810 done
6811 done
6812
6813 fi
6814 fi
6815 DLLTOOL=$ac_cv_prog_DLLTOOL
6816 if test -n "$DLLTOOL"; then
6817   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6818 echo "${ECHO_T}$DLLTOOL" >&6
6819 else
6820   echo "$as_me:$LINENO: result: no" >&5
6821 echo "${ECHO_T}no" >&6
6822 fi
6823
6824   fi
6825   test -n "$ac_cv_prog_DLLTOOL" && break
6826 done
6827
6828 if test -z "$ac_cv_prog_DLLTOOL" ; then
6829   set dummy dlltool
6830   if test $build = $host ; then
6831     DLLTOOL="$2"
6832   else
6833     DLLTOOL="${ncn_tool_prefix}$2"
6834   fi
6835 fi
6836
6837
6838
6839 if test -n "$LD"; then
6840   ac_cv_prog_LD=$LD
6841 elif test -n "$ac_cv_prog_LD"; then
6842   LD=$ac_cv_prog_LD
6843 fi
6844
6845 if test -n "$ac_cv_prog_LD"; then
6846   for ncn_progname in ld; do
6847     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6848 set dummy ${ncn_progname}; ac_word=$2
6849 echo "$as_me:$LINENO: checking for $ac_word" >&5
6850 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6851 if test "${ac_cv_prog_LD+set}" = set; then
6852   echo $ECHO_N "(cached) $ECHO_C" >&6
6853 else
6854   if test -n "$LD"; then
6855   ac_cv_prog_LD="$LD" # Let the user override the test.
6856 else
6857 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6858 for as_dir in $PATH
6859 do
6860   IFS=$as_save_IFS
6861   test -z "$as_dir" && as_dir=.
6862   for ac_exec_ext in '' $ac_executable_extensions; do
6863   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6864     ac_cv_prog_LD="${ncn_progname}"
6865     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6866     break 2
6867   fi
6868 done
6869 done
6870
6871 fi
6872 fi
6873 LD=$ac_cv_prog_LD
6874 if test -n "$LD"; then
6875   echo "$as_me:$LINENO: result: $LD" >&5
6876 echo "${ECHO_T}$LD" >&6
6877 else
6878   echo "$as_me:$LINENO: result: no" >&5
6879 echo "${ECHO_T}no" >&6
6880 fi
6881
6882   done
6883 fi
6884
6885 for ncn_progname in ld; do
6886   if test -n "$ncn_tool_prefix"; then
6887     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6888 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6889 echo "$as_me:$LINENO: checking for $ac_word" >&5
6890 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6891 if test "${ac_cv_prog_LD+set}" = set; then
6892   echo $ECHO_N "(cached) $ECHO_C" >&6
6893 else
6894   if test -n "$LD"; then
6895   ac_cv_prog_LD="$LD" # Let the user override the test.
6896 else
6897 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6898 for as_dir in $PATH
6899 do
6900   IFS=$as_save_IFS
6901   test -z "$as_dir" && as_dir=.
6902   for ac_exec_ext in '' $ac_executable_extensions; do
6903   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6904     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6905     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6906     break 2
6907   fi
6908 done
6909 done
6910
6911 fi
6912 fi
6913 LD=$ac_cv_prog_LD
6914 if test -n "$LD"; then
6915   echo "$as_me:$LINENO: result: $LD" >&5
6916 echo "${ECHO_T}$LD" >&6
6917 else
6918   echo "$as_me:$LINENO: result: no" >&5
6919 echo "${ECHO_T}no" >&6
6920 fi
6921
6922   fi
6923   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6924     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6925 set dummy ${ncn_progname}; ac_word=$2
6926 echo "$as_me:$LINENO: checking for $ac_word" >&5
6927 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6928 if test "${ac_cv_prog_LD+set}" = set; then
6929   echo $ECHO_N "(cached) $ECHO_C" >&6
6930 else
6931   if test -n "$LD"; then
6932   ac_cv_prog_LD="$LD" # Let the user override the test.
6933 else
6934 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6935 for as_dir in $PATH
6936 do
6937   IFS=$as_save_IFS
6938   test -z "$as_dir" && as_dir=.
6939   for ac_exec_ext in '' $ac_executable_extensions; do
6940   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6941     ac_cv_prog_LD="${ncn_progname}"
6942     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6943     break 2
6944   fi
6945 done
6946 done
6947
6948 fi
6949 fi
6950 LD=$ac_cv_prog_LD
6951 if test -n "$LD"; then
6952   echo "$as_me:$LINENO: result: $LD" >&5
6953 echo "${ECHO_T}$LD" >&6
6954 else
6955   echo "$as_me:$LINENO: result: no" >&5
6956 echo "${ECHO_T}no" >&6
6957 fi
6958
6959   fi
6960   test -n "$ac_cv_prog_LD" && break
6961 done
6962
6963 if test -z "$ac_cv_prog_LD" ; then
6964   set dummy ld
6965   if test $build = $host ; then
6966     LD="$2"
6967   else
6968     LD="${ncn_tool_prefix}$2"
6969   fi
6970 fi
6971
6972
6973
6974 if test -n "$LIPO"; then
6975   ac_cv_prog_LIPO=$LIPO
6976 elif test -n "$ac_cv_prog_LIPO"; then
6977   LIPO=$ac_cv_prog_LIPO
6978 fi
6979
6980 if test -n "$ac_cv_prog_LIPO"; then
6981   for ncn_progname in lipo; do
6982     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6983 set dummy ${ncn_progname}; ac_word=$2
6984 echo "$as_me:$LINENO: checking for $ac_word" >&5
6985 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6986 if test "${ac_cv_prog_LIPO+set}" = set; then
6987   echo $ECHO_N "(cached) $ECHO_C" >&6
6988 else
6989   if test -n "$LIPO"; then
6990   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6991 else
6992 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6993 for as_dir in $PATH
6994 do
6995   IFS=$as_save_IFS
6996   test -z "$as_dir" && as_dir=.
6997   for ac_exec_ext in '' $ac_executable_extensions; do
6998   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6999     ac_cv_prog_LIPO="${ncn_progname}"
7000     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7001     break 2
7002   fi
7003 done
7004 done
7005
7006 fi
7007 fi
7008 LIPO=$ac_cv_prog_LIPO
7009 if test -n "$LIPO"; then
7010   echo "$as_me:$LINENO: result: $LIPO" >&5
7011 echo "${ECHO_T}$LIPO" >&6
7012 else
7013   echo "$as_me:$LINENO: result: no" >&5
7014 echo "${ECHO_T}no" >&6
7015 fi
7016
7017   done
7018 fi
7019
7020 for ncn_progname in lipo; do
7021   if test -n "$ncn_tool_prefix"; then
7022     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7023 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7024 echo "$as_me:$LINENO: checking for $ac_word" >&5
7025 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7026 if test "${ac_cv_prog_LIPO+set}" = set; then
7027   echo $ECHO_N "(cached) $ECHO_C" >&6
7028 else
7029   if test -n "$LIPO"; then
7030   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7031 else
7032 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7033 for as_dir in $PATH
7034 do
7035   IFS=$as_save_IFS
7036   test -z "$as_dir" && as_dir=.
7037   for ac_exec_ext in '' $ac_executable_extensions; do
7038   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7039     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7040     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7041     break 2
7042   fi
7043 done
7044 done
7045
7046 fi
7047 fi
7048 LIPO=$ac_cv_prog_LIPO
7049 if test -n "$LIPO"; then
7050   echo "$as_me:$LINENO: result: $LIPO" >&5
7051 echo "${ECHO_T}$LIPO" >&6
7052 else
7053   echo "$as_me:$LINENO: result: no" >&5
7054 echo "${ECHO_T}no" >&6
7055 fi
7056
7057   fi
7058   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7059     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7060 set dummy ${ncn_progname}; ac_word=$2
7061 echo "$as_me:$LINENO: checking for $ac_word" >&5
7062 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7063 if test "${ac_cv_prog_LIPO+set}" = set; then
7064   echo $ECHO_N "(cached) $ECHO_C" >&6
7065 else
7066   if test -n "$LIPO"; then
7067   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7068 else
7069 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7070 for as_dir in $PATH
7071 do
7072   IFS=$as_save_IFS
7073   test -z "$as_dir" && as_dir=.
7074   for ac_exec_ext in '' $ac_executable_extensions; do
7075   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7076     ac_cv_prog_LIPO="${ncn_progname}"
7077     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7078     break 2
7079   fi
7080 done
7081 done
7082
7083 fi
7084 fi
7085 LIPO=$ac_cv_prog_LIPO
7086 if test -n "$LIPO"; then
7087   echo "$as_me:$LINENO: result: $LIPO" >&5
7088 echo "${ECHO_T}$LIPO" >&6
7089 else
7090   echo "$as_me:$LINENO: result: no" >&5
7091 echo "${ECHO_T}no" >&6
7092 fi
7093
7094   fi
7095   test -n "$ac_cv_prog_LIPO" && break
7096 done
7097
7098 if test -z "$ac_cv_prog_LIPO" ; then
7099   set dummy lipo
7100   if test $build = $host ; then
7101     LIPO="$2"
7102   else
7103     LIPO="${ncn_tool_prefix}$2"
7104   fi
7105 fi
7106
7107
7108
7109 if test -n "$NM"; then
7110   ac_cv_prog_NM=$NM
7111 elif test -n "$ac_cv_prog_NM"; then
7112   NM=$ac_cv_prog_NM
7113 fi
7114
7115 if test -n "$ac_cv_prog_NM"; then
7116   for ncn_progname in nm; do
7117     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7118 set dummy ${ncn_progname}; ac_word=$2
7119 echo "$as_me:$LINENO: checking for $ac_word" >&5
7120 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7121 if test "${ac_cv_prog_NM+set}" = set; then
7122   echo $ECHO_N "(cached) $ECHO_C" >&6
7123 else
7124   if test -n "$NM"; then
7125   ac_cv_prog_NM="$NM" # Let the user override the test.
7126 else
7127 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7128 for as_dir in $PATH
7129 do
7130   IFS=$as_save_IFS
7131   test -z "$as_dir" && as_dir=.
7132   for ac_exec_ext in '' $ac_executable_extensions; do
7133   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7134     ac_cv_prog_NM="${ncn_progname}"
7135     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7136     break 2
7137   fi
7138 done
7139 done
7140
7141 fi
7142 fi
7143 NM=$ac_cv_prog_NM
7144 if test -n "$NM"; then
7145   echo "$as_me:$LINENO: result: $NM" >&5
7146 echo "${ECHO_T}$NM" >&6
7147 else
7148   echo "$as_me:$LINENO: result: no" >&5
7149 echo "${ECHO_T}no" >&6
7150 fi
7151
7152   done
7153 fi
7154
7155 for ncn_progname in nm; do
7156   if test -n "$ncn_tool_prefix"; then
7157     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7158 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7159 echo "$as_me:$LINENO: checking for $ac_word" >&5
7160 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7161 if test "${ac_cv_prog_NM+set}" = set; then
7162   echo $ECHO_N "(cached) $ECHO_C" >&6
7163 else
7164   if test -n "$NM"; then
7165   ac_cv_prog_NM="$NM" # Let the user override the test.
7166 else
7167 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7168 for as_dir in $PATH
7169 do
7170   IFS=$as_save_IFS
7171   test -z "$as_dir" && as_dir=.
7172   for ac_exec_ext in '' $ac_executable_extensions; do
7173   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7174     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7175     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7176     break 2
7177   fi
7178 done
7179 done
7180
7181 fi
7182 fi
7183 NM=$ac_cv_prog_NM
7184 if test -n "$NM"; then
7185   echo "$as_me:$LINENO: result: $NM" >&5
7186 echo "${ECHO_T}$NM" >&6
7187 else
7188   echo "$as_me:$LINENO: result: no" >&5
7189 echo "${ECHO_T}no" >&6
7190 fi
7191
7192   fi
7193   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7194     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7195 set dummy ${ncn_progname}; ac_word=$2
7196 echo "$as_me:$LINENO: checking for $ac_word" >&5
7197 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7198 if test "${ac_cv_prog_NM+set}" = set; then
7199   echo $ECHO_N "(cached) $ECHO_C" >&6
7200 else
7201   if test -n "$NM"; then
7202   ac_cv_prog_NM="$NM" # Let the user override the test.
7203 else
7204 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7205 for as_dir in $PATH
7206 do
7207   IFS=$as_save_IFS
7208   test -z "$as_dir" && as_dir=.
7209   for ac_exec_ext in '' $ac_executable_extensions; do
7210   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7211     ac_cv_prog_NM="${ncn_progname}"
7212     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7213     break 2
7214   fi
7215 done
7216 done
7217
7218 fi
7219 fi
7220 NM=$ac_cv_prog_NM
7221 if test -n "$NM"; then
7222   echo "$as_me:$LINENO: result: $NM" >&5
7223 echo "${ECHO_T}$NM" >&6
7224 else
7225   echo "$as_me:$LINENO: result: no" >&5
7226 echo "${ECHO_T}no" >&6
7227 fi
7228
7229   fi
7230   test -n "$ac_cv_prog_NM" && break
7231 done
7232
7233 if test -z "$ac_cv_prog_NM" ; then
7234   set dummy nm
7235   if test $build = $host ; then
7236     NM="$2"
7237   else
7238     NM="${ncn_tool_prefix}$2"
7239   fi
7240 fi
7241
7242
7243
7244 if test -n "$RANLIB"; then
7245   ac_cv_prog_RANLIB=$RANLIB
7246 elif test -n "$ac_cv_prog_RANLIB"; then
7247   RANLIB=$ac_cv_prog_RANLIB
7248 fi
7249
7250 if test -n "$ac_cv_prog_RANLIB"; then
7251   for ncn_progname in ranlib; do
7252     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7253 set dummy ${ncn_progname}; ac_word=$2
7254 echo "$as_me:$LINENO: checking for $ac_word" >&5
7255 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7256 if test "${ac_cv_prog_RANLIB+set}" = set; then
7257   echo $ECHO_N "(cached) $ECHO_C" >&6
7258 else
7259   if test -n "$RANLIB"; then
7260   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7261 else
7262 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7263 for as_dir in $PATH
7264 do
7265   IFS=$as_save_IFS
7266   test -z "$as_dir" && as_dir=.
7267   for ac_exec_ext in '' $ac_executable_extensions; do
7268   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7269     ac_cv_prog_RANLIB="${ncn_progname}"
7270     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7271     break 2
7272   fi
7273 done
7274 done
7275
7276 fi
7277 fi
7278 RANLIB=$ac_cv_prog_RANLIB
7279 if test -n "$RANLIB"; then
7280   echo "$as_me:$LINENO: result: $RANLIB" >&5
7281 echo "${ECHO_T}$RANLIB" >&6
7282 else
7283   echo "$as_me:$LINENO: result: no" >&5
7284 echo "${ECHO_T}no" >&6
7285 fi
7286
7287   done
7288 fi
7289
7290 for ncn_progname in ranlib; do
7291   if test -n "$ncn_tool_prefix"; then
7292     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7293 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7294 echo "$as_me:$LINENO: checking for $ac_word" >&5
7295 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7296 if test "${ac_cv_prog_RANLIB+set}" = set; then
7297   echo $ECHO_N "(cached) $ECHO_C" >&6
7298 else
7299   if test -n "$RANLIB"; then
7300   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7301 else
7302 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7303 for as_dir in $PATH
7304 do
7305   IFS=$as_save_IFS
7306   test -z "$as_dir" && as_dir=.
7307   for ac_exec_ext in '' $ac_executable_extensions; do
7308   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7309     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7310     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7311     break 2
7312   fi
7313 done
7314 done
7315
7316 fi
7317 fi
7318 RANLIB=$ac_cv_prog_RANLIB
7319 if test -n "$RANLIB"; then
7320   echo "$as_me:$LINENO: result: $RANLIB" >&5
7321 echo "${ECHO_T}$RANLIB" >&6
7322 else
7323   echo "$as_me:$LINENO: result: no" >&5
7324 echo "${ECHO_T}no" >&6
7325 fi
7326
7327   fi
7328   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7329     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7330 set dummy ${ncn_progname}; ac_word=$2
7331 echo "$as_me:$LINENO: checking for $ac_word" >&5
7332 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7333 if test "${ac_cv_prog_RANLIB+set}" = set; then
7334   echo $ECHO_N "(cached) $ECHO_C" >&6
7335 else
7336   if test -n "$RANLIB"; then
7337   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7338 else
7339 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7340 for as_dir in $PATH
7341 do
7342   IFS=$as_save_IFS
7343   test -z "$as_dir" && as_dir=.
7344   for ac_exec_ext in '' $ac_executable_extensions; do
7345   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7346     ac_cv_prog_RANLIB="${ncn_progname}"
7347     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7348     break 2
7349   fi
7350 done
7351 done
7352
7353 fi
7354 fi
7355 RANLIB=$ac_cv_prog_RANLIB
7356 if test -n "$RANLIB"; then
7357   echo "$as_me:$LINENO: result: $RANLIB" >&5
7358 echo "${ECHO_T}$RANLIB" >&6
7359 else
7360   echo "$as_me:$LINENO: result: no" >&5
7361 echo "${ECHO_T}no" >&6
7362 fi
7363
7364   fi
7365   test -n "$ac_cv_prog_RANLIB" && break
7366 done
7367
7368 if test -z "$ac_cv_prog_RANLIB" ; then
7369   RANLIB=":"
7370 fi
7371
7372
7373
7374 if test -n "$STRIP"; then
7375   ac_cv_prog_STRIP=$STRIP
7376 elif test -n "$ac_cv_prog_STRIP"; then
7377   STRIP=$ac_cv_prog_STRIP
7378 fi
7379
7380 if test -n "$ac_cv_prog_STRIP"; then
7381   for ncn_progname in strip; do
7382     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7383 set dummy ${ncn_progname}; ac_word=$2
7384 echo "$as_me:$LINENO: checking for $ac_word" >&5
7385 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7386 if test "${ac_cv_prog_STRIP+set}" = set; then
7387   echo $ECHO_N "(cached) $ECHO_C" >&6
7388 else
7389   if test -n "$STRIP"; then
7390   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7391 else
7392 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7393 for as_dir in $PATH
7394 do
7395   IFS=$as_save_IFS
7396   test -z "$as_dir" && as_dir=.
7397   for ac_exec_ext in '' $ac_executable_extensions; do
7398   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7399     ac_cv_prog_STRIP="${ncn_progname}"
7400     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7401     break 2
7402   fi
7403 done
7404 done
7405
7406 fi
7407 fi
7408 STRIP=$ac_cv_prog_STRIP
7409 if test -n "$STRIP"; then
7410   echo "$as_me:$LINENO: result: $STRIP" >&5
7411 echo "${ECHO_T}$STRIP" >&6
7412 else
7413   echo "$as_me:$LINENO: result: no" >&5
7414 echo "${ECHO_T}no" >&6
7415 fi
7416
7417   done
7418 fi
7419
7420 for ncn_progname in strip; do
7421   if test -n "$ncn_tool_prefix"; then
7422     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7423 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7424 echo "$as_me:$LINENO: checking for $ac_word" >&5
7425 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7426 if test "${ac_cv_prog_STRIP+set}" = set; then
7427   echo $ECHO_N "(cached) $ECHO_C" >&6
7428 else
7429   if test -n "$STRIP"; then
7430   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7431 else
7432 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7433 for as_dir in $PATH
7434 do
7435   IFS=$as_save_IFS
7436   test -z "$as_dir" && as_dir=.
7437   for ac_exec_ext in '' $ac_executable_extensions; do
7438   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7439     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7440     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7441     break 2
7442   fi
7443 done
7444 done
7445
7446 fi
7447 fi
7448 STRIP=$ac_cv_prog_STRIP
7449 if test -n "$STRIP"; then
7450   echo "$as_me:$LINENO: result: $STRIP" >&5
7451 echo "${ECHO_T}$STRIP" >&6
7452 else
7453   echo "$as_me:$LINENO: result: no" >&5
7454 echo "${ECHO_T}no" >&6
7455 fi
7456
7457   fi
7458   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7459     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7460 set dummy ${ncn_progname}; ac_word=$2
7461 echo "$as_me:$LINENO: checking for $ac_word" >&5
7462 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7463 if test "${ac_cv_prog_STRIP+set}" = set; then
7464   echo $ECHO_N "(cached) $ECHO_C" >&6
7465 else
7466   if test -n "$STRIP"; then
7467   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7468 else
7469 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7470 for as_dir in $PATH
7471 do
7472   IFS=$as_save_IFS
7473   test -z "$as_dir" && as_dir=.
7474   for ac_exec_ext in '' $ac_executable_extensions; do
7475   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7476     ac_cv_prog_STRIP="${ncn_progname}"
7477     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7478     break 2
7479   fi
7480 done
7481 done
7482
7483 fi
7484 fi
7485 STRIP=$ac_cv_prog_STRIP
7486 if test -n "$STRIP"; then
7487   echo "$as_me:$LINENO: result: $STRIP" >&5
7488 echo "${ECHO_T}$STRIP" >&6
7489 else
7490   echo "$as_me:$LINENO: result: no" >&5
7491 echo "${ECHO_T}no" >&6
7492 fi
7493
7494   fi
7495   test -n "$ac_cv_prog_STRIP" && break
7496 done
7497
7498 if test -z "$ac_cv_prog_STRIP" ; then
7499   STRIP=":"
7500 fi
7501
7502
7503
7504 if test -n "$WINDRES"; then
7505   ac_cv_prog_WINDRES=$WINDRES
7506 elif test -n "$ac_cv_prog_WINDRES"; then
7507   WINDRES=$ac_cv_prog_WINDRES
7508 fi
7509
7510 if test -n "$ac_cv_prog_WINDRES"; then
7511   for ncn_progname in windres; do
7512     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7513 set dummy ${ncn_progname}; ac_word=$2
7514 echo "$as_me:$LINENO: checking for $ac_word" >&5
7515 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7516 if test "${ac_cv_prog_WINDRES+set}" = set; then
7517   echo $ECHO_N "(cached) $ECHO_C" >&6
7518 else
7519   if test -n "$WINDRES"; then
7520   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7521 else
7522 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7523 for as_dir in $PATH
7524 do
7525   IFS=$as_save_IFS
7526   test -z "$as_dir" && as_dir=.
7527   for ac_exec_ext in '' $ac_executable_extensions; do
7528   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7529     ac_cv_prog_WINDRES="${ncn_progname}"
7530     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7531     break 2
7532   fi
7533 done
7534 done
7535
7536 fi
7537 fi
7538 WINDRES=$ac_cv_prog_WINDRES
7539 if test -n "$WINDRES"; then
7540   echo "$as_me:$LINENO: result: $WINDRES" >&5
7541 echo "${ECHO_T}$WINDRES" >&6
7542 else
7543   echo "$as_me:$LINENO: result: no" >&5
7544 echo "${ECHO_T}no" >&6
7545 fi
7546
7547   done
7548 fi
7549
7550 for ncn_progname in windres; do
7551   if test -n "$ncn_tool_prefix"; then
7552     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7553 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7554 echo "$as_me:$LINENO: checking for $ac_word" >&5
7555 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7556 if test "${ac_cv_prog_WINDRES+set}" = set; then
7557   echo $ECHO_N "(cached) $ECHO_C" >&6
7558 else
7559   if test -n "$WINDRES"; then
7560   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7561 else
7562 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7563 for as_dir in $PATH
7564 do
7565   IFS=$as_save_IFS
7566   test -z "$as_dir" && as_dir=.
7567   for ac_exec_ext in '' $ac_executable_extensions; do
7568   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7569     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7570     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7571     break 2
7572   fi
7573 done
7574 done
7575
7576 fi
7577 fi
7578 WINDRES=$ac_cv_prog_WINDRES
7579 if test -n "$WINDRES"; then
7580   echo "$as_me:$LINENO: result: $WINDRES" >&5
7581 echo "${ECHO_T}$WINDRES" >&6
7582 else
7583   echo "$as_me:$LINENO: result: no" >&5
7584 echo "${ECHO_T}no" >&6
7585 fi
7586
7587   fi
7588   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7589     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7590 set dummy ${ncn_progname}; ac_word=$2
7591 echo "$as_me:$LINENO: checking for $ac_word" >&5
7592 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7593 if test "${ac_cv_prog_WINDRES+set}" = set; then
7594   echo $ECHO_N "(cached) $ECHO_C" >&6
7595 else
7596   if test -n "$WINDRES"; then
7597   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7598 else
7599 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7600 for as_dir in $PATH
7601 do
7602   IFS=$as_save_IFS
7603   test -z "$as_dir" && as_dir=.
7604   for ac_exec_ext in '' $ac_executable_extensions; do
7605   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7606     ac_cv_prog_WINDRES="${ncn_progname}"
7607     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7608     break 2
7609   fi
7610 done
7611 done
7612
7613 fi
7614 fi
7615 WINDRES=$ac_cv_prog_WINDRES
7616 if test -n "$WINDRES"; then
7617   echo "$as_me:$LINENO: result: $WINDRES" >&5
7618 echo "${ECHO_T}$WINDRES" >&6
7619 else
7620   echo "$as_me:$LINENO: result: no" >&5
7621 echo "${ECHO_T}no" >&6
7622 fi
7623
7624   fi
7625   test -n "$ac_cv_prog_WINDRES" && break
7626 done
7627
7628 if test -z "$ac_cv_prog_WINDRES" ; then
7629   set dummy windres
7630   if test $build = $host ; then
7631     WINDRES="$2"
7632   else
7633     WINDRES="${ncn_tool_prefix}$2"
7634   fi
7635 fi
7636
7637
7638
7639 if test -n "$WINDMC"; then
7640   ac_cv_prog_WINDMC=$WINDMC
7641 elif test -n "$ac_cv_prog_WINDMC"; then
7642   WINDMC=$ac_cv_prog_WINDMC
7643 fi
7644
7645 if test -n "$ac_cv_prog_WINDMC"; then
7646   for ncn_progname in windmc; do
7647     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7648 set dummy ${ncn_progname}; ac_word=$2
7649 echo "$as_me:$LINENO: checking for $ac_word" >&5
7650 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7651 if test "${ac_cv_prog_WINDMC+set}" = set; then
7652   echo $ECHO_N "(cached) $ECHO_C" >&6
7653 else
7654   if test -n "$WINDMC"; then
7655   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7656 else
7657 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7658 for as_dir in $PATH
7659 do
7660   IFS=$as_save_IFS
7661   test -z "$as_dir" && as_dir=.
7662   for ac_exec_ext in '' $ac_executable_extensions; do
7663   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7664     ac_cv_prog_WINDMC="${ncn_progname}"
7665     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7666     break 2
7667   fi
7668 done
7669 done
7670
7671 fi
7672 fi
7673 WINDMC=$ac_cv_prog_WINDMC
7674 if test -n "$WINDMC"; then
7675   echo "$as_me:$LINENO: result: $WINDMC" >&5
7676 echo "${ECHO_T}$WINDMC" >&6
7677 else
7678   echo "$as_me:$LINENO: result: no" >&5
7679 echo "${ECHO_T}no" >&6
7680 fi
7681
7682   done
7683 fi
7684
7685 for ncn_progname in windmc; do
7686   if test -n "$ncn_tool_prefix"; then
7687     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7688 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7689 echo "$as_me:$LINENO: checking for $ac_word" >&5
7690 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7691 if test "${ac_cv_prog_WINDMC+set}" = set; then
7692   echo $ECHO_N "(cached) $ECHO_C" >&6
7693 else
7694   if test -n "$WINDMC"; then
7695   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7696 else
7697 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7698 for as_dir in $PATH
7699 do
7700   IFS=$as_save_IFS
7701   test -z "$as_dir" && as_dir=.
7702   for ac_exec_ext in '' $ac_executable_extensions; do
7703   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7704     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7705     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7706     break 2
7707   fi
7708 done
7709 done
7710
7711 fi
7712 fi
7713 WINDMC=$ac_cv_prog_WINDMC
7714 if test -n "$WINDMC"; then
7715   echo "$as_me:$LINENO: result: $WINDMC" >&5
7716 echo "${ECHO_T}$WINDMC" >&6
7717 else
7718   echo "$as_me:$LINENO: result: no" >&5
7719 echo "${ECHO_T}no" >&6
7720 fi
7721
7722   fi
7723   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7724     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7725 set dummy ${ncn_progname}; ac_word=$2
7726 echo "$as_me:$LINENO: checking for $ac_word" >&5
7727 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7728 if test "${ac_cv_prog_WINDMC+set}" = set; then
7729   echo $ECHO_N "(cached) $ECHO_C" >&6
7730 else
7731   if test -n "$WINDMC"; then
7732   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7733 else
7734 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7735 for as_dir in $PATH
7736 do
7737   IFS=$as_save_IFS
7738   test -z "$as_dir" && as_dir=.
7739   for ac_exec_ext in '' $ac_executable_extensions; do
7740   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7741     ac_cv_prog_WINDMC="${ncn_progname}"
7742     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7743     break 2
7744   fi
7745 done
7746 done
7747
7748 fi
7749 fi
7750 WINDMC=$ac_cv_prog_WINDMC
7751 if test -n "$WINDMC"; then
7752   echo "$as_me:$LINENO: result: $WINDMC" >&5
7753 echo "${ECHO_T}$WINDMC" >&6
7754 else
7755   echo "$as_me:$LINENO: result: no" >&5
7756 echo "${ECHO_T}no" >&6
7757 fi
7758
7759   fi
7760   test -n "$ac_cv_prog_WINDMC" && break
7761 done
7762
7763 if test -z "$ac_cv_prog_WINDMC" ; then
7764   set dummy windmc
7765   if test $build = $host ; then
7766     WINDMC="$2"
7767   else
7768     WINDMC="${ncn_tool_prefix}$2"
7769   fi
7770 fi
7771
7772
7773
7774 if test -n "$OBJCOPY"; then
7775   ac_cv_prog_OBJCOPY=$OBJCOPY
7776 elif test -n "$ac_cv_prog_OBJCOPY"; then
7777   OBJCOPY=$ac_cv_prog_OBJCOPY
7778 fi
7779
7780 if test -n "$ac_cv_prog_OBJCOPY"; then
7781   for ncn_progname in objcopy; do
7782     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7783 set dummy ${ncn_progname}; ac_word=$2
7784 echo "$as_me:$LINENO: checking for $ac_word" >&5
7785 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7786 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7787   echo $ECHO_N "(cached) $ECHO_C" >&6
7788 else
7789   if test -n "$OBJCOPY"; then
7790   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7791 else
7792 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7793 for as_dir in $PATH
7794 do
7795   IFS=$as_save_IFS
7796   test -z "$as_dir" && as_dir=.
7797   for ac_exec_ext in '' $ac_executable_extensions; do
7798   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7799     ac_cv_prog_OBJCOPY="${ncn_progname}"
7800     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7801     break 2
7802   fi
7803 done
7804 done
7805
7806 fi
7807 fi
7808 OBJCOPY=$ac_cv_prog_OBJCOPY
7809 if test -n "$OBJCOPY"; then
7810   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7811 echo "${ECHO_T}$OBJCOPY" >&6
7812 else
7813   echo "$as_me:$LINENO: result: no" >&5
7814 echo "${ECHO_T}no" >&6
7815 fi
7816
7817   done
7818 fi
7819
7820 for ncn_progname in objcopy; do
7821   if test -n "$ncn_tool_prefix"; then
7822     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7823 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7824 echo "$as_me:$LINENO: checking for $ac_word" >&5
7825 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7826 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7827   echo $ECHO_N "(cached) $ECHO_C" >&6
7828 else
7829   if test -n "$OBJCOPY"; then
7830   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7831 else
7832 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7833 for as_dir in $PATH
7834 do
7835   IFS=$as_save_IFS
7836   test -z "$as_dir" && as_dir=.
7837   for ac_exec_ext in '' $ac_executable_extensions; do
7838   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7839     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7840     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7841     break 2
7842   fi
7843 done
7844 done
7845
7846 fi
7847 fi
7848 OBJCOPY=$ac_cv_prog_OBJCOPY
7849 if test -n "$OBJCOPY"; then
7850   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7851 echo "${ECHO_T}$OBJCOPY" >&6
7852 else
7853   echo "$as_me:$LINENO: result: no" >&5
7854 echo "${ECHO_T}no" >&6
7855 fi
7856
7857   fi
7858   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7859     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7860 set dummy ${ncn_progname}; ac_word=$2
7861 echo "$as_me:$LINENO: checking for $ac_word" >&5
7862 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7863 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7864   echo $ECHO_N "(cached) $ECHO_C" >&6
7865 else
7866   if test -n "$OBJCOPY"; then
7867   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7868 else
7869 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7870 for as_dir in $PATH
7871 do
7872   IFS=$as_save_IFS
7873   test -z "$as_dir" && as_dir=.
7874   for ac_exec_ext in '' $ac_executable_extensions; do
7875   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7876     ac_cv_prog_OBJCOPY="${ncn_progname}"
7877     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7878     break 2
7879   fi
7880 done
7881 done
7882
7883 fi
7884 fi
7885 OBJCOPY=$ac_cv_prog_OBJCOPY
7886 if test -n "$OBJCOPY"; then
7887   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7888 echo "${ECHO_T}$OBJCOPY" >&6
7889 else
7890   echo "$as_me:$LINENO: result: no" >&5
7891 echo "${ECHO_T}no" >&6
7892 fi
7893
7894   fi
7895   test -n "$ac_cv_prog_OBJCOPY" && break
7896 done
7897
7898 if test -z "$ac_cv_prog_OBJCOPY" ; then
7899   set dummy objcopy
7900   if test $build = $host ; then
7901     OBJCOPY="$2"
7902   else
7903     OBJCOPY="${ncn_tool_prefix}$2"
7904   fi
7905 fi
7906
7907
7908
7909 if test -n "$OBJDUMP"; then
7910   ac_cv_prog_OBJDUMP=$OBJDUMP
7911 elif test -n "$ac_cv_prog_OBJDUMP"; then
7912   OBJDUMP=$ac_cv_prog_OBJDUMP
7913 fi
7914
7915 if test -n "$ac_cv_prog_OBJDUMP"; then
7916   for ncn_progname in objdump; do
7917     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7918 set dummy ${ncn_progname}; ac_word=$2
7919 echo "$as_me:$LINENO: checking for $ac_word" >&5
7920 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7921 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7922   echo $ECHO_N "(cached) $ECHO_C" >&6
7923 else
7924   if test -n "$OBJDUMP"; then
7925   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7926 else
7927 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7928 for as_dir in $PATH
7929 do
7930   IFS=$as_save_IFS
7931   test -z "$as_dir" && as_dir=.
7932   for ac_exec_ext in '' $ac_executable_extensions; do
7933   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7934     ac_cv_prog_OBJDUMP="${ncn_progname}"
7935     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7936     break 2
7937   fi
7938 done
7939 done
7940
7941 fi
7942 fi
7943 OBJDUMP=$ac_cv_prog_OBJDUMP
7944 if test -n "$OBJDUMP"; then
7945   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7946 echo "${ECHO_T}$OBJDUMP" >&6
7947 else
7948   echo "$as_me:$LINENO: result: no" >&5
7949 echo "${ECHO_T}no" >&6
7950 fi
7951
7952   done
7953 fi
7954
7955 for ncn_progname in objdump; do
7956   if test -n "$ncn_tool_prefix"; then
7957     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7958 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7959 echo "$as_me:$LINENO: checking for $ac_word" >&5
7960 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7961 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7962   echo $ECHO_N "(cached) $ECHO_C" >&6
7963 else
7964   if test -n "$OBJDUMP"; then
7965   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7966 else
7967 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7968 for as_dir in $PATH
7969 do
7970   IFS=$as_save_IFS
7971   test -z "$as_dir" && as_dir=.
7972   for ac_exec_ext in '' $ac_executable_extensions; do
7973   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7974     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7975     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7976     break 2
7977   fi
7978 done
7979 done
7980
7981 fi
7982 fi
7983 OBJDUMP=$ac_cv_prog_OBJDUMP
7984 if test -n "$OBJDUMP"; then
7985   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7986 echo "${ECHO_T}$OBJDUMP" >&6
7987 else
7988   echo "$as_me:$LINENO: result: no" >&5
7989 echo "${ECHO_T}no" >&6
7990 fi
7991
7992   fi
7993   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7994     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7995 set dummy ${ncn_progname}; ac_word=$2
7996 echo "$as_me:$LINENO: checking for $ac_word" >&5
7997 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7998 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7999   echo $ECHO_N "(cached) $ECHO_C" >&6
8000 else
8001   if test -n "$OBJDUMP"; then
8002   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8003 else
8004 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8005 for as_dir in $PATH
8006 do
8007   IFS=$as_save_IFS
8008   test -z "$as_dir" && as_dir=.
8009   for ac_exec_ext in '' $ac_executable_extensions; do
8010   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8011     ac_cv_prog_OBJDUMP="${ncn_progname}"
8012     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8013     break 2
8014   fi
8015 done
8016 done
8017
8018 fi
8019 fi
8020 OBJDUMP=$ac_cv_prog_OBJDUMP
8021 if test -n "$OBJDUMP"; then
8022   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8023 echo "${ECHO_T}$OBJDUMP" >&6
8024 else
8025   echo "$as_me:$LINENO: result: no" >&5
8026 echo "${ECHO_T}no" >&6
8027 fi
8028
8029   fi
8030   test -n "$ac_cv_prog_OBJDUMP" && break
8031 done
8032
8033 if test -z "$ac_cv_prog_OBJDUMP" ; then
8034   set dummy objdump
8035   if test $build = $host ; then
8036     OBJDUMP="$2"
8037   else
8038     OBJDUMP="${ncn_tool_prefix}$2"
8039   fi
8040 fi
8041
8042
8043
8044
8045
8046
8047 # Target tools.
8048
8049 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8050 if test "${with_build_time_tools+set}" = set; then
8051   withval="$with_build_time_tools"
8052   case x"$withval" in
8053      x/*) ;;
8054      *)
8055        with_build_time_tools=
8056        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8057 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8058        ;;
8059    esac
8060 else
8061   with_build_time_tools=
8062 fi;
8063
8064
8065
8066 if test -n "$CC_FOR_TARGET"; then
8067   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8068 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8069   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8070 fi
8071
8072 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8073   for ncn_progname in cc gcc; do
8074     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8075 set dummy ${ncn_progname}; ac_word=$2
8076 echo "$as_me:$LINENO: checking for $ac_word" >&5
8077 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8078 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8079   echo $ECHO_N "(cached) $ECHO_C" >&6
8080 else
8081   if test -n "$CC_FOR_TARGET"; then
8082   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8083 else
8084 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8085 for as_dir in $PATH
8086 do
8087   IFS=$as_save_IFS
8088   test -z "$as_dir" && as_dir=.
8089   for ac_exec_ext in '' $ac_executable_extensions; do
8090   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8091     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8092     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8093     break 2
8094   fi
8095 done
8096 done
8097
8098 fi
8099 fi
8100 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8101 if test -n "$CC_FOR_TARGET"; then
8102   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8103 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8104 else
8105   echo "$as_me:$LINENO: result: no" >&5
8106 echo "${ECHO_T}no" >&6
8107 fi
8108
8109   done
8110 fi
8111
8112 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8113   for ncn_progname in cc gcc; do
8114     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8115 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8116     if test -x $with_build_time_tools/${ncn_progname}; then
8117       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8118       echo "$as_me:$LINENO: result: yes" >&5
8119 echo "${ECHO_T}yes" >&6
8120       break
8121     else
8122       echo "$as_me:$LINENO: result: no" >&5
8123 echo "${ECHO_T}no" >&6
8124     fi
8125   done
8126 fi
8127
8128 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8129   for ncn_progname in cc gcc; do
8130     if test -n "$ncn_target_tool_prefix"; then
8131       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8132 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8133 echo "$as_me:$LINENO: checking for $ac_word" >&5
8134 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8135 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8136   echo $ECHO_N "(cached) $ECHO_C" >&6
8137 else
8138   if test -n "$CC_FOR_TARGET"; then
8139   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8140 else
8141 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8142 for as_dir in $PATH
8143 do
8144   IFS=$as_save_IFS
8145   test -z "$as_dir" && as_dir=.
8146   for ac_exec_ext in '' $ac_executable_extensions; do
8147   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8148     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8149     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8150     break 2
8151   fi
8152 done
8153 done
8154
8155 fi
8156 fi
8157 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8158 if test -n "$CC_FOR_TARGET"; then
8159   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8160 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8161 else
8162   echo "$as_me:$LINENO: result: no" >&5
8163 echo "${ECHO_T}no" >&6
8164 fi
8165
8166     fi
8167     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8168       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8169 set dummy ${ncn_progname}; ac_word=$2
8170 echo "$as_me:$LINENO: checking for $ac_word" >&5
8171 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8172 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8173   echo $ECHO_N "(cached) $ECHO_C" >&6
8174 else
8175   if test -n "$CC_FOR_TARGET"; then
8176   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8177 else
8178 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8179 for as_dir in $PATH
8180 do
8181   IFS=$as_save_IFS
8182   test -z "$as_dir" && as_dir=.
8183   for ac_exec_ext in '' $ac_executable_extensions; do
8184   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8185     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8186     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8187     break 2
8188   fi
8189 done
8190 done
8191
8192 fi
8193 fi
8194 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8195 if test -n "$CC_FOR_TARGET"; then
8196   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8197 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8198 else
8199   echo "$as_me:$LINENO: result: no" >&5
8200 echo "${ECHO_T}no" >&6
8201 fi
8202
8203     fi
8204     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8205   done
8206 fi
8207
8208 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8209   set dummy cc gcc
8210   if test $build = $target ; then
8211     CC_FOR_TARGET="$2"
8212   else
8213     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8214   fi
8215 else
8216   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8217 fi
8218
8219
8220
8221 if test -n "$CXX_FOR_TARGET"; then
8222   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8223 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8224   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8225 fi
8226
8227 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8228   for ncn_progname in c++ g++ cxx gxx; do
8229     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8230 set dummy ${ncn_progname}; ac_word=$2
8231 echo "$as_me:$LINENO: checking for $ac_word" >&5
8232 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8233 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8234   echo $ECHO_N "(cached) $ECHO_C" >&6
8235 else
8236   if test -n "$CXX_FOR_TARGET"; then
8237   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8238 else
8239 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8240 for as_dir in $PATH
8241 do
8242   IFS=$as_save_IFS
8243   test -z "$as_dir" && as_dir=.
8244   for ac_exec_ext in '' $ac_executable_extensions; do
8245   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8246     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8247     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8248     break 2
8249   fi
8250 done
8251 done
8252
8253 fi
8254 fi
8255 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8256 if test -n "$CXX_FOR_TARGET"; then
8257   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8258 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8259 else
8260   echo "$as_me:$LINENO: result: no" >&5
8261 echo "${ECHO_T}no" >&6
8262 fi
8263
8264   done
8265 fi
8266
8267 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8268   for ncn_progname in c++ g++ cxx gxx; do
8269     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8270 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8271     if test -x $with_build_time_tools/${ncn_progname}; then
8272       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8273       echo "$as_me:$LINENO: result: yes" >&5
8274 echo "${ECHO_T}yes" >&6
8275       break
8276     else
8277       echo "$as_me:$LINENO: result: no" >&5
8278 echo "${ECHO_T}no" >&6
8279     fi
8280   done
8281 fi
8282
8283 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8284   for ncn_progname in c++ g++ cxx gxx; do
8285     if test -n "$ncn_target_tool_prefix"; then
8286       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8287 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8288 echo "$as_me:$LINENO: checking for $ac_word" >&5
8289 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8290 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8291   echo $ECHO_N "(cached) $ECHO_C" >&6
8292 else
8293   if test -n "$CXX_FOR_TARGET"; then
8294   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8295 else
8296 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8297 for as_dir in $PATH
8298 do
8299   IFS=$as_save_IFS
8300   test -z "$as_dir" && as_dir=.
8301   for ac_exec_ext in '' $ac_executable_extensions; do
8302   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8303     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8304     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8305     break 2
8306   fi
8307 done
8308 done
8309
8310 fi
8311 fi
8312 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8313 if test -n "$CXX_FOR_TARGET"; then
8314   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8315 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8316 else
8317   echo "$as_me:$LINENO: result: no" >&5
8318 echo "${ECHO_T}no" >&6
8319 fi
8320
8321     fi
8322     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8323       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8324 set dummy ${ncn_progname}; ac_word=$2
8325 echo "$as_me:$LINENO: checking for $ac_word" >&5
8326 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8327 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8328   echo $ECHO_N "(cached) $ECHO_C" >&6
8329 else
8330   if test -n "$CXX_FOR_TARGET"; then
8331   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8332 else
8333 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8334 for as_dir in $PATH
8335 do
8336   IFS=$as_save_IFS
8337   test -z "$as_dir" && as_dir=.
8338   for ac_exec_ext in '' $ac_executable_extensions; do
8339   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8340     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8341     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8342     break 2
8343   fi
8344 done
8345 done
8346
8347 fi
8348 fi
8349 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8350 if test -n "$CXX_FOR_TARGET"; then
8351   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8352 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8353 else
8354   echo "$as_me:$LINENO: result: no" >&5
8355 echo "${ECHO_T}no" >&6
8356 fi
8357
8358     fi
8359     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8360   done
8361 fi
8362
8363 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8364   set dummy c++ g++ cxx gxx
8365   if test $build = $target ; then
8366     CXX_FOR_TARGET="$2"
8367   else
8368     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8369   fi
8370 else
8371   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8372 fi
8373
8374
8375
8376 if test -n "$GCC_FOR_TARGET"; then
8377   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8378 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8379   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8380 fi
8381
8382 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8383   for ncn_progname in gcc; do
8384     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8385 set dummy ${ncn_progname}; ac_word=$2
8386 echo "$as_me:$LINENO: checking for $ac_word" >&5
8387 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8388 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8389   echo $ECHO_N "(cached) $ECHO_C" >&6
8390 else
8391   if test -n "$GCC_FOR_TARGET"; then
8392   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8393 else
8394 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8395 for as_dir in $PATH
8396 do
8397   IFS=$as_save_IFS
8398   test -z "$as_dir" && as_dir=.
8399   for ac_exec_ext in '' $ac_executable_extensions; do
8400   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8401     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8402     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8403     break 2
8404   fi
8405 done
8406 done
8407
8408 fi
8409 fi
8410 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8411 if test -n "$GCC_FOR_TARGET"; then
8412   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8413 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8414 else
8415   echo "$as_me:$LINENO: result: no" >&5
8416 echo "${ECHO_T}no" >&6
8417 fi
8418
8419   done
8420 fi
8421
8422 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8423   for ncn_progname in gcc; do
8424     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8425 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8426     if test -x $with_build_time_tools/${ncn_progname}; then
8427       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8428       echo "$as_me:$LINENO: result: yes" >&5
8429 echo "${ECHO_T}yes" >&6
8430       break
8431     else
8432       echo "$as_me:$LINENO: result: no" >&5
8433 echo "${ECHO_T}no" >&6
8434     fi
8435   done
8436 fi
8437
8438 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8439   for ncn_progname in gcc; do
8440     if test -n "$ncn_target_tool_prefix"; then
8441       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8442 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8443 echo "$as_me:$LINENO: checking for $ac_word" >&5
8444 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8445 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8446   echo $ECHO_N "(cached) $ECHO_C" >&6
8447 else
8448   if test -n "$GCC_FOR_TARGET"; then
8449   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8450 else
8451 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8452 for as_dir in $PATH
8453 do
8454   IFS=$as_save_IFS
8455   test -z "$as_dir" && as_dir=.
8456   for ac_exec_ext in '' $ac_executable_extensions; do
8457   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8458     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8459     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8460     break 2
8461   fi
8462 done
8463 done
8464
8465 fi
8466 fi
8467 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8468 if test -n "$GCC_FOR_TARGET"; then
8469   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8470 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8471 else
8472   echo "$as_me:$LINENO: result: no" >&5
8473 echo "${ECHO_T}no" >&6
8474 fi
8475
8476     fi
8477     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8478       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8479 set dummy ${ncn_progname}; ac_word=$2
8480 echo "$as_me:$LINENO: checking for $ac_word" >&5
8481 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8482 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8483   echo $ECHO_N "(cached) $ECHO_C" >&6
8484 else
8485   if test -n "$GCC_FOR_TARGET"; then
8486   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8487 else
8488 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8489 for as_dir in $PATH
8490 do
8491   IFS=$as_save_IFS
8492   test -z "$as_dir" && as_dir=.
8493   for ac_exec_ext in '' $ac_executable_extensions; do
8494   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8495     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8496     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8497     break 2
8498   fi
8499 done
8500 done
8501
8502 fi
8503 fi
8504 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8505 if test -n "$GCC_FOR_TARGET"; then
8506   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8507 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8508 else
8509   echo "$as_me:$LINENO: result: no" >&5
8510 echo "${ECHO_T}no" >&6
8511 fi
8512
8513     fi
8514     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8515   done
8516 fi
8517
8518 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8519   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8520 else
8521   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8522 fi
8523
8524
8525
8526 if test -n "$GCJ_FOR_TARGET"; then
8527   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8528 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8529   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8530 fi
8531
8532 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8533   for ncn_progname in gcj; do
8534     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8535 set dummy ${ncn_progname}; ac_word=$2
8536 echo "$as_me:$LINENO: checking for $ac_word" >&5
8537 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8538 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8539   echo $ECHO_N "(cached) $ECHO_C" >&6
8540 else
8541   if test -n "$GCJ_FOR_TARGET"; then
8542   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8543 else
8544 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8545 for as_dir in $PATH
8546 do
8547   IFS=$as_save_IFS
8548   test -z "$as_dir" && as_dir=.
8549   for ac_exec_ext in '' $ac_executable_extensions; do
8550   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8551     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8552     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8553     break 2
8554   fi
8555 done
8556 done
8557
8558 fi
8559 fi
8560 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8561 if test -n "$GCJ_FOR_TARGET"; then
8562   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8563 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8564 else
8565   echo "$as_me:$LINENO: result: no" >&5
8566 echo "${ECHO_T}no" >&6
8567 fi
8568
8569   done
8570 fi
8571
8572 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8573   for ncn_progname in gcj; do
8574     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8575 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8576     if test -x $with_build_time_tools/${ncn_progname}; then
8577       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8578       echo "$as_me:$LINENO: result: yes" >&5
8579 echo "${ECHO_T}yes" >&6
8580       break
8581     else
8582       echo "$as_me:$LINENO: result: no" >&5
8583 echo "${ECHO_T}no" >&6
8584     fi
8585   done
8586 fi
8587
8588 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8589   for ncn_progname in gcj; do
8590     if test -n "$ncn_target_tool_prefix"; then
8591       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8592 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8593 echo "$as_me:$LINENO: checking for $ac_word" >&5
8594 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8595 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8596   echo $ECHO_N "(cached) $ECHO_C" >&6
8597 else
8598   if test -n "$GCJ_FOR_TARGET"; then
8599   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8600 else
8601 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8602 for as_dir in $PATH
8603 do
8604   IFS=$as_save_IFS
8605   test -z "$as_dir" && as_dir=.
8606   for ac_exec_ext in '' $ac_executable_extensions; do
8607   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8608     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8609     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8610     break 2
8611   fi
8612 done
8613 done
8614
8615 fi
8616 fi
8617 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8618 if test -n "$GCJ_FOR_TARGET"; then
8619   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8620 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8621 else
8622   echo "$as_me:$LINENO: result: no" >&5
8623 echo "${ECHO_T}no" >&6
8624 fi
8625
8626     fi
8627     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8628       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8629 set dummy ${ncn_progname}; ac_word=$2
8630 echo "$as_me:$LINENO: checking for $ac_word" >&5
8631 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8632 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8633   echo $ECHO_N "(cached) $ECHO_C" >&6
8634 else
8635   if test -n "$GCJ_FOR_TARGET"; then
8636   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8637 else
8638 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8639 for as_dir in $PATH
8640 do
8641   IFS=$as_save_IFS
8642   test -z "$as_dir" && as_dir=.
8643   for ac_exec_ext in '' $ac_executable_extensions; do
8644   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8645     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8646     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8647     break 2
8648   fi
8649 done
8650 done
8651
8652 fi
8653 fi
8654 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8655 if test -n "$GCJ_FOR_TARGET"; then
8656   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8657 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8658 else
8659   echo "$as_me:$LINENO: result: no" >&5
8660 echo "${ECHO_T}no" >&6
8661 fi
8662
8663     fi
8664     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8665   done
8666 fi
8667
8668 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8669   set dummy gcj
8670   if test $build = $target ; then
8671     GCJ_FOR_TARGET="$2"
8672   else
8673     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8674   fi
8675 else
8676   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8677 fi
8678
8679
8680
8681 if test -n "$GFORTRAN_FOR_TARGET"; then
8682   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8683 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8684   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8685 fi
8686
8687 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8688   for ncn_progname in gfortran; do
8689     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8690 set dummy ${ncn_progname}; ac_word=$2
8691 echo "$as_me:$LINENO: checking for $ac_word" >&5
8692 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8693 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8694   echo $ECHO_N "(cached) $ECHO_C" >&6
8695 else
8696   if test -n "$GFORTRAN_FOR_TARGET"; then
8697   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8698 else
8699 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8700 for as_dir in $PATH
8701 do
8702   IFS=$as_save_IFS
8703   test -z "$as_dir" && as_dir=.
8704   for ac_exec_ext in '' $ac_executable_extensions; do
8705   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8706     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8707     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8708     break 2
8709   fi
8710 done
8711 done
8712
8713 fi
8714 fi
8715 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8716 if test -n "$GFORTRAN_FOR_TARGET"; then
8717   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8718 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8719 else
8720   echo "$as_me:$LINENO: result: no" >&5
8721 echo "${ECHO_T}no" >&6
8722 fi
8723
8724   done
8725 fi
8726
8727 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8728   for ncn_progname in gfortran; do
8729     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8730 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8731     if test -x $with_build_time_tools/${ncn_progname}; then
8732       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8733       echo "$as_me:$LINENO: result: yes" >&5
8734 echo "${ECHO_T}yes" >&6
8735       break
8736     else
8737       echo "$as_me:$LINENO: result: no" >&5
8738 echo "${ECHO_T}no" >&6
8739     fi
8740   done
8741 fi
8742
8743 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8744   for ncn_progname in gfortran; do
8745     if test -n "$ncn_target_tool_prefix"; then
8746       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8747 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8748 echo "$as_me:$LINENO: checking for $ac_word" >&5
8749 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8750 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8751   echo $ECHO_N "(cached) $ECHO_C" >&6
8752 else
8753   if test -n "$GFORTRAN_FOR_TARGET"; then
8754   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8755 else
8756 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8757 for as_dir in $PATH
8758 do
8759   IFS=$as_save_IFS
8760   test -z "$as_dir" && as_dir=.
8761   for ac_exec_ext in '' $ac_executable_extensions; do
8762   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8763     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8764     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8765     break 2
8766   fi
8767 done
8768 done
8769
8770 fi
8771 fi
8772 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8773 if test -n "$GFORTRAN_FOR_TARGET"; then
8774   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8775 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8776 else
8777   echo "$as_me:$LINENO: result: no" >&5
8778 echo "${ECHO_T}no" >&6
8779 fi
8780
8781     fi
8782     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8783       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8784 set dummy ${ncn_progname}; ac_word=$2
8785 echo "$as_me:$LINENO: checking for $ac_word" >&5
8786 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8787 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8788   echo $ECHO_N "(cached) $ECHO_C" >&6
8789 else
8790   if test -n "$GFORTRAN_FOR_TARGET"; then
8791   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8792 else
8793 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8794 for as_dir in $PATH
8795 do
8796   IFS=$as_save_IFS
8797   test -z "$as_dir" && as_dir=.
8798   for ac_exec_ext in '' $ac_executable_extensions; do
8799   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8800     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8801     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8802     break 2
8803   fi
8804 done
8805 done
8806
8807 fi
8808 fi
8809 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8810 if test -n "$GFORTRAN_FOR_TARGET"; then
8811   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8812 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8813 else
8814   echo "$as_me:$LINENO: result: no" >&5
8815 echo "${ECHO_T}no" >&6
8816 fi
8817
8818     fi
8819     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8820   done
8821 fi
8822
8823 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8824   set dummy gfortran
8825   if test $build = $target ; then
8826     GFORTRAN_FOR_TARGET="$2"
8827   else
8828     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8829   fi
8830 else
8831   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8832 fi
8833
8834
8835
8836 cat > conftest.c << \EOF
8837 #ifdef __GNUC__
8838   gcc_yay;
8839 #endif
8840 EOF
8841 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8842   have_gcc_for_target=yes
8843 else
8844   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8845   have_gcc_for_target=no
8846 fi
8847 rm conftest.c
8848
8849
8850
8851
8852 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8853   if test -n "$with_build_time_tools"; then
8854     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8855 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8856     if test -x $with_build_time_tools/ar; then
8857       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8858       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8859       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8860 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8861     else
8862       echo "$as_me:$LINENO: result: no" >&5
8863 echo "${ECHO_T}no" >&6
8864     fi
8865   elif test $build != $host && test $have_gcc_for_target = yes; then
8866     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8867     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8868     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8869   fi
8870 fi
8871 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8872   # Extract the first word of "ar", so it can be a program name with args.
8873 set dummy ar; ac_word=$2
8874 echo "$as_me:$LINENO: checking for $ac_word" >&5
8875 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8876 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8877   echo $ECHO_N "(cached) $ECHO_C" >&6
8878 else
8879   case $AR_FOR_TARGET in
8880   [\\/]* | ?:[\\/]*)
8881   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8882   ;;
8883   *)
8884   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8885 for as_dir in $gcc_cv_tool_dirs
8886 do
8887   IFS=$as_save_IFS
8888   test -z "$as_dir" && as_dir=.
8889   for ac_exec_ext in '' $ac_executable_extensions; do
8890   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8891     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8892     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8893     break 2
8894   fi
8895 done
8896 done
8897
8898   ;;
8899 esac
8900 fi
8901 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8902
8903 if test -n "$AR_FOR_TARGET"; then
8904   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8905 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8906 else
8907   echo "$as_me:$LINENO: result: no" >&5
8908 echo "${ECHO_T}no" >&6
8909 fi
8910
8911 fi
8912 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8913
8914
8915 if test -n "$AR_FOR_TARGET"; then
8916   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8917 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8918   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8919 fi
8920
8921 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8922   for ncn_progname in ar; do
8923     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8924 set dummy ${ncn_progname}; ac_word=$2
8925 echo "$as_me:$LINENO: checking for $ac_word" >&5
8926 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8927 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8928   echo $ECHO_N "(cached) $ECHO_C" >&6
8929 else
8930   if test -n "$AR_FOR_TARGET"; then
8931   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8932 else
8933 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8934 for as_dir in $PATH
8935 do
8936   IFS=$as_save_IFS
8937   test -z "$as_dir" && as_dir=.
8938   for ac_exec_ext in '' $ac_executable_extensions; do
8939   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8940     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8941     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8942     break 2
8943   fi
8944 done
8945 done
8946
8947 fi
8948 fi
8949 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8950 if test -n "$AR_FOR_TARGET"; then
8951   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8952 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8953 else
8954   echo "$as_me:$LINENO: result: no" >&5
8955 echo "${ECHO_T}no" >&6
8956 fi
8957
8958   done
8959 fi
8960
8961 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8962   for ncn_progname in ar; do
8963     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8964 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8965     if test -x $with_build_time_tools/${ncn_progname}; then
8966       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8967       echo "$as_me:$LINENO: result: yes" >&5
8968 echo "${ECHO_T}yes" >&6
8969       break
8970     else
8971       echo "$as_me:$LINENO: result: no" >&5
8972 echo "${ECHO_T}no" >&6
8973     fi
8974   done
8975 fi
8976
8977 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8978   for ncn_progname in ar; do
8979     if test -n "$ncn_target_tool_prefix"; then
8980       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8981 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8982 echo "$as_me:$LINENO: checking for $ac_word" >&5
8983 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8984 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8985   echo $ECHO_N "(cached) $ECHO_C" >&6
8986 else
8987   if test -n "$AR_FOR_TARGET"; then
8988   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8989 else
8990 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8991 for as_dir in $PATH
8992 do
8993   IFS=$as_save_IFS
8994   test -z "$as_dir" && as_dir=.
8995   for ac_exec_ext in '' $ac_executable_extensions; do
8996   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8997     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8998     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8999     break 2
9000   fi
9001 done
9002 done
9003
9004 fi
9005 fi
9006 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9007 if test -n "$AR_FOR_TARGET"; then
9008   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9009 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9010 else
9011   echo "$as_me:$LINENO: result: no" >&5
9012 echo "${ECHO_T}no" >&6
9013 fi
9014
9015     fi
9016     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9017       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9018 set dummy ${ncn_progname}; ac_word=$2
9019 echo "$as_me:$LINENO: checking for $ac_word" >&5
9020 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9021 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9022   echo $ECHO_N "(cached) $ECHO_C" >&6
9023 else
9024   if test -n "$AR_FOR_TARGET"; then
9025   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9026 else
9027 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9028 for as_dir in $PATH
9029 do
9030   IFS=$as_save_IFS
9031   test -z "$as_dir" && as_dir=.
9032   for ac_exec_ext in '' $ac_executable_extensions; do
9033   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9034     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9035     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9036     break 2
9037   fi
9038 done
9039 done
9040
9041 fi
9042 fi
9043 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9044 if test -n "$AR_FOR_TARGET"; then
9045   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9046 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9047 else
9048   echo "$as_me:$LINENO: result: no" >&5
9049 echo "${ECHO_T}no" >&6
9050 fi
9051
9052     fi
9053     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9054   done
9055 fi
9056
9057 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9058   set dummy ar
9059   if test $build = $target ; then
9060     AR_FOR_TARGET="$2"
9061   else
9062     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9063   fi
9064 else
9065   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9066 fi
9067
9068 else
9069   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9070 fi
9071
9072
9073
9074
9075 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9076   if test -n "$with_build_time_tools"; then
9077     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9078 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9079     if test -x $with_build_time_tools/as; then
9080       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9081       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9082       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9083 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9084     else
9085       echo "$as_me:$LINENO: result: no" >&5
9086 echo "${ECHO_T}no" >&6
9087     fi
9088   elif test $build != $host && test $have_gcc_for_target = yes; then
9089     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9090     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9091     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9092   fi
9093 fi
9094 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9095   # Extract the first word of "as", so it can be a program name with args.
9096 set dummy as; ac_word=$2
9097 echo "$as_me:$LINENO: checking for $ac_word" >&5
9098 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9099 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9100   echo $ECHO_N "(cached) $ECHO_C" >&6
9101 else
9102   case $AS_FOR_TARGET in
9103   [\\/]* | ?:[\\/]*)
9104   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9105   ;;
9106   *)
9107   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9108 for as_dir in $gcc_cv_tool_dirs
9109 do
9110   IFS=$as_save_IFS
9111   test -z "$as_dir" && as_dir=.
9112   for ac_exec_ext in '' $ac_executable_extensions; do
9113   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9114     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9115     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9116     break 2
9117   fi
9118 done
9119 done
9120
9121   ;;
9122 esac
9123 fi
9124 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9125
9126 if test -n "$AS_FOR_TARGET"; then
9127   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9128 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9129 else
9130   echo "$as_me:$LINENO: result: no" >&5
9131 echo "${ECHO_T}no" >&6
9132 fi
9133
9134 fi
9135 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9136
9137
9138 if test -n "$AS_FOR_TARGET"; then
9139   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9140 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9141   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9142 fi
9143
9144 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9145   for ncn_progname in as; do
9146     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9147 set dummy ${ncn_progname}; ac_word=$2
9148 echo "$as_me:$LINENO: checking for $ac_word" >&5
9149 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9150 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9151   echo $ECHO_N "(cached) $ECHO_C" >&6
9152 else
9153   if test -n "$AS_FOR_TARGET"; then
9154   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9155 else
9156 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9157 for as_dir in $PATH
9158 do
9159   IFS=$as_save_IFS
9160   test -z "$as_dir" && as_dir=.
9161   for ac_exec_ext in '' $ac_executable_extensions; do
9162   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9163     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9164     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9165     break 2
9166   fi
9167 done
9168 done
9169
9170 fi
9171 fi
9172 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9173 if test -n "$AS_FOR_TARGET"; then
9174   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9175 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9176 else
9177   echo "$as_me:$LINENO: result: no" >&5
9178 echo "${ECHO_T}no" >&6
9179 fi
9180
9181   done
9182 fi
9183
9184 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9185   for ncn_progname in as; do
9186     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9187 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9188     if test -x $with_build_time_tools/${ncn_progname}; then
9189       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9190       echo "$as_me:$LINENO: result: yes" >&5
9191 echo "${ECHO_T}yes" >&6
9192       break
9193     else
9194       echo "$as_me:$LINENO: result: no" >&5
9195 echo "${ECHO_T}no" >&6
9196     fi
9197   done
9198 fi
9199
9200 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9201   for ncn_progname in as; do
9202     if test -n "$ncn_target_tool_prefix"; then
9203       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9204 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9205 echo "$as_me:$LINENO: checking for $ac_word" >&5
9206 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9207 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9208   echo $ECHO_N "(cached) $ECHO_C" >&6
9209 else
9210   if test -n "$AS_FOR_TARGET"; then
9211   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9212 else
9213 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9214 for as_dir in $PATH
9215 do
9216   IFS=$as_save_IFS
9217   test -z "$as_dir" && as_dir=.
9218   for ac_exec_ext in '' $ac_executable_extensions; do
9219   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9220     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9221     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9222     break 2
9223   fi
9224 done
9225 done
9226
9227 fi
9228 fi
9229 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9230 if test -n "$AS_FOR_TARGET"; then
9231   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9232 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9233 else
9234   echo "$as_me:$LINENO: result: no" >&5
9235 echo "${ECHO_T}no" >&6
9236 fi
9237
9238     fi
9239     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9240       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9241 set dummy ${ncn_progname}; ac_word=$2
9242 echo "$as_me:$LINENO: checking for $ac_word" >&5
9243 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9244 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9245   echo $ECHO_N "(cached) $ECHO_C" >&6
9246 else
9247   if test -n "$AS_FOR_TARGET"; then
9248   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9249 else
9250 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9251 for as_dir in $PATH
9252 do
9253   IFS=$as_save_IFS
9254   test -z "$as_dir" && as_dir=.
9255   for ac_exec_ext in '' $ac_executable_extensions; do
9256   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9257     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9258     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9259     break 2
9260   fi
9261 done
9262 done
9263
9264 fi
9265 fi
9266 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9267 if test -n "$AS_FOR_TARGET"; then
9268   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9269 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9270 else
9271   echo "$as_me:$LINENO: result: no" >&5
9272 echo "${ECHO_T}no" >&6
9273 fi
9274
9275     fi
9276     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9277   done
9278 fi
9279
9280 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9281   set dummy as
9282   if test $build = $target ; then
9283     AS_FOR_TARGET="$2"
9284   else
9285     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9286   fi
9287 else
9288   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9289 fi
9290
9291 else
9292   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9293 fi
9294
9295
9296
9297
9298 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9299   if test -n "$with_build_time_tools"; then
9300     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9301 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9302     if test -x $with_build_time_tools/dlltool; then
9303       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9304       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9305       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9306 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9307     else
9308       echo "$as_me:$LINENO: result: no" >&5
9309 echo "${ECHO_T}no" >&6
9310     fi
9311   elif test $build != $host && test $have_gcc_for_target = yes; then
9312     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9313     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9314     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9315   fi
9316 fi
9317 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9318   # Extract the first word of "dlltool", so it can be a program name with args.
9319 set dummy dlltool; ac_word=$2
9320 echo "$as_me:$LINENO: checking for $ac_word" >&5
9321 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9322 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9323   echo $ECHO_N "(cached) $ECHO_C" >&6
9324 else
9325   case $DLLTOOL_FOR_TARGET in
9326   [\\/]* | ?:[\\/]*)
9327   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9328   ;;
9329   *)
9330   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9331 for as_dir in $gcc_cv_tool_dirs
9332 do
9333   IFS=$as_save_IFS
9334   test -z "$as_dir" && as_dir=.
9335   for ac_exec_ext in '' $ac_executable_extensions; do
9336   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9337     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9338     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9339     break 2
9340   fi
9341 done
9342 done
9343
9344   ;;
9345 esac
9346 fi
9347 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9348
9349 if test -n "$DLLTOOL_FOR_TARGET"; then
9350   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9351 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9352 else
9353   echo "$as_me:$LINENO: result: no" >&5
9354 echo "${ECHO_T}no" >&6
9355 fi
9356
9357 fi
9358 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9359
9360
9361 if test -n "$DLLTOOL_FOR_TARGET"; then
9362   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9363 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9364   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9365 fi
9366
9367 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9368   for ncn_progname in dlltool; do
9369     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9370 set dummy ${ncn_progname}; ac_word=$2
9371 echo "$as_me:$LINENO: checking for $ac_word" >&5
9372 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9373 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9374   echo $ECHO_N "(cached) $ECHO_C" >&6
9375 else
9376   if test -n "$DLLTOOL_FOR_TARGET"; then
9377   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9378 else
9379 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9380 for as_dir in $PATH
9381 do
9382   IFS=$as_save_IFS
9383   test -z "$as_dir" && as_dir=.
9384   for ac_exec_ext in '' $ac_executable_extensions; do
9385   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9386     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9387     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9388     break 2
9389   fi
9390 done
9391 done
9392
9393 fi
9394 fi
9395 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9396 if test -n "$DLLTOOL_FOR_TARGET"; then
9397   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9398 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9399 else
9400   echo "$as_me:$LINENO: result: no" >&5
9401 echo "${ECHO_T}no" >&6
9402 fi
9403
9404   done
9405 fi
9406
9407 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9408   for ncn_progname in dlltool; do
9409     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9410 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9411     if test -x $with_build_time_tools/${ncn_progname}; then
9412       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9413       echo "$as_me:$LINENO: result: yes" >&5
9414 echo "${ECHO_T}yes" >&6
9415       break
9416     else
9417       echo "$as_me:$LINENO: result: no" >&5
9418 echo "${ECHO_T}no" >&6
9419     fi
9420   done
9421 fi
9422
9423 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9424   for ncn_progname in dlltool; do
9425     if test -n "$ncn_target_tool_prefix"; then
9426       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9427 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9428 echo "$as_me:$LINENO: checking for $ac_word" >&5
9429 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9430 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9431   echo $ECHO_N "(cached) $ECHO_C" >&6
9432 else
9433   if test -n "$DLLTOOL_FOR_TARGET"; then
9434   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9435 else
9436 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9437 for as_dir in $PATH
9438 do
9439   IFS=$as_save_IFS
9440   test -z "$as_dir" && as_dir=.
9441   for ac_exec_ext in '' $ac_executable_extensions; do
9442   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9443     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9444     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9445     break 2
9446   fi
9447 done
9448 done
9449
9450 fi
9451 fi
9452 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9453 if test -n "$DLLTOOL_FOR_TARGET"; then
9454   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9455 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9456 else
9457   echo "$as_me:$LINENO: result: no" >&5
9458 echo "${ECHO_T}no" >&6
9459 fi
9460
9461     fi
9462     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9463       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9464 set dummy ${ncn_progname}; ac_word=$2
9465 echo "$as_me:$LINENO: checking for $ac_word" >&5
9466 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9467 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9468   echo $ECHO_N "(cached) $ECHO_C" >&6
9469 else
9470   if test -n "$DLLTOOL_FOR_TARGET"; then
9471   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9472 else
9473 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9474 for as_dir in $PATH
9475 do
9476   IFS=$as_save_IFS
9477   test -z "$as_dir" && as_dir=.
9478   for ac_exec_ext in '' $ac_executable_extensions; do
9479   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9480     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9481     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9482     break 2
9483   fi
9484 done
9485 done
9486
9487 fi
9488 fi
9489 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9490 if test -n "$DLLTOOL_FOR_TARGET"; then
9491   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9492 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9493 else
9494   echo "$as_me:$LINENO: result: no" >&5
9495 echo "${ECHO_T}no" >&6
9496 fi
9497
9498     fi
9499     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9500   done
9501 fi
9502
9503 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9504   set dummy dlltool
9505   if test $build = $target ; then
9506     DLLTOOL_FOR_TARGET="$2"
9507   else
9508     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9509   fi
9510 else
9511   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9512 fi
9513
9514 else
9515   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9516 fi
9517
9518
9519
9520
9521 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9522   if test -n "$with_build_time_tools"; then
9523     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9524 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9525     if test -x $with_build_time_tools/ld; then
9526       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9527       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9528       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9529 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9530     else
9531       echo "$as_me:$LINENO: result: no" >&5
9532 echo "${ECHO_T}no" >&6
9533     fi
9534   elif test $build != $host && test $have_gcc_for_target = yes; then
9535     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9536     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9537     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9538   fi
9539 fi
9540 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9541   # Extract the first word of "ld", so it can be a program name with args.
9542 set dummy ld; ac_word=$2
9543 echo "$as_me:$LINENO: checking for $ac_word" >&5
9544 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9545 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9546   echo $ECHO_N "(cached) $ECHO_C" >&6
9547 else
9548   case $LD_FOR_TARGET in
9549   [\\/]* | ?:[\\/]*)
9550   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9551   ;;
9552   *)
9553   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9554 for as_dir in $gcc_cv_tool_dirs
9555 do
9556   IFS=$as_save_IFS
9557   test -z "$as_dir" && as_dir=.
9558   for ac_exec_ext in '' $ac_executable_extensions; do
9559   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9560     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9561     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9562     break 2
9563   fi
9564 done
9565 done
9566
9567   ;;
9568 esac
9569 fi
9570 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9571
9572 if test -n "$LD_FOR_TARGET"; then
9573   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9574 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9575 else
9576   echo "$as_me:$LINENO: result: no" >&5
9577 echo "${ECHO_T}no" >&6
9578 fi
9579
9580 fi
9581 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9582
9583
9584 if test -n "$LD_FOR_TARGET"; then
9585   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9586 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9587   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9588 fi
9589
9590 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9591   for ncn_progname in ld; do
9592     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9593 set dummy ${ncn_progname}; ac_word=$2
9594 echo "$as_me:$LINENO: checking for $ac_word" >&5
9595 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9596 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9597   echo $ECHO_N "(cached) $ECHO_C" >&6
9598 else
9599   if test -n "$LD_FOR_TARGET"; then
9600   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9601 else
9602 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9603 for as_dir in $PATH
9604 do
9605   IFS=$as_save_IFS
9606   test -z "$as_dir" && as_dir=.
9607   for ac_exec_ext in '' $ac_executable_extensions; do
9608   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9609     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9610     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9611     break 2
9612   fi
9613 done
9614 done
9615
9616 fi
9617 fi
9618 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9619 if test -n "$LD_FOR_TARGET"; then
9620   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9621 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9622 else
9623   echo "$as_me:$LINENO: result: no" >&5
9624 echo "${ECHO_T}no" >&6
9625 fi
9626
9627   done
9628 fi
9629
9630 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9631   for ncn_progname in ld; do
9632     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9633 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9634     if test -x $with_build_time_tools/${ncn_progname}; then
9635       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9636       echo "$as_me:$LINENO: result: yes" >&5
9637 echo "${ECHO_T}yes" >&6
9638       break
9639     else
9640       echo "$as_me:$LINENO: result: no" >&5
9641 echo "${ECHO_T}no" >&6
9642     fi
9643   done
9644 fi
9645
9646 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9647   for ncn_progname in ld; do
9648     if test -n "$ncn_target_tool_prefix"; then
9649       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9650 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9651 echo "$as_me:$LINENO: checking for $ac_word" >&5
9652 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9653 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9654   echo $ECHO_N "(cached) $ECHO_C" >&6
9655 else
9656   if test -n "$LD_FOR_TARGET"; then
9657   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9658 else
9659 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9660 for as_dir in $PATH
9661 do
9662   IFS=$as_save_IFS
9663   test -z "$as_dir" && as_dir=.
9664   for ac_exec_ext in '' $ac_executable_extensions; do
9665   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9666     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9667     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9668     break 2
9669   fi
9670 done
9671 done
9672
9673 fi
9674 fi
9675 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9676 if test -n "$LD_FOR_TARGET"; then
9677   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9678 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9679 else
9680   echo "$as_me:$LINENO: result: no" >&5
9681 echo "${ECHO_T}no" >&6
9682 fi
9683
9684     fi
9685     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9686       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9687 set dummy ${ncn_progname}; ac_word=$2
9688 echo "$as_me:$LINENO: checking for $ac_word" >&5
9689 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9690 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9691   echo $ECHO_N "(cached) $ECHO_C" >&6
9692 else
9693   if test -n "$LD_FOR_TARGET"; then
9694   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9695 else
9696 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9697 for as_dir in $PATH
9698 do
9699   IFS=$as_save_IFS
9700   test -z "$as_dir" && as_dir=.
9701   for ac_exec_ext in '' $ac_executable_extensions; do
9702   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9703     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9704     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9705     break 2
9706   fi
9707 done
9708 done
9709
9710 fi
9711 fi
9712 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9713 if test -n "$LD_FOR_TARGET"; then
9714   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9715 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9716 else
9717   echo "$as_me:$LINENO: result: no" >&5
9718 echo "${ECHO_T}no" >&6
9719 fi
9720
9721     fi
9722     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9723   done
9724 fi
9725
9726 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9727   set dummy ld
9728   if test $build = $target ; then
9729     LD_FOR_TARGET="$2"
9730   else
9731     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9732   fi
9733 else
9734   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9735 fi
9736
9737 else
9738   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9739 fi
9740
9741
9742
9743
9744 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9745   if test -n "$with_build_time_tools"; then
9746     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9747 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9748     if test -x $with_build_time_tools/lipo; then
9749       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9750       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9751       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9752 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9753     else
9754       echo "$as_me:$LINENO: result: no" >&5
9755 echo "${ECHO_T}no" >&6
9756     fi
9757   elif test $build != $host && test $have_gcc_for_target = yes; then
9758     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9759     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9760     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9761   fi
9762 fi
9763 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9764   # Extract the first word of "lipo", so it can be a program name with args.
9765 set dummy lipo; ac_word=$2
9766 echo "$as_me:$LINENO: checking for $ac_word" >&5
9767 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9768 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9769   echo $ECHO_N "(cached) $ECHO_C" >&6
9770 else
9771   case $LIPO_FOR_TARGET in
9772   [\\/]* | ?:[\\/]*)
9773   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9774   ;;
9775   *)
9776   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9777 for as_dir in $gcc_cv_tool_dirs
9778 do
9779   IFS=$as_save_IFS
9780   test -z "$as_dir" && as_dir=.
9781   for ac_exec_ext in '' $ac_executable_extensions; do
9782   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9783     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9784     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9785     break 2
9786   fi
9787 done
9788 done
9789
9790   ;;
9791 esac
9792 fi
9793 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9794
9795 if test -n "$LIPO_FOR_TARGET"; then
9796   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9797 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9798 else
9799   echo "$as_me:$LINENO: result: no" >&5
9800 echo "${ECHO_T}no" >&6
9801 fi
9802
9803 fi
9804 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9805
9806
9807 if test -n "$LIPO_FOR_TARGET"; then
9808   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9809 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9810   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9811 fi
9812
9813 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9814   for ncn_progname in lipo; do
9815     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9816 set dummy ${ncn_progname}; ac_word=$2
9817 echo "$as_me:$LINENO: checking for $ac_word" >&5
9818 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9819 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9820   echo $ECHO_N "(cached) $ECHO_C" >&6
9821 else
9822   if test -n "$LIPO_FOR_TARGET"; then
9823   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9824 else
9825 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9826 for as_dir in $PATH
9827 do
9828   IFS=$as_save_IFS
9829   test -z "$as_dir" && as_dir=.
9830   for ac_exec_ext in '' $ac_executable_extensions; do
9831   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9832     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9833     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9834     break 2
9835   fi
9836 done
9837 done
9838
9839 fi
9840 fi
9841 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9842 if test -n "$LIPO_FOR_TARGET"; then
9843   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9844 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9845 else
9846   echo "$as_me:$LINENO: result: no" >&5
9847 echo "${ECHO_T}no" >&6
9848 fi
9849
9850   done
9851 fi
9852
9853 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9854   for ncn_progname in lipo; do
9855     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9856 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9857     if test -x $with_build_time_tools/${ncn_progname}; then
9858       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9859       echo "$as_me:$LINENO: result: yes" >&5
9860 echo "${ECHO_T}yes" >&6
9861       break
9862     else
9863       echo "$as_me:$LINENO: result: no" >&5
9864 echo "${ECHO_T}no" >&6
9865     fi
9866   done
9867 fi
9868
9869 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9870   for ncn_progname in lipo; do
9871     if test -n "$ncn_target_tool_prefix"; then
9872       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9873 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9874 echo "$as_me:$LINENO: checking for $ac_word" >&5
9875 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9876 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9877   echo $ECHO_N "(cached) $ECHO_C" >&6
9878 else
9879   if test -n "$LIPO_FOR_TARGET"; then
9880   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9881 else
9882 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9883 for as_dir in $PATH
9884 do
9885   IFS=$as_save_IFS
9886   test -z "$as_dir" && as_dir=.
9887   for ac_exec_ext in '' $ac_executable_extensions; do
9888   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9889     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9890     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9891     break 2
9892   fi
9893 done
9894 done
9895
9896 fi
9897 fi
9898 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9899 if test -n "$LIPO_FOR_TARGET"; then
9900   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9901 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9902 else
9903   echo "$as_me:$LINENO: result: no" >&5
9904 echo "${ECHO_T}no" >&6
9905 fi
9906
9907     fi
9908     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9909       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9910 set dummy ${ncn_progname}; ac_word=$2
9911 echo "$as_me:$LINENO: checking for $ac_word" >&5
9912 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9913 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9914   echo $ECHO_N "(cached) $ECHO_C" >&6
9915 else
9916   if test -n "$LIPO_FOR_TARGET"; then
9917   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9918 else
9919 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9920 for as_dir in $PATH
9921 do
9922   IFS=$as_save_IFS
9923   test -z "$as_dir" && as_dir=.
9924   for ac_exec_ext in '' $ac_executable_extensions; do
9925   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9926     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9927     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9928     break 2
9929   fi
9930 done
9931 done
9932
9933 fi
9934 fi
9935 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9936 if test -n "$LIPO_FOR_TARGET"; then
9937   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9938 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9939 else
9940   echo "$as_me:$LINENO: result: no" >&5
9941 echo "${ECHO_T}no" >&6
9942 fi
9943
9944     fi
9945     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9946   done
9947 fi
9948
9949 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9950   set dummy lipo
9951   if test $build = $target ; then
9952     LIPO_FOR_TARGET="$2"
9953   else
9954     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9955   fi
9956 else
9957   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9958 fi
9959
9960 else
9961   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9962 fi
9963
9964
9965
9966
9967 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9968   if test -n "$with_build_time_tools"; then
9969     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9970 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9971     if test -x $with_build_time_tools/nm; then
9972       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9973       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9974       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9975 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9976     else
9977       echo "$as_me:$LINENO: result: no" >&5
9978 echo "${ECHO_T}no" >&6
9979     fi
9980   elif test $build != $host && test $have_gcc_for_target = yes; then
9981     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9982     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
9983     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9984   fi
9985 fi
9986 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9987   # Extract the first word of "nm", so it can be a program name with args.
9988 set dummy nm; ac_word=$2
9989 echo "$as_me:$LINENO: checking for $ac_word" >&5
9990 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9991 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9992   echo $ECHO_N "(cached) $ECHO_C" >&6
9993 else
9994   case $NM_FOR_TARGET in
9995   [\\/]* | ?:[\\/]*)
9996   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9997   ;;
9998   *)
9999   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10000 for as_dir in $gcc_cv_tool_dirs
10001 do
10002   IFS=$as_save_IFS
10003   test -z "$as_dir" && as_dir=.
10004   for ac_exec_ext in '' $ac_executable_extensions; do
10005   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10006     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10007     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10008     break 2
10009   fi
10010 done
10011 done
10012
10013   ;;
10014 esac
10015 fi
10016 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10017
10018 if test -n "$NM_FOR_TARGET"; then
10019   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10020 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10021 else
10022   echo "$as_me:$LINENO: result: no" >&5
10023 echo "${ECHO_T}no" >&6
10024 fi
10025
10026 fi
10027 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10028
10029
10030 if test -n "$NM_FOR_TARGET"; then
10031   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10032 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10033   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10034 fi
10035
10036 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10037   for ncn_progname in nm; do
10038     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10039 set dummy ${ncn_progname}; ac_word=$2
10040 echo "$as_me:$LINENO: checking for $ac_word" >&5
10041 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10042 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10043   echo $ECHO_N "(cached) $ECHO_C" >&6
10044 else
10045   if test -n "$NM_FOR_TARGET"; then
10046   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10047 else
10048 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10049 for as_dir in $PATH
10050 do
10051   IFS=$as_save_IFS
10052   test -z "$as_dir" && as_dir=.
10053   for ac_exec_ext in '' $ac_executable_extensions; do
10054   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10055     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10056     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10057     break 2
10058   fi
10059 done
10060 done
10061
10062 fi
10063 fi
10064 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10065 if test -n "$NM_FOR_TARGET"; then
10066   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10067 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10068 else
10069   echo "$as_me:$LINENO: result: no" >&5
10070 echo "${ECHO_T}no" >&6
10071 fi
10072
10073   done
10074 fi
10075
10076 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10077   for ncn_progname in nm; do
10078     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10079 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10080     if test -x $with_build_time_tools/${ncn_progname}; then
10081       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10082       echo "$as_me:$LINENO: result: yes" >&5
10083 echo "${ECHO_T}yes" >&6
10084       break
10085     else
10086       echo "$as_me:$LINENO: result: no" >&5
10087 echo "${ECHO_T}no" >&6
10088     fi
10089   done
10090 fi
10091
10092 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10093   for ncn_progname in nm; do
10094     if test -n "$ncn_target_tool_prefix"; then
10095       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10096 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10097 echo "$as_me:$LINENO: checking for $ac_word" >&5
10098 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10099 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10100   echo $ECHO_N "(cached) $ECHO_C" >&6
10101 else
10102   if test -n "$NM_FOR_TARGET"; then
10103   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10104 else
10105 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10106 for as_dir in $PATH
10107 do
10108   IFS=$as_save_IFS
10109   test -z "$as_dir" && as_dir=.
10110   for ac_exec_ext in '' $ac_executable_extensions; do
10111   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10112     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10113     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10114     break 2
10115   fi
10116 done
10117 done
10118
10119 fi
10120 fi
10121 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10122 if test -n "$NM_FOR_TARGET"; then
10123   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10124 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10125 else
10126   echo "$as_me:$LINENO: result: no" >&5
10127 echo "${ECHO_T}no" >&6
10128 fi
10129
10130     fi
10131     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10132       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10133 set dummy ${ncn_progname}; ac_word=$2
10134 echo "$as_me:$LINENO: checking for $ac_word" >&5
10135 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10136 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10137   echo $ECHO_N "(cached) $ECHO_C" >&6
10138 else
10139   if test -n "$NM_FOR_TARGET"; then
10140   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10141 else
10142 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10143 for as_dir in $PATH
10144 do
10145   IFS=$as_save_IFS
10146   test -z "$as_dir" && as_dir=.
10147   for ac_exec_ext in '' $ac_executable_extensions; do
10148   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10149     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10150     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10151     break 2
10152   fi
10153 done
10154 done
10155
10156 fi
10157 fi
10158 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10159 if test -n "$NM_FOR_TARGET"; then
10160   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10161 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10162 else
10163   echo "$as_me:$LINENO: result: no" >&5
10164 echo "${ECHO_T}no" >&6
10165 fi
10166
10167     fi
10168     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10169   done
10170 fi
10171
10172 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10173   set dummy nm
10174   if test $build = $target ; then
10175     NM_FOR_TARGET="$2"
10176   else
10177     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10178   fi
10179 else
10180   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10181 fi
10182
10183 else
10184   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10185 fi
10186
10187
10188
10189
10190 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10191   if test -n "$with_build_time_tools"; then
10192     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10193 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10194     if test -x $with_build_time_tools/objdump; then
10195       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10196       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10197       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10198 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10199     else
10200       echo "$as_me:$LINENO: result: no" >&5
10201 echo "${ECHO_T}no" >&6
10202     fi
10203   elif test $build != $host && test $have_gcc_for_target = yes; then
10204     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10205     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10206     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10207   fi
10208 fi
10209 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10210   # Extract the first word of "objdump", so it can be a program name with args.
10211 set dummy objdump; ac_word=$2
10212 echo "$as_me:$LINENO: checking for $ac_word" >&5
10213 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10214 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10215   echo $ECHO_N "(cached) $ECHO_C" >&6
10216 else
10217   case $OBJDUMP_FOR_TARGET in
10218   [\\/]* | ?:[\\/]*)
10219   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10220   ;;
10221   *)
10222   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10223 for as_dir in $gcc_cv_tool_dirs
10224 do
10225   IFS=$as_save_IFS
10226   test -z "$as_dir" && as_dir=.
10227   for ac_exec_ext in '' $ac_executable_extensions; do
10228   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10229     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10230     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10231     break 2
10232   fi
10233 done
10234 done
10235
10236   ;;
10237 esac
10238 fi
10239 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10240
10241 if test -n "$OBJDUMP_FOR_TARGET"; then
10242   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10243 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10244 else
10245   echo "$as_me:$LINENO: result: no" >&5
10246 echo "${ECHO_T}no" >&6
10247 fi
10248
10249 fi
10250 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10251
10252
10253 if test -n "$OBJDUMP_FOR_TARGET"; then
10254   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10255 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10256   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10257 fi
10258
10259 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10260   for ncn_progname in objdump; do
10261     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10262 set dummy ${ncn_progname}; ac_word=$2
10263 echo "$as_me:$LINENO: checking for $ac_word" >&5
10264 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10265 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10266   echo $ECHO_N "(cached) $ECHO_C" >&6
10267 else
10268   if test -n "$OBJDUMP_FOR_TARGET"; then
10269   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10270 else
10271 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10272 for as_dir in $PATH
10273 do
10274   IFS=$as_save_IFS
10275   test -z "$as_dir" && as_dir=.
10276   for ac_exec_ext in '' $ac_executable_extensions; do
10277   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10278     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10279     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10280     break 2
10281   fi
10282 done
10283 done
10284
10285 fi
10286 fi
10287 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10288 if test -n "$OBJDUMP_FOR_TARGET"; then
10289   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10290 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10291 else
10292   echo "$as_me:$LINENO: result: no" >&5
10293 echo "${ECHO_T}no" >&6
10294 fi
10295
10296   done
10297 fi
10298
10299 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10300   for ncn_progname in objdump; do
10301     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10302 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10303     if test -x $with_build_time_tools/${ncn_progname}; then
10304       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10305       echo "$as_me:$LINENO: result: yes" >&5
10306 echo "${ECHO_T}yes" >&6
10307       break
10308     else
10309       echo "$as_me:$LINENO: result: no" >&5
10310 echo "${ECHO_T}no" >&6
10311     fi
10312   done
10313 fi
10314
10315 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10316   for ncn_progname in objdump; do
10317     if test -n "$ncn_target_tool_prefix"; then
10318       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10319 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10320 echo "$as_me:$LINENO: checking for $ac_word" >&5
10321 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10322 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10323   echo $ECHO_N "(cached) $ECHO_C" >&6
10324 else
10325   if test -n "$OBJDUMP_FOR_TARGET"; then
10326   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10327 else
10328 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10329 for as_dir in $PATH
10330 do
10331   IFS=$as_save_IFS
10332   test -z "$as_dir" && as_dir=.
10333   for ac_exec_ext in '' $ac_executable_extensions; do
10334   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10335     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10336     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10337     break 2
10338   fi
10339 done
10340 done
10341
10342 fi
10343 fi
10344 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10345 if test -n "$OBJDUMP_FOR_TARGET"; then
10346   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10347 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10348 else
10349   echo "$as_me:$LINENO: result: no" >&5
10350 echo "${ECHO_T}no" >&6
10351 fi
10352
10353     fi
10354     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10355       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10356 set dummy ${ncn_progname}; ac_word=$2
10357 echo "$as_me:$LINENO: checking for $ac_word" >&5
10358 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10359 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10360   echo $ECHO_N "(cached) $ECHO_C" >&6
10361 else
10362   if test -n "$OBJDUMP_FOR_TARGET"; then
10363   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10364 else
10365 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10366 for as_dir in $PATH
10367 do
10368   IFS=$as_save_IFS
10369   test -z "$as_dir" && as_dir=.
10370   for ac_exec_ext in '' $ac_executable_extensions; do
10371   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10372     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10373     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10374     break 2
10375   fi
10376 done
10377 done
10378
10379 fi
10380 fi
10381 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10382 if test -n "$OBJDUMP_FOR_TARGET"; then
10383   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10384 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10385 else
10386   echo "$as_me:$LINENO: result: no" >&5
10387 echo "${ECHO_T}no" >&6
10388 fi
10389
10390     fi
10391     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10392   done
10393 fi
10394
10395 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10396   set dummy objdump
10397   if test $build = $target ; then
10398     OBJDUMP_FOR_TARGET="$2"
10399   else
10400     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10401   fi
10402 else
10403   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10404 fi
10405
10406 else
10407   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10408 fi
10409
10410
10411
10412
10413 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10414   if test -n "$with_build_time_tools"; then
10415     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10416 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10417     if test -x $with_build_time_tools/ranlib; then
10418       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10419       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10420       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10421 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10422     else
10423       echo "$as_me:$LINENO: result: no" >&5
10424 echo "${ECHO_T}no" >&6
10425     fi
10426   elif test $build != $host && test $have_gcc_for_target = yes; then
10427     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10428     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10429     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10430   fi
10431 fi
10432 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10433   # Extract the first word of "ranlib", so it can be a program name with args.
10434 set dummy ranlib; ac_word=$2
10435 echo "$as_me:$LINENO: checking for $ac_word" >&5
10436 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10437 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10438   echo $ECHO_N "(cached) $ECHO_C" >&6
10439 else
10440   case $RANLIB_FOR_TARGET in
10441   [\\/]* | ?:[\\/]*)
10442   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10443   ;;
10444   *)
10445   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10446 for as_dir in $gcc_cv_tool_dirs
10447 do
10448   IFS=$as_save_IFS
10449   test -z "$as_dir" && as_dir=.
10450   for ac_exec_ext in '' $ac_executable_extensions; do
10451   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10452     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10453     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10454     break 2
10455   fi
10456 done
10457 done
10458
10459   ;;
10460 esac
10461 fi
10462 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10463
10464 if test -n "$RANLIB_FOR_TARGET"; then
10465   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10466 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10467 else
10468   echo "$as_me:$LINENO: result: no" >&5
10469 echo "${ECHO_T}no" >&6
10470 fi
10471
10472 fi
10473 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10474
10475
10476 if test -n "$RANLIB_FOR_TARGET"; then
10477   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10478 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10479   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10480 fi
10481
10482 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10483   for ncn_progname in ranlib; do
10484     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10485 set dummy ${ncn_progname}; ac_word=$2
10486 echo "$as_me:$LINENO: checking for $ac_word" >&5
10487 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10488 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10489   echo $ECHO_N "(cached) $ECHO_C" >&6
10490 else
10491   if test -n "$RANLIB_FOR_TARGET"; then
10492   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10493 else
10494 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10495 for as_dir in $PATH
10496 do
10497   IFS=$as_save_IFS
10498   test -z "$as_dir" && as_dir=.
10499   for ac_exec_ext in '' $ac_executable_extensions; do
10500   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10501     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10502     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10503     break 2
10504   fi
10505 done
10506 done
10507
10508 fi
10509 fi
10510 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10511 if test -n "$RANLIB_FOR_TARGET"; then
10512   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10513 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10514 else
10515   echo "$as_me:$LINENO: result: no" >&5
10516 echo "${ECHO_T}no" >&6
10517 fi
10518
10519   done
10520 fi
10521
10522 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10523   for ncn_progname in ranlib; do
10524     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10525 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10526     if test -x $with_build_time_tools/${ncn_progname}; then
10527       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10528       echo "$as_me:$LINENO: result: yes" >&5
10529 echo "${ECHO_T}yes" >&6
10530       break
10531     else
10532       echo "$as_me:$LINENO: result: no" >&5
10533 echo "${ECHO_T}no" >&6
10534     fi
10535   done
10536 fi
10537
10538 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10539   for ncn_progname in ranlib; do
10540     if test -n "$ncn_target_tool_prefix"; then
10541       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10542 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10543 echo "$as_me:$LINENO: checking for $ac_word" >&5
10544 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10545 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10546   echo $ECHO_N "(cached) $ECHO_C" >&6
10547 else
10548   if test -n "$RANLIB_FOR_TARGET"; then
10549   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10550 else
10551 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10552 for as_dir in $PATH
10553 do
10554   IFS=$as_save_IFS
10555   test -z "$as_dir" && as_dir=.
10556   for ac_exec_ext in '' $ac_executable_extensions; do
10557   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10558     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10559     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10560     break 2
10561   fi
10562 done
10563 done
10564
10565 fi
10566 fi
10567 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10568 if test -n "$RANLIB_FOR_TARGET"; then
10569   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10570 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10571 else
10572   echo "$as_me:$LINENO: result: no" >&5
10573 echo "${ECHO_T}no" >&6
10574 fi
10575
10576     fi
10577     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10578       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10579 set dummy ${ncn_progname}; ac_word=$2
10580 echo "$as_me:$LINENO: checking for $ac_word" >&5
10581 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10582 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10583   echo $ECHO_N "(cached) $ECHO_C" >&6
10584 else
10585   if test -n "$RANLIB_FOR_TARGET"; then
10586   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10587 else
10588 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10589 for as_dir in $PATH
10590 do
10591   IFS=$as_save_IFS
10592   test -z "$as_dir" && as_dir=.
10593   for ac_exec_ext in '' $ac_executable_extensions; do
10594   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10595     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10596     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10597     break 2
10598   fi
10599 done
10600 done
10601
10602 fi
10603 fi
10604 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10605 if test -n "$RANLIB_FOR_TARGET"; then
10606   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10607 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10608 else
10609   echo "$as_me:$LINENO: result: no" >&5
10610 echo "${ECHO_T}no" >&6
10611 fi
10612
10613     fi
10614     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10615   done
10616 fi
10617
10618 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10619   set dummy ranlib
10620   if test $build = $target ; then
10621     RANLIB_FOR_TARGET="$2"
10622   else
10623     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10624   fi
10625 else
10626   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10627 fi
10628
10629 else
10630   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10631 fi
10632
10633
10634
10635
10636 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10637   if test -n "$with_build_time_tools"; then
10638     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10639 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10640     if test -x $with_build_time_tools/strip; then
10641       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10642       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10643       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10644 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10645     else
10646       echo "$as_me:$LINENO: result: no" >&5
10647 echo "${ECHO_T}no" >&6
10648     fi
10649   elif test $build != $host && test $have_gcc_for_target = yes; then
10650     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10651     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10652     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10653   fi
10654 fi
10655 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10656   # Extract the first word of "strip", so it can be a program name with args.
10657 set dummy strip; ac_word=$2
10658 echo "$as_me:$LINENO: checking for $ac_word" >&5
10659 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10660 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10661   echo $ECHO_N "(cached) $ECHO_C" >&6
10662 else
10663   case $STRIP_FOR_TARGET in
10664   [\\/]* | ?:[\\/]*)
10665   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10666   ;;
10667   *)
10668   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10669 for as_dir in $gcc_cv_tool_dirs
10670 do
10671   IFS=$as_save_IFS
10672   test -z "$as_dir" && as_dir=.
10673   for ac_exec_ext in '' $ac_executable_extensions; do
10674   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10675     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10676     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10677     break 2
10678   fi
10679 done
10680 done
10681
10682   ;;
10683 esac
10684 fi
10685 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10686
10687 if test -n "$STRIP_FOR_TARGET"; then
10688   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10689 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10690 else
10691   echo "$as_me:$LINENO: result: no" >&5
10692 echo "${ECHO_T}no" >&6
10693 fi
10694
10695 fi
10696 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10697
10698
10699 if test -n "$STRIP_FOR_TARGET"; then
10700   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10701 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10702   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10703 fi
10704
10705 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10706   for ncn_progname in strip; do
10707     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10708 set dummy ${ncn_progname}; ac_word=$2
10709 echo "$as_me:$LINENO: checking for $ac_word" >&5
10710 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10711 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10712   echo $ECHO_N "(cached) $ECHO_C" >&6
10713 else
10714   if test -n "$STRIP_FOR_TARGET"; then
10715   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10716 else
10717 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10718 for as_dir in $PATH
10719 do
10720   IFS=$as_save_IFS
10721   test -z "$as_dir" && as_dir=.
10722   for ac_exec_ext in '' $ac_executable_extensions; do
10723   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10724     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10725     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10726     break 2
10727   fi
10728 done
10729 done
10730
10731 fi
10732 fi
10733 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10734 if test -n "$STRIP_FOR_TARGET"; then
10735   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10736 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10737 else
10738   echo "$as_me:$LINENO: result: no" >&5
10739 echo "${ECHO_T}no" >&6
10740 fi
10741
10742   done
10743 fi
10744
10745 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10746   for ncn_progname in strip; do
10747     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10748 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10749     if test -x $with_build_time_tools/${ncn_progname}; then
10750       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10751       echo "$as_me:$LINENO: result: yes" >&5
10752 echo "${ECHO_T}yes" >&6
10753       break
10754     else
10755       echo "$as_me:$LINENO: result: no" >&5
10756 echo "${ECHO_T}no" >&6
10757     fi
10758   done
10759 fi
10760
10761 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10762   for ncn_progname in strip; do
10763     if test -n "$ncn_target_tool_prefix"; then
10764       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10765 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10766 echo "$as_me:$LINENO: checking for $ac_word" >&5
10767 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10768 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10769   echo $ECHO_N "(cached) $ECHO_C" >&6
10770 else
10771   if test -n "$STRIP_FOR_TARGET"; then
10772   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10773 else
10774 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10775 for as_dir in $PATH
10776 do
10777   IFS=$as_save_IFS
10778   test -z "$as_dir" && as_dir=.
10779   for ac_exec_ext in '' $ac_executable_extensions; do
10780   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10781     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10782     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10783     break 2
10784   fi
10785 done
10786 done
10787
10788 fi
10789 fi
10790 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10791 if test -n "$STRIP_FOR_TARGET"; then
10792   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10793 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10794 else
10795   echo "$as_me:$LINENO: result: no" >&5
10796 echo "${ECHO_T}no" >&6
10797 fi
10798
10799     fi
10800     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10801       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10802 set dummy ${ncn_progname}; ac_word=$2
10803 echo "$as_me:$LINENO: checking for $ac_word" >&5
10804 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10805 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10806   echo $ECHO_N "(cached) $ECHO_C" >&6
10807 else
10808   if test -n "$STRIP_FOR_TARGET"; then
10809   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10810 else
10811 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10812 for as_dir in $PATH
10813 do
10814   IFS=$as_save_IFS
10815   test -z "$as_dir" && as_dir=.
10816   for ac_exec_ext in '' $ac_executable_extensions; do
10817   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10818     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10819     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10820     break 2
10821   fi
10822 done
10823 done
10824
10825 fi
10826 fi
10827 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10828 if test -n "$STRIP_FOR_TARGET"; then
10829   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10830 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10831 else
10832   echo "$as_me:$LINENO: result: no" >&5
10833 echo "${ECHO_T}no" >&6
10834 fi
10835
10836     fi
10837     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10838   done
10839 fi
10840
10841 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10842   set dummy strip
10843   if test $build = $target ; then
10844     STRIP_FOR_TARGET="$2"
10845   else
10846     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10847   fi
10848 else
10849   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10850 fi
10851
10852 else
10853   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10854 fi
10855
10856
10857
10858
10859 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10860   if test -n "$with_build_time_tools"; then
10861     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10862 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10863     if test -x $with_build_time_tools/windres; then
10864       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10865       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10866       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10867 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10868     else
10869       echo "$as_me:$LINENO: result: no" >&5
10870 echo "${ECHO_T}no" >&6
10871     fi
10872   elif test $build != $host && test $have_gcc_for_target = yes; then
10873     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10874     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10875     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10876   fi
10877 fi
10878 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10879   # Extract the first word of "windres", so it can be a program name with args.
10880 set dummy windres; ac_word=$2
10881 echo "$as_me:$LINENO: checking for $ac_word" >&5
10882 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10883 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10884   echo $ECHO_N "(cached) $ECHO_C" >&6
10885 else
10886   case $WINDRES_FOR_TARGET in
10887   [\\/]* | ?:[\\/]*)
10888   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10889   ;;
10890   *)
10891   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10892 for as_dir in $gcc_cv_tool_dirs
10893 do
10894   IFS=$as_save_IFS
10895   test -z "$as_dir" && as_dir=.
10896   for ac_exec_ext in '' $ac_executable_extensions; do
10897   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10898     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10899     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10900     break 2
10901   fi
10902 done
10903 done
10904
10905   ;;
10906 esac
10907 fi
10908 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10909
10910 if test -n "$WINDRES_FOR_TARGET"; then
10911   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10912 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10913 else
10914   echo "$as_me:$LINENO: result: no" >&5
10915 echo "${ECHO_T}no" >&6
10916 fi
10917
10918 fi
10919 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10920
10921
10922 if test -n "$WINDRES_FOR_TARGET"; then
10923   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10924 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10925   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10926 fi
10927
10928 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10929   for ncn_progname in windres; do
10930     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10931 set dummy ${ncn_progname}; ac_word=$2
10932 echo "$as_me:$LINENO: checking for $ac_word" >&5
10933 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10934 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10935   echo $ECHO_N "(cached) $ECHO_C" >&6
10936 else
10937   if test -n "$WINDRES_FOR_TARGET"; then
10938   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10939 else
10940 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10941 for as_dir in $PATH
10942 do
10943   IFS=$as_save_IFS
10944   test -z "$as_dir" && as_dir=.
10945   for ac_exec_ext in '' $ac_executable_extensions; do
10946   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10947     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10948     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10949     break 2
10950   fi
10951 done
10952 done
10953
10954 fi
10955 fi
10956 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10957 if test -n "$WINDRES_FOR_TARGET"; then
10958   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10959 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10960 else
10961   echo "$as_me:$LINENO: result: no" >&5
10962 echo "${ECHO_T}no" >&6
10963 fi
10964
10965   done
10966 fi
10967
10968 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10969   for ncn_progname in windres; do
10970     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10971 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10972     if test -x $with_build_time_tools/${ncn_progname}; then
10973       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10974       echo "$as_me:$LINENO: result: yes" >&5
10975 echo "${ECHO_T}yes" >&6
10976       break
10977     else
10978       echo "$as_me:$LINENO: result: no" >&5
10979 echo "${ECHO_T}no" >&6
10980     fi
10981   done
10982 fi
10983
10984 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10985   for ncn_progname in windres; do
10986     if test -n "$ncn_target_tool_prefix"; then
10987       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10988 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10989 echo "$as_me:$LINENO: checking for $ac_word" >&5
10990 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10991 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10992   echo $ECHO_N "(cached) $ECHO_C" >&6
10993 else
10994   if test -n "$WINDRES_FOR_TARGET"; then
10995   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10996 else
10997 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10998 for as_dir in $PATH
10999 do
11000   IFS=$as_save_IFS
11001   test -z "$as_dir" && as_dir=.
11002   for ac_exec_ext in '' $ac_executable_extensions; do
11003   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11004     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11005     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11006     break 2
11007   fi
11008 done
11009 done
11010
11011 fi
11012 fi
11013 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11014 if test -n "$WINDRES_FOR_TARGET"; then
11015   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11016 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11017 else
11018   echo "$as_me:$LINENO: result: no" >&5
11019 echo "${ECHO_T}no" >&6
11020 fi
11021
11022     fi
11023     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11024       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11025 set dummy ${ncn_progname}; ac_word=$2
11026 echo "$as_me:$LINENO: checking for $ac_word" >&5
11027 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11028 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11029   echo $ECHO_N "(cached) $ECHO_C" >&6
11030 else
11031   if test -n "$WINDRES_FOR_TARGET"; then
11032   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11033 else
11034 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11035 for as_dir in $PATH
11036 do
11037   IFS=$as_save_IFS
11038   test -z "$as_dir" && as_dir=.
11039   for ac_exec_ext in '' $ac_executable_extensions; do
11040   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11041     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11042     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11043     break 2
11044   fi
11045 done
11046 done
11047
11048 fi
11049 fi
11050 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11051 if test -n "$WINDRES_FOR_TARGET"; then
11052   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11053 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11054 else
11055   echo "$as_me:$LINENO: result: no" >&5
11056 echo "${ECHO_T}no" >&6
11057 fi
11058
11059     fi
11060     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11061   done
11062 fi
11063
11064 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11065   set dummy windres
11066   if test $build = $target ; then
11067     WINDRES_FOR_TARGET="$2"
11068   else
11069     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11070   fi
11071 else
11072   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11073 fi
11074
11075 else
11076   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11077 fi
11078
11079
11080
11081
11082 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11083   if test -n "$with_build_time_tools"; then
11084     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11085 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11086     if test -x $with_build_time_tools/windmc; then
11087       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11088       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11089       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11090 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11091     else
11092       echo "$as_me:$LINENO: result: no" >&5
11093 echo "${ECHO_T}no" >&6
11094     fi
11095   elif test $build != $host && test $have_gcc_for_target = yes; then
11096     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11097     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11098     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11099   fi
11100 fi
11101 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11102   # Extract the first word of "windmc", so it can be a program name with args.
11103 set dummy windmc; ac_word=$2
11104 echo "$as_me:$LINENO: checking for $ac_word" >&5
11105 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11106 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11107   echo $ECHO_N "(cached) $ECHO_C" >&6
11108 else
11109   case $WINDMC_FOR_TARGET in
11110   [\\/]* | ?:[\\/]*)
11111   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11112   ;;
11113   *)
11114   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11115 for as_dir in $gcc_cv_tool_dirs
11116 do
11117   IFS=$as_save_IFS
11118   test -z "$as_dir" && as_dir=.
11119   for ac_exec_ext in '' $ac_executable_extensions; do
11120   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11121     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11122     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11123     break 2
11124   fi
11125 done
11126 done
11127
11128   ;;
11129 esac
11130 fi
11131 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11132
11133 if test -n "$WINDMC_FOR_TARGET"; then
11134   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11135 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11136 else
11137   echo "$as_me:$LINENO: result: no" >&5
11138 echo "${ECHO_T}no" >&6
11139 fi
11140
11141 fi
11142 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11143
11144
11145 if test -n "$WINDMC_FOR_TARGET"; then
11146   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11147 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11148   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11149 fi
11150
11151 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11152   for ncn_progname in windmc; do
11153     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11154 set dummy ${ncn_progname}; ac_word=$2
11155 echo "$as_me:$LINENO: checking for $ac_word" >&5
11156 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11157 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11158   echo $ECHO_N "(cached) $ECHO_C" >&6
11159 else
11160   if test -n "$WINDMC_FOR_TARGET"; then
11161   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11162 else
11163 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11164 for as_dir in $PATH
11165 do
11166   IFS=$as_save_IFS
11167   test -z "$as_dir" && as_dir=.
11168   for ac_exec_ext in '' $ac_executable_extensions; do
11169   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11170     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11171     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11172     break 2
11173   fi
11174 done
11175 done
11176
11177 fi
11178 fi
11179 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11180 if test -n "$WINDMC_FOR_TARGET"; then
11181   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11182 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11183 else
11184   echo "$as_me:$LINENO: result: no" >&5
11185 echo "${ECHO_T}no" >&6
11186 fi
11187
11188   done
11189 fi
11190
11191 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11192   for ncn_progname in windmc; do
11193     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11194 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11195     if test -x $with_build_time_tools/${ncn_progname}; then
11196       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11197       echo "$as_me:$LINENO: result: yes" >&5
11198 echo "${ECHO_T}yes" >&6
11199       break
11200     else
11201       echo "$as_me:$LINENO: result: no" >&5
11202 echo "${ECHO_T}no" >&6
11203     fi
11204   done
11205 fi
11206
11207 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11208   for ncn_progname in windmc; do
11209     if test -n "$ncn_target_tool_prefix"; then
11210       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11211 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11212 echo "$as_me:$LINENO: checking for $ac_word" >&5
11213 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11214 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11215   echo $ECHO_N "(cached) $ECHO_C" >&6
11216 else
11217   if test -n "$WINDMC_FOR_TARGET"; then
11218   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11219 else
11220 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11221 for as_dir in $PATH
11222 do
11223   IFS=$as_save_IFS
11224   test -z "$as_dir" && as_dir=.
11225   for ac_exec_ext in '' $ac_executable_extensions; do
11226   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11227     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11228     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11229     break 2
11230   fi
11231 done
11232 done
11233
11234 fi
11235 fi
11236 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11237 if test -n "$WINDMC_FOR_TARGET"; then
11238   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11239 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11240 else
11241   echo "$as_me:$LINENO: result: no" >&5
11242 echo "${ECHO_T}no" >&6
11243 fi
11244
11245     fi
11246     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11247       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11248 set dummy ${ncn_progname}; ac_word=$2
11249 echo "$as_me:$LINENO: checking for $ac_word" >&5
11250 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11251 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11252   echo $ECHO_N "(cached) $ECHO_C" >&6
11253 else
11254   if test -n "$WINDMC_FOR_TARGET"; then
11255   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11256 else
11257 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11258 for as_dir in $PATH
11259 do
11260   IFS=$as_save_IFS
11261   test -z "$as_dir" && as_dir=.
11262   for ac_exec_ext in '' $ac_executable_extensions; do
11263   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11264     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11265     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11266     break 2
11267   fi
11268 done
11269 done
11270
11271 fi
11272 fi
11273 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11274 if test -n "$WINDMC_FOR_TARGET"; then
11275   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11276 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11277 else
11278   echo "$as_me:$LINENO: result: no" >&5
11279 echo "${ECHO_T}no" >&6
11280 fi
11281
11282     fi
11283     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11284   done
11285 fi
11286
11287 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11288   set dummy windmc
11289   if test $build = $target ; then
11290     WINDMC_FOR_TARGET="$2"
11291   else
11292     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11293   fi
11294 else
11295   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11296 fi
11297
11298 else
11299   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11300 fi
11301
11302
11303 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11304
11305 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11306 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11307 if test "x${build}" != "x${host}" ; then
11308   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11309     # We already found the complete path
11310     ac_dir=`dirname $AR_FOR_TARGET`
11311     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11312 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11313   else
11314     # Canadian cross, just use what we found
11315     echo "$as_me:$LINENO: result: pre-installed" >&5
11316 echo "${ECHO_T}pre-installed" >&6
11317   fi
11318 else
11319   ok=yes
11320   case " ${configdirs} " in
11321     *" binutils "*) ;;
11322     *) ok=no ;;
11323   esac
11324
11325   if test $ok = yes; then
11326     # An in-tree tool is available and we can use it
11327     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11328     echo "$as_me:$LINENO: result: just compiled" >&5
11329 echo "${ECHO_T}just compiled" >&6
11330   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11331     # We already found the complete path
11332     ac_dir=`dirname $AR_FOR_TARGET`
11333     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11334 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11335   elif test "x$target" = "x$host"; then
11336     # We can use an host tool
11337     AR_FOR_TARGET='$(AR)'
11338     echo "$as_me:$LINENO: result: host tool" >&5
11339 echo "${ECHO_T}host tool" >&6
11340   else
11341     # We need a cross tool
11342     echo "$as_me:$LINENO: result: pre-installed" >&5
11343 echo "${ECHO_T}pre-installed" >&6
11344   fi
11345 fi
11346
11347 echo "$as_me:$LINENO: checking where to find the target as" >&5
11348 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11349 if test "x${build}" != "x${host}" ; then
11350   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11351     # We already found the complete path
11352     ac_dir=`dirname $AS_FOR_TARGET`
11353     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11354 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11355   else
11356     # Canadian cross, just use what we found
11357     echo "$as_me:$LINENO: result: pre-installed" >&5
11358 echo "${ECHO_T}pre-installed" >&6
11359   fi
11360 else
11361   ok=yes
11362   case " ${configdirs} " in
11363     *" gas "*) ;;
11364     *) ok=no ;;
11365   esac
11366
11367   if test $ok = yes; then
11368     # An in-tree tool is available and we can use it
11369     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11370     echo "$as_me:$LINENO: result: just compiled" >&5
11371 echo "${ECHO_T}just compiled" >&6
11372   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11373     # We already found the complete path
11374     ac_dir=`dirname $AS_FOR_TARGET`
11375     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11376 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11377   elif test "x$target" = "x$host"; then
11378     # We can use an host tool
11379     AS_FOR_TARGET='$(AS)'
11380     echo "$as_me:$LINENO: result: host tool" >&5
11381 echo "${ECHO_T}host tool" >&6
11382   else
11383     # We need a cross tool
11384     echo "$as_me:$LINENO: result: pre-installed" >&5
11385 echo "${ECHO_T}pre-installed" >&6
11386   fi
11387 fi
11388
11389 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11390 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11391 if test "x${build}" != "x${host}" ; then
11392   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11393     # We already found the complete path
11394     ac_dir=`dirname $CC_FOR_TARGET`
11395     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11396 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11397   else
11398     # Canadian cross, just use what we found
11399     echo "$as_me:$LINENO: result: pre-installed" >&5
11400 echo "${ECHO_T}pre-installed" >&6
11401   fi
11402 else
11403   ok=yes
11404   case " ${configdirs} " in
11405     *" gcc "*) ;;
11406     *) ok=no ;;
11407   esac
11408
11409   if test $ok = yes; then
11410     # An in-tree tool is available and we can use it
11411     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11412     echo "$as_me:$LINENO: result: just compiled" >&5
11413 echo "${ECHO_T}just compiled" >&6
11414   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11415     # We already found the complete path
11416     ac_dir=`dirname $CC_FOR_TARGET`
11417     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11418 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11419   elif test "x$target" = "x$host"; then
11420     # We can use an host tool
11421     CC_FOR_TARGET='$(CC)'
11422     echo "$as_me:$LINENO: result: host tool" >&5
11423 echo "${ECHO_T}host tool" >&6
11424   else
11425     # We need a cross tool
11426     echo "$as_me:$LINENO: result: pre-installed" >&5
11427 echo "${ECHO_T}pre-installed" >&6
11428   fi
11429 fi
11430
11431 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11432 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11433 if test "x${build}" != "x${host}" ; then
11434   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11435     # We already found the complete path
11436     ac_dir=`dirname $CXX_FOR_TARGET`
11437     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11438 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11439   else
11440     # Canadian cross, just use what we found
11441     echo "$as_me:$LINENO: result: pre-installed" >&5
11442 echo "${ECHO_T}pre-installed" >&6
11443   fi
11444 else
11445   ok=yes
11446   case " ${configdirs} " in
11447     *" gcc "*) ;;
11448     *) ok=no ;;
11449   esac
11450   case ,${enable_languages}, in
11451     *,c++,*) ;;
11452     *) ok=no ;;
11453   esac
11454   if test $ok = yes; then
11455     # An in-tree tool is available and we can use it
11456     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'
11457     echo "$as_me:$LINENO: result: just compiled" >&5
11458 echo "${ECHO_T}just compiled" >&6
11459   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11460     # We already found the complete path
11461     ac_dir=`dirname $CXX_FOR_TARGET`
11462     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11463 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11464   elif test "x$target" = "x$host"; then
11465     # We can use an host tool
11466     CXX_FOR_TARGET='$(CXX)'
11467     echo "$as_me:$LINENO: result: host tool" >&5
11468 echo "${ECHO_T}host tool" >&6
11469   else
11470     # We need a cross tool
11471     echo "$as_me:$LINENO: result: pre-installed" >&5
11472 echo "${ECHO_T}pre-installed" >&6
11473   fi
11474 fi
11475
11476 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11477 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11478 if test "x${build}" != "x${host}" ; then
11479   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11480     # We already found the complete path
11481     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11482     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11483 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11484   else
11485     # Canadian cross, just use what we found
11486     echo "$as_me:$LINENO: result: pre-installed" >&5
11487 echo "${ECHO_T}pre-installed" >&6
11488   fi
11489 else
11490   ok=yes
11491   case " ${configdirs} " in
11492     *" gcc "*) ;;
11493     *) ok=no ;;
11494   esac
11495   case ,${enable_languages}, in
11496     *,c++,*) ;;
11497     *) ok=no ;;
11498   esac
11499   if test $ok = yes; then
11500     # An in-tree tool is available and we can use it
11501     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'
11502     echo "$as_me:$LINENO: result: just compiled" >&5
11503 echo "${ECHO_T}just compiled" >&6
11504   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11505     # We already found the complete path
11506     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11507     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11508 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11509   elif test "x$target" = "x$host"; then
11510     # We can use an host tool
11511     RAW_CXX_FOR_TARGET='$(CXX)'
11512     echo "$as_me:$LINENO: result: host tool" >&5
11513 echo "${ECHO_T}host tool" >&6
11514   else
11515     # We need a cross tool
11516     echo "$as_me:$LINENO: result: pre-installed" >&5
11517 echo "${ECHO_T}pre-installed" >&6
11518   fi
11519 fi
11520
11521 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11522 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11523 if test "x${build}" != "x${host}" ; then
11524   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11525     # We already found the complete path
11526     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11527     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11528 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11529   else
11530     # Canadian cross, just use what we found
11531     echo "$as_me:$LINENO: result: pre-installed" >&5
11532 echo "${ECHO_T}pre-installed" >&6
11533   fi
11534 else
11535   ok=yes
11536   case " ${configdirs} " in
11537     *" binutils "*) ;;
11538     *) ok=no ;;
11539   esac
11540
11541   if test $ok = yes; then
11542     # An in-tree tool is available and we can use it
11543     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11544     echo "$as_me:$LINENO: result: just compiled" >&5
11545 echo "${ECHO_T}just compiled" >&6
11546   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11547     # We already found the complete path
11548     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11549     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11550 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11551   elif test "x$target" = "x$host"; then
11552     # We can use an host tool
11553     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11554     echo "$as_me:$LINENO: result: host tool" >&5
11555 echo "${ECHO_T}host tool" >&6
11556   else
11557     # We need a cross tool
11558     echo "$as_me:$LINENO: result: pre-installed" >&5
11559 echo "${ECHO_T}pre-installed" >&6
11560   fi
11561 fi
11562
11563 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11564 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11565 if test "x${build}" != "x${host}" ; then
11566   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11567     # We already found the complete path
11568     ac_dir=`dirname $GCC_FOR_TARGET`
11569     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11570 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11571   else
11572     # Canadian cross, just use what we found
11573     echo "$as_me:$LINENO: result: pre-installed" >&5
11574 echo "${ECHO_T}pre-installed" >&6
11575   fi
11576 else
11577   ok=yes
11578   case " ${configdirs} " in
11579     *" gcc "*) ;;
11580     *) ok=no ;;
11581   esac
11582
11583   if test $ok = yes; then
11584     # An in-tree tool is available and we can use it
11585     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11586     echo "$as_me:$LINENO: result: just compiled" >&5
11587 echo "${ECHO_T}just compiled" >&6
11588   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11589     # We already found the complete path
11590     ac_dir=`dirname $GCC_FOR_TARGET`
11591     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11592 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11593   elif test "x$target" = "x$host"; then
11594     # We can use an host tool
11595     GCC_FOR_TARGET='$()'
11596     echo "$as_me:$LINENO: result: host tool" >&5
11597 echo "${ECHO_T}host tool" >&6
11598   else
11599     # We need a cross tool
11600     echo "$as_me:$LINENO: result: pre-installed" >&5
11601 echo "${ECHO_T}pre-installed" >&6
11602   fi
11603 fi
11604
11605 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11606 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11607 if test "x${build}" != "x${host}" ; then
11608   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11609     # We already found the complete path
11610     ac_dir=`dirname $GCJ_FOR_TARGET`
11611     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11612 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11613   else
11614     # Canadian cross, just use what we found
11615     echo "$as_me:$LINENO: result: pre-installed" >&5
11616 echo "${ECHO_T}pre-installed" >&6
11617   fi
11618 else
11619   ok=yes
11620   case " ${configdirs} " in
11621     *" gcc "*) ;;
11622     *) ok=no ;;
11623   esac
11624   case ,${enable_languages}, in
11625     *,java,*) ;;
11626     *) ok=no ;;
11627   esac
11628   if test $ok = yes; then
11629     # An in-tree tool is available and we can use it
11630     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11631     echo "$as_me:$LINENO: result: just compiled" >&5
11632 echo "${ECHO_T}just compiled" >&6
11633   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11634     # We already found the complete path
11635     ac_dir=`dirname $GCJ_FOR_TARGET`
11636     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11637 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11638   elif test "x$target" = "x$host"; then
11639     # We can use an host tool
11640     GCJ_FOR_TARGET='$(GCJ)'
11641     echo "$as_me:$LINENO: result: host tool" >&5
11642 echo "${ECHO_T}host tool" >&6
11643   else
11644     # We need a cross tool
11645     echo "$as_me:$LINENO: result: pre-installed" >&5
11646 echo "${ECHO_T}pre-installed" >&6
11647   fi
11648 fi
11649
11650 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11651 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11652 if test "x${build}" != "x${host}" ; then
11653   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11654     # We already found the complete path
11655     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11656     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11657 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11658   else
11659     # Canadian cross, just use what we found
11660     echo "$as_me:$LINENO: result: pre-installed" >&5
11661 echo "${ECHO_T}pre-installed" >&6
11662   fi
11663 else
11664   ok=yes
11665   case " ${configdirs} " in
11666     *" gcc "*) ;;
11667     *) ok=no ;;
11668   esac
11669   case ,${enable_languages}, in
11670     *,fortran,*) ;;
11671     *) ok=no ;;
11672   esac
11673   if test $ok = yes; then
11674     # An in-tree tool is available and we can use it
11675     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11676     echo "$as_me:$LINENO: result: just compiled" >&5
11677 echo "${ECHO_T}just compiled" >&6
11678   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11679     # We already found the complete path
11680     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11681     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11682 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11683   elif test "x$target" = "x$host"; then
11684     # We can use an host tool
11685     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11686     echo "$as_me:$LINENO: result: host tool" >&5
11687 echo "${ECHO_T}host tool" >&6
11688   else
11689     # We need a cross tool
11690     echo "$as_me:$LINENO: result: pre-installed" >&5
11691 echo "${ECHO_T}pre-installed" >&6
11692   fi
11693 fi
11694
11695 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11696 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11697 if test "x${build}" != "x${host}" ; then
11698   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11699     # We already found the complete path
11700     ac_dir=`dirname $LD_FOR_TARGET`
11701     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11702 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11703   else
11704     # Canadian cross, just use what we found
11705     echo "$as_me:$LINENO: result: pre-installed" >&5
11706 echo "${ECHO_T}pre-installed" >&6
11707   fi
11708 else
11709   ok=yes
11710   case " ${configdirs} " in
11711     *" ld "*) ;;
11712     *) ok=no ;;
11713   esac
11714
11715   if test $ok = yes; then
11716     # An in-tree tool is available and we can use it
11717     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11718     echo "$as_me:$LINENO: result: just compiled" >&5
11719 echo "${ECHO_T}just compiled" >&6
11720   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11721     # We already found the complete path
11722     ac_dir=`dirname $LD_FOR_TARGET`
11723     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11724 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11725   elif test "x$target" = "x$host"; then
11726     # We can use an host tool
11727     LD_FOR_TARGET='$(LD)'
11728     echo "$as_me:$LINENO: result: host tool" >&5
11729 echo "${ECHO_T}host tool" >&6
11730   else
11731     # We need a cross tool
11732     echo "$as_me:$LINENO: result: pre-installed" >&5
11733 echo "${ECHO_T}pre-installed" >&6
11734   fi
11735 fi
11736
11737 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11738 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11739 if test "x${build}" != "x${host}" ; then
11740   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11741     # We already found the complete path
11742     ac_dir=`dirname $LIPO_FOR_TARGET`
11743     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11744 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11745   else
11746     # Canadian cross, just use what we found
11747     echo "$as_me:$LINENO: result: pre-installed" >&5
11748 echo "${ECHO_T}pre-installed" >&6
11749   fi
11750 else
11751   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11752     # We already found the complete path
11753     ac_dir=`dirname $LIPO_FOR_TARGET`
11754     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11755 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11756   elif test "x$target" = "x$host"; then
11757     # We can use an host tool
11758     LIPO_FOR_TARGET='$(LIPO)'
11759     echo "$as_me:$LINENO: result: host tool" >&5
11760 echo "${ECHO_T}host tool" >&6
11761   else
11762     # We need a cross tool
11763     echo "$as_me:$LINENO: result: pre-installed" >&5
11764 echo "${ECHO_T}pre-installed" >&6
11765   fi
11766 fi
11767
11768 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11769 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11770 if test "x${build}" != "x${host}" ; then
11771   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11772     # We already found the complete path
11773     ac_dir=`dirname $NM_FOR_TARGET`
11774     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11775 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11776   else
11777     # Canadian cross, just use what we found
11778     echo "$as_me:$LINENO: result: pre-installed" >&5
11779 echo "${ECHO_T}pre-installed" >&6
11780   fi
11781 else
11782   ok=yes
11783   case " ${configdirs} " in
11784     *" binutils "*) ;;
11785     *) ok=no ;;
11786   esac
11787
11788   if test $ok = yes; then
11789     # An in-tree tool is available and we can use it
11790     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11791     echo "$as_me:$LINENO: result: just compiled" >&5
11792 echo "${ECHO_T}just compiled" >&6
11793   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11794     # We already found the complete path
11795     ac_dir=`dirname $NM_FOR_TARGET`
11796     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11797 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11798   elif test "x$target" = "x$host"; then
11799     # We can use an host tool
11800     NM_FOR_TARGET='$(NM)'
11801     echo "$as_me:$LINENO: result: host tool" >&5
11802 echo "${ECHO_T}host tool" >&6
11803   else
11804     # We need a cross tool
11805     echo "$as_me:$LINENO: result: pre-installed" >&5
11806 echo "${ECHO_T}pre-installed" >&6
11807   fi
11808 fi
11809
11810 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11811 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11812 if test "x${build}" != "x${host}" ; then
11813   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11814     # We already found the complete path
11815     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11816     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11817 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11818   else
11819     # Canadian cross, just use what we found
11820     echo "$as_me:$LINENO: result: pre-installed" >&5
11821 echo "${ECHO_T}pre-installed" >&6
11822   fi
11823 else
11824   ok=yes
11825   case " ${configdirs} " in
11826     *" binutils "*) ;;
11827     *) ok=no ;;
11828   esac
11829
11830   if test $ok = yes; then
11831     # An in-tree tool is available and we can use it
11832     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11833     echo "$as_me:$LINENO: result: just compiled" >&5
11834 echo "${ECHO_T}just compiled" >&6
11835   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11836     # We already found the complete path
11837     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11838     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11839 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11840   elif test "x$target" = "x$host"; then
11841     # We can use an host tool
11842     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11843     echo "$as_me:$LINENO: result: host tool" >&5
11844 echo "${ECHO_T}host tool" >&6
11845   else
11846     # We need a cross tool
11847     echo "$as_me:$LINENO: result: pre-installed" >&5
11848 echo "${ECHO_T}pre-installed" >&6
11849   fi
11850 fi
11851
11852 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11853 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11854 if test "x${build}" != "x${host}" ; then
11855   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11856     # We already found the complete path
11857     ac_dir=`dirname $RANLIB_FOR_TARGET`
11858     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11859 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11860   else
11861     # Canadian cross, just use what we found
11862     echo "$as_me:$LINENO: result: pre-installed" >&5
11863 echo "${ECHO_T}pre-installed" >&6
11864   fi
11865 else
11866   ok=yes
11867   case " ${configdirs} " in
11868     *" binutils "*) ;;
11869     *) ok=no ;;
11870   esac
11871
11872   if test $ok = yes; then
11873     # An in-tree tool is available and we can use it
11874     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11875     echo "$as_me:$LINENO: result: just compiled" >&5
11876 echo "${ECHO_T}just compiled" >&6
11877   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11878     # We already found the complete path
11879     ac_dir=`dirname $RANLIB_FOR_TARGET`
11880     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11881 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11882   elif test "x$target" = "x$host"; then
11883     # We can use an host tool
11884     RANLIB_FOR_TARGET='$(RANLIB)'
11885     echo "$as_me:$LINENO: result: host tool" >&5
11886 echo "${ECHO_T}host tool" >&6
11887   else
11888     # We need a cross tool
11889     echo "$as_me:$LINENO: result: pre-installed" >&5
11890 echo "${ECHO_T}pre-installed" >&6
11891   fi
11892 fi
11893
11894 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11895 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11896 if test "x${build}" != "x${host}" ; then
11897   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11898     # We already found the complete path
11899     ac_dir=`dirname $STRIP_FOR_TARGET`
11900     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11901 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11902   else
11903     # Canadian cross, just use what we found
11904     echo "$as_me:$LINENO: result: pre-installed" >&5
11905 echo "${ECHO_T}pre-installed" >&6
11906   fi
11907 else
11908   ok=yes
11909   case " ${configdirs} " in
11910     *" binutils "*) ;;
11911     *) ok=no ;;
11912   esac
11913
11914   if test $ok = yes; then
11915     # An in-tree tool is available and we can use it
11916     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11917     echo "$as_me:$LINENO: result: just compiled" >&5
11918 echo "${ECHO_T}just compiled" >&6
11919   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11920     # We already found the complete path
11921     ac_dir=`dirname $STRIP_FOR_TARGET`
11922     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11923 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11924   elif test "x$target" = "x$host"; then
11925     # We can use an host tool
11926     STRIP_FOR_TARGET='$(STRIP)'
11927     echo "$as_me:$LINENO: result: host tool" >&5
11928 echo "${ECHO_T}host tool" >&6
11929   else
11930     # We need a cross tool
11931     echo "$as_me:$LINENO: result: pre-installed" >&5
11932 echo "${ECHO_T}pre-installed" >&6
11933   fi
11934 fi
11935
11936 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11937 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11938 if test "x${build}" != "x${host}" ; then
11939   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11940     # We already found the complete path
11941     ac_dir=`dirname $WINDRES_FOR_TARGET`
11942     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11943 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11944   else
11945     # Canadian cross, just use what we found
11946     echo "$as_me:$LINENO: result: pre-installed" >&5
11947 echo "${ECHO_T}pre-installed" >&6
11948   fi
11949 else
11950   ok=yes
11951   case " ${configdirs} " in
11952     *" binutils "*) ;;
11953     *) ok=no ;;
11954   esac
11955
11956   if test $ok = yes; then
11957     # An in-tree tool is available and we can use it
11958     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11959     echo "$as_me:$LINENO: result: just compiled" >&5
11960 echo "${ECHO_T}just compiled" >&6
11961   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11962     # We already found the complete path
11963     ac_dir=`dirname $WINDRES_FOR_TARGET`
11964     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11965 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11966   elif test "x$target" = "x$host"; then
11967     # We can use an host tool
11968     WINDRES_FOR_TARGET='$(WINDRES)'
11969     echo "$as_me:$LINENO: result: host tool" >&5
11970 echo "${ECHO_T}host tool" >&6
11971   else
11972     # We need a cross tool
11973     echo "$as_me:$LINENO: result: pre-installed" >&5
11974 echo "${ECHO_T}pre-installed" >&6
11975   fi
11976 fi
11977
11978 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
11979 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
11980 if test "x${build}" != "x${host}" ; then
11981   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11982     # We already found the complete path
11983     ac_dir=`dirname $WINDMC_FOR_TARGET`
11984     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11985 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11986   else
11987     # Canadian cross, just use what we found
11988     echo "$as_me:$LINENO: result: pre-installed" >&5
11989 echo "${ECHO_T}pre-installed" >&6
11990   fi
11991 else
11992   ok=yes
11993   case " ${configdirs} " in
11994     *" binutils "*) ;;
11995     *) ok=no ;;
11996   esac
11997
11998   if test $ok = yes; then
11999     # An in-tree tool is available and we can use it
12000     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12001     echo "$as_me:$LINENO: result: just compiled" >&5
12002 echo "${ECHO_T}just compiled" >&6
12003   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12004     # We already found the complete path
12005     ac_dir=`dirname $WINDMC_FOR_TARGET`
12006     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12007 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12008   elif test "x$target" = "x$host"; then
12009     # We can use an host tool
12010     WINDMC_FOR_TARGET='$(WINDMC)'
12011     echo "$as_me:$LINENO: result: host tool" >&5
12012 echo "${ECHO_T}host tool" >&6
12013   else
12014     # We need a cross tool
12015     echo "$as_me:$LINENO: result: pre-installed" >&5
12016 echo "${ECHO_T}pre-installed" >&6
12017   fi
12018 fi
12019
12020
12021
12022
12023
12024 # Certain tools may need extra flags.
12025 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12026 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12027 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12028
12029 # When building target libraries, except in a Canadian cross, we use
12030 # the same toolchain as the compiler we just built.
12031 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12032 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12033 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12034 if test $host = $build; then
12035   case " $configdirs " in
12036     *" gcc "*)
12037       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12038       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12039       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12040       ;;
12041   esac
12042 fi
12043
12044
12045
12046
12047
12048 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12049 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12050 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12051 if test "${enable_maintainer_mode+set}" = set; then
12052   enableval="$enable_maintainer_mode"
12053   USE_MAINTAINER_MODE=$enableval
12054 else
12055   USE_MAINTAINER_MODE=no
12056 fi;
12057 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12058 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12059
12060
12061 if test "$USE_MAINTAINER_MODE" = yes; then
12062   MAINTAINER_MODE_TRUE=
12063   MAINTAINER_MODE_FALSE='#'
12064 else
12065   MAINTAINER_MODE_TRUE='#'
12066   MAINTAINER_MODE_FALSE=
12067 fi
12068 MAINT=$MAINTAINER_MODE_TRUE
12069
12070 # ---------------------
12071 # GCC bootstrap support
12072 # ---------------------
12073
12074 # Stage specific cflags for build.
12075 stage1_cflags="-g"
12076 case $build in
12077   vax-*-*)
12078     case ${GCC} in
12079       yes) stage1_cflags="-g -Wa,-J" ;;
12080       *) stage1_cflags="-g -J" ;;
12081     esac ;;
12082 esac
12083
12084 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12085 if test "$GCC" = yes; then
12086   saved_CFLAGS="$CFLAGS"
12087
12088   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12089   CFLAGS="$CFLAGS -fkeep-inline-functions"
12090   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12091 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12092   cat >conftest.$ac_ext <<_ACEOF
12093 /* confdefs.h.  */
12094 _ACEOF
12095 cat confdefs.h >>conftest.$ac_ext
12096 cat >>conftest.$ac_ext <<_ACEOF
12097 /* end confdefs.h.  */
12098
12099 #if (__GNUC__ < 3) \
12100     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12101                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12102 #error http://gcc.gnu.org/PR29382
12103 #endif
12104
12105 int
12106 main ()
12107 {
12108
12109   ;
12110   return 0;
12111 }
12112 _ACEOF
12113 rm -f conftest.$ac_objext
12114 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12115   (eval $ac_compile) 2>conftest.er1
12116   ac_status=$?
12117   grep -v '^ *+' conftest.er1 >conftest.err
12118   rm -f conftest.er1
12119   cat conftest.err >&5
12120   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12121   (exit $ac_status); } &&
12122          { ac_try='test -z "$ac_c_werror_flag"
12123                          || test ! -s conftest.err'
12124   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12125   (eval $ac_try) 2>&5
12126   ac_status=$?
12127   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12128   (exit $ac_status); }; } &&
12129          { ac_try='test -s conftest.$ac_objext'
12130   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12131   (eval $ac_try) 2>&5
12132   ac_status=$?
12133   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12134   (exit $ac_status); }; }; then
12135   echo "$as_me:$LINENO: result: yes" >&5
12136 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12137 else
12138   echo "$as_me: failed program was:" >&5
12139 sed 's/^/| /' conftest.$ac_ext >&5
12140
12141 echo "$as_me:$LINENO: result: no" >&5
12142 echo "${ECHO_T}no" >&6
12143 fi
12144 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12145
12146   CFLAGS="$saved_CFLAGS"
12147 fi
12148
12149
12150
12151 # Enable --enable-checking in stage1 of the compiler.
12152 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12153 if test "${enable_stage1_checking+set}" = set; then
12154   enableval="$enable_stage1_checking"
12155   stage1_checking=--enable-checking=${enable_stage1_checking}
12156 else
12157   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12158   stage1_checking=--enable-checking=yes,types
12159 else
12160   stage1_checking=--enable-checking=$enable_checking,types
12161 fi
12162 fi;
12163
12164
12165 # Enable -Werror in bootstrap stage2 and later.
12166 # Check whether --enable-werror or --disable-werror was given.
12167 if test "${enable_werror+set}" = set; then
12168   enableval="$enable_werror"
12169
12170 else
12171   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12172   enable_werror=yes
12173 else
12174   enable_werror=no
12175 fi
12176 fi;
12177 case ${enable_werror} in
12178   yes) stage2_werror_flag="--enable-werror-always" ;;
12179   *) stage2_werror_flag="" ;;
12180 esac
12181
12182
12183 # Flags needed to enable html installing and building
12184
12185 # Check whether --with-datarootdir or --without-datarootdir was given.
12186 if test "${with_datarootdir+set}" = set; then
12187   withval="$with_datarootdir"
12188   datarootdir="\${prefix}/${withval}"
12189 else
12190   datarootdir="\${prefix}/share"
12191 fi;
12192
12193
12194 # Check whether --with-docdir or --without-docdir was given.
12195 if test "${with_docdir+set}" = set; then
12196   withval="$with_docdir"
12197   docdir="\${prefix}/${withval}"
12198 else
12199   docdir="\${datarootdir}/doc"
12200 fi;
12201
12202
12203 # Check whether --with-pdfdir or --without-pdfdir was given.
12204 if test "${with_pdfdir+set}" = set; then
12205   withval="$with_pdfdir"
12206   pdfdir="\${prefix}/${withval}"
12207 else
12208   pdfdir="\${docdir}"
12209 fi;
12210
12211
12212 # Check whether --with-htmldir or --without-htmldir was given.
12213 if test "${with_htmldir+set}" = set; then
12214   withval="$with_htmldir"
12215   htmldir="\${prefix}/${withval}"
12216 else
12217   htmldir="\${docdir}"
12218 fi;
12219
12220
12221
12222
12223
12224
12225           ac_config_files="$ac_config_files Makefile"
12226 cat >confcache <<\_ACEOF
12227 # This file is a shell script that caches the results of configure
12228 # tests run on this system so they can be shared between configure
12229 # scripts and configure runs, see configure's option --config-cache.
12230 # It is not useful on other systems.  If it contains results you don't
12231 # want to keep, you may remove or edit it.
12232 #
12233 # config.status only pays attention to the cache file if you give it
12234 # the --recheck option to rerun configure.
12235 #
12236 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12237 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12238 # following values.
12239
12240 _ACEOF
12241
12242 # The following way of writing the cache mishandles newlines in values,
12243 # but we know of no workaround that is simple, portable, and efficient.
12244 # So, don't put newlines in cache variables' values.
12245 # Ultrix sh set writes to stderr and can't be redirected directly,
12246 # and sets the high bit in the cache file unless we assign to the vars.
12247 {
12248   (set) 2>&1 |
12249     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12250     *ac_space=\ *)
12251       # `set' does not quote correctly, so add quotes (double-quote
12252       # substitution turns \\\\ into \\, and sed turns \\ into \).
12253       sed -n \
12254         "s/'/'\\\\''/g;
12255           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12256       ;;
12257     *)
12258       # `set' quotes correctly as required by POSIX, so do not add quotes.
12259       sed -n \
12260         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12261       ;;
12262     esac;
12263 } |
12264   sed '
12265      t clear
12266      : clear
12267      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12268      t end
12269      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12270      : end' >>confcache
12271 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12272   if test -w $cache_file; then
12273     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12274     cat confcache >$cache_file
12275   else
12276     echo "not updating unwritable cache $cache_file"
12277   fi
12278 fi
12279 rm -f confcache
12280
12281 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12282 # Let make expand exec_prefix.
12283 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12284
12285 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12286 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12287 # trailing colons and then remove the whole line if VPATH becomes empty
12288 # (actually we leave an empty line to preserve line numbers).
12289 if test "x$srcdir" = x.; then
12290   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12291 s/:*\$(srcdir):*/:/;
12292 s/:*\${srcdir}:*/:/;
12293 s/:*@srcdir@:*/:/;
12294 s/^\([^=]*=[     ]*\):*/\1/;
12295 s/:*$//;
12296 s/^[^=]*=[       ]*$//;
12297 }'
12298 fi
12299
12300 # Transform confdefs.h into DEFS.
12301 # Protect against shell expansion while executing Makefile rules.
12302 # Protect against Makefile macro expansion.
12303 #
12304 # If the first sed substitution is executed (which looks for macros that
12305 # take arguments), then we branch to the quote section.  Otherwise,
12306 # look for a macro that doesn't take arguments.
12307 cat >confdef2opt.sed <<\_ACEOF
12308 t clear
12309 : clear
12310 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12311 t quote
12312 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12313 t quote
12314 d
12315 : quote
12316 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12317 s,\[,\\&,g
12318 s,\],\\&,g
12319 s,\$,$$,g
12320 p
12321 _ACEOF
12322 # We use echo to avoid assuming a particular line-breaking character.
12323 # The extra dot is to prevent the shell from consuming trailing
12324 # line-breaks from the sub-command output.  A line-break within
12325 # single-quotes doesn't work because, if this script is created in a
12326 # platform that uses two characters for line-breaks (e.g., DOS), tr
12327 # would break.
12328 ac_LF_and_DOT=`echo; echo .`
12329 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12330 rm -f confdef2opt.sed
12331
12332
12333 ac_libobjs=
12334 ac_ltlibobjs=
12335 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12336   # 1. Remove the extension, and $U if already installed.
12337   ac_i=`echo "$ac_i" |
12338          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12339   # 2. Add them.
12340   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12341   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12342 done
12343 LIBOBJS=$ac_libobjs
12344
12345 LTLIBOBJS=$ac_ltlibobjs
12346
12347
12348
12349 : ${CONFIG_STATUS=./config.status}
12350 ac_clean_files_save=$ac_clean_files
12351 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12352 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12353 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12354 cat >$CONFIG_STATUS <<_ACEOF
12355 #! $SHELL
12356 # Generated by $as_me.
12357 # Run this file to recreate the current configuration.
12358 # Compiler output produced by configure, useful for debugging
12359 # configure, is in config.log if it exists.
12360
12361 debug=false
12362 ac_cs_recheck=false
12363 ac_cs_silent=false
12364 SHELL=\${CONFIG_SHELL-$SHELL}
12365 _ACEOF
12366
12367 cat >>$CONFIG_STATUS <<\_ACEOF
12368 ## --------------------- ##
12369 ## M4sh Initialization.  ##
12370 ## --------------------- ##
12371
12372 # Be Bourne compatible
12373 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12374   emulate sh
12375   NULLCMD=:
12376   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12377   # is contrary to our usage.  Disable this feature.
12378   alias -g '${1+"$@"}'='"$@"'
12379 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12380   set -o posix
12381 fi
12382 DUALCASE=1; export DUALCASE # for MKS sh
12383
12384 # Support unset when possible.
12385 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12386   as_unset=unset
12387 else
12388   as_unset=false
12389 fi
12390
12391
12392 # Work around bugs in pre-3.0 UWIN ksh.
12393 $as_unset ENV MAIL MAILPATH
12394 PS1='$ '
12395 PS2='> '
12396 PS4='+ '
12397
12398 # NLS nuisances.
12399 for as_var in \
12400   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12401   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12402   LC_TELEPHONE LC_TIME
12403 do
12404   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12405     eval $as_var=C; export $as_var
12406   else
12407     $as_unset $as_var
12408   fi
12409 done
12410
12411 # Required to use basename.
12412 if expr a : '\(a\)' >/dev/null 2>&1; then
12413   as_expr=expr
12414 else
12415   as_expr=false
12416 fi
12417
12418 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12419   as_basename=basename
12420 else
12421   as_basename=false
12422 fi
12423
12424
12425 # Name of the executable.
12426 as_me=`$as_basename "$0" ||
12427 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12428          X"$0" : 'X\(//\)$' \| \
12429          X"$0" : 'X\(/\)$' \| \
12430          .     : '\(.\)' 2>/dev/null ||
12431 echo X/"$0" |
12432     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12433           /^X\/\(\/\/\)$/{ s//\1/; q; }
12434           /^X\/\(\/\).*/{ s//\1/; q; }
12435           s/.*/./; q'`
12436
12437
12438 # PATH needs CR, and LINENO needs CR and PATH.
12439 # Avoid depending upon Character Ranges.
12440 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12441 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12442 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12443 as_cr_digits='0123456789'
12444 as_cr_alnum=$as_cr_Letters$as_cr_digits
12445
12446 # The user is always right.
12447 if test "${PATH_SEPARATOR+set}" != set; then
12448   echo "#! /bin/sh" >conf$$.sh
12449   echo  "exit 0"   >>conf$$.sh
12450   chmod +x conf$$.sh
12451   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12452     PATH_SEPARATOR=';'
12453   else
12454     PATH_SEPARATOR=:
12455   fi
12456   rm -f conf$$.sh
12457 fi
12458
12459
12460   as_lineno_1=$LINENO
12461   as_lineno_2=$LINENO
12462   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12463   test "x$as_lineno_1" != "x$as_lineno_2" &&
12464   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12465   # Find who we are.  Look in the path if we contain no path at all
12466   # relative or not.
12467   case $0 in
12468     *[\\/]* ) as_myself=$0 ;;
12469     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12470 for as_dir in $PATH
12471 do
12472   IFS=$as_save_IFS
12473   test -z "$as_dir" && as_dir=.
12474   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12475 done
12476
12477        ;;
12478   esac
12479   # We did not find ourselves, most probably we were run as `sh COMMAND'
12480   # in which case we are not to be found in the path.
12481   if test "x$as_myself" = x; then
12482     as_myself=$0
12483   fi
12484   if test ! -f "$as_myself"; then
12485     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12486 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12487    { (exit 1); exit 1; }; }
12488   fi
12489   case $CONFIG_SHELL in
12490   '')
12491     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12492 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12493 do
12494   IFS=$as_save_IFS
12495   test -z "$as_dir" && as_dir=.
12496   for as_base in sh bash ksh sh5; do
12497          case $as_dir in
12498          /*)
12499            if ("$as_dir/$as_base" -c '
12500   as_lineno_1=$LINENO
12501   as_lineno_2=$LINENO
12502   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12503   test "x$as_lineno_1" != "x$as_lineno_2" &&
12504   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12505              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12506              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12507              CONFIG_SHELL=$as_dir/$as_base
12508              export CONFIG_SHELL
12509              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12510            fi;;
12511          esac
12512        done
12513 done
12514 ;;
12515   esac
12516
12517   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12518   # uniformly replaced by the line number.  The first 'sed' inserts a
12519   # line-number line before each line; the second 'sed' does the real
12520   # work.  The second script uses 'N' to pair each line-number line
12521   # with the numbered line, and appends trailing '-' during
12522   # substitution so that $LINENO is not a special case at line end.
12523   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12524   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12525   sed '=' <$as_myself |
12526     sed '
12527       N
12528       s,$,-,
12529       : loop
12530       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12531       t loop
12532       s,-$,,
12533       s,^['$as_cr_digits']*\n,,
12534     ' >$as_me.lineno &&
12535   chmod +x $as_me.lineno ||
12536     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12537 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12538    { (exit 1); exit 1; }; }
12539
12540   # Don't try to exec as it changes $[0], causing all sort of problems
12541   # (the dirname of $[0] is not the place where we might find the
12542   # original and so on.  Autoconf is especially sensible to this).
12543   . ./$as_me.lineno
12544   # Exit status is that of the last command.
12545   exit
12546 }
12547
12548
12549 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12550   *c*,-n*) ECHO_N= ECHO_C='
12551 ' ECHO_T='      ' ;;
12552   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12553   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12554 esac
12555
12556 if expr a : '\(a\)' >/dev/null 2>&1; then
12557   as_expr=expr
12558 else
12559   as_expr=false
12560 fi
12561
12562 rm -f conf$$ conf$$.exe conf$$.file
12563 echo >conf$$.file
12564 if ln -s conf$$.file conf$$ 2>/dev/null; then
12565   # We could just check for DJGPP; but this test a) works b) is more generic
12566   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12567   if test -f conf$$.exe; then
12568     # Don't use ln at all; we don't have any links
12569     as_ln_s='cp -p'
12570   else
12571     as_ln_s='ln -s'
12572   fi
12573 elif ln conf$$.file conf$$ 2>/dev/null; then
12574   as_ln_s=ln
12575 else
12576   as_ln_s='cp -p'
12577 fi
12578 rm -f conf$$ conf$$.exe conf$$.file
12579
12580 if mkdir -p . 2>/dev/null; then
12581   as_mkdir_p=:
12582 else
12583   test -d ./-p && rmdir ./-p
12584   as_mkdir_p=false
12585 fi
12586
12587 as_executable_p="test -f"
12588
12589 # Sed expression to map a string onto a valid CPP name.
12590 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12591
12592 # Sed expression to map a string onto a valid variable name.
12593 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12594
12595
12596 # IFS
12597 # We need space, tab and new line, in precisely that order.
12598 as_nl='
12599 '
12600 IFS="   $as_nl"
12601
12602 # CDPATH.
12603 $as_unset CDPATH
12604
12605 exec 6>&1
12606
12607 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12608 # report actual input values of CONFIG_FILES etc. instead of their
12609 # values after options handling.  Logging --version etc. is OK.
12610 exec 5>>config.log
12611 {
12612   echo
12613   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12614 ## Running $as_me. ##
12615 _ASBOX
12616 } >&5
12617 cat >&5 <<_CSEOF
12618
12619 This file was extended by $as_me, which was
12620 generated by GNU Autoconf 2.59.  Invocation command line was
12621
12622   CONFIG_FILES    = $CONFIG_FILES
12623   CONFIG_HEADERS  = $CONFIG_HEADERS
12624   CONFIG_LINKS    = $CONFIG_LINKS
12625   CONFIG_COMMANDS = $CONFIG_COMMANDS
12626   $ $0 $@
12627
12628 _CSEOF
12629 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12630 echo >&5
12631 _ACEOF
12632
12633 # Files that config.status was made for.
12634 if test -n "$ac_config_files"; then
12635   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12636 fi
12637
12638 if test -n "$ac_config_headers"; then
12639   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12640 fi
12641
12642 if test -n "$ac_config_links"; then
12643   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12644 fi
12645
12646 if test -n "$ac_config_commands"; then
12647   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12648 fi
12649
12650 cat >>$CONFIG_STATUS <<\_ACEOF
12651
12652 ac_cs_usage="\
12653 \`$as_me' instantiates files from templates according to the
12654 current configuration.
12655
12656 Usage: $0 [OPTIONS] [FILE]...
12657
12658   -h, --help       print this help, then exit
12659   -V, --version    print version number, then exit
12660   -q, --quiet      do not print progress messages
12661   -d, --debug      don't remove temporary files
12662       --recheck    update $as_me by reconfiguring in the same conditions
12663   --file=FILE[:TEMPLATE]
12664                    instantiate the configuration file FILE
12665
12666 Configuration files:
12667 $config_files
12668
12669 Report bugs to <bug-autoconf@gnu.org>."
12670 _ACEOF
12671
12672 cat >>$CONFIG_STATUS <<_ACEOF
12673 ac_cs_version="\\
12674 config.status
12675 configured by $0, generated by GNU Autoconf 2.59,
12676   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12677
12678 Copyright (C) 2003 Free Software Foundation, Inc.
12679 This config.status script is free software; the Free Software Foundation
12680 gives unlimited permission to copy, distribute and modify it."
12681 srcdir=$srcdir
12682 INSTALL="$INSTALL"
12683 _ACEOF
12684
12685 cat >>$CONFIG_STATUS <<\_ACEOF
12686 # If no file are specified by the user, then we need to provide default
12687 # value.  By we need to know if files were specified by the user.
12688 ac_need_defaults=:
12689 while test $# != 0
12690 do
12691   case $1 in
12692   --*=*)
12693     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12694     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12695     ac_shift=:
12696     ;;
12697   -*)
12698     ac_option=$1
12699     ac_optarg=$2
12700     ac_shift=shift
12701     ;;
12702   *) # This is not an option, so the user has probably given explicit
12703      # arguments.
12704      ac_option=$1
12705      ac_need_defaults=false;;
12706   esac
12707
12708   case $ac_option in
12709   # Handling of the options.
12710 _ACEOF
12711 cat >>$CONFIG_STATUS <<\_ACEOF
12712   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12713     ac_cs_recheck=: ;;
12714   --version | --vers* | -V )
12715     echo "$ac_cs_version"; exit 0 ;;
12716   --he | --h)
12717     # Conflict between --help and --header
12718     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12719 Try \`$0 --help' for more information." >&5
12720 echo "$as_me: error: ambiguous option: $1
12721 Try \`$0 --help' for more information." >&2;}
12722    { (exit 1); exit 1; }; };;
12723   --help | --hel | -h )
12724     echo "$ac_cs_usage"; exit 0 ;;
12725   --debug | --d* | -d )
12726     debug=: ;;
12727   --file | --fil | --fi | --f )
12728     $ac_shift
12729     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12730     ac_need_defaults=false;;
12731   --header | --heade | --head | --hea )
12732     $ac_shift
12733     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12734     ac_need_defaults=false;;
12735   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12736   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12737     ac_cs_silent=: ;;
12738
12739   # This is an error.
12740   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12741 Try \`$0 --help' for more information." >&5
12742 echo "$as_me: error: unrecognized option: $1
12743 Try \`$0 --help' for more information." >&2;}
12744    { (exit 1); exit 1; }; } ;;
12745
12746   *) ac_config_targets="$ac_config_targets $1" ;;
12747
12748   esac
12749   shift
12750 done
12751
12752 ac_configure_extra_args=
12753
12754 if $ac_cs_silent; then
12755   exec 6>/dev/null
12756   ac_configure_extra_args="$ac_configure_extra_args --silent"
12757 fi
12758
12759 _ACEOF
12760 cat >>$CONFIG_STATUS <<_ACEOF
12761 if \$ac_cs_recheck; then
12762   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12763   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12764 fi
12765
12766 _ACEOF
12767
12768
12769
12770
12771
12772 cat >>$CONFIG_STATUS <<\_ACEOF
12773 for ac_config_target in $ac_config_targets
12774 do
12775   case "$ac_config_target" in
12776   # Handling of arguments.
12777   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12778   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12779 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12780    { (exit 1); exit 1; }; };;
12781   esac
12782 done
12783
12784 # If the user did not use the arguments to specify the items to instantiate,
12785 # then the envvar interface is used.  Set only those that are not.
12786 # We use the long form for the default assignment because of an extremely
12787 # bizarre bug on SunOS 4.1.3.
12788 if $ac_need_defaults; then
12789   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12790 fi
12791
12792 # Have a temporary directory for convenience.  Make it in the build tree
12793 # simply because there is no reason to put it here, and in addition,
12794 # creating and moving files from /tmp can sometimes cause problems.
12795 # Create a temporary directory, and hook for its removal unless debugging.
12796 $debug ||
12797 {
12798   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12799   trap '{ (exit 1); exit 1; }' 1 2 13 15
12800 }
12801
12802 # Create a (secure) tmp directory for tmp files.
12803
12804 {
12805   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12806   test -n "$tmp" && test -d "$tmp"
12807 }  ||
12808 {
12809   tmp=./confstat$$-$RANDOM
12810   (umask 077 && mkdir $tmp)
12811 } ||
12812 {
12813    echo "$me: cannot create a temporary directory in ." >&2
12814    { (exit 1); exit 1; }
12815 }
12816
12817 _ACEOF
12818
12819 cat >>$CONFIG_STATUS <<_ACEOF
12820
12821 #
12822 # CONFIG_FILES section.
12823 #
12824
12825 # No need to generate the scripts if there are no CONFIG_FILES.
12826 # This happens for instance when ./config.status config.h
12827 if test -n "\$CONFIG_FILES"; then
12828   # Protect against being on the right side of a sed subst in config.status.
12829   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12830    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12831 s,@SHELL@,$SHELL,;t t
12832 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12833 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12834 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12835 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12836 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12837 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12838 s,@exec_prefix@,$exec_prefix,;t t
12839 s,@prefix@,$prefix,;t t
12840 s,@program_transform_name@,$program_transform_name,;t t
12841 s,@bindir@,$bindir,;t t
12842 s,@sbindir@,$sbindir,;t t
12843 s,@libexecdir@,$libexecdir,;t t
12844 s,@datadir@,$datadir,;t t
12845 s,@sysconfdir@,$sysconfdir,;t t
12846 s,@sharedstatedir@,$sharedstatedir,;t t
12847 s,@localstatedir@,$localstatedir,;t t
12848 s,@libdir@,$libdir,;t t
12849 s,@includedir@,$includedir,;t t
12850 s,@oldincludedir@,$oldincludedir,;t t
12851 s,@infodir@,$infodir,;t t
12852 s,@mandir@,$mandir,;t t
12853 s,@build_alias@,$build_alias,;t t
12854 s,@host_alias@,$host_alias,;t t
12855 s,@target_alias@,$target_alias,;t t
12856 s,@DEFS@,$DEFS,;t t
12857 s,@ECHO_C@,$ECHO_C,;t t
12858 s,@ECHO_N@,$ECHO_N,;t t
12859 s,@ECHO_T@,$ECHO_T,;t t
12860 s,@LIBS@,$LIBS,;t t
12861 s,@build@,$build,;t t
12862 s,@build_cpu@,$build_cpu,;t t
12863 s,@build_vendor@,$build_vendor,;t t
12864 s,@build_os@,$build_os,;t t
12865 s,@build_noncanonical@,$build_noncanonical,;t t
12866 s,@host_noncanonical@,$host_noncanonical,;t t
12867 s,@target_noncanonical@,$target_noncanonical,;t t
12868 s,@host@,$host,;t t
12869 s,@host_cpu@,$host_cpu,;t t
12870 s,@host_vendor@,$host_vendor,;t t
12871 s,@host_os@,$host_os,;t t
12872 s,@target@,$target,;t t
12873 s,@target_cpu@,$target_cpu,;t t
12874 s,@target_vendor@,$target_vendor,;t t
12875 s,@target_os@,$target_os,;t t
12876 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12877 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12878 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12879 s,@LN@,$LN,;t t
12880 s,@LN_S@,$LN_S,;t t
12881 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12882 s,@build_libsubdir@,$build_libsubdir,;t t
12883 s,@build_subdir@,$build_subdir,;t t
12884 s,@host_subdir@,$host_subdir,;t t
12885 s,@target_subdir@,$target_subdir,;t t
12886 s,@CC@,$CC,;t t
12887 s,@CFLAGS@,$CFLAGS,;t t
12888 s,@LDFLAGS@,$LDFLAGS,;t t
12889 s,@CPPFLAGS@,$CPPFLAGS,;t t
12890 s,@ac_ct_CC@,$ac_ct_CC,;t t
12891 s,@EXEEXT@,$EXEEXT,;t t
12892 s,@OBJEXT@,$OBJEXT,;t t
12893 s,@CXX@,$CXX,;t t
12894 s,@CXXFLAGS@,$CXXFLAGS,;t t
12895 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12896 s,@GNATBIND@,$GNATBIND,;t t
12897 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12898 s,@GNATMAKE@,$GNATMAKE,;t t
12899 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12900 s,@do_compare@,$do_compare,;t t
12901 s,@gmplibs@,$gmplibs,;t t
12902 s,@gmpinc@,$gmpinc,;t t
12903 s,@stage1_languages@,$stage1_languages,;t t
12904 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12905 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12906 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
12907 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
12908 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12909 s,@tooldir@,$tooldir,;t t
12910 s,@build_tooldir@,$build_tooldir,;t t
12911 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12912 s,@GDB_TK@,$GDB_TK,;t t
12913 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12914 s,@build_configargs@,$build_configargs,;t t
12915 s,@build_configdirs@,$build_configdirs,;t t
12916 s,@host_configargs@,$host_configargs,;t t
12917 s,@configdirs@,$configdirs,;t t
12918 s,@target_configargs@,$target_configargs,;t t
12919 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
12920 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
12921 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12922 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12923 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
12924 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
12925 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
12926 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
12927 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
12928 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
12929 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
12930 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
12931 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
12932 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
12933 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
12934 s,@config_shell@,$config_shell,;t t
12935 s,@YACC@,$YACC,;t t
12936 s,@BISON@,$BISON,;t t
12937 s,@M4@,$M4,;t t
12938 s,@LEX@,$LEX,;t t
12939 s,@FLEX@,$FLEX,;t t
12940 s,@MAKEINFO@,$MAKEINFO,;t t
12941 s,@EXPECT@,$EXPECT,;t t
12942 s,@RUNTEST@,$RUNTEST,;t t
12943 s,@AR@,$AR,;t t
12944 s,@AS@,$AS,;t t
12945 s,@DLLTOOL@,$DLLTOOL,;t t
12946 s,@LD@,$LD,;t t
12947 s,@LIPO@,$LIPO,;t t
12948 s,@NM@,$NM,;t t
12949 s,@RANLIB@,$RANLIB,;t t
12950 s,@STRIP@,$STRIP,;t t
12951 s,@WINDRES@,$WINDRES,;t t
12952 s,@WINDMC@,$WINDMC,;t t
12953 s,@OBJCOPY@,$OBJCOPY,;t t
12954 s,@OBJDUMP@,$OBJDUMP,;t t
12955 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12956 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12957 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12958 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12959 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12960 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12961 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12962 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12963 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12964 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12965 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12966 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12967 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12968 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12969 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12970 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
12971 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12972 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12973 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12974 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12975 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12976 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12977 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12978 s,@MAINT@,$MAINT,;t t
12979 s,@stage1_cflags@,$stage1_cflags,;t t
12980 s,@stage1_checking@,$stage1_checking,;t t
12981 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12982 s,@datarootdir@,$datarootdir,;t t
12983 s,@docdir@,$docdir,;t t
12984 s,@pdfdir@,$pdfdir,;t t
12985 s,@htmldir@,$htmldir,;t t
12986 s,@LIBOBJS@,$LIBOBJS,;t t
12987 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12988 /@serialization_dependencies@/r $serialization_dependencies
12989 s,@serialization_dependencies@,,;t t
12990 /@host_makefile_frag@/r $host_makefile_frag
12991 s,@host_makefile_frag@,,;t t
12992 /@target_makefile_frag@/r $target_makefile_frag
12993 s,@target_makefile_frag@,,;t t
12994 /@alphaieee_frag@/r $alphaieee_frag
12995 s,@alphaieee_frag@,,;t t
12996 /@ospace_frag@/r $ospace_frag
12997 s,@ospace_frag@,,;t t
12998 CEOF
12999
13000 _ACEOF
13001
13002   cat >>$CONFIG_STATUS <<\_ACEOF
13003   # Split the substitutions into bite-sized pieces for seds with
13004   # small command number limits, like on Digital OSF/1 and HP-UX.
13005   ac_max_sed_lines=48
13006   ac_sed_frag=1 # Number of current file.
13007   ac_beg=1 # First line for current file.
13008   ac_end=$ac_max_sed_lines # Line after last line for current file.
13009   ac_more_lines=:
13010   ac_sed_cmds=
13011   while $ac_more_lines; do
13012     if test $ac_beg -gt 1; then
13013       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13014     else
13015       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13016     fi
13017     if test ! -s $tmp/subs.frag; then
13018       ac_more_lines=false
13019     else
13020       # The purpose of the label and of the branching condition is to
13021       # speed up the sed processing (if there are no `@' at all, there
13022       # is no need to browse any of the substitutions).
13023       # These are the two extra sed commands mentioned above.
13024       (echo ':t
13025   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13026       if test -z "$ac_sed_cmds"; then
13027         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13028       else
13029         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13030       fi
13031       ac_sed_frag=`expr $ac_sed_frag + 1`
13032       ac_beg=$ac_end
13033       ac_end=`expr $ac_end + $ac_max_sed_lines`
13034     fi
13035   done
13036   if test -z "$ac_sed_cmds"; then
13037     ac_sed_cmds=cat
13038   fi
13039 fi # test -n "$CONFIG_FILES"
13040
13041 _ACEOF
13042 cat >>$CONFIG_STATUS <<\_ACEOF
13043 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13044   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13045   case $ac_file in
13046   - | *:- | *:-:* ) # input from stdin
13047         cat >$tmp/stdin
13048         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13049         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13050   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13051         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13052   * )   ac_file_in=$ac_file.in ;;
13053   esac
13054
13055   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13056   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13057 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13058          X"$ac_file" : 'X\(//\)[^/]' \| \
13059          X"$ac_file" : 'X\(//\)$' \| \
13060          X"$ac_file" : 'X\(/\)' \| \
13061          .     : '\(.\)' 2>/dev/null ||
13062 echo X"$ac_file" |
13063     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13064           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13065           /^X\(\/\/\)$/{ s//\1/; q; }
13066           /^X\(\/\).*/{ s//\1/; q; }
13067           s/.*/./; q'`
13068   { if $as_mkdir_p; then
13069     mkdir -p "$ac_dir"
13070   else
13071     as_dir="$ac_dir"
13072     as_dirs=
13073     while test ! -d "$as_dir"; do
13074       as_dirs="$as_dir $as_dirs"
13075       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13076 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13077          X"$as_dir" : 'X\(//\)[^/]' \| \
13078          X"$as_dir" : 'X\(//\)$' \| \
13079          X"$as_dir" : 'X\(/\)' \| \
13080          .     : '\(.\)' 2>/dev/null ||
13081 echo X"$as_dir" |
13082     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13083           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13084           /^X\(\/\/\)$/{ s//\1/; q; }
13085           /^X\(\/\).*/{ s//\1/; q; }
13086           s/.*/./; q'`
13087     done
13088     test ! -n "$as_dirs" || mkdir $as_dirs
13089   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13090 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13091    { (exit 1); exit 1; }; }; }
13092
13093   ac_builddir=.
13094
13095 if test "$ac_dir" != .; then
13096   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13097   # A "../" for each directory in $ac_dir_suffix.
13098   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13099 else
13100   ac_dir_suffix= ac_top_builddir=
13101 fi
13102
13103 case $srcdir in
13104   .)  # No --srcdir option.  We are building in place.
13105     ac_srcdir=.
13106     if test -z "$ac_top_builddir"; then
13107        ac_top_srcdir=.
13108     else
13109        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13110     fi ;;
13111   [\\/]* | ?:[\\/]* )  # Absolute path.
13112     ac_srcdir=$srcdir$ac_dir_suffix;
13113     ac_top_srcdir=$srcdir ;;
13114   *) # Relative path.
13115     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13116     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13117 esac
13118
13119 # Do not use `cd foo && pwd` to compute absolute paths, because
13120 # the directories may not exist.
13121 case `pwd` in
13122 .) ac_abs_builddir="$ac_dir";;
13123 *)
13124   case "$ac_dir" in
13125   .) ac_abs_builddir=`pwd`;;
13126   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13127   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13128   esac;;
13129 esac
13130 case $ac_abs_builddir in
13131 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13132 *)
13133   case ${ac_top_builddir}. in
13134   .) ac_abs_top_builddir=$ac_abs_builddir;;
13135   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13136   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13137   esac;;
13138 esac
13139 case $ac_abs_builddir in
13140 .) ac_abs_srcdir=$ac_srcdir;;
13141 *)
13142   case $ac_srcdir in
13143   .) ac_abs_srcdir=$ac_abs_builddir;;
13144   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13145   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13146   esac;;
13147 esac
13148 case $ac_abs_builddir in
13149 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13150 *)
13151   case $ac_top_srcdir in
13152   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13153   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13154   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13155   esac;;
13156 esac
13157
13158
13159   case $INSTALL in
13160   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13161   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13162   esac
13163
13164   if test x"$ac_file" != x-; then
13165     { echo "$as_me:$LINENO: creating $ac_file" >&5
13166 echo "$as_me: creating $ac_file" >&6;}
13167     rm -f "$ac_file"
13168   fi
13169   # Let's still pretend it is `configure' which instantiates (i.e., don't
13170   # use $as_me), people would be surprised to read:
13171   #    /* config.h.  Generated by config.status.  */
13172   if test x"$ac_file" = x-; then
13173     configure_input=
13174   else
13175     configure_input="$ac_file.  "
13176   fi
13177   configure_input=$configure_input"Generated from `echo $ac_file_in |
13178                                      sed 's,.*/,,'` by configure."
13179
13180   # First look for the input files in the build tree, otherwise in the
13181   # src tree.
13182   ac_file_inputs=`IFS=:
13183     for f in $ac_file_in; do
13184       case $f in
13185       -) echo $tmp/stdin ;;
13186       [\\/$]*)
13187          # Absolute (can't be DOS-style, as IFS=:)
13188          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13189 echo "$as_me: error: cannot find input file: $f" >&2;}
13190    { (exit 1); exit 1; }; }
13191          echo "$f";;
13192       *) # Relative
13193          if test -f "$f"; then
13194            # Build tree
13195            echo "$f"
13196          elif test -f "$srcdir/$f"; then
13197            # Source tree
13198            echo "$srcdir/$f"
13199          else
13200            # /dev/null tree
13201            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13202 echo "$as_me: error: cannot find input file: $f" >&2;}
13203    { (exit 1); exit 1; }; }
13204          fi;;
13205       esac
13206     done` || { (exit 1); exit 1; }
13207 _ACEOF
13208 cat >>$CONFIG_STATUS <<_ACEOF
13209   sed "$ac_vpsub
13210 $extrasub
13211 _ACEOF
13212 cat >>$CONFIG_STATUS <<\_ACEOF
13213 :t
13214 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13215 s,@configure_input@,$configure_input,;t t
13216 s,@srcdir@,$ac_srcdir,;t t
13217 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13218 s,@top_srcdir@,$ac_top_srcdir,;t t
13219 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13220 s,@builddir@,$ac_builddir,;t t
13221 s,@abs_builddir@,$ac_abs_builddir,;t t
13222 s,@top_builddir@,$ac_top_builddir,;t t
13223 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13224 s,@INSTALL@,$ac_INSTALL,;t t
13225 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13226   rm -f $tmp/stdin
13227   if test x"$ac_file" != x-; then
13228     mv $tmp/out $ac_file
13229   else
13230     cat $tmp/out
13231     rm -f $tmp/out
13232   fi
13233
13234 done
13235 _ACEOF
13236
13237 cat >>$CONFIG_STATUS <<\_ACEOF
13238
13239 { (exit 0); exit 0; }
13240 _ACEOF
13241 chmod +x $CONFIG_STATUS
13242 ac_clean_files=$ac_clean_files_save
13243
13244
13245 # configure is writing to config.log, and then calls config.status.
13246 # config.status does its own redirection, appending to config.log.
13247 # Unfortunately, on DOS this fails, as config.log is still kept open
13248 # by configure, so config.status won't be able to write to it; its
13249 # output is simply discarded.  So we exec the FD to /dev/null,
13250 # effectively closing config.log, so it can be properly (re)opened and
13251 # appended to by config.status.  When coming back to configure, we
13252 # need to make the FD available again.
13253 if test "$no_create" != yes; then
13254   ac_cs_success=:
13255   ac_config_status_args=
13256   test "$silent" = yes &&
13257     ac_config_status_args="$ac_config_status_args --quiet"
13258   exec 5>/dev/null
13259   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13260   exec 5>>config.log
13261   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13262   # would make configure fail if this is the last instruction.
13263   $ac_cs_success || { (exit 1); exit 1; }
13264 fi
13265